*修改状态机

7 files changed, 66 insertions, 49 deletions

diff --git a/src/libjin/Graphics/je_sprite.h b/src/libjin/Graphics/je_sprite.h
index a361be7..76ef30a 100644
--- a/src/libjin/Graphics/je_sprite.h
+++ b/src/libjin/Graphics/je_sprite.h
@@ -11,6 +11,19 @@ namespace JinEngine
 {
     namespace Graphics
     {
+        /** Determines position of the sprite in its bounds. */
+        enum SpriteAnchor
+        {
+            SA_TopLeft,
+            SA_TopCenter,
+            SA_TopRight,
+            SA_MiddleLeft,
+            SA_MiddleCenter,
+            SA_MiddleRight,
+            SA_BottomLeft,
+            SA_BottomCenter,
+            SA_BottomRight
+        };
 
         /// 
         /// A sprite is unit of rendering. Animation is based on sprite, but not texture or other graphic stuff.
diff --git a/src/libjin/Math/je_ellipse.cpp b/src/libjin/Math/je_ellipse.cpp
new file mode 100644
index 0000000..e69de29
--- /dev/null
+++ b/src/libjin/Math/je_ellipse.cpp
diff --git a/src/libjin/Math/je_ellipse.h b/src/libjin/Math/je_ellipse.h
new file mode 100644
index 0000000..e69de29
--- /dev/null
+++ b/src/libjin/Math/je_ellipse.h
diff --git a/src/libjin/Time/je_timer.h b/src/libjin/Time/je_timer.h
index 603cade..fabde28 100644
--- a/src/libjin/Time/je_timer.h
+++ b/src/libjin/Time/je_timer.h
@@ -4,6 +4,8 @@
 #if defined(jin_time)
 
 #include <vector>
+#include <functional>
+
 #include "SDL2/SDL.h"
 
 namespace JinEngine
@@ -18,7 +20,7 @@ namespace JinEngine
 		{
 		public:
 
-            typedef void(*TimerCallback)(void* prameters);
+            typedef std::function<void(void*)> TimerCallback;
 
             ///
             ///
diff --git a/src/libjin/ai/je_ai.h b/src/libjin/ai/je_ai.h
index be1d622..57debce 100644
--- a/src/libjin/ai/je_ai.h
+++ b/src/libjin/ai/je_ai.h
@@ -1,7 +1,10 @@
 #ifndef __JE_AI_H__
 #define __JE_AI_H__
 
+// Decision Making
 #include "je_state_machine.h"
 #include "je_behavior_tree.h"
 
+// 
+
 #endif
\ No newline at end of file
diff --git a/src/libjin/ai/je_state_machine.cpp b/src/libjin/ai/je_state_machine.cpp
index 7f1666c..27b24a0 100644
--- a/src/libjin/ai/je_state_machine.cpp
+++ b/src/libjin/ai/je_state_machine.cpp
@@ -29,10 +29,10 @@ namespace JinEngine
                 mTraslateCallback(from, to, mUserData);
             if (mEnterCallback != nullptr)                                                 
                 mEnterCallback(to, mUserData);
-            map<string, StateChangeCallback*>::iterator it = mOnExitState.find(from);
+            map<string, StateChangeCallback>::iterator it = mOnExitState.find(from);
             if (it != mOnExitState.end())                                                  
                 it->second(mUserData);
-            map<pair<string, string>, StateTranslateCallback*>::iterator transItr
+            map<pair<string, string>, StateTranslateCallback>::iterator transItr
                 = mOnStateTranslate.find(pair<string, string>(from, to));
             if (transItr != mOnStateTranslate.end())
                 transItr->second(mUserData);
@@ -71,7 +71,7 @@ namespace JinEngine
             // Call update
             if (mUpdateCallback != nullptr)
                 mUpdateCallback(mCurrentState, mUserData);
-            map<string, StateUpdateCallback*>::iterator uit = mOnUpdateState.find(mCurrentState);
+            map<string, StateUpdateCallback>::iterator uit = mOnUpdateState.find(mCurrentState);
             if (uit != mOnUpdateState.end())
                 uit->second(mUserData);
         }
@@ -107,7 +107,7 @@ namespace JinEngine
             // Call update
             if (mUpdateCallback != nullptr)
                 mUpdateCallback(mCurrentState, mUserData);
-            map<string, StateUpdateCallback*>::iterator uit = mOnUpdateState.find(mCurrentState);
+            map<string, StateUpdateCallback>::iterator uit = mOnUpdateState.find(mCurrentState);
             if (uit != mOnUpdateState.end())
                 uit->second(mUserData);
             // Recursive.
@@ -145,9 +145,9 @@ namespace JinEngine
                     int value = p.value._int;
                     int cvalue = condition.value._int;
                     bool is = false;
-                    is |= ((condition.expression & ParameterExpression::INT_BIGGER) ? value > cvalue : false);
+                    is |= ((condition.expression & ParameterExpression::INT_GREATER) ? value > cvalue : false);
                     is |= ((condition.expression & ParameterExpression::INT_EQUAL) ? value == cvalue : false);
-                    is |= ((condition.expression & ParameterExpression::INT_SMALLER) ? value < cvalue : false);
+                    is |= ((condition.expression & ParameterExpression::INT_LESS) ? value < cvalue : false);
                     return is;
                 }
                 case ParameterType::Float:
@@ -155,9 +155,9 @@ namespace JinEngine
                     float value = p.value._float;
                     float cvalue = condition.value._float;
                     bool is = false;
-                    is |= ((condition.expression & ParameterExpression::FLOAT_BIGGER) ? value > cvalue : false);
+                    is |= ((condition.expression & ParameterExpression::FLOAT_GREATER) ? value > cvalue : false);
                     is |= ((condition.expression & ParameterExpression::FLOAT_EQUAL) ? value == cvalue : false);
-                    is |= ((condition.expression & ParameterExpression::FLOAT_SMALLER) ? value < cvalue : false);
+                    is |= ((condition.expression & ParameterExpression::FLOAT_LESS) ? value < cvalue : false);
                     return is;
                 }
                 case ParameterType::Bool: 
