// Planner.c
//
// Version	Date	 Author	 Description
//	--------------------------------------------------------------------------
//  0.01	24/06/01 BWW	 Initial implementation

#include <c:\psx\include\libps.h>
#include "planner.h"
#include "pad.h"
#include "funcprototypes.h"

// Define the buffers
volatile u_char *bb0, *bb1;


// Low Complexity
char Environment[ENV_HEIGHT][ENV_WIDTH] = 
   {{{OBJ_FLAT  },{OBJ_DOWN  },{OBJ_DOWN  },{OBJ_WATER },{OBJ_UP    },{OBJ_UP    },{OBJ_UP    },{OBJ_FLAT  },{OBJ_FLAT  },{OBJ_FLAT  }},
    {{OBJ_FLAT  },{OBJ_DOWN  },{OBJ_DOWN  },{OBJ_WATER },{OBJ_WATER },{OBJ_UP    },{OBJ_UP    },{OBJ_UP    },{OBJ_FLAT  },{OBJ_FLAT  }},
    {{OBJ_DOWN  },{OBJ_FLAT  },{OBJ_DOWN  },{OBJ_DOWN  },{OBJ_WATER },{OBJ_UP    },{OBJ_UP    },{OBJ_UP    },{OBJ_FLAT  },{OBJ_FLAT  }},
    {{OBJ_UP    },{OBJ_FLAT  },{OBJ_DOWN  },{OBJ_DOWN  },{OBJ_WATER },{OBJ_UP    },{OBJ_UP    },{OBJ_WATER },{OBJ_WATER },{OBJ_WATER }},
    {{OBJ_FLAT  },{OBJ_FLAT  },{OBJ_DOWN  },{OBJ_WATER },{OBJ_WATER },{OBJ_WATER },{OBJ_WATER },{OBJ_WATER },{OBJ_FLAT  },{OBJ_FLAT  }},
    {{OBJ_FLAT  },{OBJ_DOWN  },{OBJ_WATER },{OBJ_WATER },{OBJ_DOWN  },{OBJ_DOWN  },{OBJ_DOWN  },{OBJ_WATER },{OBJ_UP    },{OBJ_UP    }},
    {{OBJ_FLAT  },{OBJ_DOWN  },{OBJ_WATER },{OBJ_UP    },{OBJ_FLAT  },{OBJ_FLAT  },{OBJ_DOWN  },{OBJ_WATER },{OBJ_UP    },{OBJ_UP    }},
    {{OBJ_FLAT  },{OBJ_DOWN  },{OBJ_WATER },{OBJ_UP    },{OBJ_FLAT  },{OBJ_FLAT  },{OBJ_DOWN  },{OBJ_WATER },{OBJ_FLAT  },{OBJ_FLAT  }},
    {{OBJ_FLAT  },{OBJ_DOWN  },{OBJ_WATER },{OBJ_WATER },{OBJ_UP    },{OBJ_FLAT  },{OBJ_DOWN  },{OBJ_WATER },{OBJ_FLAT  },{OBJ_FLAT  }},
    {{OBJ_FLAT  },{OBJ_DOWN  },{OBJ_DOWN  },{OBJ_WATER },{OBJ_UP    },{OBJ_FLAT  },{OBJ_DOWN  },{OBJ_WATER },{OBJ_FLAT  },{OBJ_FLAT  }}};

