#include <mcomdf0-defs.h>


Prototype void startDoodle(void);
Prototype void initDoodle(struct nodeSprt *);
Prototype void moveDoodleList(void);
Prototype struct nodeSprt *endDoodle(struct nodeSprt *);
Prototype void ignoreDoodle(struct nodeSprt *);
Prototype struct nodeSprt *destroyDoodle(struct nodeSprt *);
Prototype struct nodeSprt *hitDoodle(struct nodeSprt*);
Prototype void doodleThink(struct nodeSprt *);
Prototype void drawShots(UWORD,UBYTE);
Prototype void drawAShot(UWORD);
Prototype void gameLoop1(void);
Prototype void gameLoop2(void);
Prototype void intToStr(char *,ULONG);
Prototype void hiScoreTables(void);
Prototype void inputName(void);
Prototype void setSounds(void);
Prototype void triggerSound(UBYTE);
Prototype void flash(void);
Prototype void shade(void);
Prototype UWORD altBase(UWORD,UWORD);
Prototype void theEnd(void);

extern ULONG score;
extern struct SimpleSprite *sprtF;


/***************************************
       SYSTEM GLOBAL VARIABLES
***************************************/
extern struct ColorMap *colorMap;
extern struct RastPort *screenRP,*viewRP;
extern struct AreaInfo areaInfo;
extern struct TmpRas tmpRas;
extern struct BitMap *viewBM,cityBM;

extern struct MsgPort *winMsgPort;

extern struct Library *IntuitionBase;
extern struct GfxBase *GfxBase;
extern struct Library *MathIeeeSingBasBase;
extern struct Library *MathIeeeSingTransBase;
extern struct Library *DiskfontBase;
extern struct TextAttr topaz;
extern __far struct Custom custom;
extern struct MsgPort *startPort;
extern struct UCopList *uCopList[2];
extern struct ColorSpec baseColor;


extern struct ColorSpec cSpec[33];

extern struct ColorSpec tCSpec[8];

extern struct TagItem screenTags[];

extern struct TagItem winTags[];
extern struct TagItem wTags[];

extern struct TagItem nwTags[];

extern struct Screen *screen;
extern struct Window *window;

extern WORD areaBuffer[100];
extern void *buffer;
extern struct RastPort explodRP[26];
extern struct BitMap	explodBM[26];
extern UBYTE *bytePtr;
/***************************************
	  GLOBAL VARIABLES
***************************************/
extern struct nodeExplode *head;

extern struct nodeMissile
{
struct nodeMissile *next,*prev;
ULONG stepCount;
WORD cX,cY,targetX,targetY;
WORD baseX,baseY,range;
WORD dX,dY;
}*GMHead,*AMHead;

extern struct nodeSprt
{
struct nodeSprt *next,*prev;
struct SimpleSprite *sprtF,*sprtR;
WORD sprtNoF,sprtNoR;
WORD direction;
UWORD *imageF,*imageR;
UBYTE exploding;
}*spHead,*saHead,*dHead;

extern struct hScore
{
ULONG hiScore;
char scoreStr[11],name[11];
}allTime[11],todays[11];

extern UWORD LplaneFront[];
extern UWORD LplaneRear[];
extern UWORD RplaneFront[];
extern UWORD RplaneRear[];
extern UWORD sattalite[];
extern UWORD doodleBug[];
extern UWORD mouseImage[];
extern UWORD crossImageData[][];
extern struct Image crossImage;
extern ULONG cityImageData[2][16];
extern struct Image cityImage;
extern char allTimeText[10][30],todaysText[10][30],scoreStr[11];

/*extern struct IntuiText allTimeLine[10],todaysLine[10];
extern struct IntuiText startText;
extern struct IntuiText allTimeTitle;
extern struct IntuiText todaysTitle;
*/extern struct IntuiText scoreText;/*
extern struct IntuiText mouseQueryText;
extern struct IntuiText yesText;
extern struct IntuiText noText;*/


extern WORD count;
extern UBYTE baseCount;
extern ULONG level,wave,step,speed,score,eCity;
extern BOOL city[12];
extern FILE *fp;
extern struct TextFont *font;
extern BOOL forbiden,firstCall;
extern struct MsgPort *replyPort,*audPort;

extern struct command
{
struct Message cMessage;
UBYTE command;
}audCommand;
extern BOOL threeMouseButtons;
extern UBYTE shots[3];




/*struct nodeSprt *destroySat(struct nodeSprt *sprtPtr)
{
triggerSound(2);
startExplosion(sprtPtr->sprtF->x,sprtPtr->sprtF->y+10);
score+=sprtPtr->sprtF->y;
sprtPtr=endSat(sprtPtr);
return sprtPtr;
}*/

