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

##### Functions

    attack            X
    fire_phaser       X
    fire_torp         X
    tract             X
    weapon_init       X

       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

attack defined in line 103; used 4 times

- in /usr/src/games/warp/them.c line 328-331(3)
- in /usr/src/games/warp/weapon.h line 19

fire_phaser defined in line 440; used 8 times

- in line 181, 188, 229, 259-261(2)
- in /usr/src/games/warp/us.c line 128-132(2)
- in /usr/src/games/warp/weapon.h line 20

fire_torp defined in line 35; used 9 times

- in line 155-159(2), 239-243(2)
- in /usr/src/games/warp/move.c line 451
- in /usr/src/games/warp/them.c line 303
- in /usr/src/games/warp/us.c line 154-158(2)
- in /usr/src/games/warp/weapon.h line 18

tract defined in line 604; used 3 times

- in /usr/src/games/warp/us.c line 62, 90
- in /usr/src/games/warp/weapon.h line 21

weapon_init defined in line 29; used 2 times

- in /usr/src/games/warp/warp.c line 299
- in /usr/src/games/warp/weapon.h line 22

Last modified: 1987-06-19 Generated: 2016-12-26 | Generated by src2html V0.67 page hit count: 1679 |