blame: source/code/main.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://www.blockattack.net

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

*/

#include "common.h"

#include "global.hpp"

#include "scopeHelpers.hpp"

#include "icon.hpp"

#include "os.hpp"

#include <string.h>

#include "version.h"

//If DEBUG is defined: AI info and FPS will be written to screen

#ifndef DEBUG

#define DEBUG 1

#endif

#define WITH_SDL 1

#include "sago/SagoSpriteHolder.hpp"

#include <iostream>

#include <stdlib.h>

#include <time.h>           //Used for srand()

#include <sstream>          //Still used by itoa2

#include <string>

#include "SDL.h"            //The SDL libary, used for most things

#include <SDL_mixer.h>      //Used for sound & music

#include <SDL_image.h>      //To load PNG images!

#include <physfs.h>         //Abstract file system. To use containers

#include "Libs/NFont.h"

//#include "ttfont.h"        //To use True Type Fonts in SDL

//#include "config.h"

#include <vector>

#include "MenuSystem.h"

#include "puzzlehandler.hpp"

#include "stageclearhandler.hpp"

#include <memory>

#include "ScoresDisplay.hpp"

//if SHAREDIR is not used we look in current directory

#ifndef SHAREDIR

#define SHAREDIR "."

#endif

#ifndef LOCALEDIR

#define LOCALEDIR SHAREDIR"/locale"

#endif

#ifndef PACKAGE

#define PACKAGE "blockattack_roftb"

#endif

#include "highscore.h"      //Stores highscores

#include "ReadKeyboard.h"   //Reads text from keyboard

#include "stats.h"          //Saves general stats 

//#include "uploadReplay.h"   //Takes care of everything libcurl related

#include "common.h"

#include "gamecontroller.h"

#include <boost/program_options.hpp>

/*******************************************************************************

* All variables and constant has been moved to mainVars.inc for the overview.  *

*******************************************************************************/

#include "mainVars.inc"

using namespace std;

static int InitImages(sago::SagoSpriteHolder& holder);

static void FsSearchParthMainAppend(std::vector<std::string>& paths) {

	paths.push_back((string)SHAREDIR+"/blockattack.data");

	paths.push_back((string)PHYSFS_getBaseDir()+"/blockattack.data");

	paths.push_back((string)PHYSFS_getBaseDir()+"/data");

}

static void PhysFsSetSearchPath(const vector<string>& paths, const string& savepath) {

	for (const string& path : paths) {

		PHYSFS_addToSearchPath(path.c_str(),1);

	}

	PHYSFS_addToSearchPath(savepath.c_str(), 1);

	PHYSFS_setWriteDir(savepath.c_str());

}

static void PhysFsCreateFolders() {

	PHYSFS_mkdir("screenshots");

	PHYSFS_mkdir("replays");

	PHYSFS_mkdir("puzzles");

}

//Load all image files to memory

