#include "BoxManager.h"




static GsDOBJ2 BoxObjects[60][5]; // All Box prats
static GsCOORDINATE2 BoxCoordinates[60]; // The box coordinates
static short flags[60]; // Indicates whether a box is in movement
static int Boxes; // Number of boxes
static short BoxPlaces[30][30]; // Index for box objects
static short Targets[30][30]; // Is one if target place 
static int CorrectlyPlaced; // Number of boxes correctly placed





void DrawBoxes()
{
	GsOT *table;
	GsOT *special;
	int count;
	MATRIX Screen;
	MATRIX World;
	int j;
	

	table=getMidGround();	
	special=getBoxGround();
	for(count=0;count<Boxes;count++)
	{
		GsGetLws(BoxObjects[count][0].coord2,&World,&Screen);
		GsSetLightMatrix(&World);
		GsSetLsMatrix(&Screen);
		for(j=0;j<5;j++)
		{
			PushMatrix();
			if (flags[count]==0)
				GsSortObject4(&BoxObjects[count][j],table,0,(u_long *)getScratchAddr(0));
			else // Draw box in extra order tbale if in movement
				GsSortObject4(&BoxObjects[count][j],special,0,(u_long *)getScratchAddr(0));		
			PopMatrix();
		}
	}
}


int noBox(unsigned short xpos,unsigned short ypos)
{
	return (BoxPlaces[xpos][ypos]==-1);
}

void SubdivideBox(unsigned short xpos,unsigned short ypos)
{
	int index;
	int j;
	
	if ((xpos<30)&&(ypos<30))
	{ 
		index=BoxPlaces[xpos][ypos];
		if (index!=-1)
		{
			for(j=0;j<5;j++)
				BoxObjects[index][j].attribute=
				(BoxObjects[index][j].attribute)|(2<<9);
		}
	} 
}


void RoughSubdivideBox(unsigned short xpos,unsigned short ypos)
{
	int index;
	int j;
	
	if ((xpos<30)&&(ypos<30))
	{ 
		index=BoxPlaces[xpos][ypos];
		if (index!=-1)
		{
			for(j=0;j<5;j++)
				BoxObjects[index][j].attribute=
				(BoxObjects[index][j].attribute)|(1<<9);
		}
	} 
}


void UnifyBox(unsigned short xpos,unsigned short ypos)
{
	int index;
	int j;
	
	if ((xpos<30)&&(ypos<30))
	{
		index=BoxPlaces[xpos][ypos];
		if (index!=-1)
		{
			for(j=0;j<5;j++)
			BoxObjects[index][j].attribute=
			(BoxObjects[index][j].attribute)&(~(3<<9));
		}
	}
}

// Deactivates a part of the box (side)
static void BoxDeactivate(unsigned short position[2],int index)
{
	int Object;
	
	Object=BoxPlaces[position[0]][position[1]];
	BoxObjects[Object][index].attribute=
		(BoxObjects[Object][index].attribute)|(1<<31);
}


// Reactivates the side
static void BoxActivate(unsigned short position[2],int index)
{
	int Object;
	
	Object=BoxPlaces[position[0]][position[1]];
	BoxObjects[Object][index].attribute=
		(BoxObjects[Object][index].attribute)&(~(1<<31));
}

// Test a box and its four potential neighbours wheter to switch of components
static void SwitchOffComponents(unsigned short position[2])
{
	unsigned short Testposition[2];
	
	Testposition[0]=position[0]+1;
	Testposition[1]=position[1];
	if ((!noBox(Testposition[0],Testposition[1])||
		(!NoWall(Testposition[0],Testposition[1]))))
	{
		BoxDeactivate(position,3);
		if (!noBox(Testposition[0],Testposition[1]))
			BoxDeactivate(Testposition,1);
		else 
			WallDeactivate(Testposition,1);
	}
	Testposition[0]=position[0];
	Testposition[1]=position[1]-1;
	if ((!noBox(Testposition[0],Testposition[1])||
		(!NoWall(Testposition[0],Testposition[1]))))
	{
		BoxDeactivate(position,2);
		if (!noBox(Testposition[0],Testposition[1]))
			BoxDeactivate(Testposition,4);
		else 
			WallDeactivate(Testposition,4);
	}
	Testposition[0]=position[0]-1;
	Testposition[1]=position[1];
	if ((!noBox(Testposition[0],Testposition[1])||
		(!NoWall(Testposition[0],Testposition[1]))))
	{
		BoxDeactivate(position,1);
		if (!noBox(Testposition[0],Testposition[1]))
			BoxDeactivate(Testposition,3);
		else 
			WallDeactivate(Testposition,3);
	}
	Testposition[0]=position[0];
	Testposition[1]=position[1]+1;
	if ((!noBox(Testposition[0],Testposition[1])||
		(!NoWall(Testposition[0],Testposition[1]))))
	{
		BoxDeactivate(position,4);
		if (!noBox(Testposition[0],Testposition[1]))
			BoxDeactivate(Testposition,2);
		else 
			WallDeactivate(Testposition,2);
	}
}

