//--------------------------------------------------------------------------
// File: grid_control.c
// Description: Contains Functions to control Grid States
// Notes: N/A
//--------------------------------------------------------------------------

//----------------
// Includes
//----------------

#include <libps.h>				// Standard PSX Libs

#include "grid_control.h"
#include "main.h"


//-----------------
// Grid Structure
//----------------- 

struct Grid{
	int x;
	int y;
	int row;
	int state;
	} Grid[73];

//----------------------
// Grid[].state #defines
//----------------------

#define		GRID_EMPTY		0
#define		GRID_RED		1
#define		GRID_YELLOW		2
#define		GRID_BLUE		3
#define		GRID_GREEN		4

//----------------------
// Global Variables
//----------------------

int GemType;
int DropDelay = 0;


//----------------
// External Data
//----------------

extern GsSPRITE		RedGem;
extern GsSPRITE		YellowGem;
extern GsSPRITE		BlueGem;
extern GsSPRITE		GreenGem;

#define		GEM_DROPPING		1
#define		GEM_NOT_DROPPING	0

#define		RUN_GAME			0
#define		STOP_GAME			1

extern	int GameState;
extern	int DropGemPosition;
extern	int GemDropState;

//--------------------------------------------------------------------------
// Function: void InitGrid(void) 
// Description: Initalizes all Grids 
// Parameters: none
// Returns: none
// Notes: N/A
//--------------------------------------------------------------------------

void InitGrid(void)
	{
	int i;
	int x;
	int y;
	int row;
	
	for(i=1;i<73;i++)
		{
		switch(i){
			case 1:
				x=40;
				y=24;
				row=1;
				break;
			case 7:
				x=40;
				y+=16;
				row=2;
				break;
			case 13:
				x=40;
				y+=16;
				row=3;
				break;
			case 19:
				x=40;
				y+=16;
				row=4;
				break;
			case 25:
				x=40;
				y+=16;			
				row=5;
				break;
			case 31:
				x=40;
				y+=16;			
				row=6;
				break;
			case 37:
				x=40;
				y+=16;			
				row=7;
				break;
			case 43:
				x=40;
				y+=16;			
				row=8;
				break;
			case 49:
				x=40;
				y+=16;			
				row=9;
				break;
			case 55:
				x=40;
				y+=16;			
				row=10;
				break;
			case 61:
				x=40;
				y+=16;			
				row=11;
				break;
			case 67:
				x=40;
				y+=16;			
				row=12;
				break;
			}
		Grid[i].x = x;
		Grid[i].y = y;
		Grid[i].row = row;
		Grid[i].state = GRID_EMPTY;	// should be GRID_EMPTY normally
		x+=16;
		}
		
		
}// InitGrid
	
		
		
//--------------------------------------------------------------------------
// Function: void PrintGridValues(void) 
// Description: Prints Grid values
// Parameters: none
// Returns: none
// Notes: N/A
//--------------------------------------------------------------------------

