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.1 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

//Abstract layer is experimental and appears to cause trouble in some cercumstances. And it is not implemented

#ifndef USE_ABSTRACT_FS

    #define USE_ABSTRACT_FS 1

#endif

//Build-in level editor is still experimental!

#ifndef LEVELEDITOR

    #define LEVELEDITOR 0

#endif

//Macros to convert surfaces (for 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!

#if USE_ABSTRACT_FS

    #include <physfs.h>         //Abstract file system. To use containers

#endif

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

//#include "config.h"

#include <vector>

#include <SDL/SDL_timer.h>

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

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;

}

#if USE_ABSTRACT_FS

SDL_Surface * IMG_Load2(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 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;

}

#else

//Because we use the SHAREDIR we need:

SDL_Surface * IMG_Load2(char* path) {

    string tmp = "";

    SDL_Surface * ret=NULL;

    tmp = (string)""+sharedir+(string)"/"+path;

#if DEBUG

    cout << "loading " << tmp << endl;

#endif

    if (!(ret = IMG_Load(tmp.c_str())))

        ret = IMG_Load(path);

    return ret;

}

#endif

//Function to replace an image (ie. for a theme). Return true if replacing

bool reloadIMG(SDL_Surface **surface2replace, string replaceWith)

{

    string fullPath = SHAREDIR+(string)"/themes/"+replaceWith;

    #if DEBUG

    cout << "Trying to load " << fullPath << endl;

    #endif

    SDL_Surface * temp = NULL;

    temp = IMG_Load(fullPath.c_str());

    if(temp) //If we loaded a new image

    {

        #if DEBUG

        cout << "Found in game folder: " << fullPath << endl;

        #endif

        SDL_FreeSurface(*surface2replace);

        *surface2replace = temp;

        return true;

    }

    //Stop if under windows:

    #ifdef __unix__

    fullPath = (string)getenv("HOME")+(string)"/.gamesaves/blockattack/themes/"+replaceWith;

    #if DEBUG

    cout << "Trying to load " << fullPath << endl;

    #endif

    temp = IMG_Load(fullPath.c_str());

    if(temp) //If we loaded a new image

    {

        #if DEBUG

        cout << "Found in home folder: " << fullPath << endl;

        #endif

        SDL_FreeSurface(*surface2replace);

        *surface2replace = temp;

        return true;

    }

    #endif

    *surface2replace = * surface2replace;

    return false;

} 

void loadTheme(string themeName)

