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://blockattack.sf.net

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

*/

#include "common.h"

#include "global.hpp"

#include "scopeHelpers.hpp"

#include <string.h>

#ifndef VERSION_NUMBER

#define VERSION_NUMBER "version 1.5.0 BETA"

#endif

//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 "physfs_stream.hpp" //To use C++ style file streams

#include "Libs/NFont.h"

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

//#include "config.h"

#include <vector>

#include <SDL/SDL_timer.h>

#include <SDL/SDL_video.h>

#include <SDL/SDL_ttf.h>

#include "CppSdlImageHolder.hpp"

#include "MenuSystem.h"

#include "puzzlehandler.hpp"

#include <memory>

//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 "joypad.h"         //Used for joypads

#include "listFiles.h"      //Used to show files on screen

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

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

#include "common.h"

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

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

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

#include "mainVars.hpp"

using namespace std;

static void UnloadImages();

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

static string oldThemePath = "default";

static bool loaded = false;

void loadTheme(sago::SagoSpriteHolder& holder, const string& themeName) {

	if (loaded) {

		UnloadImages();

	}

#if defined(__unix__)

	string home = (string)getenv("HOME")+(string)"/.gamesaves/blockattack";

#elif defined(_WIN32)

	string home = (string)getMyDocumentsPath()+(string)"/My Games/blockattack";

#endif

	//Remove old theme

	PHYSFS_removeFromSearchPath(oldThemePath.c_str());

	//Look in blockattack.data

	PHYSFS_addToSearchPath(((string)SHAREDIR+"/blockattack.data").c_str(), 1);

	//Look in folder

	PHYSFS_addToSearchPath( ((string) PHYSFS_getBaseDir()+"/data").c_str(), 1);

	//Look in home folder

#if defined(__unix__) || defined(_WIN32)

	PHYSFS_addToSearchPath(home.c_str(), 1);

#endif

	if (themeName == Config::getInstance()->getString("themename")) {

		//If this is a theme different from the saved one. Remember it!

		Config::getInstance()->setString("themename", themeName);

	}

	if (themeName.compare("default")==0 || (themeName.compare("start")==0)) {

		InitImages(holder);

		loaded =true;

		return; //Nothing more to do

	}

	oldThemePath = "themes/"+themeName;

	PHYSFS_addToSearchPath(oldThemePath.c_str(),0);

#if defined(__unix__) || defined(_WIN32)

	PHYSFS_addToSearchPath((home+(string)"/"+oldThemePath).c_str(), 0);

#endif

	InitImages(holder);

	loaded = true;

}

Mix_Music* Mix_LoadMUS2(string path) {

	if (!PHYSFS_exists(path.c_str())) {

		cerr << "Warning: File not in blockattack.data: " << path << endl;

		return nullptr; //file doesn't exist

	}

	PHYSFS_file* myfile = PHYSFS_openRead(path.c_str());

	// Get the lenght of the file

	unsigned int m_size = PHYSFS_fileLength(myfile);

	// Get the file data.

	char* m_data = new char[m_size];

	int length_read = PHYSFS_read (myfile, m_data, 1, m_size);

	if (length_read != (int)m_size) {

		delete [] m_data;

		m_data = 0;

		PHYSFS_close(myfile);

		cerr << "Error: Curropt data file!" << endl;

		return nullptr;

	}

	PHYSFS_close(myfile);

// And this is how you load from a memory buffer with SDL

	SDL_RWops* rw = SDL_RWFromMem (m_data, m_size);

	//The above might fail an return null.

	if (!rw) {

		delete [] m_data;

		m_data = 0;

		PHYSFS_close(myfile);

		cerr << "Error: Curropt data file!" << endl;

		return nullptr;

	}

	Mix_Music* ret = Mix_LoadMUS_RW(rw, SDL_TRUE);

	return ret;

}

Mix_Chunk* Mix_LoadWAV2(const char* path) {

	if (!PHYSFS_exists(path)) {

		cerr << "Warning: File not in blockattack.data: " << path << endl;

		return nullptr; //file doesn't exist

	}

	PHYSFS_file* myfile = PHYSFS_openRead(path);

	// Get the lenght of the file

	unsigned int m_size = PHYSFS_fileLength(myfile);

	// Get the file data.

	char* m_data = new char[m_size];

	int length_read = PHYSFS_read (myfile, m_data, 1, m_size);

	if (length_read != (int)m_size) {

		delete [] m_data;

		m_data = 0;

		PHYSFS_close(myfile);

		cerr << "Error: Curropt data file!" << endl;

		return nullptr;

	}

	PHYSFS_close(myfile);

// And this is how you load from a memory buffer with SDL

	SDL_RWops* rw = SDL_RWFromMem (m_data, m_size);

	//The above might fail an return null.

	if (!rw) {

		delete [] m_data;

		m_data = 0;

		PHYSFS_close(myfile);

		cerr << "Error: Curropt data file!" << endl;

		return nullptr;

	}

	Mix_Chunk* ret = Mix_LoadWAV_RW(rw,true); //the second argument tells the function to three RWops

	return ret;

}