void PrintGridValues(void) 
	{
	int i;
		
	for(i=1;i<13;i++)
		{
		switch(i){
			case 1:
				printf("Grid[%d].x = %d\n", i, Grid[i].x);
				printf("Grid[%d].y = %d\n", i, Grid[i].y);
				printf("Grid[%d].row = %d\n", i, Grid[i].row);
				printf("Grid[%d].state = %d\n", i, Grid[i].state);
				break;
			case 7:
				printf("Grid[%d].x = %d\n", i, Grid[i].x);
				printf("Grid[%d].y = %d\n", i, Grid[i].y);
				printf("Grid[%d].row = %d\n", i, Grid[i].row);
				printf("Grid[%d].state = %d\n", i, Grid[i].state);
				break;
			case 13:
				printf("Grid[%d].x = %d\n", i, Grid[i].x);
				printf("Grid[%d].y = %d\n", i, Grid[i].y);
				printf("Grid[%d].row = %d\n", i, Grid[i].row);
				printf("Grid[%d].state = %d\n", i, Grid[i].state);
				break;
			case 19:
				printf("Grid[%d].x = %d\n", i, Grid[i].x);
				printf("Grid[%d].y = %d\n", i, Grid[i].y);
				printf("Grid[%d].row = %d\n", i, Grid[i].row);
				printf("Grid[%d].state = %d\n", i, Grid[i].state);
				break;
			case 25:
				printf("Grid[%d].x = %d\n", i, Grid[i].x);
				printf("Grid[%d].y = %d\n", i, Grid[i].y);
				printf("Grid[%d].row = %d\n", i, Grid[i].row);
				printf("Grid[%d].state = %d\n", i, Grid[i].state);
				break;
			case 31:
				printf("Grid[%d].x = %d\n", i, Grid[i].x);
				printf("Grid[%d].y = %d\n", i, Grid[i].y);
				printf("Grid[%d].row = %d\n", i, Grid[i].row);
				printf("Grid[%d].state = %d\n", i, Grid[i].state);
				break;
			case 37:
				printf("Grid[%d].x = %d\n", i, Grid[i].x);
				printf("Grid[%d].y = %d\n", i, Grid[i].y);
				printf("Grid[%d].row = %d\n", i, Grid[i].row);
				printf("Grid[%d].state = %d\n", i, Grid[i].state);
				break;
			case 43:
				printf("Grid[%d].x = %d\n", i, Grid[i].x);
				printf("Grid[%d].y = %d\n", i, Grid[i].y);
				printf("Grid[%d].row = %d\n", i, Grid[i].row);
				printf("Grid[%d].state = %d\n", i, Grid[i].state);
				break;
			case 49:
				printf("Grid[%d].x = %d\n", i, Grid[i].x);
				printf("Grid[%d].y = %d\n", i, Grid[i].y);
				printf("Grid[%d].row = %d\n", i, Grid[i].row);
				printf("Grid[%d].state = %d\n", i, Grid[i].state);
				break;
			case 55:
				printf("Grid[%d].x = %d\n", i, Grid[i].x);
				printf("Grid[%d].y = %d\n", i, Grid[i].y);
				printf("Grid[%d].row = %d\n", i, Grid[i].row);
				printf("Grid[%d].state = %d\n", i, Grid[i].state);
				break;
			case 61:
				printf("Grid[%d].x = %d\n", i, Grid[i].x);
				printf("Grid[%d].y = %d\n", i, Grid[i].y);
				printf("Grid[%d].row = %d\n", i, Grid[i].row);
				printf("Grid[%d].state = %d\n", i, Grid[i].state);
				break;
			case 67:
				printf("Grid[%d].x = %d\n", i, Grid[i].x);
				printf("Grid[%d].y = %d\n", i, Grid[i].y);
				printf("Grid[%d].row = %d\n", i, Grid[i].row);
				printf("Grid[%d].state = %d\n", i, Grid[i].state);
				break;
			}
		}
	
}// PrintGridValues


//--------------------------------------------------------------------------
// Function: int GetGridState(int grid) 
// Description: Gets value of Grid[grid].status 
// Parameters: none
// Returns: 0 if EMPTY: 1 if RED: 2 if YELLOW: 3 if BLUE: 4 if GREEN
// Notes: N/A
//--------------------------------------------------------------------------
 
int GetGridState(int grid)
	{
	switch(Grid[grid].state){
	
		case GRID_EMPTY:
			return 0;
			break;
		case GRID_RED:
			return 1;
			break;
		case GRID_YELLOW:
			return 2;
			break;
		case GRID_BLUE:
			return 3;
			break;
		case GRID_GREEN:
			return 4;
			break;
		}
		
}// GetGridState


//--------------------------------------------------------------------------
// Function: void DrawGrid(void) 
// Description: Draws all Gems acording Grid values  
// Parameters: none
// Returns: none
// Notes: N/A
//--------------------------------------------------------------------------
 
void DrawGrid(void)
	{
	int i;
	
	for(i=1;i<73;i++)
		{
		switch(Grid[i].state){
		
			case GRID_RED:
				RedGem.x = Grid[i].x;
				RedGem.y = Grid[i].y;
				GsSortFastSprite(&RedGem,&WorldOT[activeBuff],0);
				break;
			case GRID_YELLOW:
				YellowGem.x = Grid[i].x;
				YellowGem.y = Grid[i].y;
				GsSortFastSprite(&YellowGem,&WorldOT[activeBuff],0);
			  	break;
			case GRID_BLUE:
				BlueGem.x = Grid[i].x;
				BlueGem.y = Grid[i].y;
				GsSortFastSprite(&BlueGem,&WorldOT[activeBuff],0);
			  	break;
			case GRID_GREEN:
				GreenGem.x = Grid[i].x;
				GreenGem.y = Grid[i].y;
				GsSortFastSprite(&GreenGem,&WorldOT[activeBuff],0);
				break;
			}
		}
	
}// DrawGrid 