{

    if(themeName.compare("default")==0)

        themeName = "..";

    reloadIMG(&backgroundImage,themeName+"/gfx/background.png");

    reloadIMG(&backgroundImage,themeName+"/gfx/background.jpg");

    CONVERT(backgroundImage); //We should always convert even if we don't have to or else: SEGFAULT!

    reloadIMG(&bNewGame,themeName+"/gfx/bNewGame.png");

    CONVERT(bNewGame);

    reloadIMG(&b1player,themeName+"/gfx/bOnePlayer.png");

    CONVERT(b1player);

    reloadIMG(&b2players,themeName+"/gfx/bTwoPlayers.png");

    CONVERT(b2players);

    reloadIMG(&bVsMode,themeName+"/gfx/bVsGame.png");

    CONVERT(bVsMode);

    reloadIMG(&bVsModeConfig,themeName+"/gfx/bVsGameConfig.png");

    CONVERT(bVsModeConfig);

    reloadIMG(&bPuzzle,themeName+"/gfx/bPuzzle.png");

    CONVERT(bPuzzle);

    reloadIMG(&bStageClear,themeName+"/gfx/bStageClear.png");

    CONVERT(bStageClear);

    reloadIMG(&bTimeTrial,themeName+"/gfx/bTimeTrial.png");

    CONVERT(bTimeTrial);

    reloadIMG(&bEndless,themeName+"/gfx/bEndless.png");

    CONVERT(bEndless);

    reloadIMG(&bOptions,themeName+"/gfx/bOptions.png");

    CONVERT(bOptions);

    reloadIMG(&bConfigure,themeName+"/gfx/bConfigure.png");

    CONVERTA(bConfigure);

    reloadIMG(&bSelectPuzzle,themeName+"/gfx/bSelectPuzzle.png");

    CONVERTA(bSelectPuzzle);

    reloadIMG(&bReplay,themeName+"/gfx/bReplays.png");

    CONVERTA(bReplay);

    reloadIMG(&bSave,themeName+"/gfx/bSave.png");

    CONVERTA(bSave);

    reloadIMG(&bLoad,themeName+"/gfx/bLoad.png");

    CONVERTA(bLoad);

#if NETWORK

    reloadIMG(&bNetwork,themeName+"/gfx/bNetwork.png");

    CONVERTA(bNetwork);

    reloadIMG(&bHost,themeName+"/gfx/bHost.png");

    CONVERTA(bHost);

    reloadIMG(&bConnect,themeName+"/gfx/bConnect.png");

    CONVERTA(bConnect);

#endif

    reloadIMG(&bHighScore,themeName+"/gfx/bHighScore.png");

    CONVERT(bHighScore);

    reloadIMG(&boardBackBack,themeName+"/gfx/boardBackBack.png");

    CONVERTA(boardBackBack);

    reloadIMG(&backBoard,themeName+"/gfx/BackBoard.png");

    CONVERT(backBoard);

    reloadIMG(&blackLine,themeName+"/gfx/blackLine.png");

    CONVERT(blackLine);

    reloadIMG(&changeButtonsBack,themeName+"/gfx/changeButtonsBack.png");

    CONVERTA(changeButtonsBack);

    reloadIMG(&cursor[0],themeName+"/gfx/animations/cursor/1.png");

    CONVERTA(cursor[0]);

    reloadIMG(&cursor[1],themeName+"/gfx/animations/cursor/2.png");

    CONVERTA(cursor[1]);

    reloadIMG(&cursor[0],themeName+"/gfx/animations/counter/1.png");

    CONVERTA(counter[0]);

    reloadIMG(&cursor[1],themeName+"/gfx/animations/counter/2.png");

    CONVERTA(counter[1]);

    reloadIMG(&cursor[2],themeName+"/gfx/animations/counter/3.png");

    CONVERTA(counter[2]);

    reloadIMG(&optionsBack,themeName+"/gfx/options.png");

    CONVERTA(optionsBack);

    reloadIMG(&bExit,themeName+"/gfx/bExit.png");

    CONVERT(bExit);

    reloadIMG(&bOn,themeName+"/gfx/bOn.png");

    CONVERT(bOn);

    reloadIMG(&bOff,themeName+"/gfx/bOff.png");

    CONVERT(bOff);

    reloadIMG(&bChange,themeName+"/gfx/bChange.png");

    CONVERT(bChange);

    reloadIMG(&b1024,themeName+"/gfx/b1024.png");

    CONVERT(b1024);

    reloadIMG(&dialogBox,themeName+"/gfx/dialogbox.png");

    CONVERTA(dialogBox);

//	CONVERTA(fileDialogBox);

    reloadIMG(&iLevelCheck,themeName+"/gfx/iLevelCheck.png");

    CONVERTA(iLevelCheck);

    reloadIMG(&iLevelCheckBox,themeName+"/gfx/iLevelCheckBox.png");

    CONVERT(iLevelCheckBox);

    reloadIMG(&iCheckBoxArea,themeName+"/gfx/iCheckBoxArea.png");

    CONVERTA(iCheckBoxArea);

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

    {

        reloadIMG(&explosion[i],themeName+"/gfx/animations/explosion/"+(char)('0'+i)+".png");

        CONVERTA(explosion[i]);

    }

    reloadIMG(&bricks[0],themeName+"/gfx/bricks/blue.png");

    reloadIMG(&bricks[1],themeName+"/gfx/bricks/green.png");

    reloadIMG(&bricks[2],themeName+"/gfx/bricks/purple.png");

    reloadIMG(&bricks[3],themeName+"/gfx/bricks/red.png");

    reloadIMG(&bricks[4],themeName+"/gfx/bricks/turkish.png");

    reloadIMG(&bricks[5],themeName+"/gfx/bricks/yellow.png");

    reloadIMG(&bricks[6],themeName+"/gfx/bricks/grey.png");

    reloadIMG(&balls[0],themeName+"/gfx/balls/ballBlue.png");

    reloadIMG(&balls[1],themeName+"/gfx/balls/ballGreen.png");

    reloadIMG(&balls[2],themeName+"/gfx/balls/ballPurple.png");

    reloadIMG(&balls[3],themeName+"/gfx/balls/ballRed.png");

    reloadIMG(&balls[4],themeName+"/gfx/balls/ballTurkish.png");

    reloadIMG(&balls[5],themeName+"/gfx/balls/ballYellow.png");

    reloadIMG(&balls[6],themeName+"/gfx/balls/ballGray.png");

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

    {

        CONVERTA(bricks[i]);

        CONVERTA(balls[i]);

    }

    reloadIMG(&crossover,themeName+"/gfx/crossover.png");

    CONVERTA(crossover);

    reloadIMG(&garbageTL,themeName+"/gfx/garbage/garbageTL.png");

    CONVERTA(garbageTL);

    reloadIMG(&garbageT,themeName+"/gfx/garbage/garbageT.png");

    CONVERTA(garbageT);

    reloadIMG(&garbageTR,themeName+"/gfx/garbage/garbageTR.png");

    CONVERTA(garbageTR);

    reloadIMG(&garbageR,themeName+"/gfx/garbage/garbageR.png");

    CONVERTA(garbageR);

    reloadIMG(&garbageBR,themeName+"/gfx/garbage/garbageBR.png");

    CONVERTA(garbageBR);

    reloadIMG(&garbageB,themeName+"/gfx/garbage/garbageB.png");

    CONVERTA(garbageB);

    reloadIMG(&garbageBL,themeName+"/gfx/garbage/garbageBL.png");

    CONVERTA(garbageBL);

    reloadIMG(&garbageL,themeName+"/gfx/garbage/garbageL.png");

    CONVERTA(garbageL);

    reloadIMG(&garbageFill,themeName+"/gfx/garbage/garbageFill.png");

    CONVERTA(garbageFill);

    reloadIMG(&garbageML,themeName+"/gfx/garbage/garbageML.png");

    CONVERTA(garbageML);

    reloadIMG(&garbageMR,themeName+"/gfx/garbage/garbageMR.png");

    CONVERTA(garbageMR);

    reloadIMG(&garbageM,themeName+"/gfx/garbage/garbageM.png");

    CONVERTA(garbageM);

    reloadIMG(&garbageGML,themeName+"/gfx/garbage/garbageGML.png");

    CONVERTA(garbageGML);

    reloadIMG(&garbageGMR,themeName+"/gfx/garbage/garbageGMR.png");

    CONVERTA(garbageGMR);

    reloadIMG(&garbageGM,themeName+"/gfx/garbage/garbageGM.png");

    CONVERTA(garbageGM);

    reloadIMG(&smiley[0],themeName+"/gfx/smileys/0.png");

    CONVERTA(smiley[0]);

    reloadIMG(&smiley[1],themeName+"/gfx/smileys/1.png");

    CONVERTA(smiley[1]);

    reloadIMG(&smiley[2],themeName+"/gfx/smileys/2.png");

    CONVERTA(smiley[2]);

    reloadIMG(&smiley[3],themeName+"/gfx/smileys/3.png");

    CONVERTA(smiley[3]);

    reloadIMG(&iWinner,themeName+"/gfx/iWinner.png");

    CONVERTA(iWinner);

    reloadIMG(&iDraw,themeName+"/gfx/iDraw.png");

    CONVERTA(iDraw);

    reloadIMG(&iLoser,themeName+"/gfx/iLoser.png");

    CONVERTA(iLoser);

    reloadIMG(&iChainBack,themeName+"/gfx/chainFrame.png");

    CONVERTA(iChainBack);

    reloadIMG(&iGameOver,themeName+"/gfx/iGameOver.png");

    CONVERTA(iGameOver);

    reloadIMG(&mouse,themeName+"/gfx/mouse.png");

    CONVERTA(mouse);

    reloadIMG(&stageBobble,themeName+"/gfx/iStageClearLimit.png");

    CONVERTA(stageBobble);

    reloadIMG(&bTheme,themeName+"/gfx/bTheme.png");

    CONVERTA(bTheme);

    reloadIMG(&bSkip,themeName+"/gfx/bSkip.png");

    CONVERTA(bSkip);

    reloadIMG(&bRetry,themeName+"/gfx/bRetry.png");

    CONVERTA(bRetry);

    reloadIMG(&bNext,themeName+"/gfx/bNext.png");

    CONVERTA(bNext);

    /**

     *Fonts is a special case

     */

    //First we free them:

    SFont_FreeFont(fBlueFont);

    SFont_FreeFont(fSmallFont);

//SFont frees the surfaces then it frees the Font! So we start by loading the fonts we know are there:

    iBlueFont = IMG_Load2((char*)"gfx/24P_Arial_Blue.png");

    iSmallFont = IMG_Load2((char*)"gfx/14P_Arial_Angle_Red.png");

//Then we reload the images:

    reloadIMG(&iBlueFont,themeName+"/gfx/24P_Arial_Blue.png");

    reloadIMG(&iSmallFont,themeName+"/gfx/14P_Arial_Angle_Red.png");

    //Then we convert them:

    CONVERTA(iBlueFont);

    CONVERTA(iSmallFont);

    //Then create the fonts again:

    fBlueFont = SFont_InitFont(iBlueFont);

    fSmallFont = SFont_InitFont(iSmallFont);

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

    #if DEBUG

    cout << "Loading succeded" << endl;

    #endif

}