/**************************************/
void startDoodle()
{
struct nodeSprt *tDHead;

if(dHead)
    {tDHead=dHead;
     while(tDHead->next)
	tDHead=tDHead->next;
     if(!(tDHead->next=(struct nodeSprt *)AllocVec(sizeof(struct nodeSprt),MEMF_ANY)))
	fail("Could not alloc Sprt list");
     tDHead->next->prev=tDHead;
     tDHead=tDHead->next;
     tDHead->next=NULL;
     initDoodle(tDHead);
    }
else
    {if(!(dHead=(struct nodeSprt *)AllocVec(sizeof(struct nodeSprt),MEMF_ANY)))
	fail("Could not alloc sprite list head");
     dHead->prev=NULL;
     dHead->next=NULL;
     initDoodle(dHead);
    }
}
/**************************************/
void initDoodle(struct nodeSprt *sprtPtr)
{
if(!(sprtPtr->sprtF=(struct SimpleSprite *)AllocVec(sizeof(struct SimpleSprite),MEMF_ANY)))
     fail("Could Not Alloc sprite struct");
if(-1==(sprtPtr->sprtNoF=GetSprite(sprtPtr->sprtF,-1)))
    {ignoreDoodle(sprtPtr);
     return;
    }
if(!(sprtPtr->imageF=(UWORD *)AllocVec((sizeof(UWORD))*20,MEMF_CHIP)))
    fail("Could not alloc SprtimageF");
for(count=0;count<20;count++)
    *(sprtPtr->imageF+count)=doodleBug[count];
sprtPtr->sprtF->x=rand()%300;
sprtPtr->sprtF->y=0;
sprtPtr->sprtF->height=8;
if(sprtPtr->sprtF->x<30)
    sprtPtr->direction=14;
else if(sprtPtr->sprtF->x<66)
    sprtPtr->direction=44;
else if(sprtPtr->sprtF->x<102)
    sprtPtr->direction=80;
else if(sprtPtr->sprtF->x<130)
    sprtPtr->direction=116;
else if(sprtPtr->sprtF->x<164)
    sprtPtr->direction=150;
else if(sprtPtr->sprtF->x<200)
    sprtPtr->direction=180;
else if(sprtPtr->sprtF->x<236)
    sprtPtr->direction=216;
else if(sprtPtr->sprtF->x<272)
    sprtPtr->direction=252;
else sprtPtr->direction=286;
sprtPtr->exploding=0;

ChangeSprite(NULL,sprtPtr->sprtF,(APTR)sprtPtr->imageF);

}
/**************************************/

void moveDoodleList()
{
struct nodeSprt *tDHead;

tDHead=dHead;
while(tDHead)
    {if(tDHead->exploding)
	{tDHead->exploding++;
	 (UWORD)tDHead->imageF[rand()%16+2]&=rand()%0xFFF;
	 (UWORD)tDHead->imageF[rand()%16+2]&=rand()%0xFFF;
	 ChangeSprite(NULL,tDHead->sprtF,(APTR)tDHead->imageF);
	 if(tDHead->exploding>10)
	    tDHead=destroyDoodle(tDHead);
	 else
	    tDHead=tDHead->next;
	}
     else
	{doodleThink(tDHead);
	 if(7==ReadPixel(viewRP,tDHead->sprtF->x+6,tDHead->sprtF->y+5))
	    {startExplosion(tDHead->sprtF->x,tDHead->sprtF->y+4);
	     triggerSound(2);
	     tDHead->exploding=1;
	    }
	 else if(7==ReadPixel(viewRP,tDHead->sprtF->x+11,tDHead->sprtF->y))
	    {startExplosion(tDHead->sprtF->x+10,tDHead->sprtF->y+1);
	     triggerSound(2);
	     tDHead->exploding=1;
	    }
	      else if(7==ReadPixel(viewRP,tDHead->sprtF->x+16,tDHead->sprtF->y+5))
		     {startExplosion(tDHead->sprtF->x+16,tDHead->sprtF->y+5);
		      triggerSound(2);
		      tDHead->exploding=1;
		      }
		   else if(7==ReadPixel(viewRP,tDHead->sprtF->x+11,tDHead->sprtF->y+9))
			   {startExplosion(tDHead->sprtF->x+10,tDHead->sprtF->y+8);
			    triggerSound(2);
			    tDHead->exploding=1;
			   }
	 if(tDHead->sprtF->y>222)
	    tDHead=hitDoodle(tDHead);
	 else tDHead=tDHead->next;
	}
    }
}

/**************************************/
struct nodeSprt *endDoodle(struct nodeSprt *sprtPtr)
{
struct nodeSprt *tNode;

if(sprtPtr==dHead)
    {dHead=sprtPtr->next;
     tNode=dHead;
     if(tNode)
	tNode->prev=NULL;
    }
else
    {tNode=sprtPtr->next;
     if(tNode)
	tNode->prev=sprtPtr->prev;
     sprtPtr->prev->next=tNode;
    }
FreeVec(sprtPtr->sprtF);
FreeSprite(sprtPtr->sprtNoF);
FreeVec(sprtPtr);
return tNode;
}
/**************************************/
void ignoreDoodle(struct nodeSprt *sprtPtr)
{
if(sprtPtr==dHead)
    dHead=NULL;
else
    sprtPtr->prev->next=NULL;
FreeVec(sprtPtr);
}

/**************************************/

