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

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

*/

//Some definitions

//The game is divided in frames. FALLTIME means the blocks will fall one block every FRAMELENGTH*FALLTIME millisecond

#define FRAMELENGTH 50

#define HANGTIME 40

#define FALLTIME 20

//Don't change the following, they are fundamental and later some functions are hardcoded

#define BLOCKFALL 10000

#define GARBAGE 1000000

#define CHAINPLACE 10000000

#include "BlockGame.hpp"

#include "puzzlehandler.hpp"

#include<boost/lexical_cast.hpp>

static stringstream ss; //Used for internal formatting

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

//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;

	AIlineToClear = 0;

	AIcolorToClear = 0;

	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();

	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)

{

	format f("%1%");

	f % globalSpeedLevel;

	ActionPerformed(ACTION_GAMESPEED,f.str());

	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)

{

	format f("%1%");

	f % globalHandicap;

	ActionPerformed(ACTION_HANDICAP, f.str());

	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() const

{

	return (120-AI_MoveSpeed)/20+3;

}

int BlockGame::GetScore() const

{

	return score;

}

int BlockGame::GetHandicap() const

{

	return handicap;

}

bool BlockGame::isGameOver() const

{

	return bGameOver;

}

Sint32 BlockGame::GetGameStartedAt() const

{

	return gameStartedAt;

}

Sint32 BlockGame::GetGameEndedAt() const

{

	return gameEndedAfter;

}

bool BlockGame::isTimeTrial() const

{

	return timetrial;

}

bool BlockGame::isStageClear() const

{

	return stageClear;

}

bool BlockGame::isVsMode() const

{

	return vsMode;

}

bool BlockGame::isPuzzleMode() const

{

	return puzzleMode;

}

int BlockGame::GetLinesCleared() const

{

	return linesCleared;

}

int BlockGame::GetStageClearLimit() const

{

	return stageClearLimit;

}

int BlockGame::GetChains() const

{

	return chain;

}

int BlockGame::GetPixels() const

{

	return pixels;

}

int BlockGame::GetSpeedLevel() const

{

	return speedLevel;

}

int BlockGame::GetTowerHeight() const

{

	return TowerHeight;

}

int BlockGame::GetCursorX() const

{

	return cursorx;

}

int BlockGame::GetCursorY() const

{

	return cursory;

}

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

{

	format f("%1% %2%");

	f % x % y;

	ActionPerformed(ACTION_MOVECURSORTO, f.str());

	cursorx = x;

	cursory = y;

}

bool BlockGame::GetIsWinner()  const

{

	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( unsigned int ticks)

{

	this->ticks = ticks;

	stageButtonStatus = SBdontShow;

	bReplaying  =  false;

#if NETWORK

	bNetworkPlayer=false;

	bDisconnected =false;

#endif

	nrFellDown = 0;

	nrPushedPixel = 0;

	nrStops = 0;

	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;

	actionIndex = 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;

	theReplay = Replay();

	ActionPerformed(ACTION_NEW,"");

}	//NewGame

void BlockGame::NewTimeTrialGame( unsigned int ticks)

{

	NewGame(ticks);

	ActionPerformed(ACTION_NEWTT,"");

	timetrial = true;

	putStartBlocks();

}

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

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

{

	if (level > -1)

	{

		NewGame(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, unsigned int ticks)

{

	if (level>-1)

	{

		NewGame(ticks);

		puzzleMode = true;

		Level = level;

		MovesLeft = PuzzleNumberOfMovesAllowed(Level);

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

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

			{

				board[i][j+1] = PuzzleGetBrick(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, ticks);

	}

	else if (stageClear) {

		NewStageGame(Level, ticks);

	}

}

//Play the next level

void BlockGame::nextLevel(unsigned int ticks)

{

	if (puzzleMode) {

		if (Level<PuzzleGetNumberOfPuzzles()-1) {

			NewPuzzleGame(Level+1, ticks);

		}

	}

	else if(stageClear) {

		if (Level<50-1) {

			NewStageGame(Level+1, ticks);

		}

	}

}

//Starts new Vs Game (two Player)

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

{

	NewGame(ticks);

	ActionPerformed(ACTION_NEWVS,"");

	vsMode = true;

	putStartBlocks();

	garbageTarget = target;

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

}

//Starts new Vs Game (two Player)

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

{

	NewGame(ticks);

	vsMode = true;

	AI_Enabled = AI;

	if(!AI) {

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

	}

	else {

		name = "CPU";

	}

	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( unsigned int ticks, const Replay& r)

{

	if(r.getActions().size()==0)

	{

		cerr << "Empty replay data" << endl;

		return;

	}

	NewGame(ticks);

	gameStartedAt = ticks+3000;

	replayIndex = 0;

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

	theReplay = r;

#if NETWORK

	bNetworkPlayer = false; //Take input from replay file

#endif

}

#if NETWORK

//network play

void BlockGame::playNetwork(unsigned int ticks)

{

	NewGame(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()

{

	ActionPerformed(ACTION_WIN,"");

	if (!bGameOver || !hasWonTheGame)

	{

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

		if(!AI_Enabled && !bReplaying)

		{

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

		}

		bGameOver = true;

		PlayerWonEvent();

		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()));

		}

	}

	hasWonTheGame = true;

}

//void SetGameOver();

#if NETWORK

//Sets disconnected:

void BlockGame::setDisconnect()

{

	bDisconnected = true;

	SetGameOver();

}

#endif

//Prints "draw" and ends the game

void BlockGame::setDraw()

{

	ActionPerformed(ACTION_DRAW, "");

	bGameOver = true;

	if(!AI_Enabled && !bReplaying)

	{

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

	}

	hasWonTheGame = false;

	bDraw = true;

	DrawEvent();

	if (!AI_Enabled && !bReplaying) {

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

	}

}

//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)

{

	format f("%1%");

	f % n;

	ActionPerformed(ACTION_STARTBLOCKS ,f.str());

#if DEBUG

	cout << n << ":" << f.str() << endl;

#endif

	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()

{

	Sint32 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;

}

//Creates garbage using a given wide and height

bool BlockGame::CreateGarbage(int wide, int height)

{

	format f("%1% %2%");

	f % wide % height;

	ActionPerformed(ACTION_CREATEGARBAGE,f.str());

#if NETWORK

	if (bNetworkPlayer)

	{

		pushGarbage(wide, height, 0);

	}

	else

#endif

	{

		if (wide>6) wide = 6;

		if (height>12) height = 12;

		int startPosition = 12;

		while ((!(LineEmpty(startPosition))) || (startPosition == 29))

			startPosition++;

		if (startPosition == 29) return false; //failed to place blocks

		if (29-startPosition<height) return false;	//not enough space

		int start, end;

		if (bGarbageFallLeft)

		{

			start=0;

			end=start+wide;

			bGarbageFallLeft = false;

		}

		else

		{

			start=6-wide;

			end = 6;

			bGarbageFallLeft = true;

		}

		for (int i = startPosition; i <startPosition+height; i++)

			for (int j = start; j < end; j++)

			{

				board[j][i] = 1000000+nextGarbageNumber;

			}

		nextGarbageNumber++;

		if (nextGarbageNumber>999999) nextGarbageNumber = 10;

		//bGarbageFallLeft = !(bGarbageFallLeft);

		return true;

	}

	return false;

}

//Creates garbage using a given wide and height

bool BlockGame::CreateGreyGarbage()

{

	ActionPerformed(ACTION_CREATEGRAYGARBAGE,"");

#if NETWORK

	if (bNetworkPlayer)

	{

		pushGarbage(6, 1, 1);

	}

	else

#endif

	{

		int startPosition = 12;

		while ((!(LineEmpty(startPosition))) || (startPosition == 29))

			startPosition++;

		if (startPosition == 29) return false; //failed to place blocks

		if (29-startPosition<1) return false;	//not enough space

		int start, end;

		{

			start=0;

			end=6;

		}

		for (int i = startPosition; i <startPosition+1; i++)

		{

			for (int j = start; j < end; j++)

			{

				board[j][i] = 2*1000000+nextGarbageNumber;

			}

		}

		nextGarbageNumber++;

		if (nextGarbageNumber>999999)

			nextGarbageNumber = 10;

		return true;

	}

	return false;

}

//Clears garbage, must take one the lower left corner!

int BlockGame::GarbageClearer(int x, int y, int number, bool aLineToClear, int chain)

{

	if ((board[x][y])%1000000 != number) return -1;

	if (aLineToClear)

	{

		board[x][y] = rand() % 6;

		board[x][y] += 10*HANGTIME+BLOCKHANG+CHAINPLACE*chain;

	}

	garbageToBeCleared[x][y] = false;

	GarbageClearer(x+1, y, number, aLineToClear, chain);

	GarbageClearer(x, y+1, number, false, chain);

	return 1;

}

//Marks garbage that must be cleared

int BlockGame::GarbageMarker(int x, int y)

{

	if ((x>6)||(x<0)||(y<0)||(y>29)) return -1;