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

   1: /* $Header: them.c,v 7.0.1.5 86/12/12 17:05:41 lwall Exp $ */
   2: 
   3: /* $Log:	them.c,v $
   4:  * Revision 7.0.1.5  86/12/12  17:05:41  lwall
   5:  * Baseline for net release.
   6:  *
   7:  * Revision 7.0.1.4  86/10/20  12:32:38  lwall
   8:  * Wasn't clearing FRIENDLY flag on pirate creation.
   9:  *
  10:  * Revision 7.0.1.3  86/10/20  12:15:33  lwall
  11:  * Was trying to create pirates from cloaked pirates.
  12:  *
  13:  * Revision 7.0.1.2  86/10/17  10:03:44  lwall
  14:  * Fixed Romulan writing spaces while cloaked.
  15:  *
  16:  * Revision 7.0.1.1  86/10/16  10:53:39  lwall
  17:  * Added Damage.  Fixed random bugs.
  18:  *
  19:  * Revision 7.0  86/10/08  15:14:15  lwall
  20:  * Split into separate files.  Added amoebas and pirates.
  21:  *
  22:  */
  23: 
  24: #include "EXTERN.h"
  25: #include "warp.h"
  26: #include "bang.h"
  27: #include "object.h"
  28: #include "move.h"
  29: #include "score.h"
  30: #include "term.h"
  31: #include "us.h"
  32: #include "util.h"
  33: #include "weapon.h"
  34: #include "INTERN.h"
  35: #include "them.h"
  36: 
  37: void
  38: them_init()
  39: {
  40:     ;
  41: }
  42: 
  43: void
  44: their_smarts()
  45: {
  46:     Reg1 OBJECT *curkl;
  47:     Reg2 OBJECT *obj;
  48:     Reg3 int prob;
  49:     Reg4 int count;
  50:     Reg5 int y;
  51:     Reg6 int x;
  52: 
  53:     if (numcrushes && (obj=movers)->type == Crusher) {
  54:     if (numamoebas) {
  55:         y = obj->posy;
  56:         x = (obj->posx+(obj->image=='<'?1:-1)+XSIZE00)%XSIZE;
  57:         if (amb[y][x] == '~') {
  58:         obj->velx = 0;      /* stop and munch amoeba */
  59:         modify_amoeba(y,x,1,' ',(int)rand_mod(5+ambsize/10)+1);
  60:         if (occupant[y][x] == nuke) /* except go for nucleus */
  61:             obj->velx = (obj->image=='<' ? 1 : -1);
  62:         }
  63:         else if (!obj->velx) {
  64:         if (!rand_mod(4))
  65:             obj->image = rand_mod(2) ? '<' : '>';
  66:         obj->velx = obj->image == '<' ? 1 : -1;
  67:         }
  68:     }
  69:     obj->vely += (rand_mod(222) - 111) / 100;
  70:     if (!(rand_mod(100))) {
  71:         setimage(obj, (obj->velx *= -1) < 0 ? '>' : '<');
  72:     }
  73:     }
  74:     if (numamoebas) {
  75:     if (!rand_mod(3))
  76:         nuke->velx = nuke->vely = 0;
  77:     if (nuke->strategy && ambsize < 90 && !rand_mod(200-smarts))
  78:         modify_amoeba(0,0,0,'~',(int)rand_mod(10));
  79:     if (ambsize > 200 || (ambsize > 100 && !rand_mod(15)))
  80:         modify_amoeba(yamblast,xamblast,2,' ',(ambsize-100)/5);
  81:     }
  82:     for (curkl = enemies; curkl->type == Enemy; curkl = curkl->next) {
  83:     if ((curkl->flags & (CLOAKS|FRIENDLY)) == CLOAKS &&
  84:         (curkl->image != ' ') &&
  85:         (curkl->energy > 300 || massacre) ) {
  86:         setimage(curkl, ' ');
  87:     }
  88:     if (madgorns)
  89:         prob = 3;
  90:     else if (curkl->vely || curkl->velx)
  91:         prob = massacre?10:20;
  92:     else if ((curkl->flags & (PIRATE|FRIENDLY)) == PIRATE) {
  93:                 /* pirates want to sit sometimes */
  94:         if (curkl->strategy) {
  95:         if ((obj = lookimg(curkl->posy, curkl->posx, '@')) ||
  96:             (obj = lookimg(curkl->posy, curkl->posx, 'B')) ) {
  97:             make_plink(obj->posy, obj->posx);
  98:             if (!--curkl->strategy) {   /* clock ran down */
  99:             if (obj->image == '@') {
 100:                 obj->image = '*';
 101:                 numinhab--;
 102:                 if (obj->flags & STATIC)
 103:                 mvaddch(obj->posy+1,obj->posx*2,obj->image);
 104:                 if (curkl->energy < 20000)
 105:                 curkl->energy += 5000;
 106:             }
 107:             prob = 2;   /* our work here is done */
 108:             }
 109:             else if (obj->image == 'B') {
 110:             btorp -= rand_mod(50);
 111:             if (btorp < 0)
 112:                 btorp = 0;
 113:             obj->energy -= rand_mod(500);
 114:             if (obj->energy < 0)
 115:                 obj->energy = 0;
 116:             prob = 10000;       /* stay here */
 117:             }
 118:             else
 119:             prob = 10000;
 120:         }
 121:         else {      /* it went away--go elsewhere */
 122:             prob = 4;
 123:             curkl->strategy = 0;
 124:         }
 125:         }
 126:         else if (lookimg(curkl->posy, curkl->posx, '@') ||
 127:              lookimg(curkl->posy, curkl->posx, 'B')) {
 128:         curkl->strategy = rand_mod(15)+5;
 129:         prob = 10000;
 130:         }
 131:         else
 132:         prob = 4;
 133:     }
 134:     else if (curkl->image == 'M') { /* Mudd wants to sit sometimes */
 135:         if ((obj = lookimg(curkl->posy, curkl->posx, 'E')) ||
 136:         (obj = lookimg(curkl->posy, curkl->posx, 'B')) ) {
 137:         if (obj->image == 'B') {
 138:             btorp -= rand_mod(40);
 139:             if (btorp < 0)
 140:             btorp = 0;
 141:             obj->energy -= rand_mod(100);
 142:             if (obj->energy < 0)
 143:             obj->energy = 0;
 144:         }
 145:         else if (!obj->vely && !obj->velx) {
 146:             etorp -= rand_mod(10);
 147:             if (etorp < 0)
 148:             etorp = 0;
 149:             obj->energy -= rand_mod(20);
 150:             if (obj->energy < 0)
 151:             obj->energy = 0;
 152:         }
 153:         prob = 10000;       /* stay here */
 154:         }
 155:         else        /* it went away--go elsewhere */
 156:         prob = 4;
 157:     }
 158:     else if (curkl->flags & FRIENDLY) {
 159:         if (curkl->energy < 10000 &&
 160:           lookimg(curkl->posy, curkl->posx, '@') ) {
 161:         curkl->energy += 100;
 162:         prob = 20;  /* do some loading */
 163:         }
 164:         else
 165:         prob = 4;
 166:     }
 167:     else if (curkl->image == '&') {
 168:         if (curkl->flags & COUNTDOWN) {
 169:         if (curkl->strategy)
 170:             curkl->strategy--;
 171:         else
 172:             curkl->flags &= ~COUNTDOWN;
 173:         prob = 100; /* someone's feeding us, so sit still */
 174:         }
 175:         else
 176:         prob = 4;
 177:     }
 178:     else
 179:         prob = 4;           /* don't sit still too long */
 180:     count = 11;
 181:     for (;;) {
 182:         if (--count <= 0)       /* no opening, just ram something */
 183:         break;
 184: 
 185: #ifdef lint
 186:         prob = prob;
 187: #endif
 188:         if (!(rand_mod(prob)))  /* turn randomly occasionally */
 189:         goto accell;
 190: 
 191:         y=(curkl->posy+curkl->vely+YSIZE00)%YSIZE;  /* find prospective */
 192:         x=(curkl->posx+curkl->velx+XSIZE00)%XSIZE;  /*   new position */
 193: 
 194:         if (numamoebas) {
 195:         if (curkl == nuke) {
 196:             if (amb[y][x] != '~')
 197:             goto accell;    /* never move nucleus from protoplasm */
 198:         }
 199:         else {
 200:             if (amb[y][x] == '~' && rand_mod(2)) {
 201:             yamblast = y;
 202:             xamblast = x;
 203:             goto accell;
 204:             }
 205:         }
 206:         }
 207: 
 208:         obj = occupant[y][x];
 209:         if (!obj) break;        /* is anyone there? */
 210: 
 211:         switch (obj->type) {
 212:         case Star:
 213:         if (obj->image == '@' && (curkl->flags & PIRATE)) {
 214:             if (curkl->image != 'P' && curkl->image != ' ') {
 215:             if (curkl->flags & FRIENDLY) {
 216:                 curkl->flags &= ~FRIENDLY;
 217:                 curkl->energy += 1000;
 218:                 possiblescore += curkl->mass;
 219:                 inumfriends--;
 220:                 numfriends--;
 221:                 inumenemies++;
 222:                 numenemies++;
 223:             }
 224:             curkl->image = 'P';
 225:             }
 226:             break;      /* go ahead and ram the star */
 227:         }
 228:         goto accell;        /* try not to ram stars */
 229:         case Torp:
 230:         if (!obj->vely && !obj->velx && (rand_mod(100) <= smarts) &&
 231:           (obj->image == 'o' || obj->image == 'O' || obj->image == 'X'))
 232:             goto accell;    /* try not to ram "friendly" torps */
 233:         break;
 234:         case Web:
 235:         if (curkl->image != 'T')
 236:             goto accell;    /* non-Tholians shouldn't ram web */
 237:         if (count <= 5)
 238:             break;      /* Tholians retrace web if desperate */
 239:         if (obj->image ==
 240:             (curkl->vely?
 241:              (curkl->velx?
 242:               (curkl->velx==curkl->vely?
 243:                '\\'
 244:               :
 245:                '/'
 246:               )
 247:              :
 248:               '|'
 249:              )
 250:             :
 251:              '-'
 252:             )
 253:            ) goto accell;   /* Tholians try not to retrace web */
 254:         break;          /* No problem with crossing web */
 255:         }
 256:         break;          /* okay to move over object */
 257: 
 258:     accell:
 259:         /* determine maximum velocity */
 260:         if (massacre && curkl->image != 'T') {
 261:         curkl->vely = rand_mod(7) - 3;
 262:         curkl->velx = rand_mod(7) - 3;
 263:         }
 264:         else if (curkl->image == '&') {
 265:         if (rand_mod(2)) {
 266:             curkl->vely = rand_mod(3) - 1;
 267:             curkl->velx = rand_mod(3) - 1;
 268:         }
 269:         else {
 270:             curkl->vely = curkl->strategy & 3;
 271:             if (curkl->vely & 2)
 272:             curkl->vely = -1;
 273:             curkl->velx = (curkl->strategy >> 2) & 3;
 274:             if (curkl->velx & 2)
 275:             curkl->velx = -1;
 276:         }
 277:         }
 278:         else if (curkl->energy >= 2500 && curkl->image != 'T') {
 279:         curkl->vely = rand_mod(5) - 2;
 280:         curkl->velx = rand_mod(5) - 2;
 281:         }
 282:         else {
 283:         curkl->vely = rand_mod(3) - 1;
 284:         curkl->velx = rand_mod(3) - 1;
 285:         }
 286:     }
 287:     if (count != 10) {
 288:         if (curkl->image == ' ') {
 289:         setimage(curkl, curkl->flags & PIRATE ? 'P' : 'R');
 290:         }
 291:         if (!count) {
 292:         curkl->vely = 0;
 293:         curkl->velx = 0;
 294:         }
 295:     }
 296:     if (curkl->image == 'G' && (base||ent) &&
 297:         !rand_mod((103-smarts)*10) ) {
 298:         int xxx,yyy;
 299: 
 300:         for (xxx = -1; xxx<=1; xxx++)
 301:         for (yyy = -1; yyy<=1; yyy++)
 302:             if ((xxx||yyy) && rand_mod(2))
 303:             fire_torp(curkl,yyy,xxx);
 304:     }
 305:     else if (curkl->image == 'T' && (curkl->velx || curkl->vely)) {
 306:         Make_object(Web,
 307:             curkl->vely?
 308:          (curkl->velx?
 309:           (curkl->velx==curkl->vely?
 310:            '\\'
 311:           :
 312:            '/'
 313:           )
 314:          :
 315:           '|'
 316:          )
 317:         :
 318:          '-',
 319:         curkl->posy,curkl->posx,0,0,32767L,32767L,&root);
 320:         if (obj && obj->type == Web) {
 321:         unmake_object(obj);
 322:         occupant[y][x] = Null(OBJECT*);
 323:         }
 324:     }
 325:     }
 326:     /* klingon-style fighting */
 327:     if (numamoebas)
 328:     attack(nuke);
 329:     attack(base);
 330:     if (ent && (!cloaked || ent->image=='E' || ent->image=='e'))
 331:     attack(ent);
 332: }
 333: 
 334: void
 335: modify_amoeba(y,x,where,ch,quant)
 336: Reg1 int y;
 337: Reg2 int x;
 338: int where;
 339: Reg6 int ch;
 340: Reg7 int quant;
 341: {
 342:     Reg3 int dy;
 343:     Reg4 int dx;
 344:     Reg5 int count = 15;
 345: 
 346:     if (!numamoebas)
 347:     return;
 348:     if (!where || (where==1 && rand_mod(2))) {
 349:     y = nuke->posy;
 350:     x = nuke->posx;
 351:     }
 352:     if (nuke->strategy && rand_mod(3)) {
 353:     dy = nuke->strategy & 3;
 354:     if (dy & 2)
 355:         dy = -1;
 356:     dx = (nuke->strategy >> 2) & 3;
 357:     if (dx & 2)
 358:         dx = -1;
 359:     if (ch == ' ') {        /* take from the tail */
 360:         dy = -dy;
 361:         dx = -dx;
 362:     }
 363:     if (!rand_mod(100))
 364:         nuke->strategy = rand_mod(256);
 365:     }
 366:     else {
 367:     dy = rand_mod(3) - 1;
 368:     dx = rand_mod(3) - 1;
 369:     }
 370:     if (!dy && !dx)
 371:     return;
 372:     do {
 373:     if (--count < 0)
 374:         return;
 375:     y = (y + dy + YSIZE00) % YSIZE;
 376:     x = (x + dx + XSIZE00) % XSIZE;
 377:     } while (amb[y][x] != ' ');
 378:     if (ch == ' ') {
 379:     y = (y - dy + YSIZE00) % YSIZE;
 380:     x = (x - dx + XSIZE00) % XSIZE;
 381:     }
 382:     if (ambsize > 100 && quant > 2) {
 383:     quant >>= (ambsize/100);
 384:     }
 385:     if ((nuke->energy += quant << 6) > 32767)
 386:     nuke->energy = 32767;
 387:     count = quant << 3;     /* endless loop catcher */
 388:     while (count-- > 0 && quant > 0) {
 389:     if (amb[y][x] != ch) {
 390:         quant--;
 391:         amb[y][x] = ch;
 392:         if (ch == '~') {
 393:         ambsize++;
 394:         yblasted[y] |= 2;
 395:         xblasted[x] |= 2;
 396:         blasted = TRUE;
 397:         }
 398:         else
 399:         ambsize--;
 400:         if (!occupant[y][x])
 401:         mvaddch(y+1,x*2,ch);
 402:     }
 403:     y = (y + rand_mod(3) + YSIZE99) % YSIZE;
 404:     x = (x + rand_mod(3) + XSIZE99) % XSIZE;
 405:     }
 406: }

Defined functions