struct nodeSprt *destroyDoodle(struct nodeSprt *sprtPtr)
{
triggerSound(2);
startExplosion(sprtPtr->sprtF->x+10,sprtPtr->sprtF->y+5);
score+=(220-sprtPtr->sprtF->y)*3;
sprtPtr=endDoodle(sprtPtr);
return sprtPtr;
}
/**************************************/
void doodleThink(struct nodeSprt *sprtPtr)
{
WORD x=0,y=level/10+1;
BYTE count;
BYTE countb;
if(sprtPtr->sprtF->y>120)
    {if(sprtPtr->sprtF->x+11>sprtPtr->direction)
	 x=-2;
     else if(sprtPtr->sprtF->x+11<sprtPtr->direction)
	      x=+2;
    }
else
    x=rand()%7-3;
for(count=0;count<level/3-1;count++)
    {for(countb=-1*count;countb<=count;countb++)
	{if(7==ReadPixel(viewRP,countb+sprtPtr->sprtF->x+11,sprtPtr->sprtF->y+count+10))
	    {y=-1*(level/10+1);
	     x=rand()%3-1;
	    }
	}
    }
if(sprtPtr->sprtF->x>500)
    {sprtPtr->sprtF->x=0;
     x=0;
    }
else if(sprtPtr->sprtF->x>320)
    x=-2;
MoveSprite(NULL,sprtPtr->sprtF,sprtPtr->sprtF->x+x,sprtPtr->sprtF->y+y);
}
/**************************************/

struct nodeSprt *hitDoodle(struct nodeSprt *sprtPtr)
{
startExplosion(sprtPtr->direction,230);
startExplosion(sprtPtr->direction,220);
destroyCity(sprtPtr->direction);
return endDoodle(sprtPtr);
}

/**************************************/

void drawShots(UWORD x,UBYTE shots)
{
if(shots==5)
    {SetAPen(viewRP,0);
     for(count=0;count<5;count++)
	drawAShot(x+count*4);
    }
else
    {SetAPen(viewRP,4);
     drawAShot(x+shots*4);
    }
}
/**************************************/

void drawAShot(UWORD x)
{
WritePixel(viewRP,x+5,227);
WritePixel(viewRP,x+6,227);
WritePixel(viewRP,x+7,227);
WritePixel(viewRP,x+6,226);
WritePixel(viewRP,x+6,225);
WritePixel(viewRP,x+6,224);
}
/**************************************/

