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

	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;

	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;

	}

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

	boost::format f("%1%");

	f % 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) {

	boost::format f("%1%");

	f % 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() 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) {

	cursorx = x;

	cursory = y;

}

bool BlockGame::GetIsWinner()  const {

	return hasWonTheGame;

}

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

void BlockGame::NewGame( unsigned int ticks) {

	this->ticks = ticks;

	stageButtonStatus = SBdontShow;

	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;

	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;

}   //NewGame

void BlockGame::NewTimeTrialGame( unsigned int ticks) {

	NewGame(ticks);

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

	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;

}

//Prints "winner" and ends game

void BlockGame::setPlayerWon() {

	if (!bGameOver || !hasWonTheGame) {

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

		if (!AI_Enabled) {

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

		}

		bGameOver = true;

		PlayerWonEvent();

		if (!AI_Enabled) {

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

			if (garbageTarget->AI_Enabled) {

				//We have defeated an AI

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

			}

		}

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

			//The AI have defeated a human player

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

		}

	}

	hasWonTheGame = true;

}

//Prints "draw" and ends the game

void BlockGame::setDraw() {

	bGameOver = true;

	if (!AI_Enabled) {

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

	}

	hasWonTheGame = false;

	bDraw = true;

	DrawEvent();

	if (!AI_Enabled) {

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

	}

}

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

bool BlockGame::LineEmpty(int lineNr) const {

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

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

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

#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) {

	{

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

	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;

}

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

	}

	if (((board[x][y])/1000000 == 1)&&(garbageToBeCleared[x][y] == false)) {

		garbageToBeCleared[x][y] = true;

		//Float fill

		GarbageMarker(x-1, y);

		GarbageMarker(x+1, y);

		GarbageMarker(x, y-1);

		GarbageMarker(x, y+1);

	}

	return 1;

}

int BlockGame::FirstGarbageMarker(int x, int y) {

	if ((x>6)||(x<0)||(y<0)||(y>29)) {

		return -1;

	}

	if (((board[x][y])/1000000 == 2)&&(garbageToBeCleared[x][y] == false)) {

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

			garbageToBeCleared[i][y] = true;

		}

	}

	else if (((board[x][y])/1000000 == 1)&&(garbageToBeCleared[x][y] == false)) {

		garbageToBeCleared[x][y] = true;

		//Float fill

		GarbageMarker(x-1, y);

		GarbageMarker(x+1, y);

		GarbageMarker(x, y-1);

		GarbageMarker(x, y+1);

	}

	return 1;

}

//Clear Blocks if 3 or more is alligned (naive implemented)

void BlockGame::ClearBlocks() {

	bool toBeCleared[7][30]; //true if blok must be removed

	int previus=-1; //the last block checked

	int combo=0;

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

		for (int j=0; j<7; j++) {

			toBeCleared[j][i] = false;

			garbageToBeCleared[j][i] = false;

		}

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

		bool faaling = false;

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

			if ((faaling)&&(board[i][j]>-1)&&(board[i][j]%10000000<7)) {

				board[i][j]+=BLOCKFALL;

			}

			if ((!faaling)&&((board[i][j]/BLOCKFALL)%10==1)) {

				board[i][j]-=BLOCKFALL;

			}

			if (!((board[i][j]>-1)&&(board[i][j]%10000000<7))) {

				faaling=true;

			}

			if (((board[i][j]/1000000)%10==1)||((board[i][j]/1000000)%10==2)||((board[i][j]/BLOCKHANG)%10==1)||((board[i][j]/BLOCKWAIT)%10==1)) {

				faaling = false;

			}

		}

	}

	for (int j=0; j<7; j++) {

		previus = -1;

		combo=0;

		for (int i=1; i<30; i++) {

			if ((board[j][i]>-1)&&(board[j][i]%10000000<7)) {

				if (board[j][i]%10000000 == previus) {

					combo++;

				}

				else {

					if (combo>2)

						for (int k = i-combo; k<i; k++) {

							toBeCleared[j][k] = true;

						}

					combo=1;

					previus = board[j][i]%10000000;

				}

			} //if board

			else {

				if (combo>2)

					for (int k = i-combo; k<i; k++) {

						toBeCleared[j][k] = true;

					}

				combo = 0;

				previus = -1;

			}

		} //for i

	} //for j

	chain = 0;

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

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

			//Clears blocks marked for clearing

			Sint32 temp=board[i][j];

			if (1==((temp/BLOCKWAIT)%10))

				if (((temp/10)%100)==0) {

					if (chainSize[chain]<chainSize[board[i][j]/10000000]) {

						chain = board[i][j]/10000000;

					}

					AddBall(i, j, true, board[i][j]%10);

					AddBall(i, j, false, board[i][j]%10);

					AddExplosion(i, j);

					board[i][j]=-2;

				}

		}

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

		bool setChain=false;

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

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

				setChain=false;

			}

			if (board[i][j]==-2) {

				board[i][j]=-1;

				setChain=true;

				BlockPopEvent();

			}

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

				if ((setChain)&&((board[i][j]/GARBAGE)%10!=1)&&((board[i][j]/GARBAGE)%10!=2)) {

					board[i][j]=((board[i][j]%CHAINPLACE)+CHAINPLACE*chain);

					//somethingsGottaFall = true;

				}

		}

	}

	int startvalue;

	if (pixels == 0) {

		startvalue=1;

	}

	else {

		startvalue=0;

	}

	for (int i=startvalue; i<30; i++) {

		previus=-1;

		combo=0;

		for (int j=0; j<7; j++) {

			if (((board[j][i]>-1)&&(board[j][i]%10000000<7))) {

				if (board[j][i]%10000000 == previus) {

					combo++;

				}

				else {

					if (combo>2)

						for (int k = j-combo; k<j; k++) {

							toBeCleared[k][i] = true;

						}

					combo=1;

					previus = board[j][i]%10000000;

				}

			} //if board

			else {

				if (combo>2)

					for (int k = j-combo; k<j; k++) {

						toBeCleared[k][i] = true;

					}

				combo = 0;

				previus = -1;

			}

		} //for j

	} //for i

	combo = 0;

	chain = 0;

	int grey = 0;

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

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

			if (toBeCleared[j][i]) {

				//see if any garbage is around:

				FirstGarbageMarker(j-1, i);

				FirstGarbageMarker(j+1, i);

				FirstGarbageMarker(j, i-1);

				FirstGarbageMarker(j, i+1);

				//that is checked now :-)

				if (board[j][i]%10000000==6) {

					grey++;

				}

				if ((vsMode) && (grey>2) && (board[j][i]%10000000==6)) {

					garbageTarget->CreateGreyGarbage();

				}

				if ((board[j][i]>-1)&&(board[j][i]%10000000<7)) {

					board[j][i]+=BLOCKWAIT+10*FALLTIME;