blame: source/code/BlockGame.cpp

/*

===========================================================================

blockattack - Block Attack - Rise of the Blocks

Copyright (C) 2005-2012 Poul Sander

This program is free software: you can redistribute it and/or modify

it under the terms of the GNU General Public License as published by

the Free Software Foundation, either version 2 of the License, or

(at your option) any later version.

This program is distributed in the hope that it will be useful,

but WITHOUT ANY WARRANTY; without even the implied warranty of

MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

GNU General Public License for more details.

You should have received a copy of the GNU General Public License

along with this program.  If not, see http://www.gnu.org/licenses/

Source information and contacts persons can be found at

http://blockattack.sf.net

===========================================================================

*/

#include "BlockGame.hpp"

////////////////////////////////////////////////////////////////////////////////

//The BloackGame class represents a board, score, time etc. for a single player/

////////////////////////////////////////////////////////////////////////////////

Uint16 BlockGame::rand2()

{

	nextRandomNumber = nextRandomNumber*1103515245 + 12345;

	return ((Uint16)(nextRandomNumber/65536)) % 32768;

}

int BlockGame::firstUnusedChain()

{

	bool found=false;

	int i = 0;

	while (!found)

	{

		if (!chainUsed[++i])

			found=true;

		if (i>NUMBEROFCHAINS-2)

			found=true;

	}

	return i;

}

//Constructor

BlockGame::BlockGame()

{

	srand((int)time(NULL));

	nrFellDown = 0;

	nrPushedPixel = 0;

	garbageTarget = this;

	nrStops=0;

	//topx = tx;

	//topy = ty;

	cursorx = 2;

	cursory = 3;

	stop = 0;

	pixels = 0;

	score = 0;

	bGameOver = false;

	bDraw = false;

	bReplaying=false; //No replay by default

#if NETWORK

	bDisconnected=false;

	bNetworkPlayer = false;

#endif

	timetrial = false;

	stageClear = false;

	vsMode = false;

	puzzleMode = false;

	linesCleared = 0;

	AI_Enabled = false;

	AI_MoveSpeed=100;

	hasWonTheGame = false;

	combo=0;                      //counts

	chain=0;

	hangTicks = 0;

	baseSpeed = 0.5;           //All other speeds are relative to this

	speed = baseSpeed;

	speedLevel = 1;

	ticks = 0;

	gameStartedAt = ticks;

	gameEndedAfter = 0;

	pushedPixelAt = gameStartedAt;

	nextGarbageNumber = 10;

	handicap=0;

	for (int i=0; i<7; i++)

		for (int j=0; j<30; j++)

		{

			board[i][j] = -1;

		}

	for (int i=0; i<NUMBEROFCHAINS; i++)

	{

		chainUsed[i]=false;

		chainSize[i] = 0;

	}

	theReplay = Replay();

	showGame = true;              //The game is now active

	lastCounter = -1;           //To prevent the final chunk to be played when stating the program

}	//Constructor

//Deconstructor, never really used... game used to crash when called, cause of the way sBoard was created

//It should work now and can be used if we want to assign more players in network games that we need to free later

BlockGame::~BlockGame()

{

}

void BlockGame::setGameSpeed(Uint8 globalSpeedLevel)

{

	switch (globalSpeedLevel)

	{

	case 0:

		baseSpeed=0.5;

		break;

	case 1:

		baseSpeed=0.4;

		break;

	case 2:

		baseSpeed=0.3;

		break;

	case 3:

		baseSpeed=0.25;

		break;

	case 4:

		baseSpeed=0.2;

		break;

	default:

		baseSpeed=0.15;

		break;

	};

}

void BlockGame::setHandicap(Uint8 globalHandicap)

{

	handicap=1000*((Uint32)globalHandicap);

}

//Set the move speed of the AI based on the aiLevel parameter

//Also enables AI

void BlockGame::setAIlevel(Uint8 aiLevel)

{

	AI_Enabled = true;

	AI_MoveSpeed=120-(20*(aiLevel-3));

};

Uint8 BlockGame::getAIlevel()

{

	return (120-AI_MoveSpeed)/20+3;

}

int BlockGame::GetScore()

{

	return score;

}

int BlockGame::GetHandicap()

{

	return handicap;

}

bool BlockGame::isGameOver()

{

	return bGameOver;

}

int BlockGame::GetTopX()

{

	return topx;

}

int BlockGame::GetTopY()

{

	return topy;

}

unsigned int BlockGame::GetGameStartedAt()

{

	return gameStartedAt;

}

unsigned int BlockGame::GetGameEndedAt()

{

	return gameEndedAfter;

}

