aboutsummaryrefslogtreecommitdiff
path: root/src
diff options
context:
space:
mode:
Diffstat (limited to 'src')
-rw-r--r--src/3rdparty/buildvm/buildvm.exebin123392 -> 121856 bytes
-rw-r--r--src/3rdparty/minilua/minilua.exebin219136 -> 209920 bytes
-rw-r--r--src/libjin/Time/je_timer.cpp2
-rw-r--r--src/libjin/Utils/je_log.cpp10
-rw-r--r--src/libjin/ai/je_state_machine.cpp134
-rw-r--r--src/libjin/ai/je_state_machine.h66
-rw-r--r--src/lua/common/je_lua_function.cpp45
-rw-r--r--src/lua/common/je_lua_function.h46
-rw-r--r--src/lua/common/je_lua_reference.cpp31
-rw-r--r--src/lua/common/je_lua_reference.h27
-rw-r--r--src/lua/modules/ai/je_lua_state_machine.cpp10
-rw-r--r--src/lua/modules/time/je_lua_timer.cpp51
12 files changed, 264 insertions, 158 deletions
diff --git a/src/3rdparty/buildvm/buildvm.exe b/src/3rdparty/buildvm/buildvm.exe
index 493ffc0..9cacff6 100644
--- a/src/3rdparty/buildvm/buildvm.exe
+++ b/src/3rdparty/buildvm/buildvm.exe
Binary files differ
diff --git a/src/3rdparty/minilua/minilua.exe b/src/3rdparty/minilua/minilua.exe
index 96c032d..512e93b 100644
--- a/src/3rdparty/minilua/minilua.exe
+++ b/src/3rdparty/minilua/minilua.exe
Binary files differ
diff --git a/src/libjin/Time/je_timer.cpp b/src/libjin/Time/je_timer.cpp
index 3315abf..a3edca7 100644
--- a/src/libjin/Time/je_timer.cpp
+++ b/src/libjin/Time/je_timer.cpp
@@ -88,7 +88,7 @@ namespace JinEngine
Timer::Handler::~Handler()
{
- if (finishCallback)
+ if (finishCallback != nullptr)
finishCallback(paramters);
}
diff --git a/src/libjin/Utils/je_log.cpp b/src/libjin/Utils/je_log.cpp
index 1704ce3..e369e14 100644
--- a/src/libjin/Utils/je_log.cpp
+++ b/src/libjin/Utils/je_log.cpp
@@ -16,19 +16,19 @@ void Loghelper::log(Level _level, const char* _fmt, ...)
switch (_level)
{
case LV_ERROR:
- levelStr = "[Jin internal error]: ";
+ levelStr = "[Jin Error]: ";
break;
case LV_WARNING:
- levelStr = "[Jin internal warning]: ";
+ levelStr = "[Jin Warning]: ";
break;
case LV_INFO:
- levelStr = "[Jin internal info]: ";
+ levelStr = "[Jin Info]: ";
break;
case LV_DEBUG:
- levelStr = "[Jin internal debug]: ";
+ levelStr = "[Jin Debug]: ";
break;
default:
- levelStr = "[Jin internal unknow]: ";
+ levelStr = "[Jin Unknow]: ";
break;
}
char buffer[FORMAT_MSG_BUFFER_SIZE + 1] = { 0 };
diff --git a/src/libjin/ai/je_state_machine.cpp b/src/libjin/ai/je_state_machine.cpp
index 27b24a0..6208265 100644
--- a/src/libjin/ai/je_state_machine.cpp
+++ b/src/libjin/ai/je_state_machine.cpp
@@ -10,18 +10,18 @@ namespace JinEngine
{
StateMachine::StateMachine(Mode mode, void* userdata)
- : mCurrentState("Empty")
+ : mCurrentState(0)
, mUserData(userdata)
, mMode(mode)
{
- addState("Empty");
+ addState(0);
}
StateMachine::~StateMachine()
{
}
- void StateMachine::invokeCallback(const string& from, const string& to)
+ void StateMachine::invokeCallback(int from, int to)
{
if (mExitCallback != nullptr)
mExitCallback(from, mUserData);
@@ -29,11 +29,11 @@ namespace JinEngine
mTraslateCallback(from, to, mUserData);
if (mEnterCallback != nullptr)
mEnterCallback(to, mUserData);
- map<string, StateChangeCallback>::iterator it = mOnExitState.find(from);
+ map<int, StateChangeCallback>::iterator it = mOnExitState.find(from);
if (it != mOnExitState.end())
it->second(mUserData);
- map<pair<string, string>, StateTranslateCallback>::iterator transItr
- = mOnStateTranslate.find(pair<string, string>(from, to));
+ map<pair<int, int>, StateTranslateCallback>::iterator transItr
+ = mOnStateTranslate.find(pair<int, int>(from, to));
if (transItr != mOnStateTranslate.end())
transItr->second(mUserData);
it = mOnEnterState.find(to);
@@ -43,10 +43,10 @@ namespace JinEngine
void StateMachine::stepwiseProcess()
{
- map<string, State>::iterator it = mStates.find(mCurrentState);
+ map<int, State>::iterator it = mStates.find(mCurrentState);
if (it == mStates.end())
{
- jin_log_error("The state %s is not exist.", mCurrentState);
+ jin_log_error("The state [%d] is not exist.", mCurrentState);
return;
}
State& state = it->second;
@@ -71,17 +71,17 @@ namespace JinEngine
// Call update
if (mUpdateCallback != nullptr)
mUpdateCallback(mCurrentState, mUserData);
- map<string, StateUpdateCallback>::iterator uit = mOnUpdateState.find(mCurrentState);
+ map<int, StateUpdateCallback>::iterator uit = mOnUpdateState.find(mCurrentState);
if (uit != mOnUpdateState.end())
uit->second(mUserData);
}
void StateMachine::iterativeProcess()
{
- map<string, State>::iterator it = mStates.find(mCurrentState);
+ map<int, State>::iterator it = mStates.find(mCurrentState);
if (it == mStates.end())
{
- jin_log_error("The state %s is not exist.", mCurrentState);
+ jin_log_error("The state [%d] is not exist.", mCurrentState);
return;
}
State& state = it->second;
@@ -107,7 +107,7 @@ namespace JinEngine
// Call update
if (mUpdateCallback != nullptr)
mUpdateCallback(mCurrentState, mUserData);
- map<string, StateUpdateCallback>::iterator uit = mOnUpdateState.find(mCurrentState);
+ map<int, StateUpdateCallback>::iterator uit = mOnUpdateState.find(mCurrentState);
if (uit != mOnUpdateState.end())
uit->second(mUserData);
// Recursive.
@@ -131,10 +131,10 @@ namespace JinEngine
bool StateMachine::processCondition(const Condition& condition)
{
- map<string, Parameter>::iterator it = mParameters.find(condition.parameter);
+ map<int, Parameter>::iterator it = mParameters.find(condition.parameter);
if (it == mParameters.end())
{
- jin_log_error("The parameter %s is not exist", condition.parameter);
+ jin_log_error("The parameter <%d> is not exist", condition.parameter);
return false;
}
Parameter& p = it->second;
@@ -180,73 +180,73 @@ namespace JinEngine
return false;
}
- const string& StateMachine::getCurrentState()
+ int StateMachine::getCurrentState()
{
return mCurrentState;
}
- void StateMachine::addParameteri(const std::string& name)
+ void StateMachine::addParameteri(int name)
{
if (mParameters.find(name) != mParameters.end())
{
- jin_log_error("The parameter %s is already exist.", name);
+ jin_log_error("The parameter <%d> is already exist.", name);
return;
}
Parameter p;
p.type = ParameterType::Int;
p.value._int = 0;
- mParameters.insert(pair<string, Parameter>(name, p));
+ mParameters.insert(pair<int, Parameter>(name, p));
}
- void StateMachine::addParameterf(const std::string& name)
+ void StateMachine::addParameterf(int name)
{
if (mParameters.find(name) != mParameters.end())
{
- jin_log_error("The parameter %s is already exist.", name);
+ jin_log_error("The parameter <%d> is already exist.", name);
return;
}
Parameter p;
p.type = ParameterType::Float;
p.value._float = 0.0f;
- mParameters.insert(pair<string, Parameter>(name, p));
+ mParameters.insert(pair<int, Parameter>(name, p));
}
- void StateMachine::addParameterb(const std::string& name)
+ void StateMachine::addParameterb(int name)
{
if (mParameters.find(name) != mParameters.end())
{
- jin_log_error("The parameter %s is already exist.", name);
+ jin_log_error("The parameter <%d> is already exist.", name);
return;
}
Parameter p;
p.type = ParameterType::Bool;
p.value._bool = false;
- mParameters.insert(pair<string, Parameter>(name, p));
+ mParameters.insert(pair<int, Parameter>(name, p));
}
- void StateMachine::addParametert(const std::string& name)
+ void StateMachine::addParametert(int name)
{
if (mParameters.find(name) != mParameters.end())
{
- jin_log_error("The parameter %s is already exist.", name);
+ jin_log_error("The parameter <%d> is already exist.", name);
return;
}
Parameter p;
p.type = ParameterType::Trigger;
p.value._trigger = false;
- mParameters.insert(pair<string, Parameter>(name, p));
+ mParameters.insert(pair<int, Parameter>(name, p));
}
- void StateMachine::addState(const std::string& name)
+ void StateMachine::addState(int name)
{
if (mStates.find(name) != mStates.end())
{
- jin_log_error("The state %s is already exist.", name);
+ jin_log_error("The state [%d] is already exist.", name);
return;
}
State state;
state.name = name;
- mStates.insert(pair<string, State>(name, state));
+ mStates.insert(pair<int, State>(name, state));
}
const char* StateMachine::parameterTypeString(ParameterType type)
@@ -260,37 +260,37 @@ namespace JinEngine
}
}
- void StateMachine::addTransition(const std::string& from, const std::string& to, const Conditions& conditions)
+ void StateMachine::addTransition(int from, int to, const Conditions& conditions)
{
- map<string, State>::iterator it;
+ map<int, State>::iterator it;
it = mStates.find(from);
if (it == mStates.end())
{
- jin_log_error("The state %s is not exist.", from);
+ jin_log_error("The state [%d] is not exist.", from);
return;
}
State& fromState = it->second;
it = mStates.find(to);
if (it == mStates.end())
{
- jin_log_error("The state %s is not exist.", to);
+ jin_log_error("The state [%d] is not exist.", to);
return;
}
// Check condtion correctness.
for (int i = 0; i < conditions.conditions.size(); ++i)
{
const Condition& condition = conditions.conditions[i];
- map<string, Parameter>::iterator itp;
+ map<int, Parameter>::iterator itp;
itp = mParameters.find(condition.parameter);
if (itp == mParameters.end())
{
- jin_log_error("The parameter %s is not exist.", condition.parameter);
+ jin_log_error("The parameter <%d> is not exist.", condition.parameter);
return;
}
Parameter& p = itp->second;
if (p.type != condition.type)
{
- jin_log_error("The type of parameter %s is a %s, but the transition gives a %s value."
+ jin_log_error("The type of parameter <%d> is a %s, but the transition gives a %s value."
, condition.parameter, parameterTypeString(p.type), parameterTypeString(condition.type));
return;
}
@@ -302,43 +302,43 @@ namespace JinEngine
fromState.transitions.push_back(transition);
}
- void StateMachine::setParameteri(const std::string& name, int value)
+ void StateMachine::setParameteri(int name, int value)
{
- map<string, Parameter>::iterator it = mParameters.find(name);
+ map<int, Parameter>::iterator it = mParameters.find(name);
if (it == mParameters.end())
{
- jin_log_error("The state %s is not exist.", name);
+ jin_log_error("The state [%d] is not exist.", name);
return;
}
Parameter& p = it->second;
if (p.type != ParameterType::Int)
{
- jin_log_error("The type of parameter %s is %s, but try to assign a int value to it", name, parameterTypeString(p.type));
+ jin_log_error("The type of parameter <%d> is %s, but try to assign a int value to it", name, parameterTypeString(p.type));
return;
}
p.value._int = value;
}
- void StateMachine::setParameterf(const std::string& name, float value)
+ void StateMachine::setParameterf(int name, float value)
{
- map<string, Parameter>::iterator it = mParameters.find(name);
+ map<int, Parameter>::iterator it = mParameters.find(name);
if (it == mParameters.end())
{
- jin_log_error("The state %s is not exist.", name);
+ jin_log_error("The state [%d] is not exist.", name);
return;
}
Parameter& p = it->second;
if (p.type != ParameterType::Float)
{
- jin_log_error("The type of parameter %s is %s, but try to assign a float value to it", name, parameterTypeString(p.type));
+ jin_log_error("The type of parameter <%d> is %s, but try to assign a float value to it", name, parameterTypeString(p.type));
return;
}
p.value._float = value;
}
- void StateMachine::setParameterb(const std::string& name, bool value)
+ void StateMachine::setParameterb(int name, bool value)
{
- map<string, Parameter>::iterator it = mParameters.find(name);
+ map<int, Parameter>::iterator it = mParameters.find(name);
if (it == mParameters.end())
{
jin_log_error("The state %s is not exist.", name);
@@ -347,15 +347,15 @@ namespace JinEngine
Parameter& p = it->second;
if (p.type != ParameterType::Bool)
{
- jin_log_error("The type of parameter %s is %s, but try to assign a bool value to it", name, parameterTypeString(p.type));
+ jin_log_error("The type of parameter <%d> is %s, but try to assign a bool value to it", name, parameterTypeString(p.type));
return;
}
p.value._bool = value;
}
- void StateMachine::setParametert(const std::string& name)
+ void StateMachine::setParametert(int name)
{
- map<string, Parameter>::iterator it = mParameters.find(name);
+ map<int, Parameter>::iterator it = mParameters.find(name);
if (it == mParameters.end())
{
jin_log_error("The state %s is not exist.", name);
@@ -364,61 +364,61 @@ namespace JinEngine
Parameter& p = it->second;
if (p.type != ParameterType::Trigger)
{
- jin_log_error("The type of parameter %s is %s, but try to assign a trigger value to it", name, parameterTypeString(p.type));
+ jin_log_error("The type of parameter <%d> is %s, but try to assign a trigger value to it", name, parameterTypeString(p.type));
return;
}
p.value._trigger = true;
}
- void StateMachine::forceToState(const std::string& name)
+ void StateMachine::forceToState(int name)
{
if (mStates.find(name) == mStates.end())
{
- jin_log_error("The state %s is not exist.", name);
+ jin_log_error("The state [%d] is not exist.", name);
return;
}
mCurrentState = name;
}
- void StateMachine::addEnterListener(const std::string& state, const StateChangeCallback& callback)
+ void StateMachine::addEnterListener(int state, const StateChangeCallback& callback)
{
if (mOnEnterState.find(state) != mOnEnterState.end())
{
- jin_log_error("The enter listener of %s is already exist.", state);
+ jin_log_error("The enter listener of [%d] is already exist.", state);
return;
}
- mOnEnterState.insert(pair<string, StateChangeCallback>(state, callback));
+ mOnEnterState.insert(pair<int, StateChangeCallback>(state, callback));
}
- void StateMachine::addUpdateListener(const std::string& state, const StateUpdateCallback& callback)
+ void StateMachine::addUpdateListener(int state, const StateUpdateCallback& callback)
{
if (mOnUpdateState.find(state) != mOnUpdateState.end())
{
- jin_log_error("The update listener of %s is already exist.", state);
+ jin_log_error("The update listener of [%d] is already exist.", state);
return;
}
- mOnUpdateState.insert(pair<string, StateUpdateCallback>(state, callback));
+ mOnUpdateState.insert(pair<int, StateUpdateCallback>(state, callback));
}
- void StateMachine::addExitListener(const std::string& state, const StateChangeCallback& callback)
+ void StateMachine::addExitListener(int state, const StateChangeCallback& callback)
{
if (mOnExitState.find(state) != mOnExitState.end())
{
- jin_log_error("The exit listener of %s is already exist.", state);
+ jin_log_error("The exit listener of [%d] is already exist.", state);
return;
}
- mOnExitState.insert(pair<string, StateChangeCallback>(state, callback));
+ mOnExitState.insert(pair<int, StateChangeCallback>(state, callback));
}
- void StateMachine::addTranslateListener(const std::string& from, const std::string& to, const StateChangeCallback& callback)
+ void StateMachine::addTranslateListener(int from, int to, const StateChangeCallback& callback)
{
- if (mOnStateTranslate.find(pair<string, string>(from, to)) != mOnStateTranslate.end())
+ if (mOnStateTranslate.find(pair<int, int>(from, to)) != mOnStateTranslate.end())
{
- jin_log_error("The traslate listener of %s to %s is already exist.", from, to);
+ jin_log_error("The traslate listener of [%d] to [%d] is already exist.", from, to);
return;
}
- pair<string, string> key(from, to);
- mOnStateTranslate.insert(pair<pair<string, string>, StateTranslateCallback>(key, callback));
+ pair<int, int> key(from, to);
+ mOnStateTranslate.insert(pair<pair<int, int>, StateTranslateCallback>(key, callback));
}
void StateMachine::setUpdateListener(const SingleStateCallback& callback)
diff --git a/src/libjin/ai/je_state_machine.h b/src/libjin/ai/je_state_machine.h
index 6cd3f17..c928989 100644
--- a/src/libjin/ai/je_state_machine.h
+++ b/src/libjin/ai/je_state_machine.h
@@ -68,7 +68,7 @@ namespace JinEngine
///
struct Condition
{
- std::string parameter;
+ int parameter;
ParameterExpression expression;
ParameterType type;
ParameterValue value;
@@ -100,7 +100,7 @@ namespace JinEngine
conditions = condition.conditions;
}
- inline Conditions& andi(const std::string& parameter, ParameterExpression expression, int value)
+ inline Conditions& andi(int parameter, ParameterExpression expression, int value)
{
Condition condition;
condition.expression = expression;
@@ -111,7 +111,7 @@ namespace JinEngine
return *this;
}
- inline Conditions& andf(const std::string& parameter, ParameterExpression expression , float value)
+ inline Conditions& andf(int parameter, ParameterExpression expression , float value)
{
Condition condition;
condition.expression = expression;
@@ -122,7 +122,7 @@ namespace JinEngine
return *this;
}
- inline Conditions& andb(const std::string& parameter, ParameterExpression expression, bool value)
+ inline Conditions& andb(int parameter, ParameterExpression expression, bool value)
{
Condition condition;
condition.expression = expression;
@@ -133,7 +133,7 @@ namespace JinEngine
return *this;
}
- inline Conditions& andt(const std::string& parameter)
+ inline Conditions& andt(int parameter)
{
Condition condition;
condition.parameter = parameter;
@@ -165,12 +165,12 @@ namespace JinEngine
///
///
///
- typedef std::function<void(const std::string&, void*)> SingleStateCallback;
+ typedef std::function<void(int, void*)> SingleStateCallback;
///
///
///
- typedef std::function<void(const std::string&, const std::string, void*)> DoubleStateCallback;
+ typedef std::function<void(int, const int, void*)> DoubleStateCallback;
///
/// State machine constructor.
@@ -195,82 +195,82 @@ namespace JinEngine
///
/// Get current state name.
///
- const std::string& getCurrentState();
+ int getCurrentState();
///
/// Add a integer parameter.
///
- void addParameteri(const std::string& name);
+ void addParameteri(int name);
///
///
///
- void addParameterf(const std::string& name);
+ void addParameterf(int name);
///
///
///
- void addParameterb(const std::string& name);
+ void addParameterb(int name);
///
///
///
- void addParametert(const std::string& name);
+ void addParametert(int name);
///
/// Add a state.
///
- void addState(const std::string& name);
+ void addState(int name);
///
///
///
- void addTransition(const std::string& from, const std::string& to, const Conditions& conditions);
+ void addTransition(int from, int to, const Conditions& conditions);
///
/// Set parameter value.
///
- void setParameteri(const std::string& name, int value);
+ void setParameteri(int name, int value);
///
/// Set parameter value.
///
- void setParameterf(const std::string& name, float value);
+ void setParameterf(int name, float value);
///
/// Set parameter value.
///
- void setParameterb(const std::string& name, bool value);
+ void setParameterb(int name, bool value);
///
/// Set parameter value.
///
- void setParametert(const std::string& name);
+ void setParametert(int name);
///
/// Force change to state.
///
- void forceToState(const std::string& name);
+ void forceToState(int name);
///
///
///
- void addEnterListener(const std::string& state, const StateChangeCallback& callback);
+ void addEnterListener(int state, const StateChangeCallback& callback);
///
/// Call state update function.
///
- void addUpdateListener(const std::string& state, const StateUpdateCallback& callback);
+ void addUpdateListener(int state, const StateUpdateCallback& callback);
///
///
///
- void addExitListener(const std::string& state, const StateChangeCallback& callback);
+ void addExitListener(int state, const StateChangeCallback& callback);
///
///
///
- void addTranslateListener(const std::string& from, const std::string& to, const StateChangeCallback& callback);
+ void addTranslateListener(int from, int to, const StateChangeCallback& callback);
///
///
@@ -309,7 +309,7 @@ namespace JinEngine
struct Transition
{
Conditions conditions; ///< Condition to active transition.
- std::string state; ///< State to translate to.
+ int state; ///< State to translate to.
};
///
@@ -317,7 +317,7 @@ namespace JinEngine
///
struct State
{
- std::string name; ///< Name of state.
+ int name; ///< Name of state.
std::vector<Transition> transitions; ///< All transitions this state have.
};
@@ -343,32 +343,32 @@ namespace JinEngine
///
///
///
- void invokeCallback(const std::string& from, const std::string& to);
+ void invokeCallback(int from, int to);
///
/// All state this state machine keeps.
///
- std::map<std::string, State> mStates;
+ std::map<int, State> mStates;
///
///
///
- std::map<std::string, StateChangeCallback> mOnEnterState;
+ std::map<int, StateChangeCallback> mOnEnterState;
///
///
///
- std::map<std::string, StateUpdateCallback> mOnUpdateState;
+ std::map<int, StateUpdateCallback> mOnUpdateState;
///
///
///
- std::map<std::string, StateChangeCallback> mOnExitState;
+ std::map<int, StateChangeCallback> mOnExitState;
///
/// From first to second.
///
- std::map<std::pair<std::string, std::string>, StateTranslateCallback> mOnStateTranslate;
+ std::map<std::pair<int, int>, StateTranslateCallback> mOnStateTranslate;
///
///
@@ -393,12 +393,12 @@ namespace JinEngine
///
/// Current state.
///
- std::string mCurrentState;
+ int mCurrentState;
///
/// All parameters.
///
- std::map<std::string, Parameter> mParameters;
+ std::map<int, Parameter> mParameters;
Mode mMode;
diff --git a/src/lua/common/je_lua_function.cpp b/src/lua/common/je_lua_function.cpp
new file mode 100644
index 0000000..e202d99
--- /dev/null
+++ b/src/lua/common/je_lua_function.cpp
@@ -0,0 +1,45 @@
+#include "je_lua_function.h"
+
+namespace JinEngine
+{
+ namespace Lua
+ {
+
+ LuaFunc::LuaFunc(lua_State* L)
+ : mLuaFunc(nullptr)
+ , mParams(0)
+ , mL(L)
+ {
+ }
+
+ LuaFunc::~LuaFunc()
+ {
+ delete mLuaFunc;
+ for (auto p : mParams)
+ delete p;
+ }
+
+ void LuaFunc::setFunc(int i, uint nresults )
+ {
+ if (mLuaFunc != nullptr)
+ delete mLuaFunc;
+ mLuaFunc = new LuaRef(mL, i);
+ mNResults = nresults;
+ }
+
+ void LuaFunc::pushParam(int i)
+ {
+ mParams.push_back(new LuaRef(mL, i));
+ }
+
+ uint LuaFunc::call()
+ {
+ mLuaFunc->push();
+ for (auto p : mParams)
+ p->push();
+ luax_call(mL, mParams.size(), mNResults);
+ return mNResults;
+ }
+
+ }
+} \ No newline at end of file
diff --git a/src/lua/common/je_lua_function.h b/src/lua/common/je_lua_function.h
new file mode 100644
index 0000000..a2d5ccc
--- /dev/null
+++ b/src/lua/common/je_lua_function.h
@@ -0,0 +1,46 @@
+#ifndef __JIN_COMMON_FUNCTION_H
+#define __JIN_COMMON_FUNCTION_H
+
+#include <vector>
+
+#include "libjin/jin.h"
+#include "../luax.h"
+#include "je_lua_reference.h"
+
+namespace JinEngine
+{
+ namespace Lua
+ {
+
+ class LuaFunc
+ {
+ public:
+ LuaFunc(lua_State* L);
+ ~LuaFunc();
+
+ ///
+ ///
+ ///
+ void setFunc(int i, uint nresults);
+
+ ///
+ ///
+ ///
+ void pushParam(int i);
+
+ ///
+ ///
+ ///
+ uint call();
+
+ private:
+ LuaRef* mLuaFunc;
+ std::vector<LuaRef*> mParams;
+ lua_State* mL;
+ uint mNResults;
+ };
+
+ } // namespace Lua
+} // namespace JinEngine
+
+#endif // __JIN_COMMON_REFERENCE_H \ No newline at end of file
diff --git a/src/lua/common/je_lua_reference.cpp b/src/lua/common/je_lua_reference.cpp
new file mode 100644
index 0000000..90223de
--- /dev/null
+++ b/src/lua/common/je_lua_reference.cpp
@@ -0,0 +1,31 @@
+#include "je_lua_reference.h"
+
+namespace JinEngine
+{
+ namespace Lua
+ {
+
+ LuaRef::LuaRef(lua_State* L, int i)
+ : mL(L)
+ {
+ luax_pushvalue(mL, i);
+ mIndex = luax_ref(mL, LUA_REGISTRYINDEX);
+ }
+
+ LuaRef::~LuaRef()
+ {
+ unref();
+ }
+
+ void LuaRef::unref()
+ {
+ luax_unref(mL, LUA_REGISTRYINDEX, mIndex);
+ }
+
+ void LuaRef::push()
+ {
+ luax_rawgeti(mL, LUA_REGISTRYINDEX, mIndex);
+ }
+
+ }
+} \ No newline at end of file
diff --git a/src/lua/common/je_lua_reference.h b/src/lua/common/je_lua_reference.h
index 28c3bc3..bde61b6 100644
--- a/src/lua/common/je_lua_reference.h
+++ b/src/lua/common/je_lua_reference.h
@@ -12,33 +12,18 @@ namespace JinEngine
/// This class wraps the reference functionality built into Lua, which allows C++ code to refer to Lua
/// variables.
///
- class Reference
+ class LuaRef
{
public:
- Reference(lua_State* L, unsigned int i)
- : mL(L)
- {
- luax_pushvalue(mL, i);
- mIndex = luax_ref(mL, LUA_REGISTRYINDEX);
- }
-
- ~Reference()
- {
- unref();
- }
-
- void unref()
- {
- luax_unref(mL, LUA_REGISTRYINDEX, mIndex);
- }
+ LuaRef(lua_State* L, int i);
+ ~LuaRef();
+
+ void unref();
///
/// Push value onto the stack.
///
- void push()
- {
- luax_rawgeti(mL, LUA_REGISTRYINDEX, mIndex);
- }
+ void push();
private:
lua_State* const mL;
diff --git a/src/lua/modules/ai/je_lua_state_machine.cpp b/src/lua/modules/ai/je_lua_state_machine.cpp
index 9b95f43..82899b4 100644
--- a/src/lua/modules/ai/je_lua_state_machine.cpp
+++ b/src/lua/modules/ai/je_lua_state_machine.cpp
@@ -7,14 +7,14 @@ namespace JinEngine
{
namespace Lua
{
-
+
LUA_IMPLEMENT int l_addEnterCallback(lua_State* L)
{
- StateMachine* sm;
- sm->addEnterListener("", [](void* p) -> void{
+ //StateMachine* sm;
+ //sm->addEnterListener("", [](void* p) -> void{
-
- });
+ //
+ //});
return 0;
}
diff --git a/src/lua/modules/time/je_lua_timer.cpp b/src/lua/modules/time/je_lua_timer.cpp
index c79c16b..239d1dd 100644
--- a/src/lua/modules/time/je_lua_timer.cpp
+++ b/src/lua/modules/time/je_lua_timer.cpp
@@ -1,4 +1,5 @@
#include "../types.h"
+#include "lua/common/je_lua_function.h"
#include "lua/common/je_lua_common.h"
#include "je_lua_timer.h"
@@ -23,23 +24,21 @@ namespace JinEngine
delete param;
}
- Reference* func;
- Reference* param;
+ LuaRef* func;
+ LuaRef* param;
};
-#define TIMER_CALLBACK \
-[=](void* data)->void { \
- Callback* cbk = static_cast<Callback*>(data); \
- cbk->func->push(); \
- cbk->param->push(); \
- luax_call(L, 1, 0); \
-}
+ static Timer::TimerCallback Timer_Callback = [](void* data)->void
+ {
+ LuaFunc* func = static_cast<LuaFunc*>(data);
+ func->call();
+ };
-#define FINISH_CALLBACK \
-[=](void* data) { \
- Callback* cbk = static_cast<Callback*>(data); \
- delete cbk; \
-}
+ static Timer::FinishCallback Finish_Callback = [](void* data)->void
+ {
+ LuaFunc* func = static_cast<LuaFunc*>(data);
+ delete func;
+ };
LUA_IMPLEMENT inline SharedTimer checkTimer(lua_State* L)
{
@@ -53,10 +52,10 @@ namespace JinEngine
SharedTimer shared = checkTimer(L);
Timer* timer = shared.getObject();
float s = luax_checknumber(L, 2);
- Callback* callback = new Callback();
- callback->func = new Reference(L, 3);
- callback->param = new Reference(L, 4);
- Timer::Handler* handler = timer->every(s, TIMER_CALLBACK, callback, FINISH_CALLBACK);
+ LuaFunc* func = new LuaFunc(L);
+ func->setFunc(3, 0);
+ func->pushParam(4);
+ Timer::Handler* handler = timer->every(s, Timer_Callback, func, Finish_Callback);
Proxy* proxy = luax_newinstance(L, JIN_TIME_HANDLER);
proxy->bind(new Shared<Timer::Handler>(handler, JIN_TIME_HANDLER));
return 1;
@@ -68,10 +67,10 @@ namespace JinEngine
SharedTimer shared = checkTimer(L);
Timer* timer = shared.getObject();
float s = luax_checknumber(L, 2);
- Callback* callback = new Callback();
- callback->func = new Reference(L, 3);
- callback->param = new Reference(L, 4);
- Timer::Handler* handler = timer->after(s, TIMER_CALLBACK, callback, FINISH_CALLBACK);
+ LuaFunc* func = new LuaFunc(L);
+ func->setFunc(3, 0);
+ func->pushParam(4);
+ Timer::Handler* handler = timer->after(s, Timer_Callback, func, Finish_Callback);
Proxy* proxy = luax_newinstance(L, JIN_TIME_HANDLER);
proxy->bind(new Shared<Timer::Handler>(handler, JIN_TIME_HANDLER));
return 1;
@@ -84,10 +83,10 @@ namespace JinEngine
Timer* timer = shared.getObject();
float s = luax_checknumber(L, 2);
int count = luax_checkinteger(L, 3);
- Callback* callback = new Callback();
- callback->func = new Reference(L, 4);
- callback->param = new Reference(L, 5);
- Timer::Handler* handler = timer->repeat(s, count, TIMER_CALLBACK, callback, FINISH_CALLBACK);
+ LuaFunc* func = new LuaFunc(L);
+ func->setFunc(4, 0);
+ func->pushParam(5);
+ Timer::Handler* handler = timer->repeat(s, count, Timer_Callback, func, Finish_Callback);
Proxy* proxy = luax_newinstance(L, JIN_TIME_HANDLER);
proxy->bind(new Shared<Timer::Handler>(handler, JIN_TIME_HANDLER));
return 1;
generated by cgit v1.1-26-g67d0 at 2025-05-22 11:19:46 +0000