Home | History | Annotate | Line # | Download | only in warp 
      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(void)
     39 {
     40     ;
     41 }
     42 
     43 void
     44 their_smarts(void)
     45 {
     46     OBJECT *curkl;
     47     OBJECT *obj = NULL;
     48     int prob;
     49     int count;
     50     int y = 0;
     51     int x = 0;
     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;
    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(int y, int x, int where, int ch, int quant)
    336 {
    337     int dy;
    338     int dx;
    339     int count = 15;
    340 
    341     if (!numamoebas)
    342 	return;
    343     if (!where || (where==1 && rand_mod(2))) {
    344 	y = nuke->posy;
    345 	x = nuke->posx;
    346     }
    347     if (nuke->strategy && rand_mod(3)) {
    348 	dy = nuke->strategy & 3;
    349 	if (dy & 2)
    350 	    dy = -1;
    351 	dx = (nuke->strategy >> 2) & 3;
    352 	if (dx & 2)
    353 	    dx = -1;
    354 	if (ch == ' ') {		/* take from the tail */
    355 	    dy = -dy;
    356 	    dx = -dx;
    357 	}
    358 	if (!rand_mod(100))
    359 	    nuke->strategy = rand_mod(256);
    360     }
    361     else {
    362 	dy = rand_mod(3) - 1;
    363 	dx = rand_mod(3) - 1;
    364     }
    365     if (!dy && !dx)
    366 	return;
    367     do {
    368 	if (--count < 0)
    369 	    return;
    370 	y = (y + dy + YSIZE00) % YSIZE;
    371 	x = (x + dx + XSIZE00) % XSIZE;
    372     } while (amb[y][x] != ' ');
    373     if (ch == ' ') {
    374 	y = (y - dy + YSIZE00) % YSIZE;
    375 	x = (x - dx + XSIZE00) % XSIZE;
    376     }
    377     if (ambsize > 100 && quant > 2) {
    378 	quant >>= (ambsize/100);
    379     }
    380     if ((nuke->energy += quant << 6) > 32767)
    381 	nuke->energy = 32767;
    382     count = quant << 3;		/* endless loop catcher */
    383     while (count-- > 0 && quant > 0) {
    384 	if (amb[y][x] != ch) {
    385 	    quant--;
    386 	    amb[y][x] = ch;
    387 	    if (ch == '~') {
    388 		ambsize++;
    389 		yblasted[y] |= 2;
    390 		xblasted[x] |= 2;
    391 		blasted = true;
    392 	    }
    393 	    else
    394 		ambsize--;
    395 	    if (!occupant[y][x])
    396 		mvaddch(y+1,x*2,ch);
    397 	}
    398 	y = (y + rand_mod(3) + YSIZE99) % YSIZE;
    399 	x = (x + rand_mod(3) + XSIZE99) % XSIZE;
    400     }
    401 }
    402