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

   1: /* $Header: weapon.c,v 7.0.1.2 86/10/20 14:36:33 lwall Exp $ */
   2: 
   3: /* $Log:	weapon.c,v $
   4:  * Revision 7.0.1.2  86/10/20  14:36:33  lwall
   5:  * Picked some lint.
   6:  *
   7:  * Revision 7.0.1.1  86/10/16  10:54:42  lwall
   8:  * Added Damage.  Fixed random bugs.
   9:  *
  10:  * Revision 7.0  86/10/08  15:18:08  lwall
  11:  * Split into separate files.  Added amoebas and pirates.
  12:  *
  13:  */
  14: 
  15: #include "EXTERN.h"
  16: #include "warp.h"
  17: #include "bang.h"
  18: #include "object.h"
  19: #include "move.h"
  20: #include "score.h"
  21: #include "sig.h"
  22: #include "term.h"
  23: #include "them.h"
  24: #include "us.h"
  25: #include "util.h"
  26: #include "INTERN.h"
  27: #include "weapon.h"
  28: 
  29: void
  30: weapon_init()
  31: {
  32:     ;
  33: }
  34: 
  35: void
  36: fire_torp(from, ydir, xdir)
  37: Reg1 OBJECT *from;
  38: Reg3 int ydir;
  39: Reg4 int xdir;
  40: {
  41:     Reg2 OBJECT *to;
  42: 
  43:     if (from->type == Enemy ||
  44:        (from == ent && etorp > 0) ||
  45:        (from == base && btorp > 0)) {
  46:     to = occupant[(from->posy+from->vely+ydir+YSIZE00)%YSIZE]
  47:              [(from->posx+from->velx+xdir+XSIZE00)%XSIZE];
  48:     if (from->type != Enemy || !to || to->vely || to->velx) {
  49:         if (from->type != Enemy &&
  50:          (to = isatorp[from==base][ydir+1][xdir+1])) {
  51:         to->vely += ydir;
  52:         to->velx += xdir;
  53:         }
  54:         else {
  55:         if (from == ent) {
  56:             to = make_object(Torp, '+', from->posy,from->posx,
  57:             from->vely+ydir,from->velx+xdir, 0L, 1L,&root);
  58:             aretorps++;
  59:             isatorp[0][ydir+1][xdir+1] = to;
  60:             etorp--;
  61:         }
  62:         else if (from == base) {
  63:             to = make_object(Torp, '+', from->posy,from->posx,
  64:             from->vely+ydir,from->velx+xdir, 0L, 1L,&root);
  65:             aretorps++;
  66:             isatorp[1][ydir+1][xdir+1] = to;
  67:             btorp--;
  68:         }
  69:         else if (from->image == 'G') {
  70:             numos++;
  71:             to = make_object(Torp, 'o', from->posy,from->posx,
  72:             from->vely+ydir,from->velx+xdir, 100L, 1L,&root);
  73:             if (madgorns) {
  74:             possiblescore += 35;
  75:             to->image = '0';
  76:             to->mass = 2000;
  77:             to->energy = 2000;
  78:             }
  79:             else if (rand_mod(120)+10 > smarts)
  80:             possiblescore += 100;
  81:             else {
  82:             possiblescore += 200;
  83:             to->image = 'O';
  84:             }
  85:         }
  86:         else {
  87:             to = make_object(Torp, 'x', from->posy,from->posx,
  88:             from->vely+ydir,from->velx+xdir, 0L, 1L,&root);
  89:             if (rand_mod(160)+10 > smarts)
  90:             possiblescore += 10;
  91:             else {
  92:             possiblescore += 100;
  93:             to->image = 'X';
  94:             to->mass = 1000+super*20;
  95:             numxes++;
  96:             }
  97:         }
  98:         }
  99:     }
 100:     }
 101: }
 102: 
 103: void
 104: attack(attackee)
 105: Reg7 OBJECT *attackee;
 106: {
 107:     Reg1 int dx;
 108:     Reg2 int dy;
 109:     Reg3 int curx;
 110:     Reg4 int cury;
 111:     Reg5 int prob;
 112:     Reg6 OBJECT *obj;
 113:     Reg8 bool torps;
 114:     Reg9 bool webnear = FALSE;
 115:     Reg10 bool thru_stars;
 116:     int nukey;
 117:     int nukex;
 118:     int nukedist;
 119: 
 120:     if (attackee) {
 121:     if (attackee == nuke) {
 122:         if (amb[attackee->posy][attackee->posx] != '~')
 123:         return;
 124:         nukey = nukex = 0;
 125:         nukedist = 100;
 126:     }
 127:     for (dx= -1; dx<=1 ; dx++) {
 128:         for (dy= -1; dy<=1; dy++) {
 129:         if (dx||dy) {
 130:             cury = attackee->posy;
 131:             curx = attackee->posx;
 132:             torps = thru_stars = FALSE;
 133:             if (massacre || madgorns || !rand_mod(53-super) )
 134:             webnear += rand_mod(2);
 135:             else
 136:             webnear = FALSE;
 137:             for (prob = scandist;prob;prob--) {
 138:             cury = (cury + dy + YSIZE00) % YSIZE;
 139:             curx = (curx + dx + XSIZE00) % XSIZE;
 140:             if (obj = occupant[cury][curx]) {
 141:                 switch (obj->image) {
 142:                 case 'P': case 'K': case 'R': case ' ':
 143:         pot_shot:
 144:                 if (attackee == nuke) {
 145:                     if (rand_mod(2+scandist-prob) <
 146:                       rand_mod(smarts/40+1))
 147:                     Tract(nuke,dy,dx,rand_mod(3)?1:-1);
 148:                 }
 149:                 if (rand_mod(51 - sm50) <= prob) {
 150:                     switch (obj->strategy||thru_stars?0:
 151:                       rand_mod(ent?4:2)) {
 152:                     case 1: case 2:
 153:                     if (-dy + attackee->vely == obj->vely
 154:                      && -dx + attackee->velx == obj->velx)
 155:                         fire_torp(obj,
 156:                          -dy + attackee->vely,
 157:                          -dx + attackee->velx);
 158:                     else
 159:                         fire_torp(obj,
 160:                          -dy + attackee->vely - obj->vely,
 161:                          -dx + attackee->velx - obj->velx);
 162:                     if (obj->image == ' ')
 163:                         setimage(obj,
 164:                           obj->flags & PIRATE ? 'P' : 'R');
 165:                     break;
 166:                     case 3: {
 167:                     int newspeed =
 168:                         rand_mod(prob<5&&smarts>70?4:3)-1;
 169: 
 170:                     obj->vely = -dy * newspeed;
 171:                     obj->velx = -dx * newspeed;
 172:                     if (newspeed >= 0 &&
 173:                         !rand_mod(82-sm80)) {
 174:                         obj->vely += attackee->vely;
 175:                         obj->velx += attackee->velx;
 176:                     }
 177:                     break;
 178:                     }
 179:                     case 0:
 180:                     if (!torps && obj->energy > 1000) {
 181:                         fire_phaser(obj, -dy, -dx);
 182:                         if (smarts > 40 &&
 183:                            (scandist-prob > 5
 184:                         || attackee==base) &&
 185:                            (massacre || obj->strategy ||
 186:                             rand_mod(2)))
 187:                         while (rand_mod(2))
 188:                             fire_phaser(obj, -dy, -dx);
 189:                         if (obj->image == ' ')
 190:                         setimage(obj,
 191:                           obj->flags&PIRATE ? 'P':'R');
 192:                     }
 193:                     if (obj->strategy) {
 194:                         obj->velx = obj->vely = 0;
 195:                         if (obj->energy < 1000 ||
 196:                           bvely || bvelx)
 197:                         obj->strategy = 0;
 198:                     }
 199:                     else if ((attackee==base ||
 200:                           (cloaking && attackee==ent)
 201:                          ) &&
 202:                          scandist-prob > 5 &&
 203:                              !(rand_mod(
 204:                            ent?antibase*2:antibase)) )
 205:                         obj->strategy = 1;
 206:                     break;
 207:                     }
 208:                 }
 209:                 goto bombout;
 210:                 case 'G':
 211:                 if (thru_stars && obj->strategy < 7)
 212:                     goto bombout;
 213:                 if (attackee == nuke) {
 214:                     if (rand_mod(2+scandist-prob) <
 215:                       rand_mod(smarts/40+1))
 216:                     Tract(nuke,dy,dx,rand_mod(3)?1:-1);
 217:                     goto bombout;
 218:                 }
 219:                 if (obj->strategy) {
 220:                     if (madgorns || !rand_mod(4)) {
 221:                     obj->vely = attackee->vely;
 222:                     obj->velx = attackee->velx;
 223:                     }
 224:                     obj->strategy += (!torps && deados > 10);
 225:                     if (obj->strategy > 4)
 226:                     madgorns = TRUE;
 227:                     if (!torps && obj->strategy > 5) {
 228:                     do {
 229:                         fire_phaser(obj, -dy, -dx);
 230:                     } while (rand_mod(2));
 231:                     }
 232:                 }
 233:                 else if (numgorns >= numenemies-1 &&
 234:                     deados > 15+numgorns*5)
 235:                     obj->strategy = 1;
 236:                 if (madgorns || rand_mod(51 - sm50) <= prob) {
 237:                     if (-dy + attackee->vely == obj->vely
 238:                      && -dx + attackee->velx == obj->velx)
 239:                     fire_torp(obj,
 240:                      -dy + attackee->vely,
 241:                      -dx + attackee->velx);
 242:                     else
 243:                     fire_torp(obj,
 244:                      -dy + attackee->vely - obj->vely,
 245:                      -dx + attackee->velx - obj->velx);
 246:                 }
 247:                 goto bombout;
 248:                 case 'T':
 249:                 if (attackee == nuke) {
 250:                     if (rand_mod(2+scandist-prob) <
 251:                       rand_mod(smarts/40+1))
 252:                     Tract(nuke,dy,dx,rand_mod(3)?1:-1);
 253:                 }
 254:                 if (thru_stars)
 255:                     goto bombout;
 256:                 if (webnear && scandist-prob > 5) {
 257:                     if (massacre || rand_mod(50) < super) {
 258:                     if (!torps && obj->energy > 1000) {
 259:                         fire_phaser(obj, -dy, -dx);
 260:                         while (!rand_mod(57-sm55))
 261:                         fire_phaser(obj, -dy, -dx);
 262:                     }
 263:                     }
 264:                 }
 265:                 goto bombout;
 266:                 case 'C': case 'c':
 267:                 if (thru_stars)
 268:                     goto bombout;
 269:                 break;
 270:                 case 'Q': case 'W': case 'Y': case 'U':
 271:                 case 'I': case 'S': case 'D': case 'H': case 'J':
 272:                 case 'L': case 'Z': case 'V': case 'M': case 'F':
 273:                 if (attackee == nuke) {
 274:                     if (rand_mod(2+scandist-prob) <
 275:                       rand_mod(smarts/40+1))
 276:                     Tract(nuke,dy,dx,rand_mod(3)?1:-1);
 277:                     if (rand_mod(2))
 278:                     goto pot_shot;
 279:                 }
 280:                 if (madfriends > 1000) {
 281:                     madfriends -= 200;
 282:                     goto pot_shot;
 283:                 }
 284:                 /* FALL THROUGH */
 285:                 case '+':
 286:                 if (attackee == nuke) {
 287:                     if (smarts > 70) {
 288:                     if (
 289:                      (obj->posx + obj->velx + XSIZE00)%XSIZE
 290:                         == attackee->posx &&
 291:                      (obj->posy + obj->vely + YSIZE00)%YSIZE
 292:                         == attackee->posy ) {
 293:                         Tract(nuke,dy,dx,-1);
 294:                     }
 295:                     else
 296:                         while (!rand_mod(82-sm80))
 297:                         Tract(nuke,dy,dx,-1);
 298:                     }
 299:                     else if (smarts > 60 ||
 300:                       rand_mod(2+scandist-prob) <
 301:                       rand_mod(smarts/20+1))
 302:                     Tract(nuke,dy,dx,rand_mod(3)?1:-1);
 303:                 }
 304:                 torps = FALSE;
 305:                 thru_stars = FALSE;
 306:                 break;
 307:                 case '|': case '-': case '/': case '\\':
 308:                 if (thru_stars)
 309:                     goto bombout;
 310:                 webnear = (scandist-prob < 3);
 311:                 torps = FALSE;
 312:                 break;
 313:                 case 'x':
 314:                 if (attackee == nuke) {
 315:                     if (rand_mod(2+scandist-prob) <
 316:                       rand_mod(smarts/20+1))
 317:                     Tract(nuke,dy,dx,rand_mod(3)?1:-1);
 318:                 }
 319:                 if (thru_stars)
 320:                     goto bombout;
 321:                 torps = TRUE;
 322:                 break;
 323:                 case 'o': case 'O': case '0':
 324:                 if (attackee == nuke) {
 325:                     if (rand_mod(2+scandist-prob) <
 326:                       rand_mod(smarts/20+1))
 327:                     Tract(nuke,dy,dx,rand_mod(3)?1:-1);
 328:                 }
 329:                 if (thru_stars)
 330:                     goto bombout;
 331:                 torps = TRUE;
 332:                 if (rand_mod(99+3*scandist) < smarts+3*prob) {
 333:                     obj->vely = -dy + attackee->vely;
 334:                     obj->velx = -dx + attackee->velx;
 335:                     if (obj->flags & STATIC) {/* not a mover? */
 336:                     obj->flags &= ~STATIC;
 337:                     obj->prev->next = obj->next;
 338:                     obj->next->prev = obj->prev;
 339:                     root.prev->next = obj;
 340:                     obj->prev = root.prev;
 341:                     root.prev = obj;
 342:                     obj->next = &root;
 343:                     }
 344:                 }
 345:                 if (obj->image != '0')
 346:                     break;
 347:                 /* DROP THROUGH! */
 348:                 case 'X':
 349:                 if (attackee == nuke) {
 350:                     if (rand_mod(2+scandist-prob) <
 351:                       rand_mod(smarts/20+1))
 352:                     Tract(nuke,dy,dx,rand_mod(3)?1:-1);
 353:                 }
 354:                 torps = TRUE;
 355:                 if (thru_stars)
 356:                     goto bombout;
 357:                 if (prob == scandist) {
 358:                     int y, x;
 359: 
 360:                     blast[y=(obj->posy+obj->vely+YSIZE00)%YSIZE]
 361:                      [x=(obj->posx+obj->velx+XSIZE00)%XSIZE]
 362:                       += (obj->image == '0' ? 2000 : 200);
 363:                     yblasted[y] |= 1;
 364:                     xblasted[x] |= 1;
 365:                     blasted = TRUE;
 366:                 }
 367:                 break;
 368:                 case 'A':
 369:                 if (attackee != nuke) {
 370:                     if (scandist-prob>1 && !rand_mod(51-super))
 371:                     Tract(obj,-dy,-dx,1);
 372:                 }
 373:                 /* FALL THROUGH */
 374:                 case '*': case '@':
 375:                 if (attackee == nuke) {
 376:                     if (amb[cury][curx] != '~') {
 377:                     if (scandist-prob < nukedist) {
 378:                         nukedist = scandist-prob;
 379:                         nukey = dy; /* nearest food in */
 380:                         nukex = dx; /*   this direction */
 381:                     }
 382:                     if (smarts > 55 && scandist-prob > 8) {
 383:                         if (rand_mod(30+scandist-prob) <
 384:                           rand_mod(smarts/20+1))
 385:                         Tract(nuke,dy,dx,1);
 386:                     }
 387:                     }
 388:                     else if (obj->vely || obj->velx) {
 389:                     Tract(nuke,dy,dx,1); /* for looks */
 390:                     obj->vely = obj->velx = 0;
 391:                     }
 392:                 }
 393:                 if (!thru_stars)
 394:                     if (rand_mod(97-sm95))
 395:                     goto bombout;
 396:                     else
 397:                     thru_stars = TRUE;
 398:                 break;
 399:                 case '<': case '>':
 400:                 if (attackee == nuke) {
 401:                     if ((!dy && scandist-prob < 8) ||
 402:                       rand_mod(2+scandist-prob) <
 403:                       rand_mod(smarts/20+1) ) {
 404:                     nuke->mass += 10000;
 405:                     Tract(nuke,dy,dx,-1);
 406:                     nuke->mass -= 10000;
 407:                     }
 408:                 }
 409:                 goto bombout;
 410:                 case 'E': case 'B':
 411:                 if (attackee == nuke) {
 412:                     if (rand_mod(2+scandist-prob) <
 413:                       rand_mod(smarts/40+1))
 414:                     Tract(nuke,dy,dx,rand_mod(3)?1:-1);
 415:                 }
 416:                 goto bombout;
 417:                 default:
 418:                 goto bombout;
 419:                 }
 420:             }
 421:             else {
 422:                 if (thru_stars)
 423:                 goto bombout;
 424:             }
 425:             }
 426: bombout:            ; /* end of loop */
 427:         }
 428:         }
 429:     }
 430:     if (attackee == nuke && nukedist < 100) {/* aim amoeba at nearest */
 431:         if (nukey < 0)          /*   free star */
 432:         nukey = 2;
 433:         if (nukex < 0)
 434:         nukex = 2;
 435:         nuke->strategy = nukey + (nukex << 2);
 436:     }
 437:     }
 438: }
 439: 
 440: void
 441: fire_phaser(obj, dy, dx)
 442: Reg7 OBJECT *obj;
 443: Reg5 int dy;
 444: Reg6 int dx;
 445: {
 446:     Reg1 int y;
 447:     Reg2 int x;
 448:     Reg3 int skipping;
 449:     Reg4 int size=5000;
 450:     int decr = 50, oldy, oldx;
 451:     static char curchar[] = "@* ";
 452: 
 453:     if (obj == ent)
 454:     decr = 100;
 455:     else if (obj == base) {
 456:     decr = 1000;
 457:     size = 200;
 458:     }
 459:     if (!dy)
 460:     curchar[2] = '-';
 461:     else if (!dx)
 462:     curchar[2] = '!';
 463:     else if (dy == dx)
 464:     curchar[2] = '\\';
 465:     else
 466:     curchar[2] = '/';
 467:     if (obj->energy >= decr) {
 468:     obj->energy -= decr;
 469:     for (
 470:       /* initialize */
 471:       skipping = (obj != base),
 472:       y = (obj->posy+(obj==base?dy*2:dy)+YSIZE00)%YSIZE,
 473:       x = (obj->posx+(obj==base?dx*2:dx)+XSIZE00)%XSIZE;
 474:       /* while */
 475:       size && (!occupant[y][x]||(skipping && occupant[y][x]->type==Star));
 476:       /* at end of loop */
 477:       y = (y+dy+YSIZE00) % YSIZE,
 478:       x = (x+dx+XSIZE00) % XSIZE,
 479:       size = size * 3 / 4 ) {
 480:         move(y+1,x*2,0);
 481:         beg_qwrite();
 482:         if (obj == base || obj->image == 'T') {
 483:         *filler = '@';
 484:         qwrite();
 485:         *filler = '#';
 486:         qwrite();
 487:         *filler = '~';
 488:         qwrite();
 489:         *filler = '%';
 490:         qwrite();
 491:         *filler = ':';
 492:         qwrite();
 493:         *filler = '@';
 494:         }
 495:         else {
 496:         *filler = size >= 500 ?
 497:               *curchar : (size >= 50 ?
 498:                      curchar[1] :
 499:                      curchar[2]);
 500:         }
 501:         qwrite();
 502:         if (occupant[y][x])
 503:         qaddc(occupant[y][x]->image);
 504:         else {
 505:         if (numamoebas)
 506:             qaddc(amb[y][x]);
 507:         else
 508:             qaddspace();
 509:         if (skipping)
 510:             skipping = 0;
 511:         }
 512:         end_qwrite();
 513:     }
 514:     if (size) {
 515:         char img;
 516: 
 517:         assert(occupant[y][x]);
 518:         img = occupant[y][x]->image;
 519:         if (occupant[y][x]->type == Crusher) {
 520:         if (dy)
 521:             return;
 522:             if (dx==(img == '<' ? 1 : -1) ) {
 523:             occupant[y][x]->image =
 524:             (occupant[y][x]->velx *= -1) < 0 ? '>' : '<';
 525:             return;
 526:         }
 527:         }
 528:         else if (occupant[y][x]->flags & FRIENDLY)
 529:         madfriends += 200;
 530:         if (numamoebas && amb[y][x] == '~' && smarts % 3 &&
 531:         (smarts > 70 || rand_mod(smarts) > rand_mod(20)) ) {
 532:         if (size > 10000)
 533:             modify_amoeba(y,x,1,'~',10);
 534:         else if (size > 1000)
 535:             modify_amoeba(y,x,1,'~',7);
 536:         else if (size > 50)
 537:             modify_amoeba(y,x,1,'~',5);
 538:         else
 539:             modify_amoeba(y,x,1,'~',2);
 540:         if (occupant[y][x] == nuke) {
 541:             nuke->strategy = rand_mod(30);
 542:             nuke->flags |= COUNTDOWN;
 543:         }
 544:         return;
 545:         }
 546:         else {
 547:         move(y+1,x*2,0);
 548:         beg_qwrite();
 549:         if (img == ' ') {
 550:             *filler = occupant[y][x]->flags & PIRATE ? 'P' : 'R';
 551:             occupant[y][x]->image = *filler;
 552:             occupant[y][x]->strategy = 0;
 553:             qwrite();
 554:             qwrite();
 555:         }
 556:         else if (img == 'C' || img == 'c') {
 557:             cloaked = 0;
 558:             img += 2;
 559:             occupant[y][x]->image = img;
 560:             *filler = img;
 561:             qwrite();
 562:             qwrite();
 563:         }
 564:         else if (img == 'K' && size > 50)
 565:             occupant[y][x]->strategy = 0;
 566:         *filler = '@';
 567:         qwrite();
 568:         *filler = '#';
 569:         qwrite();
 570:         *filler = '@';
 571:         qwrite();
 572:         *filler = '#';
 573:         qwrite();
 574:         *filler = '@';
 575:         qwrite();
 576:         qaddc(img);
 577:         end_qwrite();
 578:         oldy = y;
 579:         oldx = x;
 580:         y = (occupant[oldy][oldx]->posy + occupant[oldy][oldx]->vely +
 581:             YSIZE00) % YSIZE;
 582:         x = (occupant[oldy][oldx]->posx + occupant[oldy][oldx]->velx +
 583:             XSIZE00) % XSIZE;
 584:         if (occupant[y][x] && occupant[y][x]->type == Star) {
 585:             y = occupant[oldy][oldx]->posy;
 586:             x = occupant[oldy][oldx]->posx;
 587:         }
 588:         if (obj==base)
 589:             blast[y][x] += size>50 ? 15000 : (size>15 ? 1500 : 150);
 590:         else if (obj==ent)
 591:             blast[y][x] += size*4;
 592:         else if (obj->image=='T')
 593:             blast[y][x] += 15000;
 594:         else
 595:             blast[y][x] += size*smarts/25;
 596:         yblasted[y] |= 1;
 597:         xblasted[x] |= 1;
 598:         blasted = TRUE;
 599:         }
 600:     }
 601:     }
 602: }
 603: 
 604: int
 605: tract(obj, dy, dx, to_or_fro)
 606: Reg7 OBJECT *obj;
 607: Reg4 int dy;
 608: Reg5 int dx;
 609: int to_or_fro;
 610: {
 611:     Reg1 int y;
 612:     Reg2 int x;
 613:     Reg3 int size=10;
 614:     static char ch;
 615:     Reg6 OBJECT *tractee;
 616: 
 617:     if (!dy)
 618:     ch = '|';
 619:     else if (!dx)
 620:     ch = '-';
 621:     else if (dy == dx)
 622:     ch = '/';
 623:     else
 624:     ch = '\\';
 625:     {
 626:     for (
 627:       y = (obj->posy+dy+YSIZE00)%YSIZE,
 628:       x = (obj->posx+dx+XSIZE00)%XSIZE;
 629:       size && (!occupant[y][x]);
 630:       y = (y+dy+YSIZE00) % YSIZE, x = (x+dx+XSIZE00) % XSIZE, size--) {
 631:         move(y+1,x*2,0);
 632:         beg_qwrite();
 633:         *filler = ch;
 634:         qwrite();
 635:         qwrite();
 636:         if (numamoebas)
 637:         qaddch(amb[y][x]);
 638:         else
 639:         qaddspace();
 640:         end_qwrite();
 641:     }
 642:     tractee = occupant[y][x];
 643:     if (size) {
 644:         assert(tractee);
 645:         if (numamoebas && obj != nuke && amb[y][x] == '~') {
 646:         if (to_or_fro > 0)
 647:             modify_amoeba(y,x,2,'~',size);
 648:         else
 649:             modify_amoeba(y,x,1,' ',size);
 650:         }
 651:         if (tractee->type != Web &&
 652:         (tractee->mass < obj->mass * 5 ||
 653:          (tractee->type == Crusher && !dx) ) ) {
 654:         if (tractee == ent) {
 655:             evely -= dy * to_or_fro;
 656:             evelx -= dx * to_or_fro;
 657:         }
 658:         else if (tractee == base) {
 659:             bvely -= dy * to_or_fro;
 660:             bvelx -= dx * to_or_fro;
 661:         }
 662:         else {
 663:             tractee->vely -= dy * to_or_fro;
 664:             tractee->velx -= dx * to_or_fro;
 665:         }
 666:         if (tractee->type == Torp ||
 667:             tractee->type == Star) {
 668:             if (tractee->flags & STATIC) {  /* not a mover? */
 669:             tractee->flags &= ~STATIC;
 670:             tractee->prev->next = tractee->next;
 671:             tractee->next->prev = tractee->prev;
 672:             root.prev->next = tractee;
 673:             tractee->prev = root.prev;
 674:             root.prev = tractee;
 675:             tractee->next = &root;
 676:             }
 677:         }
 678:         }
 679:         else if (tractee->type == Crusher && !dy &&
 680:           dx==(tractee->image == '<' ? 1 : -1) ) {
 681:         setimage(tractee, (tractee->velx *= -1) < 0 ? '>' : '<');
 682:         }
 683:         if (tractee->mass * 5 > obj->mass)
 684:         return(1);
 685:     }
 686:     }
 687:     return(0);
 688: }

Defined functions