Return to us.c CVS log

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

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

1.1     ! root        1: /* $Header: us.c,v 7.0.1.3 87/01/13 17:13:21 lwall Exp $ */
        !             2: 
        !             3: /* $Log:       us.c,v $
        !             4:  * Revision 7.0.1.3  87/01/13  17:13:21  lwall
        !             5:  * Partially fixed ^S behavior.  It now just ignores ^S.
        !             6:  * 
        !             7:  * Revision 7.0.1.2  86/12/12  17:06:09  lwall
        !             8:  * Baseline for net release.
        !             9:  * 
        !            10:  * Revision 7.0.1.1  86/10/16  10:53:50  lwall
        !            11:  * Added Damage.  Fixed random bugs.
        !            12:  * 
        !            13:  * Revision 7.0  86/10/08  15:14:21  lwall
        !            14:  * Split into separate files.  Added amoebas and pirates.
        !            15:  * 
        !            16:  */
        !            17: 
        !            18: #include "EXTERN.h"
        !            19: #include "warp.h"
        !            20: #include "bang.h"
        !            21: #include "object.h"
        !            22: #include "play.h"
        !            23: #include "sig.h"
        !            24: #include "term.h"
        !            25: #include "util.h"
        !            26: #include "weapon.h"
        !            27: #include "INTERN.h"
        !            28: #include "us.h"
        !            29: 
        !            30: void
        !            31: us_init()
        !            32: {
        !            33:     ;
        !            34: }
        !            35: 
        !            36: void
        !            37: do_direction(dy,dx)
        !            38: int dy, dx;
        !            39: {
        !            40:     Reg1 int decr;
        !            41:     Reg2 OBJECT *obj;
        !            42: 
        !            43:     if (status < 2) {
        !            44:        if (cloaking) {
        !            45:            char ch;
        !            46:            
        !            47:            cloaked = FALSE;
        !            48:            ch = (ent->energy >= 500?'E':'e');
        !            49:            if (ch != ent->image) {
        !            50:                setimage(ent, ch);
        !            51:            }
        !            52:        }
        !            53:        decr = 5+abs(evely)+abs(evelx)+tractor*tractor;
        !            54:        if (ent->energy >= decr) {
        !            55:            ent->energy -= decr;
        !            56:            if (tractor) {
        !            57:                if (!damage || !damflag[NOTRACTORS]) {
        !            58:                    if (!rand_mod(50)) {
        !            59:                        damage++;
        !            60:                        damflag[NOTRACTORS] = rand_mod(smarts+10)+2;
        !            61:                    }
        !            62:                    if (tract(ent,dy,dx,tractor)) {
        !            63:                        evely += tractor*dy;
        !            64:                        evelx += tractor*dx;
        !            65:                    }
        !            66:                }
        !            67:            }
        !            68:            else if (!damage ||
        !            69:              (!entmode && !damflag[NOIMPULSE]) ||
        !            70:              (entmode && !damflag[NOWARP]) ) {
        !            71:                if (!rand_mod(30+500/(abs(evely)+abs(evelx)+1))) {
        !            72:                    damage++;
        !            73:                    damflag[entmode?NOWARP:NOIMPULSE] = rand_mod(smarts+10)+2;
        !            74:                }
        !            75:                evely += dy;
        !            76:                evelx += dx;
        !            77:            }
        !            78:            if (inumthols &&
        !            79:              (obj=occupant[(ent->posy+evely+YSIZE00)%YSIZE]
        !            80:                           [(ent->posx+evelx+XSIZE00)%XSIZE] ) &&
        !            81:              obj->type == Web)
        !            82:                evely = evelx = 0;
        !            83:        }
        !            84:     }
        !            85:     else if (status == 2) {
        !            86:        decr = 500+abs(bvely)*5+abs(bvelx)*5+tractor*tractor*100;
        !            87:        if (base->energy >= decr) {
        !            88:            base->energy -= decr;
        !            89:            if (tractor) {
        !            90:                if (tract(base,dy,dx,tractor)) {
        !            91:                    bvely += tractor*dy;
        !            92:                    bvelx += tractor*dx;
        !            93:                }
        !            94:            }
        !            95:            else {
        !            96:                bvely += dy;
        !            97:                bvelx += dx;
        !            98:            }
        !            99:            if (inumthols &&
        !           100:              (obj=occupant[(base->posy+bvely+YSIZE00)%YSIZE]
        !           101:                           [(base->posx+bvelx+XSIZE00)%XSIZE] ) &&
        !           102:              obj->type == Web)
        !           103:                bvely = bvelx = 0;
        !           104:        }
        !           105:     }
        !           106:     tractor = 0;
        !           107: }
        !           108: 
        !           109: void
        !           110: ctrl_direction(dy,dx)
        !           111: int dy, dx;
        !           112: {
        !           113:     if (status < 2) {
        !           114:        if (cloaking) {
        !           115:            char ch;
        !           116:            
        !           117:            cloaked = FALSE;
        !           118:            ch = (ent->energy >= 500?'E':'e');
        !           119:            if (ch != ent->image) {
        !           120:                setimage(ent, ch);
        !           121:            }
        !           122:        }
        !           123:        if (!damage || !damflag[NOPHASERS]) {
        !           124:            if (!rand_mod(200)) {
        !           125:                damage++;
        !           126:                damflag[NOPHASERS] = rand_mod(smarts+10)+2;
        !           127:            }
        !           128:            fire_phaser(ent, dy, dx);
        !           129:        }
        !           130:     }
        !           131:     else if (status == 2)
        !           132:        fire_phaser(base, dy, dx);
        !           133: }
        !           134: 
        !           135: void
        !           136: shift_direction(dy,dx)
        !           137: int dy, dx;
        !           138: {
        !           139:     if (status < 2) {
        !           140:        if (cloaking) {
        !           141:            char ch;
        !           142:            
        !           143:            cloaked = FALSE;
        !           144:            ch = (ent->energy >= 500?'E':'e');
        !           145:            if (ch != ent->image) {
        !           146:                setimage(ent, ch);
        !           147:            }
        !           148:        }
        !           149:        if (!damage || !damflag[NOTORPS]) {
        !           150:            if (!rand_mod(300)) {
        !           151:                damage++;
        !           152:                damflag[NOTORPS] = rand_mod(smarts+10)+2;
        !           153:            }
        !           154:            fire_torp(ent, dy, dx);
        !           155:        }
        !           156:     }
        !           157:     else if (status == 2)
        !           158:        fire_torp(base, dy, dx);
        !           159: }
        !           160: 
        !           161: void
        !           162: get_commands(done)
        !           163: bool *done;
        !           164: {
        !           165:     static char ch[80];
        !           166:     Reg1 int i;
        !           167:     Reg2 int count;
        !           168:     Reg3 bool ctrla = FALSE;
        !           169:     char numdestructs = 0, numzaps = 0;
        !           170: 
        !           171: top:
        !           172:     while (count = read_nd(ch,(sizeof ch))) {
        !           173:        for (i=0; i<count; i++) {
        !           174:            if (ch[i] == 'Q') {
        !           175:                bombed_out = TRUE;
        !           176:                *done = TRUE;
        !           177:                keepgoing = FALSE;
        !           178:                return;
        !           179:            }
        !           180:            if (ch[i] == 'q' || ch[i] == BREAKCH || ch[i] == INTRCH) {
        !           181:                int x;
        !           182:                static char quest[] = "Do you wish to escape from reality? ";
        !           183: 
        !           184:                if (timer >= whenok) {
        !           185:                    mvaddstr(12,22,quest);
        !           186:                    do {
        !           187:                        getcmd(&ch[i]);
        !           188:                    } while (ch[i] != 'y' && ch[i] != 'n');
        !           189:                    if (ch[i] == 'y') {
        !           190:                        bombed_out = TRUE;
        !           191:                        *done = TRUE;
        !           192:                        return;
        !           193:                    }
        !           194:                    else {
        !           195:                        for (x=11; x<=28; x++) {
        !           196:                            mvaddch(12,x*2,
        !           197:                                occupant[11][x]
        !           198:                                   ? occupant[11][x]->image
        !           199:                                   : numamoebas
        !           200:                                      ? amb[11][x]
        !           201:                                      : ' ');
        !           202:                            addspace();
        !           203:                        }
        !           204:                        roundsleep(2);
        !           205:                        whenok = timer + 10;
        !           206:                        goto top;
        !           207:                    }
        !           208:                }
        !           209:                else {
        !           210:                    write(1,"\07",1);
        !           211:                    goto top;
        !           212:                }
        !           213:            }
        !           214:        }
        !           215:        for (i=0; i<count; i++) {
        !           216:            if (ctrla) {
        !           217:                switch (ch[i]) {
        !           218:                case '1': case 'b':
        !           219:                    ctrl_direction(1, -1);
        !           220:                    break;
        !           221:                case '2': case 'j':
        !           222:                    ctrl_direction(1, 0);
        !           223:                    break;
        !           224:                case '3': case 'n':
        !           225:                    ctrl_direction(1, 1);
        !           226:                    break;
        !           227:                case '4': case 'h':
        !           228:                    ctrl_direction(0, -1);
        !           229:                    break;
        !           230:                case '6': case 'l':
        !           231:                    ctrl_direction(0, 1);
        !           232:                    break;
        !           233:                case '7': case 'y':
        !           234:                    ctrl_direction(-1, -1);
        !           235:                    break;
        !           236:                case '8': case 'k':
        !           237:                    ctrl_direction(-1, 0);
        !           238:                    break;
        !           239:                case '9': case 'u':
        !           240:                    ctrl_direction(-1, 1);
        !           241:                    break;
        !           242:                case 'r':
        !           243:                    rewrite();
        !           244:                    roundsleep(3);
        !           245:                    ctrla = FALSE;
        !           246:                    goto top;
        !           247:                case 'w':
        !           248:                    clear();
        !           249:                    while (!input_pending())
        !           250:                        sleep(1);
        !           251:                    rewrite();
        !           252:                    roundsleep(3);
        !           253:                    ctrla = FALSE;
        !           254:                    goto top;
        !           255: #ifdef SIGTSTP
        !           256:                case 'z':
        !           257:                    clear();
        !           258:                    mytstp();
        !           259:                    sleep(4);
        !           260:                    ctrla = FALSE;
        !           261:                    goto top;
        !           262: #endif
        !           263:                default:
        !           264:                    break;
        !           265:                }
        !           266:                ctrla = FALSE;
        !           267:            }
        !           268:            else {
        !           269:                switch (ch[i]) {
        !           270:                case 'Z':
        !           271:                    clear();
        !           272:                    mytstp();
        !           273:                    sleep(4);
        !           274:                    goto top;
        !           275:                case 'i':
        !           276:                    if (ent && (!damage || !damflag[NOIMPULSE])) {
        !           277:                        entmode = 0;
        !           278:                        status = 0;
        !           279:                    }
        !           280:                    break;
        !           281:                case 'w':
        !           282:                    if (ent && (!damage || !damflag[NOWARP])) {
        !           283:                        entmode = 1;
        !           284:                        status = 1;
        !           285:                    }
        !           286:                    break;
        !           287:                case 'p':
        !           288:                    if (base) {
        !           289:                        status = 2;
        !           290:                    }
        !           291:                    break;
        !           292:                case 'o':
        !           293:                    if (status < 2) {
        !           294:                        if (base)
        !           295:                            status = 2;
        !           296:                    }
        !           297:                    else if (status == 2) {
        !           298:                        if (ent)
        !           299:                            status = entmode;
        !           300:                    }
        !           301:                    break;
        !           302:                case 'v':
        !           303:                    if (ent) {
        !           304:                        status = entmode;
        !           305:                    }
        !           306:                    cloaking=FALSE;
        !           307:                    cloaked=FALSE;
        !           308:                    break;
        !           309:                case 'c':
        !           310:                    if (ent) {
        !           311:                        status = entmode;
        !           312:                        if (ent->energy >= 250)
        !           313:                            cloaking = TRUE;
        !           314:                    }
        !           315:                    break;
        !           316:                case 'z':
        !           317:                    if (ent && (!damage || !damflag[NOZAPPER])) {
        !           318:                        ++numzaps;
        !           319:                        if (!rand_mod(100/numzaps)) {
        !           320:                            damage++;
        !           321:                            damflag[NOZAPPER] = rand_mod(smarts+10)+2;
        !           322:                        }
        !           323:                        if (nxtbang && bangm[nxtbang-1] < 0)
        !           324:                            --nxtbang;  /* consolidate zaps */
        !           325:                        make_blast(evely*2+ent->posy,evelx*2+ent->posx,
        !           326:                            -5000000L, 3*numzaps);
        !           327:                        ent->energy /= 2;
        !           328:                    }
        !           329:                    break;
        !           330:                case 'D':
        !           331:                    if (status < 2 && (!damage || !damflag[NODESTRUCT])) {
        !           332:                        if (ent && !rand_mod(10)) {
        !           333:                            damage++;
        !           334:                            damflag[NODESTRUCT] = rand_mod(smarts+10)+2;
        !           335:                        }
        !           336:                        if (++numdestructs <= 2)
        !           337:                            make_blast(evely*2+ent->posy,evelx*2+ent->posx,
        !           338:                                15000L, 3);
        !           339:                        ent->energy /= 4;
        !           340:                    }
        !           341:                    else if (status == 2) {
        !           342:                        if (numdestructs)
        !           343:                            base->energy = base->energy / 2;
        !           344:                        if (++numdestructs <= 2)
        !           345:                            make_blast(base->posy, base->posx, 15000L, 5);
        !           346:                    }
        !           347:                    break;
        !           348:                case 'd':
        !           349:                    if ((!damage || !damflag[NODESTRUCT]) && (base||ent)) {
        !           350:                        Reg4 OBJECT *obj;
        !           351:                        int x, y;
        !           352: 
        !           353:                        if (ent && !rand_mod(200)) {
        !           354:                            damage++;
        !           355:                            damflag[NODESTRUCT] = rand_mod(smarts+10)+2;
        !           356:                        }
        !           357:                        for (obj = root.prev;
        !           358:                          obj != &root;
        !           359:                          obj = obj->prev) {
        !           360:                            if (obj->image == '+') {
        !           361:                                blast[y=(obj->posy+obj->vely+YSIZE00)%YSIZE]
        !           362:                                     [x=(obj->posx+obj->velx+XSIZE00)%XSIZE]
        !           363:                                     += 1;
        !           364:                                yblasted[y] |= 1;
        !           365:                                xblasted[x] |= 1;
        !           366:                                blasted = TRUE;
        !           367:                                obj->mass = (massacre?3000:4000);
        !           368:                            }
        !           369:                        }
        !           370:                    }
        !           371:                    break;
        !           372:                case 's':
        !           373:                    if ((!damage || !damflag[NODESTRUCT]) && (base||ent)) {
        !           374:                        Reg4 OBJECT *obj;
        !           375:                        if (ent && !rand_mod(200)) {
        !           376:                            damage++;
        !           377:                            damflag[NODESTRUCT] = rand_mod(smarts+10)+2;
        !           378:                        }
        !           379:                        for (obj = root.prev;
        !           380:                          obj->type == Torp || obj->type == Web ||
        !           381:                          obj->type == Star;
        !           382:                          obj = obj->prev) {
        !           383:                            if (obj->image == '+')
        !           384:                                obj->vely = obj->velx = 0;
        !           385:                        }
        !           386:                    }
        !           387:                    break;
        !           388:                case '\001':
        !           389:                    ctrla = TRUE;
        !           390:                    break;
        !           391:                case '\002':
        !           392:                case '\003':
        !           393:                case '\004':
        !           394:                case '\005':
        !           395:                case '\006':
        !           396:                case '\007':
        !           397:                case '\010':
        !           398:                case '\011':
        !           399:                case '\012':
        !           400:                case '\013':
        !           401:                case '\014':
        !           402:                case '\015':
        !           403:                case '\016':
        !           404:                case '\017':
        !           405:                case '\020':
        !           406:                case '\021':
        !           407:                case '\022':
        !           408:                case '\023':
        !           409:                case '\024':
        !           410:                case '\025':
        !           411:                case '\026':
        !           412:                case '\027':
        !           413:                case '\030':
        !           414:                case '\031':
        !           415:                case '\032':
        !           416:                    ch[i] += 96;
        !           417:                    i--;
        !           418:                    ctrla = TRUE;
        !           419:                    break;
        !           420:                case '\033':
        !           421:                    tractor = 0;
        !           422:                    break;
        !           423:                case 'a':
        !           424:                    tractor++;
        !           425:                    break;
        !           426:                case 'r':
        !           427:                    tractor--;
        !           428:                    break;
        !           429:                case '1': case 'b':
        !           430:                    do_direction(1,-1);
        !           431:                    break;
        !           432:                case '2': case 'j':
        !           433:                    do_direction(1,0);
        !           434:                    break;
        !           435:                case '3': case 'n':
        !           436:                    do_direction(1,1);
        !           437:                    break;
        !           438:                case '4': case 'h':
        !           439:                    do_direction(0,-1);
        !           440:                    break;
        !           441:                case '6': case 'l':
        !           442:                    do_direction(0,1);
        !           443:                    break;
        !           444:                case '7': case 'y':
        !           445:                    do_direction(-1,-1);
        !           446:                    break;
        !           447:                case '8': case 'k':
        !           448:                    do_direction(-1,0);
        !           449:                    break;
        !           450:                case '9': case 'u':
        !           451:                    do_direction(-1,1);
        !           452:                    break;
        !           453:                case '0': case 'S':
        !           454:                    if (status < 2) {
        !           455:                        evely = 0;
        !           456:                        evelx = 0;
        !           457:                    }
        !           458:                    break;
        !           459:                case '-':
        !           460:                    if (status < 2 && ent->energy >= 10) {
        !           461:                        evely *= -1;
        !           462:                        evelx *= -1;
        !           463:                        ent->energy -= 10;
        !           464:                    }
        !           465:                    break;
        !           466:                case '%': case '\177': case '_':
        !           467:                    shift_direction(0, -1);
        !           468:                    shift_direction(0, 1);
        !           469:                    shift_direction(-1, 0);
        !           470:                    shift_direction(1, 0);
        !           471:                    shift_direction(-1, -1);
        !           472:                    shift_direction(-1, 1);
        !           473:                    shift_direction(1, -1);
        !           474:                    shift_direction(1, 1);
        !           475:                    break;
        !           476:                case '!': case 'B':
        !           477:                    shift_direction(1, -1);
        !           478:                    break;
        !           479:                case '@': case 'J':
        !           480:                    shift_direction(1, 0);
        !           481:                    break;
        !           482:                case '#': case 'N':
        !           483:                    shift_direction(1, 1);
        !           484:                    break;
        !           485:                case '$': case 'H':
        !           486:                    shift_direction(0, -1);
        !           487:                    break;
        !           488:                case '^': case 'L':
        !           489:                    shift_direction(0, 1);
        !           490:                    break;
        !           491:                case '&': case 'Y':
        !           492:                    shift_direction(-1, -1);
        !           493:                    break;
        !           494:                case '*': case 'K':
        !           495:                    shift_direction(-1, 0);
        !           496:                    break;
        !           497:                case '(': case 'U':
        !           498:                    shift_direction(-1, 1);
        !           499:                    break;
        !           500:                case '?':
        !           501:                    helper();
        !           502:                    roundsleep(3);
        !           503:                    goto top;
        !           504:                default:
        !           505:                    break;
        !           506:                }
        !           507:            }
        !           508:        }
        !           509:     }
        !           510: }

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