*去掉文件前缀je_

1 files changed, 0 insertions, 445 deletions

diff --git a/src/libjin/ai/je_state_machine.cpp b/src/libjin/ai/je_state_machine.cpp
deleted file mode 100644
index 6208265..0000000
--- a/src/libjin/ai/je_state_machine.cpp
+++ /dev/null
@@ -1,445 +0,0 @@
-#include "je_state_machine.h"
-
-#include "../utils/je_log.h"
-
-using namespace std;
-
-namespace JinEngine
-{
-    namespace AI
-    {
-
-        StateMachine::StateMachine(Mode mode, void* userdata)
-            : mCurrentState(0)
-            , mUserData(userdata)
-            , mMode(mode)
-        {
-            addState(0);
-        }
-
-        StateMachine::~StateMachine()
-        {
-        }
-
-        void StateMachine::invokeCallback(int from, int to)
-        {
-            if (mExitCallback != nullptr)                                              
-                mExitCallback(from, mUserData);
-            if (mTraslateCallback != nullptr)
-                mTraslateCallback(from, to, mUserData);
-            if (mEnterCallback != nullptr)                                                 
-                mEnterCallback(to, mUserData);
-            map<int, StateChangeCallback>::iterator it = mOnExitState.find(from);
-            if (it != mOnExitState.end())                                                  
-                it->second(mUserData);
-            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);
-            if (it != mOnEnterState.end())                                                 
-                it->second(mUserData);                                        
-        }
-
-        void StateMachine::stepwiseProcess()
-        {
-            map<int, State>::iterator it = mStates.find(mCurrentState);
-            if (it == mStates.end())
-            {
-                jin_log_error("The state [%d] is not exist.", mCurrentState);
-                return;
-            }
-            State& state = it->second;
-            for (int i = 0; i < state.transitions.size(); ++i)
-            {
-                Conditions conditions = state.transitions[i].conditions;
-                bool isActive = true;
-                for (int j = 0; j < conditions.conditions.size(); ++j)
-                {
-                    isActive &= processCondition(conditions.conditions[j]);
-                    if (!isActive)
-                        break;
-                }
-                if (isActive)
-                {
-                    // Traslate
-                    mCurrentState = state.transitions[i].state;
-                    invokeCallback(state.name, mCurrentState);
-                    break;
-                }
-            }
-            // Call update
-            if (mUpdateCallback != nullptr)
-                mUpdateCallback(mCurrentState, mUserData);
-            map<int, StateUpdateCallback>::iterator uit = mOnUpdateState.find(mCurrentState);
-            if (uit != mOnUpdateState.end())
-                uit->second(mUserData);
-        }
-
-        void StateMachine::iterativeProcess()
-        {
-            map<int, State>::iterator it = mStates.find(mCurrentState);
-            if (it == mStates.end())
-            {
-                jin_log_error("The state [%d] is not exist.", mCurrentState);
-                return;
-            }
-            State& state = it->second;
-            bool isActive = true;
-            for (int i = 0; i < state.transitions.size(); ++i)
-            {
-                Conditions conditions = state.transitions[i].conditions;
-                isActive = true;
-                for (int j = 0; j < conditions.conditions.size(); ++j)
-                {
-                    isActive &= processCondition(conditions.conditions[j]);
-                    if (!isActive)
-                        break; 
-                }
-                if (isActive)
-                {
-                    // Traslate
-                    mCurrentState = state.transitions[i].state;
-                    invokeCallback(state.name, mCurrentState);
-                    break;
-                }
-            }
-            // Call update
-            if (mUpdateCallback != nullptr)
-                mUpdateCallback(mCurrentState, mUserData);
-            map<int, StateUpdateCallback>::iterator uit = mOnUpdateState.find(mCurrentState);
-            if (uit != mOnUpdateState.end())
-                uit->second(mUserData);
-            // Recursive.
-            if(isActive)
-                return iterativeProcess();
-        }
-
-        void StateMachine::setMode(Mode mode)
-        {
-            mMode = mode;
-        }
-
-        void StateMachine::update()
-        {
-            switch (mMode)
-            {
-                case Mode::Iterative: iterativeProcess(); break;
-                case Mode::Stepwise: stepwiseProcess(); break;
-            }
-        }
-
-        bool StateMachine::processCondition(const Condition& condition)
-        {
-            map<int, Parameter>::iterator it = mParameters.find(condition.parameter);
-            if (it == mParameters.end())
-            {
-                jin_log_error("The parameter <%d> is not exist", condition.parameter);
-                return false; 
-            }
-            Parameter& p = it->second;
-            switch (p.type)
-            {
-                case ParameterType::Int: 
-                {
-                    int value = p.value._int;
-                    int cvalue = condition.value._int;
-                    bool is = false;
-                    is |= ((condition.expression & ParameterExpression::INT_GREATER) ? value > cvalue : false);
-                    is |= ((condition.expression & ParameterExpression::INT_EQUAL) ? value == cvalue : false);
-                    is |= ((condition.expression & ParameterExpression::INT_LESS) ? value < cvalue : false);
-                    return is;
-                }
-                case ParameterType::Float:
-                {
-                    float value = p.value._float;
-                    float cvalue = condition.value._float;
-                    bool is = false;
-                    is |= ((condition.expression & ParameterExpression::FLOAT_GREATER) ? value > cvalue : false);
-                    is |= ((condition.expression & ParameterExpression::FLOAT_EQUAL) ? value == cvalue : false);
-                    is |= ((condition.expression & ParameterExpression::FLOAT_LESS) ? value < cvalue : false);
-                    return is;
-                }
-                case ParameterType::Bool: 
-                {
-                    bool value = p.value._bool;
-                    bool cvalue = condition.value._bool;
-                    bool is = false;
-                    is |= ((condition.expression & ParameterExpression::BOOL_IS) ? value == cvalue : false);
-                    is |= ((condition.expression & ParameterExpression::BOOL_NOT) ? value != cvalue : false);
-                    return is;
-                }
-                case ParameterType::Trigger:
-                {
-                    bool is = p.value._trigger;
-                    // Close trigger.
-                    p.value._trigger = false;
-                    return is;
-                }
-            }
-            return false;
-        }
-
-        int StateMachine::getCurrentState()
-        {
-            return mCurrentState;
-        }
-
-        void StateMachine::addParameteri(int name)
-        {
-            if (mParameters.find(name) != mParameters.end())
-            {
-                jin_log_error("The parameter <%d> is already exist.", name);
-                return;
-            }
-            Parameter p; 
-            p.type = ParameterType::Int;
-            p.value._int = 0;
-            mParameters.insert(pair<int, Parameter>(name, p));
-        }
-
-        void StateMachine::addParameterf(int name)
-        {
-            if (mParameters.find(name) != mParameters.end())
-            {
-                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<int, Parameter>(name, p));
-        }
-
-        void StateMachine::addParameterb(int name)
-        {
-            if (mParameters.find(name) != mParameters.end())
-            {
-                jin_log_error("The parameter <%d> is already exist.", name);
-                return;
-            }
-            Parameter p;
-            p.type = ParameterType::Bool;
-            p.value._bool = false;
-            mParameters.insert(pair<int, Parameter>(name, p));
-        }
-
-        void StateMachine::addParametert(int name)
-        {
-            if (mParameters.find(name) != mParameters.end())
-            {
-                jin_log_error("The parameter <%d> is already exist.", name);
-                return;
-            }
-            Parameter p;
-            p.type = ParameterType::Trigger;
-            p.value._trigger = false;
-            mParameters.insert(pair<int, Parameter>(name, p));
-        }
-
-        void StateMachine::addState(int name)
-        {
-            if (mStates.find(name) != mStates.end())
-            {
-                jin_log_error("The state [%d] is already exist.", name);
-                return;
-            }
-            State state;
-            state.name = name; 
-            mStates.insert(pair<int, State>(name, state));
-        }
-
-        const char* StateMachine::parameterTypeString(ParameterType type)
-        {
-            switch (type)
-            {
-                case ParameterType::Int: return "int"; 
-                case ParameterType::Float: return "float"; 
-                case ParameterType::Bool: return "bool"; 
-                case ParameterType::Trigger: return "trigger"; 
-            }
-        }
-
-        void StateMachine::addTransition(int from, int to, const Conditions& conditions)
-        {
-            map<int, State>::iterator it;
-            it = mStates.find(from);
-            if (it == mStates.end())
-            {
-                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 [%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<int, Parameter>::iterator itp;
-                itp = mParameters.find(condition.parameter);
-                if (itp == mParameters.end())
-                {
-                    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 <%d> is a %s, but the transition gives a %s value."
-                        , condition.parameter, parameterTypeString(p.type), parameterTypeString(condition.type));
-                    return;
-                }
-            }
-            // Add transition.
-            Transition transition;
-            transition.conditions = conditions;
-            transition.state = to;
-            fromState.transitions.push_back(transition);
-        }
-
-        void StateMachine::setParameteri(int name, int value)
-        {
-            map<int, Parameter>::iterator it = mParameters.find(name);
-            if (it == mParameters.end())
-            {
-                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 <%d> is %s, but try to assign a int value to it", name, parameterTypeString(p.type));
-                return;
-            }
-            p.value._int = value;
-        }
-
-        void StateMachine::setParameterf(int name, float value)
-        {
-            map<int, Parameter>::iterator it = mParameters.find(name);
-            if (it == mParameters.end())
-            {
-                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 <%d> is %s, but try to assign a float value to it", name, parameterTypeString(p.type));
-                return;
-            }
-            p.value._float = value;
-        }
-
-        void StateMachine::setParameterb(int name, bool value)
-        {
-            map<int, Parameter>::iterator it = mParameters.find(name);
-            if (it == mParameters.end())
-            {
-                jin_log_error("The state %s is not exist.", name);
-                return;
-            }
-            Parameter& p = it->second;
-            if (p.type != ParameterType::Bool)
-            {
-                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(int name)
-        {
-            map<int, Parameter>::iterator it = mParameters.find(name);
-            if (it == mParameters.end())
-            {
-                jin_log_error("The state %s is not exist.", name);
-                return;
-            }
-            Parameter& p = it->second;
-            if (p.type != ParameterType::Trigger)
-            {
-                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(int name)
-        {
-            if (mStates.find(name) == mStates.end())
-            {
-                jin_log_error("The state [%d] is not exist.", name);
-                return;
-            }
-            mCurrentState = name;
-        }
-
-        void StateMachine::addEnterListener(int state, const StateChangeCallback& callback)
-        {
-            if (mOnEnterState.find(state) != mOnEnterState.end())
-            {
-                jin_log_error("The enter listener of [%d] is already exist.", state);
-                return;
-            }
-            mOnEnterState.insert(pair<int, StateChangeCallback>(state, callback));
-        }
-
-        void StateMachine::addUpdateListener(int state, const StateUpdateCallback& callback)
-        {
-            if (mOnUpdateState.find(state) != mOnUpdateState.end())
-            {
-                jin_log_error("The update listener of [%d] is already exist.", state);
-                return;
-            }
-            mOnUpdateState.insert(pair<int, StateUpdateCallback>(state, callback));
-        }
-
-        void StateMachine::addExitListener(int state, const StateChangeCallback& callback)
-        {
-            if (mOnExitState.find(state) != mOnExitState.end())
-            {
-                jin_log_error("The exit listener of [%d] is already exist.", state);
-                return;
-            }
-            mOnExitState.insert(pair<int, StateChangeCallback>(state, callback));
-        }
-
-        void StateMachine::addTranslateListener(int from, int to, const StateChangeCallback& callback)
-        {
-            if (mOnStateTranslate.find(pair<int, int>(from, to)) != mOnStateTranslate.end())
-            {
-                jin_log_error("The traslate listener of [%d] to [%d] is already exist.", from, to);
-                return;
-            }
-            pair<int, int> key(from, to);
-            mOnStateTranslate.insert(pair<pair<int, int>, StateTranslateCallback>(key, callback));
-        }
-
-        void StateMachine::setUpdateListener(const SingleStateCallback& callback)
-        {
-            mUpdateCallback = callback;
-        }
-
-        void StateMachine::setEnterListener(const SingleStateCallback& callback)
-        {
-            mEnterCallback = callback;
-        }
-
-        void StateMachine::setExitListener(const SingleStateCallback& callback)
-        {
-            mExitCallback = callback;
-        }
-
-        void StateMachine::setTranslateListener(const DoubleStateCallback& callback)
-        {
-            mTraslateCallback = callback;
-        }
-
-    } // namespace AI 
-} // namespace JinEngine
\ No newline at end of file