aboutsummaryrefslogtreecommitdiff
path: root/src/libjin/ai
diff options
context:
space:
mode:
Diffstat (limited to 'src/libjin/ai')
-rw-r--r--src/libjin/ai/je_state_machine.cpp134
-rw-r--r--src/libjin/ai/je_state_machine.h66
2 files changed, 100 insertions, 100 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)
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;
generated by cgit v1.1-26-g67d0 at 2025-05-30 02:38:29 +0000