Modify file structure

src/strategy/rpg/NewRpgAction.cpp

@@ -0,0 +1,366 @@
+#include "NewRpgAction.h"
+
+#include <cmath>
+#include <cstdint>
+
+#include "NewRpgStrategy.h"
+#include "ObjectDefines.h"
+#include "ObjectGuid.h"
+#include "PathGenerator.h"
+#include "Player.h"
+#include "PlayerbotAI.h"
+#include "Playerbots.h"
+#include "Random.h"
+#include "RandomPlayerbotMgr.h"
+#include "Timer.h"
+#include "TravelMgr.h"
+#include "World.h"
+
+bool TellRpgStatusAction::Execute(Event event)
+{
+    std::string out = botAI->rpgInfo.ToString();
+    botAI->TellMasterNoFacing(out);
+    return true;
+}
+
+bool NewRpgStatusUpdateAction::Execute(Event event)
+{
+    NewRpgInfo& info = botAI->rpgInfo;
+    switch (info.status)
+    {
+        case NewRpgStatus::IDLE:
+        {
+            uint32 roll = urand(1, 100);
+            // IDLE -> NEAR_NPC
+            // if ((!info.lastNearNpc || info.lastNearNpc + setNpcInterval < getMSTime()) && roll <= 30)
+            if (roll <= 40)
+            {
+                info.lastNearNpc = getMSTime();
+                GuidVector possibleTargets = AI_VALUE(GuidVector, "possible rpg targets");
+                if (!possibleTargets.empty())
+                {
+                    info.status = NewRpgStatus::NEAR_NPC;
+                    return true;
+                }
+            }
+            // IDLE -> GO_INNKEEPER
+            else if (bot->GetLevel() >= 6 && roll <= 50)
+            {
+                WorldPosition pos = SelectRandomInnKeeperPos();
+                if (pos != WorldPosition() && bot->GetExactDist(pos) > 50.0f)
+                {
+                    info.lastGoInnKeeper = getMSTime();
+                    info.status = NewRpgStatus::GO_INNKEEPER;
+                    info.innKeeperPos = pos;
+                    return true;
+                }
+            }
+            // IDLE -> GO_GRIND
+            else if (roll <= 90)
+            {
+                WorldPosition pos = SelectRandomGrindPos();
+                if (pos != WorldPosition())
+                {
+                    info.lastGoGrind = getMSTime();
+                    info.status = NewRpgStatus::GO_GRIND;
+                    info.grindPos = pos;
+                    return true;
+                }
+            }
+            // IDLE -> REST
+            info.status = NewRpgStatus::REST;
+            info.lastRest = getMSTime();
+            bot->SetStandState(UNIT_STAND_STATE_SIT);
+            return true;
+        }
+        case NewRpgStatus::GO_GRIND:
+        {
+            WorldPosition& originalPos = info.grindPos;
+            assert(info.grindPos != WorldPosition());
+            // GO_GRIND -> NEAR_RANDOM
+            if (bot->GetExactDist(originalPos) < 10.0f)
+            {
+                info.status = NewRpgStatus::NEAR_RANDOM;
+                info.lastNearRandom = getMSTime();
+                info.grindPos = WorldPosition();
+                return true;
+            }
+            // // just choose another grindPos
+            // if (!info.lastGoGrind || info.lastGoGrind + setGrindInterval < getMSTime())
+            // {
+            //     WorldPosition pos = SelectRandomGrindPos();
+            //     if (pos == WorldPosition())
+            //         break;
+            //     info.status = NewRpgStatus::GO_GRIND;
+            //     info.lastGoGrind = getMSTime();
+            //     info.grindPos = pos;
+            //     return true;
+            // }
+            break;
+        }
+        case NewRpgStatus::GO_INNKEEPER:
+        {
+            WorldPosition& originalPos = info.innKeeperPos;
+            assert(info.innKeeperPos != WorldPosition());
+            // GO_INNKEEPER -> NEAR_NPC
+            if (bot->GetExactDist(originalPos) < 10.0f)
+            {
+                info.lastNearNpc = getMSTime();
+                info.status = NewRpgStatus::NEAR_NPC;
+                info.innKeeperPos = WorldPosition();
+                return true;
+            }
+            break;
+        }
+        case NewRpgStatus::NEAR_RANDOM:
+        {
+            // NEAR_RANDOM -> IDLE
+            if (info.lastNearRandom + statusNearRandomDuration < getMSTime())
+            {
+                info.status = NewRpgStatus::IDLE;
+                return true;
+            }
+            break;
+        }
+        case NewRpgStatus::NEAR_NPC:
+        {
+            if (info.lastNearNpc + statusNearNpcDuration < getMSTime())
+            {
+                info.status = NewRpgStatus::IDLE;
+                return true;
+            }
+            break;
+        }
+        case NewRpgStatus::REST:
+        {
+            // REST -> IDLE
+            if (info.lastRest + statusRestDuration < getMSTime())
+            {
+                info.status = NewRpgStatus::IDLE;
+                return true;
+            }
+            break;
+        }
+        default:
+            break;
+    }
+    return false;
+}
+
+WorldPosition NewRpgStatusUpdateAction::SelectRandomGrindPos()
+{
+    const std::vector<WorldLocation>& locs = sRandomPlayerbotMgr->locsPerLevelCache[bot->GetLevel()];
+    std::vector<WorldLocation> lo_prepared_locs, hi_prepared_locs;
+    for (auto& loc : locs)
+    {
+        if (bot->GetMapId() != loc.GetMapId())
+            continue;
+
+        if (bot->GetExactDist(loc) < 500.0f)
+        {
+            hi_prepared_locs.push_back(loc);
+        }
+
+        if (bot->GetExactDist(loc) < 1500.0f)
+        {
+            lo_prepared_locs.push_back(loc);
+        }
+    }
+    WorldPosition dest;
+    if (urand(1, 100) <= 50 && !hi_prepared_locs.empty())
+    {
+        uint32 idx = urand(0, hi_prepared_locs.size() - 1);
+        dest = hi_prepared_locs[idx];
+    }
+    else if (!lo_prepared_locs.empty())
+    {
+        uint32 idx = urand(0, lo_prepared_locs.size() - 1);
+        dest = lo_prepared_locs[idx];
+    }
+    LOG_DEBUG("playerbots", "[New Rpg] Bot {} select random grind pos Map:{} X:{} Y:{} Z:{} ({}+{} available in {})",
+             bot->GetName(), dest.GetMapId(), dest.GetPositionX(), dest.GetPositionY(), dest.GetPositionZ(),
+             hi_prepared_locs.size(), lo_prepared_locs.size() - hi_prepared_locs.size(), locs.size());
+    return dest;
+}
+
+WorldPosition NewRpgStatusUpdateAction::SelectRandomInnKeeperPos()
+{
+    const std::vector<WorldLocation>& locs = IsAlliance(bot->getRace())
+                                                 ? sRandomPlayerbotMgr->allianceStarterPerLevelCache[bot->GetLevel()]
+                                                 : sRandomPlayerbotMgr->hordeStarterPerLevelCache[bot->GetLevel()];
+    std::vector<WorldLocation> prepared_locs;
+    for (auto& loc : locs)
+    {
+        if (bot->GetMapId() != loc.GetMapId())
+            continue;
+        
+        float range = bot->GetLevel() <= 5 ? 500.0f : 2500.0f;
+        if (bot->GetExactDist(loc) < range)
+        {
+            prepared_locs.push_back(loc);
+        }
+    }
+    WorldPosition dest;
+    if (!prepared_locs.empty())
+    {
+        uint32 idx = urand(0, prepared_locs.size() - 1);
+        dest = prepared_locs[idx];
+    }
+    LOG_DEBUG("playerbots", "[New Rpg] Bot {} select random inn keeper pos Map:{} X:{} Y:{} Z:{} ({} available in {})",
+             bot->GetName(), dest.GetMapId(), dest.GetPositionX(), dest.GetPositionY(), dest.GetPositionZ(),
+             prepared_locs.size(), locs.size());
+    return dest;
+}
+
+bool NewRpgGoFarAwayPosAction::MoveFarTo(WorldPosition dest)
+{
+    float dis = bot->GetExactDist(dest);
+    if (dis < pathFinderDis)
+    {
+        return MoveTo(dest.getMapId(), dest.GetPositionX(), dest.GetPositionY(), dest.GetPositionZ());
+    }
+
+    float minDelta = M_PI;
+    const float x = bot->GetPositionX();
+    const float y = bot->GetPositionY();
+    const float z = bot->GetPositionZ();
+    float rx, ry, rz;
+    bool found = false;
+    int attempt = 5;
+    while (--attempt)
+    {
+        float angle = bot->GetAngle(&dest);
+        float delta = (rand_norm() - 0.5) * M_PI * 0.6;
+        angle += delta;
+        float dis = rand_norm() * pathFinderDis;
+        float dx = x + cos(angle) * dis;
+        float dy = y + sin(angle) * dis;
+        float dz = z;
+        PathGenerator path(bot);
+        path.CalculatePath(dx, dy, dz);
+        // bool canReach = bot->GetMap()->CanReachPositionAndGetValidCoords(bot, x, y, z, dx, dy, dz, false);
+        bool canReach = path.GetPathType() & PATHFIND_NORMAL;
+
+        if (canReach)
+        {
+            G3D::Vector3 endPos = path.GetPath().back();
+            found = true;
+            rx = endPos.x;
+            ry = endPos.y;
+            rz = endPos.z;
+            break;
+        }
+    }
+    if (found)
+    {
+        return MoveTo(bot->GetMapId(), rx, ry, rz, false, false, false, true);
+    }
+    // fallback to direct move
+    float angle = bot->GetAngle(&dest);
+    return MoveTo(bot->GetMapId(), x + cos(angle) * pathFinderDis, y + sin(angle) * pathFinderDis, z);
+}
+
+bool NewRpgGoGrindAction::Execute(Event event) { return MoveFarTo(botAI->rpgInfo.grindPos); }
+
+bool NewRpgGoInnKeeperAction::Execute(Event event) { return MoveFarTo(botAI->rpgInfo.innKeeperPos); }
+
+bool NewRpgMoveRandomAction::Execute(Event event)
+{
+    float distance = rand_norm() * moveStep;
+    Map* map = bot->GetMap();
+    const float x = bot->GetPositionX();
+    const float y = bot->GetPositionY();
+    const float z = bot->GetPositionZ();
+    int attempts = 5;
+    while (--attempts)
+    {
+        float angle = (float)rand_norm() * 2 * static_cast<float>(M_PI);
+        float dx = x + distance * cos(angle);
+        float dy = y + distance * sin(angle);
+        float dz = z;
+        if (!map->CheckCollisionAndGetValidCoords(bot, bot->GetPositionX(), bot->GetPositionY(), bot->GetPositionZ(),
+                                                  dx, dy, dz))
+            continue;
+
+        if (map->IsInWater(bot->GetPhaseMask(), dx, dy, dz, bot->GetCollisionHeight()))
+            continue;
+
+        bool moved = MoveTo(bot->GetMapId(), dx, dy, dz, false, false, false, true);
+        if (moved)
+            return true;
+    }
+
+    return false;
+}
+
+bool NewRpgMoveNpcAction::Execute(Event event)
+{
+    NewRpgInfo& info = botAI->rpgInfo;
+    if (!info.npcPos)
+    {
+        GuidVector possibleTargets = AI_VALUE(GuidVector, "possible rpg targets");
+        if (possibleTargets.empty())
+            return false;
+        int idx = urand(0, possibleTargets.size() - 1);
+        ObjectGuid guid = possibleTargets[idx];
+        Unit* unit = botAI->GetUnit(guid);
+        if (unit)
+        {
+            info.npcPos = GuidPosition(unit);
+            info.lastReachNpc = 0;
+        }
+        else
+            return false;
+    }
+
+    if (bot->GetDistance(info.npcPos) <= INTERACTION_DISTANCE)
+    {
+        if (!info.lastReachNpc)
+        {
+            info.lastReachNpc = getMSTime();
+            return true;
+        }
+
+        if (info.lastReachNpc && info.lastReachNpc + stayTime > getMSTime())
+            return false;
+
+        info.npcPos = GuidPosition();
+        info.lastReachNpc = 0;
+    }
+    else
+    {
+        assert(info.npcPos);
+        Unit* unit = botAI->GetUnit(info.npcPos);
+        if (!unit)
+            return false;
+        float x = unit->GetPositionX();
+        float y = unit->GetPositionY();
+        float z = unit->GetPositionZ();
+        float mapId = unit->GetMapId();
+        float angle = 0.f;
+        if (bot->IsWithinLOS(x, y, z))
+        {
+            if (!unit->isMoving())
+                angle = unit->GetAngle(bot) + (M_PI * irand(-25, 25) / 100.0);  // Closest 45 degrees towards the target
+            else
+                angle = unit->GetOrientation() +
+                        (M_PI * irand(-25, 25) / 100.0);  // 45 degrees infront of target (leading it's movement)
+        }
+        else
+            angle = 2 * M_PI * rand_norm();  // A circle around the target.
+        float rnd = rand_norm();
+        x += cos(angle) * INTERACTION_DISTANCE * rnd;
+        y += sin(angle) * INTERACTION_DISTANCE * rnd;
+        // bool exact = true;
+        if (!unit->GetMap()->CheckCollisionAndGetValidCoords(unit, unit->GetPositionX(), unit->GetPositionY(),
+                                                             unit->GetPositionZ(), x, y, z))
+        {
+            x = unit->GetPositionX();
+            y = unit->GetPositionY();
+            z = unit->GetPositionZ();
+            // exact = false;
+        }
+        return MoveTo(mapId, x, y, z, false, false, false, true);
+    }
+    return true;
+}