@@ -380,37 +380,37 @@ namespace JinEngine
             mCurrentState = name;
         }
 
-        void StateMachine::addEnterListener(const std::string& state, StateChangeCallback* callback)
+        void StateMachine::addEnterListener(const std::string& state, const StateChangeCallback& callback)
         {
             if (mOnEnterState.find(state) != mOnEnterState.end())
             {
                 jin_log_error("The enter listener of %s is already exist.", state);
                 return;
             }
-            mOnEnterState.insert(pair<string, StateChangeCallback*>(state, callback));
+            mOnEnterState.insert(pair<string, StateChangeCallback>(state, callback));
         }
 
-        void StateMachine::addUpdateListener(const std::string& state, StateUpdateCallback* callback)
+        void StateMachine::addUpdateListener(const std::string& state, const StateUpdateCallback& callback)
         {
             if (mOnUpdateState.find(state) != mOnUpdateState.end())
             {
                 jin_log_error("The update listener of %s is already exist.", state);
                 return;
             }
-            mOnUpdateState.insert(pair<string, StateUpdateCallback*>(state, callback));
+            mOnUpdateState.insert(pair<string, StateUpdateCallback>(state, callback));
         }
 
-        void StateMachine::addExitListener(const std::string& state, StateChangeCallback* callback)
+        void StateMachine::addExitListener(const std::string& state, const StateChangeCallback& callback)
         {
             if (mOnExitState.find(state) != mOnExitState.end())
             {
                 jin_log_error("The exit listener of %s is already exist.", state);
                 return;
             }
-            mOnExitState.insert(pair<string, StateChangeCallback*>(state, callback));
+            mOnExitState.insert(pair<string, StateChangeCallback>(state, callback));
         }
 
-        void StateMachine::addTranslateListener(const std::string& from, const std::string& to, StateChangeCallback* callback)
+        void StateMachine::addTranslateListener(const std::string& from, const std::string& to, const StateChangeCallback& callback)
         {
             if (mOnStateTranslate.find(pair<string, string>(from, to)) != mOnStateTranslate.end())
             {
@@ -418,25 +418,25 @@ namespace JinEngine
                 return;
             }
             pair<string, string> key(from, to);
-            mOnStateTranslate.insert(pair<pair<string, string>, StateTranslateCallback*>(key, callback));
+            mOnStateTranslate.insert(pair<pair<string, string>, StateTranslateCallback>(key, callback));
         }
 
-        void StateMachine::setUpdateListener(SingleStateCallback* callback)
+        void StateMachine::setUpdateListener(const SingleStateCallback& callback)
         {
             mUpdateCallback = callback;
         }
 
-        void StateMachine::setEnterListener(SingleStateCallback* callback)
+        void StateMachine::setEnterListener(const SingleStateCallback& callback)
         {
             mEnterCallback = callback;
         }
 
-        void StateMachine::setExitListener(SingleStateCallback* callback)
+        void StateMachine::setExitListener(const SingleStateCallback& callback)
         {
             mExitCallback = callback;
         }
 
-        void StateMachine::setTranslateListener(DoubleStateCallback* callback)
+        void StateMachine::setTranslateListener(const DoubleStateCallback& callback)
         {
             mTraslateCallback = callback;
         }
diff --git a/src/libjin/ai/je_state_machine.h b/src/libjin/ai/je_state_machine.h
index f53137e..2921ecd 100644
--- a/src/libjin/ai/je_state_machine.h
+++ b/src/libjin/ai/je_state_machine.h
@@ -6,6 +6,7 @@
 
 #include <map>
 #include <vector>
