-PlayerbotAI implementation: Hooks (On update ai, on trigger check, on action execute), Methods (GetBot, GetAIValue, IsTriggerActive, ExecuteCommand)

Co-Authored-By: mostlikely4r <[email protected]>

Author: Niam5

BindingMap.h

@@ -249,6 +249,24 @@ struct UniqueObjectKey
     { }
 };
 
+#if defined ELUNA_PLAYERBOTS
+/*
+ * A `BindingMap` key type for event ID/String bindings
+ *   (currently just PlayerbotAI).
+ */
+template <typename T>
+struct StringKey
+{
+    T event_id;
+    std::string qualifier;
+
+    StringKey(T event_id, std::string qualifier) :
+        event_id(event_id),
+        qualifier(qualifier)
+    { }
+};
+#endif
+
 class hash_helper
 {
 public:
@@ -326,6 +344,18 @@ namespace std
         }
     };
 
+#if defined ELUNA_PLAYERBOTS
+    template<typename T>
+    struct equal_to < StringKey<T> >
+    {
+        bool operator()(StringKey<T> const& lhs, StringKey<T> const& rhs) const
+        {
+            return lhs.event_id == rhs.event_id
+                && (lhs.qualifier.empty() || rhs.qualifier.empty() || lhs.qualifier == rhs.qualifier);
+        }
+    };
+#endif
+
     template<typename T>
     struct hash < EventKey<T> >
     {
@@ -358,6 +388,19 @@ namespace std
             return hash_helper::hash(k.event_id, k.instance_id, k.guid);
         }
     };
+
+#if defined ELUNA_PLAYERBOTS
+    template<typename T>
+    struct hash < StringKey<T> >
+    {
+        typedef StringKey<T> argument_type;
+
+        hash_helper::result_type operator()(argument_type const& k) const
+        {
+            return hash_helper::hash(k.event_id, k.qualifier);
+        }
+    };
+#endif
 }
 
 #endif // _BINDING_MAP_H

ElunaIncludes.h

@@ -120,6 +120,10 @@
 #endif
 #endif
 
+#if defined ELUNA_PLAYERBOTS
+#include "playerbot/PlayerbotAI.h"
+#endif
+
 #if !defined ELUNA_MANGOS
 #if ELUNA_EXPANSION > EXP_CLASSIC
 typedef Opcodes OpcodesList;

ElunaTemplate.cpp