static int InitImages(sago::SagoSpriteHolder& holder) {

	bricks[0] = holder.GetSprite("blue");

	bricks[1] = holder.GetSprite("green");

	bricks[2] = holder.GetSprite("purple");

	bricks[3] = holder.GetSprite("red");

	bricks[4] = holder.GetSprite("turkish");

	bricks[5] = holder.GetSprite("yellow");

	bricks[6] = holder.GetSprite("grey");

	bomb = holder.GetSprite("block_bomb");

	backgroundImage = holder.GetSprite("background");

	bHighScore = holder.GetSprite("b_highscore");

	bBack = holder.GetSprite("b_blank");

	bForward = holder.GetSprite("b_forward");

	blackLine = holder.GetSprite("black_line");

	stageBobble = holder.GetSprite("i_stage_clear_limit");

	crossover = holder.GetSprite("crossover");

	balls[0] = holder.GetSprite("ball_blue");

	balls[1] = holder.GetSprite("ball_green");

	balls[2] = holder.GetSprite("ball_purple");

	balls[3] = holder.GetSprite("ball_red");

	balls[4] = holder.GetSprite("ball_turkish");

	balls[5] = holder.GetSprite("ball_yellow");

	balls[6] = holder.GetSprite("ball_gray");

	cursor = holder.GetSprite("cursor");

	ready = holder.GetSprite("ready");

	explosion[0] = holder.GetSprite("explosion0");

	explosion[1] = holder.GetSprite("explosion1");

	explosion[2] = holder.GetSprite("explosion2");

	explosion[3] = holder.GetSprite("explosion3");

	counter[0] = holder.GetSprite("counter_1");

	counter[1] = holder.GetSprite("counter_2");

	counter[2] = holder.GetSprite("counter_3");

	iGameOver = holder.GetSprite("i_game_over");

	iWinner = holder.GetSprite("i_winner");

	iDraw = holder.GetSprite("i_draw");

	iLoser = holder.GetSprite("i_loser");

	iChainFrame = holder.GetSprite("chain_frame");

	dialogBox = holder.GetSprite("dialogbox");

	iLevelCheck = holder.GetSprite("i_level_check");

	iLevelCheckBox = holder.GetSprite("i_level_check_box");

	iLevelCheckBoxMarked = holder.GetSprite("i_level_check_box_marked");

	iCheckBoxArea = holder.GetSprite("i_check_box_area");

	boardBackBack = holder.GetSprite("board_back_back");

	garbageTL = holder.GetSprite("garbage_tl");

	garbageT = holder.GetSprite("garbage_t");

	garbageTR = holder.GetSprite("garbage_tr");

	garbageR = holder.GetSprite("garbage_r");

	garbageBR = holder.GetSprite("garbage_br");

	garbageB = holder.GetSprite("garbage_b");

	garbageBL = holder.GetSprite("garbage_bl");

	garbageL = holder.GetSprite("garbage_l");

	garbageFill = holder.GetSprite("garbage_fill");

	garbageML = holder.GetSprite("garbage_ml");

	garbageM = holder.GetSprite("garbage_m");

	garbageMR = holder.GetSprite("garbage_mr");

	garbageGM = holder.GetSprite("garbage_gm");

	garbageGML = holder.GetSprite("garbage_gml");

	garbageGMR = holder.GetSprite("garbage_gmr");

	smiley[0] = holder.GetSprite("smileys0");

	smiley[1] = holder.GetSprite("smileys1");

	smiley[2] = holder.GetSprite("smileys2");

	smiley[3] = holder.GetSprite("smileys3");

	transCover = holder.GetSprite("trans_cover");

	bExit = holder.GetSprite("b_exit");

	bSkip = holder.GetSprite("b_blank");

	bNext = holder.GetSprite("b_blank");

	bRetry = holder.GetSprite("b_blank");

	mouse = holder.GetSprite("mouse");

	menuMarked = holder.GetSprite("menu_marked");

	menuUnmarked = holder.GetSprite("menu_unmarked");

	backBoard = holder.GetSprite("back_board");

	SDL_Color nf_button_color, nf_standard_blue_color, nf_standard_small_color;

	memset(&nf_button_color,0,sizeof(SDL_Color));

	nf_button_color.b = 255;

	nf_button_color.g = 255;

	nf_button_color.r = 255;

	nf_button_color.a = 255;

	nf_standard_blue_color.b = 255;

	nf_standard_blue_color.g = 0;

	nf_standard_blue_color.r = 0;

	nf_standard_blue_color.a = 255;

	nf_standard_small_color.b = 0;

	nf_standard_small_color.g = 0;

	nf_standard_small_color.r = 200;

	nf_standard_small_color.a = 255;

	nf_button_font.load(screen, holder.GetDataHolder().getFontPtr("freeserif", 24), nf_button_color);

	nf_standard_blue_font.load(screen, holder.GetDataHolder().getFontPtr("freeserif", 30), nf_standard_blue_color);

	nf_standard_small_font.load(screen, holder.GetDataHolder().getFontPtr("freeserif", 16), nf_standard_small_color);

	nf_scoreboard_font.load(screen, holder.GetDataHolder().getFontPtr("penguinattack", 20), nf_button_color);

//Loads the sound if sound present

	if (!NoSound) {

		//And here the music:

		bgMusic = holder.GetDataHolder().getMusicPtr("bgmusic");

		highbeatMusic = holder.GetDataHolder().getMusicPtr("highbeat");

		//the music... we just hope it exists, else the user won't hear anything

		//Same goes for the sounds

		boing = holder.GetDataHolder().getSoundPtr("pop");

		applause = holder.GetDataHolder().getSoundPtr("applause");

		photoClick = holder.GetDataHolder().getSoundPtr("cameraclick");

		typingChunk = holder.GetDataHolder().getSoundPtr("typing");

		counterChunk = holder.GetDataHolder().getSoundPtr("counter");

		counterFinalChunk = holder.GetDataHolder().getSoundPtr("counter_final");

	} //All sound has been loaded or not

	return 0;

} //InitImages()