//--------------------------------------------------------------------------
// Function: void GridGravity(void) 
// Description: Drops all Gems acording Grid values  
// Parameters: none
// Returns: none
// Notes: N/A
//--------------------------------------------------------------------------
 
void GridGravity(void)
	{
	int i;
	
	for(i=1;i<73;i++)
		{
		switch(Grid[i].state){
		
			case GRID_EMPTY:
				if(Grid[i-6].state != GRID_EMPTY)
					{
					Grid[i].state = Grid[i-6].state;
					Grid[i-6].state = GRID_EMPTY;
					}
				break;
			}
		}
		
}// GridGravity
					 	

//--------------------------------------------------------------------------
// Function: void RandomizeGrid(int row) 
// Description: Creates randomized Grid values from row down  
// Parameters: none
// Returns: none
// Notes: N/A
//--------------------------------------------------------------------------
 
void RandomizeGrid(int row)
	{
	int i;
	
	switch(row){
	
		case 1:
			i = 1;
			break;
		case 2:
			i = 7;
			break;
		case 3:
			i = 13;
			break;
		case 4:
			i = 19;
			break;
		case 5:
			i = 25;
			break;
		case 6:
			i = 31;
			break;
		case 7:
			i = 37;
			break;
		case 8:
			i = 43;
			break;	
		case 9:
			i = 49;
			break;
		case 10:
			i = 55;
			break;
		case 11:
			i = 61;
			break;
		case 12:
			i = 67;
			break;
		}
		
	for(i;i<73;i++)
		{
		Grid[i].state = rand()%5;
		}
		
}// RandomizeGrid

//--------------------------------------------------------------------------
// Function: void CheckForHLine(void) 
// Description: Checks for a complete Horizontal line 
// Parameters: none
// Returns: none
// Notes: N/A
//--------------------------------------------------------------------------
 

void CheckForHLine(void)
	{
	int i;
	
	for(i=1;i<73;i++)
		{	
		if(Grid[i].state == Grid[i+1].state && Grid[i].state == Grid[i-1].state &&
			Grid[i+1].row == Grid[i].row && Grid[i-1].row == Grid[i].row)
			{
			Grid[i].state = GRID_EMPTY;
			Grid[i+1].state = GRID_EMPTY;
			Grid[i-1].state = GRID_EMPTY;
			GridGravity();
			}
		
		if(Grid[i].state == Grid[i+1].state && Grid[i].state == Grid[i+2].state &&
			Grid[i+1].row == Grid[i].row && Grid[i+2].row == Grid[i].row)
			{
			Grid[i].state = GRID_EMPTY;
			Grid[i+1].state = GRID_EMPTY;
			Grid[i+2].state = GRID_EMPTY;
			GridGravity();
			}
			
		if(Grid[i].state == Grid[i-1].state && Grid[i].state == Grid[i-2].state &&
			Grid[i-1].row == Grid[i].row && Grid[i-2].row == Grid[i].row)
			{
			Grid[i].state = GRID_EMPTY;
			Grid[i-1].state = GRID_EMPTY;
			Grid[i-2].state = GRID_EMPTY;
			GridGravity();
			}
			
		} 
	
}// CheckForHLine	


//--------------------------------------------------------------------------
// Function: void CheckForVLine(void) 
// Description: Checks for a complete Vertical line 
// Parameters: none
// Returns: none
// Notes: N/A
//--------------------------------------------------------------------------
 

void CheckForVLine(void)
	{
	int i;
	
	for(i=1;i<61;i++)
		{	
		if(Grid[i].state == Grid[i+6].state && Grid[i].state == Grid[i+12].state)
			{
			Grid[i].state = GRID_EMPTY;
			Grid[i+6].state = GRID_EMPTY;
			Grid[i+12].state = GRID_EMPTY;
			GridGravity();
			}
		}	

}// CheckForVLine


//--------------------------------------------------------------------------
// Function: void CheckForDLine(void) 
// Description: Checks for a complete Diagonal Line
// Parameters: none
// Returns: none
// Notes: N/A
//--------------------------------------------------------------------------
 
void CheckForDLine(void)
	{
	
}// CheckForDLine

//--------------------------------------------------------------------------
// Function: void CheckAllGrid(void) 
// Description: Checks and updates all Grid    
// Parameters: none
// Returns: none
// Notes: N/A
//--------------------------------------------------------------------------
 
void CheckAllGrid(void)
	{
	int i = 0;
	
	while(i < 13)
		{
		GridGravity();
		DrawGrid();
		CheckForHLine();
		CheckForVLine();
		i++;
		}
		
}// CheckAllGrid 


