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

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

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

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

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

SDL_Surface * IMG_Load2(const char* path)

{

	if (!PHYSFS_exists(path))

	{

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

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

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

	{

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

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

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

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

		return NULL;

	}

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

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

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

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

#if LEVELEDITOR

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

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

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

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

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

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

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

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

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

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

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

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

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

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

#endif

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

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

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

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

}

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

}

/*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()

{

#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

	//Deconstructor

	~aBall()

	{

	}   //Deconstructor

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

	//The old ball information is also saved so balls can be deleted!

	aBall oldBallArray[maxNumberOfBalls];

	bool oldBallUsed[maxNumberOfBalls];

	ballManeger()

	{

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

		{

			ballUsed[i] = false;

			oldBallUsed[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;