#include <stdio.h>

#include <libps.h>
#include "fw.h"
#include "pad.h"
#include "Dogfight.h"
#include "inits.h"

void init ( void )
{
	// Lets talk layers :
	// Shots from player 1 = Layer 1
	// Shots from player 2 = Layer 2
	// AA Fire = Layer 3
	// Ground = Layer 4
	// Hangers = Layer 5
	// Player 1 = Layer 6
	// Player 2 = Layer 7

	int	CurrentPlayer;
	int	CurrentShot;
	int	CurrentAAFire;
	int	CurrentSmoke;
	int	WallYPos;
	int	HangerYPos;
	int CurrentGround;
	int	GroundWidth;
	int	NextGroundXPos;
	int	GroundYPos;
	int	PlaneStartY;

	fwActorReset ();
	fwAnimateReset ();

	fwDirectSetBackGround ( 0, 0, 128 );

	// Load up our costumes.
	PlaneCostume = fwCostumeAdd ( TEXTURE_PLANE, 2, 1 );
	ShotCostume = fwCostumeAdd ( TEXTURE_SHOT, 1, 1 );
	AAFireCostume = fwCostumeAdd ( TEXTURE_AAFIRE, 2, 3 );
	GroundCostume = fwCostumeAdd ( TEXTURE_GROUND, 1, 1 );
	HangerCostume = fwCostumeAdd ( TEXTURE_HANGER, 1, 2 );
	WallCostume = fwCostumeAdd ( TEXTURE_WALL, 1, 1 );
	ScoreCostume = fwCostumeAdd ( TEXTURE_SCORE, 2, 5 );

	// For now we shall us the aafire costume as our smoke cloud costume
	SmokeCostume = AAFireCostume;

	// Actors used to display the curret score
	ScoreActor[0] = fwActorAdd ( ScoreCostume );
	ScoreActor[1] = fwActorAdd ( ScoreCostume );
	fwActorSetOnStage ( ScoreActor[0], OFF_STAGE );
	fwActorSetOnStage ( ScoreActor[1], OFF_STAGE );
	
	// Set up the screen details
	GroundActor[0] = fwActorAdd ( GroundCostume );
	fwActorSetLayer( GroundActor[0], STAGE_LAYER_4 );
	fwActorSetOnStage ( GroundActor[0], ON_STAGE );
	GroundYPos = ( fwDirectScreenHeight() - ( fwActorGetPixelHeight ( GroundActor[0] ) >> 1 ) ) << STAGE_SHIFT;
	fwActorPos ( GroundActor[0], ( fwActorGetPixelWidth( GroundActor[0] ) >> 1 ) << STAGE_SHIFT, GroundYPos );
	CurrentGround = 0;
	GroundWidth = fwActorGetPixelWidth ( GroundActor[0] ) << STAGE_SHIFT;
	NextGroundXPos = GroundWidth;
	while ( NextGroundXPos < ( fwDirectScreenWidth() << STAGE_SHIFT ) )
	{
		CurrentGround++;
		GroundActor[CurrentGround] = fwActorAdd ( GroundCostume );
		fwActorPos ( GroundActor[CurrentGround], NextGroundXPos+ ( GroundWidth >> 1 ), GroundYPos );
		fwActorSetLayer( GroundActor[CurrentGround], STAGE_LAYER_4 );
		NextGroundXPos+=GroundWidth;
	}

	WallActor = fwActorAdd ( WallCostume );
	fwActorSetLayer( WallActor, STAGE_LAYER_4 );
	fwActorSetOnStage ( WallActor, ON_STAGE );
	WallYPos = ( ( fwDirectScreenHeight() - fwActorGetPixelHeight ( GroundActor[0] ) ) - ( fwActorGetPixelHeight ( WallActor ) >> 1 ) ) << STAGE_SHIFT;
	fwActorPos ( WallActor, fwDirectScreenWidth() << (STAGE_SHIFT-1), WallYPos );

	HangerActor[0] = fwActorAdd ( HangerCostume );
	fwActorSetLayer( HangerActor[0], STAGE_LAYER_5 );
	HangerActor[1] = fwActorAdd ( HangerCostume+1 );
	fwActorSetLayer( HangerActor[1], STAGE_LAYER_5 );

	HangerYPos = ( ( fwDirectScreenHeight() - fwActorGetPixelHeight ( GroundActor[0] ) ) - ( fwActorGetPixelHeight ( HangerActor[0] ) >> 1 ) ) << STAGE_SHIFT;
	fwActorPos ( HangerActor[0], ( fwActorGetPixelWidth( HangerActor[0] ) >> 1 ) << (STAGE_SHIFT), HangerYPos );
	fwActorPos ( HangerActor[1], ( fwDirectScreenWidth() - ( fwActorGetPixelWidth( HangerActor[1] ) >> 1 ) ) << (STAGE_SHIFT), HangerYPos );
	
	// initialise the animations

	// The planes and shots will be wraping round the stage
	// The parameters for the animations are ( To save on looking up the fwanimat.h file ):
	// 1.	Kind of animation. In this case its repeat so the object will wrap around on the screen
	// 2.	How many times to repeat. -1 indicates that the animation is set to repeat indefinately
	// 3.	What is the initial value of the animation. ( Start position of actor )
	// 4.	Minimum value allowed.
	// 5.	Maximum value allowed
	// 6.	Initial change value for the animation. 0 = stationary. The main game loop will modify 
	//	the change values to move the actors about.
	// 7.	Pasue time. Length of frames to wait between changing animation value. Set to zero as 
	// 	in our case we want to apply the animation for every frame.

	PlaneStartY = ( ( fwDirectScreenHeight() - fwActorGetPixelHeight ( GroundActor[0] ) ) - ( fwActorGetPixelHeight ( PlaneActor[0] ) >> 1 ) );

	XPlaneAnim[0] = fwAnimateAdd ( ANIMATE_REPEAT, -1, ( ( fwActorGetPixelWidth(PlaneActor[0] ) >>1 )<<STAGE_SHIFT), 0, fwDirectScreenWidth()<<STAGE_SHIFT, 0, 0 );
	XPlaneAnim[1] = fwAnimateAdd ( ANIMATE_REPEAT, -1, ( fwDirectScreenWidth() - ( fwActorGetPixelWidth( PlaneActor[1] ) >> 1 ) ) << STAGE_SHIFT, 0, fwDirectScreenWidth()<<STAGE_SHIFT, 0, 0 );
	YPlaneAnim[0] = fwAnimateAdd ( ANIMATE_REPEAT, -1, (PlaneStartY)<< STAGE_SHIFT, 0, fwDirectScreenHeight()<<STAGE_SHIFT, 0, 0 );
	YPlaneAnim[1] = fwAnimateAdd ( ANIMATE_REPEAT, -1, (PlaneStartY)<< STAGE_SHIFT, 0, fwDirectScreenHeight()<<STAGE_SHIFT, 0, 0 );

	// Create the plane actors.
	// NOTE: We will keep the default actor x,y positions as 0. The animations we will be attaching to the planes
	// will move the actors about on the screen
	PlaneActor[0] = fwActorAdd ( PlaneCostume );
	fwActorSetLayer(PlaneActor[0], STAGE_LAYER_6 );

	fwActorSetBoundingScale ( PlaneActor[0], 50 );


	PlaneActor[1] = fwActorAdd ( PlaneCostume+1 );
	fwActorSetLayer(PlaneActor[1], STAGE_LAYER_7 );

	fwActorSetBoundingScale ( PlaneActor[1], 50 );


	// And assign the animations to the x and y positions of the actors.
	fwActorAnimateXPos ( PlaneActor[0], XPlaneAnim[0] );
	fwActorAnimateYPos ( PlaneActor[0], YPlaneAnim[0] );
	fwActorAnimateXPos ( PlaneActor[1], XPlaneAnim[1] );
	fwActorAnimateYPos ( PlaneActor[1], YPlaneAnim[1] );

	// Kick off both the X and Y Plane animations
//	fwAnimateStart ( XPlaneAnim[0] );
//	fwAnimateStart ( XPlaneAnim[1] );
//	fwAnimateStart ( YPlaneAnim[0] );
//	fwAnimateStart ( YPlaneAnim[1] );

	// Initialize all the shots;
	for ( CurrentPlayer = 0; CurrentPlayer < 2; CurrentPlayer++ )
	{
		for ( CurrentShot = 0; CurrentShot < MaxShots; CurrentShot++ )
		{
			// Create the x and y Animations for this shot
			XShotAnim[CurrentPlayer][CurrentShot] = fwAnimateAdd ( ANIMATE_REPEAT, -1, 0, 0, fwDirectScreenWidth()<<STAGE_SHIFT, 0, 0 );
			YShotAnim[CurrentPlayer][CurrentShot] = fwAnimateAdd ( ANIMATE_REPEAT, -1, 0, 0, fwDirectScreenHeight()<<STAGE_SHIFT, 0, 0 );
			
			// Create an actor for this shot
			ShotActor[CurrentPlayer][CurrentShot] = fwActorAdd ( ShotCostume );

			fwActorCollisionLayers ( ShotActor[CurrentPlayer][CurrentShot], STAGE_LAYER_3 | STAGE_LAYER_4 | STAGE_LAYER_5 );
			if ( CurrentPlayer == 0 )
			{
				fwActorSetLayer(ShotActor[CurrentPlayer][CurrentShot], STAGE_LAYER_1 );
				fwActorCollisionLayers ( ShotActor[CurrentPlayer][CurrentShot], STAGE_LAYER_3 | STAGE_LAYER_4 | STAGE_LAYER_5 | STAGE_LAYER_1 | STAGE_LAYER_2 );
			}
			else
			{
				fwActorSetLayer(ShotActor[CurrentPlayer][CurrentShot], STAGE_LAYER_2 );
				fwActorCollisionLayers ( ShotActor[CurrentPlayer][CurrentShot], STAGE_LAYER_3 | STAGE_LAYER_4 | STAGE_LAYER_5 | STAGE_LAYER_1 | STAGE_LAYER_2 );
			}
			
			// Assign the x,y Animtions to the actor
			fwActorAnimateXPos ( ShotActor[CurrentPlayer][CurrentShot], XShotAnim[CurrentPlayer][CurrentShot] );
			fwActorAnimateYPos ( ShotActor[CurrentPlayer][CurrentShot], YShotAnim[CurrentPlayer][CurrentShot] );

			// Add kick the animations off
			fwAnimateStart ( XShotAnim[CurrentPlayer][CurrentShot] );
			fwAnimateStart ( YShotAnim[CurrentPlayer][CurrentShot] );
		}
	}

	// Initialise all the Anti Aircraft Fire 
	for ( CurrentAAFire = 0; CurrentAAFire < TotalAAFire; CurrentAAFire++ )
	{
		// Create an actor for this shot
		AAFireActor[CurrentAAFire] = fwActorAdd ( AAFireCostume );

		// Make the explosions twice thier actual size.. we like big explosions
		fwActorSetScale ( AAFireActor[CurrentAAFire], 4096 << 1 );

		// The smoke is transparent
		fwActorSetTransparency ( AAFireActor[CurrentAAFire], ACTOR_TRANSPARENCY_ON + ACTOR_TRANSPARENCY_ADD_AND_HALF );

		// The last 2 aa fires are reserved to player explosions and 
		// therefore MUST NOT be set to the active layer otherwise the
		// Players will collide with thier own explosions ( NOT GOOD )
		if ( CurrentAAFire < ( TotalAAFire - 2 ) )
			fwActorSetLayer(AAFireActor[CurrentAAFire], STAGE_LAYER_3 );

		// Create the costume animation for this AAFire
		CostumeAAFireAnim[CurrentAAFire] = fwAnimateAdd ( ANIMATE_REPEAT, 1, 0,0,5,1,10 );

		// Assign the Animation to the AAFire actor costume.
		fwActorAnimateCostume ( AAFireActor[CurrentAAFire],CostumeAAFireAnim[CurrentAAFire] );

		// NOTE : In this case we will not be kicking off the animation until required.
	}

	// Initialise all the Plane smoke clouds
	for ( CurrentPlayer = 0; CurrentPlayer < 2; CurrentPlayer++ )
	{
		for ( CurrentSmoke = 0; CurrentSmoke < 10; CurrentSmoke++ )
		{
			SmokeActor[CurrentPlayer][CurrentSmoke] = fwActorAdd ( SmokeCostume );

			// Create the costume animation for this AAFire
			ScaleSmokeAnim[CurrentPlayer][CurrentSmoke] = fwAnimateAdd ( ANIMATE_REPEAT, 1, 0, 0, 16000,100,1 );

			// Assign the Animation to the AAFire actor costume.
			fwActorAnimateScale ( SmokeActor[CurrentPlayer][CurrentSmoke], ScaleSmokeAnim[CurrentPlayer][CurrentSmoke] );

			// The smoke is transparent
			fwActorSetTransparency ( SmokeActor[CurrentPlayer][CurrentSmoke], ACTOR_TRANSPARENCY_ON + ACTOR_TRANSPARENCY_ADD_QUARTER );
			
			// Of course its not actualy on stage to start with
			fwActorSetOnStage ( SmokeActor[CurrentPlayer][CurrentSmoke], OFF_STAGE );
		}
	}

}

