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

1.1     ! root        1: /* $Header: init.c,v 7.0.1.4 86/12/12 16:58:03 lwall Exp $ */
        !             2: 
        !             3: /* $Log:       init.c,v $
        !             4:  * Revision 7.0.1.4  86/12/12  16:58:03  lwall
        !             5:  * Baseline for net release.
        !             6:  * 
        !             7:  * Revision 7.0.1.3  86/10/20  14:35:31  lwall
        !             8:  * Picked some lint.
        !             9:  * 
        !            10:  * Revision 7.0.1.2  86/10/17  15:53:30  lwall
        !            11:  * Added random walk star fields.
        !            12:  * 
        !            13:  * Revision 7.0.1.1  86/10/16  10:51:19  lwall
        !            14:  * Added Damage.  Fixed random bugs.
        !            15:  * 
        !            16:  * Revision 7.0  86/10/08  15:12:10  lwall
        !            17:  * Split into separate files.  Added amoebas and pirates.
        !            18:  * 
        !            19:  */
        !            20: 
        !            21: #include "EXTERN.h"
        !            22: #include "warp.h"
        !            23: #include "bang.h"
        !            24: #include "object.h"
        !            25: #include "move.h"
        !            26: #include "play.h"
        !            27: #include "score.h"
        !            28: #include "term.h"
        !            29: #include "them.h"
        !            30: #include "us.h"
        !            31: #include "util.h"
        !            32: #include "weapon.h"
        !            33: #include "INTERN.h"
        !            34: #include "init.h"
        !            35: 
        !            36: void
        !            37: initialize()
        !            38: {
        !            39:     Reg1 int i;
        !            40:     Reg2 int x;
        !            41:     Reg3 int y;
        !            42:     Reg4 int dist;
        !            43:     Reg5 int ydist;
        !            44:     Reg6 int xdist;
        !            45:     long e;
        !            46:     int yoff, xoff, ypred, xpred;
        !            47:     Reg7 OBJECT *obj;
        !            48:     char ch;
        !            49:     FILE *mapfp = NULL;
        !            50:     bool tmptholspec;
        !            51:     int inhabjackpot;
        !            52:     long inhenergy;
        !            53:     int walksplit = 200;
        !            54:     static char *distname[] =
        !            55:        {" #"," -"," \\"," /",
        !            56:         " |"," *"," `"," '"};
        !            57: 
        !            58:     cloaking = madgorns = FALSE;
        !            59:     deados = madfriends = 0;
        !            60:     curscore = possiblescore = 0L;
        !            61:     yamblast = xamblast = ambsize = 0;
        !            62:     if (smarts > 90)
        !            63:        massacre = TRUE;
        !            64:     scandist = (massacre?20:15);
        !            65:     antibase = (smarts>60?1:(smarts>40?2:(smarts>25?4:100)));
        !            66:     sm35 = (smarts>35?35:smarts);
        !            67:     sm45 = (smarts>45?45:smarts);
        !            68:     sm50 = (smarts>50?50:smarts);
        !            69:     sm55 = (smarts>55?55:smarts);
        !            70:     sm80 = (smarts>80?80:smarts);
        !            71:     sm95 = (smarts>95?95:smarts);
        !            72:     super = (smarts>50?smarts-50:0);
        !            73:     enemshields = 10 + super/2;                /* (scaled by 10) 1 @ 50 .. 3 @ 90 */
        !            74:     if (smarts>90)
        !            75:        enemshields += (smarts-90)*10;  /* lay it on thick: ~13 @ 99 */
        !            76:     entmax = (smarts>=75?5000:(smarts>=50?4000:(smarts>=40?3000:2000)));
        !            77:     basemax = (smarts>=75?20000:(smarts>=50?15000:(smarts>=40?12500:10000)));
        !            78: 
        !            79:     clear();
        !            80:     while (root.next != &root) {
        !            81:        root.next = root.next->next;
        !            82:        free_object(root.next->prev);
        !            83:     }
        !            84:     root.prev = &root;
        !            85:     enemies = movers = NULL;
        !            86:     numos = numxes = 0;
        !            87: #if defined(vax) && XYSIZEx4 == 3680
        !            88:     asm("movc5 $0,_occupant,$0,$3680,_occupant");
        !            89:     asm("movc5 $0,_blast,$0,$3680,_blast");    /* 3680 = XYSIZEx4 */
        !            90:     asm("movc5 $0,_amb,$32,$920,_amb");
        !            91: #else
        !            92:     for (y=0;y<YSIZE;y++)
        !            93:        for (x=0;x<XSIZE;x++) {
        !            94:            occupant[y][x] = 0;
        !            95:            blast[y][x] = 0;
        !            96:            amb[y][x] = ' ';
        !            97:        }
        !            98: #endif
        !            99:     for (y=0; y<YSIZE; y++)
        !           100:        yblasted[y] = 0;
        !           101:     for (x=0; x<XSIZE; x++)
        !           102:        xblasted[x] = 0;
        !           103:     blasted = FALSE;
        !           104:     if (!starspec)
        !           105:        if (smarts < 15)
        !           106:            inumstars = 50 + rand_mod(50);
        !           107:        else if (smarts < 50 || smarts > 85)
        !           108:            inumstars = exdis(800) + rand_mod(100) + 1;
        !           109:        else /* too few stars makes 50..85 too hard */
        !           110:            inumstars = exdis(700) + rand_mod(150-super*2) + 50+super*2;
        !           111:     tmptholspec = (smarts > 15 && inumstars < 450 && ! rand_mod(90-sm80));
        !           112:     if (!klingspec) {
        !           113:        inumenemies = rand_mod((smarts+1)/2) + 1;
        !           114:        if (massacre || tmptholspec)
        !           115:            inumenemies += 10;
        !           116:     }
        !           117:     if (!friendspec)
        !           118:        inumfriends = rand_mod(smarts/8+1);
        !           119:     if (!piratespec)
        !           120:        inumpirates = rand_mod(inumfriends/2+1);
        !           121:     if (inumfriends+inumenemies+inumstars > YSIZE*XSIZE-20)
        !           122:        inumstars = YSIZE*XSIZE-20 - inumenemies - inumfriends;
        !           123:     if (inumstars < 0) {
        !           124:        inumfriends += inumstars;
        !           125:        inumstars = 0;
        !           126:     }
        !           127:     if (inumfriends < 0) {
        !           128:        inumenemies += inumfriends;
        !           129:        inumfriends = 0;
        !           130:     }
        !           131:     if (inumenemies < 0)
        !           132:        inumenemies = 0;
        !           133:     numstars = inumstars;
        !           134:     inuminhab = numinhab = 0;
        !           135:     inumroms = inumthols = inumgorns = 0;
        !           136:     numapollos = apolspec || massacre ? 1 :
        !           137:        ((!numstars || rand_mod(2) || smarts < 10) ? 0 : 1);
        !           138:     inumapollos = apolloflag = 0;
        !           139:     realapollo = NULL;
        !           140:     inumcrushes = numcrushes =
        !           141:        crushspec||massacre?1:(rand_mod(2000) < inumstars);
        !           142:     inumenemies += inumcrushes;
        !           143:     inumamoebas = numamoebas = (amoebaspec ? 1 :
        !           144:        !rand_mod(inumcrushes?3-massacre:8) );  /* < and & are fun together */
        !           145:     inumenemies += inumamoebas;
        !           146:     if (!rand_mod(40)) {
        !           147:        inhabjackpot = 32767;
        !           148:        inumfriends += rand_mod(10);
        !           149:        inumpirates += rand_mod(10);
        !           150:     }
        !           151:     else
        !           152:        inhabjackpot = inumpirates;
        !           153:     inhenergy = 30000-super*150;
        !           154:     if (!rand_mod(10))
        !           155:        inhenergy = 50000;
        !           156:     if (!rand_mod(4))
        !           157:        inhenergy += rand_mod(3500+super*150);
        !           158:     numfriends = inumfriends;
        !           159:     numpirates = inumpirates;
        !           160:     numenemies = inumenemies;
        !           161:     deadmudds = 0;
        !           162: 
        !           163:     /* do stars */
        !           164: 
        !           165: stars_again:
        !           166:     if (prespec)
        !           167:        dist = 4;
        !           168:     else if (numstars > 750)
        !           169:        dist = 0;
        !           170:     else
        !           171:        dist = rand_mod(starspec||smarts<=5?3:5);
        !           172:     if (debugging) {
        !           173:        real_y = real_x = -100;
        !           174:        printf("\r\n");
        !           175:     }
        !           176:     switch (dist) {
        !           177:     case 0:                            /* uniform random */
        !           178:        ydist = xdist = 0;
        !           179:        if (inumstars < 700 && !rand_mod(3-(inumstars<50))) {
        !           180:            ydist = xdist = 6;          /* well, maybe not so random */
        !           181:            y = rand_mod(YSIZE);
        !           182:            x = rand_mod(XSIZE);
        !           183:            if (rand_mod(2))
        !           184:                walksplit = inumstars/(exdis(40)+1);
        !           185:        }
        !           186:        if (debugging)
        !           187:            printf(" R\r\n");
        !           188:        break;
        !           189:     case 1: case 2:    /* clumped, maybe skewed, maybe superposed */
        !           190:        ydist = rand_mod(4);
        !           191:        xdist = rand_mod(2);
        !           192:        if (debugging)
        !           193:            printf("%s\r\n",distname[ydist+4*xdist]);
        !           194:        yoff = rand_mod(YSIZE);
        !           195:        xoff = rand_mod(XSIZE);
        !           196:        if (dist == 2)
        !           197:            dist = numstars/2 + exdis(numstars/2) - exdis(numstars/2);
        !           198:        else
        !           199:            dist = 0;
        !           200:        break;
        !           201:     case 3: case 4:                    /* predefined or residual */
        !           202:       scenario_again:
        !           203:        if (debugging)
        !           204:            printf(" P\r\n");
        !           205:        dist = 0;
        !           206:        Sprintf(spbuf,"smap.%d",
        !           207:            (prescene>=0?prescene:rand_mod(MAPS)) );
        !           208:        if ((mapfp = fopen(spbuf,"r")) != NULL &&
        !           209:            fgets(spbuf,10,mapfp) != NULL ) {
        !           210:            inumstars = numstars = atoi(spbuf);
        !           211:            if (inumenemies+inumstars > YSIZE*XSIZE-20)
        !           212:                inumstars = numstars = YSIZE*XSIZE-20 - inumenemies;
        !           213:            ydist = rand_mod(2) + 4;    /* flip y axis? */
        !           214:            xdist = rand_mod(2) + 4;    /* flip x axis? */
        !           215:            yoff = rand_mod(YSIZE);     /* how much to shift y */
        !           216:            xoff = rand_mod(XSIZE);     /* how much to shift x */
        !           217:        }
        !           218:        else {
        !           219:            prespec = FALSE;
        !           220:            prescene = -1;
        !           221:            if (rand_mod(2))
        !           222:                goto scenario_again;
        !           223:            goto stars_again;
        !           224:        }
        !           225:        break;
        !           226:     }
        !           227:     for (i = 1; i <= numstars; i++) {
        !           228:        if (dist && i == dist) {        /* flip to another skewing? */
        !           229:            ydist = rand_mod(4);
        !           230:            xdist = rand_mod(2);
        !           231:            if (!rand_mod(4)) {
        !           232:                ydist = xdist = 6;
        !           233:                if (debugging)
        !           234:                    printf("&\r\n");
        !           235:            }
        !           236:            else if (debugging)
        !           237:                printf("%s\r\n",distname[ydist+4*xdist]);
        !           238:            yoff = rand_mod(YSIZE);
        !           239:            xoff = rand_mod(XSIZE);
        !           240:            dist = 0;
        !           241:        }
        !           242:        do {                            /* until an open spot found */
        !           243:            switch (xdist) {
        !           244:            case 0:
        !           245:                x = rand_mod(XSIZE);    /* pick from 0..39, uniform */
        !           246:                break;
        !           247:            case 1: case 2: case 3:
        !           248: #ifndef lint
        !           249:                x = (int)((((double)(myrand()-HALFRAND)) *
        !           250:                           ((double)(myrand()-HALFRAND))/RANDRAND)
        !           251:                          * 20.0) + xoff;       /* pick from -20..20, clumped */
        !           252: #endif
        !           253:                break;
        !           254:            case 4:
        !           255:                if (fscanf(mapfp,"%d %d\n",&ypred,&xpred) == EOF)
        !           256:                    ydist = xdist = 0;
        !           257:                x = xpred + xoff;
        !           258:                break;
        !           259:            case 5:
        !           260:                if (fscanf(mapfp,"%d %d\n",&ypred,&xpred) == EOF)
        !           261:                    ydist = xdist = 0;
        !           262:                x = -xpred + xoff;
        !           263:                break;
        !           264:            case 6:
        !           265:                x += rand_mod(3) - 1;
        !           266:                break;
        !           267:            }
        !           268:            switch (ydist) {
        !           269:            case 0:
        !           270:                y = rand_mod(YSIZE);
        !           271:                break;
        !           272:            case 1:
        !           273: #ifndef lint
        !           274:                y = (int)((((double)(myrand()-HALFRAND)) *
        !           275:                           ((double)(myrand()-HALFRAND))/RANDRAND)
        !           276:                          * 12.0) + yoff;       /* pick from -12..12, clumped */
        !           277: #endif
        !           278:                break;
        !           279:            case 2:
        !           280: #ifndef lint
        !           281:                y = (int)((((double)(myrand()-HALFRAND)) *
        !           282:                           ((double)(myrand()-HALFRAND))/RANDRAND)
        !           283:                          * 12.0) + yoff + x*YSIZE/XSIZE;
        !           284:                                                /* clumped & skewed */
        !           285: #endif
        !           286:                break;
        !           287:            case 3:
        !           288: #ifndef lint
        !           289:                y = (int)((((double)(myrand()-HALFRAND)) *
        !           290:                           ((double)(myrand()-HALFRAND))/RANDRAND)
        !           291:                          * 12.0) + yoff - x*YSIZE/XSIZE;
        !           292:                                                /* clumped & skewed */
        !           293: #endif
        !           294:                break;
        !           295:            case 4:
        !           296:                y = ypred + yoff;
        !           297:                break;
        !           298:            case 5:
        !           299:                y = -ypred + yoff;
        !           300:                break;
        !           301:            case 6:
        !           302:                y += rand_mod(3) - 1;
        !           303: #ifdef lint
        !           304:                walksplit = walksplit;
        !           305: #endif
        !           306:                if (!rand_mod(walksplit)) {
        !           307:                    y = rand_mod(YSIZE);
        !           308:                    x = rand_mod(XSIZE);
        !           309:                }
        !           310:                break;
        !           311:            }
        !           312:            while (x<0) x += XSIZE00;
        !           313:            while (y<0) y += YSIZE00;
        !           314:            x %= XSIZE;
        !           315:            y %= YSIZE;
        !           316:        } while (occupant[y][x]);
        !           317:        e = rand_mod(32768);
        !           318:        if (--inhabjackpot > 0 || e >= inhenergy) {
        !           319:            ch = '@';
        !           320:            if (inhabjackpot && e < 10000)
        !           321:                e += 10000;
        !           322:            inuminhab = ++numinhab;
        !           323:        }
        !           324:        else {
        !           325:            ch = '*';
        !           326:        }
        !           327:        obj = make_object(Star,ch,y,x,0,0,e+rand_mod(super*100+1),e/4,&root);
        !           328:        obj->flags |= STATIC;
        !           329:     }
        !           330:     if (inumstars > 30 && inhabjackpot <= 0 &&
        !           331:         !rand_mod(3 - (inumstars > 400) - (inhenergy > 32768)) ) {
        !           332:        int initx;
        !           333:        int inity;
        !           334: 
        !           335:        x = initx = obj->posx;
        !           336:        y = inity = obj->posy;
        !           337:        while (rand_mod(2) && inuminhab < inumstars/2) {
        !           338:            for (i=rand_mod(smarts)*2+20; i; i--) {
        !           339:                if ((obj = occupant[y][x]) && obj->image == '*') {
        !           340:                    setimage(obj,'@');
        !           341:                    if (obj->energy < 10000)
        !           342:                        obj->energy += 20000; /* the benefits of civilization */
        !           343:                    inuminhab = ++numinhab;
        !           344:                }
        !           345:                if (i&15) {
        !           346:                    y = (y + rand_mod(3) + YSIZE99) % YSIZE;
        !           347:                    x = (x + rand_mod(3) + XSIZE99) % XSIZE;
        !           348:                }
        !           349:                else {                  /* don't wander too far */
        !           350:                    y = inity;
        !           351:                    x = initx;
        !           352:                }
        !           353:            }
        !           354:            x = initx = rand_mod(XSIZE);
        !           355:            y = inity = rand_mod(YSIZE);
        !           356:        }
        !           357:     }
        !           358:     if (mapfp != NULL)
        !           359:        Fclose(mapfp);
        !           360:     if (numcrushes) {
        !           361:        do {
        !           362:            x = rand_mod(XSIZE);
        !           363:            y = rand_mod(YSIZE);
        !           364:        } while (occupant[y][x]);
        !           365:        movers = make_object(Crusher,'<',y,x,0,1,32767L,32768L,&root);
        !           366:        possiblescore += 10000;
        !           367:     }
        !           368:     ient = (numents != 0);
        !           369:     if (ient) {
        !           370:        do {
        !           371:            x = rand_mod(XSIZE);
        !           372:            y = rand_mod(YSIZE);
        !           373:        } while (occupant[y][x]);
        !           374:        e = entmax;
        !           375:        ent = make_object(Enterprise,'E',y,x,0,0,e,e/2,&root);
        !           376:        if (!movers)
        !           377:            movers = ent;
        !           378:     }
        !           379:     ibase = (numbases != 0);
        !           380:     if (ibase) {
        !           381:        e = 52-super;
        !           382:        do {
        !           383:            x = rand_mod(XSIZE);
        !           384:            y = rand_mod(YSIZE);
        !           385:        } while (occupant[y][x] || lookaround(y,x,Star) * 7 < e--);
        !           386:        e = basemax;
        !           387:        base = make_object(Base, 'B',y,x,0,0,e,e/4,&root);
        !           388:        if (!movers)
        !           389:            movers = base;
        !           390:     }
        !           391:     if (numamoebas) {
        !           392:        do {
        !           393:            x = rand_mod(XSIZE);
        !           394:            y = rand_mod(YSIZE);
        !           395:        } while (occupant[y][x]);
        !           396:        nuke = make_object(Enemy,'&',y,x,0,0,32767L,
        !           397:          (long)entmax+entmax+rand_mod(entmax),&root);
        !           398:        possiblescore += 10000;
        !           399:        amb[y][x] = '~';
        !           400:        if (rand_mod(2))
        !           401:            modify_amoeba(y,x,2,'~',(int)rand_mod(smarts<<1));/* just make blob */
        !           402:        else {
        !           403:            for (i=smarts/10+1; i; i--) {
        !           404:                nuke->strategy = rand_mod(256);         /* random direction */
        !           405:                modify_amoeba(y,x,2,'~',(int)rand_mod(5));
        !           406:                modify_amoeba(y,x,2,'~',(int)rand_mod(5));
        !           407:                modify_amoeba(y,x,2,'~',(int)rand_mod(5));
        !           408:                modify_amoeba(y,x,2,'~',(int)rand_mod(5));      /* extend pseudopod */
        !           409:            }
        !           410:        }
        !           411:        if (!enemies)
        !           412:            enemies = nuke;
        !           413:        if (!movers)
        !           414:            movers = nuke;
        !           415:     }
        !           416:     if (rand_mod(27-sm50/2) && !romspec && !gornspec)
        !           417:        dist = 27-sm50/2;
        !           418:     else
        !           419:        dist = rand_mod(4) + 1;
        !           420:     for (i = 1+inumcrushes+inumamoebas; i <= numenemies; i++) {
        !           421:        do {
        !           422:            x = rand_mod(XSIZE);
        !           423:            y = rand_mod(YSIZE);
        !           424:        } while (occupant[y][x]);
        !           425:        if (rand_mod(dist)) {
        !           426:            if (!tholspec && !tmptholspec && rand_mod((inumstars*3)/sm50+2))
        !           427:                ch = 'K';
        !           428:            else {
        !           429:                ch = 'T';
        !           430:                inumthols++;
        !           431:            }
        !           432:        }
        !           433:        else {
        !           434:            if (romspec == gornspec)
        !           435:                e = 50;
        !           436:            else if (gornspec)
        !           437:                e = 10;
        !           438:            else
        !           439:                e = 90;
        !           440:            if (rand_mod(100) < e) {
        !           441:                ch = 'R';
        !           442:                inumroms++;
        !           443:            }
        !           444:            else {
        !           445:                ch = 'G';
        !           446:                inumgorns++;
        !           447:            }
        !           448:        }
        !           449:        if (possiblescore > ENTBOUNDARY - 10000)
        !           450:            e = (ENTBOUNDARY - possiblescore) / 5;
        !           451:        else
        !           452:            e = 250 + (sm50-1) * 30 * 20 / numenemies+1;
        !           453: #ifndef lint
        !           454:        e = exdis((int)e) + e - exdis((int)e);
        !           455:        obj = make_object(Enemy,ch,y,x,0,0,
        !           456:            e + rand_mod(super*200+2) + 10000*massacre,e/4,&root);
        !           457: #endif
        !           458:        e /= 4;
        !           459:        switch (ch) {
        !           460:        case 'K':
        !           461:            possiblescore += e;
        !           462:            break;
        !           463:        case 'T':
        !           464:            possiblescore += e*3/2;
        !           465:            break;
        !           466:        case 'G':
        !           467:            possiblescore += e*2;
        !           468:            break;
        !           469:        case 'R':
        !           470:            possiblescore += e*3;
        !           471:            obj->flags |= CLOAKS;
        !           472:            break;
        !           473:        }
        !           474:        if (!enemies)
        !           475:            enemies = obj;
        !           476:        if (!movers)
        !           477:            movers = obj;
        !           478:     }
        !           479:     numgorns = inumgorns;
        !           480:     for (i=0; i<numfriends; i++) {
        !           481:        do {
        !           482:            x = rand_mod(XSIZE);
        !           483:            y = rand_mod(YSIZE);
        !           484:        } while (occupant[y][x]);
        !           485:        e = 250 + (sm50-1) * 30 * 20 / numenemies+1;
        !           486: #ifndef lint
        !           487:        e = exdis((int)e) + e - exdis((int)e);
        !           488: #endif
        !           489:        {
        !           490:            static char let[] = "QWYUISDHJLZVMFFFFFFFFF";
        !           491: 
        !           492:            dist = rand_mod(20);
        !           493:            ch = let[dist];
        !           494:        }               /* grr, venix doesn't like indexing into string */
        !           495:        obj = make_object(Enemy,ch,y,x,0,0,
        !           496:            e + rand_mod(super*200+2),e/4,&root);
        !           497:        if (numpirates-- > 0) {
        !           498:            obj->flags |= PIRATE;
        !           499:            if (smarts >= 20 && !rand_mod(10-smarts/10))
        !           500:                obj->flags |= CLOAKS;
        !           501:        }
        !           502:        obj->flags |= FRIENDLY;
        !           503:        if (!enemies)
        !           504:            enemies = obj;
        !           505:        if (!movers)
        !           506:            movers = obj;
        !           507:     }
        !           508:     if (!movers)
        !           509:        movers = &root;
        !           510:     if (!enemies)
        !           511:        enemies = &root;
        !           512:     if (ent)
        !           513:        mvaddch(ent->posy+1, ent->posx*2, ent->image);
        !           514:     if (base)
        !           515:        mvaddch(base->posy+1, base->posx*2, base->image);
        !           516:     sleep(2);
        !           517:     {
        !           518:        Reg7 OBJECT *curobj;
        !           519: 
        !           520:        for (curobj = root.next; curobj != &root; curobj = curobj->next) {
        !           521:            mvaddch(curobj->posy+1, curobj->posx*2, curobj->image);
        !           522:        }
        !           523:     }
        !           524: 
        !           525:     for (i=0;i<2;i++) for (y=0;y<3;y++) for (x=0;x<3;x++) 
        !           526:     isatorp[i][y][x]=0;
        !           527: 
        !           528:     whenok = 0;
        !           529:     timer = 0;
        !           530:     finish = 0;
        !           531:     bombed_out = FALSE;
        !           532:     if (ent)
        !           533:        entmode = status = 0;
        !           534:     else
        !           535:        if (base)
        !           536:            status = 2;
        !           537:        else
        !           538:            status = 3;
        !           539: 
        !           540:     Sprintf(spbuf,
        !           541:     "%-4s E: %4d %2d B: %5d %3d Enemies: %-3d Stars: %-3d Stardate%5d.%1d %9ld",
        !           542:        "   ", 0, 0, 0, 0, 0, 0, smarts * 100, 0, 0L);
        !           543:     mvaddstr(0,0,spbuf);
        !           544:     oldeenergy = oldbenergy = oldcurscore =
        !           545:     oldstatus = oldetorp = oldbtorp = oldstrs = oldenemies = -1;
        !           546:                                        /* force everything to fill in */
        !           547:     damage = olddamage = 0;
        !           548:     for (i=0; i<MAXDAMAGE; i++)
        !           549:        damflag[i] = 0;
        !           550:     btorp = 500;
        !           551:     etorp = 50;
        !           552: }

unix.superglobalmegacorp.com

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