/************************************************************************/
/*									*/
/*				     ######################		*/
/*	A n t h o n y			   ##  ##  ##			*/
/*					   ##########			*/
/*		T h y s s e n		 ####  ##  #### 		*/
/*				       ####    ##    ####		*/
/*				     ####      ##      ####		*/
/*									*/
/************************************************************************/

/*
**  Crabs - also for AMIGA under lattace C
*/

#include <stdio.h>
#include <string.h>
#include <intuition/intuition.h>
#include <graphics/gfxmacros.h>
#include <exec/exec.h>
#include <proto/all.h>
#define BM_SRC 0xC0	 /* minterm source only */
#define BM_DST 0xA0	 /* minterm destination only */

#include "crabs.h"

 /* intuition variables */
struct Library	      *IntuitionBase = NULL, *GfxBase = NULL;
struct Screen	      *WBScrn = NULL;
struct Window	      *Window = NULL;	     /* Window pointer */
struct RastPort       *RPwindow = NULL;      /* windows raster port */
struct Remember       *Remember = NULL;      /* memory allocation memory */
struct Task	      *MyTask = NULL;	     /* my tasks address */
struct IntuiMessage   *message = NULL;
int		      WBScrX, WBScrY;	     /* size of workbench screen */
ULONG		      WindowSignal;	     /* IDCMP window signal */
struct NewWindow      NW = {
	30, 200, 350, 40, 0, 1, 	      /* position, size and colors */
	CLOSEWINDOW,			     /* IDCMP messages */
	ACTIVATE| SIMPLE_REFRESH| WINDOWDEPTH|
	   WINDOWDRAG| WINDOWCLOSE,	     /* window flags */
	NULL, NULL,			     /* gadget, checkmark */
	(UBYTE *) " << CRABS >> ",           /* name of window */
	NULL,NULL,			     /* screen-> , BitMap-> */
	0,0,0,0,			     /* min and max size (disable) */
	WBENCHSCREEN			     /* screen type */
	};


   /* program varibles */
typedef struct {
  int		  x, y;
}		point;

typedef enum {
    Looking,	      /* crab is looking for food */
    Nibbling,	      /* crab took a nibble and is stepping back */
    Munching	      /* crab is eating the food (after step back) */
} crabstatus;

static struct {
  crabstatus	  stat;       /* current status of crab */
  point 	  pos;	      /* upper left corner screen coords */
  point 	  vel;	      /* velocity (pixels/cycle) */
  point 	  old;	      /* last position for backward step */
  int		  lp;	      /* life points of this crab */
  struct RastPort *RP;	      /* which map is the crab using */
}     crab[MAXCRABS];	      /* crabs' state */

int	NumCrabs = 0;	      /* number of crabs on screen */

/* Crab images to be drawen to the screen using the mask */
unsigned short chip   crabup[] =	  /* facing up */
#  include "crabup.i"
#ifndef ONEIMAGE
unsigned short chip   crabdown[] =	  /* facing down */
#  include "crabdown.i"
unsigned short chip   crabright[] =	  /* facing right */
#  include "crabright.i"
unsigned short chip   crableft[] =	  /* facing left */
#  include "crableft.i"
#endif
unsigned short chip   crabmask[] =	  /* crabs mask */
#  include "crabmask.i"

  /* Bitmaps and raster ports of the screens */
struct BitMap	BMtemp, BMmask, BMup;
struct RastPort RPtemp, RPmask, RPup, RPscreen;
#ifndef ONEIMAGE
struct BitMap	BMdown, BMright, BMleft;
struct RastPort RPdown, RPright, RPleft;
#endif


  /* function declarations */
extern void	Init(), OpenLibraries(), InitWindow(), InitRP(), Print();
extern void	CrabsExit(), Cycle(), DrawCrab(), HideCrab(), ModVel(), NewVel();
extern BOOL	MoveCrab(), TestCrab(), TestBackground();
extern void	RandInit();
extern int	RandInt();

#ifdef CBACK
  /* Cback.o initializations */
LONG _stack = 2000;
char *_procname = "Crabs";
LONG _priority = -1;
LONG _BackGroundIO = 0;
#endif

