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.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

// The game uses a very special  base-10 pack system

// int  999999999999

//      YYYYYGWBHTTC

// YYYY = Chain

// G = Garbage, 1= NORMAL, 2=GRAY

// W = Waiting (A bomb is on it)

// B = 1 if the block is falling

// H = Block is hanging after garbage (Get Ready text on it)

// TT = Time (in steps) until something happens

// C = color

static bool block_isFalling(int block) {

	return (block/BLOCKFALL)%10;

}

static void block_setFalling(int& block, bool value) {

	if (value) {

		if (!block_isFalling(block)) {

			block += BLOCKFALL;

		}

	}

	else {

		if (block_isFalling(block)) {

			block -= BLOCKFALL;

		}

	}

}

#include "BlockGame.hpp"

#include "puzzlehandler.hpp"

#include "stageclearhandler.hpp"

#include <sstream>

#include <deque>

//Function to convert numbers to string (2 diget)

static std::string itoa2(int num) {

	char buffer[20];

	snprintf(buffer, sizeof(buffer), "%02i", num);

	return buffer;

}

/**

 * This function tells how long the game may pause the rise of the blocks.

 * This decreases as the game progresses.

 * @param stops In out variable. If larger than the max allowed

 * @param ticks Ticks since the game was started

 * @param gameStartedAt Tick the game was started at.

 */

static void capMaxStops(int& stops, unsigned int ticks, unsigned int gameStartedAt) {

	if (ticks < gameStartedAt || stops == 0) {

		//Game not started or not stops, do nothing

		return;

	}

	unsigned int gameTime = gameStartedAt - ticks;

	int maxSeconds = 10-( (gameTime/1000) % 30 );

	if (maxSeconds < 3) {

		maxSeconds = 1;

	}

	int cappedStops = maxSeconds * 1000;

	if (stops > cappedStops) {

		stops = cappedStops;

	}

}

stageButton stageButtonStatus;

static std::stringstream ss; //Used for internal formatting

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

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

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

int BlockGame::rand2() {

	nextRandomNumber = nextRandomNumber*1103515245 + 12345;

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

	AI_MoveSpeed=100;

	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;

		}

	}

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

}   //Constructor

void BlockGame::setGameSpeed(int globalSpeedLevel) {

	switch (globalSpeedLevel) {

	case 0:

		baseSpeed=0.5;

		break;

	case 1:

		baseSpeed=0.1;

		break;

	case 2:

		baseSpeed=0.07;

		break;

	case 3:

		baseSpeed=0.04;

		break;

	case 4:

		baseSpeed=0.015;

		break;

	default:

		baseSpeed=0.005;

		break;

	};

}

void BlockGame::setHandicap(int globalHandicap) {

	handicap=1000*((int)globalHandicap);

}

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

//Also enables AI

void BlockGame::setAIlevel(int aiLevel) {

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

};

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

}

int BlockGame::GetGameStartedAt() const {

	return gameStartedAt;

}

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

}

void BlockGame::NewGame(const BlockGameStartInfo& s) {

	replayInfo.startInfo = s;

	replayInfo.actions.clear();

	this->recordStats = s.recordStats;

	if (s.AI) {

		recordStats = false;

	}

	NewGameInternal(s.ticks);

	if (s.timeTrial) {

		timetrial = true;

		putStartBlocks();

	}

	if (s.stageClear) {

		if (s.level > -1) {

			stageClear = true;

			Level = s.level;

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

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

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

			speed = baseSpeed;

		}

	}

	if (s.puzzleMode) {

		if (s.level>-1) {

			puzzleMode = true;

			Level = s.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] = 5;

			}

		}

		this->singlePuzzle = s.singlePuzzle;

	}

	if (s.vsMode) {

		vsMode = true;

		AI_Enabled = s.AI;

		if (recordStats) {

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

		}

		if (s.vsAI) {

			setAIlevel(s.level);

			vsAI = true;

		}

		if (AI_Enabled) {

			name = "CPU";

			setAIlevel(s.level);

		}

		putStartBlocks();

	}

	if (s.startBlocks >= 0) {

		putStartBlocks(s.startBlocks);

	}

	if (s.handicap > 0) {

		setHandicap(s.handicap);

	}

	if (s.gameSpeed > 0) {

		setGameSpeed(s.gameSpeed);

		speed = baseSpeed;

	}

}

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

void BlockGame::NewGameInternal( 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::FinalizeBlockGameInfo() {

	replayInfo.extra.name = name;

	replayInfo.extra.score = score;

	replayInfo.extra.seconds = gameEndedAfter;

}

//Prints "winner" and ends game

void BlockGame::setPlayerWon() {

	if (!bGameOver || !hasWonTheGame) {

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

		if (recordStats) {

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

		}

		bGameOver = true;

		PlayerWonEvent();

		if (recordStats) {

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

			if (vsAI) {

				//We have defeated an AI

				Stats::getInstance()->addOne("defeatedAI"+std::to_string(getAIlevel()));

			}

		}

		if (AI_Enabled && vsAI) {

			//The AI have defeated a human player

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

		}

		FinalizeBlockGameInfo();

	}

	hasWonTheGame = true;

}

//Prints "draw" and ends the game

void BlockGame::setDraw() {

	bGameOver = true;

	if (recordStats) {

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

	}

	hasWonTheGame = false;

	bDraw = true;

	DrawEvent();

	if (recordStats) {

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

	}

	FinalizeBlockGameInfo();

}

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

}

void BlockGame::putStartBlocks() {

	putStartBlocks(time(0));

}

void BlockGame::putStartBlocks(int 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() {

	int 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 ( startPosition <= 29 && !LineEmpty(startPosition)) {

			startPosition++;

		}

		if (startPosition >= 29) {

			return false;    //failed to place blocks

		}

		if (29-startPosition<height) {

			return false;    //not enough space

		}

		int start = 0;

		int end = 6;

		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;

		}

		return true;

	}

	return false;

}

//Creates garbage using a given wide and height

bool BlockGame::CreateGreyGarbage() {

	int startPosition = 12;

	while ( startPosition <= 29 && !LineEmpty(startPosition) ) {

		startPosition++;

	}

	if (startPosition >= 29) {

		return false;    //failed to place blocks

	}

	int start = 0;

	int 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] = this->rand2() % 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)) {

				block_setFalling(board[i][j], true);

			}

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

				block_setFalling(board[i][j], false);

			}

			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

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

				}

			}

		}

	}

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

				}