Return to warp.c CVS log

Up to [CSRG BSD Unix] / 43BSDReno / games / warp

Annotation of 43BSDReno/games/warp/warp.c, revision 1.1

1.1     ! root        1: char rcsid[] = "@(#)$Header: warp.c,v 7.0.1.3 86/12/12 17:07:44 lwall Exp $";
        !             2: 
        !             3: /*     warp -- a real-time space war program
        !             4:  *     author: Larry Wall
        !             5:  *     helpers: Jonathan and Mark Biggar, and Dan Faigin
        !             6:  *     special thanks to my sweetie Gloria who suggested the Planet Crusher
        !             7:  *
        !             8:  *     Copyright (C) 1986, Larry Wall
        !             9:  *
        !            10:  *     This program may be copied as long as this copyright notice is
        !            11:  *     included, and as long as it is not being copied for purposes
        !            12:  *     of profit.  If you want to modify this program in any way other
        !            13:  *     than normal configuration changes, common decency would suggest
        !            14:  *     that you also modify the name of the program so that my good name
        !            15:  *     (what there is of it) is not impugned.  (Calling it something like
        !            16:  *     "warpx" or "superwarp" would be fine.)  Also, give it another
        !            17:  *     WARPDIR so that the scoreboards don't get confused.
        !            18:  *
        !            19:  * version 5.0  04/20/83
        !            20:  *         5.1  05/05/83       various tidbits
        !            21:  *        5.2  05/12/83        VAX -> vax, ifdef'ed a SIGCONT
        !            22:  *        5.3  05/24/83        RCS
        !            23:  *
        !            24:  * $Log:       warp.c,v $
        !            25:  * Revision 7.0.1.3  86/12/12  17:07:44  lwall
        !            26:  * Baseline for net release.
        !            27:  * 
        !            28:  * Revision 7.0.1.2  86/10/20  12:08:00  lwall
        !            29:  * Made all exits reset tty.
        !            30:  * 
        !            31:  * Revision 7.0.1.1  86/10/16  10:54:13  lwall
        !            32:  * Added Damage.  Fixed random bugs.
        !            33:  * 
        !            34:  * Revision 7.0  86/10/08  15:14:47  lwall
        !            35:  * Split into separate files.  Added amoebas and pirates.
        !            36:  * 
        !            37:  * Revision 6.4  83/12/16  13:11:45  lwall
        !            38:  * Handled 15 bit random number generators.
        !            39:  * 
        !            40:  * Fixed array overflow bug on multiple zaps.
        !            41:  * 
        !            42:  * Multiple zaps now consolidated to minimize output.
        !            43:  * 
        !            44:  * Tholian jackpot games outlawed under difficulty 15.
        !            45:  * 
        !            46:  * Revision 6.3  83/08/24  11:17:49  lwall
        !            47:  * Fixed array overflow bug on multiple zap.
        !            48:  * 
        !            49:  * Revision 6.2  83/08/23  18:06:37  lwall
        !            50:  * Added zap command.
        !            51:  * Warp -s should now work on dumb terminals
        !            52:  * Specifying difficulty >= 40 now just makes it a special game.
        !            53:  * SIGTTOU #ifdef'ed.
        !            54:  * No-delay read provided as alternative to FIONREAD.
        !            55:  * Warp won't report "-1 obsolete" when there are no Enterprises left.
        !            56:  * Some high-difficulty tuning.
        !            57:  * 
        !            58:  * Revision 6.1  83/08/17  08:49:03  lwall
        !            59:  * Fixed obscure bug in storing UP that caused a %. in CM to occasionally
        !            60:  * foist garbage onto the screen.
        !            61:  * 
        !            62:  * Revision 6.0  83/08/08  17:09:26  lwall
        !            63:  * New baseline version for net release.
        !            64:  * 
        !            65:  * Revision 5.5  83/08/01  10:59:56  lwall
        !            66:  * Cloaking for the Enterprise.
        !            67:  * Difficulty now goes to 99, and many activities depending on difficulty
        !            68:  *     have been adjusted in frequency.
        !            69:  * Simplified exit sequence, and reduced dependencies on control
        !            70:  *     characters.  You needn't see the scoreboard if you don't want to.
        !            71:  * Hitting i,w,c, or v switches to Enterprise.  Hitting p switches to Base.
        !            72:  * Excessive use of q is not allowed.
        !            73:  * Excessive use of D is not allowed.
        !            74:  * Scoreboard may depend on either full name or login name.
        !            75:  * Integrated scoreboard lister.  Login name now shows up on scoreboard.
        !            76:  * "Hidden" startup options are now upper case.
        !            77:  * Checks upon startup for no cursor movement, or screen too small.
        !            78:  * Checks upon startup that WARPDIR is correctly protected, and that warp
        !            79:  *     is running setuid.  As an additional bonus this prevents root from
        !            80:  *     running warp, which mucks things up, UN*X be blessed.
        !            81:  * All gets's turned into fgets's for safety.
        !            82:  * Bonus Enterprises and Bases.
        !            83:  * Escalating bonuses for saving Base and Enterprise.
        !            84:  * Escalating Enterprise energy.
        !            85:  * Turbolasers decrease with distance.
        !            86:  * Really smart enemies can see through stars occasionally.
        !            87:  * Occasional Tholian jackpot waves.  Tholians are a trifle nastier.
        !            88:  * Choleric Gorns.
        !            89:  * An O or o can miss seeing you.  Enemies can avoid a stationary O, o, or X.
        !            90:  * Warp 3 enemies and other nastinesses are possible in massacre mode.
        !            91:  * Enemies that decide to navigate when they see you can do other things than
        !            92:  *     just come toward you.
        !            93:  * Gorns occasionally launch a salvo for the fun of it.
        !            94:  * Only star and enemy explosions can keep the round going now.
        !            95:  * Bounces don't always go back to starting spot now.
        !            96:  * Better full name processing.  USG quirks handled.  & substitution also
        !            97:  *     handled now (whoever dreamed up that one must have been in the middle
        !            98:  *     of the night before the morning after).
        !            99:  * Catch ^D on fgets.
        !           100:  * Version number printer.
        !           101:  * Less signal catching during debugging.
        !           102:  * 
        !           103:  * Revision 5.4  83/06/24  09:28:38  lwall
        !           104:  * 16 bit random number generators are now supported.
        !           105:  * Made warp not blow up on a null save file.
        !           106:  * Warp now prints E and B before the stars.
        !           107:  * Fixed bug which caused torp count to get decremented even when no torp
        !           108:  *     was launched because of an obstacle.
        !           109:  * Put %<n>ld formats where appropriate.
        !           110:  * Fixed E: 0  0 bug on refresh.
        !           111:  * 
        !           112:  * Revision 5.3  83/05/24  14:03:10  lwall
        !           113:  * Starting RCS
        !           114:  * 
        !           115:  */
        !           116: 
        !           117: #include "INTERN.h"
        !           118: #include "warp.h"
        !           119: #include "EXTERN.h"
        !           120: #include "bang.h"
        !           121: #include "init.h"
        !           122: #include "intrp.h"
        !           123: #include "object.h"
        !           124: #include "move.h"
        !           125: #include "play.h"
        !           126: #include "score.h"
        !           127: #include "sig.h"
        !           128: #include "term.h"
        !           129: #include "them.h"
        !           130: #include "us.h"
        !           131: #include "util.h"
        !           132: #include "version.h"
        !           133: #include "weapon.h"
        !           134: 
        !           135: main(argc,argv)
        !           136: int argc;
        !           137: char *argv[];
        !           138: {
        !           139:     char tmp, *s, *tcbuf;
        !           140: 
        !           141:     int i;
        !           142: 
        !           143:     FILE *savfil;
        !           144: 
        !           145: #if RANDBITS > 16
        !           146:     for (i=100; i; i--)
        !           147:        if (rand() >= 65536)
        !           148:            goto rand_ok;
        !           149:     printf("Recompile with RANDBITS = 15 or 16.\n");
        !           150:     exit(1);
        !           151: #else
        !           152: #if RANDBITS > 15
        !           153:     for (i=100; i; i--) {
        !           154:        if (rand() >= 32768)
        !           155:            goto rand_ok;
        !           156:     }
        !           157:     printf("Recompile with RANDBITS = 15.\n");
        !           158:     exit(1);
        !           159: #endif
        !           160: #endif
        !           161: rand_ok:
        !           162: 
        !           163: #ifdef lint  /* to suppress "defined but never used" */
        !           164: # ifdef SIGTSTP
        !           165:     (void)stop_catcher();
        !           166: # endif
        !           167: # ifdef SIGCONT
        !           168:     (void)cont_catcher();
        !           169: # endif
        !           170: #endif
        !           171: 
        !           172:     while (--argc > 0 && (*++argv)[0] == '-')
        !           173:        for (s = argv[0]+1; *s != '\0'; s++)
        !           174:            switch (*s) {
        !           175:            case '&':
        !           176:                amoebaspec = TRUE;
        !           177:                beginner = TRUE;
        !           178:                break;
        !           179:            case 'A':
        !           180:                apolspec = TRUE;
        !           181:                beginner = TRUE;
        !           182:                break;
        !           183:            case 'b':
        !           184:                beginner = TRUE;
        !           185:                break;
        !           186:            case 'C':
        !           187:                crushspec = TRUE;
        !           188:                beginner = TRUE;
        !           189:                break;
        !           190:            case 'D':
        !           191:                debugging = TRUE;
        !           192: #ifdef DEBUGGING
        !           193:                debug = atoi(++s);
        !           194: #endif
        !           195:                s += strlen(s)-1;
        !           196:                break;
        !           197:            case 'd':
        !           198:                s++;
        !           199:                if (*s == '=') s++;
        !           200:                ismarts = atoi(s);
        !           201:                if (ismarts <= 0)
        !           202:                    ismarts = 1;
        !           203:                if (ismarts > 99)
        !           204:                    ismarts = 99;
        !           205:                if (ismarts > 40)
        !           206:                    beginner = TRUE;
        !           207:                s += strlen(s)-1;
        !           208:                break;
        !           209:            case 'E':
        !           210:                klingspec = TRUE;
        !           211:                beginner = TRUE;
        !           212:                s++;
        !           213:                if (*s == '=') s++;
        !           214:                inumenemies = atoi(s);
        !           215:                s += strlen(s)-1;
        !           216:                break;
        !           217:            case 'F':
        !           218:                friendspec = TRUE;
        !           219:                beginner = TRUE;
        !           220:                s++;
        !           221:                if (*s == '=') s++;
        !           222:                inumfriends = atoi(s);
        !           223:                s += strlen(s)-1;
        !           224:                break;
        !           225:            case 'G':
        !           226:                gornspec = TRUE;
        !           227:                beginner = TRUE;
        !           228:                break;
        !           229:            case 'l':
        !           230:                lowspeed = TRUE;
        !           231:                break;
        !           232:            case 'm':
        !           233:                metakey = TRUE;
        !           234:                break;
        !           235:            case 'M':
        !           236:                massacre = TRUE;
        !           237:                break;
        !           238:            case 'P':
        !           239:                piratespec = TRUE;
        !           240:                beginner = TRUE;
        !           241:                s++;
        !           242:                if (*s == '=') s++;
        !           243:                inumpirates = atoi(s);
        !           244:                s += strlen(s)-1;
        !           245:                break;
        !           246:            case 'S':
        !           247:                prespec = TRUE;
        !           248:                beginner = TRUE;
        !           249:                s++;
        !           250:                if (*s == '=') s++;
        !           251:                if (*s)
        !           252:                    prescene = atoi(s);
        !           253:                else
        !           254:                    prescene = -1;
        !           255:                s += strlen(s)-1;
        !           256:                break;
        !           257:            case 'R':
        !           258:                romspec = TRUE;
        !           259:                beginner = TRUE;
        !           260:                break;
        !           261:            case '*':
        !           262:                starspec = TRUE;
        !           263:                beginner = TRUE;
        !           264:                s++;
        !           265:                if (*s == '=') s++;
        !           266:                inumstars = atoi(s);
        !           267:                s += strlen(s)-1;
        !           268:                break;
        !           269:            case 's':
        !           270:                scorespec = TRUE;
        !           271:                break;
        !           272:            case 'T':
        !           273:                tholspec = TRUE;
        !           274:                beginner = TRUE;
        !           275:                break;
        !           276:            case 'x':
        !           277:                experimenting = TRUE;
        !           278:                break;
        !           279:            case 'v':
        !           280:                version();
        !           281:                exit(0);
        !           282:                break;
        !           283:            default:
        !           284:                fprintf(stderr,"warp: illegal option %c\n", *s);
        !           285:                fprintf(stderr, "Usage: warp -dn -b -x -v -s\n");
        !           286:                exit(1);
        !           287:            }
        !           288:     if (argc != 0) {
        !           289:        fprintf(stderr, "Usage: warp -dn -b -x -v -s\n");
        !           290:        exit(1);
        !           291:     }
        !           292:     bang_init();
        !           293:     move_init();
        !           294:     object_init();
        !           295:     play_init();
        !           296:     them_init();
        !           297:     us_init();
        !           298:     util_init();
        !           299:     weapon_init();
        !           300: 
        !           301:     tcbuf = malloc(1024);
        !           302:     intrp_init(tcbuf);
        !           303: 
        !           304:     if (chdir(warplib) < 0)
        !           305:        fprintf(stderr,nocd,warplib);
        !           306: 
        !           307:     term_init();
        !           308: 
        !           309:     term_set(tcbuf);
        !           310:     free(tcbuf);
        !           311: 
        !           312:     umask(022);     /* mustn't rely on incoming umask--could be 033 which */
        !           313:                    /* would disable people from running wscore */
        !           314: 
        !           315:     score_init();
        !           316: 
        !           317:     sig_init();
        !           318: 
        !           319:     if (totalscore) {
        !           320:        clear();
        !           321:        mvaddstr(12,25,"*** restoring saved game ***");
        !           322:        roundsleep(1);
        !           323:     }
        !           324: 
        !           325:     srand(getpid());
        !           326: 
        !           327:     do {
        !           328:        for (keepgoing = TRUE;;) {
        !           329:            if (!experimenting) {
        !           330:                if ((savfil = fopen(savefilename,"w")) == NULL) {
        !           331:                    resetty();
        !           332:                    printf("Can't open savefile\r\n");
        !           333:                    finalize(1);
        !           334:                }
        !           335:                fprintf(savfil,
        !           336:                    "%-8s %10ld, %2d,%5d,%2d,%2d,%3d %c%c%c%c%c%c%c%c%c\n",
        !           337:                    logname, totalscore, smarts, cumsmarts,
        !           338:                    numents, numbases, wave,
        !           339:                    apolspec ? 'a' : ' ',
        !           340:                    beginner   ? 'b' : ' ',
        !           341:                    crushspec  ? 'c' : ' ',
        !           342:                    gornspec   ? 'g' : ' ',
        !           343:                    massacre   ? 'm' : ' ',
        !           344:                    romspec    ? 'r' : ' ',
        !           345:                    tholspec   ? 't' : ' ',
        !           346:                    lowspeed   ? 'l' : ' ',
        !           347:                    amoebaspec ? '&' : ' '
        !           348:                );
        !           349:                fprintf(savfil,"         running on %s, process #%d\n",
        !           350:                    term+5,getpid());
        !           351:                Fclose(savfil);
        !           352:            }
        !           353: 
        !           354:            lastscore = totalscore;
        !           355:            initialize();
        !           356:            play();
        !           357:            cumsmarts += smarts;
        !           358:            wavescore();
        !           359:            if (numents<=0 && numbases<=0)
        !           360:                keepgoing = FALSE;
        !           361:          if (!keepgoing) break;
        !           362:            do {
        !           363:                if (experimenting) {
        !           364:                    mvaddstr(23,15,
        !           365:                      "      [Hit space to continue, 'q' to quit]       ");
        !           366:                }
        !           367:                else {
        !           368:                    mvaddstr(23,15,
        !           369:                      "[Hit space to continue, 's' to save, 'q' to quit]");
        !           370:                }
        !           371:                sleep(1);
        !           372:                Fflush(stdout);
        !           373:                eat_typeahead();
        !           374:                getcmd(&tmp);
        !           375:                if (tmp == BREAKCH || tmp == INTRCH) {
        !           376:                    mvaddstr(23,15,
        !           377:                      "                                                 ");
        !           378:                    mvaddstr(23,33,
        !           379:                      "Really quit? ");
        !           380:                    getcmd(&tmp);
        !           381:                    if (tmp == 'y' || tmp == 'Y')
        !           382:                        tmp = 'q';
        !           383:                    else
        !           384:                        tmp = 1;
        !           385:                }
        !           386:            } while (tmp != INTRCH && tmp != BREAKCH && !index(" qQs",tmp));
        !           387:          if (tmp != ' ' && tmp != 's') break;
        !           388:            if (!beginner && smarts < 20)
        !           389:                smarts += 4;
        !           390:            else if (!beginner && smarts < 35)
        !           391:                smarts += 2;
        !           392:            else if (smarts < 99)
        !           393:                smarts++;
        !           394:          if (tmp == 's') save_game();
        !           395:        }
        !           396:        score();
        !           397: 
        !           398:     } while (justonemoretime);
        !           399: 
        !           400:     if (!experimenting)
        !           401:        unlink(savefilename);
        !           402: 
        !           403:     clear();
        !           404:     resetty();
        !           405:     exit(0);
        !           406: }

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