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

//Macros to convert surfaces (ffor faster drawing)

#define CONVERT(n) tmp = SDL_DisplayFormat(n); SDL_FreeSurface(n); n = tmp

#define CONVERTA(n) tmp = SDL_DisplayFormatAlpha(n); SDL_FreeSurface(n); n = tmp

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

SDL_Surface* IMG_Load2(const char* path) {

	if (!PHYSFS_exists(path)) {

		cerr << "Error: 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 an image 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;

	}

	SDL_Surface* surface = IMG_Load_RW(rw,true); //the second argument tells the function to three RWops

	return surface;

}

shared_ptr<CppSdl::CppSdlImageHolder> IMG_Load3(string path) {

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

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

		throw exception();

	}

	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;

		throw exception();

	}

	PHYSFS_close(myfile);

	shared_ptr<CppSdl::CppSdlImageHolder> surface(new CppSdl::CppSdlImageHolder(m_data, m_size));

	return surface;

}

static void UnloadImages();

static int InitImages();

static string oldThemePath = "default";

static bool loaded = false;

void loadTheme(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(PHYSFS_getBaseDir(), 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();

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

	loaded = true;

}

long NFont_OpenFont(NFont* target, const char* path,int ptsize, SDL_Color color, int style=TTF_STYLE_NORMAL) {

	if (!PHYSFS_exists(path)) {

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

		return -1; //file doesn't exist

	}

	if (!(TTF_WasInit())) {

		TTF_Init();

	}

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

	}

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

	}

	TTF_Font* font;

	font=TTF_OpenFontRW(rw, 1, ptsize);

	TTF_SetFontStyle(font,style);

	target->load(font,color);

	TTF_CloseFont(font); //Once loaded we don't care anymore!

	return 0;

}

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

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

	if (!((backgroundImage = IMG_Load2("gfx/background.png"))

	        && (bOptions = IMG_Load2("gfx/bOptions.png"))

	        && (bConfigure = IMG_Load2("gfx/bConfigure.png"))

	        && (bSelectPuzzle = IMG_Load2("gfx/bSelectPuzzle.png"))

	        && (bHighScore = IMG_Load2("gfx/bHighScore.png"))

	        && (bBack = IMG_Load2("gfx/bBlank.png"))

	        && (bForward = IMG_Load2("gfx/bForward.png"))

	        && (blackLine = IMG_Load2("gfx/blackLine.png"))

	        && (stageBobble = IMG_Load2("gfx/iStageClearLimit.png"))

	        && (bricks[0] = IMG_Load2("gfx/bricks/blue.png"))

	        && (bricks[1] = IMG_Load2("gfx/bricks/green.png"))

	        && (bricks[2] = IMG_Load2("gfx/bricks/purple.png"))

	        && (bricks[3] = IMG_Load2("gfx/bricks/red.png"))

	        && (bricks[4] = IMG_Load2("gfx/bricks/turkish.png"))

	        && (bricks[5] = IMG_Load2("gfx/bricks/yellow.png"))

	        && (bricks[6] = IMG_Load2("gfx/bricks/grey.png"))

	        && (crossover = IMG_Load2("gfx/crossover.png"))

	        && (balls[0] = IMG_Load2("gfx/balls/ballBlue.png"))

	        && (balls[1] = IMG_Load2("gfx/balls/ballGreen.png"))

	        && (balls[2] = IMG_Load2("gfx/balls/ballPurple.png"))

	        && (balls[3] = IMG_Load2("gfx/balls/ballRed.png"))

	        && (balls[4] = IMG_Load2("gfx/balls/ballTurkish.png"))

	        && (balls[5] = IMG_Load2("gfx/balls/ballYellow.png"))

	        && (balls[6] = IMG_Load2("gfx/balls/ballGray.png"))

	        && (cursor[0] = IMG_Load2("gfx/animations/cursor/1.png"))

	        && (cursor[1] = IMG_Load2("gfx/animations/cursor/2.png"))

	        && (bomb[0] = IMG_Load2("gfx/animations/bomb/bomb_1.png"))

	        && (bomb[1] = IMG_Load2("gfx/animations/bomb/bomb_2.png"))

	        && (ready[0] = IMG_Load2("gfx/animations/ready/ready_1.png"))

	        && (ready[1] = IMG_Load2("gfx/animations/ready/ready_2.png"))

	        && (explosion[0] = IMG_Load2("gfx/animations/explosion/0.png"))

	        && (explosion[1] = IMG_Load2("gfx/animations/explosion/1.png"))

	        && (explosion[2] = IMG_Load2("gfx/animations/explosion/2.png"))

	        && (explosion[3] = IMG_Load2("gfx/animations/explosion/3.png"))

	        && (counter[0] = IMG_Load2("gfx/counter/1.png"))

	        && (counter[1] = IMG_Load2("gfx/counter/2.png"))

	        && (counter[2] = IMG_Load2("gfx/counter/3.png"))

	        && (backBoard = IMG_Load2("gfx/BackBoard.png")) //not used, we just test if it exists :)

	        && (iGameOver = IMG_Load2("gfx/iGameOver.png"))

	        && (iWinner = IMG_Load2("gfx/iWinner.png"))

	        && (iDraw = IMG_Load2("gfx/iDraw.png"))

	        && (iLoser = IMG_Load2("gfx/iLoser.png"))

	        && (iChainBack = IMG_Load2("gfx/chainFrame.png"))

//            && (optionsBack = IMG_Load2("gfx/options.png"))

	        && (bOn = IMG_Load2("gfx/bOn.png"))

	        && (bOff = IMG_Load2("gfx/bOff.png"))

//            && (bChange = IMG_Load2("gfx/bChange.png"))

	        && (b1024 = IMG_Load2("gfx/b1024.png"))

	        && (dialogBox = IMG_Load2("gfx/dialogbox.png"))

//	&& (fileDialogBox = IMG_Load2("gfx/fileDialogbox.png"))

	        && (iLevelCheck = IMG_Load2("gfx/iLevelCheck.png"))

	        && (iLevelCheckBox = IMG_Load2("gfx/iLevelCheckBox.png"))

	        && (iLevelCheckBoxMarked = IMG_Load2("gfx/iLevelCheckBoxMarked.png"))

	        && (iCheckBoxArea = IMG_Load2("gfx/iCheckBoxArea.png"))

	        && (boardBackBack = IMG_Load2("gfx/boardBackBack.png"))

	        && (changeButtonsBack = IMG_Load2("gfx/changeButtonsBack.png"))

	        && (garbageTL = IMG_Load2("gfx/garbage/garbageTL.png"))

	        && (garbageT = IMG_Load2("gfx/garbage/garbageT.png"))

	        && (garbageTR = IMG_Load2("gfx/garbage/garbageTR.png"))

	        && (garbageR = IMG_Load2("gfx/garbage/garbageR.png"))

	        && (garbageBR = IMG_Load2("gfx/garbage/garbageBR.png"))

	        && (garbageB = IMG_Load2("gfx/garbage/garbageB.png"))

	        && (garbageBL = IMG_Load2("gfx/garbage/garbageBL.png"))

	        && (garbageL = IMG_Load2("gfx/garbage/garbageL.png"))

	        && (garbageFill = IMG_Load2("gfx/garbage/garbageFill.png"))

	        && (garbageML = IMG_Load2("gfx/garbage/garbageML.png"))

	        && (garbageM = IMG_Load2("gfx/garbage/garbageM.png"))

	        && (garbageMR = IMG_Load2("gfx/garbage/garbageMR.png"))

	        && (garbageGM = IMG_Load2("gfx/garbage/garbageGM.png"))

	        && (garbageGML = IMG_Load2("gfx/garbage/garbageGML.png"))

	        && (garbageGMR = IMG_Load2("gfx/garbage/garbageGMR.png"))

	        && (smiley[0] = IMG_Load2("gfx/smileys/0.png"))

	        && (smiley[1] = IMG_Load2("gfx/smileys/1.png"))

	        && (smiley[2] = IMG_Load2("gfx/smileys/2.png"))

	        && (smiley[3] = IMG_Load2("gfx/smileys/3.png"))

	        //new in 1.3.2

	        && (transCover = IMG_Load2("gfx/transCover.png"))

	        //end new in 1.3.2

	        //new in 1.4.0

	        && (bSkip = IMG_Load2("gfx/bBlank.png"))

	        && (bNext = IMG_Load2("gfx/bBlank.png"))

	        && (bRetry = IMG_Load2("gfx/bBlank.png"))

	     ))

		//if there was a problem ie. "File not found"

	{

		cerr << "Error: Failed to load image file: " << SDL_GetError() << endl;

		exit(1);

	}

	try {

		bNewGame = IMG_Load3("gfx/bNewGame.png");

		mouse = IMG_Load3("gfx/mouse.png");

		menuMarked = IMG_Load3("gfx/menu/marked.png");

		menuUnmarked = IMG_Load3("gfx/menu/unmarked.png");

	}

	catch (exception& e) {

		cerr << e.what() << endl;

		exit(1);

	}

	//Prepare for fast blittering!

	CONVERT(backgroundImage);

	CONVERT(bOptions);

	CONVERTA(bConfigure);

	CONVERTA(bSelectPuzzle);

	CONVERTA(bSkip);

	CONVERTA(bRetry);

	CONVERTA(bNext);

	CONVERT(bHighScore);

	CONVERTA(boardBackBack);

	CONVERT(backBoard);

	CONVERT(blackLine);

	CONVERTA(changeButtonsBack);

	CONVERTA(cursor[0]);

	CONVERTA(cursor[1]);

	CONVERTA(counter[0]);

	CONVERTA(counter[1]);

	CONVERTA(counter[2]);

	CONVERT(bOn);

	CONVERT(bOff);

	CONVERT(b1024);

	CONVERTA(dialogBox);

