No OneTemporary
Actions

Authored By

Unknown

Size

42 KB

Referenced Files

None

Subscribers

None

View Options

	diff --git a/data/music/haunted.music b/data/music/haunted.music
	index 00c1ef0..4ae5920 100644
	--- a/data/music/haunted.music
	+++ b/data/music/haunted.music
	@@ -1,12 +1,12 @@
	# The Haunted Mansion - by Juho-Petteri Yliuntinen
	# CC-BY-SA 3.0 Unported: http://creativecommons.org/licenses/by-sa/3.0/

	music(haunted){
	file=mams-the_haunted_mansion-full_final.ogg
	trackname="The Haunted Mansion"
	- author=Juho-Petteri Yliuntinen
	+ author="Juho-Petteri Yliuntinen"
	license="CC-BY-SA 3.0 Unported"
	start=0
	volume=128
	loop=0
	}
	\ No newline at end of file
	diff --git a/data/music/menu.music b/data/music/menu.music
	index 7c6d4ed..3f8af87 100644
	--- a/data/music/menu.music
	+++ b/data/music/menu.music
	@@ -1,15 +1,15 @@
	# Main theme - by Juho-Petteri Yliuntinen
	# CC-BY-SA 3.0 Unported: http://creativecommons.org/licenses/by-sa/3.0/

	music(menu){
	file=mams-menu_initial.ogg
	trackname="Menu theme"
	- author=Juho-Petteri Yliuntinen
	+ author="Juho-Petteri Yliuntinen"
	license="CC-BY-SA 3.0 Unported"
	start=0
	volume=128
	loop=1
	loopfile=mams-menu_loop.ogg
	loopstart=0
	loopend=-1
	}
	\ No newline at end of file
	diff --git a/data/music/neverending.music b/data/music/neverending.music
	index aa8389b..291ac66 100644
	--- a/data/music/neverending.music
	+++ b/data/music/neverending.music
	@@ -1,12 +1,12 @@
	# Neverending Stair - by Juho-Petteri Yliuntinen
	# CC-BY-SA 3.0 Unported: http://creativecommons.org/licenses/by-sa/3.0/

	music(neverending){
	file=mams-neverending_stair-full_final.ogg
	trackname="Neverending Stair"
	- author=Juho-Petteri Yliuntinen
	+ author="Juho-Petteri Yliuntinen"
	license="CC-BY-SA 3.0 Unported"
	start=0
	volume=128
	loop=0
	}
	\ No newline at end of file
	diff --git a/data/music/theatre.music b/data/music/theatre.music
	index 831841b..3f48c25 100644
	--- a/data/music/theatre.music
	+++ b/data/music/theatre.music
	@@ -1,12 +1,12 @@
	# Master's Theatre - by Juho-Petteri Yliuntinen
	# CC-BY-SA 3.0 Unported: http://creativecommons.org/licenses/by-sa/3.0/

	music(theatre){
	file=mams-masters_theatre-full_final.ogg
	trackname="Master's Theatre"
	- author=Juho-Petteri Yliuntinen
	+ author="Juho-Petteri Yliuntinen"
	license="CC-BY-SA 3.0 Unported"
	start=0
	volume=128
	loop=0
	}
	\ No newline at end of file
	diff --git a/src/MusicManager.cpp b/src/MusicManager.cpp
	index 7d129f2..c032142 100644
	--- a/src/MusicManager.cpp
	+++ b/src/MusicManager.cpp
	@@ -1,346 +1,362 @@
	/*
	* Copyright (C) 2012 Me and My Shadow
	*
	* This file is part of Me and My Shadow.
	*
	* Me and My Shadow is free software: you can redistribute it and/or modify
	* it under the terms of the GNU General Public License as published by
	* the Free Software Foundation, either version 3 of the License, or
	* (at your option) any later version.
	*
	* Me and My Shadow is distributed in the hope that it will be useful,
	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	* GNU General Public License for more details.
	*
	* You should have received a copy of the GNU General Public License
	* along with Me and My Shadow. If not, see <http://www.gnu.org/licenses/>.
	*/

	#include "MusicManager.h"
	#include "TreeStorageNode.h"
	#include "POASerializer.h"
	#include "FileManager.h"
	#include "Functions.h"
	#include <stdio.h>
	#include <fstream>
	#include <iostream>
	#include <algorithm>
	using namespace std;

	MusicManager::MusicManager(){
	Mix_HookMusicFinished(musicStoppedHook);
	Mix_VolumeMusic(MIX_MAX_VOLUME);
	enabled=false;
	currentList="default";
	lastTime=0;
	playing=NULL;
	}

	MusicManager::~MusicManager(){
	//We call destroy().
	destroy();
	}

	void MusicManager::destroy(){
	//Loop through the imageCollection and free them.
	std::map<std::string,Music*>::iterator i;
	for(i=musicCollection.begin();i!=musicCollection.end();++i){
	if(i->second!=NULL){
	Mix_FreeMusic(i->second->music);
	if(i->second->loop)
	Mix_FreeMusic(i->second->loop);
	delete i->second;
	}
	}
	playing=NULL;

	//And clear the collection and the lists.
	musicCollection.clear();
	musicLists.clear();
	}

	void MusicManager::setEnabled(bool enable){
	//Set the new status.
	if(enabled!=enable)
	enabled=enable;
	else
	return;

	if(enable){
	//It got turned on, so start the menu music.
	playMusic("menu",false);
	}else{
	//Stop the current music.
	Mix_HaltMusic();
	Mix_VolumeMusic(atoi(getSettings()->getValue("music").c_str()));
	}
	}

	void MusicManager::setVolume(int volume){
	Mix_VolumeMusic(volume);
	}

	string MusicManager::loadMusic(const std::string &file){
	//Open the .music file.
	ifstream musicFile;
	musicFile.open(file.c_str());
	string returnString="";

	//Check if the file exists.
	if(musicFile){
	//Now parse the file.
	TreeStorageNode obj;
	{
	POASerializer objSerializer;
	if(!objSerializer.readNode(musicFile,&obj,true)){
	cerr<<"ERROR: Invalid file format of music description file."<<endl;
	}
	}

	//Loop through the entries.
	for(unsigned int i=0;i<obj.subNodes.size();i++){
	TreeStorageNode* obj1=obj.subNodes[i];
	if(obj1==NULL)
	continue;
	if(obj1->value.size()>=1 && obj1->name=="music"){
	//Make sure that this music isn't already loaded.
	map<string,Music*>::iterator it=musicCollection.find(obj1->value[0]);
	if(it==musicCollection.end()){
	//We've found an entry for a music file.
	Music* music=new Music;
	music->music=NULL;
	music->loop=NULL;

	//Load some data.
	for(map<string,vector<string> >::iterator i=obj1->attributes.begin();i!=obj1->attributes.end();++i){
	if(i->first=="file"){
	//Load the music file.
	music->music=Mix_LoadMUS((getDataPath()+"music/"+i->second[0]).c_str());
	}
	if(i->first=="loopfile"){
	//Load the loop file.
	music->loop=Mix_LoadMUS((getDataPath()+"music/"+i->second[0]).c_str());
	}
	if(i->first=="trackname"){
	music->trackName=i->second[0];
	}
	if(i->first=="author"){
	music->author=i->second[0];
	}
	if(i->first=="license"){
	music->license=i->second[0];
	}
	if(i->first=="start"){
	music->start=(atoi(i->second[0].c_str()));
	}
	if(i->first=="volume"){
	music->volume=(atoi(i->second[0].c_str()));
	}
	if(i->first=="loopstart"){
	music->loopStart=(atoi(i->second[0].c_str()));
	}
	if(i->first=="loopend"){
	music->loopEnd=(atoi(i->second[0].c_str()));
	}
	}

	//Set the default value for lastTime.
	music->lastTime=-1;
	music->name=obj1->value[0];

	//Now add it to the collection.
	musicCollection[obj1->value[0]]=music;
	}

	//Add the name of the music to the return string even if it's already loaded.
	//This is to allow music to be in multiple music lists.
	if(!returnString.empty())
	returnString+=',';
	returnString+=obj1->value[0];
	}
	}
	}

	//Return the return string.
	return returnString;
	}

	bool MusicManager::loadMusicList(const std::string &file){
	//Open the .list file.
	ifstream musicFile;
	musicFile.open(file.c_str());

	//Check if the file exists.
	if(musicFile){
	//Now parse the file.
	TreeStorageNode obj;
	{
	POASerializer objSerializer;
	if(!objSerializer.readNode(musicFile,&obj,true)){
	cerr<<"ERROR: Invalid file format of music list file."<<endl;
	return false;
	}
	}

	//Get the name of the list.
	std::string name;
	{
	map<string,vector<string> >::iterator it=obj.attributes.find("name");
	if(it!=obj.attributes.end()){
	name=obj.attributes["name"][0];
	}else{
	cerr<<"ERROR: No name for music list "<<file<<endl;
	return false;
	}
	}

	//Check if the list isn't already loaded.
	std::map<std::string,std::vector<std::string> >::iterator it=musicLists.find(name);
	if(it!=musicLists.end())
	return true;

	//Loop through the entries.
	for(unsigned int i=0;i<obj.subNodes.size();i++){
	TreeStorageNode* obj1=obj.subNodes[i];
	if(obj1==NULL)
	continue;
	if(obj1->value.size()>=1 && obj1->name=="musicfile"){
	//Load the music file.
	string result=loadMusic(getDataPath()+"music/"+obj1->value[0]);
	if(!result.empty()){
	if(result.find(',')!=string::npos){
	size_t pos=result.find(',');
	while(pos!=string::npos){
	musicLists[name].push_back(result.substr(pos,result.find(',',pos+1)));
	}
	}else{
	musicLists[name].push_back(result);
	}
	}
	}
	}
	}else{
	cerr<<"ERROR: Unable to open music list file "<<file<<endl;
	return false;
	}

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

	void MusicManager::playMusic(const std::string &name,bool fade){
	//Make sure music is enabled.
	if(!enabled)
	return;

	//Check if the music is in the collection.
	Music* music=musicCollection[name];
	if(music==NULL){
	cerr<<"ERROR: Unable to play music "<<name<<endl;
	return;
	}

	//Now check if we should fade the previous one out.
	if(fade){
	Mix_FadeOutMusic(375);
	//Set the next music.
	nextMusic=name;
	}else{
	if(music->loopStart<=0 && music->loop==NULL){
	Mix_FadeInMusicPos(music->music,-1,0,music->start);
	}else{
	Mix_FadeInMusicPos(music->music,0,0,music->start);
	}
	Mix_VolumeMusic(music->volume*float(atoi(getSettings()->getValue("music").c_str())/float(MIX_MAX_VOLUME)));

	//Set the playing pointer.
	playing=music;
	}
	}

	void MusicManager::pickMusic(){
	//Make sure the currentList exists.
	vector<std::string> list=musicLists[currentList];
	if(currentList.empty()){
	cerr<<"ERROR: Unkown music list "<<currentList<<endl;
	return;
	}

	//Shuffle the list.
	random_shuffle(list.begin(),list.end());

	//Now loop through the music and search the oldest.
	Music* oldest=NULL;
	for(unsigned int i=0;i<list.size();i++){
	//Check if oldest is set.
	if(oldest==NULL){
	//It isn't so pick the first music.
	oldest=musicCollection[list[i]];
	continue;
	}

	//Check if this song is null.
	if(musicCollection[list[i]]==NULL)
	continue;

	//Check if this music is never played.
	if(musicCollection[list[i]]->lastTime==-1){
	oldest=musicCollection[list[i]];
	//And break out.
	break;
	}

	//Check if this music is older.
	if(musicCollection[list[i]]->lastTime<oldest->lastTime){
	oldest=musicCollection[list[i]];
	}
	}

	//Check if oldest ins't null.
	if(oldest!=NULL){
	playMusic(oldest->name);
	//Set the lastTime and increase it.
	oldest->lastTime=lastTime;
	lastTime++;
	}
	}

	void MusicManager::musicStopped(){
	//Check if there's a music to play.
	if(!nextMusic.empty()){
	//Check if the music is in the collection.
	Music* music=musicCollection[nextMusic];
	if(music==NULL){
	cerr<<"ERROR: Unable to play music "<<nextMusic<<endl;
	return;
	}

	if(music->loopStart<=0){
	Mix_FadeInMusicPos(music->music,-1,375,music->start);
	}else{
	Mix_FadeInMusicPos(music->music,0,375,music->start);
	}

	Mix_VolumeMusic(music->volume*float(atoi(getSettings()->getValue("music").c_str())/float(MIX_MAX_VOLUME)));

	//Set playing.
	playing=music;

	//Now reset nextMusic.
	nextMusic.clear();
	}else{
	//Check what kind of loop.
	if(playing->loop!=NULL){
	Mix_FadeInMusicPos(playing->loop,-1,0,playing->loopStart);
	}else{
	//This is for looping the end of music.
	Mix_FadeInMusicPos(playing->music,0,0,playing->loopStart);
	}
	}
	}

	void MusicManager::setMusicList(const string &list){
	//Check if the list exists.

	}
	+
	+vector<string> MusicManager::createCredits(){
	+ //Vector that will be returned.
	+ vector<string> result;
	+
	+ //Loop through the music tracks.
	+ std::map<std::string,Music*>::iterator it;
	+ for(it=musicCollection.begin();it!=musicCollection.end();it++){
	+ result.push_back(" - "+it->second->trackName);
	+ result.push_back(" License: "+it->second->license);
	+ result.push_back(" Attribution: "+it->second->author);
	+ }
	+
	+ //And return the result.
	+ return result;
	+}
	diff --git a/src/MusicManager.h b/src/MusicManager.h
	index f55fff1..a488a0f 100644
	--- a/src/MusicManager.h
	+++ b/src/MusicManager.h
	@@ -1,136 +1,141 @@
	/*
	* Copyright (C) 2012 Me and My Shadow
	*
	* This file is part of Me and My Shadow.
	*
	* Me and My Shadow is free software: you can redistribute it and/or modify
	* it under the terms of the GNU General Public License as published by
	* the Free Software Foundation, either version 3 of the License, or
	* (at your option) any later version.
	*
	* Me and My Shadow is distributed in the hope that it will be useful,
	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	* GNU General Public License for more details.
	*
	* You should have received a copy of the GNU General Public License
	* along with Me and My Shadow. If not, see <http://www.gnu.org/licenses/>.
	*/

	#ifndef MUSICMANAGER_H
	#define MUSICMANAGER_H

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

	//Class for loading and playing the music.
	class MusicManager{
	private:
	//This structure is used to hold music information.
	struct Music{
	//Pointer to the actual music.
	Mix_Music* music;
	//Pointer to the loop music, if any.
	Mix_Music* loop;

	//String containing the name of the music.
	//This is the same name as in the musicCollection.
	std::string name;

	//String containing the track name of the music.
	//This is the name given by the author.
	std::string trackName;
	//String containing the name of the author.
	std::string author;
	//String containing the license the music is released under.
	std::string license;

	//Integer containing the time where to start playing.
	int start;

	//The volume to play the music with.
	//Scale 0-128.
	int volume;

	//Integer containing the loopstart.
	int loopStart;
	//Integer containing the loopend.
	//NOTE: loopend doesn't work and is thus ignored.
	int loopEnd;

	//Integer used to keep track when which music was played.
	int lastTime;
	};
	public:
	//Constructor.
	MusicManager();
	//Destructor.
	~MusicManager();

	//Destroys the music.
	void destroy();

	//Method that will either disable or enable music.
	//enable: Boolean if the musicManager should be enabled or not.
	void setEnabled(bool enable=true);

	//Method that will set the volume of the music.
	//NOTE: The set volume isn't presistent, only use this to update the volume after a change to the music setting.
	//volume: The new volume.
	void setVolume(int volume);

	//This method will load one music file and add it to the collection.
	//file: The filename of the music file.
	//Returns: String containing the loaded music comma sperated, it's empty if it fails.
	std::string loadMusic(const std::string &file);

	//This method will load from a music list.
	//file: The filename of the music list file.
	//Returns: True if no error occurs.
	bool loadMusicList(const std::string &file);

	//This method will start playing a music file.
	//name: The name of the song.
	//fade: Boolean if it should fade the current one out or not.
	void playMusic(const std::string &name,bool fade=true);

	//This method will pick music from the current music list.
	void pickMusic();

	//Method that will be called when a music stopped.
	void musicStopped();

	//Set the music list.
	//list: The name of the list.
	void setMusicList(const std::string &list);
	+
	+ //Method that will create credits text for the (loaded) music tracks.
	+ //NOTE: This is only used by the Credits screen.
	+ //Returns: A vector containing the lines of credits.
	+ std::vector<std::string> createCredits();
	private:
	//Boolean if the MusicManager is enabled or not.
	//The default value is false meaning that the MusicManager has to be enabled before the music starts.
	bool enabled;

	//Integer that is used to keep track of the last played song.
	int lastTime;

	//Pointer to the music struct that is currently playing.
	Music* playing;

	//String containing the name of the music to play when the previous one stopped.
	//This means that it will be checked in the musicStopped method.
	std::string nextMusic;

	//String containing the name of the current music list.
	std::string currentList;

	//Map containing the music.
	//The key is the name of the music and the value is a pointer to the Mix_Music.
	std::map<std::string,Music*> musicCollection;

	//Map containing the music lists.
	//The key is the name of the list and the value is an array of music names.
	std::map<std::string,std::vector<std::string> > musicLists;
	};

	#endif
	diff --git a/src/TitleMenu.cpp b/src/TitleMenu.cpp
	index 13291e3..af9f2e6 100644
	--- a/src/TitleMenu.cpp
	+++ b/src/TitleMenu.cpp
	@@ -1,824 +1,828 @@
	/*
	* 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 "Functions.h"
	#include "GameState.h"
	#include "Globals.h"
	#include "TitleMenu.h"
	#include "GUIListBox.h"
	#include "InputManager.h"
	#include <iostream>
	#include <algorithm>
	#include <sstream>
	#include <SDL/SDL_gfxBlitFunc.h>

	#include "libs/tinygettext/tinygettext.hpp"

	using namespace std;

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

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

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

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

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

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


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

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

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

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

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

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

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

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


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

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

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

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

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

	void Menu::resize(){}


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

	//Some varables for the options.
	static bool fullscreen,leveltheme,internet;
	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(){
	//Render the title.
	SDL_Color black={0,0,0};
	title=TTF_RenderUTF8_Blended(fontTitle,_("Settings"),black);

	//Load the jump sound, used for sound volume configuration.
	jumpSound=Mix_LoadWAV((getDataPath()+"sfx/jump.wav").c_str());
	lastJumpSound=0;

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

	//Set the restartFlag false.
	restartFlag=false;

	//Now create the gui.
	createGUI();
	}

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

	//Free the title image.
	SDL_FreeSurface(title);
	//And free the jump sound.
	Mix_FreeChunk(jumpSound);
	}

	void Options::createGUI(){
	//Variables for positioning
	int x = (SCREEN_WIDTH-540)/2;
	int liftY=40; //TODO: This is variable for laziness of maths...

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

	//Now we create GUIObjects for every option.
	GUIObject* obj=new GUIObject(x,150-liftY,240,36,GUIObjectLabel,_("Music"));
	GUIObjectRoot->childControls.push_back(obj);

	musicSlider=new GUISlider(x+220,150-liftY,256,36,atoi(getSettings()->getValue("music").c_str()),0,128,15);
	musicSlider->name="sldMusic";
	musicSlider->eventCallback=this;
	GUIObjectRoot->childControls.push_back(musicSlider);

	obj=new GUIObject(x,190-liftY,240,36,GUIObjectLabel,_("Sound"));
	GUIObjectRoot->childControls.push_back(obj);

	soundSlider=new GUISlider(x+220,190-liftY,256,36,atoi(getSettings()->getValue("sound").c_str()),0,128,15);
	soundSlider->name="sldSound";
	soundSlider->eventCallback=this;
	GUIObjectRoot->childControls.push_back(soundSlider);

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

	obj=new GUIObject(x,270-liftY,240,36,GUIObjectLabel,_("Resolution"));
	obj->name="lstResolution";
	GUIObjectRoot->childControls.push_back(obj);

	//Create list with many different resolutions
	resolutions = new GUISingleLineListBox(x+220,270-liftY,300,36);
	resolutions->value=-1;

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

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

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

	for(unsigned int i=0;i<sizeof(predefinedResolutionList)/sizeof(_res);i++){
	resolutionList.push_back(predefinedResolutionList[i]);
	}
	}else{
	for(unsigned int i=0;modes[i]!=NULL;i++){
	//Check if the resolution is big enough
	if(modes[i]->w>=800 && modes[i]->h>=600){
	_res res={modes[i]->w, modes[i]->h};
	resolutionList.push_back(res);
	}
	}
	reverse(resolutionList.begin(),resolutionList.end());
	}
	}

	//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->item.push_back(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->item.push_back(out.str());
	resolutions->value=resolutions->item.size()-1;
	}
	lastRes=resolutions->value;

	GUIObjectRoot->childControls.push_back(resolutions);

	obj=new GUIObject(x,310-liftY,240,36,GUIObjectLabel,_("Language"));
	obj->name="lstResolution";
	GUIObjectRoot->childControls.push_back(obj);

	//Create GUI list with available languages
	langs = new GUISingleLineListBox(x+220,310-liftY,300,36);
	langs->name="lstLanguages";

	/// TRANSLATORS: as detect user's language automatically
	langs->item.push_back(_("Auto-Detect"));
	langValues.push_back("");

	langs->item.push_back("English");
	langValues.push_back("en");

	//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->item.push_back(s0->get_name());
	langValues.push_back(s0->str());
	}

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

	langs->value=lastLang;
	GUIObjectRoot->childControls.push_back(langs);

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

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

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

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

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

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

	//new: key settings
	GUIObject* b1=new GUIObject(SCREEN_WIDTH*0.3,SCREEN_HEIGHT-120,-1,36,GUIObjectButton,_("Config Keys"),0,true,true,GUIGravityCenter);
	b1->name="cmdKeys";
	b1->eventCallback=this;
	GUIObjectRoot->childControls.push_back(b1);

	//Reset progress settings.
	/// TRANSLATORS: Used for button which clear any level progress like unlocked levels and highscores.
	GUIObject* b2=new GUIObject(SCREEN_WIDTH*0.7,SCREEN_HEIGHT-120,-1,36,GUIObjectButton,_("Clear Progress"),0,true,true,GUIGravityCenter);
	b2->name="cmdReset";
	b2->eventCallback=this;
	GUIObjectRoot->childControls.push_back(b2);

	b1->render(0,0,false);
	b2->render(0,0,false);
	if(b2->left-b2->gravityX < b1->left+b1->width-b1->gravityX){
	b1->smallFont=true;
	b1->width=-1;
	b2->smallFont=true;
	b2->width=-1;
	}

	b1=new GUIObject(SCREEN_WIDTH*0.3,SCREEN_HEIGHT-60,-1,36,GUIObjectButton,_("Cancel"),0,true,true,GUIGravityCenter);
	b1->name="cmdBack";
	b1->eventCallback=this;
	GUIObjectRoot->childControls.push_back(b1);

	b2=new GUIObject(SCREEN_WIDTH*0.7,SCREEN_HEIGHT-60,-1,36,GUIObjectButton,_("Save Changes"),0,true,true,GUIGravityCenter);
	b2->name="cmdSave";
	b2->eventCallback=this;
	GUIObjectRoot->childControls.push_back(b2);

	b1->render(0,0,false);
	b2->render(0,0,false);
	if(b2->left-b2->gravityX < b1->left+b1->width-b1->gravityX){
	b1->smallFont=true;
	b1->width=-1;
	b2->smallFont=true;
	b2->width=-1;
	}
	}

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

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

	//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("leveltheme",leveltheme?"1":"0");
	getSettings()->setValue("internet",internet?"1":"0");
	getSettings()->setValue("theme",themeName);
	if(!useProxy)
	internetProxy.clear();
	getSettings()->setValue("internet-proxy",internetProxy);

	getSettings()->setValue("lang",langValues.at(langs->value));

	//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()){
	//Loading the theme failed so quit.
	setNextState(STATE_EXIT);
	return;
	}
	}
	if(langs->value!=lastLang){
	//We set the language.
	language=langValues.at(langs->value);
	dictionaryManager->set_language(tinygettext::Language::from_name(langValues.at(langs->value)));
	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=="cmdKeys"){
	inputMgr.showConfig();
	}else if(name=="cmdReset"){
	if(msgBox(_("Do you really want to reset level progress?"),MsgBoxYesNo,_("Warning"))==MsgBoxYes){
	//We delete the progress folder.
	#ifdef WIN32
	removeDirectory((getUserPath()+"progress").c_str());
	createDirectory((getUserPath()+"progress").c_str());
	#else
	removeDirectory((getUserPath(USER_DATA)+"/progress").c_str());
	createDirectory((getUserPath(USER_DATA)+"/progress").c_str());
	#endif
	}
	return;
	}else if(name=="chkFullscreen"){
	fullscreen=obj->value?true:false;

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

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

	//Check if the internetProxy field is empty.
	useProxy=!internetProxy.empty();
	}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){
	Mix_PlayChannel(-1,jumpSound,0);
	lastJumpSound=15;
	}
	}
	}

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

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

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

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

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

	void Options::resize(){
	//Recreate the gui to fit the new resolution.
	createGUI();
	}

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

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

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

	//Now determine the number of lines and calculate the height of the resulting credits surface.
	int lines=credits.size();
	int fontHeight=TTF_FontLineSkip(fontText);

	creditsText=SDL_CreateRGBSurface(SDL_SWSURFACE,SCREEN_WIDTH,lines*fontHeight,32,0xFF000000,0x00FF0000,0x0000FF00,0x000000FF);

	for(int i=0;i<lines;i++){
	if(credits[i][0]!='\0'){
	SDL_Surface* lineSurf=TTF_RenderUTF8_Blended(fontText,credits[i].c_str(),black);

	SDL_SetAlpha(lineSurf,0,0xFF);
	SDL_SetAlpha(creditsText,SDL_SRCALPHA,SDL_ALPHA_TRANSPARENT);

	applySurface(0,fontHeight*i,lineSurf,creditsText,NULL);

	SDL_FreeSurface(lineSurf);
	}
	}

	//Create GUI
	createGUI();
	}

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

	//Free images
	SDL_FreeSurface(title);
	SDL_FreeSurface(creditsText);
	}

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

	GUIObject* obj=new GUIObject(SCREEN_WIDTH*0.5,SCREEN_HEIGHT-60,-1,36,GUIObjectButton,_("Back"),0,true,true,GUIGravityCenter);
	obj->name="cmdBack";
	obj->eventCallback=this;
	GUIObjectRoot->childControls.push_back(obj);

	scrollbar=new GUIScrollBar(SCREEN_WIDTH-64-16,128,16,SCREEN_HEIGHT-128-92,1,0,0,creditsText->h/2-(SCREEN_HEIGHT-128-92)/2);
	GUIObjectRoot->childControls.push_back(scrollbar);
	}

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

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

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

	//Check for scrolling down and up.
	if(event.type==SDL_MOUSEBUTTONDOWN && event.button.button==SDL_BUTTON_WHEELDOWN && scrollbar){
	if(scrollbar->value<scrollbar->maxValue)
	scrollbar->value+=scrollbar->smallChange;
	if(scrollbar->value>scrollbar->maxValue)
	scrollbar->value=scrollbar->maxValue;
	return;
	}else if(event.type==SDL_MOUSEBUTTONDOWN && event.button.button==SDL_BUTTON_WHEELUP && scrollbar){
	if(scrollbar->value>0)
	scrollbar->value-=scrollbar->smallChange;
	if(scrollbar->value<0)
	scrollbar->value=0;
	return;
	}
	}

	void Credits::logic(){

	}

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

	SDL_Rect r;
	r.x = 0;
	r.y = scrollbar->value*2;
	r.w = SCREEN_WIDTH-64-16;
	r.h = SCREEN_HEIGHT-128-92;
	applySurface(64,128,creditsText,screen,&r);
	//SDL_BlitSurface(creditsText,NULL,screen,&r);

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

	void Credits::resize(){
	//Recreate the gui to fit the new resolution.
	createGUI();
	}

File Metadata

Mime Type: text/x-diff
Expires: Wed, Jun 17, 9:11 PM (1 w, 5 d ago)
Storage Engine: blob
Storage Format: Raw Data
Storage Handle: 70680
Default Alt Text: (42 KB)

No OneTemporaryActions

View Options

File Metadata

Event Timeline

No OneTemporary
Actions