src/strategy/rpg/NewRpgAction.h

@@ -0,0 +1,78 @@
+#ifndef _PLAYERBOT_NEWRPGACTION_H
+#define _PLAYERBOT_NEWRPGACTION_H
+
+#include "Duration.h"
+#include "MovementActions.h"
+#include "NewRpgStrategy.h"
+#include "TravelMgr.h"
+#include "PlayerbotAI.h"
+
+class TellRpgStatusAction : public Action
+{
+public:
+    TellRpgStatusAction(PlayerbotAI* botAI) : Action(botAI, "rpg status") {}
+
+    bool Execute(Event event) override;
+};
+
+class NewRpgStatusUpdateAction : public Action
+{
+public:
+    NewRpgStatusUpdateAction(PlayerbotAI* botAI) : Action(botAI, "new rpg status update") {}
+    bool Execute(Event event) override;
+protected:
+    // const int32 setGrindInterval = 5 * 60 * 1000;
+    // const int32 setNpcInterval = 1 * 60 * 1000;
+    const int32 statusNearNpcDuration = 5 * 60 * 1000;
+    const int32 statusNearRandomDuration = 5 * 60 * 1000;
+    const int32 statusRestDuration = 2 * 60 * 1000;
+    WorldPosition SelectRandomGrindPos();
+    WorldPosition SelectRandomInnKeeperPos();
+};
+
+class NewRpgGoFarAwayPosAction : public MovementAction
+{
+public:
+    NewRpgGoFarAwayPosAction(PlayerbotAI* botAI, std::string name) : MovementAction(botAI, name) {}
+    // bool Execute(Event event) override;
+    bool MoveFarTo(WorldPosition dest);
+
+protected:
+    // WorldPosition dest;
+    float pathFinderDis = 70.0f; // path finder
+};
+
+class NewRpgGoGrindAction : public NewRpgGoFarAwayPosAction
+{
+public:
+    NewRpgGoGrindAction(PlayerbotAI* botAI) : NewRpgGoFarAwayPosAction(botAI, "new rpg go grind") {}
+    bool Execute(Event event) override;
+};
+
+class NewRpgGoInnKeeperAction : public NewRpgGoFarAwayPosAction
+{
+public:
+    NewRpgGoInnKeeperAction(PlayerbotAI* botAI) : NewRpgGoFarAwayPosAction(botAI, "new rpg go innkeeper") {}
+    bool Execute(Event event) override;
+};
+
+
+class NewRpgMoveRandomAction : public MovementAction
+{
+public:
+    NewRpgMoveRandomAction(PlayerbotAI* botAI) : MovementAction(botAI, "new rpg move random") {}
+    bool Execute(Event event) override;
+protected:
+    const float moveStep = 50.0f;
+};
+
+class NewRpgMoveNpcAction : public MovementAction
+{
+public:
+    NewRpgMoveNpcAction(PlayerbotAI* botAI) : MovementAction(botAI, "new rpg move npcs") {}
+    bool Execute(Event event) override;
+protected:
+    const uint32 stayTime = 8 * 1000;
+};
+
+#endif

