2.11BSD#431 - /usr/src/games/warp/us.c

   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: }

Defined functions