void
_main()
{
  Init();

  for (;;) {
    Cycle();
  }
  /* NOTREACHED */
}

void
Init()
/* set up initial crab layer */
{
  int		  i;	       /* crab # */

  OpenLibraries();        /* open the various system structures */

  if( ! (Window = OpenWindow( &NW )) )
    CrabsExit(NULL);
  RPwindow = Window->RPort;
  WindowSignal = 1<<Window->UserPort->mp_SigBit;

  InitWindow();

  MyTask = FindTask( NULL );
  WBScrn = Window->WScreen;
  WBScrX = WBScrn->Width -SIZE;
  WBScrY = WBScrn->Height -SIZE/2;

  memcpy((char *) &RPscreen, (char *) &(WBScrn->RastPort),
				      sizeof( struct RastPort ));

  InitRP(&RPup,    &BMup,    &crabup);
  InitRP(&RPmask,  &BMmask,  &crabmask);
  InitRP(&RPtemp,  &BMtemp,  NULL);
#ifndef ONEIMAGE
  InitRP(&RPdown,  &BMdown,  &crabdown);
  InitRP(&RPleft,  &BMdown,  &crableft);
  InitRP(&RPright, &BMright, &crabright);
#endif

  RandInit();

  /* Create initial set of crabs: */
  for (NumCrabs = 0; NumCrabs < STARTCRABS; NumCrabs++) {
    for (i = PLACELIM; i > 0; i--) {
      crab[NumCrabs].pos.x = RandInt(0, WBScrX-1);
      crab[NumCrabs].pos.y = RandInt(0, WBScrY-1);
      crab[NumCrabs].old = crab[NumCrabs].pos;
      if( !TestBackground(NumCrabs) )
	break;				    /* space found */
    }
    if( !i )                           /* did we reach the placement limit */
      CrabsExit("Can't place crabs! No empty space found!");
    crab[NumCrabs].lp = REPROlp / 2;
    crab[NumCrabs].stat = Looking;
    NewVel(NumCrabs);
    DrawCrab(NumCrabs);
  }
}

void
OpenLibraries()
{
  if( ! (IntuitionBase = OpenLibrary( "intuition.library", 0 )) )
    CrabsExit("Can't open Intuition Library");
  if( ! (GfxBase = OpenLibrary( "graphics.library", 0 )) )
    CrabsExit("Can't Open Graphics Library");
}

void
InitWindow()
{
  Move(RPwindow, Window->BorderLeft,
	  Window->BorderTop + RPwindow->TxBaseline );
  SetAPen(RPwindow, 3);
  Print("Reproducing Crabs by Anthony Thyssen");
  SetAPen(RPwindow, 1);
  Print("   Original idea from Scientific American");
}

void
InitRP(rp, bm, image)
  struct RastPort *rp;
  struct BitMap   *bm;
  short 	  *image;
{
  InitBitMap(bm,  1, SIZE,SIZE/2);
  if( image )
    bm->Planes[0] = (PLANEPTR) image;
  else
    if( !(bm->Planes[0] = (PLANEPTR)
	 AllocRemember( &Remember, RASSIZE(SIZE,SIZE/2),
	     MEMF_CHIP | MEMF_CLEAR) ) ) {    /* allocate with memory */
      CrabsExit("Can't alloc raster");
    }
  InitRastPort( rp );
  rp->BitMap = bm;
}

void
Print(str)
  char *str;
{
  Text( RPwindow, str, strlen(str) );
  Move( RPwindow, Window->BorderLeft,
      RPwindow->cp_y + RPwindow->TxHeight); /* move to next line */
}

void
CrabsExit(exitmessage)
  char *exitmessage;
/* exit crabs - remove all traces */
{
  int		  i;

  for (i = 0; i < NumCrabs; ++i)
    HideCrab(i);

  RefreshWindowFrame(Window);
  InitWindow();
  if( Window && exitmessage ) {
    Print(exitmessage);
    /*printf("%s\n", exitmessage); /* Debugging */
    Delay(200);
  }

  FreeRemember( &Remember, TRUE );    /* Frre all allocated memory */

  if( Window )          CloseWindow( Window );
  if( GfxBase )         CloseLibrary( GfxBase );
  if( IntuitionBase )   CloseLibrary( IntuitionBase );

  _exit(0);
}

