#include "WolfDef.h"
#include <string.h>
#include <stdlib.h>

extern Word NumberIndex;	/* Hack for drawing numbers */
static LongWord BJTime;	/* Time to draw BJ? */
static Word WhichBJ;	/* Which BJ to show */
static LongWord Indexs[3];		/* Offsets to BJ's true shapes */
static Byte *BJPtr;			/* Pointer to BJ's shapes */
static Word ParTime;		/* Par time for level */
static LongWord BonusScore;	/* Additional points */

#define BONUSX	353
#define BONUSY	103
#define	TIMEX	353
#define TIMEWIDTH 36
#define	TIMEY	140
#define	TIMEY2	180
#define SCOREX 353
#define SCOREY 332
#define	RATIOX	353
#define	RATIOY	217
#define	RATIOY2	253
#define	RATIOY3	291

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

	Draw BJ if needed
	
**********************************/

static Rect BJRect = {48,73,48+142,73+131};	/* Rect for BJ's picture */
static void ShowBJ(void) 
{		
	if ((ReadTick()-BJTime) >= 20) {		/* Time to draw a BJ? */
		BJTime = ReadTick();				/* Set the new time */
		if (WhichBJ!=2) {			/* Thumbs up? */
			WhichBJ ^= 1;			/* Nope, toggle breathing */
		}
		DrawShape(73,48,&BJPtr[Indexs[WhichBJ]]);		/* Draw BJ */
		BlastScreen2(&BJRect);				/* Update video */
	}
}

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

	Have BJ Breath for a while
	
**********************************/

static void BJBreath(Word Delay)
{
	do {
		ShowBJ();
		if (WaitTicksEvent(1)) {
			break;
		}
	} while (--Delay);
}

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

	Draw the score 
	
**********************************/

static Rect ScoreRect = {SCOREY,SCOREX,SCOREY+22,SCOREX+(12*7)};

static void DrawIScore(void) 
{
	SetNumber(gamestate.score,SCOREX,SCOREY,7);		/* Draw the game score */
	BlastScreen2(&ScoreRect);
}

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

	Draw the earned bonus
	
**********************************/

static Rect BonusRect = {BONUSY,BONUSX,BONUSY+22,BONUSX+(12*7)};
static void DrawIBonus(void)
{
	SetNumber(BonusScore,BONUSX,BONUSY,7);
	BlastScreen2(&BonusRect);
}

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

	Draw a time value at the given coords
	
**********************************/

static void DrawTime(Word x,Word y,Word time)
{
	Word minutes,seconds;
	Rect TimeRect;

	TimeRect.left = x;
	TimeRect.right = x+((12*4)+TIMEWIDTH);
	TimeRect.top = y;
	TimeRect.bottom = y+22;
	
	minutes = time/60;
	seconds = time%60;
	SetNumber(minutes,x,y,2);
	x+=TIMEWIDTH;
	SetNumber(seconds,x,y,2);
	BlastScreen2(&TimeRect);
}

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

	Draws a ratio value at the given coords.
	
**********************************/

static void DrawRatio(Word x,Word y,Word theRatio)
{
	Rect RatioRect;
	
	RatioRect.top = y;
	RatioRect.left = x;
	RatioRect.bottom = y+22;
	RatioRect.right = x+(3*12);
	SetNumber(theRatio,x,y,3);
	BlastScreen2(&RatioRect);
}

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

	RollScore
	Do a Bill-Budgey roll of the old score to the new score,
	not bothering with the lower digit, as you never get less
	than ten for anything.

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

static void RollScore(void)
{
	Word i;

	do {
		if (BonusScore>1000) {
			i = 1000;
		} else {
			i = BonusScore;
		}
		BonusScore-=i;
		GivePoints(i);
		ShowBJ();
		DrawIScore();
		DrawIBonus();
		PlaySound(SND_MGUN|0x8000);
		if (WaitTicksEvent(6)) {
			GivePoints(BonusScore);	/* Add the final bonus */
			BonusScore=0;
			DrawIScore();
			DrawIBonus();
			break;
		}
	} while (BonusScore);
}

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

	RollRatio
	Do a Bill-Budgey roll of the ratio.

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

