Return to monop.c CVS log

Up to [CSRG BSD Unix] / 43BSD / games / monop

Annotation of 43BSD/games/monop/monop.c, revision 1.1

1.1     ! root        1: # include      "monop.def"
        !             2: 
        !             3: /*
        !             4:  *     This program implements a monopoly game
        !             5:  */
        !             6: main(ac, av)
        !             7: reg int                ac;
        !             8: reg char       *av[]; {
        !             9: 
        !            10: 
        !            11:        srand(getpid());
        !            12:        if (ac > 1) {
        !            13:                if (!rest_f(av[1]))
        !            14:                        restore();
        !            15:        }
        !            16:        else {
        !            17:                getplayers();
        !            18:                init_players();
        !            19:                init_monops();
        !            20:        }
        !            21:        num_luck = sizeof lucky_mes / sizeof (char *);
        !            22:        init_decks();
        !            23:        signal(2, quit);
        !            24:        for (;;) {
        !            25:                printf("\n%s (%d) (cash $%d) on %s\n", cur_p->name, player + 1,
        !            26:                        cur_p->money, board[cur_p->loc].name);
        !            27:                printturn();
        !            28:                force_morg();
        !            29:                execute(getinp("-- Command: ", comlist));
        !            30:        }
        !            31: }
        !            32: /*
        !            33:  *     This routine gets the names of the players
        !            34:  */
        !            35: getplayers() {
        !            36: 
        !            37:        reg char        *sp;
        !            38:        reg int         i, j;
        !            39:        char            buf[257];
        !            40: 
        !            41: blew_it:
        !            42:        for (;;) {
        !            43:                if ((num_play=get_int("How many players? ")) <= 0 ||
        !            44:                    num_play > MAX_PL)
        !            45:                        printf("Sorry. Number must range from 1 to 9\n");
        !            46:                else
        !            47:                        break;
        !            48:        }
        !            49:        cur_p = play = (PLAY *) calloc(num_play, sizeof (PLAY));
        !            50:        for (i = 0; i < num_play; i++) {
        !            51: over:
        !            52:                printf("Player %d's name: ", i + 1);
        !            53:                for (sp = buf; (*sp=getchar()) != '\n'; sp++)
        !            54:                        continue;
        !            55:                if (sp == buf)
        !            56:                        goto over;
        !            57:                *sp++ = '\0';
        !            58:                strcpy(name_list[i]=play[i].name=(char *)calloc(1,sp-buf),buf);
        !            59:                play[i].money = 1500;
        !            60:        }
        !            61:        name_list[i++] = "done";
        !            62:        name_list[i] = 0;
        !            63:        for (i = 0; i < num_play; i++)
        !            64:                for (j = i + 1; j < num_play; j++)
        !            65:                        if (strcmp(name_list[i], name_list[j]) == 0) {
        !            66:                                if (i != num_play - 1)
        !            67:                                        printf("Hey!!! Some of those are IDENTICAL!!  Let's try that again....\n");
        !            68:                                else
        !            69:                                        printf("\"done\" is a reserved word.  Please try again\n");
        !            70:                                for (i = 0; i < num_play; i++)
        !            71:                                        cfree(play[i].name);
        !            72:                                cfree(play);
        !            73:                                goto blew_it;
        !            74:                        }
        !            75: }
        !            76: /*
        !            77:  *     This routine figures out who goes first
        !            78:  */
        !            79: init_players() {
        !            80: 
        !            81:        reg int i, rl, cur_max;
        !            82:        bool    over;
        !            83:        int     max_pl;
        !            84: 
        !            85: again:
        !            86:        putchar('\n');
        !            87:        for (cur_max = i = 0; i < num_play; i++) {
        !            88:                printf("%s (%d) rolls %d\n", play[i].name, i+1, rl=roll(2, 6));
        !            89:                if (rl > cur_max) {
        !            90:                        over = FALSE;
        !            91:                        cur_max = rl;
        !            92:                        max_pl = i;
        !            93:                }
        !            94:                else if (rl == cur_max)
        !            95:                        over++;
        !            96:        }
        !            97:        if (over) {
        !            98:                printf("%d people rolled the same thing, so we'll try again\n",
        !            99:                    over + 1);
        !           100:                goto again;
        !           101:        }
        !           102:        player = max_pl;
        !           103:        cur_p = &play[max_pl];
        !           104:        printf("%s (%d) goes first\n", cur_p->name, max_pl + 1);
        !           105: }
        !           106: /*
        !           107:  *     This routine initalizes the monopoly structures.
        !           108:  */
        !           109: init_monops() {
        !           110: 
        !           111:        reg MON *mp;
        !           112:        reg int i;
        !           113: 
        !           114:        for (mp = mon; mp < &mon[N_MON]; mp++) {
        !           115:                mp->name = mp->not_m;
        !           116:                for (i = 0; i < mp->num_in; i++)
        !           117:                        mp->sq[i] = &board[(int)(mp->sq[i])];
        !           118:        }
        !           119: }

This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.