/* Header: them.c,v 7.0.1.5 86/12/12 17:05:41 lwall Exp */

/* Log:	them.c,v
 * Revision 7.0.1.5  86/12/12  17:05:41  lwall
 * Baseline for net release.
 *
 * Revision 7.0.1.4  86/10/20  12:32:38  lwall
 * Wasn't clearing FRIENDLY flag on pirate creation.
 *
 * Revision 7.0.1.3  86/10/20  12:15:33  lwall
 * Was trying to create pirates from cloaked pirates.
 *
 * Revision 7.0.1.2  86/10/17  10:03:44  lwall
 * Fixed Romulan writing spaces while cloaked.
 *
 * Revision 7.0.1.1  86/10/16  10:53:39  lwall
 * Added Damage.  Fixed random bugs.
 *
 * Revision 7.0  86/10/08  15:14:15  lwall
 * Split into separate files.  Added amoebas and pirates.
 *
 */

#include "EXTERN.h"
#include "warp.h"
#include "bang.h"
#include "object.h"
#include "move.h"
#include "score.h"
#include "term.h"
#include "us.h"
#include "util.h"
#include "weapon.h"
#include "INTERN.h"
#include "them.h"

void
them_init(void)
{
    ;
}

void
their_smarts(void)
{
    OBJECT *curkl;
    OBJECT *obj = NULL;
    int prob;
    int count;
    int y = 0;
    int x = 0;

    if (numcrushes && (obj=movers)->type == Crusher) {
	if (numamoebas) {
	    y = obj->posy;
	    x = (obj->posx+(obj->image=='<'?1:-1)+XSIZE00)%XSIZE;
	    if (amb[y][x] == '~') {
		obj->velx = 0;		/* stop and munch amoeba */
		modify_amoeba(y,x,1,' ',(int)rand_mod(5+ambsize/10)+1);
		if (occupant[y][x] == nuke)	/* except go for nucleus */
		    obj->velx = (obj->image=='<' ? 1 : -1);
	    }
	    else if (!obj->velx) {
		if (!rand_mod(4))
		    obj->image = rand_mod(2) ? '<' : '>';
		obj->velx = obj->image == '<' ? 1 : -1;
	    }
	}
	obj->vely += (rand_mod(222) - 111) / 100;
	if (!(rand_mod(100))) {
	    setimage(obj, (obj->velx *= -1) < 0 ? '>' : '<');
	}
    }
    if (numamoebas) {
	if (!rand_mod(3))
	    nuke->velx = nuke->vely = 0;
	if (nuke->strategy && ambsize < 90 && !rand_mod(200-smarts))
	    modify_amoeba(0,0,0,'~',(int)rand_mod(10));
	if (ambsize > 200 || (ambsize > 100 && !rand_mod(15)))
	    modify_amoeba(yamblast,xamblast,2,' ',(ambsize-100)/5);
    }
    for (curkl = enemies; curkl->type == Enemy; curkl = curkl->next) {
	if ((curkl->flags & (CLOAKS|FRIENDLY)) == CLOAKS &&
	    (curkl->image != ' ') &&
	    (curkl->energy > 300 || massacre) ) {
	    setimage(curkl, ' ');
	}
	if (madgorns)
	    prob = 3;
	else if (curkl->vely || curkl->velx)
	    prob = massacre?10:20;
	else if ((curkl->flags & (PIRATE|FRIENDLY)) == PIRATE) {
				/* pirates want to sit sometimes */
	    if (curkl->strategy) {
		if ((obj = lookimg(curkl->posy, curkl->posx, '@')) ||
		    (obj = lookimg(curkl->posy, curkl->posx, 'B')) ) {
		    make_plink(obj->posy, obj->posx);
		    if (!--curkl->strategy) {	/* clock ran down */
			if (obj->image == '@') {
			    obj->image = '*';
			    numinhab--;
			    if (obj->flags & STATIC)
				mvaddch(obj->posy+1,obj->posx*2,obj->image);
			    if (curkl->energy < 20000)
				curkl->energy += 5000;
			}
			prob = 2;	/* our work here is done */
		    }
		    else if (obj->image == 'B') {
			btorp -= rand_mod(50);
			if (btorp < 0)
			    btorp = 0;
			obj->energy -= rand_mod(500);
			if (obj->energy < 0)
			    obj->energy = 0;
			prob = 10000;		/* stay here */
		    }
		    else
			prob = 10000;
		}
		else {		/* it went away--go elsewhere */
		    prob = 4;
		    curkl->strategy = 0;
		}
	    }
	    else if (lookimg(curkl->posy, curkl->posx, '@') ||
		     lookimg(curkl->posy, curkl->posx, 'B')) {
		curkl->strategy = rand_mod(15)+5;
		prob = 10000;
	    }
	    else
		prob = 4;
	}
	else if (curkl->image == 'M') {	/* Mudd wants to sit sometimes */
	    if ((obj = lookimg(curkl->posy, curkl->posx, 'E')) ||
		(obj = lookimg(curkl->posy, curkl->posx, 'B')) ) {
		if (obj->image == 'B') {
		    btorp -= rand_mod(40);
		    if (btorp < 0)
			btorp = 0;
		    obj->energy -= rand_mod(100);
		    if (obj->energy < 0)
			obj->energy = 0;
		}
		else if (!obj->vely && !obj->velx) {
		    etorp -= rand_mod(10);
		    if (etorp < 0)
			etorp = 0;
		    obj->energy -= rand_mod(20);
		    if (obj->energy < 0)
			obj->energy = 0;
		}
		prob = 10000;		/* stay here */
	    }
	    else		/* it went away--go elsewhere */
		prob = 4;
	}
	else if (curkl->flags & FRIENDLY) {
	    if (curkl->energy < 10000 &&
	      lookimg(curkl->posy, curkl->posx, '@') ) {
		curkl->energy += 100;
		prob = 20;	/* do some loading */
	    }
	    else
		prob = 4;
	}
	else if (curkl->image == '&') {
	    if (curkl->flags & COUNTDOWN) {
		if (curkl->strategy)
		    curkl->strategy--;
		else
		    curkl->flags &= ~COUNTDOWN;
		prob = 100;	/* someone's feeding us, so sit still */
	    }
	    else
		prob = 4;
	}
	else
	    prob = 4;			/* don't sit still too long */
	count = 11;
	for (;;) {
	    if (--count <= 0)		/* no opening, just ram something */
		break;

#ifdef lint
	    prob = prob;
#endif
	    if (!(rand_mod(prob)))	/* turn randomly occasionally */
		goto accell;

	    y=(curkl->posy+curkl->vely+YSIZE00)%YSIZE;	/* find prospective */
	    x=(curkl->posx+curkl->velx+XSIZE00)%XSIZE;	/*   new position */

	    if (numamoebas) {
		if (curkl == nuke) {
		    if (amb[y][x] != '~')
			goto accell;	/* never move nucleus from protoplasm */
		}
		else {
		    if (amb[y][x] == '~' && rand_mod(2)) {
			yamblast = y;
			xamblast = x;
			goto accell;
		    }
		}
	    }

	    obj = occupant[y][x];
	    if (!obj) break;		/* is anyone there? */

	    switch (obj->type) {
	    case Star:
		if (obj->image == '@' && (curkl->flags & PIRATE)) {
		    if (curkl->image != 'P' && curkl->image != ' ') {
			if (curkl->flags & FRIENDLY) {
			    curkl->flags &= ~FRIENDLY;
			    curkl->energy += 1000;
			    possiblescore += curkl->mass;
			    inumfriends--;
			    numfriends--;
			    inumenemies++;
			    numenemies++;
			}
			curkl->image = 'P';
		    }
		    break;		/* go ahead and ram the star */
		}
		goto accell;		/* try not to ram stars */
	    case Torp:
		if (!obj->vely && !obj->velx && (rand_mod(100) <= smarts) &&
		  (obj->image == 'o' || obj->image == 'O' || obj->image == 'X'))
		    goto accell;	/* try not to ram "friendly" torps */
		break;
	    case Web:
		if (curkl->image != 'T')
		    goto accell;	/* non-Tholians shouldn't ram web */
		if (count <= 5)
		    break;		/* Tholians retrace web if desperate */
		if (obj->image ==
		    (curkl->vely?
		     (curkl->velx?
		      (curkl->velx==curkl->vely?
		       '\\'
		      :
		       '/'
		      )
		     :
		      '|'
		     )
		    :
		     '-'
		    )
		   ) goto accell;	/* Tholians try not to retrace web */
		break;			/* No problem with crossing web */
	    }
	    break;			/* okay to move over object */

	accell:
	    /* determine maximum velocity */
	    if (massacre && curkl->image != 'T') {
		curkl->vely = rand_mod(7) - 3;
		curkl->velx = rand_mod(7) - 3;
	    }
	    else if (curkl->image == '&') {
		if (rand_mod(2)) {
		    curkl->vely = rand_mod(3) - 1;
		    curkl->velx = rand_mod(3) - 1;
		}
		else {
		    curkl->vely = curkl->strategy & 3;
		    if (curkl->vely & 2)
			curkl->vely = -1;
		    curkl->velx = (curkl->strategy >> 2) & 3;
		    if (curkl->velx & 2)
			curkl->velx = -1;
		}
	    }
	    else if (curkl->energy >= 2500 && curkl->image != 'T') {
		curkl->vely = rand_mod(5) - 2;
		curkl->velx = rand_mod(5) - 2;
	    }
	    else {
		curkl->vely = rand_mod(3) - 1;
		curkl->velx = rand_mod(3) - 1;
	    }
	}
	if (count != 10) {
	    if (curkl->image == ' ') {
		setimage(curkl, curkl->flags & PIRATE ? 'P' : 'R');
	    }
	    if (!count) {
		curkl->vely = 0;
		curkl->velx = 0;
	    }
	}
	if (curkl->image == 'G' && (base||ent) &&
	    !rand_mod((103-smarts)*10) ) {
	    int xxx,yyy;

	    for (xxx = -1; xxx<=1; xxx++)
		for (yyy = -1; yyy<=1; yyy++)
		    if ((xxx||yyy) && rand_mod(2))
			fire_torp(curkl,yyy,xxx);
	}
	else if (curkl->image == 'T' && (curkl->velx || curkl->vely)) {
	    make_object(Web,
            curkl->vely?
	     (curkl->velx?
	      (curkl->velx==curkl->vely?
	       '\\'
	      :
	       '/'
	      )
	     :
	      '|'
	     )
	    :
	     '-',
	    curkl->posy,curkl->posx,0,0,32767L,32767L,&root);
	    if (obj && obj->type == Web) {
		unmake_object(obj);
		occupant[y][x] = NULL;
	    }
	}
    }
    /* klingon-style fighting */
    if (numamoebas)
	attack(nuke);
    attack(base);
    if (ent && (!cloaked || ent->image=='E' || ent->image=='e'))
	attack(ent);
}