//--------------------------------------------------------------------------
// Function: void CheckForClearGrid(void)
// Description: Check if the entire Grid has been cleared   
// Parameters: none
// Returns: none
// Notes: N/A
//--------------------------------------------------------------------------
 
void CheckForClearGrid(void)
	{
	int i=1;
	
	while(i != 73 && Grid[i].state == GRID_EMPTY)
		{
		i++;
		}
	
	if(i == 73)
		{
		CheckAllGrid();
		printf("You've cleared the screen. Well done!");
		GameState = STOP_GAME;
		}	
		
}// CheckForClearGrid
		
		
		
//--------------------------------------------------------------------------
// Function: void DropRandomGem(void)
// Description: Drops a random Gem into the Grid   
// Parameters: none
// Returns: none
// Notes: N/A
//--------------------------------------------------------------------------
 
void DropRandomGem(void)
	{
	if(Grid[DropGemPosition+6].state == GRID_EMPTY && Grid[DropGemPosition].row < 12)
		{
		if(DropDelay < 30)
			{
			DropDelay++;
			}
		if(DropDelay == 30)
			{
			Grid[DropGemPosition+6].state = Grid[DropGemPosition].state;
			Grid[DropGemPosition].state = GRID_EMPTY;
			DropGemPosition+=6;
			DropDelay = 0;
			}
		}
	
	else
		{
		GemDropState = GEM_NOT_DROPPING;
		}
				
}// DropRandomGem


//--------------------------------------------------------------------------
// Function: void CreateRandomGem(void) 
// Description: Generates a random Gem  
// Parameters: none
// Returns: none
// Notes: N/A
//--------------------------------------------------------------------------
 
void CreateRandomGem(void) 
	{
	GemType = 0;
	while(GemType == 0) GemType = rand()%5;
	
	DropGemPosition = 3;
	
	if(Grid[DropGemPosition].state == GRID_EMPTY)
		{
		Grid[DropGemPosition].state = GemType;
		GemDropState = GEM_DROPPING;
		}
	else
		{
		GameState = STOP_GAME;
		}

}// CreateRandomGem


//--------------------------------------------------------------------------
// Function: void MoveGemRight(void) 
// Description: Move Gem Right
// Parameters: none
// Returns: none
// Notes: N/A
//--------------------------------------------------------------------------
 
void MoveGemRight(void)
	{
	if(Grid[DropGemPosition+1].state == GRID_EMPTY &&
	   Grid[DropGemPosition+1].row == Grid[DropGemPosition].row)
	   	{
		Grid[DropGemPosition+1].state = Grid[DropGemPosition].state;
	   	Grid[DropGemPosition].state = GRID_EMPTY;
	  	DropGemPosition+=1;	
	   	}
		
}// MoveGemRight


//--------------------------------------------------------------------------
// Function: void MoveGemLeft(void) 
// Description: Move Gem Left
// Parameters: none
// Returns: none
// Notes: N/A
//--------------------------------------------------------------------------
 
void MoveGemLeft(void)
	{
	if(Grid[DropGemPosition-1].state == GRID_EMPTY &&
	   Grid[DropGemPosition-1].row == Grid[DropGemPosition].row)
	   {
	   Grid[DropGemPosition-1].state = Grid[DropGemPosition].state;
	   Grid[DropGemPosition].state = GRID_EMPTY;
	   DropGemPosition-=1;
	   }	
	
}// MoveGemLeft


//--------------------------------------------------------------------------
// Function: void MoveGemDown(void) 
// Description: Move Gem Down
// Parameters: none
// Returns: none
// Notes: N/A
//--------------------------------------------------------------------------
 
void MoveGemDown(void)
	{
	GemDropState = GEM_NOT_DROPPING;
			
}// MoveGemDown


//--------------------------------------------------------------------------
// Function: void FlashHLine(int line, int color) 
// Description: Makes a complete Horizontal line flash 
// Parameters: none
// Returns: none
// Notes: N/A
//--------------------------------------------------------------------------
 
void FlashHLine(int line, int color)
	{
	
	
}// FlashHLine


//--------------------------------------------------------------------------
// Function: void MakeHLineRed(int line) 
// Description: Makes (int line) a Horizontal line of Red Gems 
// Parameters: none
// Returns: none
// Notes: N/A
//--------------------------------------------------------------------------
 
void MakeHLineRed(int line)
	{
	int i;
	
	for(i=1;i<7;i++)
		{
		Grid[line].state = GRID_RED;
		line++;
		}

}// MakeHLineRed