No OneTemporary
Actions

Authored By

Unknown

Size

36 KB

Referenced Files

None

Subscribers

None

View Options

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

	#include "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);
	}
	}
	playing=NULL;

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

	void MusicManager::setEnabled(bool enable){
	- //In case of the options menu the volume needs to be adjusted.
	- Mix_VolumeMusic(atoi(getSettings()->getValue("music").c_str()));
	-
	//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;

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

	}
	diff --git a/src/MusicManager.h b/src/MusicManager.h
	index eee723d..732d1dd 100644
	--- a/src/MusicManager.h
	+++ b/src/MusicManager.h
	@@ -1,130 +1,135 @@
	/****************************************************************************
	** Copyright (C) 2011 Luka Horvat <redreaper132 at gmail.com>
	** Copyright (C) 2011 Edward Lii <edward_iii at myway.com>
	** Copyright (C) 2011 O. Bahri Gordebak <gordebak at gmail.com>
	**
	**
	** This file may be used under the terms of the GNU General Public
	** License version 3.0 as published by the Free Software Foundation
	** and appearing in the file LICENSE.GPL included in the packaging of
	** this file.
	**
	** This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
	** WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
	**
	** You should have received a copy of the GNU General Public License
	** along with this program. If not, see <http://www.gnu.org/licenses/>.
	**
	****************************************************************************/
	#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);
	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 60628f0..7a6a265 100644
	--- a/src/TitleMenu.cpp
	+++ b/src/TitleMenu.cpp
	@@ -1,546 +1,568 @@
	/****************************************************************************
	** Copyright (C) 2011 Luka Horvat <redreaper132 at gmail.com>
	** Copyright (C) 2011 Edward Lii <edward_iii at myway.com>
	** Copyright (C) 2011 O. Bahri Gordebak <gordebak at gmail.com>
	**
	**
	** This file may be used under the terms of the GNU General Public
	** License version 3.0 as published by the Free Software Foundation
	** and appearing in the file LICENSE.GPL included in the packaging of
	** this file.
	**
	** This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
	** WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
	**
	** You should have received a copy of the GNU General Public License
	** along with this program. If not, see <http://www.gnu.org/licenses/>.
	**
	****************************************************************************/
	#include "Functions.h"
	#include "GameState.h"
	#include "Globals.h"
	#include "TitleMenu.h"
	#include "GUIListBox.h"
	#include "InputManager.h"
	#include <iostream>
	#include <algorithm>
	#include <sstream>

	#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,_("Exit"),black);
	entries[5]=TTF_RenderUTF8_Blended(fontTitle,">",black);
	entries[6]=TTF_RenderUTF8_Blended(fontTitle,"<",black);
	}

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


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

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

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

	//Check if there's a press event.
	if((event.type==SDL_MOUSEBUTTONUP && event.button.button==SDL_BUTTON_LEFT) \|\|
	(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:
	//We quit, so we enter the exit state.
	setNextState(STATE_EXIT);
	break;
	}
	}

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

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

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


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

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

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

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

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


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

	//Some varables for the options.
	static bool fullscreen,leveltheme,internet;
	static string themeName,languageName;
	static int lastLang,lastRes;

	static bool useProxy;
	static string internetProxy;

	static bool restartFlag;

	static _res currentRes;
	#define RES_COUNT 19
	static _res resolution_list[RES_COUNT] = {
	{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}
	};

	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;

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

	//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<RES_COUNT;i++){
	//Create a string from width and height and then add it to list
	ostringstream out;
	out << resolution_list[i].w << "x" << resolution_list[i].h;
	resolutions->item.push_back(out.str());

	//Check if current resolution matches, select it
	if (resolution_list[i].w==currentRes.w && resolution_list[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
	obj=new GUIObject((SCREEN_WIDTH-240)/2-150,SCREEN_HEIGHT-120,240,36,GUIObjectButton,_("Config Keys"));
	obj->name="cmdKeys";
	obj->eventCallback=this;
	GUIObjectRoot->childControls.push_back(obj);

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

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

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

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

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

	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));
	//language=langValues.at(langs->value);
	//dictionaryManager->set_language(tinygettext::Language::from_name(langValues.at(langs->value)));

	//Is resolution from the list or is it user defined in config file
	if(resolutions->value<RES_COUNT){
	getSettings()->setValue("width",convertInt(resolution_list[resolutions->value].w));
	getSettings()->setValue("height",convertInt(resolution_list[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 show a restart message, if needed.
	if(restartFlag \|\| langs->value!=lastLang \|\| resolutions->value!=lastRes)
	/// TRANSLATORS: Some settings require to restart the game
	msgBox(_("Restart needed before the changes have effect."),MsgBoxOKOnly,_("Restart needed"));

	//Now return to the main menu.
	setNextState(STATE_MENU);
	}else if(name=="cmdKeys"){
	inputMgr.showConfig();
	}else if(name=="cmdReset"){
	if(msgBox(_("Do you really want to reset level progress?"),MsgBoxYesNo,_("Warning"))==MsgBoxYes){
	//We delete the progress folder.
	#ifdef WIN32
	removeDirectory((getUserPath()+"progress").c_str());
	createDirectory((getUserPath()+"progress").c_str());
	#else
	removeDirectory((getUserPath(USER_DATA)+"/progress").c_str());
	createDirectory((getUserPath(USER_DATA)+"/progress").c_str());
	#endif
	}
	return;
	}else if(name=="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()->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);
	}
	}

	-//Nothing to do here.
	-void Options::logic(){}
	+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,screen,NULL);

	//NOTE: The rendering of the GUI is done in Main.
	}
	diff --git a/src/TitleMenu.h b/src/TitleMenu.h
	index 537bde9..04a3d22 100644
	--- a/src/TitleMenu.h
	+++ b/src/TitleMenu.h
	@@ -1,103 +1,108 @@
	/****************************************************************************
	** Copyright (C) 2011 Luka Horvat <redreaper132 at gmail.com>
	** Copyright (C) 2011 Edward Lii <edward_iii at myway.com>
	** Copyright (C) 2011 O. Bahri Gordebak <gordebak at gmail.com>
	**
	**
	** This file may be used under the terms of the GNU General Public
	** License version 3.0 as published by the Free Software Foundation
	** and appearing in the file LICENSE.GPL included in the packaging of
	** this file.
	**
	** This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
	** WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
	**
	** You should have received a copy of the GNU General Public License
	** along with this program. If not, see <http://www.gnu.org/licenses/>.
	**
	****************************************************************************/
	#ifndef TITLE_MENU_H
	#define TITLE_MENU_H

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

	//Included for the Options menu.
	#include "GUIObject.h"
	#include "GUIListBox.h"
	#include "GUISlider.h"


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

	//Array containg pointers to the five main menu entries.
	//The last two are the '>' and '<' characters.
	SDL_Surface* entries[7];

	//Integer used for animations.
	int animation;
	public:
	//Constructor.
	Menu();
	//Destructor.
	~Menu();

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

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

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

	+ //The jump sound used as reference to configure sound volume.
	+ Mix_Chunk* jumpSound;
	+ //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;

	//Map containing the locations the themes are stored.
	//The key is the name of the theme and the value the path.
	std::map<std::string,std::string> themeLocations;

	//Available languages
	GUISingleLineListBox* langs;
	std::vector<std::string> langValues;

	//Resolution list
	GUISingleLineListBox* resolutions;

	//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(std::string name,GUIObject* obj,int eventType);

	public:
	//Constructor.
	Options();
	//Destructor.
	~Options();

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

	//A very simple structure for resolutions
	struct _res{
	int w,h;
	};

	#endif

File Metadata

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

No OneTemporaryActions

View Options

File Metadata

Event Timeline

No OneTemporary
Actions