bool BlockGame::isTimeTrial()

{

	return timetrial;

}

bool BlockGame::isStageClear()

{

	return stageClear;

}

bool BlockGame::isVsMode()

{

	return vsMode;

}

bool BlockGame::isPuzzleMode()

{

	return puzzleMode;

}

int BlockGame::GetLinesCleared()

{

	return linesCleared;

}

int BlockGame::GetStageClearLimit()

{

	return stageClearLimit;

}

int BlockGame::GetChains()

{

	return chain;

}

int BlockGame::GetPixels()

{

	return pixels;

}

int BlockGame::GetSpeedLevel()

{

	return speedLevel;

}

int BlockGame::GetTowerHeight()

{

	return TowerHeight;

}

int BlockGame::GetCursorX()

{

	return cursorx;

}

int BlockGame::GetCursorY()

{

	return cursory;

}

void BlockGame::MoveCursorTo(int x, int y)

{

	cursorx = x;

	cursory = y;

}

bool BlockGame::GetIsWinner()

{

	return hasWonTheGame;

}

#if NETWORK

#define garbageStackSize 10

void BlockGame::emptyGarbageStack()

{

	for (int i=0; i<10; i++)

		for (int j=0; j<3; j++)

			garbageStack[i][j] = 0;

	garbageStackUsed = 0;

}

bool BlockGame::pushGarbage(Uint8 width, Uint8 height, Uint8 type)

{

	if (garbageStackUsed>=garbageStackSize)

		return false;

	garbageStack[garbageStackUsed][0]=width;

	garbageStack[garbageStackUsed][1]=height;

	garbageStack[garbageStackUsed][2]=type;

	garbageStackUsed++;

	return true;

}

bool BlockGame::popGarbage(Uint8 *width, Uint8 *height, Uint8 *type)

{

	if (garbageStackUsed<1)

		return false;

	garbageStackUsed--;

	*width=garbageStack[garbageStackUsed][0];

	*height=garbageStack[garbageStackUsed][1];

	*type=garbageStack[garbageStackUsed][2];

	return true;

}

#endif

//Instead of creating new object new game is called, to prevent memory leaks

void BlockGame::NewGame(int tx, int ty, unsigned int ticks)

{

	this->ticks = ticks;

	stageButtonStatus = SBdontShow;

	bReplaying  =  false;

#if NETWORK

	bNetworkPlayer=false;

	bDisconnected =false;

#endif

	nrFellDown = 0;

	lastNrOfPlayers = 1; //At least one player :-)

	nrPushedPixel = 0;

	nrStops = 0;

	topx = tx;

	topy = ty;

	cursorx = 2;

	cursory = 3;

	stop = 0;

	pixels = 0;

	score = 0;

	bGameOver = false;

	bDraw = false;

	timetrial = false;

	stageClear = false;

	linesCleared = 0;

	hasWonTheGame = false;

	vsMode = false;

	puzzleMode = false;

	combo=0;

	chain=0;

	AI_Enabled = false;

	baseSpeed= 0.5;

	speed = baseSpeed;

	speedLevel = 1;

	gameStartedAt = ticks+3000;

	pushedPixelAt = gameStartedAt;

	nextGarbageNumber = 10;

	handicap=0;

	for (int i=0; i<7; i++)

		for (int j=0; j<30; j++)

		{

			board[i][j] = -1;

		}

	for (int i=0; i<NUMBEROFCHAINS; i++)

	{

		chainUsed[i]=false;

		chainSize[i] = 0;

	}

	lastAImove = ticks+3000;

	showGame = true;

	theReplay = Replay();

}	//NewGame

void BlockGame::NewTimeTrialGame(int x,int y, unsigned int ticks)

{

	NewGame(x,y,ticks);

	timetrial = true;

	putStartBlocks();

}

//Starts a new stage game, takes level as input!

void BlockGame::NewStageGame(int level, int tx, int ty,unsigned int ticks)

{

	if (level > -1)

	{

		NewGame(tx, ty,ticks);

		stageClear = true;

		Level = level;

		Stats::getInstance()->addOne("PlayedStageLevel"+itoa2(level));

		stageClearLimit = 30+(Level%6)*10;

		baseSpeed = 0.5/((double)(Level*0.5)+1.0);

		speed = baseSpeed;

	}

}

void BlockGame::NewPuzzleGame(int level, int tx, int ty, unsigned int ticks)