/*Draws a image from on a given Surface. Takes source image, destination surface and coordinates*/

void DrawIMG(const sago::SagoSprite& sprite, SDL_Renderer* target, int x, int y) {

	sprite.Draw(target, SDL_GetTicks() ,x,y);

}

void DrawIMG_Bounded(const sago::SagoSprite& sprite, SDL_Renderer* target, int x, int y, int minx, int miny, int maxx, int maxy) {

	SDL_Rect bounds;

	bounds.x = minx;

	bounds.y = miny;

	bounds.w = maxx-minx;

	bounds.h = maxy-miny;

	sprite.DrawBounded(target, SDL_GetTicks(),x,y,bounds);

}

static void NFont_Write(SDL_Renderer* target, int x, int y, const string& text) {

	nf_standard_blue_font.draw(target, x, y, "%s", text.c_str());

}

static void NFont_Write(SDL_Renderer* target, int x, int y, const char* text) {

	nf_standard_blue_font.draw(target, x, y, "%s", text);

}

SDL_Window* sdlWindow;

std::unique_ptr<sago::SagoDataHolder> dataHolder;

std::unique_ptr<sago::SagoSpriteHolder> spriteHolder;

void ResetFullscreen() {

	Mix_HaltMusic();  //We need to reload all data in case the screen type changes. Music must be stopped before unload.

	if (bFullscreen) {

		SDL_SetWindowFullscreen(sdlWindow, SDL_WINDOW_FULLSCREEN_DESKTOP);

	}

	else {

		SDL_SetWindowFullscreen(sdlWindow, 0);

	}

	dataHolder.reset(new sago::SagoDataHolder(screen));

	spriteHolder.reset(new sago::SagoSpriteHolder( *(dataHolder.get()) ) );

	InitImages(*(spriteHolder.get()) );

	SDL_ShowCursor(SDL_DISABLE);

}

//The small things that are faaling when you clear something

class ABall {

private:

	double x = 0.0;

	double y = 0.0;

	double velocityY = 0.0;

	double velocityX = 0.0;

	int color = 0;

	unsigned long int lastTime = 0;

public:

	ABall() {

	}

	//constructor:

	ABall(int X, int Y, bool right, int coulor) {

		double tal = 1.0+((double)rand()/((double)RAND_MAX));

		velocityY = -tal*startVelocityY;

		lastTime = currentTime;

		x = (double)X;

		y = (double)Y;

		color = coulor;

		if (right) {

			velocityX = tal*VelocityX;

		}

		else {

			velocityX = -tal*VelocityX;

		}

	}  //constructor

	void update() {

		double timePassed = (((double)(currentTime-lastTime))/1000.0);  //time passed in seconds

		x = x+timePassed*velocityX;

		y = y+timePassed*velocityY;

		velocityY = velocityY + gravity*timePassed;

		if (y<1.0) {

			velocityY=10.0;

		}

		if ((velocityY>minVelocity) && (y>(double)(768-ballSize)) && (y<768.0)) {

			velocityY = -0.70*velocityY;

			y = 768.0-ballSize;

		}

		lastTime = currentTime;

	}

	int getX() {

		return (int)x;

	}

	int getY() {

		return (int)y;

	}

	int getColor() {

		return color;

	}

};  //aBall

static const int maxNumberOfBalls = 6*12*2*2;

class BallManager {

public:

	ABall ballArray[maxNumberOfBalls];

	bool ballUsed[maxNumberOfBalls];