// Medium Complexity
//char Environment[ENV_HEIGHT][ENV_WIDTH] = 
//   {{{OBJ_FLAT  },{OBJ_FLAT  },{OBJ_DOWN  },{OBJ_WATER },{OBJ_DOWN  },{OBJ_FLAT  },{OBJ_FLAT  },{OBJ_DOWN  },{OBJ_DOWN  },{OBJ_WATER }},
//    {{OBJ_FLAT  },{OBJ_WALL  },{OBJ_DOWN  },{OBJ_WATER },{OBJ_DOWN  },{OBJ_WALL  },{OBJ_FLAT  },{OBJ_DOWN  },{OBJ_WATER },{OBJ_WATER }},
//    {{OBJ_DOWN  },{OBJ_WATER },{OBJ_WATER },{OBJ_WATER },{OBJ_FLAT  },{OBJ_WALL  },{OBJ_FLAT  },{OBJ_DOWN  },{OBJ_WATER },{OBJ_FLAT  }},
//    {{OBJ_DOWN  },{OBJ_WATER },{OBJ_DOWN  },{OBJ_FLAT  },{OBJ_FLAT  },{OBJ_WALL  },{OBJ_FLAT  },{OBJ_DOWN  },{OBJ_WATER },{OBJ_FLAT  }},
//	{{OBJ_DOWN  },{OBJ_WATER },{OBJ_DOWN  },{OBJ_FLAT  },{OBJ_WALL  },{OBJ_WALL  },{OBJ_FLAT  },{OBJ_DOWN  },{OBJ_WATER },{OBJ_FLAT  }},
//    {{OBJ_FLAT  },{OBJ_WATER },{OBJ_DOWN  },{OBJ_DOWN  },{OBJ_WALL  },{OBJ_DOWN  },{OBJ_DOWN  },{OBJ_DOWN  },{OBJ_WATER },{OBJ_FLAT  }},
//    {{OBJ_FLAT  },{OBJ_WATER },{OBJ_WATER },{OBJ_WATER },{OBJ_WATER },{OBJ_WATER },{OBJ_WATER },{OBJ_WATER },{OBJ_WATER },{OBJ_FLAT  }},
//    {{OBJ_UP    },{OBJ_UP    },{OBJ_WALL  },{OBJ_DOWN  },{OBJ_WALL  },{OBJ_DOWN  },{OBJ_WATER },{OBJ_FLAT  },{OBJ_FLAT  },{OBJ_FLAT  }},
//    {{OBJ_FLAT  },{OBJ_UP    },{OBJ_FLAT  },{OBJ_FLAT  },{OBJ_FLAT  },{OBJ_DOWN  },{OBJ_WATER },{OBJ_FLAT  },{OBJ_FLAT  },{OBJ_FLAT  }},
//    {{OBJ_UP    },{OBJ_UP    },{OBJ_WALL  },{OBJ_FLAT  },{OBJ_WALL  },{OBJ_DOWN  },{OBJ_WATER },{OBJ_FLAT  },{OBJ_FLAT  },{OBJ_FLAT  }}};

// High Complexity
//char Environment[ENV_HEIGHT][ENV_WIDTH] = 
//   {{{OBJ_FLAT  },{OBJ_FLAT  },{OBJ_FLAT  },{OBJ_DOWN  },{OBJ_WATER },{OBJ_DOWN  },{OBJ_WALL  },{OBJ_DOWN  },{OBJ_WATER },{OBJ_FLAT  }},
//  	{{OBJ_FLAT  },{OBJ_DOWN  },{OBJ_WALL  },{OBJ_DOWN  },{OBJ_WATER },{OBJ_DOWN  },{OBJ_WALL  },{OBJ_DOWN  },{OBJ_WATER },{OBJ_FLAT  }},
//    {{OBJ_DOWN  },{OBJ_WATER },{OBJ_WALL  },{OBJ_DOWN  },{OBJ_WATER },{OBJ_DOWN  },{OBJ_FLAT  },{OBJ_DOWN  },{OBJ_WATER },{OBJ_FLAT  }},
//    {{OBJ_FLAT  },{OBJ_WATER },{OBJ_WATER },{OBJ_WATER },{OBJ_WATER },{OBJ_WATER },{OBJ_WATER },{OBJ_WATER },{OBJ_WATER },{OBJ_WATER }},
//    {{OBJ_UP    },{OBJ_WALL  },{OBJ_DOWN  },{OBJ_DOWN  },{OBJ_WATER },{OBJ_WATER },{OBJ_WATER },{OBJ_DOWN  },{OBJ_WALL  },{OBJ_FLAT  }},
//    {{OBJ_FLAT  },{OBJ_WALL  },{OBJ_FLAT  },{OBJ_FLAT  },{OBJ_DOWN  },{OBJ_DOWN  },{OBJ_WATER },{OBJ_DOWN  },{OBJ_FLAT  },{OBJ_FLAT  }},
//    {{OBJ_FLAT  },{OBJ_FLAT  },{OBJ_FLAT  },{OBJ_WATER },{OBJ_WATER },{OBJ_WATER },{OBJ_WATER },{OBJ_WALL  },{OBJ_WALL  },{OBJ_FLAT  }},
//    {{OBJ_FLAT  },{OBJ_WALL  },{OBJ_FLAT  },{OBJ_WATER },{OBJ_FLAT  },{OBJ_FLAT  },{OBJ_DOWN  },{OBJ_UP    },{OBJ_WALL  },{OBJ_FLAT  }},
//    {{OBJ_FLAT  },{OBJ_WALL  },{OBJ_WATER },{OBJ_WATER },{OBJ_WALL  },{OBJ_WALL  },{OBJ_FLAT  },{OBJ_UP    },{OBJ_FLAT  },{OBJ_FLAT  }},
//    {{OBJ_FLAT  },{OBJ_FLAT  },{OBJ_WATER },{OBJ_FLAT  },{OBJ_FLAT  },{OBJ_FLAT  },{OBJ_FLAT  },{OBJ_UP    },{OBJ_WALL  },{OBJ_FLAT  }}};