void gameLoop1()
{
BOOL flagWait,areCities=TRUE;
UBYTE shots[3];
struct IntuiMessage *message;
UBYTE depth;
struct Window *tWindow;
struct Screen *tScreen;

for(depth=0;depth<9;depth++)
    city[depth]=TRUE;
if(!(fp=fopen("colors","rb")))
    fail("Could not open file");

for(level=1;areCities;level++)
    {fread(tCSpec,sizeof(struct ColorSpec),8,fp);
     for(depth=0;depth<8;depth++)
	{cSpec[depth].Red=tCSpec[depth].Red;
	 cSpec[depth].Green=tCSpec[depth].Green;
	 cSpec[depth].Blue=tCSpec[depth].Blue;
	}
     for(depth=8;depth<32;depth++)
	{cSpec[depth].Red=cSpec[depth%4].Red;
	 cSpec[depth].Green=cSpec[depth%4].Green;
	 cSpec[depth].Blue=cSpec[depth%4].Blue;
	 cSpec[depth].ColorIndex=depth;
	}
     cSpec[32].ColorIndex=-1;
     for(depth=0;depth<3;depth++)
	 shots[depth]=30;
     city[0]=TRUE;
     city[4]=TRUE;
     city[8]=TRUE;
     baseCount=3;
     speed=0;
     tWindow=window;
     tScreen=screen;
     WaitTOF();
     screen=OpenScreenTagList(NULL,screenTags);
     winTags[5].ti_Data=(ULONG)screen;
     window=OpenWindowTagList(NULL,winTags);
     shade();
     CloseWindow(tWindow);
     CloseScreen(tScreen);
     viewBM=(struct BitMap *)&window->RPort->BitMap;
     screenRP=&screen->RastPort;
     viewRP=window->RPort;
     viewRP->TmpRas=&tmpRas;
     viewRP->AreaInfo=&areaInfo;
     SetPointer(window,mouseImage,12,16,-10,-6);
     SetRast(viewRP,0);
     WaitTOF();
     drawGround();
     if(city[1]) DrawImage(viewRP,&cityImage,30,214);
     if(city[2]) DrawImage(viewRP,&cityImage,66,214);
     if(city[3]) DrawImage(viewRP,&cityImage,102,214);
     if(city[5]) DrawImage(viewRP,&cityImage,164,214);
     if(city[6]) DrawImage(viewRP,&cityImage,200,214);
     if(city[7]) DrawImage(viewRP,&cityImage,236,214);
     for(wave=0;wave<=(level/2+1);wave++)
	{for(depth=0;depth<8;depth++)
	    aimAToGMissile(rand()%300,0);
	 for(depth=0;depth<level/3;depth++)
	    startDoodle();
	 step=0;
	 while(AMHead)
	     {step++;
	      if((step>200-level*10) && wave<(level/2+1))
		 {for(depth=0;depth<8;depth++) aimAToGMissile(rand()%300,0);
		  for(depth=0;depth<level/3;depth++)
		      startDoodle();
		  wave++;
		  step=0;
		 }
	      if(baseCount) flagWait=TRUE;
	      flash();
	      while(flagWait)
	       {
		WaitPort(window->UserPort);
		message=(struct IntuiMessage *)GetMsg(window->UserPort);
		if(message)
		   {if(message->Class & IDCMP_MOUSEBUTTONS)
		      {if(message->MouseY<210)
			{switch(message->Code)
			 {case SELECTDOWN :
			    if(shots[0])
			       {shots[0]--;
				startGToAMissile(14,message->MouseX,message->MouseY);
				if(shots[0]<6)
				    drawShots(0,shots[0]);
			       }
			    break;
			  case MIDDLEDOWN :
			    if(shots[1])
			       {shots[1]--;
				startGToAMissile(150,message->MouseX,message->MouseY);
				if(shots[1]<6)
				    drawShots(136,shots[1]);
			       }
			    break;
			  case MENUDOWN :
			    if(shots[2])
			       {shots[2]--;
				startGToAMissile(286,message->MouseX,message->MouseY);
				if(shots[2]<6)
				    drawShots(272,shots[2]);
			       }
			    break;
			  default :
			    break;
			 }
		       ReplyMsg((struct Message *)message);
		      }
		     else triggerSound(0);
		     }
		    else if(message->Class & IDCMP_INTUITICKS)
			{ReplyMsg((struct Message *)message);
			 flagWait=FALSE;
			}
		   }
	       }
	      moveGToAMissileList();
	      moveExplosionList();
	      if((level%14>6)&&(step%2))
		moveAToGMissileList();
	      moveAToGMissileList();
	      moveDoodleList();
	      if(baseCount)
		{if(!(rand()%550)) startSprt();
		 if(!(rand()%(2100/level))) startSat();
		}
	      moveSprtList();
	      moveSatList();
	     }
	}
     while(GMHead)
	 GMHead=endGToAMissile(GMHead);
     while(head)
	 head=endExplosion(head);
     while(spHead)
	spHead=endSprt(spHead);
     while(saHead)
	saHead=endSat(saHead);
     while(dHead)
	dHead=endDoodle(dHead);
     intToStr(scoreStr,score);
     SetRast(viewRP,0);
     depth=0;
     for(count=1;count<8;count++)
	{if(count==4) count++;
	 if(city[count])
	    {score+=50*level;
	     DrawImage(viewRP,&cityImage,36*depth+20,100);
	     depth++;
	    }
	}
     PrintIText(viewRP,&scoreText,40,120);
     Delay(5 * TICKS_PER_SECOND);
     while(score>eCity) extraCity();
     for(count=9;count<12;count++)
	{if(city[count])
	    {city[count]=FALSE;
	     extraCity();
	    }
	}
     areCities=FALSE;
     for(depth=1;depth<8;depth++)
	{if(depth==4) depth++;
	 if(city[depth]) areCities=TRUE;
	}
    }

fclose(fp);
}
/**************************************/