	BallManager() {

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

			ballUsed[i] = false;

		}

	}

	//Adds a ball to the screen at given coordiantes, traveling right or not with color

	int addBall(int x, int y,bool right,int color) {

		int ballNumber = 0;

		//Find a free ball

		while (ballNumber<maxNumberOfBalls && ballUsed[ballNumber]) {

			ballNumber++;

		}

		//Could not find a free ball, return -1

		if (ballNumber==maxNumberOfBalls) {

			return -1;

		}

		currentTime = SDL_GetTicks();

		ballArray[ballNumber] = ABall(x,y,right,color);

		ballUsed[ballNumber] = true;

		return 1;

	}  //addBall

	void update() {

		currentTime = SDL_GetTicks();

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

			if (ballUsed[i]) {

				ballArray[i].update();

				if (ballArray[i].getY()>800 || ballArray[i].getX()>xsize || ballArray[i].getX()<-ballSize) {

					ballUsed[i] = false;

				}

			}

		}

	} //update

}; //theBallManager

static BallManager theBallManager;

//a explosions, non moving

class AnExplosion {

private:

	int x = 0;

	int y = 0;

	Uint8 frameNumber = 0;

#define frameLength 80

	//How long an image in an animation should be showed

#define maxFrame 4

	//How many images there are in the animation

	unsigned long int placeTime = 0; //Then the explosion occored

public:

	AnExplosion() {

	}

	//constructor:

	AnExplosion(int X, int Y) {

		placeTime = currentTime;

		x = X;

		y = Y;

		frameNumber=0;

	}  //constructor

	//true if animation has played and object should be removed from the screen

	bool removeMe() {

		frameNumber = (currentTime-placeTime)/frameLength;

		return (!(frameNumber<maxFrame));

	}

	int getX() {

		return (int)x;

	}

	int getY() {

		return (int)y;

	}

	int getFrame() {

		return frameNumber;

	}

};  //nExplosion

class ExplosionManager {

public:

	AnExplosion explosionArray[maxNumberOfBalls];

	bool explosionUsed[maxNumberOfBalls];

	ExplosionManager() {

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

			explosionUsed[i] = false;

		}

	}

	int addExplosion(int x, int y) {

		int explosionNumber = 0;

		while ( explosionNumber<maxNumberOfBalls && explosionUsed[explosionNumber]) {

			explosionNumber++;

		}

		if (explosionNumber==maxNumberOfBalls) {

			return -1;

		}

		currentTime = SDL_GetTicks();

		explosionArray[explosionNumber] = AnExplosion(x,y);

		explosionUsed[explosionNumber] = true;

		return 1;

	}  //addBall

	void update() {

		currentTime = SDL_GetTicks();

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

			if (explosionUsed[i]) {

				if (explosionArray[i].removeMe()) {

					explosionUsed[i] = false;

				}

			}

		}

	} //update

}; //explosionManager

static ExplosionManager theExplosionManager;

//text pop-up

class TextMessage {

private:

	int x = 0;

	int y = 0;

	string textt;

	unsigned long int time = 0;

	unsigned long int placeTime = 0; //Then the text was placed

public:

	TextMessage() {

	}

	//constructor:

	TextMessage(int X, int Y,const char* Text,unsigned int Time) {

		placeTime = currentTime;

		x = X;

		y = Y;

		textt = Text;

		time = Time;

	}  //constructor

	//true if the text has expired

	bool removeMe() {

		return currentTime-placeTime>time;

	}

	int getX() {

		return x;

	}

	int getY() {

		return y;

	}

	const char* getText() {

		return textt.c_str();

	}

};  //text popup

class TextManager {

public:

	TextMessage textArray[maxNumberOfBalls];

	bool textUsed[maxNumberOfBalls];

	TextManager() {

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

			textUsed[i] = false;

		}

	}

	int addText(int x, int y,string Text,unsigned int Time) {

		int textNumber = 0;

		while (textNumber<maxNumberOfBalls && textUsed[textNumber]) {

			textNumber++;

		}

		if (textNumber==maxNumberOfBalls) {

			return -1;

		}

		currentTime = SDL_GetTicks();

		textArray[textNumber] = TextMessage(x,y,Text.c_str(),Time);

		textUsed[textNumber] = true;

		return 1;

	}  //addText

	void update() {

		currentTime = SDL_GetTicks();

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

			if (textUsed[i]) {

				if (textArray[i].removeMe()) {

					textUsed[i] = false;

				}

			}

		}

	} //update

}; //textManager

static TextManager theTextManager;

//Here comes the Block Game object

#include "BlockGame.hpp"

#include "os.hpp"

#include "sago/SagoMiscSdl2.hpp"

#include "ScoresDisplay.hpp"

class BlockGameSdl : public BlockGame {

public:

	BlockGameSdl(int tx, int ty) {

		topx = tx;

		topy = ty;

	}

	void DrawImgBoard(const sago::SagoSprite& img, int x, int y) const {

		DrawIMG(img, screen, x+topx, y+topy);

	}

	void DrawImgBoardBounded(const sago::SagoSprite& img, int x, int y) const {

		DrawIMG_Bounded(img, screen, x+topx, y+topy, topx, topy, topx + backBoard.GetWidth(), topy + backBoard.GetHeight());

	}

	void PrintTextCenteredBoard(int x, int y, const char* text) {

		nf_button_font.draw(screen, x+topx+60, y+topy+10, NFont::CENTER, "%s", text);

	}

	int GetTopX() const {

		return topx;

	}

	int GetTopY() const {

		return topy;

	}

	/**

	 * Retrives the coordinate to a given brick based on mouse input.

	 * @param match true if the coordinate are within borders

	 * @param mousex mouse coordinate input

	 * @param mousey mouse coordiante input

	 * @param x brick x. Unchanged if outside border

	 * @param y brick y. Unchanged if outside border

	 */

	void GetBrickCoordinateFromMouse(bool& match, int mousex, int mousey, int& x, int& y) const {

		if (mousex < topx || mousex > topx+50*6 || mousey < topy || mousey > topy+50*12) {

			match = false;

			return;

		}

		match = true;

		x = (mousex-topx) / 50;

		y = (50*12+topy-mousey-pixels) / 50;

	}

	void AddText(int x, int y, const std::string& text, int time) const override {

		theTextManager.addText(topx-10+x*bsize, topy+12*bsize-y*bsize, text, time);

	}

	void AddBall(int x, int y, bool right, int color) const  override {

		theBallManager.addBall(topx+40+x*bsize, topy+bsize*12-y*bsize, right, color);

	}

	void AddExplosion(int x, int y) const  override {

		theExplosionManager.addExplosion(topx-10+x*bsize, topy+bsize*12-10-y*bsize);

	}

	void PlayerWonEvent() const  override {

		if (!SoundEnabled) {

			return;

		}

		Mix_PlayChannel(1, applause, 0);

	}

	void DrawEvent() const override {

		Mix_HaltChannel(1);

	}

	void BlockPopEvent() const  override {

		if (!SoundEnabled) {

			return;

		}

		Mix_PlayChannel(0, boing, 0);

	}

	void LongChainDoneEvent() const  override {

		if (!SoundEnabled) {

			return;

		}

		Mix_PlayChannel(1, applause, 0);

	}

	void TimeTrialEndEvent() const  override {

		if (!NoSound && SoundEnabled) {

			Mix_PlayChannel(1,counterFinalChunk,0);

		}

	}

	void EndlessHighscoreEvent() const  override {

		if (!SoundEnabled) {

			return;

		}

		Mix_PlayChannel(1, applause, 0);

	}

private:

	//Draws all the bricks to the board (including garbage)

	void PaintBricks() const {

		for (int i=0; ((i<13)&&(i<30)); i++) {

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

				int basicBrick = board[j][i]%10; //The basic brick, stored on the least significant digit

				if ((basicBrick > -1) && (basicBrick < 7) && ((board[j][i]/1000000)%10==0)) {

					DrawImgBoardBounded(bricks[basicBrick],  j*bsize, bsize*12-i*bsize-pixels);

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

						DrawImgBoard(bomb,  j*bsize, bsize*12-i*bsize-pixels);

					}

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

						DrawImgBoardBounded(ready,  j*bsize, bsize*12-i*bsize-pixels);

					}

				}

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

					int left, right, over, under;

					int number = board[j][i];

					if (j<1) {

						left = -1;

					}

					else {

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

					}

					if (j>=5) {

						right = -1;

					}

					else {

						right = board[j+1][i];

					}

					if (i>28) {

						over = -1;

					}

					else {

						over = board[j][i+1];

					}

					if (i<1) {

						under = -1;

					}

					else {

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

					}

					if ((left == number)&&(right == number)&&(over == number)&&(under == number)) {

						DrawImgBoardBounded(garbageFill,  j*bsize, bsize*12-i*bsize-pixels);

					}

					if ((left != number)&&(right == number)&&(over == number)&&(under == number)) {

						DrawImgBoardBounded(garbageL,  j*bsize, bsize*12-i*bsize-pixels);

					}