//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_back");

	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[2] = holder.GetSprite("explosion1");

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

	explosion[4] = 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");

	bSkip = holder.GetSprite("b_skip");

	bNext = holder.GetSprite("b_next");

	bRetry = holder.GetSprite("b_retry");

	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_standard_blue_color.b = 255;

	nf_standard_blue_color.g = 0;

	nf_standard_blue_color.r = 0;

	nf_standard_small_color.b = 0;

	nf_standard_small_color.g = 0;

	nf_standard_small_color.r = 200;

	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 = Mix_LoadMUS2("music/bgMusic.ogg");

		highbeatMusic = Mix_LoadMUS2("music/highbeat.ogg");

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

		//Same goes for the sounds

		boing = Mix_LoadWAV2("sound/pop.ogg");

		applause = Mix_LoadWAV2("sound/applause.ogg");

		photoClick = Mix_LoadWAV2("sound/cameraclick.ogg");

		typingChunk = Mix_LoadWAV2("sound/typing.ogg");

		counterChunk = Mix_LoadWAV2("sound/counter.ogg");

		counterFinalChunk = Mix_LoadWAV2("sound/counterFinal.ogg");

	} //All sound has been loaded or not

	return 0;

} //InitImages()

//Unload images and fonts and sounds

void UnloadImages() {

	if (verboseLevel) {

		cout << "Unloading data..." << endl;

	}

}

static stringstream converter;

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

static string itoa2(int num) {

	converter.str(std::string());

	converter.clear();

	if (num<10) {

		converter << "0";

	}

	converter << num;

	return converter.str();

}

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

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

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

}

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

}

/*Draws a part of an image on a surface of choice*/

/*void DrawIMG(sago::SagoSprite &sprite, Renderer* target, int x, int y, int w, int h, int x2, int y2) {

	SDL_Rect dest;

	dest.x = x;

	dest.y = y;

	SDL_Rect dest2;

	dest2.x = x2;

	dest2.y = y2;

	dest2.w = w;

	dest2.h = h;

	sprite.Draw()

}*/

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

}

void ResetFullscreen() {

#if defined(WIN32)

	if (bFullscreen) {

		screen=SDL_SetVideoMode(xsize,ysize,32,SDL_SWSURFACE|SDL_FULLSCREEN|SDL_ANYFORMAT);

	}

	else {

		screen=SDL_SetVideoMode(xsize,ysize,32,SDL_SWSURFACE|SDL_ANYFORMAT);

	}

	DrawIMG(background, screen, 0, 0);

#else

	//TODO: Find SDL2 alternative

	//SDL_WM_ToggleFullScreen(screen); //Will only work in Linux

#endif

	SDL_ShowCursor(SDL_DISABLE);

}

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

class aBall {

private:

	double x;

	double y;

	double velocityY;

	double velocityX;

	int color;

	unsigned long int lastTime;

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

public:

	aBall ballArray[maxNumberOfBalls];

	bool ballUsed[maxNumberOfBalls];

	ballManeger() {

		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 ((ballUsed[ballNumber])&&(ballNumber<maxNumberOfBalls)) {

			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

}; //theBallManeger

static ballManeger theBallManeger;

//a explosions, non moving

class anExplosion {

private:

	int x;

	int y;

	Uint8 frameNumber;

#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; //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 explosionManeger {

public:

	anExplosion explosionArray[maxNumberOfBalls];

	bool explosionUsed[maxNumberOfBalls];

	explosionManeger() {

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

			explosionUsed[i] = false;

		}

	}

	int addExplosion(int x, int y) {

		int explosionNumber = 0;

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

			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

}; //explosionManeger

static explosionManeger theExplosionManeger;

//text pop-up

class textMessage {

private:

	int x;

	int y;

	string textt;

	unsigned long int time;

	unsigned long int placeTime; //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 textManeger {

public:

	textMessage textArray[maxNumberOfBalls];

	bool textUsed[maxNumberOfBalls];

	textManeger() {

		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

}; //textManeger

static textManeger theTextManeger;

//Here comes the Block Game object

#include "BlockGame.hpp"

#include "BlockGame.cpp"

class BlockGameSdl : public BlockGame {

public:

	BlockGameSdl(int tx, int ty) {

		topx = tx;

		topy = ty;

	}

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

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

	}

	void DrawImgBoardBounded(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;

	}

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

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

	}

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

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

	}

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

		theExplosionManeger.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++) {

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

					DrawImgBoardBounded(bricks[board[j][i]%10],  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++;

				}

			}