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

#ifndef VERSION_NUMBER

#define VERSION_NUMBER "version 1.4.2 BETA"

#endif

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

#ifndef DEBUG

#define DEBUG 0

#endif

//If NETWORK id defined: enet will be used

#ifndef NETWORK

#define NETWORK 1

#endif

//Build-in level editor is still experimental!

#ifndef LEVELEDITOR

#define LEVELEDITOR 0

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

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

//enet things

#if NETWORK

#include "enet/enet.h"

#endif

//enet things end

//#include "SFont.h"          //Used to write on screen

#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 "replay.h"			//Used for replays

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

#if LEVELEDITOR

#include "editor/editorMain.hpp" //The level editor

#endif

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

static void MakeBackground(int,int);

void closeAllMenus()

{

	bNewGameOpen=false;          //show sub menues

	bOptionsOpen=false;          //Show OptionsMenu (Configure and Select Puzzle)

	b1playerOpen=false;			//show submenu

	b2playersOpen=false;

	bReplayOpen = false;

#if NETWORK

	bNetworkOpen = false;

#endif

	showOptions = false;

}

SDL_Surface * IMG_Load2(string path)

{

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

	{

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

		return NULL; //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);

		cout << "Error. Curropt data file!" << endl;

		return NULL;

	}

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

		cout << "Error. Curropt data file!" << endl;

		return NULL;

	}

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

	return surface;

}

CppSdl::CppSdlImageHolder IMG_Load3(string path)

{

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

	{

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

		cout << "Error. Curropt data file!" << endl;

		throw exception();

	}

	PHYSFS_close(myfile);

	CppSdl::CppSdlImageHolder surface(m_data, m_size);

	return surface;

}

static void UnloadImages();

static int InitImages();

static string oldThemePath = "default";

static bool loaded = false;

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

	//Look in home folder

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

	PHYSFS_addToSearchPath(home.c_str(), 1);

#endif

	if(themeName.compare(Config::getInstance()->getString("themename"))!=0)

	{

		//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, string path,int ptsize, SDL_Color color, int style=TTF_STYLE_NORMAL)

{

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

	{

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

		return -1; //file doesn't exist

	}

	if(!(TTF_WasInit()))

		TTF_Init();

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

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

		cout << "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()))

	{

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

		return NULL; //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);

		cout << "Error. Curropt data file!" << endl;

		return NULL;

	}

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

		cout << "Error. Curropt data file!" << endl;

		return NULL;

	}

	Mix_Music* ret = Mix_LoadMUS_RW(rw);

	return ret;

}

Mix_Chunk * Mix_LoadWAV2(char* path)

{

	if (!PHYSFS_exists(path))

	{

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

		return NULL; //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);

		cout << "Error. Curropt data file!" << endl;

		return NULL;

	}

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

		cout << "Error. Curropt data file!" << endl;

		return NULL;

	}

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

			&& (background = IMG_Load2("gfx/blackBackGround.png"))

//            && (b1player = IMG_Load2("gfx/bOnePlayer.png"))

//            && (b2players = IMG_Load2("gfx/bTwoPlayers.png"))

//            && (bVsMode = IMG_Load2("gfx/bVsGame.png"))

//            && (bVsModeConfig = IMG_Load2("gfx/bVsGameConfig.png"))

//            && (bPuzzle = IMG_Load2((char*)"gfx/bPuzzle.png"))

//            && (bStageClear = IMG_Load2((char*)"gfx/bStageClear.png"))

//            && (bTimeTrial = IMG_Load2((char*)"gfx/bTimeTrial.png"))

			//&& (bEndless = IMG_Load2((char*)"gfx/bEndless.png"))

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

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

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

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

//            && (bExit = IMG_Load2((char*)"gfx/bExit.png"))

			&& (bBack = IMG_Load2((char*)"gfx/bBack.png"))

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

//            && (bReplay = IMG_Load2((char*)"gfx/bReplays.png"))

//            && (bSave = IMG_Load2((char*)"gfx/bSave.png"))

//            && (bLoad = IMG_Load2((char*)"gfx/bLoad.png"))

			/*#if NETWORK

			            && (bNetwork = IMG_Load2((char*)"gfx/bNetwork.png"))

			            && (bHost = IMG_Load2((char*)"gfx/bHost.png"))

			            && (bConnect = IMG_Load2((char*)"gfx/bConnect.png"))

			#endif*/

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

			//new in 1.3.2

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

#if LEVELEDITOR

			&& (bCreateFile = IMG_Load2((char*)"gfx/editor/bCreateFile.png"))

			&& (bDeletePuzzle = IMG_Load2((char*)"gfx/editor/bDeletePuzzle.png"))

			&& (bLoadFile = IMG_Load2((char*)"gfx/editor/bLoadFile.png"))

			&& (bMoveBack = IMG_Load2((char*)"gfx/editor/bMoveBack.png"))

			&& (bMoveDown = IMG_Load2((char*)"gfx/editor/bMoveDown.png"))

			&& (bMoveForward = IMG_Load2((char*)"gfx/editor/bMoveForward.png"))

			&& (bMoveLeft = IMG_Load2((char*)"gfx/editor/bMoveLeft.png"))

			&& (bMoveRight = IMG_Load2((char*)"gfx/editor/bMoveRight.png"))

			&& (bMoveUp = IMG_Load2((char*)"gfx/editor/bMoveUp.png"))

			&& (bNewPuzzle = IMG_Load2((char*)"gfx/editor/bNewPuzzle.png"))

			&& (bSaveFileAs = IMG_Load2((char*)"gfx/editor/bSaveFileAs.png"))

			&& (bSavePuzzle = IMG_Load2((char*)"gfx/editor/bSavePuzzle.png"))

			&& (bSaveToFile = IMG_Load2((char*)"gfx/editor/bSaveToFile.png"))

			&& (bTestPuzzle = IMG_Load2((char*)"gfx/editor/bTestPuzzle.png"))