					if ((left == number)&&(right != number)&&(over == number)&&(under == number)) {

						DrawImgBoardBounded(garbageR,  j*bsize, bsize*12-i*bsize-pixels);

					}

					if ((left == number)&&(right == number)&&(over != number)&&(under == number)) {

						DrawImgBoardBounded(garbageT,  j*bsize, bsize*12-i*bsize-pixels);

					}

					if ((left == number)&&(right == number)&&(over == number)&&(under != number)) {

						DrawImgBoardBounded(garbageB,  j*bsize, bsize*12-i*bsize-pixels);

					}

					if ((left != number)&&(right == number)&&(over != number)&&(under == number)) {

						DrawImgBoardBounded(garbageTL,  j*bsize, bsize*12-i*bsize-pixels);

					}

					if ((left != number)&&(right == number)&&(over == number)&&(under != number)) {

						DrawImgBoardBounded(garbageBL,  j*bsize, bsize*12-i*bsize-pixels);

					}

					if ((left == number)&&(right != number)&&(over != number)&&(under == number)) {

						DrawImgBoardBounded(garbageTR,  j*bsize, bsize*12-i*bsize-pixels);

					}

					if ((left == number)&&(right != number)&&(over == number)&&(under != number)) {

						DrawImgBoardBounded(garbageBR,  j*bsize, bsize*12-i*bsize-pixels);

					}

					if ((left == number)&&(right != number)&&(over != number)&&(under != number)) {

						DrawImgBoardBounded(garbageMR,  j*bsize, bsize*12-i*bsize-pixels);

					}

					if ((left == number)&&(right == number)&&(over != number)&&(under != number)) {

						DrawImgBoardBounded(garbageM,  j*bsize, bsize*12-i*bsize-pixels);

					}

					if ((left != number)&&(right == number)&&(over != number)&&(under != number)) {

						DrawImgBoardBounded(garbageML,  j*bsize, bsize*12-i*bsize-pixels);

					}

				}

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

					if (j==0) {

						DrawImgBoardBounded(garbageGML,  j*bsize, bsize*12-i*bsize-pixels);

					}

					else if (j==5) {

						DrawImgBoardBounded(garbageGMR,  j*bsize, bsize*12-i*bsize-pixels);

					}

					else {

						DrawImgBoardBounded(garbageGM,  j*bsize, bsize*12-i*bsize-pixels);

					}

				}

			}

		}

		const int j = 0;

		int garbageSize=0;

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

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

				int left, right, over, under;

				int number = board[j][i];

				if (j<1) {

					left = -1;

				}

				else {

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

				}

				if (j>5) {

					right = -1;

				}

				else {

					right = board[j+1][i];

				}

				if (i>28) {

					over = -1;

				}

				else {

					over = board[j][i+1];

				}

				if (i<1) {

					under = -1;

				}

				else {

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

				}

				if (((left != number)&&(right == number)&&(over != number)&&(under == number))&&(garbageSize>0)) {

					DrawImgBoardBounded(smiley[board[j][i]%4],  2*bsize, 12*bsize-i*bsize-pixels+(bsize/2)*garbageSize);

				}

				if (!((left != number)&&(right == number)&&(over == number)&&(under == number))) { //not in garbage

					garbageSize=0;

				}

				else {

					garbageSize++;

				}

			}

		}

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

			if (board[i][0]!=-1) {

				DrawImgBoardBounded(transCover,  i*bsize, 12*bsize-pixels);    //Make the appering blocks transperant

			}

		}

	}