{

	if (level>-1)

	{

		NewGame(tx, ty,ticks);

		puzzleMode = true;

		Level = level;

		MovesLeft = nrOfMovesAllowed[Level];

		for (int i=0; i<6; i++)

			for (int j=0; j<12; j++)

			{

				board[i][j+1] = puzzleLevels[Level][i][j];

			}

		baseSpeed = 100000;

		speed = 100000;

		//Now push the blines up

		for (int i=19; i>0; i--)

			for (int j=0; j<6; j++)

			{

				board[j][i] = board[j][i-1];

			}

		for (int j=0; j<6; j++)

		{

			board[j][0] = rand() % 6;

			if (j > 0)

			{

				if (board[j][0] == board[j-1][0])

					board[j][0] = rand() % 6;

			}

			if (board[j][0] == board[j][1])

				board[j][0] = 6;

			if (board[j][0] == board[j][1])

				board[j][0] = 6;

		}

	}

}

//Replay the current level

void BlockGame::retryLevel(unsigned int ticks)

{

	if(puzzleMode)

		NewPuzzleGame(Level,topx,topy,ticks);

	else if(stageClear)

		NewStageGame(Level,topx,topy,ticks);

}

//Play the next level

void BlockGame::nextLevel(unsigned int ticks)

{

	if(puzzleMode)

	{

		if(Level<nrOfPuzzles-1)

			NewPuzzleGame(Level+1,topx,topy,ticks);

	}

	else if(stageClear)

	{

		if(Level<50-1)

			NewStageGame(Level+1,topx,topy,ticks);

	}

}

//Starts new Vs Game (two Player)

void BlockGame::NewVsGame(int tx, int ty, BlockGame *target,unsigned int ticks)

{

	NewGame(tx, ty,ticks);

	vsMode = true;

	putStartBlocks();

	garbageTarget = target;

	Stats::getInstance()->addOne("VSgamesStarted");

}

//Starts new Vs Game (two Player)

void BlockGame::NewVsGame(int tx, int ty, BlockGame *target, bool AI,unsigned int ticks)

{

	NewGame(tx, ty,ticks);

	vsMode = true;

	AI_Enabled = AI;

	if(!AI)

		Stats::getInstance()->addOne("VSgamesStarted");

	else

		strcpy(name,"CPU\0");

	putStartBlocks();

	garbageTarget = target;

}

//Go in Demonstration mode, no movement

void BlockGame::Demonstration(bool toggle)

{

	speed=0;

	baseSpeed = 0;

}

//We want to play the replay (must have been loaded beforehand)

void BlockGame::playReplay(int tx, int ty, unsigned int ticks)

{

	NewGame(tx, ty,ticks);

	gameStartedAt = ticks;

	bReplaying = true; //We are playing, no calculations

#if NETWORK

	bNetworkPlayer = false; //Take input from replay file

#endif

}

#if NETWORK

//network play

void BlockGame::playNetwork(int tx, int ty,unsigned int ticks)

{

	NewGame(tx, ty,ticks);

	gameStartedAt = ticks;

	bReplaying = false; //We are playing, no calculations

	bNetworkPlayer = true; //Don't Take input from replay file

	emptyGarbageStack();

}

#endif

//Prints "winner" and ends game

void BlockGame::setPlayerWon()

{

	if (!bGameOver)

	{

		gameEndedAfter = ticks-gameStartedAt; //We game ends now!

		if(!AI_Enabled && !bReplaying)

		{

			TimeHandler::addTime("playTime",TimeHandler::ms2ct(gameEndedAfter));

		}

	}

	theReplay.setFinalFrame(getPackage(), 1);

	bGameOver = true;

	hasWonTheGame = true;

	showGame = false;

	if (SoundEnabled)Mix_PlayChannel(1, applause, 0);

	if(!AI_Enabled && !bReplaying)

	{

		Stats::getInstance()->addOne("totalWins");

		if(garbageTarget->AI_Enabled && !(garbageTarget->bReplaying))

		{

			//We have defeated an AI

			Stats::getInstance()->addOne("defeatedAI"+itoa(garbageTarget->getAIlevel()));

		}

	}

	if(AI_Enabled && !(garbageTarget->AI_Enabled) && garbageTarget->bReplaying==false)

	{

		//The AI have defeated a human player

		Stats::getInstance()->addOne("defeatedByAI"+itoa(getAIlevel()));

	}

}

//void SetGameOver();

#if NETWORK

//Sets disconnected:

void BlockGame::setDisconnect()

{

	bDisconnected = true;

	SetGameOver();

}

#endif

//Prints "draw" and ends the game

void BlockGame::setDraw()