void initGame ( void )
{
	int	CurrentPlayer;
	int	CurrentShot;
	int	CurrentAAFire;

	// Reset the position of both planes.
	// This is done simply by starting the animations again
	fwAnimateStart ( XPlaneAnim[0] );
	fwAnimateStart ( XPlaneAnim[1] );
	fwAnimateStart ( YPlaneAnim[0] );
	fwAnimateStart ( YPlaneAnim[1] );

	// Set the Plane speed in both x and y direction to 0.
	// We need to do this because simply restarting the animation does not reset its 
	// change value.
//	fwAnimateSetChangeValue ( XPlaneAnim[0], 0 );
//	fwAnimateSetChangeValue ( YPlaneAnim[0], 0 );
//	fwAnimateSetChangeValue ( XPlaneAnim[1], 0 );
//	fwAnimateSetChangeValue ( YPlaneAnim[1], 0 );

	// Set the initial angles of each plane
//	fwActorSetAngle (PlaneActor[0], 90 );
//	fwActorSetAngle (PlaneActor[1], 270 );
//	fwActorSetAngle (PlaneActor[0], 85 );
//	fwActorSetAngle (PlaneActor[1], 275 );

	SetPlayerStage( 0, PLAYER_LANDED );
	SetPlayerStage( 1, PLAYER_LANDED );

	// Initialize all the shots;
	// In this case all we need to do is set them to be off stage.

	// NOTE : You may have noticed that all the shot animations are permanantly running even 
	// though the shots they are attached to are off stage. This is a bit of an overhead in terms
	// of processing required for each frame but this is a very simple game so it doesnt actually 
	// affect the game speed. Why bother trying to conserve CPU time when it'll only end up
	// sitting idle anyway ?

	for ( CurrentPlayer = 0; CurrentPlayer < 2; CurrentPlayer++ )
	{
		for ( CurrentShot = 0; CurrentShot < MaxShots; CurrentShot++ )
		{
			// Mark the shot as being off stage
			fwActorSetOnStage ( ShotActor[CurrentPlayer][CurrentShot], OFF_STAGE );
		}
	}

	for ( CurrentAAFire = 0; CurrentAAFire < TotalAAFire; CurrentAAFire++ )
	{
		// Mark the shot as being off stage
		fwActorSetOnStage ( AAFireActor[CurrentAAFire], OFF_STAGE );
	}

	// Reset the scores
	PlayerKills[0] = 0;
	PlayerKills[1] = 0;
}