void gameLoop2()
{
BOOL flagWait,areCities=TRUE;
struct IntuiMessage *message;
UBYTE depth;
struct Window *tWindow;
struct Screen *tScreen;
UWORD base;

for(depth=0;depth<9;depth++)
    city[depth]=TRUE;
if(!(fp=fopen("colors","rb")))
	 fail("Could not open file");

for(level=1;areCities;level++)
    {fread(tCSpec,sizeof(struct ColorSpec),8,fp);
     for(depth=0;depth<8;depth++)
	{cSpec[depth].Red=tCSpec[depth].Red;
	 cSpec[depth].Green=tCSpec[depth].Green;
	 cSpec[depth].Blue=tCSpec[depth].Blue;
	}
     for(depth=8;depth<32;depth++)
	{cSpec[depth].Red=cSpec[depth%4].Red;
	 cSpec[depth].Green=cSpec[depth%4].Green;
	 cSpec[depth].Blue=cSpec[depth%4].Blue;
	 cSpec[depth].ColorIndex=depth;
	}
     cSpec[32].ColorIndex=-1;
     for(depth=0;depth<3;depth++)
	 shots[depth]=30;
     city[0]=TRUE;
     city[4]=TRUE;
     city[8]=TRUE;
     baseCount=3;
     speed=0;
     tWindow=window;
     tScreen=screen;
     WaitTOF();
     screen=OpenScreenTagList(NULL,screenTags);
     winTags[5].ti_Data=(ULONG)screen;
     window=OpenWindowTagList(NULL,winTags);
     shade();
     CloseWindow(tWindow);
     CloseScreen(tScreen);
     viewBM=(struct BitMap *)&window->RPort->BitMap;
     screenRP=&screen->RastPort;
     viewRP=window->RPort;
     viewRP->TmpRas=&tmpRas;
     viewRP->AreaInfo=&areaInfo;
     SetPointer(window,mouseImage,12,16,-10,-6);
     SetRast(viewRP,0);
     WaitTOF();
     drawGround();
     if(city[1]) DrawImage(viewRP,&cityImage,30,214);
     if(city[2]) DrawImage(viewRP,&cityImage,66,214);
     if(city[3]) DrawImage(viewRP,&cityImage,102,214);
     if(city[5]) DrawImage(viewRP,&cityImage,164,214);
     if(city[6]) DrawImage(viewRP,&cityImage,200,214);
     if(city[7]) DrawImage(viewRP,&cityImage,236,214);
     for(wave=0;wave<=(level/2+1);wave++)
	{for(depth=0;depth<8;depth++)
	    aimAToGMissile(rand()%300,0);
	 for(depth=0;depth<level/3;depth++)
	    startDoodle();
	 step=0;
	 while(AMHead)
	     {step++;
	      if((step>200-level*10) && wave<(level/2+1))
		 {for(depth=0;depth<8;depth++) aimAToGMissile(rand()%300,0);
		  for(depth=0;depth<level/3;depth++)
		      startDoodle();
		  wave++;
		  step=0;
		 }
	      if(baseCount) flagWait=TRUE;
	      flash();
	      while(flagWait)
		{
		 WaitPort(window->UserPort);
		 message=(struct IntuiMessage *)GetMsg(window->UserPort);
		 if(message)
		    {if((message->Class & IDCMP_MOUSEBUTTONS)&&(message->Code==SELECTDOWN||message->Code==MENUDOWN))
			{if(message->MouseY<210)
			    {if(message->MouseX<100)
				{if(shots[0])
				    {shots[0]--;
				     startGToAMissile(14,message->MouseX,message->MouseY);
				     if(shots[0]<6)
					drawShots(0,shots[0]);
				    }
				  else if(base=altBase(14,message->MouseX))
					{shots[base/140]--;
					 startGToAMissile(base,message->MouseX,message->MouseY);
					 if(shots[base/140]<6)
					    drawShots(base-14,shots[base-140]);
					}
				 }
			     else if(message->MouseX<220)
				{if(shots[1])
				    {shots[1]--;
				     startGToAMissile(150,message->MouseX,message->MouseY);
				     if(shots[1]<6)
					 drawShots(136,shots[1]);
				    }
				  else if(base=altBase(14,message->MouseX))
					{shots[base/140]--;
					 startGToAMissile(base,message->MouseX,message->MouseY);
					 if(shots[base/140]<6)
					    drawShots(base-14,shots[base-140]);
					}
				 }
			      else
				 {if(shots[2])
				    {shots[2]--;
				     startGToAMissile(286,message->MouseX,message->MouseY);
				     if(shots[2]<6)
					 drawShots(272,shots[2]);
				    }
				  else if(base=altBase(14,message->MouseX))
					{shots[base/140]--;
					 startGToAMissile(base,message->MouseX,message->MouseY);
					 if(shots[base/140]<6)
					    drawShots(base-14,shots[base-140]);
					}
				}
			     ReplyMsg((struct Message *)message);
			    }
			 else triggerSound(0);
			}
		     else if(message->Class & IDCMP_INTUITICKS)
			 {ReplyMsg((struct Message *)message);
			  flagWait=FALSE;
			 }
		    }
		}
	      moveGToAMissileList();
	      moveExplosionList();
	      if((level%14>6)&&(step%2))
		moveAToGMissileList();
	      moveAToGMissileList();
	      moveDoodleList();
	      if(baseCount)
		{if(!(rand()%550)) startSprt();
		 if(!(rand()%(2100/level))) startSat();
		}
	      moveSprtList();
	      moveSatList();
	     }
	}
     while(GMHead)
	 GMHead=endGToAMissile(GMHead);
     while(head)
	 head=endExplosion(head);
     while(spHead)
	spHead=endSprt(spHead);
     while(saHead)
	saHead=endSat(saHead);
     while(dHead)
	dHead=endDoodle(dHead);
     intToStr(scoreStr,score);
     SetRast(viewRP,0);
     depth=0;
     for(count=1;count<8;count++)
	{if(count==4) count++;
	 if(city[count])
	    {score+=50*level;
	     DrawImage(viewRP,&cityImage,36*depth+20,100);
	     depth++;
	    }
	}
     PrintIText(viewRP,&scoreText,40,120);
     Delay(5 * TICKS_PER_SECOND);
     while(score>eCity) extraCity();
     for(count=9;count<12;count++)
	{if(city[count])
	    {city[count]=FALSE;
	     extraCity();
	    }
	}
     areCities=FALSE;
     for(depth=1;depth<8;depth++)
	{if(depth==4) depth++;
	 if(city[depth]) areCities=TRUE;
	}
    }

fclose(fp);
}
/**************************************/
void intToStr(char *str,ULONG a)
{
ULONG ta,sa;
BYTE count;

str[10]=0;
ta=a;
for(count=9;count>=0;count--)
    {ta/=10;
     sa=a-ta*10;
     a=ta;
     str[count]=48+sa;
    }
count=0;
while(count<9 && str[count]==48)
    {str[count]=32;
     count++;
    }
}
/**************************************/

