No OneTemporary
Actions

Authored By

Unknown

Size

86 KB

Referenced Files

None

Subscribers

None

View Options

	diff --git a/CMakeLists.txt b/CMakeLists.txt
	index ffb3dc4..f9fcced 100644
	--- a/CMakeLists.txt
	+++ b/CMakeLists.txt
	@@ -1,132 +1,140 @@
	PROJECT(meandmyshadow)
	CMAKE_MINIMUM_REQUIRED(VERSION 2.6)
	set(CMAKE_MODULE_PATH ${CMAKE_MODULE_PATH} "${CMAKE_SOURCE_DIR}/cmake/Modules/")

	#Option if the game should be compiled with hardware acceleration.
	option (HARDWARE_ACCELERATION "Use openGL as rendering backend" ON)
	option (DEBUG_MODE "Compile the game with debug mode enabled" OFF)

	#Find the required libraries.
	Find_Package(SDL REQUIRED)
	Find_Package(SDL_ttf REQUIRED)
	Find_Package(SDL_image REQUIRED)
	Find_Package(SDL_mixer REQUIRED)
	Find_Package(SDL_gfx REQUIRED)
	Find_Package(CURL REQUIRED)
	Find_Package(LibArchive REQUIRED)
	Find_Package(OpenSSL REQUIRED)
	+Find_Package(Lua51 REQUIRED)

	#Use openGL only when compiling with HARDWARE_ACCELERATION.
	#Otherwise we try to find XLib.
	if(HARDWARE_ACCELERATION)
	Find_Package(OpenGL REQUIRED)
	else(HARDWARE_ACCELERATION)
	INCLUDE(FindX11)
	endif(HARDWARE_ACCELERATION)

	#Add the include dirs of the libraries.
	INCLUDE_DIRECTORIES(${SDL_INCLUDE_DIR})
	INCLUDE_DIRECTORIES(${SDLIMAGE_INCLUDE_DIR})
	INCLUDE_DIRECTORIES(${SDLMIXER_INCLUDE_DIR})
	INCLUDE_DIRECTORIES(${SDLTTF_INCLUDE_DIR})
	INCLUDE_DIRECTORIES(${SDLGFX_INCLUDE_DIR})
	INCLUDE_DIRECTORIES(${CURL_INCLUDE_DIR})
	INCLUDE_DIRECTORIES(${LibArchive_INCLUDE_DIR})
	INCLUDE_DIRECTORIES(${OPENSSL_INCLUDE_DIR})
	+INCLUDE_DIRECTORIES(${LUA51_INCLUDE_DIR})
	#Use openGL only when compiling with HARDWARE_ACCELERATION.
	if(HARDWARE_ACCELERATION)
	INCLUDE_DIRECTORIES(${OPENGL_INCLUDE_DIR})
	endif(HARDWARE_ACCELERATION)

	if ( NOT SDL_FOUND )
	message(FATAL_ERROR "SDL not found !")
	endif ( NOT SDL_FOUND )

	if ( NOT SDLTTF_FOUND )
	message(FATAL_ERROR "SDL_ttf not found !")
	endif ( NOT SDLTTF_FOUND )

	if ( NOT SDLMIXER_FOUND )
	message(FATAL_ERROR "SDL_mixer not found !")
	endif ( NOT SDLMIXER_FOUND )

	if ( NOT SDLGFX_FOUND )
	message(FATAL_ERROR "SDL_gfx not found !")
	endif ( NOT SDLGFX_FOUND )

	if ( NOT CURL_FOUND )
	message(FATAL_ERROR "CURL not found !")
	endif ( NOT CURL_FOUND )

	if ( NOT LibArchive_FOUND )
	message(FATAL_ERROR "LIBARCHIVE not found !")
	endif ( NOT LibArchive_FOUND )

	if ( NOT OPENSSL_FOUND )
	message(FATAL_ERROR "OpenSSL not found !")
	endif ( NOT OPENSSL_FOUND )

	+if ( NOT LUA51_FOUND )
	+ message(FATAL_ERROR "Lua not found !")
	+endif ( NOT LUA51_FOUND )
	+
	if ( HARDWARE_ACCELERATION AND NOT OPENGL_FOUND )
	message(FATAL_ERROR "OpenGL not found !")
	endif ( HARDWARE_ACCELERATION AND NOT OPENGL_FOUND )

	#Set the output path and the source path.
	set(EXECUTABLE_OUTPUT_PATH ${PROJECT_BINARY_DIR})
	set(SRC_DIR ${PROJECT_SOURCE_DIR}/src)

	#Add the include directories of the (found) libraries.
	include_directories(
	${PROJECT_BINARY_DIR}
	${SDL_INCLUDE_DIR}
	${SDLTTF_INCLUDE_DIR}
	${SDLMIXER_INCLUDE_DIR}
	${SDLIMAGE_INCLUDE_DIR}
	${SDLGFX_INCLUDE_DIR}
	${OPENSSL_INCLUDE_DIR}
	+ ${LUA_INCLUDE_DIR}
	${OPENGL_INCLUDE_DIR}
	)

	#List the source files.
	file(GLOB tinygettext ${SRC_DIR}/libs/tinygettext/*.cpp)
	file(GLOB findlocale ${SRC_DIR}/libs/findlocale/*.c)
	file(GLOB Sources ${SRC_DIR}/*.cpp)
	add_executable(meandmyshadow ${Sources} ${tinygettext} ${findlocale})

	target_link_libraries(
	meandmyshadow
	${SDL_LIBRARY}
	${SDLTTF_LIBRARY}
	${SDLIMAGE_LIBRARY}
	${SDLMIXER_LIBRARY}
	${SDLGFX_LIBRARY}
	${CURL_LIBRARY}
	${LibArchive_LIBRARY}
	${OPENSSL_LIBRARIES}
	+ ${LUA_LIBRARIES}
	${CRYPTO_LIBRARY}
	${OPENGL_LIBRARY}
	${X11_LIBRARIES}
	)

	#Path options
	set(BINDIR "bin" CACHE STRING "Where to install binaries")
	set(DATAROOTDIR "${CMAKE_INSTALL_PREFIX}/share" CACHE STRING "Sets the root of data directories to a non-default location")
	set(ICONDIR "${DATAROOTDIR}/icons" CACHE STRING "Sets the icon directory for desktop entry to a non-default location.")
	set(DESKTOPDIR "${DATAROOTDIR}/applications" CACHE STRING "Sets the desktop file directory for desktop entry to a non-default location.")

	#Parse the configure file.
	configure_file (
	"${PROJECT_SOURCE_DIR}/src/config.h.in"
	"${PROJECT_BINARY_DIR}/config.h"
	)

	#install locations
	install(DIRECTORY ${PROJECT_SOURCE_DIR}/data DESTINATION ${DATAROOTDIR}/meandmyshadow/)
	install(FILES AUTHORS DESTINATION ${DATAROOTDIR}/meandmyshadow/)
	install(TARGETS meandmyshadow RUNTIME DESTINATION ${BINDIR})
	if("${CMAKE_SYSTEM_NAME}" MATCHES "Linux")
	install(FILES meandmyshadow.desktop DESTINATION ${DESKTOPDIR})
	install(FILES icons/16x16/meandmyshadow.png DESTINATION ${ICONDIR}/hicolor/16x16/apps/)
	install(FILES icons/32x32/meandmyshadow.png DESTINATION ${ICONDIR}/hicolor/32x32/apps/)
	install(FILES icons/48x48/meandmyshadow.png DESTINATION ${ICONDIR}/hicolor/48x48/apps/)
	install(FILES icons/64x64/meandmyshadow.png DESTINATION ${ICONDIR}/hicolor/64x64/apps/)
	endif("${CMAKE_SYSTEM_NAME}" MATCHES "Linux")
	diff --git a/src/Block.h b/src/Block.h
	index 5815d48..90eef46 100644
	--- a/src/Block.h
	+++ b/src/Block.h
	@@ -1,133 +1,131 @@
	/*
	* Copyright (C) 2011-2012 Me and My Shadow
	*
	* This file is part of Me and My Shadow.
	*
	* Me and My Shadow 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 3 of the License, or
	* (at your option) any later version.
	*
	* Me and My Shadow 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 Me and My Shadow. If not, see <http://www.gnu.org/licenses/>.
	*/

	#ifndef BLOCK_H
	#define BLOCK_H

	#include "GameObjects.h"
	#include "Globals.h"
	#include "ThemeManager.h"
	#include <vector>
	#include <SDL/SDL.h>

	-class Game;
	-
	class Block: public GameObject{
	private:
	//The Appearance of the block.
	ThemeBlockInstance appearance;

	//Integer that a block can use for all sorts of things.
	int temp;
	//The save for temp when the state of the block is saved.
	int tempSave;

	//flags:
	//moving object 0x1=disabled
	//button bit0-1=behavior 0x4=pressed
	//switch bit0-1=behavior
	int flags;
	//The save for flags when the state of the block is saved.
	int flagsSave;

	//Following is for moving blocks.
	//The starting place for moving blocks.
	SDL_Rect boxBase;
	//Vector containing the poisitions of the moving block.
	std::vector<SDL_Rect> movingPos;
	int dx;
	int xSave;
	int dy;
	int ySave;
	//Boolean if the moving block loops his movement.
	//Default value is true.
	bool loop;

	//Flags of the block for the editor.
	//moving object 0x1=disabled
	//portal 0x1=automatic
	//fragile =state
	int editorFlags;
	public:
	//The id of the block.
	std::string id;
	//String containing the id of the destination for portals.
	std::string destination;
	//String containing the message of the notification block.
	std::string message;

	//Constructor.
	//x: The x location of the block.
	//y: The y location of the block.
	//objParent: Pointer to the Game object.
	Block(int x,int y,int type,Game* objParent);
	//Desturctor.
	~Block();

	//Method used to draw the block.
	void show();

	//Returns the box of a given type.
	//boxType: The type of box that should be returned.
	//See GameObjects.h for the types.
	//Returns: The box.
	virtual SDL_Rect getBox(int boxType=BoxType_Current);

	//Method used to set the location of the block.
	//It will set the base box x and y location.
	//x: The new x location.
	//y: The new y location.
	virtual void setPosition(int x,int y);

	//Save the state of the block so we can load it later on.
	virtual void saveState();
	//Load the saved state of the block so.
	virtual void loadState();
	//Reset the block.
	//save: Boolean if the saved state should also be deleted.
	virtual void reset(bool save);

	//Play an animation.
	//flags: TODO???
	virtual void playAnimation(int flags);

	//Method called when there's an event.
	//eventType: The type of event.
	//See GameObjects.h for the eventtypes.
	virtual void onEvent(int eventType);

	//Method used to retrieve a property from the block.
	//propertyType: The type of property requested.
	//See GameObjects.h for the properties.
	//obj: Pointer to the player.
	//Returns: Integer containing the value of the property.
	virtual int queryProperties(int propertyType,Player* obj);

	//Get the editor data of the block.
	//obj: The vector that will be filled with the editorData.
	virtual void getEditorData(std::vector<std::pair<std::string,std::string> >& obj);
	//Set the editor data of the block.
	//obj: The new editor data.
	virtual void setEditorData(std::map<std::string,std::string>& obj);

	//Method used for updating moving blocks or elements of blocks.
	virtual void move();
	};

	#endif
	diff --git a/src/Functions.cpp b/src/Functions.cpp
	index 73bbc2e..74ef074 100644
	--- a/src/Functions.cpp
	+++ b/src/Functions.cpp
	@@ -1,1597 +1,1610 @@
	/*
	* Copyright (C) 2011-2012 Me and My Shadow
	*
	* This file is part of Me and My Shadow.
	*
	* Me and My Shadow 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 3 of the License, or
	* (at your option) any later version.
	*
	* Me and My Shadow 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 Me and My Shadow. If not, see <http://www.gnu.org/licenses/>.
	*/

	#include <stdio.h>
	#include <math.h>
	#include <algorithm>
	#include <SDL/SDL.h>
	#ifdef __APPLE__
	#include <SDL_mixer/SDL_mixer.h>
	#include <SDL_gfx/SDL_gfxPrimitives.h>
	#include <SDL_gfx/SDL_rotozoom.h>
	#else
	#include <SDL/SDL_mixer.h>
	#include <SDL/SDL_gfxPrimitives.h>
	#include <SDL/SDL_rotozoom.h>
	#endif
	#include <SDL/SDL_syswm.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 "InputManager.h"
	#include "ImageManager.h"
	#include "MusicManager.h"
	#include "LevelPackManager.h"
	#include "ThemeManager.h"
	#include "GUIListBox.h"
	#include "GUIOverlay.h"
	#include "StatisticsManager.h"
	#include "StatisticsScreen.h"

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

	#ifdef HARDWARE_ACCELERATION
	#include <GL/gl.h>
	#include <GL/glu.h>

	//fix some Windows header bug
	#ifndef GL_BGR
	#define GL_BGR GL_BGR_EXT
	#endif
	#ifndef GL_BGRA
	#define GL_BGRA GL_BGRA_EXT
	#endif

	#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

	//Workaround for the resizing below 800x600 for X systems.
	#ifdef __linux__
	#include<X11/Xlib.h>
	#include<X11/Xutil.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;

	+//The scriptExecutor used for executing scripts.
	+ScriptExecutor scriptExecutor;
	+
	//Map containing changed settings using command line arguments.
	map<string,string> tmpSettings;
	//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(dest,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(dest,x+1,y,x+w-2,y,0,0,0,255);
	lineRGBA(dest,x+1,y+h-1,x+w-2,y+h-1,0,0,0,255);
	lineRGBA(dest,x,y+1,x,y+h-2,0,0,0,255);
	lineRGBA(dest,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(dest,x,y,0,0,0,160);
	pixelRGBA(dest,x,y+h-1,0,0,0,160);
	pixelRGBA(dest,x+w-1,y,0,0,0,160);
	pixelRGBA(dest,x+w-1,y+h-1,0,0,0,160);

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

	//Create anti-aliasing in corners of second border
	pixelRGBA(dest,x+1,y+1,0,0,0,50);
	pixelRGBA(dest,x+1,y+h-2,0,0,0,50);
	pixelRGBA(dest,x+w-2,y+1,0,0,0,50);
	pixelRGBA(dest,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 createScreen(){
	//Check if we are going fullscreen.
	if(settings->getBoolValue("fullscreen"))
	pickFullscreenResolution();

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

	//Boolean if this is the first screen creation.
	bool initial=true;

	//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;
	else if(settings->getBoolValue("resizable"))
	flags\|=SDL_RESIZABLE;
	if(SDL_SetVideoMode(SCREEN_WIDTH,SCREEN_HEIGHT,SCREEN_BPP,flags)==NULL){
	fprintf(stderr,"FATAL ERROR: SDL_SetVideoMode failed\n");
	return false;
	}

	//Delete the old screen.
	//Warning: only if previous mode is OpenGL mode.
	//NOTE: The previous mode can't switch during runtime.
	if(screen){
	SDL_FreeSurface(screen);
	screen=NULL;

	//There was a screen so this isn't the initial screen creation.
	initial=false;
	}

	//Create a screen
	screen=SDL_CreateRGBSurface(SDL_HWSURFACE,SCREEN_WIDTH,SCREEN_HEIGHT,32,0x00FF0000,0x0000FF00,0x000000FF,0);

	//Create a texture.
	glDeleteTextures(1,&screenTexture);
	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{
	//Set the flags.
	Uint32 flags=SDL_HWSURFACE \| SDL_DOUBLEBUF;
	if(settings->getBoolValue("fullscreen"))
	flags\|=SDL_FULLSCREEN;
	else if(settings->getBoolValue("resizable"))
	flags\|=SDL_RESIZABLE;

	//Check if there already was a screen.
	if(screen)
	initial=false;

	//Create the screen and check if there weren't any errors.
	screen=SDL_SetVideoMode(SCREEN_WIDTH,SCREEN_HEIGHT,SCREEN_BPP,flags);
	if(screen==NULL){
	fprintf(stderr,"FATAL ERROR: SDL_SetVideoMode failed\n");
	return false;
	}
	}

	//Now configure the newly created window (if windowed).
	if(settings->getBoolValue("fullscreen")==false)
	configureWindow(initial);

	//Create the temp surface, just a replica of the screen surface, free the previous one if any.
	if(tempSurface)
	SDL_FreeSurface(tempSurface);
	tempSurface=SDL_CreateRGBSurface(SDL_HWSURFACE\|SDL_SRCALPHA,
	screen->w,screen->h,screen->format->BitsPerPixel,
	screen->format->Rmask,screen->format->Gmask,screen->format->Bmask,0);

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

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

	#ifdef WIN32

	static WNDPROC m_OldWindowProc=NULL;

	static LRESULT CALLBACK WindowProc(HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam){
	if(msg==WM_GETMINMAXINFO){
	if(m_OldWindowProc){
	CallWindowProc(m_OldWindowProc,hwnd,msg,wParam,lParam);
	}else{
	DefWindowProc(hwnd,msg,wParam,lParam);
	}

	RECT r={0,0,800,600};
	AdjustWindowRect(&r,GetWindowLong(hwnd,GWL_STYLE),FALSE);

	MINMAXINFO info=(MINMAXINFO)lParam;
	info->ptMinTrackSize.x=r.right-r.left;
	info->ptMinTrackSize.y=r.bottom-r.top;

	return 0;
	}else{
	if(m_OldWindowProc){
	return CallWindowProc(m_OldWindowProc,hwnd,msg,wParam,lParam);
	}else{
	return DefWindowProc(hwnd,msg,wParam,lParam);
	}
	}
	}

	#endif

	void pickFullscreenResolution(){
	//Vector that will hold the resolutions to choose from.
	vector<_res> resolutionList;

	//Enumerate avaliable resolutions using SDL_ListModes()
	//Note: we enumerate fullscreen resolutions because
	// windowed resolutions always can be arbitrary
	if(resolutionList.empty()){
	SDL_Rect **modes=SDL_ListModes(NULL,SDL_FULLSCREEN\|SDL_HWSURFACE);

	if(modes==NULL \|\| ((intptr_t)modes) == -1){
	cout<<"Error: Can't enumerate avaliable screen resolutions."
	" Use predefined screen resolutions list instead."<<endl;

	static const _res predefinedResolutionList[] = {
	{800,600},
	{1024,600},
	{1024,768},
	{1152,864},
	{1280,720},
	{1280,768},
	{1280,800},
	{1280,960},
	{1280,1024},
	{1360,768},
	{1366,768},
	{1440,900},
	{1600,900},
	{1600,1200},
	{1680,1080},
	{1920,1080},
	{1920,1200},
	{2560,1440},
	{3840,2160}
	};

	//Fill the resolutionList.
	for(unsigned int i=0;i<sizeof(predefinedResolutionList)/sizeof(_res);i++){
	resolutionList.push_back(predefinedResolutionList[i]);
	}
	}else{
	//Fill the resolutionList.
	for(unsigned int i=0;modes[i]!=NULL;i++){
	//Check if the resolution is higher than the minimum (800x600).
	if(modes[i]->w>=800 && modes[i]->h>=600){
	_res res={modes[i]->w, modes[i]->h};
	resolutionList.push_back(res);
	}
	}
	//Reverse it so that we begin with the lowest resolution.
	reverse(resolutionList.begin(),resolutionList.end());
	}
	}

	//The resolution that will hold the final result, we start with the minimum (800x600).
	_res closestMatch={800,600};
	int width=atoi(getSettings()->getValue("width").c_str());
	//int height=atoi(getSettings()->getValue("height").c_str());

	//Now loop through the resolutionList.
	for(int i=0;i<(int)resolutionList.size();i++){
	//The delta between the closestMatch and the resolution from the list.
	int dM=(closestMatch.w-resolutionList[i].w);
	//The delta between the target width and the resolution from the list.
	int dT=(width-resolutionList[i].w);

	//Since the resolutions are getting higher the lower (more negative) the further away it is.
	//That's why we check if the deltaMatch is lower than the the deltaTarget.
	if((dM)<(dT)){
	closestMatch.w=resolutionList[i].w;
	closestMatch.h=resolutionList[i].h;
	}
	}

	//Now set the resolution to the closest match.
	char s[64];
	sprintf(s,"%d",closestMatch.w);
	getSettings()->setValue("width",s);
	sprintf(s,"%d",closestMatch.h);
	getSettings()->setValue("height",s);
	}

	void configureWindow(bool initial){
	//We only need to configure the window if it's resizable.
	if(!getSettings()->getBoolValue("resizable"))
	return;

	//Retrieve the WM info from SDL containing the window handle.
	struct SDL_SysWMinfo wmInfo;
	SDL_VERSION(&wmInfo.version);
	SDL_GetWMInfo(&wmInfo);

	#ifdef __linux__
	//We assume that a linux system running meandmyshadow is also running an Xorg server.
	if(wmInfo.subsystem==SDL_SYSWM_X11){
	//Create the size hints to give to the window.
	XSizeHints* sizeHints;
	if(!(sizeHints=XAllocSizeHints())){
	cerr<<"ERROR: Unable to allocate memory for XSizeHings."<<endl;
	return;
	}

	//Configure the size hint.
	sizeHints->flags=PMinSize;
	sizeHints->min_width=800;
	sizeHints->min_height=600;

	//Set the normal hints of the window.
	(void)wmInfo.info.x11.lock_func;
	XSetNormalHints(wmInfo.info.x11.display,wmInfo.info.x11.wmwindow,sizeHints);
	(void)wmInfo.info.x11.unlock_func;

	//Free size hint structure
	XFree(sizeHints);
	}else{
	//No X11 so an unsupported window manager.
	cerr<<"WARNING: Unsupported window manager."<<endl;
	}
	#elif defined(WIN32)
	//We overwrite the window proc of SDL
	WNDPROC wndproc=(WNDPROC)GetWindowLong(wmInfo.window,GWL_WNDPROC);
	if(wndproc!=NULL && wndproc!=(WNDPROC)WindowProc){
	m_OldWindowProc=wndproc;
	SetWindowLong(wmInfo.window,GWL_WNDPROC,(LONG)(WNDPROC)WindowProc);
	}
	#endif
	}

	void onVideoResize(){
	//Check if the resize event isn't malformed.
	if(event.resize.w<=0 \|\| event.resize.h<=0)
	return;

	//Check the size limit.
	if(event.resize.w<800)
	event.resize.w=800;
	if(event.resize.h<600)
	event.resize.h=600;

	//Check if it really resizes.
	if(SCREEN_WIDTH==event.resize.w && SCREEN_HEIGHT==event.resize.h)
	return;

	char s[32];

	//Set the new width and height.
	sprintf(s,"%d",event.resize.w);
	getSettings()->setValue("width",s);
	sprintf(s,"%d",event.resize.h);
	getSettings()->setValue("height",s);

	//Do resizing.
	if(!createScreen())
	return;

	//Tell the theme to resize.
	if(!loadTheme(""))
	return;

	//The new resolution is valid.
	//Now we can save the settings. (TODO: should we save?)
	//saveSettings();

	//And let the currentState update it's GUI to the new resolution.
	currentState->resize();
	}

	+//Include the scripting API.
	+#include "ScriptAPI.h"
	+
	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;
	}
	//Set the volume.
	Mix_Volume(-1,atoi(settings->getValue("sound").c_str()));

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

	//Create the screen.
	if(!createScreen())
	return false;

	//Load key config. Then initalize joystick support.
	inputMgr.loadConfig();
	inputMgr.openAllJoysitcks();

	//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;
	if(locale->country!=NULL){
	language+=string("_")+string(locale->country);
	}
	if(locale->variant!=NULL){
	language+=string("@")+string(locale->variant);
	}

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

	//Disable annoying 'Couldn't translate: blah blah blah'
	tinygettext::Log::set_log_info_callback(NULL);

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

	+ //Register the ScriptAPI's functions in the scriptExecutor.
	+ registerFunctions(getScriptExecutor());
	+
	//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/DroidSansFallback.ttf").c_str(),size);
	}
	}

	bool loadFonts(){
	//Load the fonts.
	//NOTE: This is a separate method because it will be called separately when re-initing in case of language change.

	//First close the fonts if needed.
	if(fontTitle)
	TTF_CloseFont(fontTitle);
	if(fontGUI)
	TTF_CloseFont(fontGUI);
	if(fontGUISmall)
	TTF_CloseFont(fontGUISmall);
	if(fontText)
	TTF_CloseFont(fontText);

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

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

	//Generate small arrows used for some GUI widgets.
	static void generateArrows(){
	TTF_Font* fontArrow=loadFont(_("knewave"),18);

	if(arrowLeft1){
	SDL_FreeSurface(arrowLeft1);
	SDL_FreeSurface(arrowRight1);
	SDL_FreeSurface(arrowLeft2);
	SDL_FreeSurface(arrowRight2);
	}

	arrowLeft1=TTF_RenderUTF8_Blended(fontArrow,"<",themeTextColor);
	arrowRight1=TTF_RenderUTF8_Blended(fontArrow,">",themeTextColor);
	arrowLeft2=TTF_RenderUTF8_Blended(fontArrow,"<",themeTextColorDialog);
	arrowRight2=TTF_RenderUTF8_Blended(fontArrow,">",themeTextColorDialog);

	TTF_CloseFont(fontArrow);
	}

	bool loadTheme(string name){
	//Load default fallback theme if it isn't loaded yet
	if(objThemes.themeCount()==0){
	if(objThemes.appendThemeFromFile(getDataPath()+"themes/Cloudscape/theme.mnmstheme")==NULL){
	printf("ERROR: Can't load default theme file\n");
	return false;
	}
	}

	//Resize background or load specific theme
	if(name==""\|\|name.empty()){
	objThemes.scaleToScreen();
	}else{
	string theme=processFileName(name);
	if(objThemes.appendThemeFromFile(theme+"/theme.mnmstheme")==NULL){
	printf("ERROR: Can't load theme %s\n",theme.c_str());
	return false;
	}
	}

	generateArrows();

	//Everything went fine so return true.
	return true;
	}

	static Mix_Chunk* loadWAV(const char* s){
	Mix_Chunk* c=Mix_LoadWAV(s);
	if(c!=NULL) return c;
	printf("ERROR: Can't load sound file %s: %s\n",s,SDL_GetError());
	return NULL;
	}

	bool loadFiles(){
	//Load the fonts.
	if(!loadFonts())
	return false;

	//Show a loading screen
	{
	SDL_Rect r={0,0,screen->w,screen->h};
	SDL_FillRect(screen,&r,0);

	SDL_Color fg={255,255,255};
	SDL_Surface *surface=TTF_RenderUTF8_Blended(fontTitle,_("Loading..."),fg);
	if(surface!=NULL){
	r.x=(screen->w-surface->w)/2;
	r.y=(screen->h-surface->h)/2;
	SDL_BlitSurface(surface,NULL,screen,&r);
	SDL_FreeSurface(surface);
	}

	SDL_Flip(screen);
	}

	musicManager.destroy();
	//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 configured music list.
	getMusicManager()->loadMusicList((getDataPath()+"music/"+getSettings()->getValue("musiclist")+".list"));
	getMusicManager()->setMusicList(getSettings()->getValue("musiclist"));

	//Check if music is enabled.
	if(getSettings()->getBoolValue("music"))
	getMusicManager()->setEnabled();

	//Load the sound effects
	jumpSound=loadWAV((getDataPath()+"sfx/jump.wav").c_str());
	hitSound=loadWAV((getDataPath()+"sfx/hit.wav").c_str());
	saveSound=loadWAV((getDataPath()+"sfx/checkpoint.wav").c_str());
	swapSound=loadWAV((getDataPath()+"sfx/swap.wav").c_str());
	toggleSound=loadWAV((getDataPath()+"sfx/toggle.wav").c_str());
	errorSound=loadWAV((getDataPath()+"sfx/error.wav").c_str());
	collectSound=loadWAV((getDataPath()+"sfx/collect.wav").c_str());
	achievementSound=loadWAV((getDataPath()+"sfx/achievement.ogg").c_str());

	levelPackManager.destroy();
	//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 statistics
	statsMgr.loadPicture();
	statsMgr.registerAchievements();
	statsMgr.loadFile(getUserPath(USER_CONFIG)+"statistics");

	//Do something ugly and slow
	statsMgr.reloadCompletedLevelsAndAchievements();
	statsMgr.reloadOtherAchievements();

	//Load the theme, both menu and default.
	if(!loadTheme(getSettings()->getValue("theme")))
	return false;

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

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

	//Now apply settings changed through command line arguments, if any.
	map<string,string>::iterator it;
	for(it=tmpSettings.begin();it!=tmpSettings.end();++it){
	settings->setValue(it->first,it->second);
	}
	tmpSettings.clear();

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

	+ScriptExecutor* getScriptExecutor(){
	+ return &scriptExecutor;
	+}
	+
	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);
	glTexCoord2i(0,0); glVertex3f(0,0,0);
	glTexCoord2i(1,0); glVertex3f(SCREEN_WIDTH,0,0);
	glTexCoord2i(1,1); glVertex3f(SCREEN_WIDTH,SCREEN_HEIGHT,0);
	glTexCoord2i(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(){
	//Save statistics
	statsMgr.saveFile(getUserPath(USER_CONFIG)+"statistics");

	//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 all sounds
	Mix_FreeChunk(jumpSound);
	Mix_FreeChunk(hitSound);
	Mix_FreeChunk(saveSound);
	Mix_FreeChunk(swapSound);
	Mix_FreeChunk(toggleSound);
	Mix_FreeChunk(errorSound);
	Mix_FreeChunk(collectSound);
	Mix_FreeChunk(achievementSound);

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

	//Close all joysticks.
	inputMgr.closeAllJoysticks();

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

	//Remove the temp surface.
	SDL_FreeSurface(tempSurface);

	//Stop audio.and quit
	Mix_CloseAudio();
	#ifndef __APPLE__
	Mix_Quit();
	#endif
	//And finally quit SDL.
	SDL_Quit();
	}

	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;
	case STATE_CREDITS:
	currentState=new Credits();
	break;
	case STATE_STATISTICS:
	currentState=new StatisticsScreen();
	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(const SDL_Rect* r,int count){
	//SetCamera only works in the Level editor and when mouse is inside window.
	if(stateID==STATE_LEVEL_EDITOR&&(SDL_GetAppState()&SDL_APPMOUSEFOCUS)){
	//Get the mouse coordinates.
	int x,y;
	SDL_GetMouseState(&x,&y);
	SDL_Rect mouse={x,y,0,0};

	//Don't continue here if mouse is inside one of the boxes given as parameter.
	for(int i=0;i<count;i++){
	if(checkCollision(mouse,r[i]))
	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;
	}
	}
	}

	int 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 -1;
	}

	//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 -1;
	}

	//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=="-f" \|\| argument=="-fullscreen" \|\| argument=="--fullscreen"){
	tmpSettings["fullscreen"]="1";
	}else if(argument=="-w" \|\| argument=="-windowed" \|\| argument=="--windowed"){
	tmpSettings["fullscreen"]="0";
	}else if(argument=="-mv" \|\| argument=="-music" \|\| argument=="--music"){
	//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 -1;
	}

	//Now set the music volume.
	tmpSettings["music"]=argv[i];
	}else if(argument=="-sv" \|\| argument=="-sound" \|\| argument=="--sound"){
	//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 -1;
	}

	//Now set sound volume.
	tmpSettings["sound"]=argv[i];
	}else if(argument=="-set" \|\| argument=="--set"){
	//We need a second and a third argument so we increase i.
	i+=2;
	if(i>=argc){
	printf("ERROR: Missing argument for command '%s'\n\n",argument.c_str());
	return -1;
	}

	//And set the setting.
	tmpSettings[argv[i-1]]=argv[i];
	}else if(argument=="-v" \|\| argument=="-version" \|\| argument=="--version"){
	//Print the version.
	printf("%s\n",version.c_str());
	return 0;
	}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 -1;
	}else{
	//Any other argument is unknow so we return false.
	printf("ERROR: Unknown argument %s\n\n",argument.c_str());
	return -1;
	}
	}

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

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

	//Create the GUIObjectRoot, the height and y location is temp.
	//It depends on the content what it will be.
	GUIObject* root=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;

	//Add a GUIObjectLabel with the sentence.
	root->addChild(new GUIObject(0,y,root->width,25,GUIObjectLabel,lps,0,true,true,GUIGravityCenter));
	//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.
	root->top=(SCREEN_HEIGHT-y)/2;
	root->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.
	{
	//Reduce y so that the buttons fit inside the frame.
	y-=40;

	double places[3]={0.0};
	if(count==1){
	places[0]=0.5;
	}else if(count==2){
	places[0]=0.4;
	places[1]=0.6;
	}else if(count==3){
	places[0]=0.3;
	places[1]=0.5;
	places[2]=0.7;
	}

	//Loop to add the buttons.
	for(int i=0;i<count;i++){
	obj=new GUIObject(root->width*places[i],y,-1,36,GUIObjectButton,button[i].c_str(),value[i],true,true,GUIGravityCenter);
	obj->eventCallback=&objHandler;
	root->addChild(obj);
	}
	}

	//Now we dim the screen and keep the GUI rendering/updating.
	GUIOverlay* overlay=new GUIOverlay(root);
	overlay->enterLoop(true);

	//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),lstFile(NULL),extension(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 %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;

	//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.empty()?20:60;

	//Create the frame.
	GUIObject* root=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.empty()){
	root->addChild(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;
	root->addChild(obj1);
	}

	//Add the FileName label and textfield.
	root->addChild(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());
	root->addChild(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;
	root->addChild(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;
	root->addChild(obj);
	obj=new GUIObject(400,360+base_y,192,36,GUIObjectButton,_("Cancel"));
	obj->name="cmdCancel";
	obj->eventCallback=&objHandler;
	root->addChild(obj);

	//Create the gui overlay.
	GUIOverlay* overlay=new GUIOverlay(root);
	overlay->enterLoop();

	//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/Functions.h b/src/Functions.h
	index c4c8928..bfcd4f3 100644
	--- a/src/Functions.h
	+++ b/src/Functions.h
	@@ -1,249 +1,252 @@
	/*
	* Copyright (C) 2011-2012 Me and My Shadow
	*
	* This file is part of Me and My Shadow.
	*
	* Me and My Shadow 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 3 of the License, or
	* (at your option) any later version.
	*
	* Me and My Shadow 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 Me and My Shadow. If not, see <http://www.gnu.org/licenses/>.
	*/

	#ifndef FUNCTIONS_H
	#define FUNCTIONS_H

	#include "Settings.h"
	#include "MusicManager.h"
	#include "LevelPackManager.h"
	+#include "ScriptExecutor.h"
	#include "Globals.h"

	#include <SDL/SDL.h>
	#include <string>
	#include <vector>

	//gettext function
	//message: The message to translate.
	//Returns: The translated string or the original string if there is not translation available.
	#define _(message) (dictionaryManager!=NULL?dictionaryManager->get_dictionary().translate(message).c_str():std::string(message).c_str())
	//gettext function
	//dictionaryManager: Pointer to the dictionaryManager to use for the translation.
	//message: The message to translate.
	//Returns: The translated string or the original string if there is not translation available.
	#define _C(dictionaryManager, message) ((dictionaryManager)!=NULL?(dictionaryManager)->get_dictionary().translate(message).c_str():std::string(message).c_str())
	//dummy function for xgettext
	//message: The message to translate.
	//Returns: message parameter
	#define __(message) (message)

	//Loads an image.
	//file: The image file to load.
	//Returns: The SDL_surface containing the image.
	SDL_Surface* loadImage(std::string file);

	//Method for drawing an SDL_Surface onto another.
	//x: The x location to draw the source on the desination.
	//y: The y location to draw the source on the desination.
	//source: The SDL_Surface to draw.
	//dest: The SDL_Surface to draw on.
	//clip: Rectangle which part of the source should be drawn.
	void applySurface(int x,int y,SDL_Surface* source,SDL_Surface* dest,SDL_Rect* clip);

	//Method used to draw an rectangle.
	//x: The top left x location of the rectangle.
	//y: The top left y location of the rectangle.
	//w: The width of the rectangle,
	//h: The height of the rectangle.
	//dest: The SDL_Surface to draw on.
	//color: The color of the rectangle border to draw.
	void drawRect(int x,int y,int w,int h,SDL_Surface* dest,Uint32 color=0);

	//Method used to draw filled boxes with an anti-alliased border.
	//Mostly used for GUI components.
	//x: The top left x location of the box.
	//y: The top left y location of the box.
	//w: The width of the box,
	//h: The height of the box.
	//dest: The SDL_Surface to draw on.
	//color: The color of the rectangle background to draw.
	void drawGUIBox(int x,int y,int w,int h,SDL_Surface* dest,Uint32 color);

	//Method used to draw a line.
	//x1: The x location of the start point.
	//y1: The y location of the start point.
	//x2: The x location of the end point.
	//y2: The y location of the end point.
	//dest: The SDL_Surface to draw on.
	//color: The color of the line to draw.
	void drawLine(int x1,int y1,int x2,int y2,SDL_Surface* dest,Uint32 color=0);

	//Method used to draw a line with some arrows on it.
	//x1: The x location of the start point.
	//y1: The y location of the start point.
	//x2: The x location of the end point.
	//y2: The y location of the end point.
	//dest: The SDL_Surface to draw on.
	//color: The color of the line to draw.
	//spacing: The spacing between arrows.
	//offset: Offset of first arrow relative to the start point.
	//xize, ysize: The size of arrow.
	void drawLineWithArrow(int x1,int y1,int x2,int y2,SDL_Surface* dest,Uint32 color=0,int spacing=16,int offset=0,int xsize=5,int ysize=5);

	//Method that will load the fonts needed for the game.
	//NOTE: It's separate from loadFiles(), since it might get called separatly from the code when changing the language.
	bool loadFonts();
	//Method that will load the default theme again.
	//name: name of the theme to load or empty for scaling background
	//NOTE: It's separate from loadFiles(), since it might get called separatly from the code when changing resolution.
	bool loadTheme(string name);
	//This method will attempt to create the screen/window.
	//NOTE: It's separate from init(), since it might get called separatly from the code when changing resolution.
	bool createScreen();

	//Method that is called when a fullscreen window is created.
	//It will choose the resolution that is closest to the configured one.
	void pickFullscreenResolution();

	//This method is used to configure the window that is created by createScreen.
	//NOTE: It will do it in a WM specific way, so if the wm is unkown it will do nothing.
	//initial: Boolean that is true if it's the first time the window is configured.
	void configureWindow(bool initial);

	//Call this method when receive SDL_VIDEORESIZE event.
	void onVideoResize();

	//Initialises the game. This is done almost at the beginning of the program.
	//It initialises: SDL, SDL_Mixer, SDL_ttf, the screen and the block types.
	//Returns: True if everything goes well.
	bool init();
	//Loads some important files, like the background music and the default theme.
	//Returns: True if everything goes well.
	bool loadFiles();

	//This method will load the settings from the settings file.
	//Returns: False if there's an error while loading.
	bool loadSettings();
	//This method will save the settings to the settings file.
	//Returns: False if there's an error while saving.
	bool saveSettings();
	//Method used to get a pointer to the settings object.
	//Returns: A pointer to the settings object.
	Settings* getSettings();

	//Method used to get a pointer to the MusicManager object.
	//Returns: A pointer to the MusicManager object.
	MusicManager* getMusicManager();

	//Method used to get a pointer to the LevelPackManager object.
	//Returns: A pointer to the LevelPackManager object.
	LevelPackManager* getLevelPackManager();

	+ScriptExecutor* getScriptExecutor();
	+
	//Method that will, depending on the rendering backend, draw the screen surface to the screen.
	void flipScreen();

	//Method used to clean up before quiting meandmyshadow.
	void clean();

	//Sets what the nextState will be.
	//newstate: Integer containing the id of the newstate.
	void setNextState(int newstate);
	//Method that will perform the state change.
	//It will fade out and in.
	void changeState();

	//This method is called when music is stopped.
	//NOTE: This method is outside the MusicManager because it couldn't be called otherwise.
	//Do not call this method anywhere in the code!
	void musicStoppedHook();

	//Checks collision between two SDL_Rects.
	//a: The first rectangle.
	//b: The second rectangle.
	//Returns: True if the two rectangles collide.
	bool checkCollision(const SDL_Rect& a,const SDL_Rect& b);

	//This method will check if the mouse is near a screen edge.
	//r: An array of SDL_Rect, does nothing if mouse inside these rectange(s).
	//count: Number of rectangles.
	//If so it will move the camera.
	//Note: This function only works with the leveleditor.
	void setCamera(const SDL_Rect* r,int count);

	//Parse the commandline arguments.
	//argc: Integer containing the number of aruguments there are.
	//argv: The arguments.
	//Returns: -1 if something goes wrong while parsing,
	// 0 if version is shown,
	// 1 if everything is alright
	int parseArguments(int argc, char** argv);

	//From http://en.wikipedia.org/wiki/Clamping_(graphics)
	//x: The value to clamp.
	//min: The minimum x can be.
	//max: The maximum x can be.
	//Returns: Integer containing the clamped value.
	int inline clamp(int x,int min,int max){
	return (x>max)?max:(x<min)?min:x;
	}

	//Enumeration containing the different messagebox button combinations.
	enum msgBoxButtons{
	//Only one button with the text OK.
	MsgBoxOKOnly=0,
	//Two buttons, one saying OK, the other Cancel.
	MsgBoxOKCancel=1,
	//Three buttons, Abort, Retry, Ignore.
	MsgBoxAbortRetryIgnore=2,
	//Three buttons, Yes, No or Cancel.
	MsgBoxYesNoCancel=3,
	//Two buttons, one saying Yes, the other No.
	MsgBoxYesNo=4,
	//Two buttons, one saying Retry, the other Cancel.
	MsgBoxRetryCancel=5,
	};

	//Enumeration containing the different result that can be retrieved from a messagebox.
	//It represents the button that has been pressed.
	enum msgBoxResult{
	//The OK button.
	MsgBoxOK=1,
	//The cancel button.
	MsgBoxCancel=2,
	//The abort button.
	MsgBoxAbort=3,
	//The retry button.
	MsgBoxRetry=4,
	//The ignore button.
	MsgBoxIgnore=5,
	//The yes button.
	MsgBoxYes=6,
	//The no button.
	MsgBoxNo=7,
	};

	//Method that prompts the user with a notification and/or question.
	//prompt: The message the user is prompted with.
	//buttons: Which buttons the messagebox should have.
	//title: The title of the message box.
	//Returns: A msgBoxResult which button has been pressed.
	msgBoxResult msgBox(std::string prompt,msgBoxButtons buttons,const std::string& title);

	//This method will show a file dialog in which the user can select a file.
	//NOTE: It doesn't support entering folders.
	//fileName: String that will contain the result, it can also be used to already chose the file.
	//title: The title of the fileDialog window.
	//extension: The extension the files must have, leave empty for all files.
	//path: The path to list the files of.
	//isSave: If the dialog is for saving files, and not loading.
	//verifyFile: Boolean if the selected should be verified.
	//files: Boolean if the fileDialog should display files, if not it will display directories.
	bool fileDialog(std::string& fileName,const char* title=NULL,const char* extension=NULL,const char* path=NULL,bool isSave=false,bool verifyFile=false,bool files=true);

	#endif
	diff --git a/src/Game.h b/src/Game.h
	index b8c4a6e..a04a53a 100644
	--- a/src/Game.h
	+++ b/src/Game.h
	@@ -1,221 +1,221 @@
	/*
	* Copyright (C) 2011-2012 Me and My Shadow
	*
	* This file is part of Me and My Shadow.
	*
	* Me and My Shadow 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 3 of the License, or
	* (at your option) any later version.
	*
	* Me and My Shadow 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 Me and My Shadow. If not, see <http://www.gnu.org/licenses/>.
	*/

	#ifndef GAME_H
	#define GAME_H

	#include <SDL/SDL.h>
	#ifdef __APPLE__
	#include <SDL_mixer/SDL_mixer.h>
	#include <SDL_ttf/SDL_ttf.h>
	#else
	#include <SDL/SDL_mixer.h>
	#include <SDL/SDL_ttf.h>
	#endif
	#include <vector>
	#include <map>
	#include <string>
	#include "GameState.h"
	#include "GUIObject.h"
	#include "GameObjects.h"
	#include "Player.h"
	#include "Shadow.h"

	//This structure contains variables that make a GameObjectEvent.
	struct typeGameObjectEvent{
	//The type of event.
	int eventType;
	//The type of object that should react to the event.
	int objectType;
	//Flags, 0x1 means use the id.
	int flags;
	//Blocks with this id should react to the event.
	std::string id;
	};

	class ThemeManager;
	class ThemeBackground;
	class TreeStorageNode;

	class Game : public GameState,public GUIEventCallback{
	private:
	//Boolean if the game should reset.
	bool isReset;

	//contains currently played level.
	TreeStorageNode* currentLevelNode;

	protected:
	//Array containing "tooltips" for certain block types.
	//It will be shown in the topleft corner of the screen.
	SDL_Surface* bmTips[TYPE_MAX];

	//SDL_Surface containing the action images (record, play, etc..)
	SDL_Surface* action;
	//SDL_Surface containing the medal image.
	SDL_Surface* medals;
	//SDL_Surface containing the collectable image.
	SDL_Surface* collectable;

	- //Vector containing all the levelObjects in the current game.
	- std::vector<GameObject*> levelObjects;
	-
	//The name of the current level.
	std::string levelName;
	//The path + file of the current level.
	std::string levelFile;

	//Editor data containing information like name, size, etc...
	std::map<std::string,std::string> editorData;

	//Vector used to queue the gameObjectEvents.
	std::vector<typeGameObjectEvent> eventQueue;

	//The themeManager.
	ThemeManager* customTheme;
	//The themeBackground.
	ThemeBackground* background;

	//Load a level from node.
	//After calling this function the ownership of
	//node will transfer to Game class. So don't delete
	//the node after calling this function!
	virtual void loadLevelFromNode(TreeStorageNode* obj, const std::string& fileName);

	public:
	//Array used to convert GameObject type->string.
	static const char* blockName[TYPE_MAX];
	//Map used to convert GameObject string->type.
	static std::map<std::string,int> blockNameMap;

	//Boolean that is set to true when a game is won.
	bool won;

	//Boolean that is set to true when we should save game on next logic update.
	bool saveStateNextTime;

	//Boolean that is set to true when we should load game on next logic update.
	bool loadStateNextTime;

	//Boolean if the replaying currently done is for the interlevel screen.
	bool interlevel;

	//X position of second medal in interlevel popup
	int medalX;

	//Integer containing the current tip index.
	int gameTipIndex;

	//Integer containing the number of ticks passed since the start of the level.
	int time;
	//Integer containing the stored value of time.
	int timeSaved;

	//Integer containing the number of recordings it took to finish.
	int recordings;
	//Integer containing the stored value of recordings.
	int recordingsSaved;

	//Integer keeping track of currently obtained collectables
	int currentCollectables;
	//Integer keeping track of total colletables in the level
	int totalCollectables;
	//Integer containing the stored value of current collectables
	int currentCollectablesSaved;

	//Boolean if the camera should follow the shadow or not.
	bool shadowCam;

	+ //Vector containing all the levelObjects in the current game.
	+ std::vector<GameObject*> levelObjects;
	+
	//The player...
	Player player;
	//... and his shadow.
	Shadow shadow;

	//warning: weak reference only, may point to invalid location
	GameObject* objLastCheckPoint;

	//Constructor.
	//loadLevel: Boolean if the GameState should load the level.
	Game(bool loadLevel=true);
	//If this is not empty then when next Game class is created
	//it will play this record file.
	static std::string recordFile;
	//Destructor.
	//It will call destroy();
	~Game();

	//Method used to clean up the GameState.
	void destroy();

	//Inherited from GameState.
	void handleEvents();
	void logic();
	void render();
	void resize();

	//This method will load a level.
	//fileName: The fileName of the level.
	virtual void loadLevel(std::string fileName);

	//Method used to broadcast a GameObjectEvent.
	//eventType: The type of event.
	//objectType: The type of object that should react to the event.
	//id: The id of the blocks that should react.
	void broadcastObjectEvent(int eventType,int objectType=-1,const char* id=NULL);

	//Returns if the player and shadow can save the current state.
	bool canSaveState();

	//Method used to store the current state.
	//This is used for checkpoints.
	//Returns: True if it succeeds without problems.
	bool saveState();
	//Method used to load the stored state.
	//This is used for checkpoints.
	//Returns: True if it succeeds without problems.
	bool loadState();
	//Method that will reset the GameState to it's initial state.
	//save: Boolean if the saved state should also be delted.
	void reset(bool save);

	//Save current game record to the file.
	//fileName: The filename of the destination file.
	void saveRecord(const char* fileName);
	//Load game record (and its level) from file and play it.
	//fileName: The filename of the recording file.
	void loadRecord(const char* fileName);

	//Method called by the player (or shadow) when he finished.
	void replayPlay();
	//Method that gets called when the recording has ended.
	void recordingEnded();

	//get current level's auto-save record path,
	//using current level's MD5, file name and other information.
	void getCurrentLevelAutoSaveRecordPath(std::string &bestTimeFilePath,std::string &bestRecordingFilePath,bool createPath);

	//Method that will prepare the gamestate for the next level and start it.
	//If it's the last level it will show the congratulations text and return to the level select screen.
	void gotoNextLevel();

	//GUI event handling is done here.
	void GUIEventCallback_OnEvent(std::string name,GUIObject* obj,int eventType);
	};

	#endif
	diff --git a/src/Globals.h b/src/Globals.h
	index 506ea46..79d469b 100644
	--- a/src/Globals.h
	+++ b/src/Globals.h
	@@ -1,231 +1,231 @@
	/*
	* Copyright (C) 2011-2012 Me and My Shadow
	*
	* This file is part of Me and My Shadow.
	*
	* Me and My Shadow 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 3 of the License, or
	* (at your option) any later version.
	*
	* Me and My Shadow 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 Me and My Shadow. If not, see <http://www.gnu.org/licenses/>.
	*/

	#ifndef GLOBALS_H
	#define GLOBALS_H

	#ifdef __APPLE__
	#include <SDL_mixer/SDL_mixer.h>
	#include <SDL_ttf/SDL_ttf.h>
	#else
	#include <SDL/SDL_mixer.h>
	#include <SDL/SDL_ttf.h>
	#endif
	#include <string>
	#include "libs/tinygettext/tinygettext.hpp"

	#if defined (WIN32) \|\| defined (__APPLE__)
	//#define DATA_PATH
	#else
	#include "config.h"
	#endif

	#define TITLE_FONT_RAISE 19
	#define GUI_FONT_RAISE 5

	//Global constants
	//The width of the screen.
	extern int SCREEN_WIDTH;
	//The height of the screen.
	extern int SCREEN_HEIGHT;
	//The depth of the screen.
	const int SCREEN_BPP=32;

	//SDL interprets each pixel as a 32-bit number,
	// so our masks must depend on the endianness (byte order) of the machine.
	//NOTE: We define them here so we only have to do it once.
	#if SDL_BYTEORDER == SDL_BIG_ENDIAN
	const Uint32 RMASK=0xFF000000;
	const Uint32 GMASK=0x00FF0000;
	const Uint32 BMASK=0x0000FF00;
	const Uint32 AMASK=0x000000FF;
	#else
	const Uint32 RMASK=0x000000FF;
	const Uint32 GMASK=0x0000FF00;
	const Uint32 BMASK=0x00FF0000;
	const Uint32 AMASK=0xFF000000;
	#endif

	-//Strin containing the
	+//String containing the version, used in the titelbar.
	const std::string version="V0.5 Development version";

	//The height of the current level.
	extern int LEVEL_HEIGHT;
	//The width of the current level.
	extern int LEVEL_WIDTH;

	//The target frames per seconds.
	const int FPS=40;

	//The language that in which the game should be translated.
	extern std::string language;
	//The DictionaryManager that is used to translate the game itself.
	extern tinygettext::DictionaryManager* dictionaryManager;

	//The screen surface, it's used to draw on before it's drawn to the real screen.
	extern SDL_Surface* screen;
	//SDL_Surface with the same dimensions as screen which can be used for all kinds of (temp) drawing.
	extern SDL_Surface* tempSurface;

	//Font that is used for titles.
	//Knewave large.
	extern TTF_Font* fontTitle;
	//Font that is used for captions of buttons and other GUI elements.
	//Knewave small.
	extern TTF_Font* fontGUI;
	//Font that is used for long captions of buttons and other GUI elements.
	//Knewave smaller.
	extern TTF_Font* fontGUISmall;
	//Font that is used for (long) text.
	//Blokletter-Viltstift small.
	extern TTF_Font* fontText;

	//Small arrows used for GUI widgets.
	//2 directions and 2 different/same colors depending on theme.
	extern SDL_Surface* arrowLeft1;
	extern SDL_Surface* arrowRight1;
	extern SDL_Surface* arrowLeft2;
	extern SDL_Surface* arrowRight2;

	//Sound played when the player jumps.
	extern Mix_Chunk* jumpSound;
	//Sound played when the player dies.
	extern Mix_Chunk* hitSound;
	//Sound played when the saves a state.
	extern Mix_Chunk* saveSound;
	//Sound played when the player swaps.
	extern Mix_Chunk* swapSound;
	//Sound played when the player toggles a switch.
	extern Mix_Chunk* toggleSound;
	//The sound played when the player tries something that doesn't work.
	//For example a broken portal or swapping the shadow into a shadow block.
	extern Mix_Chunk* errorSound;
	//Sound played when the player picks up a collectable.
	extern Mix_Chunk* collectSound;
	//Sound played when an achievement is achieved..
	extern Mix_Chunk* achievementSound;

	//Event, used for event handling.
	extern SDL_Event event;

	//GUI
	class GUIObject;
	extern GUIObject *GUIObjectRoot;

	//The state id of the current state.
	extern int stateID;
	//Integer containing what the next state will be.
	extern int nextState;

	//String containing the name of the current level.
	extern std::string levelName;

	//SDL rectangle used to store the camera.
	//x is the x location of the camera.
	//y is the y location of the camera.
	//w is the width of the camera. (equal to SCREEN_WIDTH)
	//h is the height of the camera. (equal to SCREEN_HEIGHT)
	extern SDL_Rect camera;

	//Themable colors
	extern SDL_Color themeTextColor;
	extern SDL_Color themeTextColorDialog;

	//Enumeration containing the ids of the game states.
	enum GameStates
	{
	//State null is a special state used to indicate no state.
	//This is used when no next state is defined.
	STATE_NULL,

	//This state is before the actual leveleditor used to make levelpacks.
	STATE_LEVEL_EDIT_SELECT,
	//This state is for the level editor.
	STATE_LEVEL_EDITOR,
	//This state is for the main menu.
	STATE_MENU,
	//This state is for the actual game.
	STATE_GAME,
	//Special state used when exiting meandmyshadow.

	STATE_EXIT,
	//This state is for the help screen.

	STATE_LEVEL_SELECT,
	//This state is for the options screen.
	STATE_OPTIONS,
	//This state is for the addon screen.
	STATE_ADDONS,
	//This state is for credits screen
	STATE_CREDITS,
	//This state is for statistics screen
	STATE_STATISTICS,
	};

	//Enumeration containing the ids of the different block types.
	enum GameTileType{
	//The normal solid block.
	TYPE_BLOCK=0,
	//Block representing the start location of the player.
	TYPE_START_PLAYER,
	//Block representing the start location of the shadow.
	TYPE_START_SHADOW,
	//The exit of the level.
	TYPE_EXIT,
	//The shadow block which is only solid for the shadow.
	TYPE_SHADOW_BLOCK,
	//Block that can kill both the player and the shadow.
	TYPE_SPIKES,

	//Special point where the player can save.
	TYPE_CHECKPOINT,
	//Block that will switch the location of the player and the shadow when invoked.
	TYPE_SWAP,
	//Block that will crumble to dust when stepped on it for the third time.
	TYPE_FRAGILE,

	//Normal block that moves along a path.
	TYPE_MOVING_BLOCK,
	//Shadow block that moves along a path.
	TYPE_MOVING_SHADOW_BLOCK,
	//A spike block that moves along a path.
	TYPE_MOVING_SPIKES,

	//Special block which, once entered, moves the player/shadow to a different portal.
	TYPE_PORTAL,
	//A block with a button which can activate or stop moving blocks, converyor belts
	TYPE_BUTTON,
	//A switch which can activate or stop moving blocks, converyor belts
	TYPE_SWITCH,

	//Solid block which works like
	TYPE_CONVEYOR_BELT,
	TYPE_SHADOW_CONVEYOR_BELT,

	//Block that contains a message that can be read.
	TYPE_NOTIFICATION_BLOCK,

	//A collectable that is able to open locked doors
	TYPE_COLLECTABLE,

	//The (max) number of tiles.
	TYPE_MAX
	};

	#endif
	diff --git a/src/ScriptAPI.h b/src/ScriptAPI.h
	new file mode 100644
	index 0000000..21c6e4c
	--- /dev/null
	+++ b/src/ScriptAPI.h
	@@ -0,0 +1,27 @@
	+/*
	+ * Copyright (C) 2012 Me and My Shadow
	+ *
	+ * This file is part of Me and My Shadow.
	+ *
	+ * Me and My Shadow 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 3 of the License, or
	+ * (at your option) any later version.
	+ *
	+ * Me and My Shadow 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 Me and My Shadow. If not, see <http://www.gnu.org/licenses/>.
	+ */
	+
	+int test(lua_State* state){
	+ cerr<<"Hello world"<<endl;
	+ return 0;
	+}
	+
	+void registerFunctions(ScriptExecutor* executor){
	+ executor->registerFunction("test",test);
	+}
	diff --git a/src/ScriptExecutor.cpp b/src/ScriptExecutor.cpp
	new file mode 100644
	index 0000000..40e7584
	--- /dev/null
	+++ b/src/ScriptExecutor.cpp
	@@ -0,0 +1,40 @@
	+/*
	+ * Copyright (C) 2012 Me and My Shadow
	+ *
	+ * This file is part of Me and My Shadow.
	+ *
	+ * Me and My Shadow 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 3 of the License, or
	+ * (at your option) any later version.
	+ *
	+ * Me and My Shadow 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 Me and My Shadow. If not, see <http://www.gnu.org/licenses/>.
	+ */
	+
	+#include "ScriptExecutor.h"
	+
	+ScriptExecutor::ScriptExecutor(){
	+ //Initialize the state.
	+ state=lua_open();
	+
	+ //Load the lua libraries.
	+ luaL_openlibs(state);
	+}
	+
	+ScriptExecutor::~ScriptExecutor(){
	+ lua_close(state);
	+}
	+
	+void ScriptExecutor::registerFunction(std::string name,lua_CFunction function){
	+ lua_register(state,name.c_str(),function);
	+}
	+
	+void ScriptExecutor::executeScript(Script script){
	+ luaL_dostring(state,script.script);
	+}
	diff --git a/src/ScriptExecutor.h b/src/ScriptExecutor.h
	new file mode 100644
	index 0000000..7abd09b
	--- /dev/null
	+++ b/src/ScriptExecutor.h
	@@ -0,0 +1,56 @@
	+/*
	+ * Copyright (C) 2012 Me and My Shadow
	+ *
	+ * This file is part of Me and My Shadow.
	+ *
	+ * Me and My Shadow 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 3 of the License, or
	+ * (at your option) any later version.
	+ *
	+ * Me and My Shadow 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 Me and My Shadow. If not, see <http://www.gnu.org/licenses/>.
	+ */
	+
	+#ifndef SCRIPTEXECUTOR_H
	+#define SCRIPTEXECUTOR_H
	+
	+extern "C" {
	+#include "lua.h"
	+#include "lualib.h"
	+#include "lauxlib.h"
	+}
	+#include <string>
	+
	+//Structure that holds a script.
	+struct Script{
	+ const char* script;
	+};
	+
	+//Class used for executing scripts.
	+class ScriptExecutor{
	+public:
	+ //Constructor.
	+ ScriptExecutor();
	+ //Destructor.
	+ ~ScriptExecutor();
	+
	+ //Add a function for script to use.
	+ //name: The name used in the lua scripts.
	+ //function: Pointer to the function.
	+ void registerFunction(std::string name,lua_CFunction function);
	+
	+ //Method that will execute a given script.
	+ //script: The script structure to execute.
	+ void executeScript(Script script);
	+private:
	+ //The state that will execute the scripts.
	+ lua_State* state;
	+};
	+
	+#endif

File Metadata

Mime Type: text/x-diff
Expires: Sat, May 16, 2:27 AM (7 h, 7 m)
Storage Engine: blob
Storage Format: Raw Data
Storage Handle: 64000
Default Alt Text: (86 KB)

No OneTemporaryActions

View Options

File Metadata

Event Timeline

No OneTemporary
Actions