v0.1.2

- setTimer, killTimer function added.
- New arguments reader added.
- Fixed various issues with using function reader.

lua_samp/CArgumentReader.cpp

@@ -4,6 +4,8 @@ ArgReader::ArgReader(lua_State *L)
 {
 	lua_VM = L;
 	argIndex = 1;
+	pendingFunctionRefOut = NULL;
+	pendingFunctionRef = -1;
 }
 
 ArgReader::~ArgReader()
@@ -105,12 +107,28 @@ void ArgReader::ReadBool(bool& boolVariable, bool defaultValue)
 	argIndex++;
 }
 
+#include "CUtility.h"
+void ArgReader::ReadArguments(CLuaArguments &luaArgumentsVariable)
+{
+	//CUtility::printf("ReadArguments called: %d - %d!", lua_type(lua_VM, 4), lua_gettop(lua_VM));
+	while (lua_type(lua_VM, argIndex) != LUA_TNONE)
+	{
+		CLuaArgument* argPointer = new CLuaArgument(lua_VM, argIndex);
+		luaArgumentsVariable.Add(argPointer);
+
+		argIndex++;
+	}
+}
+
 void ArgReader::ReadFunction(int& intVariable)
 {
 	int argType = lua_type(lua_VM, argIndex);
 	if (argType == LUA_TFUNCTION)
 	{
-		intVariable = luaL_ref(lua_VM, LUA_REGISTRYINDEX);
+		//lua_pushvalue(lua_VM, -1);
+		//intVariable = luaL_ref(lua_VM, LUA_REGISTRYINDEX);
+		pendingFunctionRefOut = &intVariable; //thanks to MTA
+		pendingFunctionRef = argIndex;
 		argIndex++;
 
 		return;
@@ -119,6 +137,21 @@ void ArgReader::ReadFunction(int& intVariable)
 	argIndex++;
 }
 
+void ArgReader::ReadFunctionComplete()
+{
+	if (pendingFunctionRef == -1)
+	{
+		CUtility::printf("CArgumentReader::ReadFunctionComplete called before CArgumentReader::ReadFunction.");
+		return;
+	}
+
+	lua_settop(lua_VM, pendingFunctionRef);
+	int ref = luaL_ref(lua_VM, LUA_REGISTRYINDEX);
+
+	*pendingFunctionRefOut = ref;
+	pendingFunctionRef = -1;
+}
+
 void ArgReader::ReadString(std::string& stringVariable, const char* defaultValue)
 {
 	//check if argument is string

lua_samp/CArgumentReader.h

@@ -2,7 +2,7 @@
 #define _ARGUMENT_READER_HEADER_
 
 #include <string>
-
+#include "CLuaArguments.h"
 extern "C"
 {
 #include "Lua_351/lua.h"
@@ -18,11 +18,15 @@ class ArgReader
 	void ReadNumber(int& intVariable, int defaultValue = NULL);
 	void ReadFloat(float& floatVariable, float defaultValue = NULL);
 	void ReadBool(bool& boolVariable, bool defaultValue = false);
+	void ReadArguments(CLuaArguments &luaArgumentsVariable);
 	void ReadFunction(int& intVariable);
+	void ReadFunctionComplete();
 	void ReadString(std::string& stringVariable, const char* defaultValue = NULL);
 
 	lua_State *lua_VM;
 	int argIndex;
+	int *pendingFunctionRefOut;
+	int pendingFunctionRef;
 };
 
 #endif

lua_samp/CLuaArgument.cpp

@@ -0,0 +1,37 @@
+#include "CLuaArgument.h"
+#include "CUtility.h"
+
+CLuaArgument::CLuaArgument(lua_State *L, int argIndex)
+{
+	argType = lua_type(L, argIndex);
+	switch (argType)
+	{
+		case LUA_TBOOLEAN:
+		{
+			argBoolean = !!lua_toboolean(L, argIndex);
+			break;
+		}
+		case LUA_TNUMBER:
+		{
+			argNumber = lua_tonumber(L, argIndex);
+			CUtility::printf("N: %d - %f", argIndex, argNumber);
+			break;
+		}
+		case LUA_TSTRING:
+		{
+			argString = lua_tostring(L, argIndex);
+			break;
+		}
+
+		default:
+		{
+			argType = 0;
+			break;
+		}
+	}
+}
+
+CLuaArgument::~CLuaArgument()
+{
+
+}

lua_samp/CLuaArgument.h

@@ -0,0 +1,26 @@
+#ifndef _LUA_ARGUMENT_HEADER_
+#define _LUA_ARGUMENT_HEADER_
+
+#include <string>
+extern "C"
+{
+#include "Lua_351/lua.h"
+}
+
+class CLuaArgument
+{
+public:
+	CLuaArgument(lua_State *L, int argIndex);
+	~CLuaArgument();
+	inline int GetType() { return argType; }
+	inline bool GetBoolean() { return argBoolean; }
+	inline lua_Number GetNumber() { return argNumber; }
+	inline std::string GetString() { return argString; }
+private:
+	int argType;
+	bool argBoolean;
+	lua_Number argNumber;
+	std::string argString;
+};
+
+#endif

lua_samp/CLuaArguments.cpp

@@ -0,0 +1,16 @@
+#include "CLuaArguments.h"
+
+void CLuaArguments::Add(CLuaArgument *arg)
+{
+	argumentsContainer.push_back(arg);
+}
+
+CLuaArguments::CLuaArguments()
+{
+
+}
+
+CLuaArguments::~CLuaArguments()
+{
+
+}

lua_samp/CLuaArguments.h

@@ -0,0 +1,19 @@
+#ifndef _LUA_ARGUMENTS_HEADER_
+#define _LUA_ARGUMENTS_HEADER_
+
+#include "CLuaArgument.h"
+#include <vector>
+
+class CLuaArguments
+{
+public:
+	CLuaArguments();
+	~CLuaArguments();
+	void Add(CLuaArgument *);
+	std::vector<CLuaArgument *> Get(void) { return argumentsContainer; }
+private:
+	std::vector<CLuaArgument *> argumentsContainer;
+	int teszt;
+};
+
+#endif

lua_samp/CLuaFunctions.cpp

@@ -1,5 +1,6 @@
 #include "CLuaFunctions.h"
 #include "CGlobalContainer.h"
+#include "CTimer.h"
 
 LUA_FUNCTION DisableFunction(lua_State *L)
 {
@@ -29,6 +30,7 @@ LUA_FUNCTION addEventHandler(lua_State *L)
 	ArgReader argReader(L);
 	argReader.ReadString(luaFunction);
 	argReader.ReadFunction(reference);
+	argReader.ReadFunctionComplete();
 
 	CContainer::LuaReference::Add(L, luaFunction, reference);
 	return 0;
@@ -42,12 +44,47 @@ LUA_FUNCTION addCommandHandler(lua_State *L)
 	ArgReader argReader(L);
 	argReader.ReadString(luaFunction);
 	argReader.ReadFunction(reference);
+	argReader.ReadFunctionComplete();
 
 	//CUtility::printf("OPCT: %s", luaFunction.c_str());
 	CContainer::LuaReference::Add(L, luaFunction, reference);
 	return 0;
 }
 
+LUA_FUNCTION setTimer(lua_State *L)
+{
+	int interval;
+	bool repeat;
+	int reference;
+	CLuaArguments *luaArgs = new CLuaArguments();
+	CUtility::printf("VM(1): %d", lua_gettop(L));
+
+	ArgReader argReader(L);
+	argReader.ReadNumber(interval);
+	argReader.ReadBool(repeat);
+	argReader.ReadFunction(reference);
+	argReader.ReadArguments(*luaArgs);
+	argReader.ReadFunctionComplete();
+
+	int timerid = CTimer::CreateTimer(interval, repeat, L, reference, luaArgs);
+	lua_pushnumber(L, timerid);
+
+	return 1;
+}
+
+LUA_FUNCTION killTimer(lua_State *L)
+{
+	int timerid;
+
+	ArgReader argReader(L);
+	argReader.ReadNumber(timerid);
+
+	bool success = CTimer::DeleteTimer(timerid, L);
+	lua_pushboolean(L, success);
+
+	return 1;
+}
+
 LUA_FUNCTION sendClientMessage(lua_State *L)
 {
 	int playerID;

lua_samp/CLuaFunctions.h

@@ -3,6 +3,7 @@
 
 #include <string>
 #include "CArgumentReader.h"
+#include "CLuaArguments.h"
 extern "C"
 {
 #include "Lua_351/lua.h"
@@ -20,6 +21,8 @@ namespace CLuaFunctions
 	int print(lua_State *L);
 	int addEventHandler(lua_State *L);
 	int addCommandHandler(lua_State *L);
+	int setTimer(lua_State *L);
+	int killTimer(lua_State *L);
 
 	//Functions - Util
 	int sendClientMessage(lua_State *L);

lua_samp/CLuaManager.cpp

@@ -1,5 +1,6 @@
 #include "CLuaManager.h"
 #include "CGlobalContainer.h"
+#include "CTimer.h"
 
 CLuaManager::CLuaManager(std::string rName, std::string scriptFile)
 {
@@ -13,6 +14,7 @@ CLuaManager::~CLuaManager()
 {
 	//CUtility::printf("CLuaManager destrcutor!");
 	CallInitExit("onScriptExit");
+	CTimer::DeleteLuaTimers(lua_VM);
 	//CContainer::LuaManager::Delete(lua_VM);
 }
 
@@ -452,6 +454,8 @@ void CLuaManager::RegisterFunctions(lua_State *L)
 	lua_register(L, "print", CLuaFunctions::print);
 	lua_register(L, "addEventHandler", CLuaFunctions::addEventHandler);
 	lua_register(L, "addCommandHandler", CLuaFunctions::addCommandHandler);
+	lua_register(L, "setTimer", CLuaFunctions::setTimer);
+	lua_register(L, "killTimer", CLuaFunctions::killTimer);
 
 	//Functions - Util
 	lua_register(L, "sendClientMessage", CLuaFunctions::sendClientMessage);