*使用int做状态机key

1 files changed, 67 insertions, 67 deletions

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)