//------------------------------------------------------------------------------
// File: missile.c
// Author: George Bain
// Date: May 24, 1997
// Descriptions: Missile related routines and collision routines
// Copyright (C) 1997 George Bain, All Rights Reserved
//------------------------------------------------------------------------------

//------------------------------------------------------------------------------
// I N C L U D E S
//------------------------------------------------------------------------------

#include <libps.h>	   // standard Sony library
#include "missile.h"
#include "gfx.h"


//------------------------------------------------------------------------------
// G L O B A L S
//------------------------------------------------------------------------------

particle_handler missile[NUM_MISSILES];  // the missiles

//------------------------------------------------------------------------------
// Function: InitMissiles()
// Description: Initialize the missiles
// Parameters: none
// Returns: void
// Notes: N/A
//------------------------------------------------------------------------------

void InitMissiles( void )
 {
    
    int count;

	for( count=0; count<NUM_MISSILES; count++ )
	     InitParticle( (particle_ptr)&missile[count].rect,0,0,3,1,RED_MISSILE,0,0,
		               0,0,MISSILE_DEAD,0,0 );
	printf("Init missiles complete\n");

 }// InitMissiles




//------------------------------------------------------------------------------
// Function: DrawMissiles()
// Description: Register missiles into the OT
// Parameters: none
// Returns: void
// Notes: N/A
//------------------------------------------------------------------------------

void DrawMissiles( void )
 {

    int count;

	for( count=0; count<NUM_MISSILES; count++ ) 
	   {

		  if( missile[count].state == MISSILE_ALIVE )
              GsSortBoxFill( &missile[count].rect, 
			                 &world_ordering_table[output_buffer_index], 0 );
				  
	   }// end for
	    
 }// end DrawMissiles  




//------------------------------------------------------------------------------
// Function: StartMissiles()
// Description: Start the missile at the given location, set up fields
// Parameters: x: x location of missile
//             y: y location of missile
//             xv: x velocity of missile
//             yv: y velocity of missile
//             r: g: b: RGB values of missile
//             tag: the owner of missile
// Returns: void
// Notes: Needs improvement
//------------------------------------------------------------------------------

void StartMissiles( int x, int y, int xv, int yv,
			        unsigned char r, unsigned char g,
					unsigned char b, int tag )
 {

	
	int count;
    
	// check all missiles
	for( count=0; count<NUM_MISSILES; count++ ) 
	   {

	      // check if missile state is DEAD
	      if( missile[count].state == MISSILE_DEAD ) 
		    {

		      // set up the fields
			  missile[count].state  = MISSILE_ALIVE; 
		      missile[count].rect.x = x;
		      missile[count].rect.y = y;
		      missile[count].xv     = xv;
		      missile[count].yv     = yv;
		      missile[count].tag    = tag;
		      missile[count].rect.r = r;
		      missile[count].rect.g = g;
		      missile[count].rect.b = b;

		      break; //exit loop

	        }// end if 

	   }// end for

 }// end StartMissiles




//------------------------------------------------------------------------------
// Function: MoveMissiles()
// Description: Move the missile and perform collision checks
// Parameters: none
// Returns: void
// Notes: N/A
//------------------------------------------------------------------------------
 
void MoveMissiles( void )
  {

	 int count,               // loop vars
		 miss_x, miss_y;      // location of missile
		 
	 // check all missiles
	 for( count=0; count<NUM_MISSILES; count++ ) 
	    {
          // check if missile is ALIVE
		  if( missile[count].state == MISSILE_ALIVE ) 
		    {
			  // missile is ALIVE so move missile
			  miss_x = ( missile[count].rect.x += missile[count].xv );
			  miss_y = ( missile[count].rect.y += missile[count].yv );

			  // test if missile hit edge of screen
			  if( (miss_x >= (SCREEN_WIDTH-2)) || (miss_x <=3) ||
				  (miss_y >= (SCREEN_HEIGHT-2)) || (miss_y <=3) )
				{
                    // missile has hit edge of screen ..kill it
					missile[count].state = MISSILE_DEAD;
					// go on with other tests
					continue;           

				}// end if 

				// test for player missile -> enemy moving left collision
				PlayerMissileCollideLeft( miss_x, miss_y );

				// test for player missile -> enemy moving right collision
				PlayerMissileCollideRight( miss_x, miss_y );

				// test for enemy missile -> player collision
				EnemyMissileCollide( miss_x, miss_y );

				// tests for player missile -> boss_one collision
				PlayerBossMissile( miss_x, miss_y );

				// test for player missile -> rocket collision
				PlayerRocketCollision( miss_x, miss_y );

		    }// end if missile ALIVE

	    }// end NUM_MISSILES

 }// end MoveMissiles




