No OneTemporary
Actions

Authored By

Unknown

Size

32 KB

Referenced Files

None

Subscribers

None

View Options

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

	#ifndef BLOCK_H
	#define BLOCK_H

	#include "GameObjects.h"
	#include "Globals.h"
	#include "ThemeManager.h"
	+#include "ScriptUserData.h"
	#include "ScriptExecutor.h"
	#include <vector>
	#include <SDL/SDL.h>

	class Block: public GameObject, public ScriptUserClass<'B','L','O','K',Block>{
	private:
	- //The Appearance of the block.
	- ThemeBlockInstance appearance;
	-
	//Integer that a block can use for all animation or visual related things.
	int animation;
	//The save for animation when the state of the block is saved.
	int animationSave;

	//flags:
	//moving object 0x1=disabled
	//button bit0-1=behavior 0x4=pressed
	//switch bit0-1=behavior
	int flags;
	//The save for flags when the state of the block is saved.
	int flagsSave;

	//Temp variables used to keep track of time/state.
	int temp;
	//The save for temp when the state of the block is saved.
	int tempSave;

	//Save variables for the current location of the block.
	int xSave,ySave;

	//Delta variables, if the block moves these must be set to the delta movement.
	int dx,dy;

	//Vector containing the poisitions of the moving block.
	std::vector<SDL_Rect> movingPos;
	//Boolean if the moving block loops his movement.
	//Default value is true.
	bool loop;

	//Integer containing the speed for conveyorbelts.
	int speed;
	int speedSave;
	int editorSpeed;

	//Following is for the pushable block.
	Block* objCurrentStand;

	//Flags of the block for the editor.
	//moving object 0x1=disabled
	//portal 0x1=automatic
	//fragile =state
	int editorFlags;
	public:
	+ //The Appearance of the block.
	+ ThemeBlockInstance appearance;
	+
	//Velocity variables for the block, if the block moves these must be set for collision/movement of the player.
	int xVel,yVel;
	//Save variables for the velocity.
	int xVelSave,yVelSave;

	//Follwing is for pushable block.
	bool inAir;
	int xVelBase,yVelBase;
	//The save variables for each of the above.
	bool inAirSave;
	int xVelBaseSave,yVelBaseSave;

	//The id of the block.
	std::string id;
	//String containing the id of the destination for portals.
	std::string destination;
	//String containing the message of the notification block.
	std::string message;

	//The map that holds a script for every event.
	map<int,std::string> scripts;

	//Constructor.
	//x: The x location of the block.
	//y: The y location of the block.
	//objParent: Pointer to the Game object.
	Block(int x,int y,int type,Game* objParent);
	//Desturctor.
	~Block();

	//Method used to draw the block.
	void show();

	//Returns the box of a given type.
	//boxType: The type of box that should be returned.
	//See GameObjects.h for the types.
	//Returns: The box.
	virtual SDL_Rect getBox(int boxType=BoxType_Current);

	//Method used to set the location of the block.
	//NOTE: The new location isn't stored as base location.
	//x: The new x location.
	//y: The new y location.
	virtual void setLocation(int x,int y);

	//Save the state of the block so we can load it later on.
	virtual void saveState();
	//Load the saved state of the block so.
	virtual void loadState();
	//Reset the block.
	//save: Boolean if the saved state should also be deleted.
	virtual void reset(bool save);

	//Play an animation.
	//flags: TODO???
	virtual void playAnimation(int flags);

	//Method called when there's an event.
	//eventType: The type of event.
	//See GameObjects.h for the eventtypes.
	virtual void onEvent(int eventType);

	//Method used to retrieve a property from the block.
	//propertyType: The type of property requested.
	//See GameObjects.h for the properties.
	//obj: Pointer to the player.
	//Returns: Integer containing the value of the property.
	virtual int queryProperties(int propertyType,Player* obj);

	//Get the editor data of the block.
	//obj: The vector that will be filled with the editorData.
	virtual void getEditorData(std::vector<std::pair<std::string,std::string> >& obj);
	//Set the editor data of the block.
	//obj: The new editor data.
	virtual void setEditorData(std::map<std::string,std::string>& obj);

	//Get a single property of the block.
	//property: The property to return.
	//Returns: The value for the requested property.
	virtual std::string getEditorProperty(std::string property);
	//Set a single property of the block.
	//property: The property to set.
	//value: The new value for the property.
	virtual void setEditorProperty(std::string property,std::string value);

	//Method used for resetting the dx/dy and xVel/yVel variables.
	virtual void prepareFrame();
	//Method used for updating moving blocks or elements of blocks.
	virtual void move();
	};

	#endif
	diff --git a/src/GameObjects.h b/src/GameObjects.h
	index b6fe937..062b11f 100644
	--- a/src/GameObjects.h
	+++ b/src/GameObjects.h
	@@ -1,164 +1,163 @@
	/*
	* 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 GAME_OBJECTS_H
	#define GAME_OBJECTS_H

	#include "Globals.h"
	-#include "ScriptUserData.h"
	#include <SDL/SDL.h>
	#include <string>
	#include <vector>
	#include <utility>
	#include <map>

	class Game;
	class Player;

	//The different gameObject events.
	enum GameObjectEventType{
	//Event called when the player walks on the gameObject.
	GameObjectEvent_PlayerWalkOn=1,
	//Event called when the player is on the gameObject.
	GameObjectEvent_PlayerIsOn,
	//Event called when the player leaves the gameObject.
	//Currently unimplemented.
	GameObjectEvent_PlayerLeave,
	//Event called when the gameObject is created.
	//Only used for scripting purpose.
	GameObjectEvent_OnCreate,
	//Event called every frame.
	//Only used for scripting purpose.
	GameObjectEvent_OnEnterFrame,

	//Event called when the player toggles it. (DOWN key)
	GameObjectEvent_OnToggle=0x10000,
	//Event called when the player switches it on. (DOWN key)
	GameObjectEvent_OnSwitchOn=0x10001,
	//Event called when the player switches it off. (DOWN key)
	GameObjectEvent_OnSwitchOff=0x10002,
	};

	//The different gameObject properties.
	enum GameObjectPropertyType{
	//If the player can walk on the gameObject.
	GameObjectProperty_PlayerCanWalkOn=1,
	//If the object is spiked.
	GameObjectProperty_IsSpikes,
	//If the gameObject has some flags.
	GameObjectProperty_Flags,
	};

	//The different box types that can be requested using the getBox(int boxType) method.
	enum GameObjectBoxType{
	//Box of the current position.
	BoxType_Current=0,
	//Box of the base/start position.
	BoxType_Base,
	//Box of the previous position.
	BoxType_Previous,
	//The movement of the block since last position.
	BoxType_Delta,
	//The velocity for when the player is standing on it.
	BoxType_Velocity,
	};

	//The GameObject class.
	class GameObject{
	protected:
	//The box of the gameObject.
	//It's used for the current location of the gameObject and its size.
	SDL_Rect box;
	//The base location of the game object.
	SDL_Rect boxBase;
	public:
	//The type of the GameObject.
	int type;
	//Pointer to the Game state.
	Game* parent;

	//Constructor.
	//parent: Pointer to the Game state.
	GameObject(Game* parent);
	//Destructor.
	~GameObject();

	//Method used to retrieve a certain box from the GameObject.
	//boxType: The type of box that is requested. (default=0)
	//Returns: An SDL_Rect.
	virtual SDL_Rect getBox(int boxType=0);

	//This method is used to place the location on a given location.
	//x: The x location to place the gameObject.
	//y: The y location to place the gameObject.
	virtual void setLocation(int x,int y);
	//This method is used to set the base of an object to a given location.
	//x: The x location to place the gameObject.
	//y: The y location to place the gameObject.
	virtual void setBaseLocation(int x,int y);


	//Method used to draw the GameObject.
	virtual void show()=0;
	//Save the state of the GameObject, used for moving blocks, etc.
	virtual void saveState();
	//Load the state of the GameObject, used for moving blocks, etc.
	virtual void loadState();
	//Reset the state of the GameObject, used for moving blocks, etc.
	//save: Boolean if the saved state should also be reset.
	virtual void reset(bool save);

	//Play an animation.
	//flags: TODO???
	virtual void playAnimation(int flags);
	//Invoke an event of the GameObject.
	//eventType: The event type.
	virtual void onEvent(int eventType);
	//Method used to request certain properties of the GameObject.
	//propertyType: The property that is requested.
	//obj: Pointer to the player.
	virtual int queryProperties(int propertyType,Player* obj);

	//Method used to retrieve the additional editor data for the GameObject.
	//Used for messages, moving positions, etc...
	//obj: Vector containing the editorData pairs. (key, value)
	virtual void getEditorData(std::vector<std::pair<std::string,std::string> >& obj);
	//Set the editorData.
	//obj: Map containing the key/value for the editor data.
	virtual void setEditorData(std::map<std::string,std::string>& obj);

	//Get a single property of the block.
	//property: The property to return.
	//Returns: The value for the requested property.
	virtual std::string getEditorProperty(std::string property);
	//Set a single property of the block.
	//property: The property to set.
	//value: The new value for the property.
	virtual void setEditorProperty(std::string property,std::string value);

	//Method that is called before the move method.
	//It can be used to reset variables like delta movement and velocity.
	virtual void prepareFrame();
	//Update method for GameObjects, used for moving blocks.
	virtual void move();
	};

	//We include block.h here because it needs some things defined above.
	#include "Block.h"
	#endif
	diff --git a/src/ScriptAPI.cpp b/src/ScriptAPI.cpp
	index 673ad59..dee042a 100644
	--- a/src/ScriptAPI.cpp
	+++ b/src/ScriptAPI.cpp
	@@ -1,473 +1,494 @@
	/*
	* 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 "ScriptAPI.h"
	#include "ScriptExecutor.h"
	#include "Functions.h"
	#include "Objects.h"
	#include "Game.h"
	#include <iostream>
	using namespace std;

	int test(lua_State* state){
	cout<<"Hello world"<<endl;
	return 0;
	}

	//Register the libraries.
	void registerFunctions(ScriptExecutor* executor){
	//
	}

	///////////////////////////BLOCK SPECIFIC///////////////////////////
	int getBlockById(lua_State* state){
	//Get the number of args, this MUST be one.
	int args=lua_gettop(state);
	if(args!=1){
	lua_pushstring(state,_("Incorrect number of arguments for getBlockById, expected 1."));
	lua_error(state);
	}
	//Make sure the given argument is an id (string).
	if(!lua_isstring(state,1)){
	lua_pushstring(state,_("Invalid type for argument 1 of getBlockById."));
	lua_error(state);
	}

	//Check if the currentState is the game state.
	Game* game=dynamic_cast<Game*>(currentState);
	if(game==NULL) return 0;

	//Get the actual game object.
	string id=lua_tostring(state,1);
	std::vector<Block*>& levelObjects=game->levelObjects;
	Block* object=NULL;
	for(unsigned int i=0;i<levelObjects.size();i++){
	if(levelObjects[i]->getEditorProperty("id")==id){
	object=levelObjects[i];
	break;
	}
	}
	if(object==NULL){
	//Unable to find the requested object.
	//Return nothing, will result in a nil in the script.
	return 0;
	}

	//Create the userdatum.
	object->createUserData(state,"block");

	//We return one object, the userdatum.
	return 1;
	}

	int getBlocksById(lua_State* state){
	//Get the number of args, this MUST be one.
	int args=lua_gettop(state);
	if(args!=1){
	lua_pushstring(state,_("Incorrect number of arguments for getBlocksById, expected 1."));
	lua_error(state);
	}
	//Make sure the given argument is an id (string).
	if(!lua_isstring(state,1)){
	lua_pushstring(state,_("Invalid type for argument 1 of getBlocksById."));
	lua_error(state);
	}

	//Check if the currentState is the game state.
	Game* game=dynamic_cast<Game*>(currentState);
	if(game==NULL) return 0;

	//Get the actual game object.
	string id=lua_tostring(state,1);
	std::vector<Block*>& levelObjects=game->levelObjects;
	std::vector<Block*> result;
	for(unsigned int i=0;i<levelObjects.size();i++){
	if(levelObjects[i]->getEditorProperty("id")==id){
	result.push_back(levelObjects[i]);
	}
	}

	//Create the table that will hold the result.
	lua_createtable(state,result.size(),0);

	//Loop through the results.
	for(unsigned int i=0;i<result.size();i++){
	//Create the userdatum.
	result[i]->createUserData(state,"block");
	//And set the table.
	lua_rawseti(state,-2,i+1);
	}

	//We return one object, the userdatum.
	return 1;
	}

	int getBlockLocation(lua_State* state){
	//Make sure there's only one argument and that argument is an userdatum.
	int args=lua_gettop(state);
	if(args!=1){
	lua_pushstring(state,_("Incorrect number of arguments for getBlockLocation, expected 1."));
	lua_error(state);
	}
	if(!lua_isuserdata(state,1)){
	lua_pushstring(state,_("Invalid type for argument 1 of getBlockLocation."));
	lua_error(state);
	}
	Block* object = Block::getObjectFromUserData(state,1);
	if(object==NULL) return 0;

	//Get the object.
	lua_pushnumber(state,object->getBox().x);
	lua_pushnumber(state,object->getBox().y);
	return 2;
	}

	int setBlockLocation(lua_State* state){
	//Check the number of arguments.
	int args=lua_gettop(state);

	//Make sure the number of arguments is correct.
	if(args!=3){
	lua_pushstring(state,_("Incorrect number of arguments for setBlockLocation, expected 3."));
	lua_error(state);
	}
	//Check if the arguments are of the right type.
	if(!lua_isuserdata(state,1)){
	lua_pushstring(state,_("Invalid type for argument 1 of setBlockLocation."));
	lua_error(state);
	}
	if(!lua_isnumber(state,2)){
	lua_pushstring(state,_("Invalid type for argument 2 of setBlockLocation."));
	lua_error(state);
	}
	if(!lua_isnumber(state,3)){
	lua_pushstring(state,_("Invalid type for argument 3 of setBlockLocation."));
	lua_error(state);
	}

	//Now get the pointer to the object.
	Block* object = Block::getObjectFromUserData(state,1);
	if(object==NULL) return 0;

	int x=lua_tonumber(state,2);
	int y=lua_tonumber(state,3);
	object->setLocation(x,y);

	return 0;
	}

	int getBlockType(lua_State* state){
	int args=lua_gettop(state);
	if(args!=1){
	lua_pushstring(state,_("Incorrect number of arguments for getBlockType, expected 1."));
	lua_error(state);
	}
	if(!lua_isuserdata(state,1)){
	lua_pushstring(state,_("Invalid type for argument 1 of getBlockType."));
	lua_error(state);
	}
	Block* object = Block::getObjectFromUserData(state,1);
	if(object==NULL \|\| object->type<0 \|\| object->type>=TYPE_MAX) return 0;

	lua_pushstring(state,Game::blockName[object->type]);
	return 1;
	}

	+int changeBlockThemeState(lua_State* state){
	+ int args=lua_gettop(state);
	+ if(args!=2){
	+ lua_pushstring(state,_("Incorrect number of arguments for changeBlockThemeState, expected 2."));
	+ lua_error(state);
	+ }
	+ if(!lua_isuserdata(state,1)){
	+ lua_pushstring(state,_("Invalid type for argument 1 of changeBlockThemeState."));
	+ lua_error(state);
	+ }
	+ if(!lua_isstring(state,2)){
	+ lua_pushstring(state,_("Invalid type for argument 2 of changeBlockThemeState."));
	+ lua_error(state);
	+ }
	+ Block* object = Block::getObjectFromUserData(state,1);
	+ object->appearance.changeState(lua_tostring(state,2));
	+
	+ return 0;
	+}
	+
	//Array with the methods for the block library.
	static const struct luaL_Reg blocklib_m[]={
	{"getBlockById",getBlockById},
	{"getBlocksById",getBlocksById},
	{"getLocation",getBlockLocation},
	{"setLocation",setBlockLocation},
	{"getType",getBlockType},
	+ {"changeThemeState",changeBlockThemeState},
	{NULL,NULL}
	};

	int luaopen_block(lua_State* state){
	luaL_newlib(state,blocklib_m);

	//Create the metatable for the block userdata.
	luaL_newmetatable(state,"block");

	lua_pushstring(state,"__index");
	lua_pushvalue(state,-2);
	lua_settable(state,-3);

	Block::registerMetatableFunctions(state,-3);

	//Register the functions and methods.
	luaL_setfuncs(state,blocklib_m,0);
	return 1;
	}

	//////////////////////////PLAYER SPECIFIC///////////////////////////

	struct PlayerUserDatum{
	char sig1,sig2,sig3,sig4;
	};

	Player* getPlayerFromUserData(lua_State* state,int idx){
	PlayerUserDatum* ud=(PlayerUserDatum*)lua_touserdata(state,1);
	//Make sure the user datum isn't null.
	if(!ud) return NULL;

	//Get the game state.
	Game* game=dynamic_cast<Game*>(currentState);
	if(game==NULL) return NULL;

	Player* player=NULL;

	//Check the signature to see if it's the player or the shadow.
	if(ud->sig1=='P' && ud->sig2=='L' && ud->sig3=='Y' && ud->sig4=='R')
	player=&game->player;
	else if(ud->sig1=='S' && ud->sig2=='H' && ud->sig3=='D' && ud->sig4=='W')
	player=&game->shadow;

	return player;
	}


	int getPlayerLocation(lua_State* state){
	//Make sure there's only one argument and that argument is an userdatum.
	int args=lua_gettop(state);
	if(args!=1){
	lua_pushstring(state,_("Incorrect number of arguments for getPlayerLocation, expected 1."));
	lua_error(state);
	}
	if(!lua_isuserdata(state,1)){
	lua_pushstring(state,_("Invalid type for argument 1 of getPlayerLocation."));
	lua_error(state);
	}

	Player* player=getPlayerFromUserData(state,1);
	if(player==NULL) return 0;

	//Get the object.
	lua_pushnumber(state,player->getBox().x);
	lua_pushnumber(state,player->getBox().y);
	return 2;
	}

	int setPlayerLocation(lua_State* state){
	//Make sure there are three arguments, userdatum and two integers.
	int args=lua_gettop(state);
	if(args!=3){
	lua_pushstring(state,_("Incorrect number of arguments for setPlayerLocation, expected 3."));
	lua_error(state);
	}
	//Check if the arguments are of the right type.
	if(!lua_isuserdata(state,1)){
	lua_pushstring(state,_("Invalid type for argument 1 of setPlayerLocation."));
	lua_error(state);
	}
	if(!lua_isnumber(state,2)){
	lua_pushstring(state,_("Invalid type for argument 2 of setPlayerLocation."));
	lua_error(state);
	}
	if(!lua_isnumber(state,3)){
	lua_pushstring(state,_("Invalid type for argument 3 of setPlayerLocation."));
	lua_error(state);
	}

	//Get the player.
	Player* player=getPlayerFromUserData(state,1);
	if(player==NULL) return 0;

	//Get the new location.
	int x=lua_tonumber(state,2);
	int y=lua_tonumber(state,3);
	player->setLocation(x,y);

	return 0;
	}

	int setPlayerJump(lua_State* state){
	//Make sure there are three arguments, userdatum and one integers.
	int args=lua_gettop(state);
	if(args!=1 && args!=2){
	lua_pushstring(state,_("Incorrect number of arguments for setPlayerJump, expected 1 or 2."));
	lua_error(state);
	}
	//Check if the arguments are of the right type.
	if(!lua_isuserdata(state,1)){
	lua_pushstring(state,_("Invalid type for argument 1 of setPlayerJump."));
	lua_error(state);
	}
	if(args==2 && !lua_isnumber(state,2)){
	lua_pushstring(state,_("Invalid type for argument 2 of setPlayerJump."));
	lua_error(state);
	}

	//Get the player.
	Player* player=getPlayerFromUserData(state,1);
	if(player==NULL) return 0;

	//Get the new location.
	if(args==2){
	int yVel=lua_tonumber(state,2);
	player->jump(yVel);
	}else{
	//Use default jump strength.
	player->jump();
	}

	return 0;
	}

	int isPlayerShadow(lua_State* state){
	//Make sure there's only one argument and that argument is an userdatum.
	int args=lua_gettop(state);
	if(args!=1){
	lua_pushstring(state,_("Incorrect number of arguments for isPlayerShadow, expected 1."));
	lua_error(state);
	}
	if(!lua_isuserdata(state,1)){
	lua_pushstring(state,_("Invalid type for argument 1 of isPlayerShadow."));
	lua_error(state);
	}

	Player* player=getPlayerFromUserData(state,1);
	if(player==NULL) return 0;

	lua_pushboolean(state,player->isShadow());
	return 1;
	}

	int getPlayerCurrentStand(lua_State* state){
	//Get the number of args, this MUST be one.
	int args=lua_gettop(state);
	if(args!=1){
	lua_pushstring(state,_("Incorrect number of arguments for getPlayerCurrentStand, expected 1."));
	lua_error(state);
	}
	//Make sure the given argument is a player userdatum.
	if(!lua_isuserdata(state,1)){
	lua_pushstring(state,_("Invalid type for argument 1 of getPlayerCurrentStand."));
	lua_error(state);
	}

	Player* player=getPlayerFromUserData(state,1);
	if(player==NULL) return 0;

	//Get the actual game object.
	Block* object=player->getObjCurrentStand();
	if(object==NULL){
	return 0;
	}

	//Create the userdatum.
	object->createUserData(state,"block");

	//We return one object, the userdatum.
	return 1;
	}

	//Array with the methods for the player and shadow library.
	static const struct luaL_Reg playerlib_m[]={
	{"getLocation",getPlayerLocation},
	{"setLocation",setPlayerLocation},
	{"jump",setPlayerJump},
	{"isShadow",isPlayerShadow},
	{"getCurrentStand",getPlayerCurrentStand},
	{NULL,NULL}
	};

	int luaopen_player(lua_State* state){
	luaL_newlib(state,playerlib_m);

	//Create the metatable for the player userdata.
	luaL_newmetatable(state,"player");

	lua_pushstring(state,"__index");
	lua_pushvalue(state,-2);
	lua_settable(state,-3);

	//Now create two default player user data, one for the player and one for the shadow.
	PlayerUserDatum* ud=(PlayerUserDatum*)lua_newuserdata(state,sizeof(PlayerUserDatum));
	ud->sig1='P';ud->sig2='L';ud->sig3='Y';ud->sig4='R';
	luaL_getmetatable(state,"player");
	lua_setmetatable(state,-2);
	lua_setglobal(state,"player");

	ud=(PlayerUserDatum*)lua_newuserdata(state,sizeof(PlayerUserDatum));
	ud->sig1='S';ud->sig2='H';ud->sig3='D';ud->sig4='W';
	luaL_getmetatable(state,"player");
	lua_setmetatable(state,-2);
	lua_setglobal(state,"shadow");

	//Register the functions and methods.
	luaL_setfuncs(state,playerlib_m,0);
	return 1;
	}

	//////////////////////////LEVEL SPECIFIC///////////////////////////

	int getLevelSize(lua_State* state){
	//NOTE: this function accepts 0 arguments, but we ignore the argument count.

	//Returns level size.
	lua_pushinteger(state,LEVEL_WIDTH);
	lua_pushinteger(state,LEVEL_HEIGHT);
	return 2;
	}

	int getLevelWidth(lua_State* state){
	//NOTE: this function accepts 0 arguments, but we ignore the argument count.

	//Returns level size.
	lua_pushinteger(state,LEVEL_WIDTH);
	return 1;
	}

	int getLevelHeight(lua_State* state){
	//NOTE: this function accepts 0 arguments, but we ignore the argument count.

	//Returns level size.
	lua_pushinteger(state,LEVEL_HEIGHT);
	return 1;
	}

	int getLevelName(lua_State* state){
	//NOTE: this function accepts 0 arguments, but we ignore the argument count.

	//Check if the currentState is the game state.
	Game* game=dynamic_cast<Game*>(currentState);
	if(game==NULL) return 0;

	//Returns level name.
	lua_pushstring(state,game->getLevelName().c_str());
	return 1;
	}

	//Array with the methods for the level library.
	static const struct luaL_Reg levellib_m[]={
	{"getSize",getLevelSize},
	{"getWidth",getLevelWidth},
	{"getHeight",getLevelHeight},
	{"getName",getLevelName},
	{NULL,NULL}
	};

	int luaopen_level(lua_State* state){
	luaL_newlib(state,levellib_m);

	//Register the functions and methods.
	luaL_setfuncs(state,levellib_m,0);
	return 1;
	}
	diff --git a/src/ScriptUserData.h b/src/ScriptUserData.h
	index 1a09c45..bb2941a 100644
	--- a/src/ScriptUserData.h
	+++ b/src/ScriptUserData.h
	@@ -1,202 +1,194 @@
	/*
	* 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 SCRIPTUSERDATA_H
	#define SCRIPTUSERDATA_H

	extern "C" {
	#include "lua.h"
	#include "lualib.h"
	#include "lauxlib.h"
	}
	#include <string>

	#ifdef _DEBUG
	#include <assert.h>
	#include <stdio.h>
	#endif

	-/** A struct represents the Lua user data.
	-*/
	+
	+//A struct represents the Lua user data.
	struct ScriptUserData{
	char sig1,sig2,sig3,sig4;
	void* data;
	ScriptUserData* prev;
	ScriptUserData* next;
	};

	-/** A helper class to bind C++ class to Lua user data.
	-*/
	-
	+//A helper class to bind C++ class to Lua user data.
	template<char sig1,char sig2,char sig3,char sig4,class T>
	class ScriptUserClass{
	public:
	ScriptUserClass():scriptUserDataHead(NULL){
	}

	ScriptUserClass(const ScriptUserClass& other):scriptUserDataHead(NULL){
	}

	ScriptUserClass& operator=(const ScriptUserClass& other){
	//do nothing
	}

	- /** Create a Lua user data pointed to this object. (-0,+1,e)
	- \param state Lua state.
	- \param metatableName Metatable name.
	- */
	- void createUserData(lua_State state,const char metatableName){
	+ //Create a Lua user data pointed to this object. (-0,+1,e)
	+ //state: Lua state.
	+ //metatableName: Metatable name.
	+ void createUserData(lua_State* state,const char* metatableName){
	//Convert this object to T.
	T* obj=dynamic_cast<T*>(this);
	#ifdef _DEBUG
	//It should not be NULL unless there is a bug in code
	assert(obj!=NULL);
	#endif

	//Create user data.
	ScriptUserData* ud=(ScriptUserData*)lua_newuserdata(state,sizeof(ScriptUserData));

	ud->sig1=sig1;
	ud->sig2=sig2;
	ud->sig3=sig3;
	ud->sig4=sig4;
	ud->data=obj;

	//Add it to the linked list.
	ud->next=scriptUserDataHead;
	ud->prev=NULL;
	if(scriptUserDataHead) scriptUserDataHead->prev=ud;
	scriptUserDataHead=ud;

	//Set matatable and we are done.
	luaL_getmetatable(state,metatableName);
	lua_setmetatable(state,-2);

	#ifdef _DEBUG
	printf("ScriptUserClass '%c%c%c%c' (%p) created userdata: %p\n",
	sig1,sig2,sig3,sig4,this,ud);
	#endif
	}

	- /** Destroys all Lua user data associated to this object.
	- */
	+ //Destroys all Lua user data associated to this object.
	void destroyUserData(){
	while(scriptUserDataHead){
	#ifdef _DEBUG
	printf("ScriptUserClass '%c%c%c%c' (%p) invalidated userdata: %p\n",
	sig1,sig2,sig3,sig4,this,scriptUserDataHead);
	#endif
	scriptUserDataHead->data=NULL;
	scriptUserDataHead=scriptUserDataHead->next;
	}
	}

	- /** Convert a Lua user data in Lua stack to object. (-0,+0,e)
	- \param state Lua state.
	- \param idx Index.
	- \return The object. NULL if this user data is invalid.
	- \note This data should be a user data.
	- */
	- static T* getObjectFromUserData(lua_State *state,int idx){
	+ //Convert a Lua user data in Lua stack to object. (-0,+0,e)
	+ //state: Lua state.
	+ //idx: Index.
	+ //Returns: The object. NULL if this user data is invalid.
	+ //NOTE: This data should be a user data.
	+ static T* getObjectFromUserData(lua_State* state,int idx){
	ScriptUserData* ud=(ScriptUserData*)lua_touserdata(state,idx);

	if(ud && ud->sig1==sig1 && ud->sig2==sig2 && ud->sig3==sig3 && ud->sig4==sig4)
	return reinterpret_cast<T*>(ud->data);
	return NULL;
	}

	- /** Register __gc, __eq to given table. (-0,+0,e)
	- \param state Lua state.
	- \param idx Index.
	- */
	+ //Register __gc, __eq to given table. (-0,+0,e)
	+ //state: Lua state.
	+ //idx: Index.
	static void registerMetatableFunctions(lua_State *state,int idx){
	lua_pushstring(state,"__gc");
	lua_pushcfunction(state,&garbageCollectorFunction);
	lua_rawset(state,idx);
	lua_pushstring(state,"__eq");
	lua_pushcfunction(state,&checkEqualFunction);
	lua_rawset(state,idx);
	}

	virtual ~ScriptUserClass(){
	destroyUserData();
	}
	private:
	ScriptUserData* scriptUserDataHead;

	- /** The garbage collector (__gc) function.
	- */
	- static int garbageCollectorFunction(lua_State *state){
	+ //The garbage collector (__gc) function.
	+ static int garbageCollectorFunction(lua_State* state){
	//Check if it's a user data. It can be a table (the library itself)
	if(!lua_isuserdata(state,1)) return 0;

	ScriptUserData* ud=(ScriptUserData*)lua_touserdata(state,1);

	if(ud){
	if(ud->data){
	#ifdef _DEBUG
	//It should be impossible unless there is a bug in code
	assert(ud->sig1==sig1 && ud->sig2==sig2 && ud->sig3==sig3 && ud->sig4==sig4);
	#endif
	//Unlink it
	if(ud->next) ud->next->prev=ud->prev;
	if(ud->prev) ud->prev->next=ud->next;
	else{
	ScriptUserClass* owner=static_cast<ScriptUserClass>(reinterpret_cast<T>(ud->data));
	owner->scriptUserDataHead=ud->next;
	}
	#ifdef _DEBUG
	printf("ScriptUserClass '%c%c%c%c' (%p) unlinked userdata: %p\n",
	sig1,sig2,sig3,sig4,
	static_cast<ScriptUserClass>(reinterpret_cast<T>(ud->data)),ud);
	#endif
	}

	ud->data=NULL;
	ud->next=NULL;
	ud->prev=NULL;
	}

	return 0;
	}

	- /** The 'operator==' (__eq) function.
	- */
	- static int checkEqualFunction(lua_State *state){
	+ //The 'operator==' (__eq) function.
	+ static int checkEqualFunction(lua_State* state){
	//Check if it's a user data. It can be a table (the library itself)
	if(!lua_isuserdata(state,1) \|\| !lua_isuserdata(state,2)) return 0;

	ScriptUserData* ud1=(ScriptUserData*)lua_touserdata(state,1);
	ScriptUserData* ud2=(ScriptUserData*)lua_touserdata(state,2);

	if(ud1!=NULL && ud2!=NULL){
	#ifdef _DEBUG
	//It should be impossible unless there is a bug in code
	assert(ud1->sig1==sig1 && ud1->sig2==sig2 && ud1->sig3==sig3 && ud1->sig4==sig4);
	assert(ud2->sig1==sig1 && ud2->sig2==sig2 && ud2->sig3==sig3 && ud2->sig4==sig4);
	#endif
	lua_pushboolean(state,ud1->data==ud2->data);
	return 1;
	}

	return 0;
	}
	};

	#endif

File Metadata

Mime Type: text/x-diff
Expires: Mon, Jun 15, 11:42 PM (2 w, 2 d ago)
Storage Engine: blob
Storage Format: Raw Data
Storage Handle: 72365
Default Alt Text: (32 KB)

No OneTemporaryActions

View Options

File Metadata

Event Timeline

No OneTemporary
Actions