// Swithces on the appropriate components, if a box leaves a place
static void SwitchOnComponents(unsigned short position[2])
{
	unsigned short Testposition[2];
	
	Testposition[0]=position[0]+1;
	Testposition[1]=position[1];
	if ((!noBox(Testposition[0],Testposition[1])||
		(!NoWall(Testposition[0],Testposition[1]))))
	{
		BoxActivate(position,3);
		if (!noBox(Testposition[0],Testposition[1]))
			BoxActivate(Testposition,1);
		else 
			WallActivate(Testposition,1);
	}
	Testposition[0]=position[0];
	Testposition[1]=position[1]-1;
	if ((!noBox(Testposition[0],Testposition[1])||
		(!NoWall(Testposition[0],Testposition[1]))))
	{
		BoxActivate(position,2);
		if (!noBox(Testposition[0],Testposition[1]))
			BoxActivate(Testposition,4);
		else 
			WallActivate(Testposition,4);
	}
	Testposition[0]=position[0]-1;
	Testposition[1]=position[1];
	if ((!noBox(Testposition[0],Testposition[1])||
		(!NoWall(Testposition[0],Testposition[1]))))
	{
		BoxActivate(position,1);
		if (!noBox(Testposition[0],Testposition[1]))
			BoxActivate(Testposition,3);
		else 
			WallActivate(Testposition,3);
	}
	Testposition[0]=position[0];
	Testposition[1]=position[1]+1;
	if ((!noBox(Testposition[0],Testposition[1])||
		(!NoWall(Testposition[0],Testposition[1]))))
	{
		BoxActivate(position,4);
		if (!noBox(Testposition[0],Testposition[1]))
			BoxActivate(Testposition,2);
		else 
			WallActivate(Testposition,2);
	}
}


// Moves a box
void MoveBox(unsigned short pushPosition[2],unsigned short targetPosition[2])
{
	int index;
	int i;
	int xincrement,yincrement;
	
	if ((noBox(targetPosition[0],targetPosition[1])&&
		(NoWall(targetPosition[0],targetPosition[1])))) // check if place is free
	{
		SwitchOnComponents(pushPosition);
		index=BoxPlaces[pushPosition[0]][pushPosition[1]];
		BoxPlaces[pushPosition[0]][pushPosition[1]]=-1;
		BoxPlaces[targetPosition[0]][targetPosition[1]]=index;
		Activate(pushPosition[0],pushPosition[1]); // Switch polys
		PlayMoveBox();
		xincrement=(targetPosition[0]-pushPosition[0])<<6;
		yincrement=(targetPosition[1]-pushPosition[1])<<6;
		flags[index]=1;
		for(i=0;i<8;i++) // Animate box movement
		{
			BoxCoordinates[index].flg=0;
			BoxCoordinates[index].coord.t[0]+=xincrement;
			BoxCoordinates[index].coord.t[1]=0;
			BoxCoordinates[index].coord.t[2]+=yincrement;
			RedrawAll();
		}
		flags[index]=0;
		Deactivate(targetPosition[0],targetPosition[1]);
		SwitchOffComponents(targetPosition);
		if (Targets[pushPosition[0]][pushPosition[1]])
			CorrectlyPlaced-=1;
		if (Targets[targetPosition[0]][targetPosition[1]])
		{
			CorrectlyPlaced+=1;
			PlayYeah();
		}
		BoxCoordinates[index].flg=0;
		BoxCoordinates[index].coord.t[0]=(targetPosition[0]<<9)-3;
		BoxCoordinates[index].coord.t[1]=0;
		BoxCoordinates[index].coord.t[2]=(targetPosition[1]<<9)-3;
	}
	else
		PlayNoResult();
}



void InitializeBoxes(short *LevelDescription,int offset)
{
	int actualIndex;
	unsigned short pos[2];
	unsigned short x,y;
	int counting;
	short xpos,ypos;
	int j;
	VECTOR scaling;
	
	scaling.vx=4144;
	scaling.vy=4096;
	scaling.vz=4144; // Make the sides a bit larger to avoid poly border artefacts
	counting=0;
	CorrectlyPlaced=0;
	actualIndex=offset;
	xpos=ypos=0;
	for (x=0;x<30;x++)
	{
		for (y=0;y<30;y++)
		{
			BoxPlaces[x][y]=-1;
			if (LevelDescription[actualIndex]==2)
				Targets[x][y]=1;
			else
				Targets[x][y]=0;
			if (LevelDescription[actualIndex]==4)
			{
				GsInitCoordinate2(WORLD,&BoxCoordinates[counting]);
				BoxCoordinates[counting].coord=GsIDMATRIX;
				ScaleMatrix(&BoxCoordinates[counting].coord,&scaling);
				BoxCoordinates[counting].flg=0;
				BoxCoordinates[counting].coord.t[0]=xpos-3;
				BoxCoordinates[counting].coord.t[1]=0;
				BoxCoordinates[counting].coord.t[2]=ypos-3;
				for (j=0;j<5;j++)
				{
					BoxObjects[counting][j]=getBox(j,&BoxCoordinates[counting]);
					BoxObjects[counting][j].attribute=0;
				}
				flags[counting]=0;
				BoxPlaces[x][y]=counting;
				counting++;
			}
			ypos+=512;
			actualIndex++;
		}
		ypos=0;
		xpos+=512;
	}
	Boxes=counting;	
	for(pos[0]=0;pos[0]<30;pos[0]++)
	{
		for(pos[1]=0;pos[1]<30;pos[1]++)
		{
			if (!noBox(pos[0],pos[1]))
				SwitchOffComponents(pos);
		}
	}
}


int isWinning()
{
	return (Boxes==CorrectlyPlaced);
}