//------------------------------------------------------------------------------
// Function: PlayerMissileCollideLeft()
// Description: Check if players missiles hit enemies moving to the
//              left of the screen, if TRUE destroy the enemy and
//              display explosion animation
// Parameters: miss_x: x location of missile
//             miss_y: y location of missile
// Returns: void
// Notes: This could be improved
//------------------------------------------------------------------------------
 
void PlayerMissileCollideLeft( int miss_x, int miss_y )
 {

	int count, count_2,   // loop vars
		enemy_hit = 0;    // hit indicator

	object_ptr current;  // current enemy 
		      
    // check against all missiles
	for( count=0; count<NUM_MISSILES; count++ ) 
	   {
         // check if missile is ALIVE and belongs to player
		 if( ( missile[count].state == MISSILE_ALIVE ) && 
			 ( missile[count].tag == PLAYER_MISSILE ) ) 
		   {
		     // check missile against all enemies
			 for( count_2=0; count_2<NUM_ENEMIES; count_2++ )
				{
				  // extract current enemy
			      current  = (object_ptr)&blue_enemy[count_2];
                    
				  // check if current enemy is ALIVE
				  if( current->state == ENEMY_ALIVE )
					{
					  // test for collision
					  if( MissileCollision( (particle_ptr)&missile[count],
				                            (object_ptr)&blue_enemy[count_2] ) )
			            {

						  // kill missile
						  missile[count].state = MISSILE_DEAD;

						  // kill enemy
						  current->state = ENEMY_DEAD;
                              
                          // enemy hit indicator
						  enemy_hit = 1;  

						  // start an explosion
						  StartExplosions( current->sprite.x+10, 
							  	           current->sprite.y+10, 
										   EXPLOSION_SPEED );
                             
						  // increase players score 
						  game_info.money += 10;

						}// end if collision
						
					}// end if enemy ALIVE

				  if( enemy_hit ) 
					  break;  

			    }// end for NUM_ENEMIES
				
		   }// end if Missile is ALIVE and is players

	  }// end for NUM_MISSILES

 }// end PlayerMissileCollideLeft




//------------------------------------------------------------------------------
// Function: PlayerMissileCollideRight()
// Description: Check if players missiles hit enemies moving to the
//              right of the screen, if TRUE destroy the enemy and
//              display explosion animation
// Parameters: miss_x: x location of missile
//             miss_y: y location of missile
// Returns: void
// Notes: This could be improved
//------------------------------------------------------------------------------

void PlayerMissileCollideRight( int miss_x, int miss_y )
 {

	int count, count_2,   // loop vars
		enemy_hit = 0;    // hit indicator

	object_ptr current;  // current enemy 
		      
    // check against all missiles
	for( count=0; count<NUM_MISSILES; count++ ) 
	   {
         // check if missile is ALIVE and belongs to player
		 if( ( missile[count].state == MISSILE_ALIVE ) && 
			 ( missile[count].tag == PLAYER_MISSILE ) ) 
		   {
		     // check missile against all enemies
			 for( count_2=0; count_2<NUM_ENEMIES; count_2++ )
				{
				  // extract current enemy
			      current  = (object_ptr)&red_enemy[count_2];
                    
				  // check if current enemy is ALIVE
				  if( current->state == ENEMY_ALIVE )
					{
					  // test for collision
					  if( MissileCollision( (particle_ptr)&missile[count],
				                            (object_ptr)&red_enemy[count_2] ) )
			            {

						  // kill missile
						  missile[count].state = MISSILE_DEAD;

						  // kill enemy
						  current->state = ENEMY_DEAD;
                              
                          // enemy hit indicator
						  enemy_hit = 1;  

						  // start an explosion
						  StartExplosions( current->sprite.x+10, 
							  	           current->sprite.y+10, 
										   EXPLOSION_SPEED );
                             
						  // increase players score 
						  game_info.money += 10;

						}// end if collision
						
					}// end if enemy ALIVE

				  if( enemy_hit ) 
					  break;  

			    }// end for NUM_ENEMIES
				
		   }// end if Missile is ALIVE and is players

	  }// end for NUM_MISSILES

 }// end PlayerMissileCollideRight