// Create instances of structures
Agent_Struct				Agent;
Key_Struct					Key;
Start_Struct				Start;
Exit_Struct					Exit;
Door_Struct					Door[10];
Bridge_Struct				Bridge[10];
Route_Struct				Route;
SearchTree_Struct			SearchTree;
SearchGoalNodes_Struct		SearchGoalNodes;
Preconditions_Struct		Preconditions;
Effects_Struct				Effects;
UnmetPreconditions_Struct	UnmetPreconditions;
ActionEffects_Struct		ActionEffects;
CausalLinks_Struct			CausalLinks;
Orderings_Struct			Orderings;
Plan_Struct					Plan;
Metrics_Struct				Metrics;

//AvailablePrecons_Struct		AvailablePrecons;
//AvailableActions_Struct		AvailableActions;

// Global variables for search routines ..... Temporary measure to get over parameter passing problems
int	startx, starty,destinationx, destinationy;


// Flag whether to print Debug information
int	Debug = false;

int up,down,left,right;

u_long	timecount;

// Standard Text
char 	TurnMsg[]		= "TURN\n";
char 	StepMsg[]		= "STEP\n";
char 	PlanMsg[]		= "PLAN OK\n";
char 	NoPlanMsg[]		= "NO PLAN\n";
char 	FailedPlanMsg[]	= "FAILED PLAN\n";
long	Turn = 0;
char 	RouteMsg[]		= "ROUTES\n";
char 	GoalMsg[]		= "GOAL SUCCESS\n";
char 	NotGoalMsg[]	= "NOT GOAL\n";

char 	NoActionMsg[]	= "NO ACTION\n";
char 	MoveToMsg[]		= "MOVETO\n";
char 	UnlockMsg[]		= "UNLOCK\n";
char 	OpenMsg[]		= "OPEN\n";
char 	PickupMsg[]		= "PICKUP\n";
char 	WaitMsg[]		= "WAIT\n";
char 	PlanActionMsg[]	= "PLAN\n";

char 	ComplexityLowMsg[]		= "LOW COMPLEX\n";
char 	ComplexityMediumMsg[]	= "MED COMPLEX\n";
char 	ComplexityHighMsg[]		= "HIGH COMPLEX\n";

char 	SpeedLowMsg[]		= "LOW SPEED\n";
char 	SpeedMediumMsg[]	= "MED SPEED\n";
char 	SpeedHighMsg[]		= "HIGH SPEED\n";

char 	StartLocationMsg[]	= "START\n";

// Speed and complexity of the dynamic environment
int		EnvSpeed;
int		EnvComplexity;
int 	EnvStartLocation;

int		BRIDGENUM;
int		DOORNUM;

// Sprite structure
GsSPRITE 	MessageSprite;

//u_long  GetCounter();
//static long CheckPad ();
//u_long PadRead();

// Which buffer variable
int			activeBuff;

// Define the packet work area
PACKET		GpuPacketArea[2][PACKETMAX2];

// Ordering table variables
GsOT		WorldOT[2];
GsOT_TAG	OTTags[2][1<<OT_LENGTH];


//	--------------------------------------------------------------------------
// 	Main routine
//	--------------------------------------------------------------------------
//	Description:	Initialise, main loop, shutdown of the program
//
//	Parameters:		None
//	Returns:		None