src/strategy/rpg/NewRpgStrategy.cpp

@@ -0,0 +1,35 @@
+/*
+ * 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.
+ */
+
+#include "NewRpgStrategy.h"
+
+#include "Playerbots.h"
+
+NewRpgStrategy::NewRpgStrategy(PlayerbotAI* botAI) : Strategy(botAI) {}
+
+NextAction** NewRpgStrategy::getDefaultActions()
+{
+    return NextAction::array(0, new NextAction("new rpg status update", 5.0f), nullptr);
+}
+
+void NewRpgStrategy::InitTriggers(std::vector<TriggerNode*>& triggers)
+{
+    triggers.push_back(
+        new TriggerNode("go grind status", NextAction::array(0, new NextAction("new rpg go grind", 1.0f), nullptr)));
+    
+    triggers.push_back(
+        new TriggerNode("go innkeeper status", NextAction::array(0, new NextAction("new rpg go innkeeper", 1.0f), nullptr)));
+
+    triggers.push_back(
+        new TriggerNode("near random status", NextAction::array(0, new NextAction("new rpg move random", 1.0f), nullptr)));
+
+    triggers.push_back(
+        new TriggerNode("near npc status", NextAction::array(0, new NextAction("new rpg move npc", 1.0f), nullptr)));
+}
+
+void NewRpgStrategy::InitMultipliers(std::vector<Multiplier*>& multipliers)
+{
+    // multipliers.push_back(new RpgActionMultiplier(botAI));
+}

