No OneTemporary
Actions

Authored By

Unknown

Size

86 KB

Referenced Files

None

Subscribers

None

View Options

	diff --git a/src/Functions.cpp b/src/Functions.cpp
	index 8501258..50e6bf0 100644
	--- a/src/Functions.cpp
	+++ b/src/Functions.cpp
	@@ -1,1161 +1,1160 @@
	/****************************************************************************
	** Copyright (C) 2011 Luka Horvat <redreaper132 at gmail.com>
	** Copyright (C) 2011 Edward Lii <edward_iii at myway.com>
	** Copyright (C) 2011 O. Bahri Gordebak <gordebak at gmail.com>
	**
	**
	** This file may be used under the terms of the GNU General Public
	** License version 3.0 as published by the Free Software Foundation
	** and appearing in the file LICENSE.GPL included in the packaging of
	** this file.
	**
	** This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
	** WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
	**
	** You should have received a copy of the GNU General Public License
	** along with this program. If not, see <http://www.gnu.org/licenses/>.
	**
	****************************************************************************/

	#include <stdio.h>
	#include <SDL/SDL.h>
	#include <SDL/SDL_mixer.h>
	#include <SDL/SDL_gfxPrimitives.h>
	#include <SDL/SDL_rotozoom.h>
	#include <string>
	#include "Globals.h"
	#include "Functions.h"
	#include "FileManager.h"
	#include "Objects.h"
	#include "Player.h"
	#include "GameObjects.h"
	#include "LevelPack.h"
	#include "TitleMenu.h"
	#include "LevelEditSelect.h"
	#include "LevelEditor.h"
	#include "Game.h"
	#include "LevelPlaySelect.h"
	#include "Addons.h"
	#include "ImageManager.h"
	#include "MusicManager.h"
	#include "LevelPackManager.h"
	#include "ThemeManager.h"
	#include "GUIListBox.h"

	#include "libs/tinyformat/tinyformat.h"
	#include "libs/tinygettext/tinygettext.hpp"
	extern "C" {
	#include "libs/findlocale/findlocale.h"
	}

	#ifdef HARDWARE_ACCELERATION
	#include <GL/gl.h>
	#include <GL/glu.h>
	#endif
	using namespace std;

	#ifdef WIN32
	#include <windows.h>
	#include <shlobj.h>
	#else
	#include <strings.h>
	#include <sys/stat.h>
	#include <sys/types.h>
	#include <unistd.h>
	#include <dirent.h>
	#endif

	//Initialise the imagemanager.
	//The ImageManager is used to prevent loading images multiple times.
	ImageManager imageManager;

	//Initialise the musicManager.
	//The MusicManager is used to prevent loading music files multiple times and for playing/fading music.
	MusicManager musicManager;

	//Initialise the levelPackManager.
	//The LevelPackManager is used to prevent loading levelpacks multiple times and for the game to know which levelpacks there are.
	LevelPackManager levelPackManager;

	//Pointer to the settings object.
	//It is used to load and save the settings file and change the settings.
	Settings* settings=0;

	#ifdef HARDWARE_ACCELERATION
	GLuint screenTexture;
	#endif

	SDL_Surface* loadImage(string file){
	//We use the imageManager to load the file.
	return imageManager.loadImage(file);
	}

	void applySurface(int x,int y,SDL_Surface* source,SDL_Surface* dest,SDL_Rect* clip){
	//The offset is needed to draw at the right location.
	SDL_Rect offset;
	offset.x=x;
	offset.y=y;

	//Let SDL do the drawing of the surface.
	SDL_BlitSurface(source,clip,dest,&offset);
	}

	void drawRect(int x,int y,int w,int h,SDL_Surface* dest,Uint32 color){
	//NOTE: We let SDL_gfx render it.
	rectangleRGBA(dest,x,y,x+w,y+h,color >> 24,color >> 16,color >> 8,255);
	}

	//Draw a box with anti-aliased borders using SDL_gfx.
	void drawGUIBox(int x,int y,int w,int h,SDL_Surface* dest,Uint32 color){
	//Fill content's background color from function parameter
	boxRGBA(screen,x+1,y+1,x+w-2,y+h-2,color >> 24,color >> 16,color >> 8,color >> 0);

	//Draw first black borders around content and leave 1 pixel in every corner
	lineRGBA(screen,x+1,y,x+w-2,y,0,0,0,255);
	lineRGBA(screen,x+1,y+h-1,x+w-2,y+h-1,0,0,0,255);
	lineRGBA(screen,x,y+1,x,y+h-2,0,0,0,255);
	lineRGBA(screen,x+w-1,y+1,x+w-1,y+h-2,0,0,0,255);

	//Fill the corners with transperent color to create anti-aliased borders
	pixelRGBA(screen,x,y,0,0,0,160);
	pixelRGBA(screen,x,y+h-1,0,0,0,160);
	pixelRGBA(screen,x+w-1,y,0,0,0,160);
	pixelRGBA(screen,x+w-1,y+h-1,0,0,0,160);

	//Draw second lighter border around content
	rectangleRGBA(screen,x+1,y+1,x+w-2,y+h-2,0,0,0,64);

	//Create anti-aliasing in corners of second border
	pixelRGBA(screen,x+1,y+1,0,0,0,50);
	pixelRGBA(screen,x+1,y+h-2,0,0,0,50);
	pixelRGBA(screen,x+w-2,y+1,0,0,0,50);
	pixelRGBA(screen,x+w-2,y+h-2,0,0,0,50);
	}

	void drawLine(int x1,int y1,int x2,int y2,SDL_Surface* dest,Uint32 color){
	//NOTE: We let SDL_gfx render it.
	lineRGBA(dest,x1,y1,x2,y2,color >> 24,color >> 16,color >> 8,255);
	}

	void drawLineWithArrow(int x1,int y1,int x2,int y2,SDL_Surface* dest,Uint32 color,int spacing,int offset,int xsize,int ysize){
	//Draw line first
	drawLine(x1,y1,x2,y2,dest,color);

	//calc delta and length
	double dx=x2-x1;
	double dy=y2-y1;
	double length=sqrt(dxdx+dydy);
	if(length<0.001) return;

	//calc the unit vector
	dx/=length; dy/=length;

	//Now draw arrows on it
	for(double p=offset;p<length;p+=spacing){
	drawLine(int(x1+pdx+0.5),int(y1+pdy+0.5),
	int(x1+(p-xsize)dx-ysizedy+0.5),int(y1+(p-xsize)dy+ysizedx+0.5),dest,color);
	drawLine(int(x1+pdx+0.5),int(y1+pdy+0.5),
	int(x1+(p-xsize)dx+ysizedy+0.5),int(y1+(p-xsize)dy-ysizedx+0.5),dest,color);
	}
	}

	bool init(){
	//Initialze SDL.
	if(SDL_Init(SDL_INIT_EVERYTHING)==-1) {
	fprintf(stderr,"FATAL ERROR: SDL_Init failed\n");
	return false;
	}

	//Initialze SDL_mixer (audio).
	if(Mix_OpenAudio(22050,MIX_DEFAULT_FORMAT,2,512)==-1){
	fprintf(stderr,"FATAL ERROR: Mix_OpenAudio failed\n");
	return false;
	}

	//Initialze SDL_ttf (fonts).
	if(TTF_Init()==-1){
	fprintf(stderr,"FATAL ERROR: TTF_Init failed\n");
	return false;
	}

	//Set the screen_width and height.
	SCREEN_WIDTH=atoi(settings->getValue("width").c_str());
	SCREEN_HEIGHT=atoi(settings->getValue("height").c_str());

	//Update the camera.
	camera.w=SCREEN_WIDTH;
	camera.h=SCREEN_HEIGHT;

	//Check if we should use gl or software rendering.
	if(settings->getBoolValue("gl")){
	#ifdef HARDWARE_ACCELERATION
	SDL_GL_SetAttribute(SDL_GL_RED_SIZE,8);
	SDL_GL_SetAttribute(SDL_GL_GREEN_SIZE,8);
	SDL_GL_SetAttribute(SDL_GL_BLUE_SIZE,8);
	SDL_GL_SetAttribute(SDL_GL_ALPHA_SIZE,8);

	SDL_GL_SetAttribute(SDL_GL_DEPTH_SIZE,16);
	SDL_GL_SetAttribute(SDL_GL_BUFFER_SIZE,32);

	SDL_GL_SetAttribute(SDL_GL_ACCUM_RED_SIZE,8);
	SDL_GL_SetAttribute(SDL_GL_ACCUM_GREEN_SIZE,8);
	SDL_GL_SetAttribute(SDL_GL_ACCUM_BLUE_SIZE,8);
	SDL_GL_SetAttribute(SDL_GL_ACCUM_ALPHA_SIZE,8);

	SDL_GL_SetAttribute(SDL_GL_MULTISAMPLEBUFFERS,0);
	SDL_GL_SetAttribute(SDL_GL_MULTISAMPLESAMPLES,0);
	SDL_GL_SetAttribute(SDL_GL_DOUBLEBUFFER,1);

	//Set the video mode.
	Uint32 flags=SDL_HWSURFACE \| SDL_OPENGL;
	if(settings->getBoolValue("fullscreen"))
	flags\|=SDL_FULLSCREEN;
	if(SDL_SetVideoMode(SCREEN_WIDTH,SCREEN_HEIGHT,SCREEN_BPP,flags)==NULL){
	fprintf(stderr,"FATAL ERROR: SDL_SetVideoMode failed\n");
	return false;
	}
	//Create a screen
	screen=SDL_CreateRGBSurface(SDL_HWSURFACE,SCREEN_WIDTH,SCREEN_HEIGHT,32,0x00FF0000,0x0000FF00,0x000000FF,0xFF000000);

	//Create a texture.
	glGenTextures(1,&screenTexture);

	//And set up gl correctly.
	glClearColor(0, 0, 0, 0);
	glClearDepth(1.0f);
	glViewport(0, 0, SCREEN_WIDTH, SCREEN_HEIGHT);
	glMatrixMode(GL_PROJECTION);
	glLoadIdentity();
	glOrtho(0, SCREEN_WIDTH, SCREEN_HEIGHT, 0, 1, -1);
	glMatrixMode(GL_MODELVIEW);
	glEnable(GL_TEXTURE_2D);
	glLoadIdentity();
	#else
	//NOTE: Hardware accelerated rendering requested but compiled without.
	cerr<<"FATAL ERROR: Unable to use hardware acceleration (compiled without)."<<endl;
	return false;
	#endif
	}else{
	Uint32 flags=SDL_HWSURFACE \| SDL_DOUBLEBUF;
	if(settings->getBoolValue("fullscreen"))
	flags\|=SDL_FULLSCREEN;
	screen=SDL_SetVideoMode(SCREEN_WIDTH,SCREEN_HEIGHT,SCREEN_BPP,flags);
	if(screen==NULL){
	fprintf(stderr,"FATAL ERROR: SDL_SetVideoMode failed\n");
	return false;
	}
	}

	//Set the the window caption.
	SDL_WM_SetCaption(("Me and my shadow "+version).c_str(),NULL);
	SDL_EnableUNICODE(1);

	//Init tinygettext for translations for the right language
	dictionaryManager = new tinygettext::DictionaryManager();
	dictionaryManager->add_directory(getDataPath()+"locale");
	dictionaryManager->set_charset("UTF-8");

	//Check if user have defined own language. If not, find it out for the player using findlocale
	string lang=getSettings()->getValue("lang");
	if(lang.length()>0){
	printf("Locale set by user to %s\n",lang.c_str());
	language=lang;
	}else{
	FL_Locale *locale;
	FL_FindLocale(&locale,FL_MESSAGES);
	printf("Locale isn't set by user: %s\n",locale->lang);
	language=locale->lang;
	FL_FreeLocale(&locale);
	}

	//Now set the language in the dictionaryManager.
	dictionaryManager->set_language(tinygettext::Language::from_name(language));

	//Create the types of blocks.
	for(int i=0;i<TYPE_MAX;i++){
	Game::blockNameMap[Game::blockName[i]]=i;
	}

	//Nothing went wrong so we return true.
	return true;
	}

	static TTF_Font* loadFont(const char* name,int size){
	TTF_Font* tmpFont=TTF_OpenFont((getDataPath()+"font/"+name+".ttf").c_str(),size);
	if(tmpFont){
	return tmpFont;
	}else{
	return TTF_OpenFont((getDataPath()+"font/freesans.ttf").c_str(),size);
	}
	}

	bool loadFiles(){
	//Load the music and play it.
	if(musicManager.loadMusic((getDataPath()+"music/menu.music")).empty()){
	printf("WARNING: Unable to load background music! \n");
	}
	musicManager.playMusic("menu",false);
	//Always load the default music list for fallback.
	musicManager.loadMusicList((getDataPath()+"music/default.list"));

	//Load the fonts.
	/// TRANSLATORS: Font used in GUI:
	/// - Use "knewave" for languages using Latin and Latin-derived alphabets
	/// - "freesans" can be used for non-Latin writing systems
	fontTitle=loadFont(_("knewave"),55);
	fontGUI=loadFont(_("knewave"),32);
	/// TRANSLATORS: Font used for normal text:
	/// - Use "Blokletters-Viltstift" for languages using Latin and Latin-derived alphabets
	/// - "freesans" can be used for non-Latin writing systems
	fontText=loadFont(_("Blokletters-Viltstift"),16);
	if(fontTitle==NULL \|\| fontGUI==NULL \|\| fontText==NULL){
	printf("ERROR: Unable to load fonts! \n");
	return false;
	}

	//Now sum up all the levelpacks.
	vector<string> v=enumAllDirs(getDataPath()+"levelpacks/");
	for(vector<string>::iterator i=v.begin(); i!=v.end(); ++i){
	levelPackManager.loadLevelPack(getDataPath()+"levelpacks/"+*i);
	}
	v=enumAllDirs(getUserPath(USER_DATA)+"levelpacks/");
	for(vector<string>::iterator i=v.begin(); i!=v.end(); ++i){
	levelPackManager.loadLevelPack(getUserPath(USER_DATA)+"levelpacks/"+*i);
	}
	v=enumAllDirs(getUserPath(USER_DATA)+"custom/levelpacks/");
	for(vector<string>::iterator i=v.begin(); i!=v.end(); ++i){
	levelPackManager.loadLevelPack(getUserPath(USER_DATA)+"custom/levelpacks/"+*i);
	}
	//Now we add a special levelpack that will contain the levels not in a levelpack.
	LevelPack* levelsPack=new LevelPack;
	levelsPack->levelpackName="Levels";
	LevelPack* customLevelsPack=new LevelPack;
	customLevelsPack->levelpackName="Custom Levels";

	//List the addon levels and add them one for one.
	v=enumAllFiles(getUserPath(USER_DATA)+"levels/");
	for(vector<string>::iterator i=v.begin(); i!=v.end(); ++i){
	levelsPack->addLevel(getUserPath(USER_DATA)+"levels/"+*i);
	levelsPack->setLocked(levelsPack->getLevelCount()-1);
	}
	//List the custom levels and add them one for one.
	v=enumAllFiles(getUserPath(USER_DATA)+"custom/levels/");
	for(vector<string>::iterator i=v.begin(); i!=v.end(); ++i){
	levelsPack->addLevel(getUserPath(USER_DATA)+"custom/levels/"+*i);
	levelsPack->setLocked(levelsPack->getLevelCount()-1);

	customLevelsPack->addLevel(getUserPath(USER_DATA)+"custom/levels/"+*i);
	customLevelsPack->setLocked(customLevelsPack->getLevelCount()-1);
	}

	//Add them to the manager.
	levelPackManager.addLevelPack(levelsPack);
	levelPackManager.addLevelPack(customLevelsPack);


	//Load the menu background.
	menuBackground=loadImage(getDataPath()+"gfx/menu/background.png");
	if(menuBackground==NULL){
	printf("ERROR: Unable to load menu background.\n");
	return false;
	}
	//Check if the menu background needs to be scaled.
	if(menuBackground->w!=SCREEN_WIDTH \|\| menuBackground->h!=SCREEN_HEIGHT){
	menuBackground=zoomSurface(menuBackground,double(SCREEN_WIDTH)/double(menuBackground->w),double(SCREEN_HEIGHT)/double(menuBackground->h),0);
	}

	//Load the default theme.
	if(objThemes.appendThemeFromFile(getDataPath()+"themes/Cloudscape/theme.mnmstheme")==NULL){
	printf("ERROR: Can't load default theme file\n");
	return false;
	}

	//Nothing failed so return true.
	return true;
	}

	bool loadSettings(){
	settings=new Settings(getUserPath(USER_CONFIG)+"meandmyshadow.cfg");
	settings->parseFile();

	//Always return true?
	return true;
	}

	bool saveSettings(){
	settings->save();

	//Always return true?
	return true;
	}

	Settings* getSettings(){
	return settings;
	}

	MusicManager* getMusicManager(){
	return &musicManager;
	}

	LevelPackManager* getLevelPackManager(){
	return &levelPackManager;
	}

	void flipScreen(){
	if(settings->getBoolValue("gl")){
	#ifdef HARDWARE_ACCELERATION
	glClear(GL_COLOR_BUFFER_BIT \| GL_DEPTH_BUFFER_BIT);
	glLoadIdentity();

	//Create a texture from the screen surface.
	glBindTexture(GL_TEXTURE_2D,screenTexture);

	//Set the texture's stretching properties
	glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MIN_FILTER,GL_LINEAR);
	glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MAG_FILTER,GL_LINEAR);

	glTexImage2D(GL_TEXTURE_2D,0,screen->format->BytesPerPixel,screen->w,screen->h,0,GL_BGRA,GL_UNSIGNED_BYTE,screen->pixels);

	glBegin(GL_QUADS);
	glTexCoord2f(0,0); glVertex3f(0,0,0);
	glTexCoord2f(1,0); glVertex3f(SCREEN_WIDTH,0,0);
	glTexCoord2f(1,1); glVertex3f(SCREEN_WIDTH,SCREEN_HEIGHT,0);
	glTexCoord2f(0,1); glVertex3f(0,SCREEN_HEIGHT,0);
	glEnd();

	SDL_GL_SwapBuffers();
	#else
	//NOTE: Trying to flip the screen using gl while compiled without.
	cerr<<"FATAL ERROR: Unable to draw to screen using OpenGL (compiled without)."<<endl;
	#endif
	}else{
	SDL_Flip(screen);
	}
	}

	void clean(){
	//We delete the settings.
	if(settings){
	delete settings;
	settings=NULL;
	}

	//Get rid of the currentstate/
	//NOTE: The state is probably already deleted by the changeState function.
	if(currentState)
	delete currentState;

	//Destroy the GUI if present.
	if(GUIObjectRoot){
	delete GUIObjectRoot;
	GUIObjectRoot=NULL;
	}

	//Destroy the imageManager.
	imageManager.destroy();

	//Destroy the musicManager.
	musicManager.destroy();

	//Destroy the levelPackManager.
	levelPackManager.destroy();
	levels=NULL;

	//Close the fonts and quit SDL_ttf.
	TTF_CloseFont(fontTitle);
	TTF_CloseFont(fontGUI);
	TTF_CloseFont(fontText);
	TTF_Quit();

	//Quit SDL.
	SDL_Quit();

	//And finally stop audio.
	Mix_CloseAudio();
	}

	void setNextState(int newstate){
	//Only change the state when we aren't already exiting.
	if(nextState!=STATE_EXIT){
	nextState=newstate;
	}
	}

	void changeState(){
	//Check if there's a nextState.
	if(nextState!=STATE_NULL){
	//Delete the currentState.
	delete currentState;
	currentState=NULL;

	//Set the currentState to the nextState.
	stateID=nextState;
	nextState=STATE_NULL;

	//Init the state.
	switch(stateID){
	case STATE_GAME:
	currentState=new Game();
	break;
	case STATE_MENU:
	currentState=new Menu();
	break;
	case STATE_LEVEL_SELECT:
	currentState=new LevelPlaySelect();
	break;
	case STATE_LEVEL_EDIT_SELECT:
	currentState=new LevelEditSelect();
	break;
	case STATE_LEVEL_EDITOR:
	currentState=new LevelEditor();
	break;
	case STATE_OPTIONS:
	currentState=new Options();
	break;
	case STATE_ADDONS:
	currentState=new Addons();
	break;
	}
	//NOTE: STATE_EXIT isn't mentioned, meaning that currentState is null.
	//This way the game loop will break and the program will exit.

	//Fade out.
	int fade=255;
	SDL_BlitSurface(screen,NULL,tempSurface,NULL);
	while(fade>0){
	fade-=17;
	if(fade<0)
	fade=0;


	SDL_FillRect(screen,NULL,0);
	SDL_SetAlpha(tempSurface, SDL_SRCALPHA, fade);
	SDL_BlitSurface(tempSurface,NULL,screen,NULL);
	flipScreen();
	SDL_Delay(25);
	}
	}
	}

	void musicStoppedHook(){
	//We just call the musicStopped method of the MusicManager.
	musicManager.musicStopped();
	}

	bool checkCollision(const SDL_Rect& a,const SDL_Rect& b){
	//Check if the left side of box a isn't past the right side of b.
	if(a.x>=b.x+b.w){
	return false;
	}
	//Check if the right side of box a isn't left of the left side of b.
	if(a.x+a.w<=b.x){
	return false;
	}
	//Check if the top side of box a isn't under the bottom side of b.
	if(a.y>=b.y+b.h){
	return false;
	}
	//Check if the bottom side of box a isn't above the top side of b.
	if(a.y+a.h<=b.y){
	return false;
	}

	//We have collision.
	return true;
	}

	void setCamera(){
	//SetCamera only works in the Level editor.
	if(stateID==STATE_LEVEL_EDITOR){
	//Get the mouse coordinates.
	int x,y;
	SDL_GetMouseState(&x,&y);

	//Make sure we avoid the toolbar.
	SDL_Rect mouse={x,y,0,0};
	SDL_Rect toolbar={155,550,510,50};
	if(checkCollision(mouse,toolbar))
	return;

	//Check if the mouse is near the left edge of the screen.
	//Else check if the mouse is near the right edge.
	if(x<50){
	//We're near the left edge so move the camera.
	camera.x-=5;
	}else if(x>SCREEN_WIDTH-50){
	//We're near the right edge so move the camera.
	camera.x+=5;
	}

	//Check if the mouse is near the top edge of the screen.
	//Else check if the mouse is near the bottom edge.
	if(y<50){
	//We're near the top edge so move the camera.
	camera.y-=5;
	}else if(y>SCREEN_HEIGHT-50){
	//We're near the bottom edge so move the camera.
	camera.y+=5;
	}
	}
	}

	bool parseArguments(int argc, char** argv){
	//Loop through all arguments.
	//We start at one since 0 is the command itself.
	for(int i=1;i<argc;i++){
	string argument=argv[i];

	//Check if the argument is the data-dir.
	if(argument=="--data-dir"){
	//We need a second argument so we increase i.
	i++;
	if(i>=argc){
	printf("ERROR: Missing argument for command '%s'\n\n",argument.c_str());
	return false;
	}

	//Configure the dataPath with the given path.
	dataPath=argv[i];
	if(!getDataPath().empty()){
	char c=dataPath[dataPath.size()-1];
	if(c!='/'&&c!='\\') dataPath+="/";
	}
	}else if(argument=="--user-dir"){
	//We need a second argument so we increase i.
	i++;
	if(i>=argc){
	printf("ERROR: Missing argument for command '%s'\n\n",argument.c_str());
	return false;
	}

	//Configure the userPath with the given path.
	userPath=argv[i];
	if(!userPath.empty()){
	char c=userPath[userPath.size()-1];
	if(c!='/'&&c!='\\') userPath+="/";
	}
	}else if(argument=="-v" \|\| argument=="-version" \|\| argument=="--version"){
	//Print the version.
	printf("Version: '%s'\n\n",version.c_str());
	}else if(argument=="-h" \|\| argument=="-help" \|\| argument=="--help"){
	//If the help is requested we'll return false without printing an error.
	//This way the usage/help text will be printed.
	return false;
	}else{
	//Any other argument is unknow so we return false.
	printf("ERROR: Unknown argument %s\n\n",argument.c_str());
	return false;
	}
	}

	//If everything went well we can return true.
	return true;
	}

	//Special structure that will recieve the GUIEventCallbacks of the messagebox.
	struct msgBoxHandler:public GUIEventCallback{
	public:
	//Integer containing the ret(urn) value of the messageBox.
	int ret;
	public:
	//Constructor.
	msgBoxHandler():ret(0){}

	void GUIEventCallback_OnEvent(std::string name,GUIObject* obj,int eventType){
	//Make sure it's a click event.
	if(eventType==GUIEventClick){
	//Set the return value.
	ret=obj->value;

	//After a click event we can delete the GUI.
	if(GUIObjectRoot){
	delete GUIObjectRoot;
	GUIObjectRoot=NULL;
	}
	}
	}
	};

	msgBoxResult msgBox(string prompt,msgBoxButtons buttons,const string& title){
	//Create the event handler.
	msgBoxHandler objHandler;
	//The GUI objects.
	GUIObject* obj;
	//We keep a pointer to the original GUIObjectRoot for later.
	GUIObject* tmp=GUIObjectRoot;

	//Create the GUIObjectRoot, the height and y location is temp.
	//It depends on the content what it will be.
	GUIObjectRoot=new GUIObject((SCREEN_WIDTH-600)/2,200,600,200,GUIObjectFrame,title.c_str());

	//Integer containing the current y location used to grow dynamic depending on the content.
	int y=50;

	//Now process the prompt.
	{
	//Pointer to the string.
	char* lps=(char*)prompt.c_str();
	//Pointer to a character.
	char* lp=NULL;

	//We keep looping forever.
	//The only way out is with the break statement.
	for(;;){
	//As long as it's still the same sentence we continue.
	//It will stop when there's a newline or end of line.
	for(lp=lps;lp!='\n'&&lp!='\r'&&*lp!=0;lp++);

	//Store the character we stopped on. (End or newline)
	char c=*lp;
	//Set the character in the string to 0, making lps a string containing one sentence.
	*lp=0;

	//Integer used to center the sentence horizontally.
	int x;
	TTF_SizeText(fontText,lps,&x,NULL);
	x=(600-x)/2;

	//Add a GUIObjectLabel with the sentence.
	GUIObjectRoot->childControls.push_back(new GUIObject(x,y,584,25,GUIObjectLabel,lps));
	//Increase y with 25, about the height of the text.
	y+=25;

	//Check the stored character if it was a stop.
	if(c==0){
	//It was so break out of the for loop.
	lps=lp;
	break;
	}
	//It wasn't meaning more will follow.
	//We set lps to point after the "newline" forming a new string.
	lps=lp+1;
	}
	}
	//Add 70 to y to leave some space between the content and the buttons.
	y+=70;
	//Recalc the size of the message box.
	GUIObjectRoot->top=(SCREEN_HEIGHT-y)/2;
	GUIObjectRoot->height=y;

	//Now we need to add the buttons.
	//Integer containing the number of buttons to add.
	int count=0;
	//Array with the return codes for the buttons.
	int value[3]={0};
	//Array containing the captation for the buttons.
	string button[3]={"","",""};
	switch(buttons){
	case MsgBoxOKCancel:
	count=2;
	button[0]=_("OK");value[0]=MsgBoxOK;
	button[1]=_("Cancel");value[1]=MsgBoxCancel;
	break;
	case MsgBoxAbortRetryIgnore:
	count=3;
	button[0]=_("Abort");value[0]=MsgBoxAbort;
	button[1]=_("Retry");value[1]=MsgBoxRetry;
	button[2]=_("Ignore");value[2]=MsgBoxIgnore;
	break;
	case MsgBoxYesNoCancel:
	count=3;
	button[0]=_("Yes");value[0]=MsgBoxYes;
	button[1]=_("No");value[1]=MsgBoxNo;
	button[2]=_("Cancel");value[2]=MsgBoxCancel;
	break;
	case MsgBoxYesNo:
	count=2;
	button[0]=_("Yes");value[0]=MsgBoxYes;
	button[1]=_("No");value[1]=MsgBoxNo;
	break;
	case MsgBoxRetryCancel:
	count=2;
	button[0]=_("Retry");value[0]=MsgBoxRetry;
	button[1]=_("Cancel");value[1]=MsgBoxCancel;
	break;
	default:
	count=1;
	button[0]=_("OK");value[0]=MsgBoxOK;
	break;
	}

	//Now we start making the buttons.
	{
	//Calculate the x location (centered).
	int x=302-count*50;
	//Reduce y so that the buttons fit inside the frame.
	y-=40;

	//Loop to add the buttons.
	for(int i=0;i<count;i++,x+=100){
	obj=new GUIObject(x,y,96,36,GUIObjectButton,button[i].c_str(),value[i]);
	obj->eventCallback=&objHandler;
	GUIObjectRoot->childControls.push_back(obj);
	}
	}

	//Now we dim the screen and keep the GUI rendering/updating.
	SDL_FillRect(tempSurface,NULL,0);
	SDL_SetAlpha(tempSurface,SDL_SRCALPHA,155);
	SDL_BlitSurface(tempSurface,NULL,screen,NULL);
	while(GUIObjectRoot){
	while(SDL_PollEvent(&event)){
	GUIObjectHandleEvents(true);

	//Also check for the return, escape or backspace button.
	//escape = KEYUP.
	//backspace and return = KEYDOWN.
	if(count==1 && ((event.type==SDL_KEYUP && event.key.keysym.sym==SDLK_ESCAPE) \|\|
	(event.type==SDL_KEYDOWN && (event.key.keysym.sym==SDLK_RETURN \|\| event.key.keysym.sym==SDLK_BACKSPACE)))){
	delete GUIObjectRoot;
	GUIObjectRoot=NULL;
	}

	}
	//Render the gui.
	if(GUIObjectRoot)
	GUIObjectRoot->render();
	flipScreen();
	SDL_Delay(30);
	}

	//We're done so set the original GUIObjectRoot back.
	GUIObjectRoot=tmp;
	//And return the result.
	return (msgBoxResult)objHandler.ret;
	}

	struct fileDialogHandler:public GUIEventCallback{
	public:
	//The ret(urn) value, true=ok and false=cancel
	bool ret;
	//Boolean if it's a save dialog.
	bool isSave;
	//Boolean if the file should be verified.
	bool verifyFile;
	//Boolean if files should be listed instead of directories.
	bool files;

	//Pointer to the textfield containing the filename.
	GUIObject* txtName;
	//Pointer to the listbox containing the different files.
	GUIListBox* lstFile;

	//The extension the files listed should have.
	const char* extension;
	//The current filename.
	string fileName;
	//The current search path.
	string path;

	//Vector containing the search paths.
	vector<string> searchPath;
	public:
	//Constructor.
	fileDialogHandler(bool isSave=false,bool verifyFile=false, bool files=true):ret(false),
	isSave(isSave),verifyFile(verifyFile),
	files(files),txtName(NULL){}

	void GUIEventCallback_OnEvent(std::string name,GUIObject* obj,int eventType){
	//Check for the ok event.
	if(name=="cmdOK"){
	//Get the entered fileName from the text field.
	std::string s=txtName->caption;

	//If it doesn't contain a slash we need to add the path to the fileName.
	if(s.find_first_of("/")==string::npos)
	s=path+s;

	//If the string empty we return.
	if(s.empty() \|\| s.find_first_of("*?")!=string::npos)
	return;

	//We only need to check for extensions if it isn't a folder dialog.
	if(files){
	//If there isn't right extension add it.
	size_t found=s.find_first_of(".");
	if(found!=string::npos)
	s.replace(s.begin()+found+1,s.end(),extension);
	else if (s.substr(found+1)!=extension)
	s.append(string(".")+extension);
	}

	//Check if we should save or load the file.
	//
	if(isSave){
	//Open the file with read permission to check if it already exists.
	FILE* f;
	f=fopen(processFileName(s).c_str(),"rb");

	//Check if it exists.
	if(f){
	//Close the file.
	fclose(f);

	//Let the currentState render once to prevent multiple GUI overlapping and prevent the screen from going black.
	currentState->render();

	//Prompt the user with a Yes or No question.
	/// TRANSLATORS: Filename is coming before this text
	-
	if(msgBox(tfm::format(_("%s already exists.\nDo you want to overwrite it?"),s),MsgBoxYesNo,_("Overwrite Prompt"))!=MsgBoxYes){
	//He answered no, so we return.
	return;
	}
	}

	//Check if we should verify the file.
	//Verifying only applies to files not to directories.
	if(verifyFile && files){
	//Open the file with write permission.
	f=fopen(processFileName(s).c_str(),"wb");

	//Check if their aren't problems.
	if(f){
	//Close the file.
	fclose(f);
	}else{
	//Let the currentState render once to prevent multiple GUI overlapping and prevent the screen from going black.
	currentState->render();

	//The file can't be opened so tell the user.
	msgBox(tfm::format(_("Can't open file %s."),s),MsgBoxOKOnly,_("Error"));
	return;
	}
	}
	}else if(verifyFile && files){
	//We need to verify a file for opening.
	FILE *f;
	f=fopen(processFileName(s).c_str(),"rb");

	//Check if it didn't fail.
	if(f){
	//Succes, so close the file.
	fclose(f);
	}else{
	//Let the currentState render once to prevent multiple GUI overlapping and prevent the screen from going black.
	currentState->render();

	//Unable to open file so tell the user.
	- msgBox(tfm::format(_("Can't open file %d."),s),MsgBoxOKOnly,_("Error"));
	+ msgBox(tfm::format(_("Can't open file %s."),s),MsgBoxOKOnly,_("Error"));
	return;
	}
	}

	//If we haven't returned then it's fine.
	//Set the fileName to the chosen file.
	fileName=s;

	//Delete the GUI.
	if(GUIObjectRoot){
	delete GUIObjectRoot;
	GUIObjectRoot=NULL;
	}

	//Set return to true.
	ret=true;
	}else if(name=="cmdCancel"){
	//Cancel means we can kill the gui.
	if(GUIObjectRoot){
	delete GUIObjectRoot;
	GUIObjectRoot=NULL;
	}
	}else if(name=="lstFile"){
	//Get a pointer to the listbox.
	GUIListBox* obj1=lstFile;

	//Make sure the option exist and change textfield to it.
	if(obj1!=NULL && txtName!=NULL && obj1->value>=0 && obj1->value<(int)obj1->item.size()){
	txtName->caption=obj1->item[obj1->value];
	}
	}else if(name=="lstSearchIn"){
	//Get the searchpath listbox.
	GUISingleLineListBox obj1=dynamic_cast<GUISingleLineListBox>(obj);

	//Check if the entry exists.
	if(obj1!=NULL && lstFile!=NULL && obj1->value>=0 && obj1->value<(int)searchPath.size()){
	//Temp string.
	string s;

	//Get the new search path.
	path=searchPath[obj1->value];

	//Make sure it isn't empty.
	if(!path.empty()){
	//Process the filename.
	s=processFileName(path);
	}else{
	//It's empty so we give the userpath.
	s=getUserPath();
	}

	//Fill the list with files or directories.
	if(files) {
	lstFile->item=enumAllFiles(s,extension);
	}else
	lstFile->item=enumAllDirs(s);

	//Remove any selection from the list.
	lstFile->value=-1;
	}
	}
	}
	};

	bool fileDialog(string& fileName,const char* title,const char* extension,const char* path,bool isSave,bool verifyFile,bool files){
	//Pointer to GUIObject to make the GUI with.
	GUIObject* obj;
	//Pointer to the current GUIObjectRoot.
	//We keep it so we can put it back after closing the fileDialog.
	GUIObject* tmp=GUIObjectRoot;

	//Create the fileDialogHandler, used for event handling.
	fileDialogHandler objHandler(isSave,verifyFile,files);
	//Vector containing the pathNames.
	vector<string> pathNames;

	//Set the extension of the objHandler.
	objHandler.extension=extension;

	//We now need to splits the given path into multiple path names.
	if(path && path[0]){
	//The string isn't empty.
	//Pointer to the paths string.
	char* lp=(char*)path;
	//Pointer to the first newline.
	char* lps=strchr(lp,'\n');
	//Pointer used for checking if their's another newline.
	//It will indicate if it's the last set or not.
	char* lpe;

	//Check for a newline.
	if(lps){
	//We have newline(s) so loop forever.
	//We can only break out of the loop when the string ends.
	for(;;){
	//Add the first searchpath.
	//This is the beginning of the string (lp) to the first newline. (lps)
	objHandler.searchPath.push_back(string(lp,lps-lp));

	//We should have another newline so search for it.
	lpe=strchr(lps+1,'\n');
	if(lpe){
	//We found it so we add that to the pathname.
	pathNames.push_back(string(lps+1,lpe-lps-1));
	//And start over again by setting lp to the start of a new set of searchPath/pathName.
	lp=lpe+1;
	}else{
	//There is no newline anymore, meaning the last entry, the rest of the string must be the pathName.
	pathNames.push_back(string(lps+1));
	//And break out of the loop.
	break;
	}

	//We haven't broken out so search for a newline.
	lps=strchr(lp,'\n');
	//If there isn't a newline break.
	if(!lps)
	break;
	}
	}else{
	//There is no newline thus the whole string is the searchPath.
	objHandler.searchPath.push_back(path);
	}
	}else{
	//Empty so put an empty string as searchPath.
	objHandler.searchPath.push_back(string());
	}

	//It's time to create the GUI.
	//If there are more than one pathNames we need to add a GUISingleLineListBox.
	int base_y=pathNames.size()>0?60:20;

	//Create the frame.
	GUIObjectRoot=new GUIObject(100,100-base_y/2,600,400+base_y,GUIObjectFrame,title?title:(isSave?_("Save File"):_("Load File")));

	//Create the search path list box if needed.
	if(pathNames.size()>0){
	GUIObjectRoot->childControls.push_back(new GUIObject(8,40,184,36,GUIObjectLabel,_("Search In")));
	GUISingleLineListBox* obj1=new GUISingleLineListBox(160,40,432,36);
	obj1->item=pathNames;
	obj1->value=0;
	obj1->name="lstSearchIn";
	obj1->eventCallback=&objHandler;
	GUIObjectRoot->childControls.push_back(obj1);
	}

	//Add the FileName label and textfield.
	GUIObjectRoot->childControls.push_back(new GUIObject(8,20+base_y,184,36,GUIObjectLabel,_("File Name")));
	{
	//Fill the textbox with the given fileName.
	string s=fileName;

	if(!isSave){
	//But only if it isn't empty.
	if(s.empty() && extension && extension[0])
	s=string("*.")+string(extension);
	}

	//Create the textbox and add it to the GUI.
	objHandler.txtName=new GUIObject(160,20+base_y,432,36,GUIObjectTextBox,s.c_str());
	GUIObjectRoot->childControls.push_back(objHandler.txtName);
	}

	//Now we add the ListBox containing the files or directories.
	{
	GUIListBox* obj1=new GUIListBox(8,60+base_y,584,292);

	//Get the searchPath.
	string s=objHandler.searchPath[0];
	//Make sure it isn't empty.
	if(!s.empty()){
	objHandler.path=s;
	s=processFileName(s);
	}else{
	s=getUserPath();
	}

	//Check if we should list files or directories.
	if(files){
	//Fill the list with files.
	obj1->item=enumAllFiles(s,extension);
	}else{
	//Fill the list with directories.
	obj1->item=enumAllDirs(s);
	}
	obj1->name="lstFile";
	obj1->eventCallback=&objHandler;
	GUIObjectRoot->childControls.push_back(obj1);
	objHandler.lstFile=obj1;
	}

	//Now create the OK and Cancel buttons.
	obj=new GUIObject(200,360+base_y,192,36,GUIObjectButton,_("OK"));
	obj->name="cmdOK";
	obj->eventCallback=&objHandler;
	GUIObjectRoot->childControls.push_back(obj);
	obj=new GUIObject(400,360+base_y,192,36,GUIObjectButton,_("Cancel"));
	obj->name="cmdCancel";
	obj->eventCallback=&objHandler;
	GUIObjectRoot->childControls.push_back(obj);

	//Now we keep rendering and updating the GUI.
	SDL_FillRect(tempSurface,NULL,0);
	SDL_SetAlpha(tempSurface,SDL_SRCALPHA,155);
	SDL_BlitSurface(tempSurface,NULL,screen,NULL);
	while(GUIObjectRoot){
	while(SDL_PollEvent(&event))
	GUIObjectHandleEvents(true);
	if(GUIObjectRoot)
	GUIObjectRoot->render();
	flipScreen();
	SDL_Delay(30);
	}

	//The while loop ended meaning we can restore the previous GUI.
	GUIObjectRoot=tmp;

	//Now determine what the return value is (and if there is one).
	if(objHandler.ret)
	fileName=objHandler.fileName;
	return objHandler.ret;
	}
	diff --git a/src/Game.cpp b/src/Game.cpp
	index 9d66d41..8b5c895 100644
	--- a/src/Game.cpp
	+++ b/src/Game.cpp
	@@ -1,1144 +1,1193 @@
	/****************************************************************************
	** Copyright (C) 2011 Luka Horvat <redreaper132 at gmail.com>
	** Copyright (C) 2011 Edward Lii <edward_iii at myway.com>
	** Copyright (C) 2011 O. Bahri Gordebak <gordebak at gmail.com>
	**
	**
	** This file may be used under the terms of the GNU General Public
	** License version 3.0 as published by the Free Software Foundation
	** and appearing in the file LICENSE.GPL included in the packaging of
	** this file.
	**
	** This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
	** WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
	**
	** You should have received a copy of the GNU General Public License
	** along with this program. If not, see <http://www.gnu.org/licenses/>.
	**
	****************************************************************************/
	#include "GameState.h"
	#include "Globals.h"
	#include "Functions.h"
	#include "FileManager.h"
	#include "GameObjects.h"
	#include "ThemeManager.h"
	#include "Objects.h"
	#include "Game.h"
	#include "TreeStorageNode.h"
	#include "POASerializer.h"
	#include "InputManager.h"
	#include <fstream>
	#include <iostream>
	#include <sstream>
	#include <vector>
	#include <map>
	+#include <algorithm>
	+#include <locale>
	#include <stdio.h>
	#include <stdlib.h>
	#include <string.h>

	#include "libs/tinyformat/tinyformat.h"

	using namespace std;

	const char* Game::blockName[TYPE_MAX]={"Block","PlayerStart","ShadowStart",
	"Exit","ShadowBlock","Spikes",
	"Checkpoint","Swap","Fragile",
	"MovingBlock","MovingShadowBlock","MovingSpikes",
	"Teleporter","Button","Switch",
	"ConveyorBelt","ShadowConveyorBelt","NotificationBlock",
	};

	map<string,int> Game::blockNameMap;
	string Game::recordFile;

	Game::Game(bool loadLevel):isReset(false)
	,currentLevelNode(NULL)
	,customTheme(NULL)
	,background(NULL)
	,won(false)
	,interlevel(false)
	,gameTipIndex(0)
	,time(0),timeSaved(0)
	,recordings(0),recordingsSaved(0)
	,shadowCam(false)
	,player(this),shadow(this),objLastCheckPoint(NULL){

	//Reserve the memory for the GameObject tips.
	memset(bmTips,0,sizeof(bmTips));

	action=loadImage(getDataPath()+"gfx/actions.png");
	medals=loadImage(getDataPath()+"gfx/medals.png");

	//Check if we should load record file.
	if(!recordFile.empty()){
	loadRecord(recordFile.c_str());
	recordFile.clear();
	return;
	}

	//If we should load the level then load it.
	if(loadLevel){
	this->loadLevel(levels->getLevelpackPath()+levels->getLevelFile());
	levels->saveLevelProgress();
	}
	}

	Game::~Game(){
	//Simply call our destroy method.
	destroy();
	}

	void Game::destroy(){
	//Loop through the levelObjects and delete them.
	for(unsigned int i=0;i<levelObjects.size();i++)
	delete levelObjects[i];
	//Done now clear the levelObjects vector.
	levelObjects.clear();

	//Clear the name and the editor data.
	levelName.clear();
	levelFile.clear();
	editorData.clear();

	//Loop through the tips.
	for(int i=0;i<TYPE_MAX;i++){
	//If it exist free the SDL_Surface.
	if(bmTips[i])
	SDL_FreeSurface(bmTips[i]);
	}
	memset(bmTips,0,sizeof(bmTips));

	//Remove everything from the themeManager.
	background=NULL;
	if(customTheme)
	objThemes.removeTheme();
	customTheme=NULL;

	//delete current level (if any)
	if(currentLevelNode){
	delete currentLevelNode;
	currentLevelNode=NULL;
	}

	//Reset the time.
	time=timeSaved=0;
	recordings=recordingsSaved=0;
	}

	void Game::loadLevelFromNode(TreeStorageNode* obj,const string& fileName){
	//Make sure there's nothing left from any previous levels.
	destroy();

	//set current level to loaded one.
	currentLevelNode=obj;

	//Temp var used for block locations.
	SDL_Rect box;

	//Set the level dimensions to the default, it will probably be changed by the editorData,
	//but 800x600 is a fallback.
	LEVEL_WIDTH=800;
	LEVEL_HEIGHT=600;

	//Load the additional data.
	for(map<string,vector<string> >::iterator i=obj->attributes.begin();i!=obj->attributes.end();i++){
	if(i->first=="size"){
	//We found the size attribute.
	if(i->second.size()>=2){
	//Set the dimensions of the level.
	LEVEL_WIDTH=atoi(i->second[0].c_str());
	LEVEL_HEIGHT=atoi(i->second[1].c_str());
	}
	}else if(i->second.size()>0){
	//Any other data will be put into the editorData.
	editorData[i->first]=i->second[0];
	}
	}

	//Get the theme.
	{
	//If a theme is configured then load it.
	string theme=processFileName(getSettings()->getValue("theme"));

	//Check if it isn't the default theme, because if it is it's already loaded.
	if(fileNameFromPath(theme)!="Cloudscape") {
	customTheme=objThemes.appendThemeFromFile(theme+"/theme.mnmstheme");
	}

	//Check if level themes are enabled.
	if(getSettings()->getBoolValue("leveltheme")) {
	string &s=editorData["theme"];
	if(!s.empty()){
	customTheme=objThemes.appendThemeFromFile(processFileName(theme)+"/theme.mnmstheme");
	}
	}

	//Set the Appearance of the player and the shadow.
	objThemes.getCharacter(false)->createInstance(&player.appearance);
	objThemes.getCharacter(true)->createInstance(&shadow.appearance);
	}


	for(unsigned int i=0;i<obj->subNodes.size();i++){
	TreeStorageNode* obj1=obj->subNodes[i];
	if(obj1==NULL) continue;
	if(obj1->name=="tile" && obj1->value.size()>=3){
	int objectType=blockNameMap[obj1->value[0]];

	box.x=atoi(obj1->value[1].c_str());
	box.y=atoi(obj1->value[2].c_str());

	map<string,string> obj;

	for(map<string,vector<string> >::iterator i=obj1->attributes.begin();i!=obj1->attributes.end();i++){
	if(i->second.size()>0) obj[i->first]=i->second[0];
	}

	levelObjects.push_back( new Block ( box.x, box.y, objectType, this) );
	levelObjects.back()->setEditorData(obj);
	}
	}

	//Set the levelName to the name of the current level.
	levelName=editorData["name"];
	levelFile=fileName;

	//Some extra stuff only needed when not in the levelEditor.
	if(stateID!=STATE_LEVEL_EDITOR){
	//We create a text with the text "Level <levelno> <levelName>".
	//It will be shown in the left bottom corner of the screen.
	string s;
	if (levels->getLevelCount()>1){
	s=tfm::format(_("Level %d %s"),levels->getCurrentLevel()+1,editorData["name"]);
	}

	SDL_Color fg={0,0,0,0};
	SDL_Color bg={255,255,255,0};
	bmTips[0]=TTF_RenderUTF8_Shaded(fontText,s.c_str(),fg,bg);
	if(bmTips[0])
	SDL_SetAlpha(bmTips[0],SDL_SRCALPHA,160);
	}

	//Get the background
	background=objThemes.getBackground();
	if(background)
	background->resetAnimation(true);
	}

	void Game::loadLevel(string fileName){
	//Create a TreeStorageNode that will hold the loaded data.
	TreeStorageNode *obj=new TreeStorageNode();
	{
	POASerializer objSerializer;
	string s=fileName;

	//Parse the file.
	if(!objSerializer.loadNodeFromFile(s.c_str(),obj,true)){
	cout<<"Can't load level file "<<s<<endl;
	delete obj;
	return;
	}
	}

	//Now call another function.
	loadLevelFromNode(obj,fileName);
	}

	void Game::saveRecord(const char* fileName){
	//check if current level is NULL (which should be impossible)
	if(currentLevelNode==NULL) return;

	TreeStorageNode obj;
	POASerializer objSerializer;

	//put current level to the node.
	currentLevelNode->name="map";
	obj.subNodes.push_back(currentLevelNode);

	//serialize the game record using RLE compression.
	#define PUSH_BACK \
	if(j>0){ \
	if(j>1){ \
	sprintf(c,"%d*%d",last,j); \
	}else{ \
	sprintf(c,"%d",last); \
	} \
	v.push_back(c); \
	}
	vector<string> &v=obj.attributes["record"];
	vector<int> *record=player.getRecord();
	char c[64];
	int i,j=0,last;
	for(i=0;i<(int)record->size();i++){
	int currentKey=(*record)[i];
	if(j==0 \|\| currentKey!=last){
	PUSH_BACK;
	last=currentKey;
	j=1;
	}else{
	j++;
	}
	}
	PUSH_BACK;
	#undef PUSH_BACK

	#ifdef RECORD_FILE_DEBUG
	//add record file debug data.
	{
	obj.attributes["recordKeyPressLog"].push_back(player.keyPressLog());

	vector<SDL_Rect> &playerPosition=player.playerPosition();
	string s;
	char c[32];

	sprintf(c,"%d\n",int(playerPosition.size()));
	s=c;

	for(unsigned int i=0;i<playerPosition.size();i++){
	SDL_Rect& r=playerPosition[i];
	sprintf(c,"%d %d\n",r.x,r.y);
	s+=c;
	}

	obj.attributes["recordPlayerPosition"].push_back(s);
	}
	#endif

	//save it
	objSerializer.saveNodeToFile(fileName,&obj,true,true);

	//remove current level from node to prevent delete it.
	obj.subNodes.clear();
	}

	void Game::loadRecord(const char* fileName){
	//Create a TreeStorageNode that will hold the loaded data.
	TreeStorageNode obj;
	{
	POASerializer objSerializer;
	string s=fileName;

	//Parse the file.
	if(!objSerializer.loadNodeFromFile(s.c_str(),&obj,true)){
	cout<<"Can't load record file "<<s<<endl;
	return;
	}
	}

	//find the node named 'map'.
	bool loaded=false;
	for(unsigned int i=0;i<obj.subNodes.size();i++){
	if(obj.subNodes[i]->name=="map"){
	//load the level. (fileName=???)
	loadLevelFromNode(obj.subNodes[i],"???");
	//remove this node to prevent delete it.
	obj.subNodes[i]=NULL;
	//over
	loaded=true;
	break;
	}
	}

	if(!loaded){
	cout<<"ERROR: Can't find subnode named 'map' from record file"<<endl;
	return;
	}

	//load the record.
	{
	vector<int> *record=player.getRecord();
	record->clear();
	vector<string> &v=obj.attributes["record"];
	for(unsigned int i=0;i<v.size();i++){
	string &s=v[i];
	string::size_type pos=s.find_first_of('*');
	if(pos==string::npos){
	//1 item only.
	int i=atoi(s.c_str());
	record->push_back(i);
	}else{
	//contains many items.
	int i=atoi(s.substr(0,pos).c_str());
	int j=atoi(s.substr(pos+1).c_str());
	for(;j>0;j--){
	record->push_back(i);
	}
	}
	}
	}

	#ifdef RECORD_FILE_DEBUG
	//load the debug data
	{
	vector<string> &v=obj.attributes["recordPlayerPosition"];
	vector<SDL_Rect> &playerPosition=player.playerPosition();
	playerPosition.clear();
	if(!v.empty()){
	if(!v[0].empty()){
	stringstream st(v[0]);
	int m;
	st>>m;
	for(int i=0;i<m;i++){
	SDL_Rect r;
	st>>r.x>>r.y;
	r.w=0;
	r.h=0;
	playerPosition.push_back(r);
	}
	}
	}
	}
	#endif

	//play the record.
	//TODO: tell the level manager don't save the level progress.
	player.playRecord();
	shadow.playRecord(); //???
	}

	/////////////EVENT///////////////
	void Game::handleEvents(){
	//First of all let the player handle input.
	player.handleInput(&shadow);

	//Check for an SDL_QUIT event.
	if(event.type==SDL_QUIT){
	//We need to quit so enter STATE_EXIT.
	setNextState(STATE_EXIT);
	}

	//Check for the escape key.
	if(inputMgr.isKeyUpEvent(INPUTMGR_ESCAPE)){
	//Escape means we go one level up, to the level select state.
	setNextState(STATE_LEVEL_SELECT);
	//Save the progress.
	levels->saveLevelProgress();

	//And change the music back to the menu music.
	getMusicManager()->playMusic("menu");
	}

	//Check if 'r' is pressed.
	if(inputMgr.isKeyDownEvent(INPUTMGR_RESTART)){
	//Check if it isn't a replay.
	if(!player.isPlayFromRecord()){
	//Set reset true.
	isReset=true;
	}else if(interlevel){
	//We can also reset during the inter level screen.
	if(GUIObjectRoot){
	delete GUIObjectRoot;
	GUIObjectRoot=NULL;
	}

	isReset=true;
	}
	}

	//Check for the next level buttons when in the interlevel popup.
	if(inputMgr.isKeyDownEvent(INPUTMGR_SPACE) \|\| (event.type==SDL_KEYDOWN && (event.key.keysym.sym==SDLK_RETURN \|\| event.key.keysym.sym==SDLK_RCTRL))){
	if(interlevel){
	//The interlevel popup is shown so we need to delete it.
	if(GUIObjectRoot){
	delete GUIObjectRoot;
	GUIObjectRoot=NULL;
	}

	//Now goto the next level.
	gotoNextLevel();
	}
	}

	//Check if tab is pressed.
	if(inputMgr.isKeyDownEvent(INPUTMGR_TAB)){
	shadowCam=!shadowCam;
	}
	}

	/////////////////LOGIC///////////////////
	void Game::logic(){
	//Add one tick to the time.
	time++;

	//Let the player store his move, if recording.
	player.shadowSetState();
	//Let the player give his recording to the shadow, if configured.
	player.shadowGiveState(&shadow);
	//Let the player jump.
	player.jump();
	//Let him move.
	player.move(levelObjects);
	//And let the camera follow him.
	if(!shadowCam){
	player.setMyCamera();
	}else{
	shadow.setMyCamera();
	}

	//Now let the shadow decide his move, if he's playing a recording.
	shadow.moveLogic();
	//Let the shadow jump.
	shadow.jump();
	//Let the shadow move.
	shadow.move(levelObjects);

	//Some levelObjects can move so update them.
	for(unsigned int i=0;i<levelObjects.size();i++){
	levelObjects[i]->move();
	}

	//Process any event in the queue.
	for(unsigned int idx=0;idx<eventQueue.size();idx++){
	//Get the event from the queue.
	typeGameObjectEvent &e=eventQueue[idx];

	//Check if the it has an id attached to it.
	if(e.flags\|1){
	//Loop through the levelObjects and give them the event if they have the right id.
	for(unsigned int i=0;i<levelObjects.size();i++){
	if(e.objectType<0 \|\| levelObjects[i]->type==e.objectType){
	Block obj=dynamic_cast<Block>(levelObjects[i]);
	if(obj!=NULL && obj->id==e.id){
	levelObjects[i]->onEvent(e.eventType);
	}
	}
	}
	}else{
	//Loop through the levelObjects and give them the event.
	for(unsigned int i=0;i<levelObjects.size();i++){
	if(e.objectType<0 \|\| levelObjects[i]->type==e.objectType){
	levelObjects[i]->onEvent(e.eventType);
	}
	}
	}
	}
	//Done processing the events so clear the queue.
	eventQueue.clear();

	//Check collision and stuff for the shadow and player.
	player.otherCheck(&shadow);

	//Check if we won.
	if(won){
	//the string to store auto-save record path.
	string bestTimeFilePath,bestRecordingFilePath;
	//and if we can't get test path.
	bool filePathError=false;

	//Set the current level won.
	levels->getLevel()->won=true;
	if(levels->getLevel()->time==-1 \|\| levels->getLevel()->time>time){
	levels->getLevel()->time=time;
	//save the best-time game record.
	if(bestTimeFilePath.empty()){
	getCurrentLevelAutoSaveRecordPath(bestTimeFilePath,bestRecordingFilePath,true);
	}
	if(bestTimeFilePath.empty()){
	cout<<"ERROR: Couldn't get auto-save record file path"<<endl;
	filePathError=true;
	}else{
	saveRecord(bestTimeFilePath.c_str());
	}
	}
	if(levels->getLevel()->recordings==-1 \|\| levels->getLevel()->recordings>recordings){
	levels->getLevel()->recordings=recordings;
	//save the best-recordings game record.
	if(bestRecordingFilePath.empty() && !filePathError){
	getCurrentLevelAutoSaveRecordPath(bestTimeFilePath,bestRecordingFilePath,true);
	}
	if(bestRecordingFilePath.empty()){
	cout<<"ERROR: Couldn't get auto-save record file path"<<endl;
	filePathError=true;
	}else{
	saveRecord(bestRecordingFilePath.c_str());
	}
	}

	//Set the next level unlocked if it exists.
	if(levels->getCurrentLevel()+1<levels->getLevelCount()){
	levels->setLocked(levels->getCurrentLevel()+1);
	}
	//And save the progress.
	levels->saveLevelProgress();

	//Now go to the interlevel screen.
	replayPlay();

	//NOTE: We set isReset false to prevent the user from getting a best time of 0.00s and 0 recordings.
	}
	won=false;

	//Check if we should reset.
	if(isReset)
	reset(false);
	isReset=false;
	}

	/////////////////RENDER//////////////////
	void Game::render(){
	//First of all render the background.
	{
	//Get a pointer to the background.
	ThemeBackground* bg=background;

	//Check if the background is null, but there are themes.
	if(bg==NULL && objThemes.themeCount()>0){
	//Get the background from the first theme in the stack.
	bg=objThemes[0]->getBackground();
	}

	//Check if the background isn't null.
	if(bg){
	//It isn't so draw it.
	bg->draw(screen);

	//And if it's the loaded background then also update the animation.
	//FIXME: Updating the animation in the render method?
	if(bg==background)
	bg->updateAnimation();
	}else{
	//There's no background so fill the screen with white.
	SDL_Rect r={0,0,SCREEN_WIDTH,SCREEN_HEIGHT};
	SDL_FillRect(screen,&r,-1);
	}
	}

	//Now we draw the levelObjects.
	for(unsigned int o=0; o<levelObjects.size(); o++){
	levelObjects[o]->show();
	}

	//Followed by the player and the shadow.
	player.show();
	shadow.show();

	//Show the levelName if it isn't the level editor.
	if(stateID!=STATE_LEVEL_EDITOR && bmTips[0]!=NULL && !interlevel){
	applySurface(0,SCREEN_HEIGHT-bmTips[0]->h,bmTips[0],screen,NULL);
	}

	//Check if there's a tooltip.
	//NOTE: gameTipIndex 0 is used for the levelName, 1 for shadow death, 2 for restart text, 3 for restart+checkpoint.
	if(gameTipIndex>3 && gameTipIndex<TYPE_MAX){
	//Check if there's a tooltip for the type.
	if(bmTips[gameTipIndex]==NULL){
	//There isn't thus make it.
	const char* s=NULL;
	+ string keyCode=inputMgr.getKeyCodeName(inputMgr.getKeyCode(INPUTMGR_ACTION,false));
	+ transform(keyCode.begin(),keyCode.end(),keyCode.begin(),::toupper);
	switch(gameTipIndex){
	case TYPE_CHECKPOINT:
	- s="Press DOWN key to save the game.";
	+ /// TRANSLATORS: Please do not remove %s from your translation:
	+ /// - %s will be replaced with current action key
	+ s=tfm::format(_("Press %s key to save the game."),keyCode).c_str();
	break;
	case TYPE_SWAP:
	- s="Press DOWN key to swap the position of player and shadow.";
	+ /// TRANSLATORS: Please do not remove %s from your translation:
	+ /// - %s will be replaced with current action key
	+ s=tfm::format("Press %s key to swap the position of player and shadow.",keyCode).c_str();
	break;
	case TYPE_SWITCH:
	- s="Press DOWN key to activate the switch.";
	+ /// TRANSLATORS: Please do not remove %s from your translation:
	+ /// - %s will be replaced with current action key
	+ s=tfm::format("Press %s key to activate the switch.",keyCode).c_str();
	break;
	case TYPE_PORTAL:
	- s="Press DOWN key to teleport.";
	+ /// TRANSLATORS: Please do not remove %s from your translation:
	+ /// - %s will be replaced with current action key
	+ s=tfm::format("Press %s key to teleport.",keyCode).c_str();
	break;
	}

	//If we have a string then it's a supported GameObject type.
	if(s!=NULL){
	SDL_Color fg={0,0,0,0},bg={255,255,255,0};
	bmTips[gameTipIndex]=TTF_RenderUTF8_Shaded(fontText,s,fg,bg);
	SDL_SetAlpha(bmTips[gameTipIndex],SDL_SRCALPHA,160);
	}
	}

	//We already have a gameTip for this type so draw it.
	if(bmTips[gameTipIndex]!=NULL){
	applySurface(0,0,bmTips[gameTipIndex],screen,NULL);
	}
	}
	//Set the gameTip to 0.
	gameTipIndex=0;

	//Pointer to the sdl surface that will contain a message, if any.
	SDL_Surface* bm=NULL;

	//Check if the player is dead, meaning we draw a message.
	if(player.dead){
	+ //Get user configured restart key
	+ string keyCodeRestart=inputMgr.getKeyCodeName(inputMgr.getKeyCode(INPUTMGR_RESTART,false));
	+ transform(keyCodeRestart.begin(),keyCodeRestart.end(),keyCodeRestart.begin(),::toupper);
	//The player is dead, check if there's a state that can be loaded.
	if(player.canLoadState()){
	//Now check if the tip is already made, if not make it.
	if(bmTips[3]==NULL){
	+ //Get user defined key for loading checkpoint
	+ string keyCodeLoad=inputMgr.getKeyCodeName(inputMgr.getKeyCode(INPUTMGR_LOAD,false));
	+ transform(keyCodeLoad.begin(),keyCodeLoad.end(),keyCodeLoad.begin(),::toupper);
	+ //Draw string
	SDL_Color fg={0,0,0,0},bg={255,255,255,0};
	bmTips[3]=TTF_RenderUTF8_Shaded(fontText,
	- "Press R to restart current level or press F3 to load the game.",
	+ /// TRANSLATORS: Please do not remove %s from your translation:
	+ /// - first %s means currently configured key to restart game
	+ /// - Second %s means configured key to load from last save
	+ tfm::format(_("Press %s to restart current level or press %s to load the game."),
	+ keyCodeRestart,keyCodeLoad).c_str(),
	fg,bg);
	SDL_SetAlpha(bmTips[3],SDL_SRCALPHA,160);
	}
	bm=bmTips[3];
	}else{
	//Now check if the tip is already made, if not make it.
	if(bmTips[2]==NULL){
	SDL_Color fg={0,0,0,0},bg={255,255,255,0};
	bmTips[2]=TTF_RenderUTF8_Shaded(fontText,
	- "Press R to restart current level.",
	+ /// TRANSLATORS: Please do not remove %s from your translation:
	+ /// - %s will be replaced with currently configured key to restart game
	+ tfm::format(_("Press %s to restart current level."),keyCodeRestart).c_str(),
	fg,bg);
	SDL_SetAlpha(bmTips[2],SDL_SRCALPHA,160);
	}
	bm=bmTips[2];
	}
	}

	//Check if the shadow has died (and there's no other notification).
	//NOTE: We use the shadow's jumptime as countdown, this variable isn't used when the shadow is dead.
	if(shadow.dead && bm==NULL && shadow.jumpTime>0){
	//Now check if the tip is already made, if not make it.
	if(bmTips[1]==NULL){
	SDL_Color fg={0,0,0,0},bg={255,255,255,0};
	bmTips[1]=TTF_RenderUTF8_Shaded(fontText,
	_("Your shadow has died."),
	fg,bg);
	SDL_SetAlpha(bmTips[1],SDL_SRCALPHA,160);
	}
	bm=bmTips[1];

	//NOTE: Logic in the render loop, we substract the shadow's jumptime by one.
	shadow.jumpTime--;
	}

	//Draw the tip.
	if(bm!=NULL)
	applySurface(0,0,bm,screen,NULL);

	//show time and records used in level editor.
	if(stateID==STATE_LEVEL_EDITOR && time>0){
	SDL_Color fg={0,0,0,0},bg={255,255,255,0};
	SDL_Surface *bm;
	int y=SCREEN_HEIGHT;

	bm=TTF_RenderUTF8_Shaded(fontText,tfm::format(_("%d recordings"),recordings).c_str(),fg,bg);
	SDL_SetAlpha(bm,SDL_SRCALPHA,160);
	y-=bm->h;
	applySurface(0,y,bm,screen,NULL);
	SDL_FreeSurface(bm);

	char c[32];
	sprintf(c,"%-.2fs",time/40.0f);
	bm=TTF_RenderUTF8_Shaded(fontText,c,fg,bg);
	SDL_SetAlpha(bm,SDL_SRCALPHA,160);
	y-=bm->h;
	applySurface(0,y,bm,screen,NULL);
	SDL_FreeSurface(bm);
	}

	//Draw the current action in the upper right corner.
	if(player.record){
	applySurface(SCREEN_WIDTH-50,0,action,screen,NULL);
	}else if(shadow.state!=0){
	SDL_Rect r={50,0,50,50};
	applySurface(SCREEN_WIDTH-50,0,action,screen,&r);
	}

	//if the game is play from record then draw something indicates it
	if(player.isPlayFromRecord()){
	//Dim the screen if interlevel is true.
	if(interlevel){
	SDL_BlitSurface(screen,NULL,tempSurface,NULL);
	SDL_FillRect(screen,NULL,0);
	SDL_SetAlpha(tempSurface, SDL_SRCALPHA,220);
	SDL_BlitSurface(tempSurface,NULL,screen,NULL);

	//Check if the GUI isn't null.
	if(GUIObjectRoot){
	//==Create first box==

	//Create the title
	SDL_Color black={0,0,0,0};
	SDL_Rect r;
	+ /// TRANSLATORS: This is caption for finished level
	SDL_Surface* bm=TTF_RenderUTF8_Blended(fontGUI,_("You've finished:"),black);

	//Recreate the level string.
	string s;
	if (levels->getLevelCount()>0){
	+ /// TRANSLATORS: Please do not remove %s or %d from your translation:
	+ /// - %d means the level number in a levelpack
	+ /// - %s means the name of current level
	s=tfm::format(_("Level %d %s"),levels->getCurrentLevel()+1,levelName);
	}

	SDL_Surface* bm2=TTF_RenderUTF8_Blended(fontText,s.c_str(),black);

	//Now draw the first gui box so that it's bigger than longer text.
	int width;
	if(bm->w>bm2->w)
	width=bm->w+32;
	else
	width=bm2->w+32;
	drawGUIBox((SCREEN_WIDTH-width)/2,4,width,68,screen,0xDDDDDDA1);

	// Now draw title.
	r.x=(SCREEN_WIDTH-bm->w)/2;
	r.y=8;
	SDL_BlitSurface(bm,NULL,screen,&r);

	// And then level name.
	r.x=(SCREEN_WIDTH-bm2->w)/2;
	r.y=44;
	SDL_BlitSurface(bm2,NULL,screen,&r);

	//Free drawed texts
	SDL_FreeSurface(bm);
	SDL_FreeSurface(bm2);

	//==Create second box==

	//Now draw the second gui box.
	drawGUIBox(GUIObjectRoot->left,GUIObjectRoot->top,GUIObjectRoot->width,GUIObjectRoot->height,screen,0xDDDDDDA1);

	//Draw the medal.
	int medal=GUIObjectRoot->value;
	r.x=(medal-1)*30;
	r.y=0;
	r.w=30;
	r.h=30;
	applySurface(GUIObjectRoot->left+16,GUIObjectRoot->top+92,medals,screen,&r);
	applySurface(GUIObjectRoot->left+370,GUIObjectRoot->top+92,medals,screen,&r);
	}
	}else if((time & 0x10)==0x10){
	SDL_Rect r={50,0,50,50};
	applySurface(0,0,action,screen,&r);
	applySurface(0,SCREEN_HEIGHT-50,action,screen,&r);
	applySurface(SCREEN_WIDTH-50,SCREEN_HEIGHT-50,action,screen,&r);
	}
	}else if(player.objNotificationBlock){
	//If the player is in front of a notification block show the message.
	//And it isn't a replay.
	std::vector<char> string_data((dynamic_cast<Block>(player.objNotificationBlock))->message.begin(), (dynamic_cast<Block>(player.objNotificationBlock))->message.end());
	string_data.push_back('\0');

	int y = 20;
	vector<SDL_Surface*> lines;

	//Now process the prompt.
	{
	//Pointer to the string.
	char* lps=&string_data[0];
	//Pointer to a character.
	char* lp=NULL;

	//We keep looping forever.
	//The only way out is with the break statement.
	for(;;){
	//As long as it's still the same sentence we continue.
	//It will stop when there's a newline or end of line.
	for(lp=lps;lp!='\n'&&lp!='\r'&&*lp!=0;lp++);

	//Store the character we stopped on. (End or newline)
	char c=*lp;
	//Set the character in the string to 0, making lps a string containing one sentence.
	*lp=0;

	//Integer used to center the sentence horizontally.
	int x;
	TTF_SizeText(fontText,lps,&x,NULL);
	x=(SCREEN_WIDTH-200-x)/2;

	//Color the text will be: black.
	SDL_Color black={0,0,0,0};
	lines.push_back(TTF_RenderUTF8_Blended(fontText,lps,black));
	//Increase y with 25, about the height of the text.
	y+=25;

	//Check the stored character if it was a stop.
	if(c==0){
	//It was so break out of the for loop.
	lps=lp;
	break;
	}
	//It wasn't meaning more will follow.
	//We set lps to point after the "newline" forming a new string.
	lps=lp+1;
	}
	}
	drawGUIBox(100,SCREEN_HEIGHT-y-25,SCREEN_WIDTH-200,y+20,screen,0xDDDDDDA1);
	while(!lines.empty()){
	SDL_Surface* bm=lines[0];

	if(bm!=NULL){
	applySurface(100+((SCREEN_WIDTH-200-bm->w)/2),SCREEN_HEIGHT-y,bm,screen,NULL);
	SDL_FreeSurface(bm);
	}

	y-=25;
	lines.erase(lines.begin());

	}
	}
	}

	void Game::replayPlay(){
	interlevel=true;

	//cout<<"Game::replayPlay()"<<endl;

	//Fix the bug that press "r" to restart a level just before finishing it
	//will cause inter-level popup appeares and the game restarts.
	//Now when the game is about to finish, we don't allow to restart.
	isReset=false;

	//Create the gui if it isn't already done.
	if(!GUIObjectRoot){
	GUIObjectRoot=new GUIObject((SCREEN_WIDTH-570)/2,SCREEN_HEIGHT-140,570,135,GUIObjectNone);
	//NOTE: We put the medal in the value of the GUIObjectRoot.

	//The different values.
	int bestTime=levels->getLevel()->time;
	int targetTime=levels->getLevel()->targetTime;
	int bestRecordings=levels->getLevel()->recordings;
	int targetRecordings=levels->getLevel()->targetRecordings;

	int medal=1;
	if(targetTime<0){
	medal=3;
	}else{
	if(targetTime<0 \|\| bestTime<=targetTime)
	medal++;
	if(targetRecordings<0 \|\| bestRecordings<=targetRecordings)
	medal++;
	}
	//Add it to the GUIObjectRoot.
	GUIObjectRoot->value=medal;

	//Create the labels with the time and best time.
	+ /// TRANSLATORS: Please do not remove %-.2f from your translation:
	+ /// - %-.2f means time in seconds
	+ /// - s is shortened form of a second. Try to keep it so.
	GUIObject* obj=new GUIObject(20,10,150,36,GUIObjectLabel,tfm::format(_("Time: %-.2fs"),time/40.0f).c_str());
	GUIObjectRoot->childControls.push_back(obj);

	+ /// TRANSLATORS: Please do not remove %-.2f from your translation:
	+ /// - %-.2f means time in seconds
	+ /// - s is shortened form of a second. Try to keep it so.
	obj=new GUIObject(20,34,150,36,GUIObjectLabel,tfm::format(_("Best time: %-.2fs"),bestTime/40.0f).c_str());
	GUIObjectRoot->childControls.push_back(obj);

	+ /// TRANSLATORS: Please do not remove %-.2f from your translation:
	+ /// - %-.2f means time in seconds
	+ /// - s is shortened form of a second. Try to keep it so.
	if(targetTime>=0){
	obj=new GUIObject(20,58,150,36,GUIObjectLabel,tfm::format(_("Target time: %-.2fs"),targetTime/40.0f).c_str());
	GUIObjectRoot->childControls.push_back(obj);
	}

	//Now the ones for the recordings.
	+ /// TRANSLATORS: Please do not remove %d from your translation:
	+ /// - %d means the number of recordings user has made
	obj=new GUIObject(210,10,150,36,GUIObjectLabel,tfm::format(_("Recordings: %d"),recordings).c_str());
	GUIObjectRoot->childControls.push_back(obj);

	+ /// TRANSLATORS: Please do not remove %d from your translation:
	+ /// - %d means the number of recordings user has made
	obj=new GUIObject(210,34,150,36,GUIObjectLabel,tfm::format(_("Best recordings: %d"),bestRecordings).c_str());
	GUIObjectRoot->childControls.push_back(obj);

	+ /// TRANSLATORS: Please do not remove %d from your translation:
	+ /// - %d means the number of recordings user has made
	if(targetRecordings>=0){
	obj=new GUIObject(210,58,150,36,GUIObjectLabel,tfm::format(_("Target recordings: %d"),targetRecordings).c_str());
	GUIObjectRoot->childControls.push_back(obj);
	}

	//The medal that is earned.
	+ /// TRANSLATORS: Please do not remove %s from your translation:
	+ /// - %s will be replaced with name of a prize medal (gold, silver or bronze)
	string s1=tfm::format(_("You earned the %s medal"),(medal>1)?(medal==3)?_("GOLD"):_("SILVER"):_("BRONZE"));
	obj=new GUIObject(48,92,150,36,GUIObjectLabel,s1.c_str());
	//Center it horizontally.
	int width;
	TTF_SizeText(fontText,s1.c_str(),&width,NULL);
	obj->width=width;
	obj->left=(416-width)/2;
	GUIObjectRoot->childControls.push_back(obj);

	//Create the three buttons, Menu, Restart, Next.
	+ /// TRANSLATORS: used as return to the level selector menu
	obj=new GUIObject(420,10,128,36,GUIObjectButton,_("Menu"));
	obj->name="cmdMenu";
	obj->eventCallback=this;
	GUIObjectRoot->childControls.push_back(obj);

	+ /// TRANSLATORS: used as restart level
	obj=new GUIObject(409,50,150,36,GUIObjectButton,_("Restart"));
	obj->name="cmdRestart";
	obj->eventCallback=this;
	GUIObjectRoot->childControls.push_back(obj);

	+ /// TRANSLATORS: used as next level
	obj=new GUIObject(420,90,128,36,GUIObjectButton,_("Next"));
	obj->name="cmdNext";
	obj->eventCallback=this;
	GUIObjectRoot->childControls.push_back(obj);
	}

	//We only need to reset a few things so we don't call reset().
	for(unsigned int i=0;i<levelObjects.size();i++){
	levelObjects[i]->reset(true);
	}
	//Also reset the background animation, if any.
	if(background)
	background->resetAnimation(true);

	//Make a copy of the playerButtons.
	vector<int> recordCopy=player.recordButton;
	player.reset(true);
	shadow.reset(true);
	player.recordButton=recordCopy;

	//Now play the recording.
	player.playRecord();
	}

	void Game::recordingEnded(){
	//Check if it's a normal replay, if so just stop.
	if(!interlevel){
	msgBox(_("Game replay is done."),MsgBoxOKOnly,_("Game Replay"));
	//Go to the level select menu.
	setNextState(STATE_LEVEL_SELECT);

	//And change the music back to the menu music.
	getMusicManager()->playMusic("menu");
	}else{
	//Instead of directly replaying we set won true to let the Game handle the replaying at the end of the update cycle.
	won=true;
	}
	}

	bool Game::saveState(){
	//Check if the player and shadow can save the current state.
	if(player.canSaveState() && shadow.canSaveState()){
	//Let the player and the shadow save their state.
	player.saveState();
	shadow.saveState();

	//Save the stats.
	timeSaved=time;
	recordingsSaved=recordings;

	//Save other state, for example moving blocks.
	for(unsigned int i=0;i<levelObjects.size();i++){
	levelObjects[i]->saveState();
	}

	//Also save the background animation, if any.
	if(background)
	background->saveAnimation();

	//Return true.
	return true;
	}

	//We can't save the state so return false.
	return false;
	}

	bool Game::loadState(){
	//Check if there's a state that can be loaded.
	if(player.canLoadState() && shadow.canLoadState()){
	//Let the player and the shadow load their state.
	player.loadState();
	shadow.loadState();

	//Load the stats.
	time=timeSaved;
	recordings=recordingsSaved;

	//Load other state, for example moving blocks.
	for(unsigned int i=0;i<levelObjects.size();i++){
	levelObjects[i]->loadState();
	}

	//Also load the background animation, if any.
	if(background)
	background->loadAnimation();

	//Return true.
	return true;
	}

	//We can't load the state so return false.
	return false;
	}

	void Game::reset(bool save){
	//We need to reset the game so we also reset the player and the shadow.
	player.reset(save);
	shadow.reset(save);

	//Reset the stats.
	time=0;
	recordings=0;

	//There is no last checkpoint so set it to NULL.
	if(save)
	objLastCheckPoint=NULL;

	//Reset other state, for example moving blocks.
	for(unsigned int i=0;i<levelObjects.size();i++){
	levelObjects[i]->reset(save);
	}
	//Also reset the background animation, if any.
	if(background)
	background->resetAnimation(save);

	//Also set interlevel to false.
	interlevel=false;
	}

	void Game::broadcastObjectEvent(int eventType,int objectType,const char* id){
	//Create a typeGameObjectEvent that can be put into the queue.
	typeGameObjectEvent e;
	//Set the event type.
	e.eventType=eventType;
	//Set the object type.
	e.objectType=objectType;
	//By default flags=0.
	e.flags=0;
	//Unless there's an id.
	if(id){
	//Set flags to 0x1 and set the id.
	e.flags\|=1;
	e.id=id;
	}

	//Add the event to the queue.
	eventQueue.push_back(e);
	}

	void Game::getCurrentLevelAutoSaveRecordPath(std::string &bestTimeFilePath,std::string &bestRecordingFilePath,bool createPath){
	levels->getLevelAutoSaveRecordPath(-1,bestTimeFilePath,bestRecordingFilePath,createPath);
	}

	void Game::gotoNextLevel(){
	//Goto the next level.
	levels->nextLevel();

	//Check if the level exists.
	if(levels->getCurrentLevel()<levels->getLevelCount()){
	setNextState(STATE_GAME);

	//Don't forget the music.
	getMusicManager()->pickMusic();
	}else{
	if(!levels->congratulationText.empty()){
	msgBox(levels->congratulationText,MsgBoxOKOnly,_("Congratulations"));
	}else{
	msgBox(_("You have finished the levelpack!"),MsgBoxOKOnly,_("Congratulations"));
	}
	//Now go back to the levelselect screen.
	setNextState(STATE_LEVEL_SELECT);
	//And set the music back to menu.
	getMusicManager()->playMusic("menu");
	}
	}

	void Game::GUIEventCallback_OnEvent(string name,GUIObject* obj,int eventType){
	if(name=="cmdMenu"){
	setNextState(STATE_LEVEL_SELECT);

	//And change the music back to the menu music.
	getMusicManager()->playMusic("menu");
	}else if(name=="cmdRestart"){
	//Clear the gui.
	if(GUIObjectRoot){
	delete GUIObjectRoot;
	GUIObjectRoot=NULL;
	}

	//And reset the game.
	//new: we don't need to clear the save game because
	//in level replay the game won't be saved
	//TODO: it doesn't work; better leave for next release
	reset(/false/ true);
	}else if(name=="cmdNext"){
	//No matter what, clear the gui.
	if(GUIObjectRoot){
	delete GUIObjectRoot;
	GUIObjectRoot=NULL;
	}

	//And goto the next level.
	gotoNextLevel();
	}
	}
	diff --git a/src/TitleMenu.cpp b/src/TitleMenu.cpp
	index 6902da5..a3ecb11 100644
	--- a/src/TitleMenu.cpp
	+++ b/src/TitleMenu.cpp
	@@ -1,418 +1,420 @@
	/****************************************************************************
	** Copyright (C) 2011 Luka Horvat <redreaper132 at gmail.com>
	** Copyright (C) 2011 Edward Lii <edward_iii at myway.com>
	** Copyright (C) 2011 O. Bahri Gordebak <gordebak at gmail.com>
	**
	**
	** This file may be used under the terms of the GNU General Public
	** License version 3.0 as published by the Free Software Foundation
	** and appearing in the file LICENSE.GPL included in the packaging of
	** this file.
	**
	** This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
	** WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
	**
	** You should have received a copy of the GNU General Public License
	** along with this program. If not, see <http://www.gnu.org/licenses/>.
	**
	****************************************************************************/
	#include "Functions.h"
	#include "GameState.h"
	#include "Globals.h"
	#include "TitleMenu.h"
	#include "GUIListBox.h"
	#include "InputManager.h"
	#include <iostream>
	#include <algorithm>
	using namespace std;

	/////////////////////////MAIN_MENU//////////////////////////////////

	//Integer containing the highlighted/selected menu option.
	static int highlight=0;

	Menu::Menu(){
	highlight=0;
	animation=0;

	//Load the title image.
	title=loadImage(getDataPath()+"gfx/menu/title.png");

	//Now render the five entries.
	SDL_Color black={0,0,0};
	entries[0]=TTF_RenderUTF8_Blended(fontTitle,_("Play"),black);
	entries[1]=TTF_RenderUTF8_Blended(fontTitle,_("Options"),black);
	entries[2]=TTF_RenderUTF8_Blended(fontTitle,_("Map Editor"),black);
	entries[3]=TTF_RenderUTF8_Blended(fontTitle,_("Addons"),black);
	entries[4]=TTF_RenderUTF8_Blended(fontTitle,_("Exit"),black);
	entries[5]=TTF_RenderUTF8_Blended(fontTitle,">",black);
	entries[6]=TTF_RenderUTF8_Blended(fontTitle,"<",black);
	}

	Menu::~Menu(){
	//We need to free the five text surfaceses.
	for(unsigned int i=0;i<7;i++)
	SDL_FreeSurface(entries[i]);
	}


	void Menu::handleEvents(){
	//Get the x and y location of the mouse.
	int x,y;
	SDL_GetMouseState(&x,&y);

	//Calculate which option is highlighted using the location of the mouse.
	//Only if mouse is 'doing something'
	if(event.type==SDL_MOUSEMOTION \|\| event.type==SDL_MOUSEBUTTONDOWN){
	if(x>=200&&x<SCREEN_WIDTH-200&&y>=(SCREEN_HEIGHT-200)/2&&y<(SCREEN_HEIGHT-200)/2+320){
	highlight=(y-((SCREEN_HEIGHT-200)/2-64))/64;
	}
	}

	//Down/Up -arrows move highlight
	if(inputMgr.isKeyDownEvent(INPUTMGR_DOWN)){
	highlight++;
	if(highlight>=6)
	highlight=5;
	}
	if(inputMgr.isKeyDownEvent(INPUTMGR_UP)){
	highlight--;
	if(highlight<1)
	highlight=1;
	}

	//Check if there's a press event.
	if((event.type==SDL_MOUSEBUTTONUP && event.button.button==SDL_BUTTON_LEFT) \|\|
	(event.type==SDL_KEYUP && (event.key.keysym.sym==SDLK_RETURN \|\| event.key.keysym.sym==SDLK_KP_ENTER))){
	//We have one so check which selected/highlighted option needs to be done.
	switch(highlight){
	case 1:
	//Enter the levelSelect state.
	setNextState(STATE_LEVEL_SELECT);
	break;
	case 2:
	//Enter the options state.
	setNextState(STATE_OPTIONS);
	break;
	case 3:
	//Enter the levelEditor, but first set the level to a default leveledit map.
	levelName="";
	setNextState(STATE_LEVEL_EDIT_SELECT);
	break;
	case 4:
	//Check if internet is enabled.
	if(!getSettings()->getBoolValue("internet")){
	msgBox(_("Enable internet in order to install addons."),MsgBoxOKOnly,_("Internet disabled"));
	break;
	}

	//Enter the help state.
	setNextState(STATE_ADDONS);
	break;
	case 5:
	//We quit, so we enter the exit state.
	setNextState(STATE_EXIT);
	break;
	}
	}

	//We also need to quit the menu when escape is pressed.
	if(inputMgr.isKeyUpEvent(INPUTMGR_ESCAPE)){
	setNextState(STATE_EXIT);
	}

	//Check if we need to quit, if so we enter the exit state.
	if(event.type==SDL_QUIT){
	setNextState(STATE_EXIT);
	}
	}

	//Nothing to do here
	void Menu::logic(){
	animation++;
	if(animation>10)
	animation=-10;
	}


	void Menu::render(){
	applySurface(0,0,menuBackground,screen,NULL);

	//Draw the title.
	applySurface((SCREEN_WIDTH-title->w)/2,40,title,screen,NULL);

	//Draw the menu entries.
	for(unsigned int i=0;i<5;i++){
	applySurface((SCREEN_WIDTH-entries[i]->w)/2,(SCREEN_HEIGHT-200)/2+64*i+(64-entries[i]->h)/2,entries[i],screen,NULL);
	}

	//Check if an option is selected/highlighted.
	if(highlight>0){
	//Draw the '>' sign, which is entry 5.
	int x=(SCREEN_WIDTH-entries[highlight-1]->w)/2-(25-abs(animation)/2)-entries[5]->w;
	int y=(SCREEN_HEIGHT-200)/2-64+64*highlight+(64-entries[5]->h)/2;
	applySurface(x,y,entries[5],screen,NULL);

	//Draw the '<' sign, which is entry 6.
	x=(SCREEN_WIDTH-entries[highlight-1]->w)/2+entries[highlight-1]->w+(25-abs(animation)/2);
	y=(SCREEN_HEIGHT-200)/2-64+64*highlight+(64-entries[6]->h)/2;
	applySurface(x,y,entries[6],screen,NULL);
	}
	}


	/////////////////////////OPTIONS_MENU//////////////////////////////////

	//Some varables for the options.
	static bool sound,music,fullscreen,leveltheme,internet;
	static string themeName;

	static bool useProxy;
	static string internetProxy;

	static bool restartFlag;

	Options::Options(){
	//Render the title.
	SDL_Color black={0,0,0};
	title=TTF_RenderUTF8_Blended(fontTitle,_("Settings"),black);

	//Set some default settings.
	music=getSettings()->getBoolValue("music");
	sound=getSettings()->getBoolValue("sound");
	fullscreen=getSettings()->getBoolValue("fullscreen");
	themeName=processFileName(getSettings()->getValue("theme"));
	leveltheme=getSettings()->getBoolValue("leveltheme");
	internet=getSettings()->getBoolValue("internet");
	internetProxy=getSettings()->getValue("internet-proxy");
	useProxy=!internetProxy.empty();

	//Set the restartFlag false.
	restartFlag=false;

	//Variables for positioning
	int x = (SCREEN_WIDTH-540)/2;

	//Create the root element of the GUI.
	if(GUIObjectRoot){
	delete GUIObjectRoot;
	GUIObjectRoot=NULL;
	}
	GUIObjectRoot=new GUIObject(0,0,SCREEN_WIDTH,SCREEN_HEIGHT,GUIObjectNone);

	//Now we create GUIObjects for every option.
	GUIObject *obj=new GUIObject(x,150,240,36,GUIObjectCheckBox,_("Music"),music?1:0);
	obj->name="chkMusic";
	obj->eventCallback=this;
	GUIObjectRoot->childControls.push_back(obj);

	obj=new GUIObject(x,190,240,36,GUIObjectCheckBox,_("Sound"),sound?1:0);
	obj->name="chkSound";
	obj->eventCallback=this;
	GUIObjectRoot->childControls.push_back(obj);

	obj=new GUIObject(x,230,240,36,GUIObjectCheckBox,_("Fullscreen"),fullscreen?1:0);
	obj->name="chkFullscreen";
	obj->eventCallback=this;
	GUIObjectRoot->childControls.push_back(obj);

	obj=new GUIObject(x,270,240,36,GUIObjectLabel,_("Theme:"));
	obj->name="theme";
	GUIObjectRoot->childControls.push_back(obj);

	//Create the theme option gui element.
	theme=new GUISingleLineListBox(x+220,270,300,36);
	theme->name="lstTheme";
	vector<string> v=enumAllDirs(getUserPath(USER_DATA)+"themes/");
	for(vector<string>::iterator i = v.begin(); i != v.end(); ++i){
	themeLocations[i]=getUserPath(USER_DATA)+"themes/"+i;
	}
	vector<string> v2=enumAllDirs(getDataPath()+"themes/");
	for(vector<string>::iterator i = v2.begin(); i != v2.end(); ++i){
	themeLocations[i]=getDataPath()+"themes/"+i;
	}
	v.insert(v.end(), v2.begin(), v2.end());

	//Try to find the configured theme so we can display it.
	int value=-1;
	for(vector<string>::iterator i = v.begin(); i != v.end(); ++i){
	if(themeLocations[*i]==themeName) {
	value=i-v.begin();
	}
	}
	theme->item=v;
	if(value==-1)
	value=theme->item.size()-1;
	theme->value=value;
	//NOTE: We call the event handling method to correctly set the themename.
	GUIEventCallback_OnEvent("lstTheme",theme,GUIEventChange);
	theme->eventCallback=this;
	GUIObjectRoot->childControls.push_back(theme);

	obj=new GUIObject(x,310,240,36,GUIObjectCheckBox,_("Level themes"),leveltheme?1:0);
	obj->name="chkLeveltheme";
	obj->eventCallback=this;
	GUIObjectRoot->childControls.push_back(obj);

	obj=new GUIObject(x,350,240,36,GUIObjectCheckBox,_("Internet"),internet?1:0);
	obj->name="chkInternet";
	obj->eventCallback=this;
	GUIObjectRoot->childControls.push_back(obj);

	//new: proxy settings
	obj=new GUIObject(x,390,240,36,GUIObjectLabel,_("Internet proxy"));
	obj->name="chkProxy";
	obj->eventCallback=this;
	GUIObjectRoot->childControls.push_back(obj);
	obj=new GUIObject(x+220,390,300,36,GUIObjectTextBox,internetProxy.c_str());
	obj->name="txtProxy";
	obj->eventCallback=this;
	GUIObjectRoot->childControls.push_back(obj);

	//new: key settings
	obj=new GUIObject((SCREEN_WIDTH-240)/2-150,SCREEN_HEIGHT-120,240,36,GUIObjectButton,_("Config Keys"));
	obj->name="cmdKeys";
	obj->eventCallback=this;
	GUIObjectRoot->childControls.push_back(obj);

	//Reset progress settings.
	+ /// TRANSLATORS: Used for button which clear any level progress like unlocked levels and highscores.
	obj=new GUIObject((SCREEN_WIDTH-260)/2+150,SCREEN_HEIGHT-120,260,36,GUIObjectButton,_("Clear Progress"));
	obj->name="cmdReset";
	obj->eventCallback=this;
	GUIObjectRoot->childControls.push_back(obj);

	obj=new GUIObject((SCREEN_WIDTH-284)/2-150,SCREEN_HEIGHT-60,284,36,GUIObjectButton,_("Cancel"));
	obj->name="cmdBack";
	obj->eventCallback=this;
	GUIObjectRoot->childControls.push_back(obj);

	obj=new GUIObject((SCREEN_WIDTH-284)/2+150,SCREEN_HEIGHT-60,284,36,GUIObjectButton,_("Save Changes"));
	obj->name="cmdSave";
	obj->eventCallback=this;
	GUIObjectRoot->childControls.push_back(obj);
	}

	Options::~Options(){
	//Delete the GUI.
	if(GUIObjectRoot){
	delete GUIObjectRoot;
	GUIObjectRoot=NULL;
	}

	//And free the title image.
	SDL_FreeSurface(title);
	}

	void Options::GUIEventCallback_OnEvent(std::string name,GUIObject* obj,int eventType){
	//Check what type of event it was.
	if(eventType==GUIEventClick){
	if(name=="cmdBack"){
	//TODO: Reset the key changes.

	//And goto the main menu.
	setNextState(STATE_MENU);
	}else if(name=="cmdSave"){
	//Save is pressed thus save
	getSettings()->setValue("sound",sound?"1":"0");
	getSettings()->setValue("music",music?"1":"0");
	getMusicManager()->setEnabled(music);
	getSettings()->setValue("fullscreen",fullscreen?"1":"0");
	getSettings()->setValue("leveltheme",leveltheme?"1":"0");
	getSettings()->setValue("internet",internet?"1":"0");
	getSettings()->setValue("theme",themeName);
	if(!useProxy)
	internetProxy.clear();
	getSettings()->setValue("internet-proxy",internetProxy);

	//Save the key configuration.
	inputMgr.saveConfig();

	//Save the settings.
	saveSettings();

	//Before we return show a restart message, if needed.
	if(restartFlag)
	+ /// TRANSLATORS: Some settings require to restart the game
	msgBox(_("Restart needed before the changes have effect."),MsgBoxOKOnly,_("Restart needed"));

	//Now return to the main menu.
	setNextState(STATE_MENU);
	}else if(name=="cmdKeys"){
	inputMgr.showConfig();
	}else if(name=="cmdReset"){
	if(msgBox(_("Do you really want to reset level progress?"),MsgBoxYesNo,_("Warning"))==MsgBoxYes){
	//We delete the progress folder.
	#ifdef WIN32
	removeDirectory((getUserPath()+"progress").c_str());
	createDirectory((getUserPath()+"progress").c_str());
	#else
	removeDirectory((getUserPath(USER_DATA)+"/progress").c_str());
	createDirectory((getUserPath(USER_DATA)+"/progress").c_str());
	#endif
	}
	return;
	}else if(name=="chkMusic"){
	music=obj->value?true:false;
	}else if(name=="chkSound"){
	sound=obj->value?true:false;
	}else if(name=="chkFullscreen"){
	fullscreen=obj->value?true:false;

	//Check if fullscreen changed.
	if(fullscreen==getSettings()->getBoolValue("fullscreen")){
	//We disable the restart message flag.
	restartFlag=false;
	}else{
	//We set the restart message flag.
	restartFlag=true;
	}

	}else if(name=="chkLeveltheme"){
	leveltheme=obj->value?true:false;
	}else if(name=="chkInternet"){
	internet=obj->value?true:false;
	}else if(name=="chkProxy"){
	useProxy=obj->value?true:false;
	}
	}
	if(name=="lstTheme"){
	if(theme!=NULL && theme->value>=0 && theme->value<(int)theme->item.size()){
	//Check if the theme is installed in the data path.
	if(themeLocations[theme->item[theme->value]].find(getDataPath())!=string::npos){
	themeName="%DATA%/themes/"+fileNameFromPath(themeLocations[theme->item[theme->value]]);
	}else if(themeLocations[theme->item[theme->value]].find(getUserPath(USER_DATA))!=string::npos){
	themeName="%USER%/themes/"+fileNameFromPath(themeLocations[theme->item[theme->value]]);
	}else{
	themeName=themeLocations[theme->item[theme->value]];
	}
	}
	}else if(name=="txtProxy"){
	internetProxy=obj->caption;

	//Check if the internetProxy field is empty.
	useProxy=!internetProxy.empty();
	}
	}

	void Options::handleEvents(){
	//Check if we need to quit, if so enter the exit state.
	if(event.type==SDL_QUIT){
	setNextState(STATE_EXIT);
	}

	//Check if the escape button is pressed, if so go back to the main menu.
	if(inputMgr.isKeyUpEvent(INPUTMGR_ESCAPE)){
	setNextState(STATE_MENU);
	}
	}

	//Nothing to do here.
	void Options::logic(){}

	void Options::render(){
	//Render the menu background image.
	applySurface(0,0,menuBackground,screen,NULL);
	//Now render the title.
	applySurface((SCREEN_WIDTH-title->w)/2,40,title,screen,NULL);

	//NOTE: The rendering of the GUI is done in Main.
	}

File Metadata

Mime Type: text/x-diff
Expires: Tue, Jun 16, 12:09 AM (2 w, 2 d ago)
Storage Engine: blob
Storage Format: Raw Data
Storage Handle: 71432
Default Alt Text: (86 KB)

No OneTemporaryActions

View Options

File Metadata

Event Timeline

No OneTemporary
Actions