blame: source/code/main.cpp

/*

Block Attack - Rise of the Blocks, SDL game, besed on Nintendo's Tetris Attack

Copyright (C) 2008 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, write to the Free Software

    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA

    Poul Sander

    R�vehjvej 36, V. 1111

    2800 Kgs. Lyngby

    DENMARK

    blockattack@poulsander.com

    http://blockattack.sf.net

*/

#include "common.h"

#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 "CppSdl/CppSdlImageHolder.hpp"

//#include "MenuSystem.h"

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

#ifndef SHAREDIR

#define SHAREDIR "."

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

            && (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/bSkip.png"))

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

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

            //&& (menuMarked = IMG_Load2((char*)"gfx/menu/marked.png"))

            //&& (menuUnmarked = IMG_Load2((char*)"gfx/menu/unmarked.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");

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

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

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

}*/

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

static string itoa2(int num)

{

    stringstream converter;

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

}

//Menu

/*void PrintHi()

{

    cout << "Hi" <<endl;

}

void InitMenues()

{

    ButtonGfx::setSurfaces(&menuMarked,&menuUnmarked);

    ButtonGfx::ttf = &ttfont;

}

void MainMenu()

{

    Menu m(&screen,true);

    Button bHi;

    bHi.setLabel("Write hi");

    bHi.setAction(PrintHi);

    m.addButton(bHi);

    m.run();

}*/

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

class aBall

{

private:

    double x;

    double y;

    double velocityY;

    double velocityX;