#endif

			//end new in 1.3.2

			//new in 1.4.0

			&& (bTheme = IMG_Load2((char*)"gfx/bTheme.png"))

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

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

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

		 ))

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

	{

		cout << "Error loading 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)

	{

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

		exit(1);

	}

	//Prepare for fast blittering!

	CONVERT(background);

	CONVERT(backgroundImage);

//    CONVERT(b1player);

//    CONVERT(b2players);

//    CONVERT(bVsMode);

//    CONVERT(bVsModeConfig);

//    CONVERT(bPuzzle);

//    CONVERT(bStageClear);

//    CONVERT(bTimeTrial);

	//CONVERT(bEndless);

	CONVERT(bOptions);

	CONVERTA(bConfigure);

	CONVERTA(bSelectPuzzle);

//    CONVERTA(bReplay);

//    CONVERTA(bSave);

//    CONVERTA(bLoad);

	CONVERTA(bTheme);

	CONVERTA(bSkip);

	CONVERTA(bRetry);

	CONVERTA(bNext);

	/*#if NETWORK

	    CONVERTA(bNetwork);

	    CONVERTA(bHost);

	    CONVERTA(bConnect);

	#endif*/

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

//    CONVERTA(optionsBack);

//    CONVERT(bExit);

	CONVERT(bOn);

	CONVERT(bOff);

//    CONVERT(bChange);

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

	//Editor:

#if LEVELEDITOR

	CONVERTA(bCreateFile);

	CONVERTA(bDeletePuzzle);

	CONVERTA(bLoadFile);

	CONVERTA(bMoveBack);

	CONVERTA(bMoveDown);

	CONVERTA(bMoveForward);

	CONVERTA(bMoveLeft);

	CONVERTA(bMoveRight);

	CONVERTA(bMoveUp);

	CONVERTA(bNewPuzzle);

	CONVERTA(bSaveFileAs);

	CONVERTA(bSavePuzzle);

	CONVERTA(bSaveToFile);

	CONVERTA(bTestPuzzle);

#endif

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

//Loads the sound if sound present

	if (!NoSound)

	{

		//And here the music:

		bgMusic = Mix_LoadMUS2((char*)"music/bgMusic.ogg");

		highbeatMusic = Mix_LoadMUS2((char*)"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((char*)"sound/pop.ogg");

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

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

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

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

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

	} //All sound has been loaded or not

	return 0;

} //InitImages()

//Unload images and fonts and sounds

void UnloadImages()

{

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

	//SDL_FreeSurface(bNewGame);

//    SDL_FreeSurface(b1player);

//    SDL_FreeSurface(b2players);

//    SDL_FreeSurface(bVsMode);

//    SDL_FreeSurface(bVsModeConfig);

//    SDL_FreeSurface(bPuzzle);

//    SDL_FreeSurface(bStageClear);

//    SDL_FreeSurface(bTimeTrial);

	//SDL_FreeSurface(bEndless);

	SDL_FreeSurface(bOptions);

	SDL_FreeSurface(bConfigure);

	SDL_FreeSurface(bSelectPuzzle);

	SDL_FreeSurface(bHighScore);

//    SDL_FreeSurface(bReplay);

//    SDL_FreeSurface(bSave);

//    SDL_FreeSurface(bLoad);

	/*    #if NETWORK

	    SDL_FreeSurface(bNetwork);

	    SDL_FreeSurface(bHost);

	    SDL_FreeSurface(bConnect);

	    #endif

	    SDL_FreeSurface(bExit);*/

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

	SDL_FreeSurface(bOn);

	SDL_FreeSurface(bOff);

//    SDL_FreeSurface(bChange);

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

}

//Function to convert numbers to string

/*string itoa(int num)

{

    stringstream converter;

    converter << num;

    return converter.str();

}*/

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

}

/*Loads all the puzzle levels*/

static int LoadPuzzleStages()

{

	//if(puzzleLoaded)

	//    return 1;

	if (!PHYSFS_exists(("puzzles/"+puzzleName).c_str()))

	{

		cout << "File not in blockattack.data: " << ("puzzles/"+puzzleName) << endl;

		return -1; //file doesn't exist

	}

	PhysFS::ifstream inFile(("puzzles/"+puzzleName).c_str());

	inFile >> nrOfPuzzles;

	if (nrOfPuzzles>maxNrOfPuzzleStages)

		nrOfPuzzles=maxNrOfPuzzleStages;

	for (int k=0; (k<nrOfPuzzles) /*&&(!inFile.eof())*/ ; k++)

	{

		inFile >> nrOfMovesAllowed[k];

		for (int i=11; i>=0; i--)

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

			{

				inFile >> puzzleLevels[k][j][i];

			}

	}

	puzzleLoaded = true;

	return 0;

}

/*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, NULL, 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,string text)

{

	nf_standard_blue_font.setDest(target);

	nf_standard_blue_font.draw(x,y,text.c_str());

	nf_standard_blue_font.setDest(screen);

}

void ResetFullscreen()