//	CONVERTA(fileDialogBox);

	CONVERTA(iLevelCheck);

	CONVERT(iLevelCheckBox);

	CONVERT(iLevelCheckBoxMarked);

	CONVERTA(iCheckBoxArea);

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

		CONVERTA(explosion[i]);

	}

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

		CONVERTA(bricks[i]);

		CONVERTA(balls[i]);

	}

	CONVERTA(crossover);

	CONVERTA(garbageTL);

	CONVERTA(garbageT);

	CONVERTA(garbageTR);

	CONVERTA(garbageR);

	CONVERTA(garbageBR);

	CONVERTA(garbageB);

	CONVERTA(garbageBL);

	CONVERTA(garbageL);

	CONVERTA(garbageFill);

	CONVERTA(garbageML);

	CONVERTA(garbageMR);

	CONVERTA(garbageM);

	CONVERTA(garbageGML);

	CONVERTA(garbageGMR);

	CONVERTA(garbageGM);

	CONVERTA(smiley[0]);

	CONVERTA(smiley[1]);

	CONVERTA(smiley[2]);

	CONVERTA(smiley[3]);

	CONVERTA(iWinner);

	CONVERTA(iDraw);

	CONVERTA(iLoser);

	CONVERTA(iChainBack);

	CONVERTA(iGameOver);

	mouse->OptimizeForBlit(true);

	bNewGame->OptimizeForBlit(true);

	CONVERTA(stageBobble);

	CONVERTA(transCover);

	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;

	NFont_OpenFont(&nf_button_font,"fonts/FreeSerif.ttf",24,nf_button_color);

	nf_button_font.setDest(screen);

	NFont_OpenFont(&nf_standard_blue_font,"fonts/FreeSerif.ttf",30,nf_standard_blue_color);

	nf_standard_blue_font.setDest(screen);

	NFont_OpenFont(&nf_standard_small_font,"fonts/FreeSerif.ttf",16,nf_standard_small_color);

	nf_standard_small_font.setDest(screen);

	NFont_OpenFont(&nf_scoreboard_font,"fonts/PenguinAttack.ttf",20,nf_button_color);

	nf_scoreboard_font.setDest(boardBackBack);

	nf_scoreboard_font.draw(370,148,_("Score:") );

	nf_scoreboard_font.draw(370,197,_("Time:") );

	nf_scoreboard_font.draw(370,246,_("Chain:") );

	nf_scoreboard_font.draw(370,295,_("Speed:") );

	nf_button_font.setDest(bRetry);

	nf_button_font.drawCenter(60,10,_("Retry"));

	nf_button_font.setDest(bNext);

	nf_button_font.drawCenter(60,10,_("Next"));

	nf_button_font.setDest(bSkip);

	nf_button_font.drawCenter(60,10,_("Skip"));

	nf_button_font.setDest(bBack);

	nf_button_font.drawCenter(60,10,_("Back"));

	nf_button_font.setDest(screen);

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

	}

	if (!NoSound) { //Only unload then it has been loaded!

		Mix_HaltMusic();

		Mix_FreeMusic(bgMusic);

		Mix_FreeMusic(highbeatMusic);

		Mix_FreeChunk(boing);

		Mix_FreeChunk(applause);

		Mix_FreeChunk(photoClick);

		Mix_FreeChunk(counterChunk);

		Mix_FreeChunk(counterFinalChunk);

		Mix_FreeChunk(typingChunk);

	}

	//Free surfaces:

	//I think this will crash, at least it happend to me...

	//Chrashes no more. Caused by an undocumented double free

	SDL_FreeSurface(backgroundImage);

	SDL_FreeSurface(bOptions);

	SDL_FreeSurface(bConfigure);

	SDL_FreeSurface(bSelectPuzzle);

	SDL_FreeSurface(bHighScore);

	SDL_FreeSurface(blackLine);

	SDL_FreeSurface(stageBobble);

	SDL_FreeSurface(bricks[0]);

	SDL_FreeSurface(bricks[1]);

	SDL_FreeSurface(bricks[2]);

	SDL_FreeSurface(bricks[3]);

	SDL_FreeSurface(bricks[4]);

	SDL_FreeSurface(bricks[5]);

	SDL_FreeSurface(bricks[6]);

	SDL_FreeSurface(crossover);

	SDL_FreeSurface(balls[0]);

	SDL_FreeSurface(balls[1]);

	SDL_FreeSurface(balls[2]);

	SDL_FreeSurface(balls[3]);

	SDL_FreeSurface(balls[4]);

	SDL_FreeSurface(balls[5]);

	SDL_FreeSurface(balls[6]);

	SDL_FreeSurface(cursor[0]);

	SDL_FreeSurface(cursor[1]);

	SDL_FreeSurface(backBoard); //not used, we just test if it exists :)

	SDL_FreeSurface(iGameOver);

	SDL_FreeSurface(iWinner);

	SDL_FreeSurface(iDraw);

	SDL_FreeSurface(iLoser);

	SDL_FreeSurface(iChainBack);

	SDL_FreeSurface(bOn);

	SDL_FreeSurface(bOff);

	SDL_FreeSurface(b1024);

	SDL_FreeSurface(dialogBox);

	//SDL_FreeSurface(fileDialogBox);

	SDL_FreeSurface(iLevelCheck);

	SDL_FreeSurface(iLevelCheckBox);

	SDL_FreeSurface(iLevelCheckBoxMarked);

	SDL_FreeSurface(iCheckBoxArea);

	SDL_FreeSurface(boardBackBack);

	SDL_FreeSurface(changeButtonsBack);

	SDL_FreeSurface(garbageTL);

	SDL_FreeSurface(garbageT);

	SDL_FreeSurface(garbageTR);

	SDL_FreeSurface(garbageR);

	SDL_FreeSurface(garbageBR);

	SDL_FreeSurface(garbageB);

	SDL_FreeSurface(garbageBL);

	SDL_FreeSurface(garbageL);

	SDL_FreeSurface(garbageFill);

	SDL_FreeSurface(garbageML);

	SDL_FreeSurface(garbageM);

	SDL_FreeSurface(garbageMR);

	SDL_FreeSurface(garbageGML);

	SDL_FreeSurface(garbageGM);

	SDL_FreeSurface(garbageGMR);

	SDL_FreeSurface(smiley[0]);

	SDL_FreeSurface(smiley[1]);

	SDL_FreeSurface(smiley[2]);

	SDL_FreeSurface(smiley[3]);

	SDL_FreeSurface(transCover);

	mouse->MakeNull();

	bNewGame->MakeNull();

}

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(SDL_Surface* img, SDL_Surface* target, int x, int y) {

	SDL_Rect dest;

	dest.x = x;

	dest.y = y;

	SDL_BlitSurface(img, nullptr, target, &dest);

}

