No OneTemporary
Actions

Authored By

Unknown

Size

124 KB

Referenced Files

None

Subscribers

None

View Options

	diff --git a/docs/Controls.md b/docs/Controls.md
	index 5127ea1..93139db 100644
	--- a/docs/Controls.md
	+++ b/docs/Controls.md
	@@ -1,46 +1,46 @@
	This file contains the default controls. The controls like `this` indicates that you can change them in the options menu.

	In main menu and level select screen:
	* `Up/Down/Left/Right` = Navigation
	* `Enter` = Select menu entry
	* `Esc` = Return to previous screen

	In game:
	* `Left` = left
	* `Right` = right
	* `Up` = jump
	* `Down` = action
	* `Space` = recording
	* `(unassigned by default)` = Cancel recording
	* `Tab` = Switch the view from/to shadow
	* `R` = Restart level
	* `F3` = Load last checkpoint (if any)
	* `Esc` = Return to previous screen

	In level editor:
	* Ctrl+X = Cut
	* Ctrl+C = Copy
	* Ctrl+V = Paste
	* Ctrl+S = Save level
	* Ctrl+Z = Undo
	* Ctrl+Y = Redo
	* Delete = Delete selected blocks
	* F2 = Select mode
	* F3 = Add mode
	* F4 = Delete mode
	* F5 = test play
	* Left click = Select block in select mode, add block in add mode, delete block in delete mode, add new path point in path mode
	* Right click = Open popup menu in select/add mode, end path/link mode
	* Backspace = Remove a path point in path mode
	* `Up/Down/Left/Right` = Moving camera
	* Mousewheel or `,/.` = Select previous/next block type in add mode, adjust speed/time when configuring moving blocks, and moving camera on other mode
	* `Tab` = Level settings
	-* `Shift` = Don't snap to grid when add/move blocks
	+* `Right Shift` = Don't snap to grid when add/move blocks
	* `Esc` = Return to previous screen

	In level editor (test play): besides in-game controls, there are
	* `F2` = Save game
	* `F4` = Swap player and shadow's position
	* `F5` = Place player at mouse location.
	* `F12` = Suicide

	diff --git a/src/Game.cpp b/src/Game.cpp
	index 45be400..8efe39b 100644
	--- a/src/Game.cpp
	+++ b/src/Game.cpp
	@@ -1,1712 +1,1712 @@
	/*
	* Copyright (C) 2011-2013 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 "Block.h"
	#include "GameState.h"
	#include "Functions.h"
	#include "GameObjects.h"
	#include "ThemeManager.h"
	#include "Game.h"
	#include "TreeStorageNode.h"
	#include "POASerializer.h"
	#include "InputManager.h"
	#include "MusicManager.h"
	#include "Render.h"
	#include "StatisticsManager.h"
	#include <fstream>
	#include <iostream>
	#include <sstream>
	#include <vector>
	#include <map>
	#include <algorithm>
	#include <locale>
	#include <stdio.h>
	#include <SDL_ttf.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", "Collectable", "Pushable"
	};

	map<string,int> Game::blockNameMap;
	map<int,string> Game::gameObjectEventTypeMap;
	map<string,int> Game::gameObjectEventNameMap;
	map<int,string> Game::levelEventTypeMap;
	map<string,int> Game::levelEventNameMap;
	string Game::recordFile;

	Game::Game(SDL_Renderer &renderer, ImageManager &imageManager):isReset(false)
	,currentLevelNode(NULL)
	,customTheme(NULL)
	,background(NULL)
	,won(false)
	,interlevel(false)
	,gameTipIndex(0)
	,time(0),timeSaved(0)
	,recordings(0),recordingsSaved(0)
	,cameraMode(CAMERA_PLAYER),cameraModeSaved(CAMERA_PLAYER)
	,player(this),shadow(this),objLastCheckPoint(NULL)
	,currentCollectables(0),totalCollectables(0),currentCollectablesSaved(0){

	saveStateNextTime=false;
	loadStateNextTime=false;

	recentSwap=recentSwapSaved=-10000;
	recentLoad=recentSave=0;

	action=imageManager.loadTexture(getDataPath()+"gfx/actions.png", renderer);
	medals=imageManager.loadTexture(getDataPath()+"gfx/medals.png", renderer);
	//Get the collectable image from the theme.
	//NOTE: Isn't there a better way to retrieve the image?
	objThemes.getBlock(TYPE_COLLECTABLE)->createInstance(&collectable);

	//Hide the cursor if not in the leveleditor.
	if(stateID!=STATE_LEVEL_EDITOR)
	SDL_ShowCursor(SDL_DISABLE);
	}

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

	//Before we leave make sure the cursor is visible.
	SDL_ShowCursor(SDL_ENABLE);
	}

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

	//Loop through the sceneryLayers and delete them.
	std::map<std::string,std::vector<Scenery*> >::iterator it;
	for(it=sceneryLayers.begin();it!=sceneryLayers.end();++it){
	for(unsigned int i=0;i<it->second.size();i++)
	delete it->second[i];
	}
	sceneryLayers.clear();

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

	//Remove everything from the themeManager.
	background=NULL;
	if(customTheme)
	objThemes.removeTheme();
	customTheme=NULL;
	//If there's a (partial) theme bundled with the levelpack remove that as well.
	if(levels->customTheme)
	objThemes.removeTheme();

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

	//Reset the time.
	time=timeSaved=0;
	recordings=recordingsSaved=0;
	recentSwap=recentSwapSaved=-10000;

	//Set the music list back to the configured list.
	getMusicManager()->setMusicList(getSettings()->getValue("musiclist"));
	}

	void Game::reloadMusic() {
	//NOTE: level music is always enabled.

	//Check if the levelpack has a prefered music list.
	if (levels && !levels->levelpackMusicList.empty())
	getMusicManager()->setMusicList(levels->levelpackMusicList);

	//Check for the music to use.
	string &s = editorData["music"];
	if (!s.empty()) {
	getMusicManager()->playMusic(s);
	} else {
	getMusicManager()->pickMusic();
	}
	}

	void Game::loadLevelFromNode(ImageManager& imageManager,SDL_Renderer& renderer,TreeStorageNode* obj,const string& fileName){
	//Make sure there's nothing left from any previous levels.
	//Not needed since loadLevelFromNode is only called from the changeState method, meaning it's a new instance of Game.
	//destroy();

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

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

	currentCollectables=0;
	totalCollectables=0;
	currentCollectablesSaved=0;

	//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.
	{
	//NOTE: level themes are always enabled.

	//Check for bundled (partial) themes for level pack.
	if (levels->customTheme){
	if (objThemes.appendThemeFromFile(levels->levelpackPath + "/theme/theme.mnmstheme", imageManager, renderer) == NULL){
	//The theme failed to load so set the customTheme boolean to false.
	levels->customTheme = false;
	}
	}

	//Check for the theme to use for this level. This has higher priority.
	//Examples: %DATA%/themes/classic or %USER%/themes/Orange
	string &s = editorData["theme"];
	if (!s.empty()){
	customTheme = objThemes.appendThemeFromFile(processFileName(s) + "/theme.mnmstheme", imageManager, renderer);
	}

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

	//Get the music.
	reloadMusic();

	//Load the data from the level node.
	for(unsigned int i=0;i<obj->subNodes.size();i++){
	TreeStorageNode* obj1=obj->subNodes[i];
	if(obj1==NULL) continue;
	if(obj1->name=="tile"){
	Block* block=new Block(this);
	if(!block->loadFromNode(imageManager,renderer,obj1)){
	delete block;
	continue;
	}

	//If the type is collectable, increase the number of totalCollectables
	if(block->type==TYPE_COLLECTABLE)
	totalCollectables++;

	//Add the block to the levelObjects vector.
	levelObjects.push_back(block);
	}else if(obj1->name=="scenerylayer" && obj1->value.size()==1){
	//Loop through the sub nodes.
	for(unsigned int j=0;j<obj1->subNodes.size();j++){
	TreeStorageNode* obj2=obj1->subNodes[j];
	if(obj2==NULL) continue;

	if(obj2->name=="object" \|\| obj2->name=="scenery"){
	//Load the scenery from node.
	Scenery* scenery=new Scenery(this);
	if(!scenery->loadFromNode(imageManager,renderer,obj2)){
	delete scenery;
	continue;
	}

	sceneryLayers[obj1->value[0]].push_back(scenery);
	}
	}
	}else if(obj1->name=="script" && !obj1->value.empty()){
	map<string,int>::iterator it=Game::levelEventNameMap.find(obj1->value[0]);
	if(it!=Game::levelEventNameMap.end()){
	int eventType=it->second;
	const std::string& script=obj1->attributes["script"][0];
	if(!script.empty()) scripts[eventType]=script;
	}
	}
	}

	//Close exits if there are collectables
	if(totalCollectables>0){
	for(unsigned int i=0;i<levelObjects.size();i++){
	if(levelObjects[i]->type==TYPE_EXIT){
	levelObjects[i]->onEvent(GameObjectEvent_OnSwitchOff);
	}
	}
	}

	//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 && levels->type!=COLLECTION){
	s=tfm::format(_("Level %d %s"),levels->getCurrentLevel()+1,_CC(levels->getDictionaryManager(),editorData["name"]));
	} else {
	s = _CC(levels->getDictionaryManager(), editorData["name"]);
	}

	bmTips[0]=textureFromText(renderer, *fontText,s.c_str(),objThemes.getTextColor(true));
	}

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

	//Reset the script environment.
	getScriptExecutor()->reset();

	//Compile and run script (only in game mode).
	if(stateID!=STATE_LEVEL_EDITOR) compileScript();
	}

	void Game::loadLevel(ImageManager& imageManager,SDL_Renderer& renderer,std::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)){
	cerr<<"ERROR: Can't load level file "<<s<<endl;
	delete obj;
	return;
	}
	}

	//Now call another function.
	loadLevelFromNode(imageManager,renderer,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(ImageManager& imageManager, SDL_Renderer& renderer, 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)){
	cerr<<"ERROR: 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(imageManager,renderer,obj.subNodes[i],"???");
	//remove this node to prevent delete it.
	obj.subNodes[i]=NULL;
	//over
	loaded=true;
	break;
	}
	}

	if(!loaded){
	cerr<<"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(ImageManager& imageManager, SDL_Renderer& renderer){
	//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)){
	//Only set isReset true if this isn't a replay.
	if(!(player.isPlayFromRecord() && !interlevel))
	isReset=true;

	//Also delete any gui (most likely the interlevel gui). Only in game mode.
	if(GUIObjectRoot && stateID!=STATE_LEVEL_EDITOR){
	delete GUIObjectRoot;
	GUIObjectRoot=NULL;
	}

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

	//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(imageManager,renderer);
	}
	}

	//Check if tab is pressed.
	if(inputMgr.isKeyDownEvent(INPUTMGR_TAB)){
	//Switch the camera mode.
	switch(cameraMode){
	case CAMERA_PLAYER:
	cameraMode=CAMERA_SHADOW;
	break;
	case CAMERA_SHADOW:
	case CAMERA_CUSTOM:
	cameraMode=CAMERA_PLAYER;
	break;
	}
	}
	}

	/////////////////LOGIC///////////////////
	void Game::logic(ImageManager& imageManager, SDL_Renderer& renderer){
	//Add one tick to the time.
	time++;

	//FIXME:Resetting dx/dy and xVel/yVel every loop interferes with movement logic of player and blocks.
	//First prepare each gameObject for the new frame.
	//This includes resetting dx/dy and xVel/yVel.
	//for(unsigned int o=0;o<levelObjects.size();o++)
	//levelObjects[o]->prepareFrame();

	//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.target){
	//NOTE: Should we check if the target still exists???
	e.target->onEvent(e.eventType);
	}else 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){
	if(levelObjects[i]->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 if we should save/load state.
	//NOTE: This happens after event handling so no eventQueue has to be saved/restored.
	if(saveStateNextTime){
	saveState();
	}else if(loadStateNextTime){
	loadState();
	}
	saveStateNextTime=false;
	loadStateNextTime=false;

	//Loop through the gameobjects to update them.
	for(unsigned int i=0;i<levelObjects.size();i++){
	//Send GameObjectEvent_OnEnterFrame event to the script
	levelObjects[i]->onEvent(GameObjectEvent_OnEnterFrame);
	}
	for(unsigned int i=0;i<levelObjects.size();i++){
	//Let the gameobject handle movement.
	levelObjects[i]->move();
	}
	//Also update the scenery.
	{
	std::map<std::string,std::vector<Scenery*> >::iterator it;
	for(it=sceneryLayers.begin();it!=sceneryLayers.end();++it){
	for(unsigned int i=0;i<it->second.size();i++)
	it->second[i]->move();
	}
	}

	//Let the player store his move, if recording.
	player.shadowSetState();
	//Let the player give his recording to the shadow, if configured.
	player.shadowGiveState(&shadow);

	//NOTE: to fix bugs regarding player/shadow swap, we should first process collision of player/shadow then move them

	SDL_Rect playerLastPosition = player.getBox();
	SDL_Rect shadowLastPosition = shadow.getBox();

	//Check collision for player.
	player.collision(levelObjects);
	//Now let the shadow decide his move, if he's playing a recording.
	shadow.moveLogic();
	//Check collision for shadow.
	shadow.collision(levelObjects);

	//Let the player move.
	player.move(levelObjects, playerLastPosition.x, playerLastPosition.y);
	//Let the shadow move.
	shadow.move(levelObjects, shadowLastPosition.x, shadowLastPosition.y);

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

	//Update the camera.
	switch(cameraMode){
	case CAMERA_PLAYER:
	player.setMyCamera();
	break;
	case CAMERA_SHADOW:
	shadow.setMyCamera();
	break;
	case CAMERA_CUSTOM:
	//NOTE: The target is (should be) screen size independent so calculate the real target x and y here.
	int targetX=cameraTarget.x-(SCREEN_WIDTH/2);
	int targetY=cameraTarget.y-(SCREEN_HEIGHT/2);
	//Move the camera to the cameraTarget.
	if(camera.x>targetX){
	camera.x-=(camera.x-targetX)>>4;
	//Make sure we don't go too far.
	if(camera.x<targetX)
	camera.x=targetX;
	}else if(camera.x<targetX){
	camera.x+=(targetX-camera.x)>>4;
	//Make sure we don't go too far.
	if(camera.x>targetX)
	camera.x=targetX;
	}
	if(camera.y>targetY){
	camera.y-=(camera.y-targetY)>>4;
	//Make sure we don't go too far.
	if(camera.y<targetY)
	camera.y=targetY;
	}else if(camera.y<targetY){
	camera.y+=(targetY-camera.y)>>4;
	//Make sure we don't go too far.
	if(camera.y>targetY)
	camera.y=targetY;
	}
	break;
	}

	//Check if we won.
	if(won){
	//Check if it's playing from record
	if(player.isPlayFromRecord() && !interlevel){
	recordingEnded(imageManager,renderer);
	}else{
	//the string to store auto-save record path.
	string bestTimeFilePath,bestRecordingFilePath;
	//and if we can't get test path.
	bool filePathError=false;

	//Get current level
	LevelPack::Level *level=levels->getLevel();

	//Now check if we should update statistics
	{
	//Get previous and current medal
	int oldMedal=level->won?1:0,newMedal=1;

	int bestTime=level->time;
	int targetTime=level->targetTime;
	int bestRecordings=level->recordings;
	int targetRecordings=level->targetRecordings;

	if(oldMedal){
	if(targetTime<0){
	oldMedal=3;
	}else{
	if(targetTime<0 \|\| bestTime<=targetTime)
	oldMedal++;
	if(targetRecordings<0 \|\| bestRecordings<=targetRecordings)
	oldMedal++;
	}
	}else{
	bestTime=time;
	bestRecordings=recordings;
	}

	if(bestTime==-1 \|\| bestTime>time) bestTime=time;
	if(bestRecordings==-1 \|\| bestRecordings>recordings) bestRecordings=recordings;

	if(targetTime<0){
	newMedal=3;
	}else{
	if(targetTime<0 \|\| bestTime<=targetTime)
	newMedal++;
	if(targetRecordings<0 \|\| bestRecordings<=targetRecordings)
	newMedal++;
	}

	//Check if we need to update statistics
	if(newMedal>oldMedal){
	switch(oldMedal){
	case 0:
	statsMgr.completedLevels++;
	break;
	case 2:
	statsMgr.silverLevels--;
	break;
	}

	switch(newMedal){
	case 2:
	statsMgr.silverLevels++;
	break;
	case 3:
	statsMgr.goldLevels++;
	break;
	}
	}
	}

	//Check the achievement "Complete a level with checkpoint, but without saving"
	if (objLastCheckPoint == NULL) {
	for (auto obj : levelObjects) {
	if (obj->type == TYPE_CHECKPOINT) {
	statsMgr.newAchievement("withoutsave");
	break;
	}
	}
	}

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

	//Update achievements
	if(levels->levelpackName=="tutorial") statsMgr.updateTutorialAchievements();
	statsMgr.updateLevelAchievements();

	//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)
	//NOTE: In case of the interlevel popup the save data needs to be deleted so the restart behaviour is the same for key and button restart.
	reset(interlevel);
	isReset=false;
	}

	/////////////////RENDER//////////////////
	void Game::render(ImageManager&,SDL_Renderer &renderer){
	//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(false);
	}

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

	//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_SetRenderDrawColor(&renderer, 255,255,255,255);
	SDL_RenderClear(&renderer);
	}
	}

	//Now draw the blackground layers.
	std::map<std::string,std::vector<Scenery*> >::iterator it;
	for(it=sceneryLayers.begin();it!=sceneryLayers.end();++it){
	if (it->first >= "f") break; // now we meet a foreground layer
	for(unsigned int i=0;i<it->second.size();i++)
	it->second[i]->show(renderer);
	}

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

	//Followed by the player and the shadow.
	//NOTE: We draw the shadow first, because he needs to be behind the player.
	shadow.show(renderer);
	player.show(renderer);

	//Now draw the foreground layers.
	for (; it != sceneryLayers.end(); ++it){
	for (unsigned int i = 0; i<it->second.size(); i++)
	it->second[i]->show(renderer);
	}

	//Show the levelName if it isn't the level editor.
	if(stateID!=STATE_LEVEL_EDITOR && bmTips[0]!=NULL && !interlevel){
	withTexture(*bmTips[0], [&](SDL_Rect r){
	drawGUIBox(-2,SCREEN_HEIGHT-r.h-4,r.w+8,r.h+6,renderer,0xFFFFFFFF);
	applyTexture(2,SCREEN_HEIGHT-r.h,*bmTips[0],renderer,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.
	string s;
	- string keyCode=_(inputMgr.getKeyCodeName(inputMgr.getKeyCode(INPUTMGR_ACTION,false)));
	+ string keyCode=inputMgr.getKeyCode(INPUTMGR_ACTION,false).describe();
	transform(keyCode.begin(),keyCode.end(),keyCode.begin(),::toupper);
	switch(gameTipIndex){
	case TYPE_CHECKPOINT:
	/// 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);
	break;
	case TYPE_SWAP:
	/// 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);
	break;
	case TYPE_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);
	break;
	case TYPE_PORTAL:
	/// 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);
	break;
	}

	//If we have a string then it's a supported GameObject type.
	if(!s.empty()){
	bmTips[gameTipIndex]=textureFromText(renderer, *fontText, s.c_str(), objThemes.getTextColor(true));
	}
	}

	//We already have a gameTip for this type so draw it.
	if(bmTips[gameTipIndex]!=NULL){
	withTexture(*bmTips[gameTipIndex], [&](SDL_Rect r){
	drawGUIBox(-2,-2,r.w+8,r.h+6,renderer,0xFFFFFFFF);
	applyTexture(2,2,*bmTips[gameTipIndex],renderer);
	});
	}
	}
	//Set the gameTip to 0.
	gameTipIndex=0;
	// Limit the scope of bm, as it's a borrowed pointer.
	{
	//Pointer to the sdl texture that will contain a message, if any.
	SDL_Texture* 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));
	+ string keyCodeRestart=inputMgr.getKeyCode(INPUTMGR_RESTART,false).describe();
	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));
	+ string keyCodeLoad=inputMgr.getKeyCode(INPUTMGR_LOAD,false).describe();
	transform(keyCodeLoad.begin(),keyCodeLoad.end(),keyCodeLoad.begin(),::toupper);
	//Draw string
	bmTips[3]=textureFromText(renderer, *fontText,//TTF_RenderUTF8_Blended(fontText,
	/// 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(),
	objThemes.getTextColor(true));
	}
	bm=bmTips[3].get();
	}else{
	//Now check if the tip is already made, if not make it.
	if(bmTips[2]==NULL){
	bmTips[2]=textureFromText(renderer, *fontText,
	/// 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(),
	objThemes.getTextColor(true));
	}
	bm=bmTips[2].get();
	}
	}

	//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){
	bmTips[1]=textureFromText(renderer, *fontText,
	_("Your shadow has died."),
	objThemes.getTextColor(true));
	}
	bm=bmTips[1].get();

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

	//return view to player and keep it there
	cameraMode=CAMERA_PLAYER;
	}

	//Draw the tip.
	if(bm!=NULL){
	const SDL_Rect textureSize = rectFromTexture(*bm);
	int x=(SCREEN_WIDTH-textureSize.w)/2;
	int y=32;
	drawGUIBox(x-8,y-8,textureSize.w+16,textureSize.h+14,renderer,0xFFFFFFFF);
	applyTexture(x,y,*bm,renderer);
	}
	}

	//Show the number of collectables the user has collected if there are collectables in the level.
	//We hide this when interlevel.
	if(currentCollectables<=totalCollectables && totalCollectables!=0 && !interlevel && time>0){
	if(collectablesTexture.needsUpdate(currentCollectables)) {
	//Temp stringstream just to addup all the text nicely
	std::stringstream temp;
	temp << currentCollectables << "/" << totalCollectables;
	collectablesTexture.update(currentCollectables,
	textureFromText(renderer,
	*fontText,
	temp.str().c_str(),
	objThemes.getTextColor(true)));
	}
	SDL_Rect bmSize = rectFromTexture(*collectablesTexture.get());

	//Draw background
	drawGUIBox(SCREEN_WIDTH-bmSize.w-34,SCREEN_HEIGHT-bmSize.h-4,bmSize.w+34+2,bmSize.h+4+2,renderer,0xFFFFFFFF);

	//Draw the collectable icon
	collectable.draw(renderer,SCREEN_WIDTH-50+12,SCREEN_HEIGHT-50+10);

	//Draw text
	applyTexture(SCREEN_WIDTH-50-bmSize.w+22,SCREEN_HEIGHT-bmSize.h,collectablesTexture.getTexture(),renderer);
	}

	//show time and records used in level editor.
	if(stateID==STATE_LEVEL_EDITOR && time>0){
	const SDL_Color fg=objThemes.getTextColor(true),bg={255,255,255,255};
	const int alpha = 160;
	if (recordingsTexture.needsUpdate(recordings)) {
	recordingsTexture.update(recordings,
	textureFromTextShaded(
	renderer,
	*fontText,
	tfm::format(_("%d recordings"),recordings).c_str(),
	fg,
	bg
	));
	SDL_SetTextureAlphaMod(recordingsTexture.get(),alpha);
	}

	int y=SCREEN_HEIGHT - textureHeight(*recordingsTexture.get());

	applyTexture(0,y,*recordingsTexture.get(), renderer);

	if(timeTexture.needsUpdate(time)) {
	const size_t len = 32;
	char c[len];
	SDL_snprintf(c,len,"%-.2fs",time/40.0f);
	timeTexture.update(time,
	textureFromTextShaded(
	renderer,
	*fontText,
	c,
	fg,
	bg
	));
	y-=textureHeight(*timeTexture.get());
	}

	applyTexture(0,y,*timeTexture.get(), renderer);
	}

	//Draw the current action in the upper right corner.
	if(player.record){
	const SDL_Rect r = { 0, 0, 50, 50 };
	applyTexture(SCREEN_WIDTH - 50, 0, *action, renderer, &r);
	} else if (shadow.state != 0){
	const SDL_Rect r={50,0,50,50};
	applyTexture(SCREEN_WIDTH-50,0,*action,renderer,&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){
	dimScreen(renderer,191);
	}else if((time & 0x10)==0x10){
	// FIXME: replace this ugly ad-hoc animation by a better one
	const SDL_Rect r={50,0,50,50};
	applyTexture(0,0,*action,renderer,&r);
	applyTexture(0,SCREEN_HEIGHT-50,*action,renderer,&r);
	applyTexture(SCREEN_WIDTH-50,SCREEN_HEIGHT-50,*action,renderer,&r);
	}
	}else if(player.objNotificationBlock){
	//If the player is in front of a notification block show the message.
	//And it isn't a replay.
	//Check if we need to update the notification message texture.
	const auto& blockId = player.objNotificationBlock;
	int maxWidth = 0;
	int y = 20;
	//We check against blockId rather than the full message, as blockId is most likely shorter.
	if(notificationTexture.needsUpdate(blockId)) {
	const std::string &untranslated_message=player.objNotificationBlock->message;
	std::string message=_CC(levels->getDictionaryManager(),untranslated_message);

	std::vector<std::string> string_data;

	//Trim the message.
	{
	size_t lps = message.find_first_not_of("\n\r \t");
	if (lps == string::npos) {
	message.clear(); // it's completely empty
	} else {
	message = message.substr(lps, message.find_last_not_of("\n\r \t") - lps + 1);
	}
	}

	//Split the message into lines.
	for (int lps = 0;;) {
	// determine the end of line
	int lpe = lps;
	for (; message[lpe] != '\n' && message[lpe] != '\r' && message[lpe] != '\0'; lpe++);

	string_data.push_back(message.substr(lps, lpe - lps));

	// break if the string ends
	if (message[lpe] == '\0') break;

	// skip "\r\n" for Windows line ending
	if (message[lpe] == '\r' && message[lpe + 1] == '\n') lpe++;

	// point to the start of next line
	lps = lpe + 1;
	}

	vector<SurfacePtr> lines;

	//Create the image for each lines
	for (int i = 0; i < (int)string_data.size(); i++) {
	//Integer used to center the sentence horizontally.
	int x = 0;
	TTF_SizeUTF8(fontText, string_data[i].c_str(), &x, NULL);

	//Find out largest width
	if (x>maxWidth)
	maxWidth = x;

	lines.emplace_back(TTF_RenderUTF8_Blended(fontText, string_data[i].c_str(), objThemes.getTextColor(true)));

	//Increase y with 25, about the height of the text.
	y += 25;
	}

	maxWidth+=SCREEN_WIDTH*0.15;

	SurfacePtr surf = createSurface(maxWidth, y);
	int y1 = y;
	for(SurfacePtr &s : lines) {
	if(s) {
	applySurface((surf->w-s->w)/2,surf->h - y1,s.get(),surf.get(),NULL);
	}
	y1 -= 25;
	}
	notificationTexture.update(blockId, textureUniqueFromSurface(renderer,std::move(surf)));
	} else {
	auto texSize = rectFromTexture(*notificationTexture.get());
	maxWidth=texSize.w;
	y=texSize.h;
	}

	drawGUIBox((SCREEN_WIDTH-maxWidth)/2,SCREEN_HEIGHT-y-25,maxWidth,y+20,renderer,0xFFFFFFBF);
	applyTexture((SCREEN_WIDTH-maxWidth)/2,SCREEN_HEIGHT-y,notificationTexture.getTexture(),renderer);
	}
	}

	void Game::resize(ImageManager&, SDL_Renderer& /renderer/){
	//Check if the interlevel popup is shown.
	if(interlevel && GUIObjectRoot){
	GUIObjectRoot->left=(SCREEN_WIDTH-GUIObjectRoot->width)/2;
	}
	}

	void Game::replayPlay(ImageManager& imageManager,SDL_Renderer& renderer){
	//Set interlevel true.
	interlevel=true;

	//Make a copy of the playerButtons.
	vector<int> recordCopy=player.recordButton;

	//Reset the game.
	reset(true);

	//Make the cursor visible when the interlevel popup is up.
	SDL_ShowCursor(SDL_ENABLE);

	//Set the copy of playerButtons back.
	player.recordButton=recordCopy;

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

	//Create the gui if it isn't already done.
	if(!GUIObjectRoot){
	//Create a new GUIObjectRoot the size of the screen.
	GUIObjectRoot=new GUIObject(imageManager,renderer,0,0,SCREEN_WIDTH,SCREEN_HEIGHT);
	//Make child widgets change color properly according to theme.
	GUIObjectRoot->inDialog=true;

	//Create a GUIFrame for the upper frame.
	GUIFrame* upperFrame=new GUIFrame(imageManager,renderer,0,4,0,68);
	GUIObjectRoot->addChild(upperFrame);

	//Render the You've finished: text and add it to a GUIImage.
	//NOTE: The texture is managed by the GUIImage so no need to free it ourselfs.
	auto bm = SharedTexture(textureFromText(renderer, *fontGUI,_("You've finished:"),objThemes.getTextColor(true)));
	const SDL_Rect textureSize = rectFromTexture(*bm);

	GUIImage* title=new GUIImage(imageManager,renderer,0,4-GUI_FONT_RAISE,textureSize.w,textureSize.h,bm);
	upperFrame->addChild(title);

	//Create the sub title.
	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,_CC(levels->getDictionaryManager(),levelName));
	}
	GUIObject* obj=new GUILabel(imageManager,renderer,0,40,0,28,s.c_str(),0,true,true,GUIGravityCenter);
	upperFrame->addChild(obj);
	obj->render(renderer,0,0,false);

	//Determine the width the upper frame should have.
	int width;
	if(textureSize.w>obj->width)
	width=textureSize.w+32;
	else
	width=obj->width+32;
	//Set the left of the title.
	title->left=(width-title->width)/2;
	//Set the width of the level label to the width of the frame for centering.
	obj->width=width;
	//Now set the position and width of the frame.
	upperFrame->width=width;
	upperFrame->left=(SCREEN_WIDTH-width)/2;

	//Now create a GUIFrame for the lower frame.
	GUIFrame* lowerFrame=new GUIFrame(imageManager,renderer,0,SCREEN_HEIGHT-140,570,135);
	GUIObjectRoot->addChild(lowerFrame);

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

	int maxWidth=0;
	int x=20;

	//Is there a target time for this level?
	int timeY=0;
	bool isTargetTime=true;
	if(targetTime<=0){
	isTargetTime=false;
	timeY=12;
	}

	//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.
	obj=new GUILabel(imageManager,renderer,x,10+timeY,-1,36,tfm::format(_("Time: %-.2fs"),time/40.0f).c_str());
	lowerFrame->addChild(obj);

	obj->render(renderer,0,0,false);
	maxWidth=obj->width;

	/// 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 GUILabel(imageManager,renderer,x,34+timeY,-1,36,tfm::format(_("Best time: %-.2fs"),bestTime/40.0f).c_str());
	lowerFrame->addChild(obj);

	obj->render(renderer,0,0,false);
	if(obj->width>maxWidth)
	maxWidth=obj->width;

	/// 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(isTargetTime){
	obj=new GUILabel(imageManager,renderer,x,58,-1,36,tfm::format(_("Target time: %-.2fs"),targetTime/40.0f).c_str());
	lowerFrame->addChild(obj);

	obj->render(renderer,0,0,false);
	if(obj->width>maxWidth)
	maxWidth=obj->width;
	}

	x+=maxWidth+20;

	//Is there target recordings for this level?
	int recsY=0;
	bool isTargetRecs=true;
	if(targetRecordings<0){
	isTargetRecs=false;
	recsY=12;
	}

	//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 GUILabel(imageManager,renderer,x,10+recsY,-1,36,tfm::format(_("Recordings: %d"),recordings).c_str());
	lowerFrame->addChild(obj);

	obj->render(renderer,0,0,false);
	maxWidth=obj->width;

	/// TRANSLATORS: Please do not remove %d from your translation:
	/// - %d means the number of recordings user has made
	obj=new GUILabel(imageManager,renderer,x,34+recsY,-1,36,tfm::format(_("Best recordings: %d"),bestRecordings).c_str());
	lowerFrame->addChild(obj);

	obj->render(renderer,0,0,false);
	if(obj->width>maxWidth)
	maxWidth=obj->width;

	/// TRANSLATORS: Please do not remove %d from your translation:
	/// - %d means the number of recordings user has made
	if(isTargetRecs){
	obj=new GUILabel(imageManager,renderer,x,58,-1,36,tfm::format(_("Target recordings: %d"),targetRecordings).c_str());
	lowerFrame->addChild(obj);

	obj->render(renderer,0,0,false);
	if(obj->width>maxWidth)
	maxWidth=obj->width;
	}

	x+=maxWidth;

	//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 GUILabel(imageManager,renderer,50,92,-1,36,s1.c_str(),0,true,true,GUIGravityCenter);
	lowerFrame->addChild(obj);

	obj->render(renderer,0,0,false);
	if(obj->left+obj->width>x){
	x=obj->left+obj->width+30;
	}else{
	obj->left=20+(x-20-obj->width)/2;
	}

	//Create the rectangle for the earned medal.
	SDL_Rect r;
	r.x=(medal-1)*30;
	r.y=0;
	r.w=30;
	r.h=30;

	//Create the medal on the left side.
	obj=new GUIImage(imageManager,renderer,16,92,30,30,medals,r);
	lowerFrame->addChild(obj);
	//And the medal on the right side.
	obj=new GUIImage(imageManager,renderer,x-24,92,30,30,medals,r);
	lowerFrame->addChild(obj);

	//Create the three buttons, Menu, Restart, Next.
	/// TRANSLATORS: used as return to the level selector menu
	GUIObject* b1=new GUIButton(imageManager,renderer,x,10,-1,36,_("Menu"),0,true,true,GUIGravityCenter);
	b1->name="cmdMenu";
	b1->eventCallback=this;
	lowerFrame->addChild(b1);
	b1->render(renderer,0,0,true);

	/// TRANSLATORS: used as restart level
	GUIObject* b2=new GUIButton(imageManager,renderer,x,50,-1,36,_("Restart"),0,true,true,GUIGravityCenter);
	b2->name="cmdRestart";
	b2->eventCallback=this;
	lowerFrame->addChild(b2);
	b2->render(renderer,0,0,true);

	/// TRANSLATORS: used as next level
	GUIObject* b3=new GUIButton(imageManager,renderer,x,90,-1,36,_("Next"),0,true,true,GUIGravityCenter);
	b3->name="cmdNext";
	b3->eventCallback=this;
	lowerFrame->addChild(b3);
	b3->render(renderer,0,0,true);

	maxWidth=b1->width;
	if(b2->width>maxWidth)
	maxWidth=b2->width;
	if(b3->width>maxWidth)
	maxWidth=b3->width;

	b1->left=b2->left=b3->left=x+maxWidth/2;

	x+=maxWidth;
	lowerFrame->width=x;
	lowerFrame->left=(SCREEN_WIDTH-lowerFrame->width)/2;
	}
	}

	void Game::recordingEnded(ImageManager& imageManager, SDL_Renderer& renderer){
	//Check if it's a normal replay, if so just stop.
	if(!interlevel){
	//Show the cursor so that the user can press the ok button.
	SDL_ShowCursor(SDL_ENABLE);
	//Now show the message box.
	msgBox(imageManager,renderer,_("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::canSaveState(){
	return (player.canSaveState() && shadow.canSaveState());
	}

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

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

	//Save the camera mode and target.
	cameraModeSaved=cameraMode;
	cameraTargetSaved=cameraTarget;

	//Save the current collectables
	currentCollectablesSaved=currentCollectables;

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

	if(!player.isPlayFromRecord() && !interlevel){
	//Update achievements
	Uint32 t=SDL_GetTicks()+5000; //Add a bias to prevent bugs
	if(recentSave+1000>t){
	statsMgr.newAchievement("panicSave");
	}
	recentSave=t;

	//Update statistics.
	statsMgr.saveTimes++;

	//Update achievements
	switch(statsMgr.saveTimes){
	case 1000:
	statsMgr.newAchievement("save1k");
	break;
	}
	}

	//Execute the onSave event.
	executeScript(LevelEvent_OnSave);

	//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;
	recentSwap=recentSwapSaved;

	//Load the camera mode and target.
	cameraMode=cameraModeSaved;
	cameraTarget=cameraTargetSaved;

	//Load the current collactbles
	currentCollectables=currentCollectablesSaved;

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

	if(!player.isPlayFromRecord() && !interlevel){
	//Update achievements.
	Uint32 t=SDL_GetTicks()+5000; //Add a bias to prevent bugs
	if(recentLoad+1000>t){
	statsMgr.newAchievement("panicLoad");
	}
	recentLoad=t;

	//Update statistics.
	statsMgr.loadTimes++;

	//Update achievements
	switch(statsMgr.loadTimes){
	case 1000:
	statsMgr.newAchievement("load1k");
	break;
	}
	}

	//Execute the onLoad event, if any.
	executeScript(LevelEvent_OnLoad);

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

	saveStateNextTime=false;
	loadStateNextTime=false;

	//Reset the stats if interlevel isn't true.
	if(!interlevel){
	time=0;
	recordings=0;
	}

	recentSwap=-10000;
	if(save) recentSwapSaved=-10000;

	//Reset the camera.
	cameraMode=CAMERA_PLAYER;
	if(save) cameraModeSaved=CAMERA_PLAYER;
	cameraTarget.x=cameraTarget.y=cameraTarget.w=cameraTarget.h=0;
	if(save) cameraTargetSaved.x=cameraTargetSaved.y=cameraTargetSaved.w=cameraTargetSaved.h=0;

	//Reset the number of collectables
	currentCollectables=0;
	if(save)
	currentCollectablesSaved=0;

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

	//Clear the event queue, since all the events are from before the reset.
	eventQueue.clear();

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

	//Reset the cached notification block
	notificationTexture.update(NULL, NULL);

	//Reset the script environment
	//NOTE: The scriptExecutor will only be reset between levels. (Why? by acme_pjz)
	getScriptExecutor()->reset();

	//Recompile and run script, only in game mode and edit mode with 'R' key pressed.
	//FIXME: We use an ad-hoc method to check if 'R' key is pressed, by checking isReset.
	if(stateID!=STATE_LEVEL_EDITOR \|\| isReset) compileScript();

	//Hide the cursor (if not the leveleditor).
	if(stateID!=STATE_LEVEL_EDITOR)
	SDL_ShowCursor(SDL_DISABLE);
	}

	void Game::compileScript(){
	compiledScripts.clear();

	for(map<int,string>::iterator it=scripts.begin();it!=scripts.end();++it){
	compiledScripts[it->first]=getScriptExecutor()->compileScript(it->second);
	}

	for(unsigned int i=0;i<levelObjects.size();i++){
	Block *block=levelObjects[i];

	block->compiledScripts.clear();

	for(map<int,string>::iterator it=block->scripts.begin();it!=block->scripts.end();++it){
	block->compiledScripts[it->first]=getScriptExecutor()->compileScript(it->second);
	}
	}

	//Call the level's onCreate event.
	executeScript(LevelEvent_OnCreate);

	//Send GameObjectEvent_OnCreate event to the script
	for(unsigned int i=0;i<levelObjects.size();i++){
	levelObjects[i]->onEvent(GameObjectEvent_OnCreate);
	}

	//Close exit(s) if there are any collectables
	if(totalCollectables>0){
	for(unsigned int i=0;i<levelObjects.size();i++){
	if(levelObjects[i]->type==TYPE_EXIT){
	levelObjects[i]->onEvent(GameObjectEvent_OnSwitchOff);
	}
	}
	}
	}

	void Game::executeScript(int eventType){
	map<int,int>::iterator it;

	//Check if there's a script for the given event.
	it=compiledScripts.find(eventType);
	if(it!=compiledScripts.end()){
	//There is one so execute it.
	getScriptExecutor()->executeScript(it->second);
	}
	}

	void Game::broadcastObjectEvent(int eventType,int objectType,const char* id,GameObject* target){
	//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;
	}
	//Or there's a target given.
	if(target)
	e.target=target;
	else
	e.target=NULL;

	//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(ImageManager& imageManager, SDL_Renderer& renderer){
	//Goto the next level.
	levels->nextLevel();

	//Check if the level exists.
	if(levels->getCurrentLevel()<levels->getLevelCount()){
	setNextState(STATE_GAME);
	}else{
	if(!levels->congratulationText.empty()){
	msgBox(imageManager,renderer,_CC(levels->getDictionaryManager(),levels->congratulationText),MsgBoxOKOnly,_("Congratulations"));
	}else{
	msgBox(imageManager,renderer,_("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(ImageManager& imageManager,SDL_Renderer& renderer, 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;
	}

	interlevel=false;

	//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(imageManager,renderer);
	}
	}
	diff --git a/src/InputManager.cpp b/src/InputManager.cpp
	index c3f0464..cf097a4 100644
	--- a/src/InputManager.cpp
	+++ b/src/InputManager.cpp
	@@ -1,466 +1,581 @@
	/*
	* 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 "InputManager.h"
	#include "Globals.h"
	#include "Settings.h"
	#include "Functions.h"
	#include "GUIObject.h"
	#include "GUIListBox.h"
	#include "GUIOverlay.h"
	#include <stdlib.h>
	#include <stdio.h>
	#include <string>
	+#include <iostream>
	+
	+#include "libs/tinyformat/tinyformat.h"
	+
	using namespace std;

	InputManager inputMgr;

	//the order must be the same as InputManagerKeys
	static const char* keySettingNames[INPUTMGR_MAX]={
	"key_up","key_down","key_left","key_right","key_jump","key_action","key_space","key_cancelRecording",
	"key_escape","key_restart","key_tab","key_save","key_load","key_swap",
	"key_teleport","key_suicide","key_shift","key_next","key_previous","key_select"
	};

	//the order must be the same as InputManagerKeys
	static const char* keySettingDescription[INPUTMGR_MAX]={
	__("Up (in menu)"),__("Down (in menu)"),__("Left"),__("Right"),__("Jump"),__("Action"),__("Space (Record)"),__("Cancel recording"),
	__("Escape"),__("Restart"),__("Tab (View shadow/Level prop.)"),__("Save game (in editor)"),__("Load game"),__("Swap (in editor)"),
	__("Teleport (in editor)"),__("Suicide (in editor)"),__("Shift (in editor)"),__("Next block type (in Editor)"),
	__("Previous block type (in editor)"), __("Select (in menu)")
	};

	+InputManagerKeyCode::InputManagerKeyCode(int sym_, int mod_)
	+ : type(KEYBOARD), sym(sym_), mod(mod_)
	+{
	+ // normalize a bit
	+ if (sym == 0) {
	+ mod == 0;
	+ } else {
	+ mod = ((mod & KMOD_CTRL) ? KMOD_CTRL : 0)
	+ \| ((mod & KMOD_ALT) ? KMOD_ALT : 0)
	+ \| ((mod & KMOD_SHIFT) ? KMOD_SHIFT : 0);
	+
	+ if (sym == SDLK_LCTRL \|\| sym == SDLK_RCTRL) mod &= ~KMOD_CTRL;
	+ if (sym == SDLK_LALT \|\| sym == SDLK_RALT) mod &= ~KMOD_ALT;
	+ if (sym == SDLK_LSHIFT \|\| sym == SDLK_RSHIFT) mod &= ~KMOD_SHIFT;
	+ }
	+}
	+
	+
	+InputManagerKeyCode::InputManagerKeyCode(InputType type_, int buttonIndex_, int buttonValue_)
	+ : type(type_), buttonIndex(buttonIndex_), buttonValue(buttonValue_)
	+{
	+}
	+
	+InputManagerKeyCode InputManagerKeyCode::createFromString(const std::string& s) {
	+ int i, j, lp;
	+
	+ if (s.find("JoystickAxis;") == 0) {
	+ lp = s.find(';');
	+ if (sscanf(s.c_str() + (lp + 1), "%d;%d", &i, &j) == 2) {
	+ return InputManagerKeyCode(JOYSTICK_AXIS, i, j);
	+ }
	+ } else if (s.find("JoystickButton;") == 0) {
	+ lp = s.find(';');
	+ if (sscanf(s.c_str() + (lp + 1), "%d", &i) == 1) {
	+ return InputManagerKeyCode(JOYSTICK_BUTTON, i, 0);
	+ }
	+ } else if (s.find("JoystickHat;") == 0) {
	+ lp = s.find(';');
	+ if (sscanf(s.c_str() + (lp + 1), "%d;%d", &i, &j) == 2) {
	+ return InputManagerKeyCode(JOYSTICK_HAT, i, j);
	+ }
	+ } else {
	+ i = atoi(s.c_str());
	+ j = 0;
	+ if (i) {
	+ if (s.find(";Ctrl") != std::string::npos) j \|= KMOD_CTRL;
	+ if (s.find(";Alt") != std::string::npos) j \|= KMOD_ALT;
	+ if (s.find(";Shift") != std::string::npos) j \|= KMOD_SHIFT;
	+ }
	+ return InputManagerKeyCode(i, j);
	+ }
	+
	+ fprintf(stderr, "ERROR: Can't parse '%s' as InputManagerKeyCode\n", s.c_str());
	+
	+ return InputManagerKeyCode();
	+}
	+
	+std::string InputManagerKeyCode::toString() const {
	+ std::ostringstream str;
	+
	+ switch (type) {
	+ default:
	+ if (sym == 0) {
	+ return std::string();
	+ } else {
	+ str << sym;
	+ if (mod & KMOD_CTRL) str << ";Ctrl";
	+ if (mod & KMOD_ALT) str << ";Alt";
	+ if (mod & KMOD_SHIFT) str << ";Shift";
	+ return str.str();
	+ }
	+ break;
	+ case JOYSTICK_AXIS:
	+ str << "JoystickAxis;" << buttonIndex << ";" << buttonValue;
	+ return str.str();
	+ break;
	+ case JOYSTICK_BUTTON:
	+ str << "JoystickButton;" << buttonIndex;
	+ return str.str();
	+ break;
	+ case JOYSTICK_HAT:
	+ str << "JoystickHat;" << buttonIndex << ";" << buttonValue;
	+ return str.str();
	+ break;
	+ }
	+}
	+
	+std::string InputManagerKeyCode::describe() const {
	+ switch (type) {
	+ default:
	+ if (sym == 0) {
	+ return std::string();
	+ } else {
	+ std::ostringstream str;
	+
	+ if (mod & KMOD_CTRL) str << "Ctrl+";
	+ if (mod & KMOD_ALT) str << "Alt+";
	+ if (mod & KMOD_SHIFT) str << "Shift+";
	+
	+ const char* s = SDL_GetKeyName(sym);
	+ if (s != NULL){
	+ str << _(s);
	+ } else{
	+ /// TRANSLAOTRS: This is used when the name of the key code is not found.
	+ str << tfm::format(_("(Key %d)"), sym);
	+ }
	+
	+ return str.str();
	+ }
	+ break;
	+ case JOYSTICK_AXIS:
	+ return tfm::format(_("Joystick axis %d %s"), buttonIndex, buttonValue > 0 ? "+" : "-");
	+ break;
	+ case JOYSTICK_BUTTON:
	+ return tfm::format(_("Joystick button %d"), buttonIndex);
	+ break;
	+ case JOYSTICK_HAT:
	+ switch (buttonValue){
	+ case SDL_HAT_LEFT:
	+ return tfm::format(_("Joystick hat %d left"), buttonIndex);
	+ break;
	+ case SDL_HAT_RIGHT:
	+ return tfm::format(_("Joystick hat %d right"), buttonIndex);
	+ break;
	+ case SDL_HAT_UP:
	+ return tfm::format(_("Joystick hat %d up"), buttonIndex);
	+ break;
	+ case SDL_HAT_DOWN:
	+ return tfm::format(_("Joystick hat %d down"), buttonIndex);
	+ break;
	+ default:
	+ fprintf(stderr, "ERROR: Invalid joystick hat value %d\n", buttonValue);
	+ /// TRANSLAOTRS: This is used when the JOYSTICK_HAT value is invalid.
	+ return tfm::format(_("Joystick hat %d %d"), buttonIndex, buttonValue);
	+ break;
	+ }
	+ break;
	+ }
	+}
	+
	+bool InputManagerKeyCode::empty() const {
	+ return type == KEYBOARD && sym == 0;
	+}
	+
	+std::string InputManagerKeyCode::describeTwo(const InputManagerKeyCode& keyCode, const InputManagerKeyCode& keyCodeAlt) {
	+ std::string s = keyCode.describe();
	+
	+ if (!keyCodeAlt.empty()) {
	+ if (!keyCode.empty()) {
	+ s += " ";
	+ s += _("OR");
	+ s += " ";
	+ }
	+ s += keyCodeAlt.describe();
	+ }
	+
	+ return s;
	+}
	+
	+bool InputManagerKeyCode::operator == (const InputManagerKeyCode& rhs) const {
	+ return type == rhs.type && sym == rhs.sym && ((type == KEYBOARD && sym == 0) \|\| mod == rhs.mod);
	+}
	+
	+bool InputManagerKeyCode::contains(const InputManagerKeyCode& rhs) const {
	+ if (type == KEYBOARD && rhs.type == KEYBOARD) {
	+ if ((mod & KMOD_CTRL) == 0 && (rhs.mod & KMOD_CTRL) != 0) return false;
	+ if ((mod & KMOD_ALT) == 0 && (rhs.mod & KMOD_ALT) != 0) return false;
	+ if ((mod & KMOD_SHIFT) == 0 && (rhs.mod & KMOD_SHIFT) != 0) return false;
	+
	+ if ((mod & KMOD_CTRL) != 0 && (rhs.mod & KMOD_CTRL) == 0) {
	+ if (rhs.sym == SDLK_LCTRL \|\| rhs.sym == SDLK_RCTRL) return true;
	+ }
	+ if ((mod & KMOD_ALT) != 0 && (rhs.mod & KMOD_ALT) == 0) {
	+ if (rhs.sym == SDLK_LALT \|\| rhs.sym == SDLK_RALT) return true;
	+ }
	+ if ((mod & KMOD_SHIFT) != 0 && (rhs.mod & KMOD_SHIFT) == 0) {
	+ if (rhs.sym == SDLK_LSHIFT \|\| rhs.sym == SDLK_RSHIFT) return true;
	+ }
	+ }
	+
	+ return false;
	+}
	+
	//A class that handles the gui events of the inputDialog.
	class InputDialogHandler:public GUIEventCallback{
	private:
	//the list box which contains keys.
	GUIListBox* listBox;
	//the parent object.
	InputManager* parent;

	//update specified key config item
	void updateConfigItem(SDL_Renderer& renderer,int index){
	//Get the description of the key.
	std::string s=_(keySettingDescription[index]);
	s+=": ";

	//Get the key code name.
	- int keyCode=parent->getKeyCode((InputManagerKeys)index,false);
	- s+=_(InputManager::getKeyCodeName(keyCode));
	-
	- //Add the alternative key if there is one.
	- int keyCodeAlt=parent->getKeyCode((InputManagerKeys)index,true);
	- if(keyCodeAlt!=0){
	- s+=" ";
	- s+=_("OR");
	- s+=" ";
	- s+=_(InputManager::getKeyCodeName(keyCodeAlt));
	- }
	+ s += InputManagerKeyCode::describeTwo(
	+ parent->getKeyCode((InputManagerKeys)index, false),
	+ parent->getKeyCode((InputManagerKeys)index, true)
	+ );

	//Update item.
	- listBox->updateItem(renderer, index,s);
	+ listBox->updateItem(renderer, index, s);
	}
	public:
	//Constructor.
	InputDialogHandler(SDL_Renderer& renderer,GUIListBox* listBox,InputManager* parent):listBox(listBox),parent(parent){
	//load the available keys to the list box.
	for(int i=0;i<INPUTMGR_MAX;i++){
	//Get the description of the key.
	std::string s=_(keySettingDescription[i]);
	s+=": ";

	//Get key code name.
	- int keyCode=parent->getKeyCode((InputManagerKeys)i,false);
	- s+=_(InputManager::getKeyCodeName(keyCode));
	-
	- //Add the alternative key if there is one.
	- int keyCodeAlt=parent->getKeyCode((InputManagerKeys)i,true);
	- if(keyCodeAlt!=0){
	- s+=" ";
	- s+=_("OR");
	- s+=" ";
	- s+=_(InputManager::getKeyCodeName(keyCodeAlt));
	- }
	+ s += InputManagerKeyCode::describeTwo(
	+ parent->getKeyCode((InputManagerKeys)i, false),
	+ parent->getKeyCode((InputManagerKeys)i, true)
	+ );

	//Add item.
	listBox->addItem(renderer, s);
	}
	}

	virtual ~InputDialogHandler(){}

	//When a key is pressed call this to set the key to currently-selected item.
	- void onKeyDown(SDL_Renderer& renderer,int keyCode){
	+ void onKeyDown(SDL_Renderer& renderer,const InputManagerKeyCode& keyCode){
	//Check if an item is selected.
	int index=listBox->value;
	if(index<0 \|\| index>=INPUTMGR_MAX) return;

	- //Update the key.
	- //SDLK_BACKSPACE will erase the key.
	- if(keyCode==SDLK_BACKSPACE){
	- parent->setKeyCode((InputManagerKeys)index,0,true);
	- parent->setKeyCode((InputManagerKeys)index,0,false);
	- updateConfigItem(renderer,index);
	- }else{
	- //Update the main key if there isn't one. Otherwise update the alternative key if there isn't one.
	- int key=parent->getKeyCode((InputManagerKeys)index,false);
	- int altKey=parent->getKeyCode((InputManagerKeys)index,true);
	- if(key==0){
	- parent->setKeyCode((InputManagerKeys)index,keyCode,false);
	- }else if((altKey==0)&&(keyCode!=key)){
	- parent->setKeyCode((InputManagerKeys)index,keyCode,true);
	- }
	- updateConfigItem(renderer,index);
	+ //Get the existing keys.
	+ auto key = parent->getKeyCode((InputManagerKeys)index, false);
	+ auto altKey = parent->getKeyCode((InputManagerKeys)index, true);
	+
	+ //SDLK_BACKSPACE will erase all the keys if there are keys.
	+ if (keyCode == InputManagerKeyCode(SDLK_BACKSPACE) && (!key.empty() \|\| !altKey.empty())) {
	+ parent->setKeyCode((InputManagerKeys)index, InputManagerKeyCode(), false);
	+ parent->setKeyCode((InputManagerKeys)index, InputManagerKeyCode(), true);
	+ updateConfigItem(renderer, index);
	+ } else if (keyCode == key \|\| keyCode == altKey) {
	+ //Do nothing if keyCode is equal to one of the existing keys.
	+ } else if (key.empty() \|\| (altKey.empty() && keyCode.contains(key))) {
	+ //Update the main key if there isn't one.
	+ parent->setKeyCode((InputManagerKeys)index, keyCode, false);
	+ updateConfigItem(renderer, index);
	+ } else if (altKey.empty() \|\| keyCode.contains(altKey)) {
	+ //Otherwise update the alternative key if there isn't one.
	+ parent->setKeyCode((InputManagerKeys)index, keyCode, true);
	+ updateConfigItem(renderer, index);
	}
	}

	void GUIEventCallback_OnEvent(ImageManager& imageManager, SDL_Renderer& renderer, std::string name,GUIObject* obj,int eventType){
	//Do nothing...
	}
	};

	//Event handler.
	static InputDialogHandler* handler;

	//A GUIObject that is used to create events for key presses.
	class GUIKeyListener:public GUIObject{
	public:

	GUIKeyListener(ImageManager& imageManager, SDL_Renderer& renderer)
	:GUIObject(imageManager,renderer){}
	private:
	//Leave empty.
	~GUIKeyListener(){}

	bool handleEvents(SDL_Renderer& renderer,int x,int y,bool enabled,bool visible,bool processed){
	if(enabled && handler){
	if(event.type==SDL_KEYDOWN){
	- handler->onKeyDown(renderer,event.key.keysym.sym);
	+ handler->onKeyDown(renderer, InputManagerKeyCode(event.key.keysym.sym, event.key.keysym.mod));
	}
	//Joystick
	else if(event.type==SDL_JOYAXISMOTION){
	if(event.jaxis.value>3200){
	- handler->onKeyDown(renderer,0x00010001 \| (int(event.jaxis.axis)<<8));
	+ handler->onKeyDown(renderer, InputManagerKeyCode(InputManagerKeyCode::JOYSTICK_AXIS, event.jaxis.axis, 1));
	}else if(event.jaxis.value<-3200){
	- handler->onKeyDown(renderer,0x000100FF \| (int(event.jaxis.axis)<<8));
	+ handler->onKeyDown(renderer, InputManagerKeyCode(InputManagerKeyCode::JOYSTICK_AXIS, event.jaxis.axis, -1));
	}
	}
	else if(event.type==SDL_JOYBUTTONDOWN){
	- handler->onKeyDown(renderer,0x00020000 \| (int(event.jbutton.button)<<8));
	+ handler->onKeyDown(renderer, InputManagerKeyCode(InputManagerKeyCode::JOYSTICK_BUTTON, event.jbutton.button, 0));
	}
	else if(event.type==SDL_JOYHATMOTION){
	- if(event.jhat.value & SDL_HAT_LEFT){
	- handler->onKeyDown(renderer,0x00030000 \| (int(event.jhat.hat)<<8) \| SDL_HAT_LEFT);
	- }else if(event.jhat.value & SDL_HAT_RIGHT){
	- handler->onKeyDown(renderer,0x00030000 \| (int(event.jhat.hat)<<8) \| SDL_HAT_RIGHT);
	- }else if(event.jhat.value & SDL_HAT_UP){
	- handler->onKeyDown(renderer,0x00030000 \| (int(event.jhat.hat)<<8) \| SDL_HAT_UP);
	- }else if(event.jhat.value & SDL_HAT_DOWN){
	- handler->onKeyDown(renderer,0x00030000 \| (int(event.jhat.hat)<<8) \| SDL_HAT_DOWN);
	+ if (event.jhat.value & SDL_HAT_LEFT){
	+ handler->onKeyDown(renderer, InputManagerKeyCode(InputManagerKeyCode::JOYSTICK_HAT, event.jhat.hat, SDL_HAT_LEFT));
	+ } else if (event.jhat.value & SDL_HAT_RIGHT){
	+ handler->onKeyDown(renderer, InputManagerKeyCode(InputManagerKeyCode::JOYSTICK_HAT, event.jhat.hat, SDL_HAT_RIGHT));
	+ } else if (event.jhat.value & SDL_HAT_UP){
	+ handler->onKeyDown(renderer, InputManagerKeyCode(InputManagerKeyCode::JOYSTICK_HAT, event.jhat.hat, SDL_HAT_UP));
	+ } else if (event.jhat.value & SDL_HAT_DOWN){
	+ handler->onKeyDown(renderer, InputManagerKeyCode(InputManagerKeyCode::JOYSTICK_HAT, event.jhat.hat, SDL_HAT_DOWN));
	}
	}
	}
	return false;
	}

	//Nothing to do.
	void render(){}
	};

	-int InputManager::getKeyCode(InputManagerKeys key,bool isAlternativeKey){
	+InputManagerKeyCode InputManager::getKeyCode(InputManagerKeys key, bool isAlternativeKey){
	if(isAlternativeKey) return alternativeKeys[key];
	else return keys[key];
	}

	-void InputManager::setKeyCode(InputManagerKeys key,int keyCode,bool isAlternativeKey){
	+void InputManager::setKeyCode(InputManagerKeys key, const InputManagerKeyCode& keyCode, bool isAlternativeKey){
	if(isAlternativeKey) alternativeKeys[key]=keyCode;
	else keys[key]=keyCode;
	}

	void InputManager::loadConfig(){
	for(int i=0;i<INPUTMGR_MAX;i++){
	string s=keySettingNames[i];

	- keys[i]=atoi(getSettings()->getValue(s).c_str());
	+ keys[i] = InputManagerKeyCode::createFromString(getSettings()->getValue(s));

	s+="2";
	- alternativeKeys[i]=atoi(getSettings()->getValue(s).c_str());
	+ alternativeKeys[i] = InputManagerKeyCode::createFromString(getSettings()->getValue(s));

	//Move the alternative key to main key if the main key is empty.
	- if(keys[i]==0&&alternativeKeys[i]!=0){
	+ if(keys[i].empty() && !alternativeKeys[i].empty()){
	keys[i]=alternativeKeys[i];
	- alternativeKeys[i]=0;
	+ alternativeKeys[i] = InputManagerKeyCode();
	}

	//Remove duplicate.
	if(keys[i]==alternativeKeys[i])
	- alternativeKeys[i]=0;
	+ alternativeKeys[i] = InputManagerKeyCode();
	}
	}

	void InputManager::saveConfig(){
	int i;
	char c[32];
	for(i=0;i<INPUTMGR_MAX;i++){
	string s=keySettingNames[i];

	//Remove duplicate.
	if(keys[i]==alternativeKeys[i])
	- alternativeKeys[i]=0;
	+ alternativeKeys[i] = InputManagerKeyCode();

	- sprintf(c,"%d",keys[i]);
	- getSettings()->setValue(s,c);
	+ getSettings()->setValue(s, keys[i].toString());

	s+="2";
	- sprintf(c,"%d",alternativeKeys[i]);
	- getSettings()->setValue(s,c);
	+ getSettings()->setValue(s, alternativeKeys[i].toString());
	}
	}

	GUIObject* InputManager::showConfig(ImageManager& imageManager, SDL_Renderer& renderer,int height){
	//Create the new GUI.
	GUIObject* root=new GUIObject(imageManager,renderer,0,0,SCREEN_WIDTH,height);

	//Instruction label.
	GUIObject* obj=new GUILabel(imageManager,renderer,0,6,root->width,36,_("Select an item and press a key to change it."),0,true,true,GUIGravityCenter);
	root->addChild(obj);

	obj=new GUILabel(imageManager,renderer,0,30,root->width,36,_("Press backspace to clear the selected item."),0,true,true,GUIGravityCenter);
	root->addChild(obj);

	//The listbox for keys.
	GUIListBox listBox=new GUIListBox(imageManager,renderer,SCREEN_WIDTH0.15,72,SCREEN_WIDTH*0.7,height-72-8);
	root->addChild(listBox);

	//Create the event handler.
	if(handler)
	delete handler;
	handler=new InputDialogHandler(renderer,listBox,this);

	obj=new GUIKeyListener(imageManager,renderer);
	root->addChild(obj);

	//Return final widget.
	return root;
	}

	-//Get key name from key code.
	-std::string InputManager::getKeyCodeName(int keyCode){
	- char c[64];
	-// if(keyCode>0 && keyCode <0x1000){
	- //Keyboard.
	- const char* s=SDL_GetKeyName(static_cast<SDL_Keycode>(keyCode));
	- if(s!=NULL){
	- return s;
	- }else{
	- SDL_snprintf(c,64,"(Key %d)",keyCode);
	- return c;
	- }
	- //TODO Key code numbers seems to have changed in SDL2
	-/* }else if(keyCode>0x1000){
	- //Joystick. First set it to invalid value.
	- sprintf(c,"(Joystick 0x%08X)",keyCode);
	- //Check the input type.
	- switch((keyCode & 0x00FF0000)>>16){
	- case 1:
	- //Axis.
	- switch(keyCode & 0xFF){
	- case 1:
	- sprintf(c,"Joystick axis %d +",(keyCode & 0x0000FF00)>>8);
	- break;
	- case 0xFF:
	- sprintf(c,"Joystick axis %d -",(keyCode & 0x0000FF00)>>8);
	- break;
	- }
	- break;
	- case 2:
	- //Button.
	- sprintf(c,"Joystick button %d",(keyCode & 0x0000FF00)>>8);
	- break;
	- case 3:
	- //Hat.
	- switch(keyCode & 0xFF){
	- case SDL_HAT_LEFT:
	- sprintf(c,"Joystick hat %d left",(keyCode & 0x0000FF00)>>8);
	- break;
	- case SDL_HAT_RIGHT:
	- sprintf(c,"Joystick hat %d right",(keyCode & 0x0000FF00)>>8);
	- break;
	- case SDL_HAT_UP:
	- sprintf(c,"Joystick hat %d up",(keyCode & 0x0000FF00)>>8);
	- break;
	- case SDL_HAT_DOWN:
	- sprintf(c,"Joystick hat %d down",(keyCode & 0x0000FF00)>>8);
	- break;
	- }
	- break;
	- }
	- return c;
	- }else{
	- //Disabled or unknown.
	- return "-";
	- }*/
	-}
	-
	InputManager::InputManager(){
	//Clear the arrays.
	for(int i=0;i<INPUTMGR_MAX;i++){
	- keys[i]=alternativeKeys[i]=keyFlags[i]=0;
	+ keyFlags[i]=0;
	}
	}

	InputManager::~InputManager(){
	closeAllJoysticks();
	}

	-int InputManager::getKeyState(int keyCode,int oldState,bool hasEvent){
	- int state=0;
	-// if(keyCode>0 && keyCode<0x1000){
	+int InputManagerKeyCode::getKeyState(int oldState, bool hasEvent, std::vector<SDL_Joystick*>& joysticks, int deadZone) const {
	+ int state = 0;
	+
	+ switch (type) {
	+ default:
	//Keyboard.
	- if(hasEvent){
	- if(event.type==SDL_KEYDOWN && event.key.keysym.sym==keyCode){
	- state\|=0x2;
	- }
	- if(event.type==SDL_KEYUP && event.key.keysym.sym==keyCode){
	- state\|=0x4;
	+ if (sym == 0) return 0;
	+ if (hasEvent && (event.type == SDL_KEYDOWN \|\| event.type == SDL_KEYUP)) {
	+ const bool isModCorrect = (mod == 0) ? true :
	+ (mod == InputManagerKeyCode(event.key.keysym.sym, event.key.keysym.mod).mod);
	+
	+ if (event.type == SDL_KEYDOWN && event.key.keysym.sym == sym && isModCorrect) {
	+ state \|= 0x3;
	+ } else if (event.type == SDL_KEYUP && event.key.keysym.sym == sym && isModCorrect) {
	+ state \|= 0x4;
	}
	}
	- //Get keyboard state for key code
	- //SDL_GetKeyboardState needs a scankey rather than keycode, so we convert
	- int numKeys = 0;
	- const Uint8* keyStates = SDL_GetKeyboardState(&numKeys);
	- SDL_Scancode scanCode = SDL_GetScancodeFromKey(keyCode);
	- if(scanCode<numKeys && keyStates[scanCode]){
	- state\|=0x1;
	+ {
	+ //Get keyboard state for key code
	+ //SDL_GetKeyboardState needs a scankey rather than keycode, so we convert
	+ int numKeys = 0;
	+ const Uint8* keyStates = SDL_GetKeyboardState(&numKeys);
	+ SDL_Scancode scanCode = SDL_GetScancodeFromKey(sym);
	+ if (scanCode < numKeys && keyStates[scanCode]) {
	+ const int m = SDL_GetModState();
	+ const bool isModCorrect = (mod == 0) ? true :
	+ (mod == InputManagerKeyCode(sym, m).mod);
	+ if (isModCorrect) state \|= 0x1;
	+ }
	}
	- //TODO - key code numbers seems to have changed in SDL2, so disabling joystick for now
	-/* }else if(keyCode>0x1000){
	- //Joystick.
	- int index=(keyCode & 0x0000FF00)>>8;
	- int value=keyCode & 0xFF;
	- int i,v;
	- switch((keyCode & 0x00FF0000)>>16){
	- case 1:
	- //Axis.
	- if(hasEvent){
	- if(event.type==SDL_JOYAXISMOTION && event.jaxis.axis==index){
	- if((value==1 && event.jaxis.value>3200) \|\| (value==0xFF && event.jaxis.value<-3200)){
	- if((oldState & 0x1)==0) state\|=0x2;
	- }else{
	- if(oldState & 0x1) state\|=0x4;
	- }
	- }
	+ break;
	+ case JOYSTICK_AXIS:
	+ //Axis.
	+ if (hasEvent && event.type == SDL_JOYAXISMOTION && event.jaxis.axis == buttonIndex) {
	+ if ((buttonValue > 0 && event.jaxis.value > deadZone) \|\| (buttonValue < 0 && event.jaxis.value < -deadZone)) {
	+ if ((oldState & 0x1) == 0) state \|= 0x3;
	+ } else {
	+ if (oldState & 0x1) state \|= 0x4;
	}
	- for(i=0;i<(int)joysticks.size();i++){
	- v=SDL_JoystickGetAxis(joysticks[i],index);
	- if((value==1 && v>3200) \|\| (value==0xFF && v<-3200)){
	- state\|=0x1;
	- break;
	- }
	+ }
	+ for (auto j : joysticks) {
	+ Sint16 v = SDL_JoystickGetAxis(j, buttonIndex);
	+ if ((buttonValue > 0 && v > deadZone) \|\| (buttonValue < 0 && v < -deadZone)){
	+ state \|= 0x1;
	+ break;
	}
	- break;
	- case 2:
	- //Button.
	- if(hasEvent){
	- if(event.type==SDL_JOYBUTTONDOWN && event.jbutton.button==index){
	- state\|=0x2;
	- }
	- if(event.type==SDL_JOYBUTTONUP && event.jbutton.button==index){
	- state\|=0x4;
	- }
	+ }
	+ break;
	+ case JOYSTICK_BUTTON:
	+ //Button.
	+ if (hasEvent) {
	+ if (event.type == SDL_JOYBUTTONDOWN && event.jbutton.button == buttonIndex){
	+ state \|= 0x3;
	+ } else if (event.type == SDL_JOYBUTTONUP && event.jbutton.button == buttonIndex){
	+ state \|= 0x4;
	}
	- for(i=0;i<(int)joysticks.size();i++){
	- v=SDL_JoystickGetButton(joysticks[i],index);
	- if(v){
	- state\|=0x1;
	- break;
	- }
	+ }
	+ for (auto j : joysticks) {
	+ Uint8 v = SDL_JoystickGetButton(j, buttonIndex);
	+ if (v) {
	+ state \|= 0x1;
	+ break;
	}
	- break;
	- case 3:
	- //Hat.
	- if(hasEvent){
	- if(event.type==SDL_JOYHATMOTION && event.jhat.hat==index){
	- if(event.jhat.value & value){
	- if((oldState & 0x1)==0) state\|=0x2;
	- }else{
	- if(oldState & 0x1) state\|=0x4;
	- }
	- }
	+ }
	+ break;
	+ case JOYSTICK_HAT:
	+ //Hat.
	+ if (hasEvent && event.type == SDL_JOYHATMOTION && event.jhat.hat == buttonIndex) {
	+ if (event.jhat.value & buttonValue){
	+ if ((oldState & 0x1) == 0) state \|= 0x3;
	+ } else{
	+ if (oldState & 0x1) state \|= 0x4;
	}
	- for(i=0;i<(int)joysticks.size();i++){
	- v=SDL_JoystickGetHat(joysticks[i],index);
	- if(v & value){
	- state\|=0x1;
	- break;
	- }
	+ }
	+ for (auto j : joysticks) {
	+ Uint8 v = SDL_JoystickGetHat(j, buttonIndex);
	+ if (v & buttonValue) {
	+ state \|= 0x1;
	+ break;
	}
	- break;
	}
	- }*/
	+ break;
	+ }
	+
	return state;
	}

	//Update the key state, according to current SDL event, etc.
	void InputManager::updateState(bool hasEvent){
	for(int i=0;i<INPUTMGR_MAX;i++){
	- keyFlags[i]=getKeyState(keys[i],keyFlags[i],hasEvent)\|getKeyState(alternativeKeys[i],keyFlags[i],hasEvent);
	+ keyFlags[i] = keys[i].getKeyState(keyFlags[i], hasEvent, joysticks) \| alternativeKeys[i].getKeyState(keyFlags[i], hasEvent, joysticks);
	}
	}

	//Check if there is KeyDown event.
	bool InputManager::isKeyDownEvent(InputManagerKeys key){
	return keyFlags[key]&0x2;
	}

	//Check if there is KeyUp event.
	bool InputManager::isKeyUpEvent(InputManagerKeys key){
	return keyFlags[key]&0x4;
	}

	//Check if specified key is down.
	bool InputManager::isKeyDown(InputManagerKeys key){
	return keyFlags[key]&0x1;
	}

	//Open all joysticks.
	void InputManager::openAllJoysitcks(){
	int i,m;
	//First close previous joysticks.
	closeAllJoysticks();

	//Open all joysticks.
	m=SDL_NumJoysticks();
	for(i=0;i<m;i++){
	SDL_Joystick *j=SDL_JoystickOpen(i);
	if(j==NULL){
	printf("ERROR: Couldn't open Joystick %d\n",i);
	}else{
	joysticks.push_back(j);
	}
	}
	}

	//Close all joysticks.
	void InputManager::closeAllJoysticks(){
	for(int i=0;i<(int)joysticks.size();i++){
	SDL_JoystickClose(joysticks[i]);
	}
	joysticks.clear();
	}
	diff --git a/src/InputManager.h b/src/InputManager.h
	index 8638775..b377715 100644
	--- a/src/InputManager.h
	+++ b/src/InputManager.h
	@@ -1,115 +1,171 @@
	/*
	* 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 INPUTMANAGER_H
	#define INPUTMANAGER_H

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

	#include "GUIObject.h"

	enum InputManagerKeys{
	INPUTMGR_UP,
	INPUTMGR_DOWN,
	INPUTMGR_LEFT,
	INPUTMGR_RIGHT,
	INPUTMGR_JUMP,
	INPUTMGR_ACTION,
	INPUTMGR_SPACE,
	INPUTMGR_CANCELRECORDING,
	INPUTMGR_ESCAPE,
	INPUTMGR_RESTART,
	INPUTMGR_TAB,
	INPUTMGR_SAVE,
	INPUTMGR_LOAD,
	INPUTMGR_SWAP,
	INPUTMGR_TELEPORT,
	INPUTMGR_SUICIDE,
	INPUTMGR_SHIFT,
	INPUTMGR_NEXT,
	INPUTMGR_PREVIOUS,
	INPUTMGR_SELECT,
	INPUTMGR_MAX
	};

	+// Represents a key code or a joystick input code.
	+struct InputManagerKeyCode {
	+ // The input type. Currently joystick ball is unsupported.
	+ enum InputType {
	+ KEYBOARD,
	+ JOYSTICK_AXIS,
	+ JOYSTICK_BUTTON,
	+ JOYSTICK_HAT,
	+ };
	+
	+ // The input type.
	+ InputType type;
	+
	+ union {
	+ struct {
	+ // The keycode if the input type is KEYBOARD.
	+ // NOTE: if type == KEYBOARD and sym == 0 then this key is disabled at all.
	+ int sym;
	+
	+ // The modifier if the input type is KEYBOARD.
	+ // NOTE: if modifier == 0 then we don't check the modifier at all.
	+ int mod;
	+ };
	+
	+ struct {
	+ // Joystick button index.
	+ int buttonIndex;
	+
	+ // Joystick button value.
	+ // If type == JOYSTICK_AXIS then value should be 1 or -1.
	+ // If type == JOYSTICK_BUTTON then it's unused.
	+ // If type == JOYSTICK_HAT then it's SDL_HAT_LEFT, SDL_HAT_RIGHT, SDL_HAT_UP or SDL_HAT_DOWN.
	+ int buttonValue;
	+ };
	+ };
	+
	+ // Constructor for a keyboard input.
	+ explicit InputManagerKeyCode(int sym_ = 0, int mod_ = 0);
	+
	+ // Constructor for a joystick input.
	+ explicit InputManagerKeyCode(InputType type_, int buttonIndex_, int buttonValue_);
	+
	+ // Create a key code from string.
	+ static InputManagerKeyCode createFromString(const std::string& s);
	+
	+ // Convert a key code to a machine-readable string.
	+ std::string toString() const;
	+
	+ // Convert a key code to a human-readable string.
	+ std::string describe() const;
	+
	+ // Convert two key codes to a human-readable string.
	+ static std::string describeTwo(const InputManagerKeyCode& keyCode, const InputManagerKeyCode& keyCodeAlt);
	+
	+ // Check if the key code is empty.
	+ bool empty() const;
	+
	+ // Internal function to check if the key corresponding to this key code is pressed.
	+ // oldState: The bit-field flag saves the key states. 0x1=key is down, 0x2=KeyDown event,0x4=KeyUp event.
	+ // hasEvent: current SDL event is present.
	+ // joysticks: List of joystick to detect.
	+ // deadZone: Joystick dead zone for JOYSTICK_AXIS detection.
	+ // Return value: The bit-field flag with the same meaning as oldState.
	+ int getKeyState(int oldState, bool hasEvent, std::vector<SDL_Joystick*>& joysticks, int deadZone = 3200) const;
	+
	+ bool operator==(const InputManagerKeyCode& rhs) const;
	+ bool operator!=(const InputManagerKeyCode& rhs) const { return !(*this == rhs); }
	+
	+ // Check if a keyboard input contains another keyboard input (for example, Ctrl+A contains Ctrl but doesn't contain A).
	+ bool contains(const InputManagerKeyCode& rhs) const;
	+};
	+
	class InputManager{
	public:
	InputManager();
	~InputManager();

	//Get and set key code of each key.
	- int getKeyCode(InputManagerKeys key,bool isAlternativeKey);
	- void setKeyCode(InputManagerKeys key,int keyCode,bool isAlternativeKey);
	+ InputManagerKeyCode getKeyCode(InputManagerKeys key, bool isAlternativeKey);
	+ void setKeyCode(InputManagerKeys key, const InputManagerKeyCode& keyCode, bool isAlternativeKey);

	//Load and save key settings from config file.
	void loadConfig();
	void saveConfig();

	//Show the config screen.
	GUIObject* showConfig(ImageManager& imageManager, SDL_Renderer& renderer, int height);

	- //Get key name from key code
	- static std::string getKeyCodeName(int keyCode);
	-
	//Update the key state, according to current SDL event, etc.
	void updateState(bool hasEvent);

	//Check if there is KeyDown event.
	bool isKeyDownEvent(InputManagerKeys key);
	//Check if there is KeyUp event.
	bool isKeyUpEvent(InputManagerKeys key);
	//Check if specified key is down.
	bool isKeyDown(InputManagerKeys key);

	//Open all joysticks.
	void openAllJoysitcks();
	//Close all joysticks.
	void closeAllJoysticks();
	private:
	//The key code of each key.
	- // - note of key code:
	- // 0 means this key is disabled
	- // 1 to 4095 (0xFFF) means keyboard keys,
	- // currently SDLKey is less than 4095
	- // >= 4096: bit field value means joystick.
	- // 0xWWXXYYZZ
	- // WW = joystick index. currently unused, should be 0.
	- // XX = joystick button type: 1-axis 2-button 3-hat, currently ball is unsupported
	- // YY = joystick button index. (we assume joystick has at most 256 buttons)
	- // ZZ = value. if type=axis then value should be 1 or 0xFF.
	- // if type=button then it's unused.
	- // if type=hat then it's SDL_HAT_LEFT, SDL_HAT_RIGHT, SDL_HAT_UP or SDL_HAT_DOWN.
	- int keys[INPUTMGR_MAX];
	- int alternativeKeys[INPUTMGR_MAX];
	+ InputManagerKeyCode keys[INPUTMGR_MAX], alternativeKeys[INPUTMGR_MAX];
	+
	//The bit-field flag array saves the key states.
	// 0x1 means the key is down.
	// 0x2 means KeyDown event.
	// 0x4 means KeyUp event.
	int keyFlags[INPUTMGR_MAX];
	+
	//Contains all joysticks.
	std::vector<SDL_Joystick*> joysticks;
	- //Internal function.
	- int getKeyState(int keyCode,int oldState,bool hasEvent);
	};

	extern InputManager inputMgr;

	#endif //INPUTMANAGER_H
	diff --git a/src/TitleMenu.cpp b/src/TitleMenu.cpp
	index 7e772ae..ce94a83 100644
	--- a/src/TitleMenu.cpp
	+++ b/src/TitleMenu.cpp
	@@ -1,869 +1,869 @@
	/*
	* Copyright (C) 2011-2013 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 "Functions.h"
	#include "GameState.h"
	#include "TitleMenu.h"
	#include "ThemeManager.h"
	#include "GUIListBox.h"
	#include "GUITextArea.h"
	#include "InputManager.h"
	#include "LevelPackManager.h"
	#include "StatisticsManager.h"
	#include "MusicManager.h"
	#include "SoundManager.h"
	#include <iostream>
	#include <algorithm>
	#include <sstream>

	#include "libs/tinygettext/tinygettext.hpp"

	using namespace std;

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

	Menu::Menu(ImageManager &imageManager, SDL_Renderer& renderer){
	animation=highlight=0;

	//Load the title image.
	titleTexture=imageManager.loadTexture(getDataPath()+"gfx/menu/title.png",renderer);


	auto tft = [&](const char* text){
	return textureFromText(renderer, *fontTitle, text, objThemes.getTextColor(false));
	};

	//Now render the five entries.
	entries[0]=tft(_("Play"));
	entries[1]=tft(_("Options"));
	entries[2]=tft(_("Map Editor"));
	entries[3]=tft(_("Addons"));
	entries[4]=tft(_("Quit"));
	entries[5]=tft(">");
	entries[6]=tft("<");

	//Load the textures for the credits and statistics buttons and their tooltips.
	creditsIcon=imageManager.loadTexture(getDataPath()+"gfx/menu/credits.png", renderer);
	creditsTooltip=textureFromText(renderer, *fontText, _("Credits"), objThemes.getTextColor(true));
	statisticsIcon=imageManager.loadTexture(getDataPath()+"gfx/menu/statistics.png", renderer);
	statisticsTooltip=textureFromText(renderer, *fontText, _("Achievements and Statistics"), objThemes.getTextColor(true));

	// Check if textures were loaded.
	//TODO: Handle this better.
	if(!titleTexture \|\| !creditsIcon \|\| !statisticsIcon) {
	std::cerr << "Failed to load one or more images for the main menu, exiting. : " << SDL_GetError() << std::endl;
	std::terminate();
	}
	}

	Menu::~Menu(){
	}


	void Menu::handleEvents(ImageManager& imageManager, SDL_Renderer& renderer){
	//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){
	highlight=0;

	if(x>=200&&x<SCREEN_WIDTH-200&&y>=(SCREEN_HEIGHT-250)/2&&y<(SCREEN_HEIGHT-200)/2+320){
	highlight=(y-((SCREEN_HEIGHT-200)/2-64))/64;
	if(highlight>5) highlight=0;
	}

	//Also check the icons.
	if(y>=SCREEN_HEIGHT-56&&y<SCREEN_HEIGHT-8){
	if(x>=SCREEN_WIDTH-8){
	//do nothing
	}else if(x>=SCREEN_WIDTH-56){
	highlight=7;
	}else if(x>=SCREEN_WIDTH-104){
	highlight=6;
	}
	}
	}

	//Down/Up -arrows move highlight
	int mod = SDL_GetModState();
	if (inputMgr.isKeyDownEvent(INPUTMGR_DOWN) \|\| inputMgr.isKeyDownEvent(INPUTMGR_RIGHT) \|\| (inputMgr.isKeyDownEvent(INPUTMGR_TAB) && (mod & KMOD_SHIFT) == 0)) {
	isKeyboardOnly = true;
	highlight++;
	if(highlight>7)
	highlight=0;
	} else if (inputMgr.isKeyDownEvent(INPUTMGR_UP) \|\| inputMgr.isKeyDownEvent(INPUTMGR_LEFT) \|\| (inputMgr.isKeyDownEvent(INPUTMGR_TAB) && (mod & KMOD_SHIFT) != 0)) {
	isKeyboardOnly = true;
	highlight--;
	if(highlight<0)
	highlight=7;
	}

	//Check if there's a press event.
	if((event.type==SDL_MOUSEBUTTONUP && event.button.button==SDL_BUTTON_LEFT) \|\|
	(inputMgr.isKeyUpEvent(INPUTMGR_SELECT))){
	//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(imageManager,renderer,_("Enable internet in order to install addons."),MsgBoxOKOnly,_("Internet disabled"));
	break;
	}

	//Enter the addons state.
	setNextState(STATE_ADDONS);
	break;
	case 5:
	//We quit, so we enter the exit state.
	setNextState(STATE_EXIT);
	break;
	case 6:
	//Show the credits screen.
	setNextState(STATE_CREDITS);
	break;
	case 7:
	//Show the statistics screen.
	setNextState(STATE_STATISTICS);
	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);
	}
	}

	void Menu::logic(ImageManager&, SDL_Renderer&){
	animation++;
	if(animation>10)
	animation=-10;
	}

	void Menu::render(ImageManager&, SDL_Renderer& renderer){
	//Draw background.
	objThemes.getBackground(true)->draw(renderer);
	objThemes.getBackground(true)->updateAnimation();

	//Draw the title.
	{
	int titleWidth, titleHeight = 0;
	SDL_QueryTexture(titleTexture.get(), NULL, NULL, &titleWidth, &titleHeight);
	const SDL_Rect rect = SDL_Rect{(SCREEN_WIDTH-titleWidth)/2, 40, titleWidth, titleHeight};
	SDL_RenderCopy(&renderer, titleTexture.get(), NULL, &rect);
	}

	// Position where we start drawing the menu entries from.
	const int menuStartY = std::max(SCREEN_HEIGHT - 200, 0) / 2;

	//Draw the menu entries.
	for(unsigned int i=0;i<5;i++){
	SDL_Rect dstRect = rectFromTexture(0, 0, *entries[i]);
	dstRect.x = std::max(SCREEN_WIDTH - dstRect.w, 0) / 2;
	dstRect.y = menuStartY + 64*i+(64-dstRect.h) / 2;
	SDL_RenderCopy(&renderer, entries[i].get(), NULL, &dstRect);
	}

	//Check if an option is selected/highlighted.
	if(highlight>0 && highlight<=5){
	// Width of highlighted entry.
	const int highlightWidth = rectFromTexture(0, 0, *entries[highlight - 1]).w;
	const int leftOfHighlight = (SCREEN_WIDTH-highlightWidth)/2;
	const SDL_Rect leftSize = rectFromTexture(0, 0, *entries[5]);
	const int rightHeight = rectFromTexture(0, 0, *entries[6]).h;
	// How much to offset the arrows to create the animation.
	const int animationX = (25-abs(animation)/2);
	// The common value of both arrow's y positions.
	const int yCommon = menuStartY-64+64*highlight;

	//Draw the '>' sign, which is entry 5.
	int x=leftOfHighlight-animationX-leftSize.w;
	int y=yCommon+(64-leftSize.h)/2;
	applyTexture(x, y, *entries[5], renderer);

	//Draw the '<' sign, which is entry 6.
	x=leftOfHighlight+highlightWidth+animationX;
	y=yCommon+(64-rightHeight)/2;
	applyTexture(x, y, *entries[6], renderer);
	}

	//Check if an icon is selected/highlighted and draw tooltip
	if(highlight==6 \|\| highlight==7){
	SDL_Texture* texture;
	if(highlight==6) {
	texture = creditsTooltip.get();
	} else {
	texture = statisticsTooltip.get();
	}
	const SDL_Rect textureSize = rectFromTexture(*texture);
	drawGUIBox(-2,SCREEN_HEIGHT-textureSize.h-2,textureSize.w+4,textureSize.h+4,renderer,0xFFFFFFFF);
	applyTexture(0, SCREEN_HEIGHT - textureSize.h, *texture, renderer);
	}

	//Draw border of icon if it's keyboard only mode.
	if (isKeyboardOnly) {
	if (highlight == 6) {
	drawGUIBox(SCREEN_WIDTH - 100, SCREEN_HEIGHT - 52, 40, 40, renderer, 0xFFFFFF40);
	}
	if (highlight == 7) {
	drawGUIBox(SCREEN_WIDTH - 52, SCREEN_HEIGHT - 52, 40, 40, renderer, 0xFFFFFF40);
	}
	}

	//Draw icons.
	applyTexture(SCREEN_WIDTH-96,SCREEN_HEIGHT-48,*creditsIcon,renderer);
	applyTexture(SCREEN_WIDTH-48,SCREEN_HEIGHT-48,*statisticsIcon,renderer);
	}

	void Menu::resize(ImageManager &, SDL_Renderer&){}


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

	//Some variables for the options.
	static bool fullscreen,internet,fade,quickrec;
	static string themeName,languageName;
	static int lastLang,lastRes;

	static bool useProxy;
	static string internetProxy;

	static bool restartFlag;

	static _res currentRes;
	static vector<_res> resolutionList;

	Options::Options(ImageManager& imageManager,SDL_Renderer& renderer){
	//Render the title.
	title=textureFromText(renderer, *fontTitle, _("Settings"), objThemes.getTextColor(false));

	//Initialize variables.
	lastJumpSound=0;
	clearIconHower=false;

	//Load icon image and tooltip text.
	clearIcon=imageManager.loadTexture(getDataPath()+"gfx/menu/clear-progress.png",renderer);
	/// TRANSLATORS: Used for button which clear any level progress like unlocked levels and highscores.
	clearTooltip=textureFromText(renderer, *fontText, _("Clear Progress"), objThemes.getTextColor(true));

	//Set some default settings.
	fullscreen=getSettings()->getBoolValue("fullscreen");
	languageName=getSettings()->getValue("lang");
	themeName=processFileName(getSettings()->getValue("theme"));
	internet=getSettings()->getBoolValue("internet");
	internetProxy=getSettings()->getValue("internet-proxy");
	useProxy=!internetProxy.empty();
	fade=getSettings()->getBoolValue("fading");
	quickrec=getSettings()->getBoolValue("quickrecord");

	//Set the restartFlag false.
	restartFlag=false;

	//Now create the gui.
	createGUI(imageManager,renderer);
	}

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

	void Options::createGUI(ImageManager& imageManager,SDL_Renderer& renderer){
	//Variables for positioning
	const int columnW=SCREEN_WIDTH*0.3;
	const int column1X=SCREEN_WIDTH*0.15;
	const int column2X=SCREEN_WIDTH*0.55;
	const int lineHeight=40;

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

	//Single line list for different tabs.
	GUISingleLineListBox* listBox=new GUISingleLineListBox(imageManager,renderer,(SCREEN_WIDTH-500)/2,104,500,32);
	listBox->addItem(_("General"));
	listBox->addItem(_("Controls"));
	listBox->value=0;
	listBox->name="lstTabs";
	listBox->eventCallback=this;
	GUIObjectRoot->addChild(listBox);

	//Create general tab.
	tabGeneral=new GUIObject(imageManager,renderer,0,150,SCREEN_WIDTH,SCREEN_HEIGHT);
	GUIObjectRoot->addChild(tabGeneral);

	//Now we create GUIObjects for every option.
	GUIObject* obj=new GUILabel(imageManager,renderer,column1X,0,columnW,36,_("Music"));
	tabGeneral->addChild(obj);

	musicSlider=new GUISlider(imageManager,renderer,column2X,0,columnW,36,atoi(getSettings()->getValue("music").c_str()),0,128,15);
	musicSlider->name="sldMusic";
	musicSlider->eventCallback=this;
	tabGeneral->addChild(musicSlider);

	obj=new GUILabel(imageManager,renderer,column1X,lineHeight,columnW,36,_("Sound"));
	tabGeneral->addChild(obj);

	soundSlider=new GUISlider(imageManager,renderer,column2X,lineHeight,columnW,36,atoi(getSettings()->getValue("sound").c_str()),0,128,15);
	soundSlider->name="sldSound";
	soundSlider->eventCallback=this;
	tabGeneral->addChild(soundSlider);

	obj=new GUILabel(imageManager,renderer,column1X,2*lineHeight,columnW,36,_("Resolution"));
	obj->name="lstResolution";
	tabGeneral->addChild(obj);

	//Create list with many different resolutions.
	resolutions = new GUISingleLineListBox(imageManager,renderer,column2X,2*lineHeight,columnW,36);
	resolutions->value=-1;

	//Only get the resolution list if it hasn't been done before.
	if(resolutionList.empty()){
	resolutionList=getResolutionList();
	}

	//Get current resolution from config file. Thus it can be user defined.
	currentRes.w=atoi(getSettings()->getValue("width").c_str());
	currentRes.h=atoi(getSettings()->getValue("height").c_str());

	for(int i=0; i<(int)resolutionList.size();i++){
	//Create a string from width and height and then add it to list.
	ostringstream out;
	out << resolutionList[i].w << "x" << resolutionList[i].h;
	resolutions->addItem(out.str());

	//Check if current resolution matches, select it.
	if(resolutionList[i].w==currentRes.w && resolutionList[i].h==currentRes.h){
	resolutions->value=i;
	}
	}

	//Add current resolution if it isn't already in the list.
	if(resolutions->value==-1){
	ostringstream out;
	out << currentRes.w << "x" << currentRes.h;
	resolutions->addItem(out.str());
	resolutions->value=resolutions->item.size()-1;
	}
	lastRes=resolutions->value;

	tabGeneral->addChild(resolutions);

	obj=new GUILabel(imageManager,renderer,column1X,3*lineHeight,columnW,36,_("Language"));
	tabGeneral->addChild(obj);

	//Create GUI list with available languages.
	langs = new GUISingleLineListBox(imageManager,renderer,column2X,3*lineHeight,columnW,36);
	langs->name="lstLanguages";

	/// TRANSLATORS: as detect user's language automatically
	langs->addItem("",_("Auto-Detect"));
	langs->addItem("en","English");

	//Get a list of every available language.
	set<tinygettext::Language> languages = dictionaryManager->get_languages();
	for (set<tinygettext::Language>::iterator s0 = languages.begin(); s0 != languages.end(); ++s0){
	//If language in loop is the same in config file, then select it
	if(getSettings()->getValue("lang")==s0->str()){
	lastLang=distance(languages.begin(),s0)+2;
	}
	//Add language in loop to list and listbox.
	langs->addItem(s0->str(),s0->get_name());
	}

	//If Auto or English are selected.
	if(getSettings()->getValue("lang")==""){
	lastLang=0;
	}else if(getSettings()->getValue("lang")=="en"){
	lastLang=1;
	}

	langs->value=lastLang;
	tabGeneral->addChild(langs);

	obj=new GUILabel(imageManager,renderer,column1X,4*lineHeight,columnW,36,_("Theme"));
	obj->name="theme";
	tabGeneral->addChild(obj);

	//Create the theme option gui element.
	theme=new GUISingleLineListBox(imageManager,renderer,column2X,4*lineHeight,columnW,36);
	theme->name="lstTheme";

	//Vector containing the theme locations and names.
	vector<pair<string,string> > themes;
	vector<string> v=enumAllDirs(getUserPath(USER_DATA)+"themes/");
	for(vector<string>::iterator i=v.begin(); i!=v.end(); ++i){
	string location=getUserPath(USER_DATA)+"themes/"+*i;
	themes.push_back(pair<string,string>(location,*i));
	}
	vector<string> v2=enumAllDirs(getDataPath()+"themes/");
	for(vector<string>::iterator i=v2.begin(); i!=v2.end(); ++i){
	string location=getDataPath()+"themes/"+*i;
	themes.push_back(pair<string,string>(location,*i));
	}

	//Try to find the configured theme so we can display it.
	int value=-1;
	for(vector<pair<string,string> >::iterator i=themes.begin(); i!=themes.end(); ++i){
	if(i->first==themeName) {
	value=i-themes.begin();
	}
	}
	theme->addItems(themes);
	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(imageManager,renderer,"lstTheme",theme,GUIEventChange);
	theme->eventCallback=this;
	tabGeneral->addChild(theme);

	//Proxy settings.
	obj=new GUILabel(imageManager,renderer,column1X,5*lineHeight,columnW,36,_("Internet proxy"));
	obj->name="chkProxy";
	obj->eventCallback=this;
	tabGeneral->addChild(obj);
	obj=new GUITextBox(imageManager,renderer,column2X,5*lineHeight,columnW,36,internetProxy.c_str());
	obj->name="txtProxy";
	obj->eventCallback=this;
	tabGeneral->addChild(obj);

	obj=new GUICheckBox(imageManager,renderer,column1X,6*lineHeight,columnW,36,_("Fullscreen"),fullscreen?1:0);
	obj->name="chkFullscreen";
	obj->eventCallback=this;
	tabGeneral->addChild(obj);

	obj=new GUICheckBox(imageManager,renderer,column2X,6*lineHeight,columnW,36,_("Internet"),internet?1:0);
	obj->name="chkInternet";
	obj->eventCallback=this;
	tabGeneral->addChild(obj);

	obj=new GUICheckBox(imageManager,renderer,column2X,7*lineHeight,columnW,36,_("Fade transition"),fade?1:0);
	obj->name="chkFade";
	obj->eventCallback=this;
	tabGeneral->addChild(obj);

	obj=new GUICheckBox(imageManager,renderer,column1X,7*lineHeight,columnW,36,_("Quick record"),quickrec?1:0);
	obj->name="chkQuickRec";
	obj->eventCallback=this;
	tabGeneral->addChild(obj);

	//Create the controls tab.
	tabControls=inputMgr.showConfig(imageManager,renderer,SCREEN_HEIGHT-210);
	tabControls->top=140;
	tabControls->visible=false;
	GUIObjectRoot->addChild(tabControls);

	//Save original keys.
	for(int i=0;i<INPUTMGR_MAX;i++){
	tmpKeys[i]=inputMgr.getKeyCode((InputManagerKeys)i,false);
	tmpAlternativeKeys[i]=inputMgr.getKeyCode((InputManagerKeys)i,true);
	}

	//Create buttons.
	GUIObjectb1=new GUIButton(imageManager,renderer,SCREEN_WIDTH0.3,SCREEN_HEIGHT-60,-1,36,_("Cancel"),0,true,true,GUIGravityCenter);
	b1->name="cmdBack";
	b1->eventCallback=this;
	GUIObjectRoot->addChild(b1);

	GUIObject* b2=new GUIButton(imageManager,renderer,SCREEN_WIDTH*0.7,SCREEN_HEIGHT-60,-1,36,_("Save Changes"),0,true,true,GUIGravityCenter);
	b2->name="cmdSave";
	b2->eventCallback=this;
	GUIObjectRoot->addChild(b2);
	}

	static string convertInt(int i){
	stringstream ss;
	ss << i;
	return ss.str();
	}

	void Options::GUIEventCallback_OnEvent(ImageManager& imageManager, SDL_Renderer& renderer, std::string name,GUIObject* obj,int eventType){
	//Check what type of event it was.
	if(eventType==GUIEventClick){
	if(name=="cmdBack"){
	//Reset the key changes.
	for(int i=0;i<INPUTMGR_MAX;i++){
	inputMgr.setKeyCode((InputManagerKeys)i,tmpKeys[i],false);
	inputMgr.setKeyCode((InputManagerKeys)i,tmpAlternativeKeys[i],true);
	}

	//Reset the music volume.
	getMusicManager()->setVolume(atoi(getSettings()->getValue("music").c_str()));
	Mix_Volume(-1,atoi(getSettings()->getValue("sound").c_str()));

	//And goto the main menu.
	setNextState(STATE_MENU);
	}else if(name=="cmdSave"){
	//Save is pressed thus save
	char s[64];
	sprintf(s,"%d",soundSlider->value);
	getSettings()->setValue("sound",s);
	sprintf(s,"%d",musicSlider->value);
	getSettings()->setValue("music",s);
	getMusicManager()->setEnabled(musicSlider->value>0);
	Mix_Volume(-1,soundSlider->value);
	getSettings()->setValue("fullscreen",fullscreen?"1":"0");
	getSettings()->setValue("internet",internet?"1":"0");
	getSettings()->setValue("theme",themeName);
	getSettings()->setValue("fading",fade?"1":"0");
	getSettings()->setValue("quickrecord",quickrec?"1":"0");
	//Before loading the theme remove the previous one from the stack.
	objThemes.removeTheme();
	loadTheme(imageManager,renderer,themeName);
	if(!useProxy)
	internetProxy.clear();
	getSettings()->setValue("internet-proxy",internetProxy);
	getSettings()->setValue("lang",langs->getName());

	//Is resolution from the list or is it user defined in config file
	if(resolutions->value<(int)resolutionList.size()){
	getSettings()->setValue("width",convertInt(resolutionList[resolutions->value].w));
	getSettings()->setValue("height",convertInt(resolutionList[resolutions->value].h));
	}else{
	getSettings()->setValue("width",convertInt(currentRes.w));
	getSettings()->setValue("height",convertInt(currentRes.h));
	}

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

	//Save the settings.
	saveSettings();

	//Before we return check if some .
	if(restartFlag \|\| resolutions->value!=lastRes){
	//The resolution changed so we need to recreate the screen.
	if(!createScreen()){
	//Screen creation failed so set to safe settings.
	getSettings()->setValue("fullscreen","0");
	getSettings()->setValue("width",convertInt(resolutionList[lastRes].w));
	getSettings()->setValue("height",convertInt(resolutionList[lastRes].h));

	if(!createScreen()){
	//Everything fails so quit.
	setNextState(STATE_EXIT);
	return;
	}
	}

	//The screen is created, now load the (menu) theme.
	if(!loadTheme(imageManager,renderer,"")){
	//Loading the theme failed so quit.
	setNextState(STATE_EXIT);
	return;
	}
	}

	if(langs->value!=lastLang){
	//We set the language.
	language=langs->getName();
	dictionaryManager->set_language(tinygettext::Language::from_name(language));
	getLevelPackManager()->updateLanguage();

	//And reload the font.
	if(!loadFonts()){
	//Loading failed so quit.
	setNextState(STATE_EXIT);
	return;
	}
	}

	//Now return to the main menu.
	setNextState(STATE_MENU);
	}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=="chkInternet"){
	internet=obj->value?true:false;
	}else if(name=="chkProxy"){
	useProxy=obj->value?true:false;
	}else if(name=="chkFade"){
	fade=obj->value?true:false;
	}else if(name=="chkQuickRec"){
	quickrec=obj->value?true:false;
	}
	}
	if(name=="lstTheme"){
	if(theme!=NULL && theme->value>=0 && theme->value<(int)theme->item.size()){
	//Convert the themeName to contain %DATA%, etc...
	themeName=compressFileName(theme->item[theme->value].first);
	}
	}else if(name=="txtProxy"){
	internetProxy=obj->caption;

	//Check if the internetProxy field is empty.
	useProxy=!internetProxy.empty();
	}else if(name=="sldMusic"){
	getMusicManager()->setEnabled(musicSlider->value>0);
	getMusicManager()->setVolume(musicSlider->value);
	}else if(name=="sldSound"){
	Mix_Volume(-1,soundSlider->value);
	if(lastJumpSound==0){
	getSoundManager()->playSound("jump");
	lastJumpSound=15;
	}
	}
	if(name=="lstTabs"){
	if(obj->value==0){
	tabGeneral->visible=true;
	tabControls->visible=false;
	}else{
	tabGeneral->visible=false;
	tabControls->visible=true;
	}
	}
	}

	void Options::handleEvents(ImageManager& imageManager, SDL_Renderer& renderer){
	//Get the x and y location of the mouse.
	int x,y;
	SDL_GetMouseState(&x,&y);

	//Check icon.
	if(event.type==SDL_MOUSEMOTION \|\| event.type==SDL_MOUSEBUTTONDOWN){
	if(y>=SCREEN_HEIGHT-56&&y<SCREEN_HEIGHT-8&&x>=SCREEN_WIDTH-56)
	clearIconHower=true;
	else
	clearIconHower=false;
	}

	if(event.type==SDL_MOUSEBUTTONUP && event.button.button==SDL_BUTTON_LEFT && clearIconHower){
	if(msgBox(imageManager,renderer,_("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
	//Reset statistics.
	statsMgr.reloadCompletedLevelsAndAchievements();
	}
	}

	//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)){
	+ if (inputMgr.isKeyUpEvent(INPUTMGR_ESCAPE) && (tabControls == NULL \|\| !tabControls->visible)) {
	setNextState(STATE_MENU);
	}
	}

	void Options::logic(ImageManager&, SDL_Renderer&){
	//Increase the lastJumpSound variable if needed.
	if(lastJumpSound!=0){
	lastJumpSound--;
	}
	}

	void Options::render(ImageManager&, SDL_Renderer& renderer){
	//Draw background.
	objThemes.getBackground(true)->draw(renderer);
	objThemes.getBackground(true)->updateAnimation();

	//Now render the title.
	drawTitleTexture(SCREEN_WIDTH, *title, renderer);

	//Check if an icon is selected/highlighted and draw tooltip
	if(clearIconHower){
	const SDL_Rect texSize = rectFromTexture(*clearTooltip);
	drawGUIBox(-2,SCREEN_HEIGHT-texSize.h-2,texSize.w+4,texSize.h+4,renderer,0xFFFFFFFF);
	applyTexture(0,SCREEN_HEIGHT-texSize.h,clearTooltip,renderer);
	}

	//Draw icon.
	applyTexture(SCREEN_WIDTH-48,SCREEN_HEIGHT-48,*clearIcon,renderer);

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

	void Options::resize(ImageManager& imageManager, SDL_Renderer& renderer){
	//Recreate the gui to fit the new resolution.
	createGUI(imageManager,renderer);
	}

	/////////////////////////CREDITS_MENU//////////////////////////////////

	Credits::Credits(ImageManager& imageManager,SDL_Renderer& renderer){
	//Render the title.
	title=textureFromText(renderer, *fontTitle,_("Credits"),objThemes.getTextColor(false));

	//Vector that will hold every line of the credits.
	vector<string> credits;

	//Open the AUTHORS file and read every line.
	{
	ifstream fin((getDataPath()+"/../AUTHORS").c_str());
	if(!fin.is_open()) {
	cerr<<"ERROR: Unable to open the AUTHORS file."<<endl;
	credits.push_back("ERROR: Unable to open the AUTHORS file.");
	credits.push_back("");
	}

	//Loop the lines of the file.
	string line;
	while(getline(fin,line)){
	credits.push_back(line);
	}
	}

	//Enter a new line between the two files.
	credits.push_back("");

	//Open the Credits.text file and read every line.
	{
	ifstream fin((getDataPath()+"/Credits.txt").c_str());
	if(!fin.is_open()) {
	cerr<<"ERROR: Unable to open the Credits.txt file."<<endl;
	credits.push_back("ERROR: Unable to open the Credits.txt file.");
	credits.push_back("");
	}

	//Loop the lines of the file.
	string line;
	while(getline(fin,line)){
	credits.push_back(line);

	//NOTE: Some sections point to other credits files.
	if(line=="music/") {
	vector<string> musicCredits=getMusicManager()->createCredits();
	credits.insert(credits.end(),musicCredits.begin(),musicCredits.end());
	}
	}
	}

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

	//Create back button.
	backButton=new GUIButton(imageManager,renderer,SCREEN_WIDTH*0.5,SCREEN_HEIGHT-60,-1,36,_("Back"),0,true,true,GUIGravityCenter);
	backButton->name="cmdBack";
	backButton->eventCallback=this;
	GUIObjectRoot->addChild(backButton);

	//Create a text area for credits.
	textArea=new GUITextArea(imageManager,renderer,SCREEN_WIDTH0.05,114,SCREEN_WIDTH0.9,SCREEN_HEIGHT-200);
	textArea->setFont(fontMono);
	textArea->setStringArray(renderer, std::move(credits));
	textArea->editable=false;
	textArea->extractHyperlinks();
	GUIObjectRoot->addChild(textArea);
	}

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

	void Credits::GUIEventCallback_OnEvent(ImageManager& imageManager, SDL_Renderer& renderer, std::string name,GUIObject* obj,int eventType){
	//Check what type of event it was.
	if(eventType==GUIEventClick){
	if(name=="cmdBack"){
	//Goto the main menu.
	setNextState(STATE_MENU);
	}
	}
	}

	void Credits::handleEvents(ImageManager&, SDL_Renderer&){
	//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);
	}
	}

	void Credits::logic(ImageManager&, SDL_Renderer&){}

	void Credits::render(ImageManager&,SDL_Renderer &renderer){
	//Draw background.
	objThemes.getBackground(true)->draw(renderer);
	objThemes.getBackground(true)->updateAnimation();

	//Now render the title.
	drawTitleTexture(SCREEN_WIDTH, *title, renderer);

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

	void Credits::resize(ImageManager&, SDL_Renderer&){
	//Resize and position widgets.
	GUIObjectRoot->width=SCREEN_WIDTH;
	GUIObjectRoot->height=SCREEN_HEIGHT;

	backButton->left=SCREEN_WIDTH/2;
	backButton->top=SCREEN_HEIGHT-60;

	textArea->left=SCREEN_WIDTH*0.05;
	textArea->width=SCREEN_WIDTH*0.9;
	textArea->height=SCREEN_HEIGHT-200;
	textArea->resize();
	}
	diff --git a/src/TitleMenu.h b/src/TitleMenu.h
	index 9e18456..02a53d2 100644
	--- a/src/TitleMenu.h
	+++ b/src/TitleMenu.h
	@@ -1,160 +1,159 @@
	/*
	* Copyright (C) 2011-2013 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 TITLE_MENU_H
	#define TITLE_MENU_H

	#include <array>

	#include <SDL.h>
	#include "GameState.h"

	//Included for the Options menu.
	#include "Render.h"
	#include "GUIObject.h"
	#include "GUIListBox.h"
	#include "GUISlider.h"
	#include "GUITextArea.h"
	#include "InputManager.h"
	#include "ImageManager.h"

	//The Main menu.
	class Menu : public GameState{
	private:
	//The title of the main menu.
	SharedTexture titleTexture;

	//Array containg pointers the five main menu entries.
	//The last two are the '>' and '<' characters.
	std::array<TexturePtr, 7> entries;

	//The icon and for the statistics menu.
	SharedTexture statisticsIcon;
	TexturePtr statisticsTooltip;

	//The icon for the credits menu.
	SharedTexture creditsIcon;
	TexturePtr creditsTooltip;

	//Integer used for animations.
	int animation;

	//Integer containing the highlighted/selected menu option.
	int highlight;
	public:
	//Constructor.
	Menu(ImageManager& imageManager, SDL_Renderer &renderer);
	//Destructor.
	~Menu();

	//Inherited from GameState.
	void handleEvents(ImageManager& imageManager, SDL_Renderer& renderer) override;
	void logic(ImageManager&, SDL_Renderer&) override;
	void render(ImageManager&, SDL_Renderer& renderer) override;
	void resize(ImageManager&, SDL_Renderer&) override;
	};

	//The Options menu.
	class Options : public GameState, private GUIEventCallback{
	private:
	//The title of the options menu.
	TexturePtr title;

	//Icon.
	SharedTexture clearIcon;
	bool clearIconHower;
	TexturePtr clearTooltip;

	//Slider used to set the music volume
	GUISlider* musicSlider;
	//Slider used to set the sound volume
	GUISlider* soundSlider;

	//Integer to keep track of the time passed since last playing the test sound.
	int lastJumpSound;

	//ListBox containing the themes the user can choose out.
	GUISingleLineListBox* theme;

	//Available languages
	GUISingleLineListBox* langs;

	//Resolution list
	GUISingleLineListBox* resolutions;

	//Containers for different tabs.
	GUIObject* tabGeneral;
	GUIObject* tabControls;

	//Keys.
	- int tmpKeys[INPUTMGR_MAX];
	- int tmpAlternativeKeys[INPUTMGR_MAX];
	-
	+ InputManagerKeyCode tmpKeys[INPUTMGR_MAX], tmpAlternativeKeys[INPUTMGR_MAX];
	+
	//GUI events are handled here.
	//name: The name of the element that invoked the event.
	//obj: Pointer to the object that invoked the event.
	//eventType: Integer containing the type of event.
	void GUIEventCallback_OnEvent(ImageManager& imageManager, SDL_Renderer& renderer, std::string name,GUIObject* obj,int eventType);

	public:
	//Constructor.
	Options(ImageManager& imageManager,SDL_Renderer& renderer);
	//Destructor.
	~Options();

	//Method that will create the GUI for the options menu.
	void createGUI(ImageManager &imageManager, SDL_Renderer &renderer);

	//Inherited from GameState.
	void handleEvents(ImageManager& imageManager, SDL_Renderer& renderer) override;
	void logic(ImageManager&, SDL_Renderer&) override;
	void render(ImageManager&, SDL_Renderer& renderer) override;
	void resize(ImageManager &imageManager, SDL_Renderer&renderer) override;
	};

	//The Credits menu.
	class Credits : public GameState, private GUIEventCallback{
	private:
	//The title of the credits menu.
	TexturePtr title;

	//Widgets.
	GUITextArea* textArea;
	GUIObject* backButton;

	//GUI events are handled here.
	//name: The name of the element that invoked the event.
	//obj: Pointer to the object that invoked the event.
	//eventType: Integer containing the type of event.
	void GUIEventCallback_OnEvent(ImageManager& imageManager, SDL_Renderer& renderer, std::string name,GUIObject* obj,int eventType);

	public:
	//Constructor.
	Credits(ImageManager& imageManager, SDL_Renderer &renderer);
	//Destructor.
	~Credits();

	//Inherited from GameState.
	void handleEvents(ImageManager&, SDL_Renderer&) override;
	void logic(ImageManager&, SDL_Renderer&) override;
	void render(ImageManager&, SDL_Renderer& renderer) override;
	void resize(ImageManager &imageManager, SDL_Renderer& renderer) override;
	};

	#endif

File Metadata

Mime Type: text/x-diff
Expires: Sat, May 16, 10:20 AM (18 h, 5 m)
Storage Engine: blob
Storage Format: Raw Data
Storage Handle: 64147
Default Alt Text: (124 KB)

No OneTemporaryActions

View Options

File Metadata

Event Timeline

No OneTemporary
Actions