/*TTF_Font * TTF_OpenFont2(char* path, int ptsize) {

    char * tmp;

    TTF_Font * ret=NULL;

    tmp = (char*)malloc (sizeof(char)*(strlen(path)+strlen(sharedir)+2));

    strcpy(tmp, sharedir);

    strcat(tmp, "/");

    strcat(tmp, path);

#if DEBUG

    printf("loading %s\n",tmp);

#endif

    if(!(TTF_WasInit()))

       TTF_Init();

    if (!(ret = TTF_OpenFont(tmp, ptsize)))

        ret = TTF_OpenFont(path, ptsize);

    if(!ret)

        cout << "failed to load font: " << TTF_GetError() << endl;

    free(tmp);

    return ret;

}*/

#if USE_ABSTRACT_FS

Mix_Music * Mix_LoadMUS2(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_Music* ret = Mix_LoadMUS_RW(rw);

    return ret;

}

#else

Mix_Music * Mix_LoadMUS2(char* path)

{

    Mix_Music * ret=NULL;

    string tmp = (string)""+sharedir+(string)"/"+path;

#if DEBUG

    cout << "loading " << tmp << endl;

#endif

    if (!(ret = Mix_LoadMUS(tmp.c_str())))

        ret = Mix_LoadMUS(path);

    return ret;

}