{

	bGameOver = true;

	if(!AI_Enabled && !bReplaying)

	{

		TimeHandler::addTime("playTime",TimeHandler::ms2ct(gameEndedAfter));

	}

	theReplay.setFinalFrame(getPackage(), 3);

	hasWonTheGame = false;

	bDraw = true;

	showGame = false;

	Mix_HaltChannel(1);

	if(!AI_Enabled && !bReplaying)

		Stats::getInstance()->addOne("totalDraws");

}

//Function to get a boardpackage

boardPackage BlockGame::getPackage()

{

	boardPackage bp;

	if(ticks<gameStartedAt)

		bp.time = 0;

	else

		bp.time = (Uint32)(ticks-gameStartedAt);

	for (int i=0; i<6; i++)

		for (int j=0; j<13; j++)

		{

			if (board[i][j]%10<7)

				bp.brick[i][j]=board[i][j]%10+1;

			if ((board[i][j]/1000000)%10==1)

			{

				//Ordinary garbage

				int aInt=0; //N=1, S=2, W=4, E=8

				if (i==0)

					aInt+=4;

				else if ((board[i-1][j])!=(board[i][j]))

					aInt+=4;

				if (i==5)

					aInt+=8;

				else if ((board[i+1][j])!=(board[i][j]))

					aInt+=8;

				if (j==0)

					aInt+=2;

				else if ((board[i][j-1])!=(board[i][j]))

					aInt+=2;

				if ((board[i][j+1])!=(board[i][j]))

					aInt+=1;

				switch (aInt)

				{

				case 8:

					bp.brick[i][j]=8;

					break;

				case 7:

					bp.brick[i][j]=10;

					break;

				case 11:

					bp.brick[i][j]=11;

					break;

				case 9:

					bp.brick[i][j]=12;

					break;

				case 5:

					bp.brick[i][j]=13;

					break;

				case 6:

					bp.brick[i][j]=14;

					break;

				case 10:

					bp.brick[i][j]=15;

					break;

				case 3: //M

					bp.brick[i][j]=16;

					break;

				case 0:

					bp.brick[i][j]=17;

					break;

				case 1:

					bp.brick[i][j]=18;

					break;

				case 2:

					bp.brick[i][j]=19;

					break;

				case 4:

					bp.brick[i][j]=20;

					break;

				default:

					bp.brick[i][j]=0;

				};

				//cout << "garbage added to replay: " << aInt << endl;

			}

			if ((board[i][j]/1000000)%10==2)

			{

				//Gray garbage

				bp.brick[i][j]=21;

			}

			if ((board[i][j]/BLOCKHANG)%10==1) //If "get ready"

				bp.brick[i][j]+=30;

		}

	bp.cursorX = (Uint8)cursorx;

	bp.cursorY = (Uint8)cursory;

	bp.score = (Uint32)score;

	bp.pixels = (Uint8)pixels;

	bp.chain = (Uint8)chain;

	bp.speed = (Uint8)speedLevel;

	Uint8 result = 0;

	if (bGameOver)

		result+=1;

	if (hasWonTheGame)

		result+=2;

	if (bDraw)

		result+=4;

	bp.result = (Uint8)result;

	return bp;

}

//Takes a package and sets the board like it

void BlockGame::setBoard(boardPackage bp)

{

	//gameStartedAt = ticks-bp.time;

	for (int i=0; i<6; i++)

		for (int j=0; j<13; j++)

		{

			//if(bp.brick[i][j]/8==0)

			board[i][j]=bp.brick[i][j]-1;

			//else

			//	board[i][j]=-1;

		}

	cursorx=bp.cursorX;

	cursory=bp.cursorY;

	score=bp.score;

	pixels=bp.pixels;

	chain=bp.chain;

	speedLevel=bp.speed;

	Uint8 result = bp.result;

	bGameOver = false; //Make sure that it is initialized!

	if(result%2==1)

	{

		bGameOver=true;

		result-=1;

	}

	if (result%4==2)

	{

		hasWonTheGame = true;

		result-=2;

	}

	if (result==4)

	{

		bDraw = true;

	}

}

//Test if LineNr is an empty line, returns false otherwise.

bool BlockGame::LineEmpty(int lineNr)

{

	bool empty = true;

	for (int i = 0; i <7; i++)

		if (board[i][lineNr] != -1)

			empty = false;

	return empty;

}

//Test if the entire board is empty (used for Puzzles)

bool BlockGame::BoardEmpty()

{

	bool empty = true;

	for (int i=0; i<6; i++)

		for (int j=1; j<13; j++)

			if (board[i][j] != -1)

				empty = false;

	return empty;

}

//Anything that the user can't move? In that case Game Over cannot occur

bool BlockGame::hasStaticContent()

