No OneTemporary
Actions

Authored By

Unknown

Size

19 KB

Referenced Files

None

Subscribers

None

View Options

	diff --git a/AndroidAppSettings.cfg b/AndroidAppSettings.cfg
	index 804bb29..3da3a66 100644
	--- a/AndroidAppSettings.cfg
	+++ b/AndroidAppSettings.cfg
	@@ -1,62 +1,62 @@
	# The application settings for Android libSDL port
	AppSettingVersion=17
	LibSdlVersion=1.2
	AppName="Me and My Shadow"
	AppFullName=net.sourceforge.meandmyshadow
	ScreenOrientation=h
	InhibitSuspend=y
	AppDataDownloadUrl="Data\|data.zip"
	-VideoDepthBpp=32
	+VideoDepthBpp=16
	NeedDepthBuffer=n
	NeedStencilBuffer=n
	NeedGles2=n
	SwVideoMode=y
	SdlVideoResize=y
	SdlVideoResizeKeepAspect=n
	CompatibilityHacks=n
	CompatibilityHacksStaticInit=n
	CompatibilityHacksTextInputEmulatesHwKeyboard=n
	CompatibilityHacksPreventAudioChopping=n
	CompatibilityHacksAppIgnoresAudioBufferSize=n
	CompatibilityHacksAdditionalPreloadedSharedLibraries=""
	CompatibilityHacksSlowCompatibleEventQueue=n
	CompatibilityHacksTouchscreenKeyboardSaveRestoreOpenGLState=y
	AppUsesMouse=y
	AppNeedsTwoButtonMouse=y
	ShowMouseCursor=y
	ForceRelativeMouseMode=n
	AppNeedsArrowKeys=y
	AppNeedsTextInput=y
	AppUsesJoystick=n
	AppUsesAccelerometer=n
	AppUsesGyroscope=n
	AppUsesMultitouch=n
	AppRecordsAudio=n
	NonBlockingSwapBuffers=n
	RedefinedKeys="SPACE RETURN NO_REMAP NO_REMAP SPACE ESCAPE"
	AppTouchscreenKeyboardKeysAmount=2
	AppTouchscreenKeyboardKeysAmountAutoFire=0
	RedefinedKeysScreenKb="0 1 2 3 4 5 6 7 8 9"
	RedefinedKeysScreenKbNames="0 1 2 3 4 5 6 7 8 9"
	StartupMenuButtonTimeout=3000
	HiddenMenuOptions='OptionalDownloadConfig'
	FirstStartMenuOptions=''
	MultiABI=n
	AppMinimumRAM=64
	AppVersionCode=490
	AppVersionName="0.49"
	ResetSdlConfigForThisVersion=n
	DeleteFilesOnUpgrade="%"
	CompiledLibraries="sdl_image sdl_ttf sdl_mixer sdl_gfx curl archive lua_52"
	CustomBuildScript=n
	AppCflags='-O2 -finline-functions -frtti'
	AppLdflags=''
	AppOverlapsSystemHeaders=
	AppSubdirsBuild=''
	AppBuildExclude=''
	AppCmdline=''
	ReadmeText='^Readme text'
	MinimumScreenSize=s
	AdmobPublisherId=n
	AdmobTestDeviceId=
	AdmobBannerSize=
	diff --git a/src/Game.h b/src/Game.h
	index 084e5d9..0e7d55d 100644
	--- a/src/Game.h
	+++ b/src/Game.h
	@@ -1,282 +1,288 @@
	/*
	* Copyright (C) 2011-2013 Me and My Shadow
	*
	* This file is part of Me and My Shadow.
	*
	* Me and My Shadow is free software: you can redistribute it and/or modify
	* it under the terms of the GNU General Public License as published by
	* the Free Software Foundation, either version 3 of the License, or
	* (at your option) any later version.
	*
	* Me and My Shadow is distributed in the hope that it will be useful,
	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	* GNU General Public License for more details.
	*
	* You should have received a copy of the GNU General Public License
	* along with Me and My Shadow. If not, see <http://www.gnu.org/licenses/>.
	*/

	#ifndef GAME_H
	#define GAME_H

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

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

	//Optional pointer to the block the event should be called on.
	GameObject* target;
	};

	class ThemeManager;
	class ThemeBackground;
	class TreeStorageNode;

	//The different level events.
	enum LevelEventType{
	//Event called when the level is created, this happens after all the blocks are created and their onCreate is called.
	LevelEvent_OnCreate=1,
	//Event called when the game is saved.
	LevelEvent_OnSave,
	//Event called when the game is loaded.
	LevelEvent_OnLoad,
	//Event called when the game is reset.
	LevelEvent_OnReset,
	};

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

	//contains currently played level.
	TreeStorageNode* currentLevelNode;

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

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

	//ThemeBlockInstance containing the collectable image.
	ThemeBlockInstance collectable;

	//The name of the current level.
	std::string levelName;
	//The path + file of the current level.
	std::string levelFile;

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

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

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

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

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

	//Map used to convert GameObjectEventType type->string.
	static std::map<int,std::string> gameObjectEventTypeMap;
	//Map used to convert GameObjectEventType string->type.
	static std::map<std::string,int> gameObjectEventNameMap;

	//Map used to convert LevelEventType type->string.
	static std::map<int,std::string> levelEventTypeMap;
	//Map used to convert LevelEventType string->type.
	static std::map<std::string,int> levelEventNameMap;

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

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

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

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

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

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

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

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

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

	//Time of recent swap, for achievements. (in game-ticks)
	int recentSwap,recentSwapSaved;

	//Store time of recent save/load for achievements (in millisecond)
	Uint32 recentLoad,recentSave;

	//Enumeration with the different camera modes.
	enum CameraMode{
	CAMERA_PLAYER,
	CAMERA_SHADOW,
	CAMERA_CUSTOM
	};
	//The current camera mode.
	CameraMode cameraMode;
	//Rectangle containing the target for the camera.
	SDL_Rect cameraTarget;

	//The saved cameraMode.
	CameraMode cameraModeSaved;
	SDL_Rect cameraTargetSaved;

	//Level scripts.
	std::map<int,std::string> scripts;

	//Vector containing all the levelObjects in the current game.
	std::vector<Block*> levelObjects;

	//The background layers for the scenery.
	std::map<std::string,std::vector<Scenery*> > backgroundLayers;

	//The player...
	Player player;
	//... and his shadow.
	Shadow shadow;

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

	//Constructor.
	Game();
	//If this is not empty then when next Game class is created
	//it will play this record file.
	static std::string recordFile;
	//Destructor.
	//It will call destroy();
	~Game();

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

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

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

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

	//Method that will check if a script for a given levelEvent is present.
	//If that's the case the script will be executed.
	//eventType: The level event type to execute.
	void inline executeScript(int eventType);

	+ //FIXME: We get a link error here :/
	+#if defined(ANDROID)
	+ //Returns if the player and shadow can save the current state.
	+ bool canSaveState();
	+#else
	//Returns if the player and shadow can save the current state.
	bool inline canSaveState();
	+#endif

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

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

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

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

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

	//Get the name of the current level.
	const std::string& getLevelName(){
	return levelName;
	}

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

	#endif
	diff --git a/src/Globals.h b/src/Globals.h
	index 8113314..8ed3ac0 100644
	--- a/src/Globals.h
	+++ b/src/Globals.h
	@@ -1,273 +1,273 @@
	/*
	* Copyright (C) 2011-2012 Me and My Shadow
	*
	* This file is part of Me and My Shadow.
	*
	* Me and My Shadow is free software: you can redistribute it and/or modify
	* it under the terms of the GNU General Public License as published by
	* the Free Software Foundation, either version 3 of the License, or
	* (at your option) any later version.
	*
	* Me and My Shadow is distributed in the hope that it will be useful,
	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	* GNU General Public License for more details.
	*
	* You should have received a copy of the GNU General Public License
	* along with Me and My Shadow. If not, see <http://www.gnu.org/licenses/>.
	*/

	#ifndef GLOBALS_H
	#define GLOBALS_H

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

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

	#define TITLE_FONT_RAISE 19
	#define GUI_FONT_RAISE 5

	//Global constants
	//The width of the screen.
	extern int SCREEN_WIDTH;
	//The height of the screen.
	extern int SCREEN_HEIGHT;
	//The depth of the screen.
	#if defined(ANDROID)
	-const int SCREEN_BPP=32; //???
	-const int SCREEN_FLAGS=SDL_HWSURFACE;
	//TODO: change other surface creating code to make the game runs faster
	+const int SCREEN_BPP=16; //??? 24?? 32??
	+const int SCREEN_FLAGS=SDL_HWSURFACE;
	#else
	const int SCREEN_BPP=32;
	const int SCREEN_FLAGS=SDL_HWSURFACE;
	#endif

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

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

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

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

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

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

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

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

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

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

	//GUI
	class GUIObject;
	extern GUIObject *GUIObjectRoot;

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

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

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

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

	//Enumeration containing the different cursor types there are.
	enum CursorType{
	//The default pointer.
	CURSOR_POINTER,

	//The vertical ibeam, used to indicate text input.
	CURSOR_CARROT,

	//A closed hand, used for indicating a drag action.
	CURSOR_DRAG,

	//The different (window) size cursor icons.
	CURSOR_SIZE_HOR,
	CURSOR_SIZE_VER,
	CURSOR_SIZE_FDIAG,
	CURSOR_SIZE_BDIAG,

	//Remove cursor used in level editor
	CURSOR_REMOVE,

	//The number of cursor types there are.
	CURSOR_MAX
	};
	//Currently used cursor type.
	extern CursorType currentCursor;
	//Array containing the SDL_Cursors.
	extern SDL_Cursor* cursors[CURSOR_MAX];

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

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

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

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

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

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

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

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

	//Solid block which works like
	TYPE_CONVEYOR_BELT,
	TYPE_SHADOW_CONVEYOR_BELT,

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

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

	//Block that can be pushed by the player and the shadow.
	//Pushable blocks can push other pushable blocks.
	TYPE_PUSHABLE,

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

	#endif

File Metadata

Mime Type: text/x-diff
Expires: Fri, May 15, 10:24 PM (3 h, 6 m)
Storage Engine: blob
Storage Format: Raw Data
Storage Handle: 63982
Default Alt Text: (19 KB)

No OneTemporaryActions

View Options

File Metadata

Event Timeline

No OneTemporary
Actions