void hiScoreTables()
{
struct hScore t;
BYTE count;
FILE *sfp;

if(sfp=fopen("hiscores","rb"))
    {for(count=0;count<10;count++)
	fread(&allTime[count],sizeof(struct hScore),1,sfp);
    }
fclose(sfp);

if(score>todays[9].hiScore)
    inputName();

allTime[10].hiScore=score;
todays[10].hiScore=score;
count=9;
while(allTime[count+1].hiScore>allTime[count].hiScore && count>=0)
    {t.hiScore=allTime[count].hiScore;
     allTime[count].hiScore=allTime[count+1].hiScore;
     allTime[count+1].hiScore=t.hiScore;
     strcpy(t.name,allTime[count].name);
     strcpy(allTime[count].name,allTime[count+1].name);
     strcpy(allTime[count+1].name,t.name);
     count--;
    }
count=9;
while(todays[count+1].hiScore>todays[count].hiScore && count>=0)
    {t.hiScore=todays[count].hiScore;
     todays[count].hiScore=todays[count+1].hiScore;
     todays[count+1].hiScore=t.hiScore;
     strcpy(t.name,todays[count].name);
     strcpy(todays[count].name,todays[count+1].name);
     strcpy(todays[count+1].name,t.name);
     count--;
    }
for(count=0;count<10;count++)
    {intToStr(allTime[count].scoreStr,allTime[count].hiScore);
     intToStr(allTimeText[count],(ULONG)(count+1));
     allTimeText[count][0]=allTimeText[count][8];
     allTimeText[count][1]=allTimeText[count][9];
     allTimeText[count][2]=allTimeText[count][10];
     strcat(allTimeText[count]," ");
     strcat(allTimeText[count],allTime[count].scoreStr);
     strcat(allTimeText[count],"...");
     strcat(allTimeText[count],allTime[count].name);
     intToStr(todays[count].scoreStr,todays[count].hiScore);
     intToStr(todaysText[count],(ULONG)(count+1));
     todaysText[count][0]=todaysText[count][8];
     todaysText[count][1]=todaysText[count][9];
     todaysText[count][2]=todaysText[count][10];
     strcat(todaysText[count]," ");
     strcat(todaysText[count],todays[count].scoreStr);
     strcat(todaysText[count],"...");
     strcat(todaysText[count],todays[count].name);
    }

if(!(sfp=fopen("hiscores","wb")))
    fail("Could not open hiScore file");
for(count=0;count<10;count++)
    fwrite(&allTime[count],sizeof(struct hScore),1,sfp);
fclose(sfp);

}

/**************************************/

void inputName()
{
struct IntuiText nameTitleText=
{2,5,JAM2,0,0,NULL,"Input Name For Hi_Score Table",NULL};
struct IntuiText nameText=
{5,7,JAM2,0,0,NULL,allTime[10].name,NULL};

BOOL loopFlag=TRUE,flagProceed=TRUE;
BYTE count=0;
struct Window *nWindow;
struct IntuiMessage *message;

strcpy(allTime[10].name,"          ");
strcpy(todays[10].name,"          ");
nwTags[5].ti_Data=(ULONG)screen;
if(!(nWindow=OpenWindowTagList(NULL,nwTags)))
    fail("Could not open name window");

SetRast(nWindow->RPort,7);
PrintIText(nWindow->RPort,&nameTitleText,5,30);
while(loopFlag)
    {if(message=(struct IntuiMessage *)GetMsg(nWindow->UserPort))
	{if(message->Class & IDCMP_VANILLAKEY)
	    {switch(message->Code)
		{case 13:
		    loopFlag=FALSE;
		    allTime[10].name[count]=0;
		    todays[10].name[count]=0;
		    break;
		 case 8:
		    if(count>0)
			{count--;
			 allTime[10].name[count]=32;
			 todays[10].name[count]=32;
			}
		    flagProceed=FALSE;
		    break;
		 default:
		    allTime[10].name[count]=message->Code;
		    todays[10].name[count]=message->Code;
		    break;
		}
	     PrintIText(nWindow->RPort,&nameText,40,100);
	     if(count<10 && flagProceed) count++;
	     flagProceed=TRUE;
	    }
	 ReplyMsg((struct Message *)message);
	}
    }
if(nWindow) CloseWindow(nWindow);
}
/**************************************/
void setSounds()
{
system("run >nil: audn");
if(!(replyPort=(struct MsgPort *)CreatePort(NULL,NULL)))
    fail("Could not Create replyPort");

Forbid();
forbiden=TRUE;
if(!(audPort=FindPort("aud6_startPort")))
    fail("Could not find Port");
Permit();
forbiden=FALSE;
}
/**************************************/
void triggerSound(UBYTE type)
{
if(firstCall)
   firstCall=FALSE;
else
   {WaitPort(replyPort);
    GetMsg(replyPort);
   }
audCommand.command=type;
audCommand.cMessage.mn_Length=sizeof(struct command);
audCommand.cMessage.mn_ReplyPort=replyPort;
PutMsg(audPort,(struct Message *)&audCommand);
}
/**************************************/
void flash()
{
struct ViewPort *viewPort;

struct TagItem uCopTags[]=
{
    {VTAG_USERCLIP_SET,NULL},
    {VTAG_END_CM,NULL},
};

viewPort=ViewPortAddress(window);
SetRGB4(viewPort,7,rand()%16,rand()%16,rand()%16);
}
/**************************************/