#endif

#if USE_ABSTRACT_FS

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;

}

#else

Mix_Chunk * Mix_LoadWAV2(char* path)

{

    Mix_Chunk * ret=NULL;

    string tmp = (string)""+sharedir+(string)"/"+path;

#if DEBUG

    cout << "loading " << tmp << endl;

#endif

    if (!(ret = Mix_LoadWAV(tmp.c_str())))

        ret = Mix_LoadWAV(path);

    return ret;

}

#endif

//Load all image files to memory

int InitImages()

{

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

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

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

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

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

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

            && (bVsModeConfig = IMG_Load2((char*)"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"))

            && (iBlueFont = IMG_Load2((char*)"gfx/24P_Arial_Blue.png"))

            && (iSmallFont = IMG_Load2((char*)"gfx/14P_Arial_Angle_Red.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"))

            //end new in 1.4.0

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

         ))

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

    {

        cout << "Error loading image file: " << SDL_GetError() << endl;

        exit(1);

    }

    //Prepare for fast blittering!

    CONVERT(background);

    CONVERT(bNewGame);

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

    //CONVERTA(menuMarked);

    //CONVERTA(menuUnmarked);

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

    CONVERTA(iSmallFont);

    CONVERTA(iGameOver);

    CONVERTA(mouse);

    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

    //Here comes the fonts:

    fBlueFont = SFont_InitFont(iBlueFont);

    fSmallFont = SFont_InitFont(iSmallFont);

    //And the ttf font:

    /*TTF_Font *ttFont1 = TTF_OpenFont2((char*)"fonts/FreeSerif.ttf", 24);

    TTF_SetFontStyle(ttFont1,TTF_STYLE_BOLD);

    ttfont = TTFont(ttFont1);*/

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

{

    //Fonts and Sounds needs to be freed

    SFont_FreeFont(fBlueFont);

    SFont_FreeFont(fSmallFont);

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

    {

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

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