Big update.

src/strategy/Engine.h

@@ -0,0 +1,127 @@
+/*
+ * Copyright (C) 2016+ AzerothCore <www.azerothcore.org>, released under GNU GPL v2 license, you may redistribute it and/or modify it under version 2 of the License, or (at your option), any later version.
+ */
+
+#ifndef _PLAYERBOT_ENGINE_H
+#define _PLAYERBOT_ENGINE_H
+
+#include "Multiplier.h"
+#include "Queue.h"
+#include "PlayerbotAIAware.h"
+#include "Strategy.h"
+#include "Trigger.h"
+
+#include <map>
+
+class Action;
+class ActionNode;
+class AiObjectContext;
+class Event;
+class NextAction;
+class PlayerbotAI;
+
+enum ActionResult
+{
+    ACTION_RESULT_UNKNOWN,
+    ACTION_RESULT_OK,
+    ACTION_RESULT_IMPOSSIBLE,
+    ACTION_RESULT_USELESS,
+    ACTION_RESULT_FAILED
+};
+
+class ActionExecutionListener
+{
+    public:
+        virtual ~ActionExecutionListener() { };
+
+        virtual bool Before(Action* action, Event event) = 0;
+        virtual bool AllowExecution(Action* action, Event event) = 0;
+        virtual void After(Action* action, bool executed, Event event) = 0;
+        virtual bool OverrideResult(Action* action, bool executed, Event event) = 0;
+};
+
+class ActionExecutionListeners : public ActionExecutionListener
+{
+    public:
+        virtual ~ActionExecutionListeners();
+
+        bool Before(Action* action, Event event) override;
+        bool AllowExecution(Action* action, Event event) override;
+        void After(Action* action, bool executed, Event event) override;
+        bool OverrideResult(Action* action, bool executed, Event event) override;
+
+        void Add(ActionExecutionListener* listener)
+        {
+            listeners.push_back(listener);
+        }
+
+        void Remove(ActionExecutionListener* listener)
+        {
+            listeners.remove(listener);
+        }
+
+    private:
+        std::list<ActionExecutionListener*> listeners;
+};
+
+class Engine : public PlayerbotAIAware
+{
+    public:
+        Engine(PlayerbotAI* botAI, AiObjectContext* factory);
+
+	    void Init();
+        void addStrategy(std::string const name);
+		void addStrategies(std::string first, ...);
+        bool removeStrategy(std::string const name);
+        bool HasStrategy(std::string const name);
+        void removeAllStrategies();
+        void toggleStrategy(std::string const name);
+        std::string const ListStrategies();
+        std::vector<std::string> GetStrategies();
+		bool ContainsStrategy(StrategyType type);
+		void ChangeStrategy(std::string const names);
+        std::string const GetLastAction() { return lastAction; }
+
+	    virtual bool DoNextAction(Unit*, uint32 depth = 0, bool minimal = false);
+	    ActionResult ExecuteAction(std::string const name, Event event = Event(), std::string const qualifier = "");
+
+        void AddActionExecutionListener(ActionExecutionListener* listener)
+        {
+            actionExecutionListeners.Add(listener);
+        }
+
+        void removeActionExecutionListener(ActionExecutionListener* listener)
+        {
+            actionExecutionListeners.Remove(listener);
+        }
+
+	    virtual ~Engine(void);
+
+        bool testMode;
+
+    private:
+        bool MultiplyAndPush(NextAction** actions, float forceRelevance, bool skipPrerequisites, Event event, const char* pushType);
+        void Reset();
+        void ProcessTriggers(bool minimal);
+        void PushDefaultActions();
+        void PushAgain(ActionNode* actionNode, float relevance, Event event);
+        ActionNode* CreateActionNode(std::string const name);
+        Action* InitializeAction(ActionNode* actionNode);
+        bool ListenAndExecute(Action* action, Event event);
+
+        void LogAction(char const* format, ...);
+        void LogValues();
+
+        ActionExecutionListeners actionExecutionListeners;
+
+    protected:
+	    Queue queue;
+	    std::vector<TriggerNode*> triggers;
+        std::vector<Multiplier*> multipliers;
+        AiObjectContext* aiObjectContext;
+        std::map<std::string, Strategy*> strategies;
+        float lastRelevance;
+        std::string lastAction;
+};
+
+#endif