void initPlayer ( int Player )
{
	fwAnimateSetChangeValue ( XPlaneAnim[Player], 0 );
	fwAnimateSetChangeValue ( YPlaneAnim[Player], 0 );

	fwAnimateStart ( XPlaneAnim[Player] );
	fwAnimateStart ( YPlaneAnim[Player] );
	// Reset angle of player too 
	if ( Player == 0 )
		fwActorSetAngle (PlaneActor[0], 75 );
	else
		fwActorSetAngle (PlaneActor[1], 285 );
}

void initPlaneSmoke ( int CurrentPlayer )
{
	int	CurrentSmoke;
	int	SmokeXPos;
	int	SmokeYPos;
	int	LifeSpan;

	LifeSpan = 1;
	SmokeXPos = ( fwActorGetPixelWidth ( SmokeActor [0][0] ) << (STAGE_SHIFT) ) * -1;
	SmokeYPos = ( fwActorGetPixelHeight ( SmokeActor [0][0] ) << (STAGE_SHIFT) ) * -1;

	// Cycle through all the smoke clouds and place them off screen
	for ( CurrentSmoke = 0; CurrentSmoke < 10; CurrentSmoke++ )
	{
		fwActorPos ( SmokeActor [CurrentPlayer][CurrentSmoke], SmokeXPos, SmokeYPos );
		fwActorSetOnStage ( SmokeActor [CurrentPlayer][CurrentSmoke], ON_STAGE );
		// Set the lifespan
		fwActorSetLifeSpan ( SmokeActor [CurrentPlayer][CurrentSmoke], LifeSpan );
		LifeSpan += 12;
	}
}