void
modify_amoeba(int y, int x, int where, int ch, int quant)
{
    int dy;
    int dx;
    int count = 15;

    if (!numamoebas)
	return;
    if (!where || (where==1 && rand_mod(2))) {
	y = nuke->posy;
	x = nuke->posx;
    }
    if (nuke->strategy && rand_mod(3)) {
	dy = nuke->strategy & 3;
	if (dy & 2)
	    dy = -1;
	dx = (nuke->strategy >> 2) & 3;
	if (dx & 2)
	    dx = -1;
	if (ch == ' ') {		/* take from the tail */
	    dy = -dy;
	    dx = -dx;
	}
	if (!rand_mod(100))
	    nuke->strategy = rand_mod(256);
    }
    else {
	dy = rand_mod(3) - 1;
	dx = rand_mod(3) - 1;
    }
    if (!dy && !dx)
	return;
    do {
	if (--count < 0)
	    return;
	y = (y + dy + YSIZE00) % YSIZE;
	x = (x + dx + XSIZE00) % XSIZE;
    } while (amb[y][x] != ' ');
    if (ch == ' ') {
	y = (y - dy + YSIZE00) % YSIZE;
	x = (x - dx + XSIZE00) % XSIZE;
    }
    if (ambsize > 100 && quant > 2) {
	quant >>= (ambsize/100);
    }
    if ((nuke->energy += quant << 6) > 32767)
	nuke->energy = 32767;
    count = quant << 3;		/* endless loop catcher */
    while (count-- > 0 && quant > 0) {
	if (amb[y][x] != ch) {
	    quant--;
	    amb[y][x] = ch;
	    if (ch == '~') {
		ambsize++;
		yblasted[y] |= 2;
		xblasted[x] |= 2;
		blasted = true;
	    }
	    else
		ambsize--;
	    if (!occupant[y][x])
		mvaddch(y+1,x*2,ch);
	}
	y = (y + rand_mod(3) + YSIZE99) % YSIZE;
	x = (x + rand_mod(3) + XSIZE99) % XSIZE;
    }
}