static void RollRatio(Word x,Word y,Word ratio)
{
	Word i;
	Word NoDelay;

	i = 0;
	NoDelay = 0;
	while (i<ratio) {
		DrawRatio(x,y,i);
		PlaySound(SND_MGUN|0x8000);
		ShowBJ();
		if (WaitTicksEvent(6)) {	
			NoDelay = 1;
			break;
		}
		i+=10;
	}
	DrawRatio(x,y,ratio);

	/* make ding sound */

	if (ratio==100) {
		if (!NoDelay) {
			PlaySound(SND_EXTRA);
			WaitTicks(30);
		}
		BonusScore += 10000;
		DrawIBonus();
		if (!NoDelay) {
			BJBreath(60);	/* Breath a little */
		}
	}
}

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

	Let's show 'em how they did!
	
**********************************/

void LevelCompleted (void)
{
	Word k;
	LongWord *PackPtr;
	Byte *ShapePtr;
	LongWord PackLength;

/* setup */

	ParTime = MapListPtr->InfoArray[gamestate.mapon].ParTime;
	BonusScore = 0;		/* Init the bonus */
	
	IntermissionHack = TRUE;	/* Hack to keep score from drawing twice */
	NumberIndex = 47;		/* Hack to draw score using an alternate number set */
	NewGameWindow(1);		/* Force 512 mode screen */
	PackPtr = LoadAResource(rIntermission);
	PackLength = PackPtr[0];
	ShapePtr = (Byte *) AllocSomeMem(PackLength);
	DLZSS(ShapePtr,(Byte *) &PackPtr[1],PackLength);
	DrawShape(0,0,ShapePtr);
	FreeSomeMem(ShapePtr);
	ReleaseAResource(rIntermission);
	PackPtr = LoadAResource(rInterPics);
	PackLength = PackPtr[0];
	BJPtr = (Byte *)AllocSomeMem(PackLength);
	DLZSS(BJPtr,(Byte *) &PackPtr[1],PackLength);
	ReleaseAResource(rInterPics);
	memcpy(Indexs,BJPtr,12);		/* Copy the index table */
	
	WhichBJ = 0;		/* Init BJ */
	BJTime = ReadTick()-50;		/* Force a redraw */
	BlastScreen();		/* Draw the screen */
	ShowBJ();			/* Draw BJ */
	StartSong(SongListPtr[1]);	/* Play the intermission song */
	SetAPalette(rInterPal);	/* Set the palette */
	DrawIScore();			/* Draw the current score */
	FlushKeys();			/* Flush the keyboard buffer */

	/* First an initial pause */
	
	BJBreath(60);

	/* Display Par Time, Player's Time, and show bonus if any. */

	if (gamestate.playtime>=(100*60*60UL)) {
		k =(99*60)+59;
	} else {
		k = gamestate.playtime/60;
	}
	DrawTime(TIMEX,TIMEY,k);		/* How much time has elapsed? */
	DrawTime(TIMEX,TIMEY2,ParTime);

	if (k < ParTime) {
		k = (ParTime-k) * 50;		/* 50 points per second */
		BonusScore += k;		/* Add to the bonus */
		DrawIBonus();			/* Draw the bonus */
		PlaySound(SND_EXTRA);
		BJBreath(60);			/* Breath a little */
	}

/* Show ratios for "terminations", treasure, and secret stuff. */
/* If 100% on all counts, Perfect Bonus! */

	k=0;		/* Not perfect (Yet) */
	RollRatio(RATIOX,RATIOY,(gamestate.treasurecount*100)/gamestate.treasuretotal);
	if (gamestate.treasurecount == gamestate.treasuretotal) {
		k++;			/* Perfect treasure */
	}
	RollRatio(RATIOX,RATIOY2,(gamestate.killcount*100)/gamestate.killtotal);
	if (gamestate.killcount == gamestate.killtotal) {
		k++;			/* Perfect kills */
	}
	RollRatio(RATIOX,RATIOY3,(gamestate.secretcount*100)/gamestate.secrettotal);
	if (gamestate.secretcount == gamestate.secrettotal) {
		k++;			/* Perfect secret */
	}
	if (BonusScore) {	/* Did you get a bonus? */
		RollScore();
		BJBreath(60);
	}
	if (k==3) {
		WhichBJ = 2;	/* Draw thumbs up for BJ */
		PlaySound(SND_THUMBSUP);
	}
	do {
		ShowBJ();		/* Animate BJ */
	} while (!WaitTicksEvent(1));		/* Wait for a keypress */
	FreeSomeMem(BJPtr);		/* Release BJ's shapes */
	FadeToBlack();		/* Fade away */
	IntermissionHack = FALSE;		/* Release the hack */
	NumberIndex = 36;			/* Restore the index */
}

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

	Handle the intermission screen
	