+#include <functional>
 
 #include "../common/je_temporary.h"
 #include "../common/je_types.h"
@@ -28,12 +29,12 @@ namespace JinEngine
             ///
             enum ParameterExpression
             {
-                INT_BIGGER = 0x02,
-                INT_SMALLER = 0x04,
+                INT_GREATER = 0x02,
+                INT_LESS = 0x04,
                 INT_EQUAL = 0x08,
 
-                FLOAT_BIGGER = 0x10,
-                FLOAT_SMALLER = 0x20,
+                FLOAT_GREATER = 0x10,
+                FLOAT_LESS = 0x20,
                 FLOAT_EQUAL = 0x40,
 
                 BOOL_IS = 0x80,
@@ -150,27 +151,27 @@ namespace JinEngine
             ///
             ///
             ///
-            typedef void(StateChangeCallback)(void* userdata);
-
+            typedef std::function<void(void*)> StateChangeCallback;
+            
             ///
             ///
             ///
-            typedef void(StateUpdateCallback)(void* userdata);
+            typedef std::function<void(void*)> StateUpdateCallback;
 
             ///
             ///
             ///
-            typedef void(StateTranslateCallback)(void* userdata);
+            typedef std::function<void(void*)> StateTranslateCallback;
 
             ///
             ///
             ///
-            typedef void(SingleStateCallback)(const std::string& stateName, void* userdata);
+            typedef std::function<void(const std::string&, void*)> SingleStateCallback;
 
             ///
             ///
             ///
-            typedef void(DoubleStateCallback)(const std::string& stateFrom, const std::string& stateTo, void* userdata);
+            typedef std::function<void(const std::string&, const std::string, void*)> DoubleStateCallback;
 
             ///
             /// State machine constructor.
@@ -255,42 +256,42 @@ namespace JinEngine
             ///
             /// 
             ///
-            void addEnterListener(const std::string& state, StateChangeCallback* callback);
+            void addEnterListener(const std::string& state, const StateChangeCallback& callback);
 
             ///
             /// Call state update function.
             ///
-            void addUpdateListener(const std::string& state, StateUpdateCallback* callback);
+            void addUpdateListener(const std::string& state, const StateUpdateCallback& callback);
 
             ///
             ///
             ///
-            void addExitListener(const std::string& state, StateChangeCallback* callback);
+            void addExitListener(const std::string& state, const StateChangeCallback& callback);
 
             ///
             ///
             ///
-            void addTranslateListener(const std::string& from, const std::string& to, StateChangeCallback* callback);
+            void addTranslateListener(const std::string& from, const std::string& to, const StateChangeCallback& callback);
 
             ///
             ///
             ///
-            void setEnterListener(SingleStateCallback* callback);
+            void setEnterListener(const SingleStateCallback& callback);
 
             ///
             ///
             ///
-            void setUpdateListener(SingleStateCallback* callback);
+            void setUpdateListener(const SingleStateCallback& callback);
 
             ///
             ///
             ///
-            void setExitListener(SingleStateCallback* callback);
+            void setExitListener(const SingleStateCallback& callback);
 
             ///
             ///
             ///
-            void setTranslateListener(DoubleStateCallback* callback);
+            void setTranslateListener(const DoubleStateCallback& callback);
 
         private:
 
@@ -327,8 +328,6 @@ namespace JinEngine
             ///
             bool processCondition(const Condition& condition);
 
-            typedef void(Processor)(void*);
-
             ///
             ///
             ///
@@ -352,42 +351,42 @@ namespace JinEngine
             ///
             ///
             ///
-            std::map<std::string, StateChangeCallback*> mOnEnterState;
+            std::map<std::string, StateChangeCallback> mOnEnterState;
 
             ///
             ///
             ///
-            std::map<std::string, StateUpdateCallback*> mOnUpdateState;
+            std::map<std::string, StateUpdateCallback> mOnUpdateState;
 
             ///
             ///
             ///
-            std::map<std::string, StateChangeCallback*> mOnExitState;
+            std::map<std::string, StateChangeCallback> mOnExitState;
 
             ///
             /// From first to second.
             ///
-            std::map<std::pair<std::string, std::string>, StateTranslateCallback*> mOnStateTranslate;
+            std::map<std::pair<std::string, std::string>, StateTranslateCallback> mOnStateTranslate;
 
             ///
             ///
             ///
-            SingleStateCallback* mEnterCallback;
+            SingleStateCallback mEnterCallback;
 
             ///
             ///
             ///
-            SingleStateCallback* mUpdateCallback;
+            SingleStateCallback mUpdateCallback;
 
             ///
             ///
             ///
-            SingleStateCallback* mExitCallback;
+            SingleStateCallback mExitCallback;
             
             ///
             ///
             ///
-            DoubleStateCallback* mTraslateCallback;
+            DoubleStateCallback mTraslateCallback;
 
             ///
             /// Current state.