//------------------------------------------------------------------------------
// Function: EnemyMissileCollide()
// Description: Check if enemy missiles hit player, if true
//              players energy level goes down a bit
// Parameters: miss_x: x location of missile
//             miss_y: y location of missile
// Returns: void
// Notes: N/A
//------------------------------------------------------------------------------

void EnemyMissileCollide( int miss_x, int miss_y )
 {

	int count,
		player_hit = 0;
    
	// check all missiles
	for( count=0; count<NUM_MISSILES; count++ ) 
	   {
         // check if player is ALIVE and the missile is enemies
		 if( (player.state == PLAYER_ALIVE) && (missile[count].tag ==
			 ENEMY_MISSILE) )
		   {
		     // test for collision
			 if( MissileCollision( (particle_ptr)&missile[count],
				                   (object_ptr)&player ) )
			   {
				 // hit indicator
				 player_hit = 1;

				 // decrease energy
				 game_info.player_energy -=1;   
				 
				 // kill the missile
				 missile[count].state = MISSILE_DEAD;
                
			   }// end bounding box

			   if( player_hit )  // slow things down a bit..break!
				   break;

		   }// end if player ALIVE

	   }// end NUM_MISSILES

 }// end EnemyMissileCollide




//------------------------------------------------------------------------------
// Function: PlayerBossMissile()
// Description: Check if players missiles hit boss, if true
//              boss energy level goes down a bit
// Parameters: miss_x: x location of missile
//             miss_y: y location of missile
// Returns: void
// Notes: N/A
//------------------------------------------------------------------------------

void PlayerBossMissile( int miss_x, int miss_y )
 {

	int count,
		boss_hit= 0;

	for( count=0; count<NUM_MISSILES; count++ ) 
	   {

		 if( (boss_one.state == BOSS_ALIVE) && (missile[count].tag ==
			  PLAYER_MISSILE) )
		   {
              
			 // test for collision
			 if( MissileCollision( (particle_ptr)&missile[count],
				                   (object_ptr)&boss_one ) )
			   {
                 // hit indicator
				 boss_hit = 1;

				 // decrease boss energy
				 game_info.boss_energy -= 1; 
                 
				 // kill the missile
				 missile[count].state = MISSILE_DEAD;

			   }// end collision

			   if( boss_hit )
				   break;

		   }// end if boss ALIVE

	   }// end NUM_MISSILES

 }// end PlayerBossMissile




//------------------------------------------------------------------------------
// Function: PlayerRocketCollision()
// Description: Check if players missiles hit rocket, if true
//              destroy the rocket and display explosion animation
// Parameters: miss_x: x location of missile
//             miss_y: y location of missile
// Returns: void
// Notes: N/A
//------------------------------------------------------------------------------

void PlayerRocketCollision( int miss_x, int miss_y)
 {

	int count, count_2, // loop vars
	    rocket_hit = 0;
		
	object_ptr current; // current rocket being processed

	// check all rockets for a collison
	for( count=0; count<NUM_ROCKETS; count++ ) 
	   {
         // chcek if rocket is ALIVE
		 if( rockets[count].state == ROCKET_ALIVE ) 
		   {
             // extract current rocket
			 current = (object_ptr)&rockets[count];

		     // check all missiles against current rocket
			 for( count_2=0; count_2<NUM_MISSILES; count_2++ )
			    {
                  // check the missile tag 
			      if( missile[count_2].tag == PLAYER_MISSILE ) 
			        {       
					  // check for bounding box	
			  	      if( MissileCollision( (particle_ptr)&missile[count_2],
				                            (object_ptr)&rockets[count] ) )
			            {
                                 
						  // there is a hit..kill the missile
                          missile[count_2].state = MISSILE_DEAD;
                          
						  // hit indicator
						  rocket_hit = 1;

						  // there is a hit..kill the rocket
						  current->state = ROCKET_DEAD;
						  
						  // start an explosion
						  StartExplosions( current->sprite.x+5, 
						                   current->sprite.y+2, 
						    			   EXPLOSION_SPEED );
                             
					      // increase players score 
						  game_info.money +=5;

						}// end bounding boxes

					    if( rocket_hit )
							break;

				     }// end if missile is PLAYERS

			    }// end for NUM_MISSILES

		   }// end if rocket is ALIVE

	   }// end for NUM_ROCKETS

 }// end PlayerRocketCollision


//--------------------------------EOF--------------------------------------------