{

	for (int i=0; i<6; i++)

		for (int j=1; j<13; j++)

			if (board[i][j] >= 10000000) 	//Higher than this means combos (garbage is static, but the stack is static but nothing to do about it)

				return true;			//They are static

	return false;					//Return false if no static object found

}

/*

 * Generates some blocks so the user don't see a board without blocks

 */

//void putStartBlocks(Uint32);

void BlockGame::putStartBlocks()

{

	putStartBlocks(time(0));

}

void BlockGame::putStartBlocks(Uint32 n)

{

	for (int i=0; i<7; i++)

		for (int j=0; j<30; j++)

		{

			board[i][j] = -1;

		}

	nextRandomNumber = n;

	int choice = rand2()%3; //Pick a random layout

	switch (choice)

	{

	case 0:

		//row 0:

		board[0][0]=1;

		board[1][0]=0;

		board[2][0]=4;

		board[3][0]=3;

		board[4][0]=3;

		board[5][0]=5;

		//row 1:

		board[0][1]=1;

		board[1][1]=4;

		board[2][1]=2;

		board[3][1]=0;

		board[4][1]=4;

		board[5][1]=5;

		//row 2:

		board[0][2]=2;

		board[1][2]=3;

		board[2][2]=0;

		board[3][2]=4;

		board[4][2]=1;

		board[5][2]=1;

		//row 3:

		board[0][3]=3;

		board[1][3]=2;

		board[2][3]=3;

		board[3][3]=1;

		board[4][3]=0;

		board[5][3]=4;

		//row 4:

		board[0][4]=2;

		board[1][4]=3;

		board[2][4]=3;

		board[3][4]=1;

		board[4][4]=4;

		board[5][4]=0;

		//row 5:

		board[0][5]=-1;

		board[1][5]=5;

		board[2][5]=5;

		board[3][5]=-1;

		board[4][5]=1;

		board[5][5]=-1;

		break;

	case 1:

		//row 0:

		board[0][0]=3;

		board[1][0]=5;

		board[2][0]=0;

		board[3][0]=0;

		board[4][0]=4;

		board[5][0]=2;

		//row 1:

		board[0][1]=3;

		board[1][1]=5;

		board[2][1]=-1;

		board[3][1]=5;

		board[4][1]=4;

		board[5][1]=2;

		//row 2:

		board[0][2]=2;

		board[1][2]=-1;

		board[2][2]=-1;

		board[3][2]=4;

		board[4][2]=0;

		board[5][2]=3;

		//row 3:

		board[0][3]=2;

		board[5][3]=3;

		break;

	default:

		//row 0:

		board[0][0]=4;

		board[1][0]=5;

		board[2][0]=2;

		board[3][0]=0;

		board[4][0]=1;

		board[5][0]=5;

		//row 1:

		board[0][1]=4;

		board[1][1]=5;

		board[2][1]=2;

		board[3][1]=1;

		board[4][1]=0;

		board[5][1]=2;

		//row 2:

		board[0][2]=2;

		board[1][2]=4;

		board[2][2]=-1;

		board[3][2]=0;

		board[4][2]=1;

		board[5][2]=5;

		//row 3:

		board[0][3]=4;

		board[1][3]=2;

		board[2][3]=-1;

		board[3][3]=1;

		board[4][3]=0;

		board[5][3]=2;

		//row 4:

		board[0][4]=4;

		board[1][4]=2;

		board[2][4]=-1;

		board[3][4]=0;

		board[4][4]=1;

		board[5][4]=-1;

		break;

	};

}

//decreases hang for all hanging blocks and wait for waiting blocks

void BlockGame::ReduceStuff()

{

	Uint32 howMuchHang = (ticks - FRAMELENGTH*hangTicks)/FRAMELENGTH;

	if (howMuchHang>0)

	{

		for (int i=0; i<7; i++)

			for (int j=0; j<30; j++)

			{

				if ((board[i][j]/BLOCKHANG)%10==1)

				{

					int hangNumber = (board[i][j]/10)%100;

					if (hangNumber<=howMuchHang)

					{

						board[i][j]-=BLOCKHANG;

						board[i][j]-=hangNumber*10;

					}

					else

					{

						board[i][j]-=10*howMuchHang;

					}

				}

				if ((board[i][j]/BLOCKWAIT)%10==1)

				{

					int hangNumber = (board[i][j]/10)%100;

					if (hangNumber<=howMuchHang)

					{

						//The blocks must be cleared

						board[i][j]-=hangNumber*10;

					}

					else

					{

						board[i][j]-=10*howMuchHang;

					}

				}

			}

	}

	hangTicks+=howMuchHang;

}