src/strategy/rpg/NewRpgStrategy.h

@@ -0,0 +1,98 @@
+/*
+ * 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_NEWRPGSTRATEGY_H
+#define _PLAYERBOT_NEWRPGSTRATEGY_H
+
+#include <cstdint>
+#include "Strategy.h"
+#include "TravelMgr.h"
+
+class PlayerbotAI;
+
+enum class NewRpgStatus
+{
+    // Going to far away place
+    GO_GRIND,
+    GO_INNKEEPER,
+    // Exploring nearby
+    NEAR_RANDOM,
+    NEAR_NPC,
+    // Taking a break
+    REST,
+    // Initial status
+    IDLE
+};
+
+struct NewRpgInfo
+{
+    NewRpgStatus status{NewRpgStatus::IDLE};
+    // NewRpgStatus::GO_GRIND
+    WorldPosition grindPos{};
+    uint32 lastGoGrind{0};
+    // NewRpgStatus::GO_INNKEEPER
+    WorldPosition innKeeperPos{};
+    uint32 lastGoInnKeeper{0};
+    // NewRpgStatus::NEAR_NPC
+    GuidPosition npcPos{};
+    uint32 lastNearNpc{0};
+    uint32 lastReachNpc{0};
+    // NewRpgStatus::NEAR_RANDOM
+    uint32 lastNearRandom{0};
+    // NewRpgStatus::REST
+    uint32 lastRest{0};
+
+    std::string ToString()
+    {
+        std::stringstream out;
+        out << "Status: ";
+        switch (status)
+        {
+            case NewRpgStatus::GO_GRIND:
+                out << "GO_GRIND";
+                out << "\nGrindPos: " << grindPos.GetMapId() << " " << grindPos.GetPositionX() << " " << grindPos.GetPositionY() << " " << grindPos.GetPositionZ();
+                out << "\nlastGoGrind: " << lastGoGrind;
+                break;
+            case NewRpgStatus::GO_INNKEEPER:
+                out << "GO_INNKEEPER";
+                out << "\nInnKeeperPos: " << innKeeperPos.GetMapId() << " " << innKeeperPos.GetPositionX() << " " << innKeeperPos.GetPositionY() << " " << innKeeperPos.GetPositionZ();
+                out << "\nlastGoInnKeeper: " << lastGoInnKeeper;
+                break;
+            case NewRpgStatus::NEAR_NPC:
+                out << "NEAR_NPC";
+                out << "\nNpcPos: " << npcPos.GetMapId() << " " << npcPos.GetPositionX() << " " << npcPos.GetPositionY() << " " << npcPos.GetPositionZ();
+                out << "\nlastNearNpc: " << lastNearNpc;
+                out << "\nlastReachNpc: " << lastReachNpc;
+                break;
+            case NewRpgStatus::NEAR_RANDOM:
+                out << "NEAR_RANDOM";
+                out << "\nlastNearRandom: " << lastNearRandom;
+                break;
+            case NewRpgStatus::IDLE:
+                out << "IDLE";
+                break;
+            case NewRpgStatus::REST:
+                out << "REST";
+                out << "\nlastRest: " << lastRest;
+                break;
+            default:
+                out << "UNKNOWN";
+        }
+        return out.str();
+    }
+};
+
+class NewRpgStrategy : public Strategy
+{
+public:
+    NewRpgStrategy(PlayerbotAI* botAI);
+
+    std::string const getName() override { return "new rpg"; }
+    NextAction** getDefaultActions() override;
+    void InitTriggers(std::vector<TriggerNode*>& triggers) override;
+    void InitMultipliers(std::vector<Multiplier*>& multipliers) override;
+};
+
+#endif

src/strategy/rpg/NewRpgTrigger.cpp

@@ -0,0 +1,4 @@
+#include "NewRpgTriggers.h"
+#include "PlayerbotAI.h"
+
+bool NewRpgStatusTrigger::IsActive() { return status == botAI->rpgInfo.status; }

src/strategy/rpg/NewRpgTriggers.h

@@ -0,0 +1,20 @@
+#ifndef _PLAYERBOT_NEWRPGTRIGGERS_H
+#define _PLAYERBOT_NEWRPGTRIGGERS_H
+
+#include "NewRpgStrategy.h"
+#include "Trigger.h"
+
+class NewRpgStatusTrigger : public Trigger
+{
+public:
+    NewRpgStatusTrigger(PlayerbotAI* botAI, NewRpgStatus status = NewRpgStatus::IDLE)
+        : Trigger(botAI, "new rpg status"), status(status)
+    {
+    }
+    bool IsActive() override;
+
+protected:
+    NewRpgStatus status;
+};
+
+#endif