void
Cycle()
  /* one motion cycle for all crabs */
{
  int		  i;

  /* test for window closure */
  if( message = (struct IntuiMessage *)GetMsg(Window->UserPort) ) {
    ReplyMsg( (struct Message *)message );
    switch( message->Class ) {
      case CLOSEWINDOW : /* window closed message */
	CrabsExit("Crabs are Exiting");
    }
  } /* Message test */

  if( NumCrabs < 5 )
    Delay( DELAY );         /* slow down the small number of crabs */

  for (i = 0; i < NumCrabs; i++) {

    /* did something bite the crab - image corrupted ? */
    if (TestCrab(i)) {              /* if so damage the crab */
      crab[i].lp -= BITElp;
      NewVel(i);
    }

    switch( crab[i].stat ) {        /* do the nessary move */
      case Looking:
	HideCrab(i);                 /* erase crab from previous position */
	crab[i].old = crab[i].pos;   /* record current position */
	if (MoveCrab(i))             /* find the new positioN */
	  crab[i].lp -= BOUNCElp;    /* crab bounced - that smarts */
	if (TestBackground(i))       /* Test if crab hits an object */
	  crab[i].stat = Nibbling;   /* if so crab will now nibble */
	crab[i].lp -= MOVElp;	     /* drain movement cost from crab */
	if (crab[i].lp < 0) {        /* check on starvation */
	  crab[i] = crab[--NumCrabs];
	  if (NumCrabs == 0)
	    CrabsExit("The last Crab just died!\n");
	  i--;
	  continue;		     /* repeat this crab as it is the next one */
	}
	DrawCrab(i);                 /* redraw crab here */
	ModVel(i, 1);                /* very slight direction change */
	break;

      case Nibbling:
	HideCrab(i);                 /* erase crab from previous position */
	crab[i].pos = crab[i].old;   /* move crab backwards */
	DrawCrab(i);                 /* draw crab here */
	crab[i].stat = Munching;     /* chew over the food */
	break;

      case Munching:
	crab[i].lp += FEEDlp;	     /* feed the food to the crab */
	ModVel(i, FEEDVEL);          /* look in roughly the same dir as before */
	crab[i].stat = Looking;      /* time taken to eat - look for more */
	if (crab[i].lp >= REPROlp) { /* check for reproduction */
	  HideCrab(i);               /* remove parent */
	  crab[i].lp /= 2;	     /* half life force */
	  if (NumCrabs < MAXCRABS) { /* is a new crab is possible */
	    crab[NumCrabs] = crab[i]; /* child is a copy of parent */
	    crab[NumCrabs].vel.x = -crab[NumCrabs].vel.x; /* reverse dir */
	    crab[NumCrabs].vel.y = -crab[NumCrabs].vel.y;
	    crab[NumCrabs].lp -= BITElp; /* child is weak */
	    MoveCrab(i);             /* move crabs away from each other */
	    MoveCrab(NumCrabs++);    /* move child twice - inc number crabs */
	    /* leave the child undrawen and corrupted! */
	  }
	  DrawCrab(i);               /* draw parent regardless of child state */
	}
	break;
    }
  }				    /* move next crab */
}

BOOL
MoveCrab(i)
  int		  i;
/* move crab to on screen position - don't draw it */
/* if the crab hits edge of screen return TRUE */
{
  BOOL	      hit = FALSE;

  crab[i].pos.x += crab[i].vel.x;	 /* motion */
  crab[i].pos.y += crab[i].vel.y;
  if( crab[i].pos.x < 0 ) {
    crab[i].pos.x = 0;
    crab[i].vel.x = abs(crab[i].vel.x);
    hit = TRUE;
  }
  if( crab[i].pos.x > WBScrX ) {
    crab[i].pos.x = WBScrX;
    crab[i].vel.x = -abs(crab[i].vel.x);
    hit = TRUE;
  }
  if( crab[i].pos.y < 0 ) {
    crab[i].pos.y = 0;
    crab[i].vel.y = abs(crab[i].vel.y);
    hit = TRUE;
  }
  if( crab[i].pos.y > WBScrY ) {
    crab[i].pos.y = WBScrY;
    crab[i].vel.y = -abs(crab[i].vel.y);
    hit = TRUE;
  }
  return (hit);
}

