No OneTemporary
Actions

Authored By

Unknown

Size

37 KB

Referenced Files

None

Subscribers

None

View Options

	diff --git a/CMakeLists.txt b/CMakeLists.txt
	index d22a9bf..a015037 100644
	--- a/CMakeLists.txt
	+++ b/CMakeLists.txt
	@@ -1,93 +1,96 @@
	PROJECT(meandmyshadow)
	CMAKE_MINIMUM_REQUIRED(VERSION 2.6)
	set(CMAKE_MODULE_PATH ${CMAKE_MODULE_PATH} "${CMAKE_SOURCE_DIR}/cmake/Modules/")

	Find_Package(SDL REQUIRED)
	Find_Package(SDL_ttf REQUIRED)
	Find_Package(SDL_image REQUIRED)
	Find_Package(SDL_mixer REQUIRED)
	Find_Package(SDL_gfx REQUIRED)
	Find_Package(CURL REQUIRED)
	Find_Package(LibArchive REQUIRED)
	Find_Package(OpenSSL REQUIRED)

	INCLUDE_DIRECTORIES(${SDL_INCLUDE_DIR})
	INCLUDE_DIRECTORIES(${SDLIMAGE_INCLUDE_DIR})
	INCLUDE_DIRECTORIES(${SDLMIXER_INCLUDE_DIR})
	INCLUDE_DIRECTORIES(${SDLTTF_INCLUDE_DIR})
	INCLUDE_DIRECTORIES(${SDLGFX_INCLUDE_DIR})
	INCLUDE_DIRECTORIES(${CURL_INCLUDE_DIR})
	INCLUDE_DIRECTORIES(${LibArchive_INCLUDE_DIR})
	INCLUDE_DIRECTORIES(${OPENSSL_INCLUDE_DIR})

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

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

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

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

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

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

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

	configure_file (
	"${PROJECT_SOURCE_DIR}/src/config.h.in"
	"${PROJECT_BINARY_DIR}/config.h"
	)

	set(EXECUTABLE_OUTPUT_PATH ${PROJECT_BINARY_DIR})
	set(SRC_DIR ${PROJECT_SOURCE_DIR}/src)

	include_directories(
	${PROJECT_BINARY_DIR}
	${SDL_INCLUDE_DIR}
	${SDLTTF_INCLUDE_DIR}
	${SDLMIXER_INCLUDE_DIR}
	${SDLIMAGE_INCLUDE_DIR}
	${SDLGFX_INCLUDE_DIR}
	${OPENSSL_INCLUDE_DIR}
	)

	SET(CMAKE_CXX_FLAGS "-Wall -g")

	# Déclaration de l'exécutable
	file(GLOB Sources ${SRC_DIR}/*.cpp)
	add_executable(meandmyshadow ${Sources})

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

	install(DIRECTORY ${PROJECT_SOURCE_DIR}/data DESTINATION share/meandmyshadow/)
	install(TARGETS meandmyshadow RUNTIME DESTINATION bin)
	if("${CMAKE_SYSTEM_NAME}" MATCHES "Linux")
	install(FILES meandmyshadow.desktop DESTINATION share/applications/)
	- install(FILES meandmyshadow.xpm DESTINATION share/pixmaps/)
	+ install(FILES icons/16x16/meandmyshadow.png DESTINATION share/icons/hicolor/16x16/apps/)
	+ install(FILES icons/32x32/meandmyshadow.png DESTINATION share/icons/hicolor/32x32/apps/)
	+ install(FILES icons/48x48/meandmyshadow.png DESTINATION share/icons/hicolor/48x48/apps/)
	+ install(FILES icons/64x64/meandmyshadow.png DESTINATION share/icons/hicolor/64x64/apps/)
	endif("${CMAKE_SYSTEM_NAME}" MATCHES "Linux")
	diff --git a/data/music/default.list b/data/music/default.list
	new file mode 100644
	index 0000000..1a111df
	--- /dev/null
	+++ b/data/music/default.list
	@@ -0,0 +1,2 @@
	+name=default
	+musicfile(menu.music)
	\ No newline at end of file
	diff --git a/icons/16x16/meandmyshadow.png b/icons/16x16/meandmyshadow.png
	new file mode 100644
	index 0000000..d847ac9
	Binary files /dev/null and b/icons/16x16/meandmyshadow.png differ
	diff --git a/icons/32x32/meandmyshadow.png b/icons/32x32/meandmyshadow.png
	new file mode 100644
	index 0000000..c83879d
	Binary files /dev/null and b/icons/32x32/meandmyshadow.png differ
	diff --git a/icons/48x48/meandmyshadow.png b/icons/48x48/meandmyshadow.png
	new file mode 100644
	index 0000000..b1b39a5
	Binary files /dev/null and b/icons/48x48/meandmyshadow.png differ
	diff --git a/icons/64x64/meandmyshadow.png b/icons/64x64/meandmyshadow.png
	new file mode 100644
	index 0000000..21620fd
	Binary files /dev/null and b/icons/64x64/meandmyshadow.png differ
	diff --git a/windows-icon/meandmyshadow.ico b/icons/windows-icon/meandmyshadow.ico
	similarity index 100%
	rename from windows-icon/meandmyshadow.ico
	rename to icons/windows-icon/meandmyshadow.ico
	diff --git a/windows-icon/meandmyshadow.xcf b/icons/windows-icon/meandmyshadow.xcf
	similarity index 100%
	rename from windows-icon/meandmyshadow.xcf
	rename to icons/windows-icon/meandmyshadow.xcf
	diff --git a/windows-icon/res.rc b/icons/windows-icon/res.rc
	similarity index 100%
	rename from windows-icon/res.rc
	rename to icons/windows-icon/res.rc
	diff --git a/windows-icon/resource.h b/icons/windows-icon/resource.h
	similarity index 100%
	rename from windows-icon/resource.h
	rename to icons/windows-icon/resource.h
	diff --git a/meandmyshadow.desktop b/meandmyshadow.desktop
	index 924d920..e2b47d3 100755
	--- a/meandmyshadow.desktop
	+++ b/meandmyshadow.desktop
	@@ -1,10 +1,10 @@
	[Desktop Entry]
	-Version=0.2
	+Version=0.3
	Type=Application
	Name=MeAndMyShadow
	GenericName=Me And My Shadow
	Comment=MeAndMyShadow is a puzzle/platformer game
	TryExec=meandmyshadow
	Exec=meandmyshadow
	Icon=meandmyshadow
	Categories=Game;LogicGame;Game;
	diff --git a/src/Addons.cpp b/src/Addons.cpp
	index 1202bd5..c7cff94 100644
	--- a/src/Addons.cpp
	+++ b/src/Addons.cpp
	@@ -1,586 +1,586 @@
	/****************************************************************************
	** 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 "Addons.h"
	#include "GameState.h"
	#include "Functions.h"
	#include "FileManager.h"
	#include "Globals.h"
	#include "Objects.h"
	#include "GUIObject.h"
	#include "GUIScrollBar.h"
	#include "GUIListBox.h"
	#include "POASerializer.h"
	#include "InputManager.h"
	#include <string>
	#include <sstream>
	#include <iostream>
	#include <SDL/SDL_ttf.h>
	#include <SDL/SDL.h>
	using namespace std;

	Addons::Addons(){
	//Load the backgroundimage and the addons file.
	background=loadImage(getDataPath()+"gfx/menu/background.png");
	//Render the title.
	SDL_Color black={0,0,0};
	title=TTF_RenderText_Blended(fontTitle,"Addons",black);

	FILE* addon=fopen((getUserPath(USER_CACHE)+"addons").c_str(),"wb");
	action=NONE;

	addons=NULL;

	//Create the gui.
	GUIObject* obj;
	if(GUIObjectRoot){
	delete GUIObjectRoot;
	GUIObjectRoot=NULL;
	}

	//Try to get(download) the addonsList.
	if(getAddonsList(addon)==false) {
	//It failed so we show the error message.
	GUIObjectRoot=new GUIObject(0,0,800,600);

	obj=new GUIObject(90,96,200,32,GUIObjectLabel,"Unable to initialze addon menu:");
	obj->name="lbl";
	GUIObjectRoot->childControls.push_back(obj);

	obj=new GUIObject(120,130,200,32,GUIObjectLabel,error.c_str());
	obj->name="lbl";
	GUIObjectRoot->childControls.push_back(obj);

	obj=new GUIObject(90,550,200,32,GUIObjectButton,"Back");
	obj->name="cmdBack";
	obj->eventCallback=this;
	GUIObjectRoot->childControls.push_back(obj);
	return;
	}

	//Downloaded the addons file now we can create the GUI.
	GUIObjectRoot=new GUIObject(0,0,800,600);
	obj=new GUIObject(90,96,200,32,GUIObjectButton,"Levels");
	obj->name="cmdLvls";
	obj->eventCallback=this;
	GUIObjectRoot->childControls.push_back(obj);
	obj=new GUIObject(300,96,200,32,GUIObjectButton,"Level Packs");
	obj->name="cmdLvlpacks";
	obj->eventCallback=this;
	GUIObjectRoot->childControls.push_back(obj);
	obj=new GUIObject(510,96,200,32,GUIObjectButton,"Themes");
	obj->name="cmdThemes";
	obj->eventCallback=this;
	GUIObjectRoot->childControls.push_back(obj);

	//Create the list for the addons.
	//By default levels will be selected.
	list=new GUIListBox(90,140,620,400);
	list->item=addonsToList("levels");
	list->name="lstAddons";
	list->eventCallback=this;
	GUIObjectRoot->childControls.push_back(list);
	type="levels";

	//And the buttons at the bottom of the screen.
	obj=new GUIObject(90,550,200,32,GUIObjectButton,"Back");
	obj->name="cmdBack";
	obj->eventCallback=this;
	GUIObjectRoot->childControls.push_back(obj);
	actionButton=new GUIObject(510,550,200,32,GUIObjectButton,"Install");
	actionButton->name="cmdInstall";
	actionButton->eventCallback=this;
	GUIObjectRoot->childControls.push_back(actionButton);
	updateButton=new GUIObject(300,550,200,32,GUIObjectButton,"Update");
	updateButton->name="cmdUpdate";
	updateButton->enabled=false;
	updateButton->visible=false;
	updateButton->eventCallback=this;
	GUIObjectRoot->childControls.push_back(updateButton);

	}

	Addons::~Addons(){
	delete addons;

	//Free the title surface.
	SDL_FreeSurface(title);

	//If the GUIObjectRoot exist delete it.
	if(GUIObjectRoot){
	delete GUIObjectRoot;
	GUIObjectRoot=NULL;
	}
	}

	bool Addons::getAddonsList(FILE* file){
	//First we download the file.
	- if(downloadFile("http://meandmyshadow.sourceforge.net/game/addons02",file)==false){
	+ if(downloadFile("http://meandmyshadow.sourceforge.net/game/addons03",file)==false){
	error="ERROR: unable to download addons file!";
	cerr<<error<<endl;
	return false;
	}
	fclose(file);

	//Load the downloaded file.
	ifstream addonFile;
	addonFile.open((getUserPath(USER_CACHE)+"addons").c_str());

	if(addonFile==false) {
	error="ERROR: unable to load addon_list file!";
	cerr<<error<<endl;
	return false;
	}

	//Parse the addonsfile.
	TreeStorageNode obj;
	{
	POASerializer objSerializer;
	if(!objSerializer.readNode(addonFile,&obj,true)){
	error="ERROR: Invalid file format of addons file!";
	cerr<<error<<endl;
	return false;
	}
	}

	//Also load the installed_addons file.
	ifstream iaddonFile;
	iaddonFile.open((getUserPath(USER_CONFIG)+"installed_addons").c_str());

	if(!iaddonFile) {
	//The installed_addons file doesn't exist, so we create it.
	ofstream iaddons;
	iaddons.open((getUserPath(USER_CONFIG)+"installed_addons").c_str());
	iaddons<<" "<<endl;
	iaddons.close();

	//Also load the installed_addons file.
	iaddonFile.open((getUserPath(USER_CONFIG)+"installed_addons").c_str());
	if(!iaddonFile) {
	error="ERROR: Unable to create the installed_addons file.";
	cerr<<error<<endl;
	return false;
	}
	}

	//And parse the installed_addons file.
	TreeStorageNode obj1;
	{
	POASerializer objSerializer;
	if(!objSerializer.readNode(iaddonFile,&obj1,true)){
	error="ERROR: Invalid file format of the installed_addons!";
	cerr<<error<<endl;
	return false;
	}
	}


	//Fill the vector.
	addons = new std::vector<Addon>;
	fillAddonList(*addons,obj,obj1);

	//Close the files.
	iaddonFile.close();
	addonFile.close();
	return true;
	}

	void Addons::fillAddonList(std::vector<Addons::Addon> &list, TreeStorageNode &addons, TreeStorageNode &installed_addons){
	//Loop through the blocks of the addons file.
	//These should contain the types levels, levelpacks, themes.
	for(unsigned int i=0;i<addons.subNodes.size();i++){
	TreeStorageNode* block=addons.subNodes[i];
	if(block==NULL) continue;

	string type;
	type=block->name;
	//Now loop the entries(subNodes) of the block.
	for(unsigned int i=0;i<block->subNodes.size();i++){
	TreeStorageNode* entry=block->subNodes[i];
	if(entry==NULL) continue;
	if(entry->name=="entry" && entry->value.size()==1){
	//The entry is valid so create a new Addon.
	Addon addon = *(new Addon);
	addon.type=type;
	addon.name=entry->value[0];
	addon.file=entry->attributes["file"][0];
	if(!entry->attributes["folder"].empty()){
	addon.folder=entry->attributes["folder"][0];
	}
	addon.author=entry->attributes["author"][0];
	addon.version=atoi(entry->attributes["version"][0].c_str());
	addon.upToDate=false;
	addon.installed=false;

	//Check if the addon is already installed.
	for(unsigned int i=0;i<installed_addons.subNodes.size();i++){
	TreeStorageNode* installed=installed_addons.subNodes[i];
	if(installed==NULL) continue;
	if(installed->name=="entry" && installed->value.size()==3){
	if(addon.type.compare(installed->value[0])==0 && addon.name.compare(installed->value[1])==0) {
	addon.installed=true;
	addon.installedVersion=atoi(installed->value[2].c_str());
	if(addon.installedVersion>=addon.version) {
	addon.upToDate=true;
	}

	}
	}
	}

	//Finally put him in the list.
	list.push_back(addon);
	}
	}
	}
	}

	std::vector<std::string> Addons::addonsToList(const std::string &type){
	std::vector<std::string> result;

	for(unsigned int i=0;i<addons->size();i++) {
	//Check if the addon is from the right type.
	if((*addons)[i].type==type) {
	string entry = (addons)[i].name + " by " + (addons)[i].author;
	if((*addons)[i].installed) {
	if((*addons)[i].upToDate) {
	entry += " *";
	} else {
	entry += " +";
	}
	}
	result.push_back(entry);
	}
	}
	return result;
	}

	bool Addons::saveInstalledAddons(){
	if(!addons) return false;

	//Open the file.
	ofstream iaddons;
	iaddons.open((getUserPath(USER_CONFIG)+"installed_addons").c_str());
	if(!iaddons) return false;

	//Loop all the levels.
	TreeStorageNode installed;
	for(unsigned int i=0;i<addons->size();i++) {
	//Check if the level is installed or not.
	if((*addons)[i].installed) {
	TreeStorageNode *entry=new TreeStorageNode;
	entry->name="entry";
	entry->value.push_back((*addons)[i].type);
	entry->value.push_back((*addons)[i].name);
	char version[64];
	sprintf(version,"%d",(*addons)[i].installedVersion);
	entry->value.push_back(version);

	installed.subNodes.push_back(entry);
	}
	}


	//And write away the file.
	POASerializer objSerializer;
	objSerializer.writeNode(&installed,iaddons,true,true);

	return true;
	}

	void Addons::handleEvents(){
	//Check if we should quit.
	if(event.type==SDL_QUIT){
	//Save the installed addons before exiting.
	saveInstalledAddons();
	setNextState(STATE_EXIT);
	}

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

	void Addons::logic(){}

	void Addons::render(){
	//We only need to draw the background.
	applySurface(0,0,background,screen,NULL);

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

	//Draw line below selected item
	SDL_Rect r;
	r.y=124;
	r.h=2;
	if(type=="levelpacks"){
	r.x=317;
	r.w=164;
	}else if (type=="themes"){
	r.x=557;
	r.w=106;
	}else{
	r.x=144;
	r.w=89;
	}
	SDL_FillRect(screen,&r,0x000000);
	}

	void Addons::GUIEventCallback_OnEvent(std::string name,GUIObject* obj,int eventType){
	if(name=="cmdLvlpacks"){
	list->item=addonsToList("levelpacks");
	list->value=0;
	type="levelpacks";
	GUIEventCallback_OnEvent("lstAddons",list,GUIEventChange);
	}else if(name=="cmdLvls"){
	list->item=addonsToList("levels");
	list->value=0;
	type="levels";
	GUIEventCallback_OnEvent("lstAddons",list,GUIEventChange);
	}else if(name=="cmdThemes"){
	list->item=addonsToList("themes");
	list->value=0;
	type="themes";
	GUIEventCallback_OnEvent("lstAddons",list,GUIEventChange);
	}else if(name=="lstAddons"){
	//Get the addon struct that belongs to it.
	Addon *addon=NULL;
	if(list->item.size()>0) {
	string entry = list->item[list->value];
	if(type.compare("levels")==0) {
	for(unsigned int i=0;i<addons->size();i++) {
	std::string prefix=(*addons)[i].name;
	if(!entry.compare(0, prefix.size(), prefix)) {
	addon=&(*addons)[i];
	}
	}
	} else if(type.compare("levelpacks")==0) {
	for(unsigned int i=0;i<addons->size();i++) {
	std::string prefix=(*addons)[i].name;
	if(!entry.compare(0, prefix.size(), prefix)) {
	addon=&(*addons)[i];
	}
	}
	} else if(type.compare("themes")==0) {
	for(unsigned int i=0;i<addons->size();i++) {
	std::string prefix=(*addons)[i].name;
	if(!entry.compare(0, prefix.size(), prefix)) {
	addon=&(*addons)[i];
	}
	}
	}
	}

	selected=addon;
	updateActionButton();
	updateUpdateButton();
	}else if(name=="cmdBack"){
	saveInstalledAddons();
	setNextState(STATE_MENU);
	}else if(name=="cmdUpdate"){

	//First remove the addon and then install it again.
	if(type.compare("levels")==0) {
	if(downloadFile(selected->file,(getUserPath(USER_DATA)+"/levels/"))!=false){
	selected->upToDate=true;
	selected->installedVersion=selected->version;
	list->item=addonsToList("levels");
	updateActionButton();
	updateUpdateButton();
	}else{
	cerr<<"ERROR: Unable to download addon!"<<endl;
	msgBox("ERROR: Unable to download addon!",MsgBoxOKOnly,"ERROR:");
	return;
	}
	}else if(type.compare("levelpacks")==0) {
	if(!removeDirectory((getUserPath(USER_DATA)+"levelpacks/"+selected->folder+"/").c_str())){
	cerr<<"ERROR: Unable to remove the directory "<<(getUserPath(USER_DATA)+"levelpacks/"+selected->folder+"/")<<"."<<endl;
	return;
	}
	if(downloadFile(selected->file,(getUserPath(USER_CACHE)+"/tmp/"))!=false){
	extractFile(getUserPath(USER_CACHE)+"/tmp/"+fileNameFromPath(selected->file,true),getUserPath(USER_DATA)+"/levelpacks/"+selected->folder+"/");
	selected->upToDate=true;
	selected->installedVersion=selected->version;
	list->item=addonsToList("levelpacks");
	updateActionButton();
	updateUpdateButton();
	}else{
	cerr<<"ERROR: Unable to download addon!"<<endl;
	msgBox("ERROR: Unable to download addon!",MsgBoxOKOnly,"ERROR:");
	return;
	}
	}else if(type.compare("themes")==0) {
	if(!removeDirectory((getUserPath(USER_DATA)+"themes/"+selected->folder+"/").c_str())){
	cerr<<"ERROR: Unable to remove the directory "<<(getUserPath(USER_DATA)+"themes/"+selected->folder+"/")<<"."<<endl;
	return;
	}
	if(downloadFile(selected->file,(getUserPath(USER_CACHE)+"/tmp/"))!=false){
	extractFile((getUserPath(USER_CACHE)+"/tmp/"+fileNameFromPath(selected->file,true)),(getUserPath(USER_DATA)+"/themes/"+selected->folder+"/"));
	selected->upToDate=true;
	selected->installedVersion=selected->version;
	list->item=addonsToList("themes");
	updateActionButton();
	updateUpdateButton();
	}else{
	cerr<<"ERROR: Unable to download addon!"<<endl;
	msgBox("ERROR: Unable to download addon!",MsgBoxOKOnly,"ERROR:");
	return;
	}
	}


	}else if(name=="cmdInstall"){
	switch(action) {
	case NONE:
	break;
	case INSTALL:
	//Download the addon.
	if(type.compare("levels")==0) {
	if(downloadFile(selected->file,getUserPath(USER_DATA)+"/levels/")!=false){
	selected->upToDate=true;
	selected->installed=true;
	selected->installedVersion=selected->version;
	list->item=addonsToList("levels");
	updateActionButton();
	updateUpdateButton();
	}else{
	cerr<<"ERROR: Unable to download addon!"<<endl;
	msgBox("ERROR: Unable to download addon!",MsgBoxOKOnly,"ERROR:");
	return;
	}
	}else if(type.compare("levelpacks")==0) {
	if(downloadFile(selected->file,getUserPath(USER_CACHE)+"/tmp/")!=false){
	extractFile(getUserPath(USER_CACHE)+"/tmp/"+fileNameFromPath(selected->file,true),getUserPath(USER_DATA)+"/levelpacks/"+selected->folder+"/");
	selected->upToDate=true;
	selected->installed=true;
	selected->installedVersion=selected->version;
	list->item=addonsToList("levelpacks");
	updateActionButton();
	updateUpdateButton();
	}else{
	cerr<<"ERROR: Unable to download addon!"<<endl;
	msgBox("ERROR: Unable to download addon!",MsgBoxOKOnly,"ERROR:");
	return;
	}
	}else if(type.compare("themes")==0) {
	if(downloadFile(selected->file,getUserPath(USER_CACHE)+"/tmp/")!=false){
	extractFile(getUserPath(USER_CACHE)+"/tmp/"+fileNameFromPath(selected->file,true),getUserPath(USER_DATA)+"/themes/"+selected->folder+"/");
	selected->upToDate=true;
	selected->installed=true;
	selected->installedVersion=selected->version;
	list->item=addonsToList("themes");
	updateActionButton();
	updateUpdateButton();
	}else{
	cerr<<"ERROR: Unable to download addon!"<<endl;
	msgBox("ERROR: Unable to download addon!",MsgBoxOKOnly,"ERROR:");
	return;
	}
	}
	break;
	case UNINSTALL:
	//Uninstall the addon.
	if(type.compare("levels")==0) {
	if(remove((getUserPath(USER_DATA)+"levels/"+fileNameFromPath(selected->file)).c_str())){
	cerr<<"ERROR: Unable to remove the file "<<(getUserPath(USER_DATA) + "levels/" + fileNameFromPath(selected->file))<<"."<<endl;
	return;
	}

	selected->upToDate=false;
	selected->installed=false;
	list->item=addonsToList("levels");
	updateActionButton();
	updateUpdateButton();
	}else if(type.compare("levelpacks")==0) {
	if(!removeDirectory((getUserPath(USER_DATA)+"levelpacks/"+selected->folder+"/").c_str())){
	cerr<<"ERROR: Unable to remove the directory "<<(getUserPath(USER_DATA)+"levelpacks/"+selected->folder+"/")<<"."<<endl;
	return;
	}

	selected->upToDate=false;
	selected->installed=false;
	list->item=addonsToList("levelpacks");
	updateActionButton();
	updateUpdateButton();
	}else if(type.compare("themes")==0) {
	if(!removeDirectory((getUserPath(USER_DATA)+"themes/"+selected->folder+"/").c_str())){
	cerr<<"ERROR: Unable to remove the directory "<<(getUserPath(USER_DATA)+"themes/"+selected->folder+"/")<<"."<<endl;
	return;
	}

	selected->upToDate=false;
	selected->installed=false;
	list->item=addonsToList("themes");
	updateActionButton();
	updateUpdateButton();
	}
	break;
	}
	}
	}

	void Addons::updateUpdateButton(){
	//some sanity check
	if(selected==NULL){
	updateButton->enabled=false;
	return;
	}

	//Check if the selected addon is installed.
	if(selected->installed){
	//It is installed, but is it uptodate?
	if(selected->upToDate){
	//The addon is installed and there is no need to show the button.
	updateButton->enabled=false;
	updateButton->visible=false;
	}else{
	//Otherwise show the button
	updateButton->enabled=true;
	updateButton->visible=true;
	}
	}else{
	//The addon isn't installed so we can only install it.
	updateButton->enabled=false;
	}
	}



	void Addons::updateActionButton(){
	//some sanity check
	if(selected==NULL){
	actionButton->enabled=false;
	action = NONE;
	return;
	}

	//Check if the selected addon is installed.
	if(selected->installed){
	//It is installed, but is it uptodate?
	actionButton->enabled=true;
	actionButton->caption="Uninstall";
	action = UNINSTALL;
	}else{
	//The addon isn't installed so we can only install it.
	actionButton->enabled=true;
	actionButton->caption="Install";
	action = INSTALL;
	}
	}
	diff --git a/src/Globals.h b/src/Globals.h
	index 35a84f6..e434c70 100644
	--- a/src/Globals.h
	+++ b/src/Globals.h
	@@ -1,163 +1,163 @@
	/****************************************************************************
	** 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 GLOBALS_H
	#define GLOBALS_H

	#include <SDL/SDL.h>
	#include <SDL/SDL_mixer.h>
	#include <SDL/SDL_ttf.h>
	#include <string>

	#ifdef WIN32
	//#define DATA_PATH
	#else
	#include "config.h"
	#endif

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

	//Strin containing the
	-const std::string version="V0.3 Development version";
	+const std::string version="V0.3";

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

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

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

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

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

	//GUI
	class GUIObject;
	extern GUIObject *GUIObjectRoot;

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

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

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

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

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

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

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

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

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

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

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

	//Solid block which works like
	TYPE_CONVEYOR_BELT,
	TYPE_SHADOW_CONVEYOR_BELT,

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

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

	#endif
	diff --git a/src/Player.h b/src/Player.h
	index 9906129..4399568 100644
	--- a/src/Player.h
	+++ b/src/Player.h
	@@ -1,254 +1,254 @@
	/****************************************************************************
	** 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 PLAYER_H
	#define PLAYER_H

	#include "ThemeManager.h"
	#include <vector>
	#include <string>
	#include <SDL/SDL_mixer.h>
	#include <SDL/SDL.h>
	#include <SDL/SDL_ttf.h>

	-//debug the game record file
	-#define RECORD_FILE_DEBUG
	+//Debug the game record file.
	+//#define RECORD_FILE_DEBUG

	class GameObject;
	class Game;

	//The different player buttons.
	//The right arrow.
	const int PlayerButtonRight=0x01;
	//The left arrow.
	const int PlayerButtonLeft=0x02;
	//The up arrow for jumping.
	const int PlayerButtonJump=0x04;
	//The down arrow for actions.
	const int PlayerButtonDown=0x08;
	//space bar for recording. (Only in recordButton)
	const int PlayerButtonSpace=0x10;

	class Player{
	protected:
	//Vector used to store the player actions in when recording.
	//These can be given to the shadow so he can execute them.
	std::vector<int> playerButton;

	private:
	//Vector used to record the whole game play.
	//And saved record in checkpoint.
	std::vector<int> recordButton,savedRecordButton;

	//record index. -1 means read input from keyboard,
	//otherwise read input from recordings (recordButton[recordIndex]).
	int recordIndex;

	//Vector containing squares along the path the player takes when recording.
	//It will be drawn as a trail of squares.
	std::vector<SDL_Rect> line;

	//Boolean if the player called the shadow to copy his moves.
	bool shadowCall;
	//Boolean if the player is recording his moves.
	bool record;

	//The following variables are to store a state.
	//Rectangle containing the players location.
	SDL_Rect boxSaved;
	//Boolean if the player is in the air.
	bool inAirSaved;
	//Boolean if the player is (going to) jump(ing).
	bool isJumpSaved;
	//Boolean if the player is (still) on the ground.
	bool onGroundSaved;
	//Boolean if the player can move.
	bool canMoveSaved;
	//Boolean if the player is holding the other (shadow).
	bool holdingOtherSaved;
	//The x velocity.
	//NOTE: The x velocity is used to indicate that there's a state saved.
	int xVelSaved;
	//The y velocity.
	int yVelSaved;

	protected:
	//Rectangle containing the player's location.
	SDL_Rect box;

	//The x and y velocity.
	int xVel, yVel;
	//The base x and y velocity, used for standing on moving blocks.
	int xVelBase, yVelBase;

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

	//Boolean if the player is in the air.
	bool inAir;
	//Boolean if the player is (going to) jump(ing).
	bool isJump;
	//Boolean if the player is (still) on the ground.
	bool onGround;
	//Boolean if the player can move.
	bool canMove;
	//Boolean if the player is alive/
	bool dead;

	//The direction the player is walking, 0=right, 1=left.
	int direction;
	//Integer containing the state of the player.
	int state;
	//The time the player is in the air (jumping).
	int jumpTime;
	//Boolean if the player is in fact the shadow.
	bool shadow;

	//Pointer to the Game state.
	friend class Game;
	Game* objParent;

	//Boolean if the downkey is pressed.
	bool downKeyPressed;
	//Boolean if the space keu is pressed.
	bool spaceKeyPressed;
	//Pointer to the object that is currently been stand on by the player.
	//This is always a valid pointer.
	GameObject* objCurrentStand;
	//Pointer to the object the player stood last on.
	//NOTE: This is a weak reference only.
	GameObject* objLastStand;
	//Pointer to the teleporter the player last took.
	//NOTE: This is a weak reference only.
	GameObject* objLastTeleport;
	//Pointer to the notification block the player is in front of.
	//This is always a valid pointer.
	GameObject* objNotificationBlock;
	//Pointer to the shadow block the player is in front of.
	//This is always a valid pointer.
	GameObject* objShadowBlock;

	public:

	//X and y location where the player starts and gets when reseted.
	int fx, fy;
	//The appearance of the player.
	ThemeCharacterInstance appearance;
	//Boolean if the player is holding the other.
	bool holdingOther;

	//Constructor.
	//objParent: Pointer to the Game state.
	Player(Game* objParent);
	//Destructor.
	~Player();

	//Method used to set the position of the player.
	//x: The new x location of the player.
	//y: The new y location of the player.
	void setPosition(int x,int y);

	//Method used to handle (key) input.
	//shadow: Pointer to the shadow used for recording/calling.
	void handleInput(class Shadow* shadow);
	//Method used to do the movement of the player.
	//levelObjects: Array containing the levelObjects, used to check collision.
	void move(std::vector<GameObject*> &levelObjects);
	//Method used to check if the player can jump and executes the jump.
	void jump();

	//This method will render the player to the screen.
	void show();
	//Method that stores the actions if the player is recording.
	void shadowSetState();

	//Method that will reset the state to 0.
	virtual void stateReset();

	//This method checks the player against the other to see if they stand on eachother.
	//other: The shadow or the player.
	void otherCheck(class Player* other);

	//Method that will ease the camera so that the player is in the center.
	void setMyCamera();
	//This method will reset the player to it's initial position.
	//save: Boolean if the saved state should also be deleted.
	void reset(bool save);
	//Method used to retrieve the current location of the player.
	//Returns: SDL_Rect containing the player's location.
	SDL_Rect getBox();

	//This method will
	void shadowGiveState(class Shadow* shadow);

	//Method that will save the current state.
	//NOTE: The special <name>Saved variables will be used.
	virtual void saveState();
	//Method that will retrieve the last saved state.
	//If there is none it will reset the player.
	virtual void loadState();
	//Method that checks if the player can save the state.
	//Returns: True if the player can save his state.
	virtual bool canSaveState();
	//Method that checks if the player can load a state.
	//Returns: True if the player can load a state.
	virtual bool canLoadState();
	//Method that will swap the state of the player with the other.
	//other: The player or the shadow.
	void swapState(Player* other);

	//Check if this player is in fact the shadow.
	//Returns: True if this is the shadow.
	inline bool isShadow(){
	return shadow;
	}

	//Let the player die when he falls of or hits spikes.
	void die();

	//Check if currently it's play from record file.
	bool isPlayFromRecord();

	//get the game record object.
	std::vector<int>* getRecord();

	#ifdef RECORD_FILE_DEBUG
	std::string& keyPressLog();
	std::vector<SDL_Rect>& playerPosition();
	#endif

	//play the record.
	void playRecord();

	private:
	//The space key is down. call this function from handleInput and another function.
	void spaceKeyDown(class Shadow* shadow);
	};

	#endif

File Metadata

Mime Type: text/x-diff
Expires: Tue, Jun 16, 8:28 PM (1 w, 6 d ago)
Storage Engine: blob
Storage Format: Raw Data
Storage Handle: 71656
Default Alt Text: (37 KB)

No OneTemporaryActions

View Options

File Metadata

Event Timeline

No OneTemporary
Actions