public:

	//Draws everything

	void DoPaintJob() {

		DrawIMG(boardBackBack,screen,this->GetTopX()-60,this->GetTopY()-68);

		nf_scoreboard_font.draw(screen, this->GetTopX()+310,this->GetTopY()-68+148,_("Score:") );

		nf_scoreboard_font.draw(screen, this->GetTopX()+310,this->GetTopY()-68+197,_("Time:") );

		nf_scoreboard_font.draw(screen, this->GetTopX()+310,this->GetTopY()-68+246,_("Chain:") );

		nf_scoreboard_font.draw(screen, this->GetTopX()+310,this->GetTopY()-68+295,_("Speed:") );

		DrawImgBoard(backBoard,  0, 0);

		PaintBricks();

		if (stageClear) {

			DrawImgBoard(blackLine,  0, bsize*(12+2)+bsize*(stageClearLimit-linesCleared)-pixels-1);

		}

		if (puzzleMode&&(!bGameOver)) {

			//We need to write nr. of moves left!

			strHolder = _("Moves left: ") + itoa(MovesLeft);

			nf_standard_blue_font.draw(screen, topx+5, topy+5, "%s",strHolder.c_str());

		}

		if (puzzleMode && stageButtonStatus == SBpuzzleMode) {

			DrawImgBoard(bRetry, cordRetryButton.x, cordRetryButton.y);

			PrintTextCenteredBoard(cordRetryButton.x, cordRetryButton.y, _("Retry"));

			if (getLevel()<PuzzleGetNumberOfPuzzles()-1) {

				if (hasWonTheGame) {

					DrawImgBoard(bNext,cordNextButton.x, cordNextButton.y);

					PrintTextCenteredBoard(cordNextButton.x, cordNextButton.y, _("Next"));

				}

				else {

					DrawImgBoard(bSkip,cordNextButton.x, cordNextButton.y);

					PrintTextCenteredBoard(cordNextButton.x, cordNextButton.y, _("Skip"));

				}

			}

			else {

				strHolder = "Last puzzle";

				nf_standard_blue_font.draw(screen, topx+5, topy+5, "%s",strHolder.c_str());

			}

		}

		if (stageClear && stageButtonStatus == SBstageClear) {

			DrawImgBoard(bRetry, cordRetryButton.x, cordRetryButton.y);

			PrintTextCenteredBoard(cordRetryButton.x, cordRetryButton.y, _("Retry"));

			if (getLevel()<50-1) {

				if (hasWonTheGame) {

					DrawImgBoard(bNext,cordNextButton.x, cordNextButton.y);

					PrintTextCenteredBoard(cordNextButton.x, cordNextButton.y, _("Next"));

				}

				else {

					DrawImgBoard(bSkip,cordNextButton.x, cordNextButton.y);

					PrintTextCenteredBoard(cordNextButton.x, cordNextButton.y, _("Skip"));

				}

			}

			else {

				strHolder = "Last stage";

				nf_standard_blue_font.draw(screen, topx+5, topy+5, "%s",strHolder.c_str());

			}

		}

#if DEBUG

		if (AI_Enabled&&(!bGameOver)) {

			strHolder = "AI_status: " + itoa(AIstatus)+ ", "+ itoa(AIlineToClear);

			//NFont_Write(   5, 5, strHolder.c_str());

			nf_standard_blue_font.draw(screen, topx+5, topy+5, "%s",strHolder.c_str());

		}

#endif

		if (!bGameOver) {

			bool touched = false;

			int mx = 0;

			int my = 0;

			this->GetMouseCursor(touched, mx, my);

			if (touched) {

				DrawImgBoard(spriteHolder->GetSprite("touchcursor"),mx*bsize, 11*bsize-my*bsize-pixels);

			}

			else {

				DrawImgBoard(cursor,cursorx*bsize-4,11*bsize-cursory*bsize-pixels-4);

			}

		}

		if (ticks<gameStartedAt) {

			int currentCounter = abs((int)ticks-(int)gameStartedAt)/1000;

			if ( (currentCounter!=lastCounter) && (SoundEnabled)&&(!NoSound)) {

				Mix_PlayChannel(1,counterChunk,0);

			}

			lastCounter = currentCounter;

			switch (currentCounter) {

			case 2:

				DrawImgBoard(counter[2],  2*bsize, 5*bsize);

				break;

			case 1:

				DrawImgBoard(counter[1],  2*bsize, 5*bsize);

				break;

			case 0:

				DrawImgBoard(counter[0],  2*bsize, 5*bsize);

				break;

			default:

				break;

			}

		}

		else {

			if (SoundEnabled&&(!NoSound)&&(timetrial)&&(ticks>gameStartedAt+10000)&&(!bGameOver)) {

				int currentCounter = (ticks-(int)gameStartedAt)/1000;

				if (currentCounter!=lastCounter) {

					if (currentCounter>115 && currentCounter<120) {

						Mix_PlayChannel(1,counterChunk,0);

					}

				}

				lastCounter = currentCounter;