void shade()
{
UWORD color=0;
static struct ViewPort *viewPort=NULL;
static BOOL spare=1;

spare=(spare+1)%2;
if(viewPort) FreeVPortCopLists(viewPort);

if(!(uCopList[spare]=(struct UCopList *)AllocVec(sizeof(struct UCopList),MEMF_CHIP|MEMF_CLEAR)))
    fail("Could not alloc uCopList");
struct TagItem uCopTags[]=
{
    {VTAG_USERCLIP_SET,NULL},
    {VTAG_END_CM,NULL},
};
if(cSpec[0].Red!=15)
    color+=(cSpec[0].Red+1)<<8;
else
    color+=(cSpec[0].Red)<<8;
if(cSpec[0].Green!=15)
    color+=(cSpec[0].Green+1)<<4;
else
    color+=(cSpec[0].Green)<<4;
if(cSpec[0].Red!=15)
    color+=cSpec[0].Blue+1;
else
    color+=cSpec[0].Blue;

viewPort=ViewPortAddress(window);
CINIT(uCopList[spare],2);
CWAIT(uCopList[spare],210,0);
CMOVE(uCopList[spare],custom.color[0],color);
CEND(uCopList[spare]);
Forbid();
viewPort->UCopIns=uCopList[spare];
Permit();
VideoControl(viewPort->ColorMap,uCopTags);
RethinkDisplay();
}
/**************************************/
UWORD altBase(UWORD base,UWORD x)
{
if(threeMouseButtons) return 0;
if(base==14)
    {if(city[4] && shots[1]) return 150;
     else if(city[8] && shots[2]) return 286;
     else return 0;
    }
if(base==150)
    {if(x>150)
	{if(city[8] && shots[2]) return 286;
	 else if(city[0] && shots[0]) return 14;
	 else return 0;
	}
     else
	{if(city[0] && shots[0]) return 14;
	 else if(city[8] && shots[2]) return 286;
	 else return 0;
	}
    }
if(base=286)
    {if(city[4] && shots[1]) return 150;
     else if(city[0] && shots[0]) return 14;
     else return 0;
    }
}
/**************************************/
void theEnd()
{
struct BitMap buffBM;
struct RastPort buffRP;
struct ViewPort *vPort;
UBYTE depth,c;
UBYTE red[2],green[2],blue[2];

vPort=ViewPortAddress(window);
SetRGB4(vPort,2,0,0,0);
SetRGB4(vPort,0,0,0,0);
InitBitMap(&buffBM,1,300,230);
InitRastPort(&buffRP);

buffRP.BitMap=&buffBM;
if(!(buffBM.Planes[0]=(PLANEPTR)AllocRaster(300,230)))
    fail("Could not alloc buff Raster");

BltClear(buffBM.Planes[0],(buffBM.BytesPerRow * buffBM.Rows),1L);
SetRast(viewRP,0);
SetAPen(viewRP,2);
/******   T   ********/
AreaMove(viewRP,60,50);
AreaDraw(viewRP,110,50);
AreaDraw(viewRP,110,60);
AreaDraw(viewRP,60,60);
AreaDraw(viewRP,60,50);
AreaEnd(viewRP);
AreaMove(viewRP,80,60);
AreaDraw(viewRP,80,100);
AreaDraw(viewRP,90,100);
AreaDraw(viewRP,90,60);
AreaDraw(viewRP,80,60);
AreaEnd(viewRP);
/*******   H   *******/
AreaMove(viewRP,130,50);
AreaDraw(viewRP,130,100);
AreaDraw(viewRP,140,100);
AreaDraw(viewRP,140,50);
AreaDraw(viewRP,130,50);
AreaEnd(viewRP);
AreaMove(viewRP,140,70);
AreaDraw(viewRP,160,70);
AreaDraw(viewRP,160,50);
AreaDraw(viewRP,170,50);
AreaDraw(viewRP,170,100);
AreaDraw(viewRP,160,100);
AreaDraw(viewRP,160,80);
AreaDraw(viewRP,140,80);
AreaDraw(viewRP,140,70);
AreaEnd(viewRP);
/*******   E   *******/
AreaMove(viewRP,200,50);
AreaDraw(viewRP,230,50);
AreaDraw(viewRP,230,60);
AreaDraw(viewRP,210,60);
AreaDraw(viewRP,210,70);
AreaDraw(viewRP,200,70);
AreaDraw(viewRP,200,50);
AreaEnd(viewRP);
AreaMove(viewRP,200,70);
AreaDraw(viewRP,230,70);
AreaDraw(viewRP,230,80);
AreaDraw(viewRP,210,80);
AreaDraw(viewRP,210,90);
AreaDraw(viewRP,200,90);
AreaDraw(viewRP,200,70);
AreaEnd(viewRP);
AreaMove(viewRP,200,90);
AreaDraw(viewRP,230,90);
AreaDraw(viewRP,230,100);
AreaDraw(viewRP,200,100);
AreaDraw(viewRP,200,90);
AreaEnd(viewRP);
/*******   E   ********/
AreaMove(viewRP,70,120);
AreaDraw(viewRP,100,120);
AreaDraw(viewRP,100,130);
AreaDraw(viewRP,80,130);
AreaDraw(viewRP,80,140);
AreaDraw(viewRP,70,140);
AreaDraw(viewRP,70,120);
AreaEnd(viewRP);
AreaMove(viewRP,70,140);
AreaDraw(viewRP,100,140);
AreaDraw(viewRP,100,150);
AreaDraw(viewRP,80,150);
AreaDraw(viewRP,80,160);
AreaDraw(viewRP,70,160);
AreaDraw(viewRP,70,140);
AreaEnd(viewRP);
AreaMove(viewRP,70,160);
AreaDraw(viewRP,100,160);
AreaDraw(viewRP,100,170);
AreaDraw(viewRP,70,170);
AreaDraw(viewRP,70,160);
AreaEnd(viewRP);
/*******   N   ********/
AreaMove(viewRP,130,120);
AreaDraw(viewRP,140,120);
AreaDraw(viewRP,140,170);
AreaDraw(viewRP,130,170);
AreaDraw(viewRP,130,120);
AreaEnd(viewRP);
AreaMove(viewRP,140,120);
AreaDraw(viewRP,160,155);
AreaDraw(viewRP,160,170);
AreaDraw(viewRP,140,135);
AreaDraw(viewRP,140,120);
AreaEnd(viewRP);
AreaMove(viewRP,160,120);
AreaDraw(viewRP,170,120);
AreaDraw(viewRP,170,170);
AreaDraw(viewRP,160,170);
AreaDraw(viewRP,160,120);
AreaEnd(viewRP);
/********   D	********/
AreaMove(viewRP,200,120);
AreaDraw(viewRP,210,120);
AreaDraw(viewRP,210,170);
AreaDraw(viewRP,200,170);
AreaDraw(viewRP,200,120);
AreaEnd(viewRP);
AreaMove(viewRP,210,120);
AreaDraw(viewRP,230,123);
AreaDraw(viewRP,245,136);
AreaDraw(viewRP,245,154);
AreaDraw(viewRP,230,167);
AreaDraw(viewRP,210,170);
AreaDraw(viewRP,210,160);
AreaDraw(viewRP,220,159);
AreaDraw(viewRP,235,150);
AreaDraw(viewRP,235,140);
AreaDraw(viewRP,220,131);
AreaDraw(viewRP,210,130);
AreaDraw(viewRP,210,120);
AreaEnd(viewRP);
triggerSound(2);
triggerSound(1);
for(depth=0;depth<16;depth++)
    {SetRGB4(vPort,2,depth,depth,depth);
     WaitTOF();
     WaitTOF();
     SetRGB4(vPort,2,depth+1,depth,depth);
     WaitTOF();
     WaitTOF();
     SetRGB4(vPort,2,depth+1,depth+1,depth);
     WaitTOF();
     WaitTOF();
     if(!(rand()%5)) triggerSound(1);
    }
viewBM=window->RPort->BitMap;
buffRP.TmpRas=&tmpRas;
buffRP.AreaInfo=&areaInfo;

SetAPen(&buffRP,1);
for(depth=0;depth<100;depth++)
    {AreaEllipse(&buffRP,150,110,depth+depth/2,depth);
     AreaEnd(&buffRP);
     WaitTOF();
     BltBitMap(&buffBM,0,0,viewBM,0,0,300,230,0xC0,0x01,NULL);
     for(c=0;c<2;c++)
	{red[c]=rand()%16;
	 green[c]=rand()%16;
	 blue[c]=rand()%16;
	}
     if(!(rand()%2)) triggerSound(rand()%2+1);
     WaitTOF();
     SetRGB4(vPort,0,red[1],green[1],blue[1]);
     SetRGB4(vPort,1,red[0],green[0],blue[0]);
     WaitTOF();
     SetRGB4(vPort,2,red[0],green[0],blue[0]);
     SetRGB4(vPort,3,red[1],green[1],blue[1]);
     WaitTOF();
    }
for(depth=0;depth<32;depth++)
    {if(red[depth%2]<15) red[depth%2]++;
     if(green[depth%2]<15) green[depth%2]++;
     if(blue[depth%2]<15) blue[depth%2]++;
     WaitTOF();
     SetRGB4(vPort,0,red[1],green[1],blue[1]);
     WaitTOF();
     SetRGB4(vPort,1,red[0],green[0],blue[0]);
     WaitTOF();
     SetRGB4(vPort,2,red[0],green[0],blue[0]);
     WaitTOF();
     SetRGB4(vPort,3,red[1],green[1],blue[1]);
     WaitTOF();
    }
}