Return to mille.c CVS log

Up to [CSRG BSD Unix] / 42BSD / games / mille

Annotation of 42BSD/games/mille/mille.c, revision 1.1

1.1     ! root        1: # include      "mille.h"
        !             2: # include      <signal.h>
        !             3: # ifdef attron
        !             4: #      include <term.h>
        !             5: # endif        attron
        !             6: 
        !             7: /*
        !             8:  * @(#)mille.c 1.3 (Berkeley) 5/10/83
        !             9:  */
        !            10: 
        !            11: int    rub();
        !            12: 
        !            13: char   _sobuf[BUFSIZ];
        !            14: 
        !            15: main(ac, av)
        !            16: reg int                ac;
        !            17: reg char       *av[]; {
        !            18: 
        !            19:        reg bool        restore;
        !            20:        double          avs[3];
        !            21: 
        !            22:        if (strcmp(av[0], "a.out") == 0) {
        !            23:                outf = fopen("q", "w");
        !            24:                setbuf(outf, 0);
        !            25:                Debug = TRUE;
        !            26:        }
        !            27:        restore = FALSE;
        !            28: # ifdef pdp11
        !            29:        if (geteuid() != ARNOLD) {
        !            30:                loadav(avs);
        !            31:                if (avs[2] > 9.0) {
        !            32:                        printf("Sorry.  The load average is too high.\n");
        !            33:                        printf("Please try again later\n");
        !            34:                        exit(1);
        !            35:                }
        !            36:        }
        !            37: # endif
        !            38:        switch (ac) {
        !            39:          case 2:
        !            40:                rest_f(av[1]);
        !            41:                restore = TRUE;
        !            42:          case 1:
        !            43:                break;
        !            44:          default:
        !            45:                printf("usage: milles [ restore_file ]\n");
        !            46:                exit(-1);
        !            47:                /* NOTREACHED */
        !            48:        }
        !            49:        setbuf(stdout, _sobuf);
        !            50:        Play = PLAYER;
        !            51:        initscr();
        !            52: # ifdef attron
        !            53: #      define  CA      cursor_address
        !            54: # endif
        !            55:        if (!CA) {
        !            56:                printf("Sorry.  Need cursor addressing to play mille\n");
        !            57:                exit(-1);
        !            58:        }
        !            59:        delwin(stdscr);
        !            60:        stdscr = Board = newwin(BOARD_Y, BOARD_X, 0, 0);
        !            61:        Score = newwin(SCORE_Y, SCORE_X, 0, 40);
        !            62:        Miles = newwin(MILES_Y, MILES_X, 17, 0);
        !            63: #ifdef attron
        !            64:        idlok(Board, TRUE);
        !            65:        idlok(Score, TRUE);
        !            66:        idlok(Miles, TRUE);
        !            67: #endif
        !            68:        leaveok(Score, TRUE);
        !            69:        leaveok(Miles, TRUE);
        !            70:        clearok(curscr, TRUE);
        !            71: # ifndef PROF
        !            72:        srand(getpid());
        !            73: # else
        !            74:        srand(0);
        !            75: # endif
        !            76:        crmode();
        !            77:        noecho();
        !            78:        signal(SIGINT, rub);
        !            79:        for (;;) {
        !            80:                if (!restore || (Player[PLAYER].total >= 5000
        !            81:                    || Player[COMP].total >= 5000)) {
        !            82:                        if (Player[COMP].total < Player[PLAYER].total)
        !            83:                                Player[PLAYER].games++;
        !            84:                        else if (Player[COMP].total > Player[PLAYER].total)
        !            85:                                Player[COMP].games++;
        !            86:                        Player[COMP].total = 0;
        !            87:                        Player[PLAYER].total = 0;
        !            88:                }
        !            89:                do {
        !            90:                        if (!restore)
        !            91:                                Handstart = Play = other(Handstart);
        !            92:                        if (!restore || On_exit) {
        !            93:                                shuffle();
        !            94:                                init();
        !            95:                        }
        !            96:                        newboard();
        !            97:                        if (restore)
        !            98:                                mvwaddstr(Score, ERR_Y, ERR_X, Initstr);
        !            99:                        prboard();
        !           100:                        do {
        !           101:                                domove();
        !           102:                                if (Finished)
        !           103:                                        newscore();
        !           104:                                prboard();
        !           105:                        } while (!Finished);
        !           106:                        check_more();
        !           107:                        restore = On_exit = FALSE;
        !           108:                } while (Player[COMP].total < 5000
        !           109:                    && Player[PLAYER].total < 5000);
        !           110:        }
        !           111: }
        !           112: 
        !           113: /*
        !           114:  *     Routine to trap rubouts, and make sure they really want to
        !           115:  * quit.
        !           116:  */
        !           117: rub() {
        !           118: 
        !           119:        signal(SIGINT, 1);
        !           120:        if (getyn("Really? "))
        !           121:                die();
        !           122:        signal(SIGINT, rub);
        !           123: }
        !           124: 
        !           125: /*
        !           126:  *     Time to go beddy-by
        !           127:  */
        !           128: die() {
        !           129: 
        !           130:        signal(SIGINT, 1);
        !           131:        if (outf)
        !           132:                fflush(outf);
        !           133:        mvcur(0, COLS - 1, LINES - 1, 0);
        !           134:        endwin();
        !           135:        exit(1);
        !           136: }

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