void DrawIMG_Bounded(SDL_Surface* img, SDL_Surface* target, int x, int y, int minx, int miny, int maxx, int maxy) {

	SDL_Rect dest;

	dest.x = x;

	dest.y = y;

	if (dest.x >= minx && dest.y >= miny && dest.x + img->w <= maxx && dest.y + img->h <= maxy) {

		SDL_BlitSurface(img, nullptr, target, &dest);

		return;

	}

	SDL_Rect dest2;

	dest2.x = 0;

	dest2.y = 0;

	dest2.w = img->w;

	dest2.h = img->h;

	if (dest.x < minx) {

		dest2.x += minx-dest.x;

		dest.x = minx;

	}

	if (dest.y < miny) {

		dest2.y += miny-dest.y;

		dest.y = miny;

	}

	if (dest.y+dest2.h > maxy) {

		dest2.h -= (dest.y+dest2.h - maxy);

	}

	if (dest.x+dest2.w > maxx) {

		dest2.w -= (dest.x+dest2.w - maxx);

	}

	SDL_BlitSurface(img, &dest2, target, &dest);

}

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

void DrawIMG(SDL_Surface* img, SDL_Surface* 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;

	SDL_BlitSurface(img, &dest2, target, &dest);

}

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

	nf_standard_blue_font.setDest(target);

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

	nf_standard_blue_font.setDest(screen);

}

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

	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;

	}