@@ -24,6 +24,9 @@ ElunaConstrainedObjectRef<BattleGround> GetWeakPtrFor(BattleGround const* obj) {
 ElunaConstrainedObjectRef<Group> GetWeakPtrFor(Group const* obj) { return { obj->GetWeakPtr(), nullptr }; }
 ElunaConstrainedObjectRef<Guild> GetWeakPtrFor(Guild const* obj) { return { obj->GetWeakPtr(), nullptr }; }
 ElunaConstrainedObjectRef<Map> GetWeakPtrFor(Map const* obj) { return { obj->GetWeakPtr(), obj }; }
+#if defined ELUNA_PLAYERBOTS
+ElunaConstrainedObjectRef<PlayerbotAI> GetWeakPtrFor(PlayerbotAI const* obj) { return { obj->GetWeakPtr(), nullptr }; }
+#endif
 ElunaConstrainedObjectRef<Object> GetWeakPtrForObjectImpl(Object const* obj)
 {
     if (obj->isType(TYPEMASK_WORLDOBJECT))

ElunaTemplate.h

@@ -68,6 +68,9 @@ ElunaConstrainedObjectRef<Map> GetWeakPtrFor(Map const* obj);
 ElunaConstrainedObjectRef<Object> GetWeakPtrForObjectImpl(Object const* obj);
 ElunaConstrainedObjectRef<Quest> GetWeakPtrFor(Quest const* obj);
 ElunaConstrainedObjectRef<Spell> GetWeakPtrFor(Spell const* obj);
+#if defined ELUNA_PLAYERBOTS
+ElunaConstrainedObjectRef<PlayerbotAI> GetWeakPtrFor(PlayerbotAI const* obj);
+#endif
 #if ELUNA_EXPANSION >= EXP_WOTLK
 ElunaConstrainedObjectRef<Vehicle> GetWeakPtrFor(Vehicle const* obj);
 #endif

LuaEngine.cpp

@@ -57,6 +57,9 @@ eventMgr(NULL),
 
 ServerEventBindings(NULL),
 PlayerEventBindings(NULL),
+#if defined ELUNA_PLAYERBOTS
+PlayerbotAIEventBindings(NULL),
+#endif
 GuildEventBindings(NULL),
 GroupEventBindings(NULL),
 VehicleEventBindings(NULL),
@@ -181,6 +184,9 @@ void Eluna::CreateBindStores()
 
     ServerEventBindings      = new BindingMap< EventKey<Hooks::ServerEvents> >(L);
     PlayerEventBindings      = new BindingMap< EventKey<Hooks::PlayerEvents> >(L);
+#if defined ELUNA_PLAYERBOTS
+    PlayerbotAIEventBindings = new BindingMap< StringKey<Hooks::PlayerbotAIEvents> >(L);
+#endif
     GuildEventBindings       = new BindingMap< EventKey<Hooks::GuildEvents> >(L);
     GroupEventBindings       = new BindingMap< EventKey<Hooks::GroupEvents> >(L);
     VehicleEventBindings     = new BindingMap< EventKey<Hooks::VehicleEvents> >(L);
@@ -205,6 +211,9 @@ void Eluna::DestroyBindStores()
 {
     delete ServerEventBindings;
     delete PlayerEventBindings;
+#if defined ELUNA_PLAYERBOTS
+    delete PlayerbotAIEventBindings;
+#endif
     delete GuildEventBindings;
     delete GroupEventBindings;
     delete VehicleEventBindings;
@@ -226,6 +235,9 @@ void Eluna::DestroyBindStores()
 
     ServerEventBindings = NULL;
     PlayerEventBindings = NULL;
+#if defined ELUNA_PLAYERBOTS
+    PlayerbotAIEventBindings = NULL;
+#endif
     GuildEventBindings = NULL;
     GroupEventBindings = NULL;
     VehicleEventBindings = NULL;
@@ -732,7 +744,11 @@ static void createCancelCallback(Eluna* e, uint64 bindingID, BindingMap<K>* bind
 }
 
 // Saves the function reference ID given to the register type's store for given entry under the given event
-int Eluna::Register(uint8 regtype, uint32 entry, ObjectGuid guid, uint32 instanceId, uint32 event_id, int functionRef, uint32 shots)
+int Eluna::Register(uint8 regtype, uint32 entry, ObjectGuid guid, uint32 instanceId, uint32 event_id, int functionRef, uint32 shots
+#if defined ELUNA_PLAYERBOTS
+, std::string qualifier
+#endif
+)
 {
     uint64 bindingID;
 
@@ -768,6 +784,18 @@ int Eluna::Register(uint8 regtype, uint32 entry, ObjectGuid guid, uint32 instanc
             }
             break;
 
+#if defined ELUNA_PLAYERBOTS
+        case Hooks::REGTYPE_PLAYERBOTAI:
+            if (event_id < Hooks::PLAYERBOTAI_EVENT_COUNT)
+            {
+                auto key = StringKey<Hooks::PlayerbotAIEvents>((Hooks::PlayerbotAIEvents)event_id, qualifier);
+                bindingID = PlayerbotAIEventBindings->Insert(key, functionRef, shots);
+                createCancelCallback(this, bindingID, PlayerbotAIEventBindings);
+                return 1; // Stack: callback
+            }
+            break;
+#endif
+
         case Hooks::REGTYPE_GROUP:
             if (event_id < Hooks::GROUP_EVENT_COUNT)
             {

LuaEngine.h

@@ -100,6 +100,10 @@ typedef VehicleInfo Vehicle;
 #endif
 #endif
 
+#if defined ELUNA_PLAYERBOTS
+class PlayerbotAI;
+#endif
+
 struct lua_State;
 class EventMgr;
 class ElunaObject;
@@ -109,6 +113,9 @@ template<typename K> class BindingMap;
 template<typename T> struct EventKey;
 template<typename T> struct EntryKey;
 template<typename T> struct UniqueObjectKey;
+#if defined ELUNA_PLAYERBOTS
+template<typename T> struct StringKey;
+#endif
 
 struct LuaScript
 {
@@ -245,6 +252,9 @@ class ELUNA_GAME_API Eluna
 
     BindingMap< EventKey<Hooks::ServerEvents> >*     ServerEventBindings;
     BindingMap< EventKey<Hooks::PlayerEvents> >*     PlayerEventBindings;
+#if defined ELUNA_PLAYERBOTS
+    BindingMap< StringKey<Hooks::PlayerbotAIEvents> >* PlayerbotAIEventBindings;
+#endif
     BindingMap< EventKey<Hooks::GuildEvents> >*      GuildEventBindings;
     BindingMap< EventKey<Hooks::GroupEvents> >*      GroupEventBindings;
     BindingMap< EventKey<Hooks::VehicleEvents> >*    VehicleEventBindings;
@@ -333,7 +343,11 @@ class ELUNA_GAME_API Eluna
 #if !defined TRACKABLE_PTR_NAMESPACE
     uint64 GetCallstackId() const { return callstackid; }
 #endif
-    int Register(uint8 reg, uint32 entry, ObjectGuid guid, uint32 instanceId, uint32 event_id, int functionRef, uint32 shots);
+    int Register(uint8 reg, uint32 entry, ObjectGuid guid, uint32 instanceId, uint32 event_id, int functionRef, uint32 shots
+#if defined ELUNA_PLAYERBOTS
+    , std::string qualifier = ""
+#endif
+    );
     void UpdateEluna(uint32 diff);
 
     // Checks
@@ -513,6 +527,13 @@ class ELUNA_GAME_API Eluna
     void HandleGossipSelectOption(Player* pPlayer, uint32 menuId, uint32 sender, uint32 action, const std::string& code);
     void OnAchievementComplete(Player* pPlayer, uint32 achievementId);
 
+#if defined ELUNA_PLAYERBOTS
+    /* PlayerbotAI*/
+    void OnUpdateAI(PlayerbotAI* pPlayer, std::string botName);
+    void OnTriggerCheck(PlayerbotAI* ai, std::string triggerName, bool enabled);
+    void OnActionExecute(PlayerbotAI* ai, std::string action, bool success);
+#endif
+
 #if ELUNA_EXPANSION >= EXP_WOTLK
     /* Vehicle */
     void OnInstall(Vehicle* vehicle);

hooks/Hooks.h

@@ -73,6 +73,9 @@ namespace Hooks
         REGTYPE_PACKET,
         REGTYPE_SERVER,
         REGTYPE_PLAYER,
+#if defined ELUNA_PLAYERBOTS
+        REGTYPE_PLAYERBOTAI,
+#endif
         REGTYPE_GUILD,
         REGTYPE_GROUP,
         REGTYPE_CREATURE,
@@ -221,6 +224,16 @@ namespace Hooks
         PLAYER_EVENT_COUNT
     };
 
+#if defined ELUNA_PLAYERBOTS
+    enum PlayerbotAIEvents
+    {
+        PLAYERBOTAI_EVENT_ON_UPDATE_AI          =      1,       // (event, ai) - Qualifier: Bot name
+        PLAYERBOTAI_EVENT_ON_TRIGGER_CHECK      =      2,       // (event, ai, trigger, triggered) - Qualifier: Trigger
+        PLAYERBOTAI_EVENT_ON_ACTION_EXECUTE     =      3,       // (event, ai, action, executed) - Qualifier: Action
+        PLAYERBOTAI_EVENT_COUNT
+    };
+#endif
+
     enum GuildEvents
     {
         // Guild

hooks/PlayerbotAIHooks.cpp

@@ -0,0 +1,50 @@
+/*
+ * Copyright (C) 2010 - 2024 Eluna Lua Engine <https://elunaluaengine.github.io/>
+ * This program is free software licensed under GPL version 3
+ * Please see the included DOCS/LICENSE.md for more information
+ */
+
+#if defined ELUNA_PLAYERBOTS
+#include "Hooks.h"
+#include "HookHelpers.h"
+#include "LuaEngine.h"
+#include "BindingMap.h"
+#include "ElunaIncludes.h"
+#include "ElunaTemplate.h"
+#include "ElunaLoader.h"
+
+using namespace Hooks;
+
+#define START_HOOK(EVENT, QUALIFIER) \
+    auto key = StringKey<PlayerbotAIEvents>(EVENT, QUALIFIER);\
+    if (!PlayerbotAIEventBindings->HasBindingsFor(key))\
+        return;\
+
+#define START_HOOK_WITH_RETVAL(EVENT, QUALIFIER, RETVAL) \
+    auto key = String<PlayerbotAIEvents>(EVENT, QUALIFIER);\
+    if (!PlayerbotAIEventBindings->HasBindingsFor(key))\
+        return RETVAL;\
+   
+void Eluna::OnUpdateAI(PlayerbotAI* ai, std::string botName)
+{
+    START_HOOK(PLAYERBOTAI_EVENT_ON_UPDATE_AI, botName);
+    Push(ai);
+    CallAllFunctions(PlayerbotAIEventBindings, key);
+}
+void Eluna::OnTriggerCheck(PlayerbotAI* ai, std::string trigger, bool enabled)
+{
+    START_HOOK(PLAYERBOTAI_EVENT_ON_TRIGGER_CHECK, trigger);
+    Push(ai);
+    Push(trigger);
+    Push(enabled);
+    CallAllFunctions(PlayerbotAIEventBindings, key);
+}
+void Eluna::OnActionExecute(PlayerbotAI* ai, std::string action, bool success)
+{
+    START_HOOK(PLAYERBOTAI_EVENT_ON_ACTION_EXECUTE, action);
+    Push(ai);
+    Push(action);
+    Push(success);
+    CallAllFunctions(PlayerbotAIEventBindings, key);
+}
+#endif //ELUNA_PLAYERBOTS