**********************************/

void Intermission (void)
{
	FadeToBlack();
	LevelCompleted();			/* Show the data (Init ParTime) */
	gamestate.globaltime += gamestate.playtime;		/* Add in the playtime */
	gamestate.globaltimetotal += ParTime;	/* Get the par */
	gamestate.globalsecret += gamestate.secretcount;	/* Secrets found */
	gamestate.globaltreasure += gamestate.treasurecount;	/* Treasures found */
	gamestate.globalkill += gamestate.killcount;	/* Number killed */
	gamestate.globalsecrettotal += gamestate.secrettotal;	/* Total secrets */
	gamestate.globaltreasuretotal += gamestate.treasuretotal;	/* Total treasures */
	gamestate.globalkilltotal += gamestate.killtotal;	/* Total kills */
	SetupPlayScreen();		/* Reset the game screen */
}

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

	Okay, let's face it: they won the game.
	
**********************************/

void VictoryIntermission (void)
{
	FadeToBlack();
	LevelCompleted();
}

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

	Show player the game characters
	
**********************************/

#define NUMCAST 12
Word caststate[NUMCAST] = {
ST_GRD_WLK1, ST_OFC_WLK1, ST_SS_WLK1,ST_MUTANT_WLK1,
ST_DOG_WLK1, ST_HANS_WLK1, ST_SCHABBS_WLK1, ST_TRANS_WLK1,
ST_UBER_WLK1, ST_DKNIGHT_WLK1,ST_MHITLER_WLK1, ST_HITLER_WLK1};

#if 0
char *casttext[NUMCAST] = { /* 28 chars max */
"GUARD",
"OFFICER",
"ELITE GUARD",
"MUTANT",
"MUTANT RAT",
"HANS GROSSE",
"DR. SCHABBS",
"TRANS GROSSE",
"UBERMUTANT",
"DEATH KNIGHT",
"MECHAMEISTER",
"STAATMEISTER"
};
#endif

void CharacterCast(void)
{
	Word Enemy,count, cycle;
	Word up;
	state_t *StatePtr;

/* reload level and set things up */

	gamestate.mapon = 0;		/* First level again */
	PrepPlayLoop();				/* Prepare the system */
	viewx = actors[0].x;		/* Mark the starting x,y */
	viewy = actors[0].y;

	topspritescale = 32*2;

/* go through the cast */

	Enemy = 0;
	cycle = 0;
	do {
		StatePtr = &states[caststate[Enemy]];		/* Init the state pointer */
		count = 1;			/* Force a fall through on first pass */
		up = FALSE;
		for (;;) {
			if (++cycle>=60*4) {		/* Time up? */
				cycle = 0;				/* Reset the clock */
				if (++Enemy>=NUMCAST) {	/* Next bad guy */
					Enemy = 0;			/* Reset the bad guy */
				}
				break;
			}
			if (!--count) {
				count = StatePtr->tictime;
				StatePtr = &states[StatePtr->next];
			}
			topspritenum = StatePtr->shapenum;	/* Set the formost shape # */
			RenderView();		/* Show the 3d view */
			WaitTicks(1);		/* Limit to 15 frames a second */
			ReadSystemJoystick();	/* Read the joystick */
			if (!joystick1 && !up) {
				up = TRUE;
				continue;
			}
			if (!up) {
				continue;
			}
			if (!joystick1) {
				continue;
			}
			if (joystick1 & (JOYPAD_START|JOYPAD_A|JOYPAD_B|JOYPAD_X|JOYPAD_Y)) {
				Enemy = NUMCAST;
				break;
			}
			if ( (joystick1 & (JOYPAD_TL|JOYPAD_LFT)) && Enemy >0) {
				Enemy--;
				break;
			}
			if ( (joystick1 & (JOYPAD_TR|JOYPAD_RGT)) && Enemy <NUMCAST-1) {
				Enemy++;
				break;
			}
		}
	} while (Enemy < NUMCAST);	/* Still able to show */
	StopSong();		/* Stop the music */
	FadeToBlack();	/* Fade out */
}