BOOL
TestCrab(i)
  int		  i;
/* test the crabs image on the screen. return TRUE if corrupt */
/* invisible crabs are the background texture */
{
  int j;
  UBYTE *byte;

  /* get crab stored on screen */
  ClipBlit( &RPscreen, crab[i].pos.x, crab[i].pos.y,
	    &RPtemp, 0, 0, SIZE, SIZE/2, BM_SRC );
  /* mask out background */
  ClipBlit( &RPmask, 0, 0, &RPtemp, 0, 0,
	    SIZE, SIZE/2, BM_SRC & BM_DST );
  /* xor with crab image */
  ClipBlit( crab[i].RP, 0, 0, &RPtemp, 0, 0,
	    SIZE, SIZE/2, BM_SRC ^ BM_DST );

  /* check the data */
  byte = BMtemp.Planes[0];
  for (j = RASSIZE(SIZE, SIZE/2)-1; j >= 0; j--)
    if( *(byte++) )
      return TRUE;

  return FALSE;
}

BOOL
TestBackground(i)
  int		  i;
/* return TRUE if crab position is not the background */
{
  int  j;
  UBYTE *byte;

  /* get screen at crab location */
  ClipBlit( &RPscreen, crab[i].pos.x, crab[i].pos.y,
	    &RPtemp, 0, 0, SIZE, SIZE/2, BM_SRC );
  /* mask out background */
  ClipBlit( &RPmask, 0, 0, &RPtemp, 0, 0,
	    SIZE, SIZE/2, BM_SRC & BM_DST );

  /* check the data */
  byte = BMtemp.Planes[0];
  for (j = RASSIZE(SIZE, SIZE/2)-1; j >= 0; j--)
    if( *(byte++) )
      return TRUE;

  return FALSE;
}

void
HideCrab(i)
/* over write current crab with screen texture */
{
  ClipBlit( &RPmask, 0, 0, &RPscreen, crab[i].pos.x, crab[i].pos.y,
	    SIZE, SIZE/2, ~BM_SRC & BM_DST );
}

void
DrawCrab(i)
  int		  i;
/* Draw the crabs on the screen if visible */
{
  HideCrab(i);
  crab[i].RP = PICKMAP( crab[i].vel );
  ClipBlit( crab[i].RP, 0, 0, &RPscreen, crab[i].pos.x, crab[i].pos.y,
	    SIZE, SIZE/2, BM_SRC | BM_DST );
}

void
NewVel(i)                              /* assign new velocity to crab */
  int		  i;		       /* crab # */
{
  crab[i].vel.x = RandInt(-MAXVEL, MAXVEL);
  crab[i].vel.y = RandInt(-MAXVEL/2, MAXVEL/2);

  /* Velocity (0,0) is okay since we repeatedly modify all velocities. */
}

void
ModVel(i, dv)                              /* randomly modify crab velocity */
  int		  i,dv; 		  /* crab, delta velocity */
{
  int		  min,max;		   /* range of new velocity */

  min=crab[i].vel.x-dv;
  max=crab[i].vel.x+dv;
  if ( max > MAXVEL)
    max = MAXVEL;
  if ( min < -MAXVEL)
    min = -MAXVEL;
  crab[i].vel.x = RandInt(min, max);

  min=crab[i].vel.y-dv;
  max=crab[i].vel.y+dv;
  if ( max > MAXVEL/2)
    max = MAXVEL/2;
  if ( min < -MAXVEL/2)
    min = -MAXVEL/2;
  crab[i].vel.y = RandInt(min, max);
}

void
RandInit()
{
  srand((int)time(NULL));
}

int
RandInt(lo, hi)                        /* generate random integer in range */
  int		  lo, hi;	       /* range lo..hi inclusive */
{
  return lo + (int)( (unsigned)rand() % (hi - lo +1) );
}