void main ()
	{


//	long dummy;

//	int index;
	 
//	int	result;

	// Initialise the environment
	ObjectInit();
	PreconditionEffectInit();
	InitExecution();
	
	// Initialise joypad buffers
	GetPadBuf(&bb0, &bb1);

	// Initialise the message sprite
	MessageSpriteInit();

	ResetAndStartCounter();
//	SetAgentGoal();

	// Initialise the Playstation drawing system
	DisplayInit();
	
	// Initialise metrics, output scenario complexity info and the header for the agent plan info
	InitMetrics();
	MetricComplexity();
	MetricPlanHeader();
	
	while ((CheckPad()) !=99)
   	{
	
		// Initialise the drawing system for a new cycle
		DisplayInitDrawingCycle();

		// Execute the plan until the agent reaches it's goal
		if (Plan.goalachieved!=true)
			{
			ExecutePlan();
			}

		// Update the dynamic events in the environment
		DynamicEvents();

		// Display a graphic representation of the environment
		DisplayStandardText();
		DisplayObject();
		DisplayRoute();
		DisplayAccessibility();
		DisplayEnvironment();

		// Wait for drawing to finish
		DisplayFinishDrawing();

		
//	*******  Reading the counter is affecting the screen display ********		
//		timecount = GetCounter();
//		timecount = GetRCnt(2);
//		if (Debug == true)
//			{
//			printf("Counter value: %c \n", timecount);
//			}

		// Wait for vertical blank interrupt
		DisplayVerticalBlank();
		
		// Finish the current drawing cycle
		DisplayCloseDrawingCycle();	
	
      }

   // Shutdown the drawing system
   DisplayClose();

   // Finish the program and return
   return;
   }

//	--------------------------------------------------------------------------
// 	Dynamic Events
//	--------------------------------------------------------------------------
//	Description:	Update counters and fire dynamic events 
//
//	Parameters:		None
//	Returns:		None

void DynamicEvents()
	{
	int		index;
		

//	printf("Bridge Counter Number = %i\n", Bridge[0].counter);
	

	// Bridges
	for (index=0;index<BRIDGENUM;index++)
		{

		// Decrement the counter.  If it reaches zero then change the status of the 
		// bridge and reset the counter to the original duration
		Bridge[index].counter--;
		if (Bridge[index].counter == 0)
			{
			
			// Reset the counter
			Bridge[index].counter = Bridge[index].duration;
			
			// Change the bridge status
			if (Bridge[index].status == BRIDGELOWERED)
				{
				Bridge[index].status = BRIDGERAISED;
				}
			else
				{
				Bridge[index].status = BRIDGELOWERED;
				}
			}
		}
	}




// ----------------------------------------------------------------------
// Reset and Re-start the Internal Clock 
// ----------------------------------------------------------------------
// Description:  Internal counter RCntCNT2 counts in 8 clock ticks = 33Mhz/8.
//               Reset it to zero and start it running again.
// Parameters:   None
// Returns:      None

void ResetAndStartCounter ()
	{
//	ResetRCnt(RCntCNT2);
//	StartRCnt(RCntCNT2);
	StartRCnt(2);
	ResetRCnt(2);
	} 

// ----------------------------------------------------------------------
// Get the Current Value of the Internal Clock 
// ----------------------------------------------------------------------
// Description:  Internal counter RCntCNT2 counts in 8 clock ticks = 33Mhz/8.
//               Get the current value and return it.
// Parameters:   None
// Returns:      long       Current value of the counter

u_long GetCounter ()
	{
//	return(GetRCnt(RCntCNT2));
	return(GetRCnt(2));
	} 
	
//	--------------------------------------------------------------------------
// 	Check Pad for Input
//	--------------------------------------------------------------------------
//	Description:	Call the function to read the joypad and then process the
//					retuned key presses.  Return 99 if the Select key has been
//					pressed as a rogue value to terminate the main loop.
//
//	Parameters:		None
//	Returns:		Long	Value 99 if Select button pushed.

static long CheckPad ()
	{
	u_long padd = PadRead(1);

	up = down = left = right = false;

  	// check to see if select has been pushed
	if(padd & PADselect) return(99);

	if (padd & PADLleft)
		{
		left = true;
		}

	if (padd & PADLright)
		{
		right = true;
		}

	if (padd & PADLup)
		{
		up = true;
		}

	if (padd & PADLdown)
		{
		down = true;
		}

	// Turn Debug on with the Triangle and off with the Square
	if (padd & PADRup)
		{
		Debug = true;
		printf ("Debug is ON\n");
		}

	if (padd & PADRleft)
		{
		Debug = false;
		printf ("Debug is OFF\n");
		}

	return (0);

	}


//	--------------------------------------------------------------------------
// 	Read Joypad Buffer Values
//	--------------------------------------------------------------------------
//	Description:	Read the joypad to see if any buttons have been pressed
//				
//	Parameters:		None
//	Returns:		ULong	Pad buffer values

u_long PadRead()
	{
	return(~(*(bb0+3) | *(bb0+2) << 8 | *(bb1+3) << 16 | *(bb1+2) << 24));
	}