From 6ea696d8a14547516a7ec988ff266e0ee69a7f5a Mon Sep 17 00:00:00 2001 From: Yunfan Li Date: Sun, 3 Mar 2024 12:42:45 +0800 Subject: [PATCH 01/22] Playerbots.cpp (sync with core) --- src/Playerbots.cpp | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/Playerbots.cpp b/src/Playerbots.cpp index 58aa42223..d49d54b55 100644 --- a/src/Playerbots.cpp +++ b/src/Playerbots.cpp @@ -222,7 +222,7 @@ class PlayerbotsServerScript : public ServerScript public: PlayerbotsServerScript() : ServerScript("PlayerbotsServerScript") { } - void OnPacketReceived(WorldSession* session, WorldPacket& packet) override + void OnPacketReceived(WorldSession* session, WorldPacket const& packet) override { if (Player* player = session->GetPlayer()) if (PlayerbotMgr* playerbotMgr = GET_PLAYERBOT_MGR(player)) From 3db6f05eb77e1113fab12f4d8dbcca9d816b06dd Mon Sep 17 00:00:00 2001 From: Yunfan Li Date: Mon, 4 Mar 2024 17:13:05 +0800 Subject: [PATCH 02/22] Maintenance command --- conf/playerbots.conf.dist | 3 +++ src/PlayerbotAIConfig.cpp | 1 + src/PlayerbotAIConfig.h | 1 + src/PlayerbotFactory.cpp | 15 +++++++++---- src/PlayerbotFactory.h | 12 +++++----- src/strategy/actions/ChatActionContext.h | 2 ++ src/strategy/actions/TrainerAction.cpp | 22 +++++++++++++++++++ src/strategy/actions/TrainerAction.h | 6 +++++ .../generic/ChatCommandHandlerStrategy.cpp | 1 + src/strategy/paladin/PaladinTriggers.cpp | 4 ++-- src/strategy/triggers/ChatTriggerContext.h | 2 ++ 11 files changed, 58 insertions(+), 11 deletions(-) diff --git a/conf/playerbots.conf.dist b/conf/playerbots.conf.dist index e075affe2..e3cc07a83 100644 --- a/conf/playerbots.conf.dist +++ b/conf/playerbots.conf.dist @@ -155,6 +155,9 @@ AiPlayerbot.AutoInitEquipLevelLimitRatio = 1.0 # default: 1 (enable) AiPlayerbot.AddClassCommand = 1 +# Enable/Disable maintenance command, learn all available spells and skills, supplement consumables, repair, etc. +# default: 1 (enable) +AiPlayerbot.MaintenanceCommand = 1 # Automation diff --git a/src/PlayerbotAIConfig.cpp b/src/PlayerbotAIConfig.cpp index 5f940fe8c..e3b0f2bd8 100644 --- a/src/PlayerbotAIConfig.cpp +++ b/src/PlayerbotAIConfig.cpp @@ -259,6 +259,7 @@ bool PlayerbotAIConfig::Initialize() autoInitOnly = sConfigMgr->GetOption("AiPlayerbot.AutoInitOnly", false); autoInitEquipLevelLimitRatio = sConfigMgr->GetOption("AiPlayerbot.AutoInitEquipLevelLimitRatio", 1.0); addClassCommand = sConfigMgr->GetOption("AiPlayerbot.AddClassCommand", 1); + maintenanceCommand = sConfigMgr->GetOption("AiPlayerbot.MaintenanceCommand", 1); playerbotsXPrate = sConfigMgr->GetOption("AiPlayerbot.KillXPRate", 1); botActiveAlone = sConfigMgr->GetOption("AiPlayerbot.BotActiveAlone", 10); diff --git a/src/PlayerbotAIConfig.h b/src/PlayerbotAIConfig.h index 3a3982f66..2dc450d75 100644 --- a/src/PlayerbotAIConfig.h +++ b/src/PlayerbotAIConfig.h @@ -193,6 +193,7 @@ class PlayerbotAIConfig bool autoInitOnly; float autoInitEquipLevelLimitRatio; int32 addClassCommand; + int32 maintenanceCommand; std::string const GetTimestampStr(); bool hasLog(std::string const fileName) { return std::find(allowedLogFiles.begin(), allowedLogFiles.end(), fileName) != allowedLogFiles.end(); }; diff --git a/src/PlayerbotFactory.cpp b/src/PlayerbotFactory.cpp index 0e907336c..d719358a6 100644 --- a/src/PlayerbotFactory.cpp +++ b/src/PlayerbotFactory.cpp @@ -369,6 +369,7 @@ void PlayerbotFactory::Refresh() InitClassSpells(); InitAvailableSpells(); InitSkills(); + InitMounts(); bot->DurabilityRepairAll(false, 1.0f, false); if (bot->isDead()) bot->ResurrectPlayer(1.0f, false); @@ -1628,7 +1629,7 @@ inline Item* StoreNewItemInInventorySlot(Player* player, uint32 newItemId, uint3 // } // } -void PlayerbotFactory::InitBags() +void PlayerbotFactory::InitBags(bool destroyOld) { for (uint8 slot = INVENTORY_SLOT_BAG_START; slot < INVENTORY_SLOT_BAG_END; ++slot) { @@ -1641,9 +1642,12 @@ void PlayerbotFactory::InitBags() if (!CanEquipUnseenItem(slot, dest, newItemId)) continue; - if (old_bag) { + if (old_bag && destroyOld) { bot->DestroyItem(INVENTORY_SLOT_BAG_0, slot, true); } + if (old_bag) { + return; + } Item* newItem = bot->EquipNewItem(dest, newItemId, true); if (newItem) { @@ -2435,7 +2439,7 @@ void PlayerbotFactory::InitAmmo() uint32 entry = sRandomItemMgr->GetAmmo(level, subClass); uint32 count = bot->GetItemCount(entry); - uint32 maxCount = 10000; + uint32 maxCount = 5000; if (count < maxCount / 2) { @@ -2726,7 +2730,9 @@ void PlayerbotFactory::InitReagents() break; } for (std::pair item : items) { - StoreItem(item.first, item.second); + int count = (int)item.second - (int)bot->GetItemCount(item.first); + if (count > 0) + StoreItem(item.first, count); } } @@ -3233,6 +3239,7 @@ void PlayerbotFactory::ApplyEnchantTemplate(uint8 spec) bot->ApplyEnchantment(pItem, PERM_ENCHANTMENT_SLOT, true); } // botAI->EnchantItemT((*itr).SpellId, (*itr).SlotId); + // const SpellItemEnchantmentEntry* a = sSpellItemEnchantmentStore.LookupEntry(1); } std::vector PlayerbotFactory::GetPossibleInventoryTypeListBySlot(EquipmentSlots slot) { diff --git a/src/PlayerbotFactory.h b/src/PlayerbotFactory.h index b654dcd29..d3b1bb71c 100644 --- a/src/PlayerbotFactory.h +++ b/src/PlayerbotFactory.h @@ -126,6 +126,12 @@ class PlayerbotFactory void InitAmmo(); static uint32 CalcMixedGearScore(uint32 gs, uint32 quality); void InitPetTalents(); + + void InitReagents(); + void InitGlyphs(); + void InitFood(); + void InitMounts(); + void InitBags(bool destroyOld = true); private: void Prepare(); // void InitSecondEquipmentSet(); @@ -146,11 +152,8 @@ class PlayerbotFactory void ClearInventory(); void ClearAllItems(); void ResetQuests(); - void InitMounts(); void InitPotions(); - void InitFood(); - void InitReagents(); - void InitGlyphs(); + bool CanEquipArmor(ItemTemplate const* proto); bool CanEquipWeapon(ItemTemplate const* proto); void EnchantItem(Item* item); @@ -158,7 +161,6 @@ class PlayerbotFactory bool CheckItemStats(uint8 sp, uint8 ap, uint8 tank); void CancelAuras(); bool IsDesiredReplacement(Item* item); - void InitBags(); void InitInventory(); void InitInventoryTrade(); void InitInventoryEquip(); diff --git a/src/strategy/actions/ChatActionContext.h b/src/strategy/actions/ChatActionContext.h index a2faa1781..cec70a7e0 100644 --- a/src/strategy/actions/ChatActionContext.h +++ b/src/strategy/actions/ChatActionContext.h @@ -114,6 +114,7 @@ class ChatActionContext : public NamedObjectContext creators["nc"] = &ChatActionContext::nc; creators["de"] = &ChatActionContext::dead; creators["trainer"] = &ChatActionContext::trainer; + creators["maintenance"] = &ChatActionContext::maintenance; creators["attack my target"] = &ChatActionContext::attack_my_target; creators["chat"] = &ChatActionContext::chat; creators["home"] = &ChatActionContext::home; @@ -211,6 +212,7 @@ class ChatActionContext : public NamedObjectContext static Action* chat(PlayerbotAI* botAI) { return new ChangeChatAction(botAI); } static Action* attack_my_target(PlayerbotAI* botAI) { return new AttackMyTargetAction(botAI); } static Action* trainer(PlayerbotAI* botAI) { return new TrainerAction(botAI); } + static Action* maintenance(PlayerbotAI* botAI) { return new MaintenanceAction(botAI); } static Action* co(PlayerbotAI* botAI) { return new ChangeCombatStrategyAction(botAI); } static Action* nc(PlayerbotAI* botAI) { return new ChangeNonCombatStrategyAction(botAI); } static Action* dead(PlayerbotAI* botAI) { return new ChangeDeadStrategyAction(botAI); } diff --git a/src/strategy/actions/TrainerAction.cpp b/src/strategy/actions/TrainerAction.cpp index e77d5d397..f5c886170 100644 --- a/src/strategy/actions/TrainerAction.cpp +++ b/src/strategy/actions/TrainerAction.cpp @@ -5,6 +5,7 @@ #include "TrainerAction.h" #include "BudgetValues.h" #include "Event.h" +#include "PlayerbotFactory.h" #include "Playerbots.h" void TrainerAction::Learn(uint32 cost, TrainerSpell const* tSpell, std::ostringstream& msg) @@ -146,3 +147,24 @@ void TrainerAction::TellFooter(uint32 totalCost) botAI->TellMaster(out); } } + +bool MaintenanceAction::Execute(Event event) +{ + if (!sPlayerbotAIConfig->maintenanceCommand) + return false; + botAI->TellMaster("maintenance"); + PlayerbotFactory factory(bot, bot->GetLevel()); + factory.InitBags(false); + factory.InitAmmo(); + factory.InitFood(); + factory.InitReagents(); + factory.InitTalentsTree(true); + factory.InitPet(); + factory.InitPetTalents(); + factory.InitClassSpells(); + factory.InitAvailableSpells(); + factory.InitSkills(); + factory.InitMounts(); + bot->DurabilityRepairAll(false, 1.0f, false); + return true; +} \ No newline at end of file diff --git a/src/strategy/actions/TrainerAction.h b/src/strategy/actions/TrainerAction.h index 6aa877665..079c2f529 100644 --- a/src/strategy/actions/TrainerAction.h +++ b/src/strategy/actions/TrainerAction.h @@ -28,4 +28,10 @@ class TrainerAction : public Action void TellFooter(uint32 totalCost); }; +class MaintenanceAction : public Action +{ + public: + MaintenanceAction(PlayerbotAI* botAI) : Action(botAI, "maintenance") { } + bool Execute(Event event) override; +}; #endif diff --git a/src/strategy/generic/ChatCommandHandlerStrategy.cpp b/src/strategy/generic/ChatCommandHandlerStrategy.cpp index d35ad0c8f..0a8382316 100644 --- a/src/strategy/generic/ChatCommandHandlerStrategy.cpp +++ b/src/strategy/generic/ChatCommandHandlerStrategy.cpp @@ -88,6 +88,7 @@ ChatCommandHandlerStrategy::ChatCommandHandlerStrategy(PlayerbotAI* botAI) : Pas supported.push_back("nc"); supported.push_back("de"); supported.push_back("trainer"); + supported.push_back("maintenance"); supported.push_back("chat"); supported.push_back("home"); supported.push_back("destroy"); diff --git a/src/strategy/paladin/PaladinTriggers.cpp b/src/strategy/paladin/PaladinTriggers.cpp index 79c0e7305..1a7f1faf1 100644 --- a/src/strategy/paladin/PaladinTriggers.cpp +++ b/src/strategy/paladin/PaladinTriggers.cpp @@ -11,8 +11,8 @@ bool SealTrigger::IsActive() { Unit* target = GetTarget(); return !botAI->HasAura("seal of justice", target) && !botAI->HasAura("seal of command", target) && !botAI->HasAura("seal of vengeance", target) && - !botAI->HasAura("seal of corruption", target) && !botAI->HasAura("seal of righteousness", target) && !botAI->HasAura("seal of light", target) && (!botAI->HasAura("seal of wisdom", target) || AI_VALUE2(uint8, "mana", "self target") > 70) && - AI_VALUE2(bool, "combat", "self target"); + !botAI->HasAura("seal of corruption", target) && !botAI->HasAura("seal of righteousness", target) && !botAI->HasAura("seal of light", target) && + (!botAI->HasAura("seal of wisdom", target) || AI_VALUE2(uint8, "mana", "self target") > 70); } bool CrusaderAuraTrigger::IsActive() diff --git a/src/strategy/triggers/ChatTriggerContext.h b/src/strategy/triggers/ChatTriggerContext.h index 830eb983d..61cc9793f 100644 --- a/src/strategy/triggers/ChatTriggerContext.h +++ b/src/strategy/triggers/ChatTriggerContext.h @@ -54,6 +54,7 @@ class ChatTriggerContext : public NamedObjectContext creators["nc"] = &ChatTriggerContext::nc; creators["de"] = &ChatTriggerContext::dead; creators["trainer"] = &ChatTriggerContext::trainer; + creators["maintenance"] = &ChatTriggerContext::maintenance; creators["attack"] = &ChatTriggerContext::attack; creators["chat"] = &ChatTriggerContext::chat; creators["accept"] = &ChatTriggerContext::accept; @@ -164,6 +165,7 @@ class ChatTriggerContext : public NamedObjectContext static Trigger* chat(PlayerbotAI* botAI) { return new ChatCommandTrigger(botAI, "chat"); } static Trigger* attack(PlayerbotAI* botAI) { return new ChatCommandTrigger(botAI, "attack"); } static Trigger* trainer(PlayerbotAI* botAI) { return new ChatCommandTrigger(botAI, "trainer"); } + static Trigger* maintenance(PlayerbotAI* botAI) { return new ChatCommandTrigger(botAI, "maintenance"); } static Trigger* co(PlayerbotAI* botAI) { return new ChatCommandTrigger(botAI, "co"); } static Trigger* nc(PlayerbotAI* botAI) { return new ChatCommandTrigger(botAI, "nc"); } static Trigger* dead(PlayerbotAI* botAI) { return new ChatCommandTrigger(botAI, "de"); } From bf01db51ae50489e0fb933b12dac5cb5ce30a6c1 Mon Sep 17 00:00:00 2001 From: Yunfan Li <56597220+liyunfan1223@users.noreply.github.com> Date: Mon, 4 Mar 2024 18:15:11 +0800 Subject: [PATCH 03/22] Create cmake-multi-platform.yml --- .github/workflows/cmake-multi-platform.yml | 80 ++++++++++++++++++++++ 1 file changed, 80 insertions(+) create mode 100644 .github/workflows/cmake-multi-platform.yml diff --git a/.github/workflows/cmake-multi-platform.yml b/.github/workflows/cmake-multi-platform.yml new file mode 100644 index 000000000..a36e30a87 --- /dev/null +++ b/.github/workflows/cmake-multi-platform.yml @@ -0,0 +1,80 @@ +# This starter workflow is for a CMake project running on multiple platforms. There is a different starter workflow if you just want a single platform. +# See: https://github.com/actions/starter-workflows/blob/main/ci/cmake-single-platform.yml +name: CMake on multiple platforms + +on: + push: + branches: [ "master" ] + pull_request: + branches: [ "master" ] + +jobs: + build: + runs-on: ${{ matrix.os }} + + strategy: + # Set fail-fast to false to ensure that feedback is delivered for all matrix combinations. Consider changing this to true when your workflow is stable. + fail-fast: false + + # Set up a matrix to run the following 3 configurations: + # 1. + # 2. + # 3. + # + # To add more build types (Release, Debug, RelWithDebInfo, etc.) customize the build_type list. + matrix: + os: [ubuntu-latest, windows-latest] + build_type: [Release] + c_compiler: [gcc, clang, cl] + include: + - os: windows-latest + c_compiler: cl + cpp_compiler: cl + - os: ubuntu-latest + c_compiler: gcc + cpp_compiler: g++ + - os: ubuntu-latest + c_compiler: clang + cpp_compiler: clang++ + exclude: + - os: windows-latest + c_compiler: gcc + - os: windows-latest + c_compiler: clang + - os: ubuntu-latest + c_compiler: cl + + steps: + - name: Checkout AzerothCore + uses: actions/checkout@v3 + with: + repository: 'liyunfan1223/azerothcore-wotlk' + ref: 'Playerbot' + + - name: Set reusable strings + # Turn repeated input strings (such as the build output directory) into step outputs. These step outputs can be used throughout the workflow file. + id: strings + shell: bash + run: | + echo "build-output-dir=${{ github.workspace }}/build" >> "$GITHUB_OUTPUT" + - name: Clone Playerbot Module + run: git clone --depth=1 --branch=master https://github.com/azerothcore/mod-transmog.git modules/mod-transmog + - name: Configure CMake + # Configure CMake in a 'build' subdirectory. `CMAKE_BUILD_TYPE` is only required if you are using a single-configuration generator such as make. + # See https://cmake.org/cmake/help/latest/variable/CMAKE_BUILD_TYPE.html?highlight=cmake_build_type + run: > + cmake -B ${{ steps.strings.outputs.build-output-dir }} + -DCMAKE_CXX_COMPILER=${{ matrix.cpp_compiler }} + -DCMAKE_C_COMPILER=${{ matrix.c_compiler }} + -DCMAKE_BUILD_TYPE=${{ matrix.build_type }} + -S ${{ github.workspace }} + + - name: Build + # Build your program with the given configuration. Note that --config is needed because the default Windows generator is a multi-config generator (Visual Studio generator). + run: cmake --build ${{ steps.strings.outputs.build-output-dir }} --config ${{ matrix.build_type }} + + - name: Test + working-directory: ${{ steps.strings.outputs.build-output-dir }} + # Execute tests defined by the CMake configuration. Note that --build-config is needed because the default Windows generator is a multi-config generator (Visual Studio generator). + # See https://cmake.org/cmake/help/latest/manual/ctest.1.html for more detail + run: ctest --build-config ${{ matrix.build_type }} From 83d46383a2c7c93e7eb65a612c67c21d6c7d1f49 Mon Sep 17 00:00:00 2001 From: Yunfan Li <56597220+liyunfan1223@users.noreply.github.com> Date: Mon, 4 Mar 2024 18:21:34 +0800 Subject: [PATCH 04/22] Update cmake-multi-platform.yml --- .github/workflows/cmake-multi-platform.yml | 59 +++++++++++++++------- 1 file changed, 42 insertions(+), 17 deletions(-) diff --git a/.github/workflows/cmake-multi-platform.yml b/.github/workflows/cmake-multi-platform.yml index a36e30a87..4e3d17acb 100644 --- a/.github/workflows/cmake-multi-platform.yml +++ b/.github/workflows/cmake-multi-platform.yml @@ -57,24 +57,49 @@ jobs: shell: bash run: | echo "build-output-dir=${{ github.workspace }}/build" >> "$GITHUB_OUTPUT" + - name: Clone Playerbot Module - run: git clone --depth=1 --branch=master https://github.com/azerothcore/mod-transmog.git modules/mod-transmog - - name: Configure CMake - # Configure CMake in a 'build' subdirectory. `CMAKE_BUILD_TYPE` is only required if you are using a single-configuration generator such as make. - # See https://cmake.org/cmake/help/latest/variable/CMAKE_BUILD_TYPE.html?highlight=cmake_build_type - run: > - cmake -B ${{ steps.strings.outputs.build-output-dir }} - -DCMAKE_CXX_COMPILER=${{ matrix.cpp_compiler }} - -DCMAKE_C_COMPILER=${{ matrix.c_compiler }} - -DCMAKE_BUILD_TYPE=${{ matrix.build_type }} - -S ${{ github.workspace }} + run: git clone --depth=1 --branch=master https://github.com/liyunfan1223/mod-playerbots.git modules/mod-playerbot + - name: Cache + uses: actions/cache@v3 + with: + path: var/ccache + key: ccache:${{ matrix.os }}:${{ matrix.compiler }}:${{ matrix.modules }}-modules:${{ github.ref }}:${{ github.sha }} + restore-keys: | + ccache:${{ matrix.os }}:${{ matrix.compiler }}:${{ matrix.modules }}-modules:${{ github.ref }} + ccache:${{ matrix.os }}:${{ matrix.compiler }}:${{ matrix.modules }}-modules + + - name: Configure OS + run: source ./acore.sh install-deps + env: + CONTINUOUS_INTEGRATION: true + + - name: Create conf/config.sh + run: source ./apps/ci/ci-conf-core.sh + + - name: Process pending sql + run: bash bin/acore-db-pendings + - name: Build - # Build your program with the given configuration. Note that --config is needed because the default Windows generator is a multi-config generator (Visual Studio generator). - run: cmake --build ${{ steps.strings.outputs.build-output-dir }} --config ${{ matrix.build_type }} + run: source ./apps/ci/ci-compile.sh + + # - name: Configure CMake + # # Configure CMake in a 'build' subdirectory. `CMAKE_BUILD_TYPE` is only required if you are using a single-configuration generator such as make. + # # See https://cmake.org/cmake/help/latest/variable/CMAKE_BUILD_TYPE.html?highlight=cmake_build_type + # run: > + # cmake -B ${{ steps.strings.outputs.build-output-dir }} + # -DCMAKE_CXX_COMPILER=${{ matrix.cpp_compiler }} + # -DCMAKE_C_COMPILER=${{ matrix.c_compiler }} + # -DCMAKE_BUILD_TYPE=${{ matrix.build_type }} + # -S ${{ github.workspace }} + + # - name: Build + # # Build your program with the given configuration. Note that --config is needed because the default Windows generator is a multi-config generator (Visual Studio generator). + # run: cmake --build ${{ steps.strings.outputs.build-output-dir }} --config ${{ matrix.build_type }} - - name: Test - working-directory: ${{ steps.strings.outputs.build-output-dir }} - # Execute tests defined by the CMake configuration. Note that --build-config is needed because the default Windows generator is a multi-config generator (Visual Studio generator). - # See https://cmake.org/cmake/help/latest/manual/ctest.1.html for more detail - run: ctest --build-config ${{ matrix.build_type }} + # - name: Test + # working-directory: ${{ steps.strings.outputs.build-output-dir }} + # # Execute tests defined by the CMake configuration. Note that --build-config is needed because the default Windows generator is a multi-config generator (Visual Studio generator). + # # See https://cmake.org/cmake/help/latest/manual/ctest.1.html for more detail + # run: ctest --build-config ${{ matrix.build_type }} From f3d61ceab8a51810f4ce7dcb4fa7d114cf0370b1 Mon Sep 17 00:00:00 2001 From: Yunfan Li <56597220+liyunfan1223@users.noreply.github.com> Date: Mon, 4 Mar 2024 18:26:48 +0800 Subject: [PATCH 05/22] Update cmake-multi-platform.yml --- .github/workflows/cmake-multi-platform.yml | 67 +++++++++++----------- 1 file changed, 35 insertions(+), 32 deletions(-) diff --git a/.github/workflows/cmake-multi-platform.yml b/.github/workflows/cmake-multi-platform.yml index 4e3d17acb..1d0836f3d 100644 --- a/.github/workflows/cmake-multi-platform.yml +++ b/.github/workflows/cmake-multi-platform.yml @@ -23,7 +23,7 @@ jobs: # # To add more build types (Release, Debug, RelWithDebInfo, etc.) customize the build_type list. matrix: - os: [ubuntu-latest, windows-latest] + os: [ubuntu-latest] build_type: [Release] c_compiler: [gcc, clang, cl] include: @@ -60,43 +60,46 @@ jobs: - name: Clone Playerbot Module run: git clone --depth=1 --branch=master https://github.com/liyunfan1223/mod-playerbots.git modules/mod-playerbot - - - name: Cache - uses: actions/cache@v3 - with: - path: var/ccache - key: ccache:${{ matrix.os }}:${{ matrix.compiler }}:${{ matrix.modules }}-modules:${{ github.ref }}:${{ github.sha }} - restore-keys: | - ccache:${{ matrix.os }}:${{ matrix.compiler }}:${{ matrix.modules }}-modules:${{ github.ref }} - ccache:${{ matrix.os }}:${{ matrix.compiler }}:${{ matrix.modules }}-modules + + - name: Install Requirements + run: sudo apt-get update && sudo apt-get install git cmake make gcc g++ clang libmysqlclient-dev libssl-dev libbz2-dev libreadline-dev libncurses-dev mysql-server libboost-all-dev + + # - name: Cache + # uses: actions/cache@v3 + # with: + # path: var/ccache + # key: ccache:${{ matrix.os }}:${{ matrix.compiler }}:${{ matrix.modules }}-modules:${{ github.ref }}:${{ github.sha }} + # restore-keys: | + # ccache:${{ matrix.os }}:${{ matrix.compiler }}:${{ matrix.modules }}-modules:${{ github.ref }} + # ccache:${{ matrix.os }}:${{ matrix.compiler }}:${{ matrix.modules }}-modules - - name: Configure OS - run: source ./acore.sh install-deps - env: - CONTINUOUS_INTEGRATION: true + # - name: Configure OS + # run: source ./acore.sh install-deps + # env: + # CONTINUOUS_INTEGRATION: true - - name: Create conf/config.sh - run: source ./apps/ci/ci-conf-core.sh + # - name: Create conf/config.sh + # run: source ./apps/ci/ci-conf-core.sh - - name: Process pending sql - run: bash bin/acore-db-pendings + # - name: Process pending sql + # run: bash bin/acore-db-pendings - - name: Build - run: source ./apps/ci/ci-compile.sh + # - name: Build + # run: source ./apps/ci/ci-compile.sh - # - name: Configure CMake - # # Configure CMake in a 'build' subdirectory. `CMAKE_BUILD_TYPE` is only required if you are using a single-configuration generator such as make. - # # See https://cmake.org/cmake/help/latest/variable/CMAKE_BUILD_TYPE.html?highlight=cmake_build_type - # run: > - # cmake -B ${{ steps.strings.outputs.build-output-dir }} - # -DCMAKE_CXX_COMPILER=${{ matrix.cpp_compiler }} - # -DCMAKE_C_COMPILER=${{ matrix.c_compiler }} - # -DCMAKE_BUILD_TYPE=${{ matrix.build_type }} - # -S ${{ github.workspace }} + - name: Configure CMake + # Configure CMake in a 'build' subdirectory. `CMAKE_BUILD_TYPE` is only required if you are using a single-configuration generator such as make. + # See https://cmake.org/cmake/help/latest/variable/CMAKE_BUILD_TYPE.html?highlight=cmake_build_type + run: > + cmake -B ${{ steps.strings.outputs.build-output-dir }} + -DCMAKE_CXX_COMPILER=${{ matrix.cpp_compiler }} + -DCMAKE_C_COMPILER=${{ matrix.c_compiler }} + -DCMAKE_BUILD_TYPE=${{ matrix.build_type }} + -S ${{ github.workspace }} - # - name: Build - # # Build your program with the given configuration. Note that --config is needed because the default Windows generator is a multi-config generator (Visual Studio generator). - # run: cmake --build ${{ steps.strings.outputs.build-output-dir }} --config ${{ matrix.build_type }} + - name: Build + # Build your program with the given configuration. Note that --config is needed because the default Windows generator is a multi-config generator (Visual Studio generator). + run: cmake --build ${{ steps.strings.outputs.build-output-dir }} --config ${{ matrix.build_type }} # - name: Test # working-directory: ${{ steps.strings.outputs.build-output-dir }} From ca1fa16eb719add22f5a4986f7f0a26661fc788e Mon Sep 17 00:00:00 2001 From: Yunfan Li Date: Mon, 4 Mar 2024 18:59:41 +0800 Subject: [PATCH 06/22] Fix Value.h --- src/strategy/Value.h | 12 ++++++------ 1 file changed, 6 insertions(+), 6 deletions(-) diff --git a/src/strategy/Value.h b/src/strategy/Value.h index 25f61b59e..9ab4b89ad 100644 --- a/src/strategy/Value.h +++ b/src/strategy/Value.h @@ -54,19 +54,19 @@ class CalculatedValue : public UntypedValue, public Value T Get() override { if (checkInterval < 2) { - PerformanceMonitorOperation* pmo = sPerformanceMonitor->start(PERF_MON_VALUE, this->getName(), this->context ? &this->context->performanceStack : nullptr); + // PerformanceMonitorOperation* pmo = sPerformanceMonitor->start(PERF_MON_VALUE, this->getName(), this->context ? &this->context->performanceStack : nullptr); value = Calculate(); - if (pmo) - pmo->finish(); + // if (pmo) + // pmo->finish(); } else { time_t now = getMSTime(); if (!lastCheckTime || now - lastCheckTime >= checkInterval) { lastCheckTime = now; - PerformanceMonitorOperation* pmo = sPerformanceMonitor->start(PERF_MON_VALUE, this->getName(), this->context ? &this->context->performanceStack : nullptr); + // PerformanceMonitorOperation* pmo = sPerformanceMonitor->start(PERF_MON_VALUE, this->getName(), this->context ? &this->context->performanceStack : nullptr); value = Calculate(); - if (pmo) - pmo->finish(); + // if (pmo) + // pmo->finish(); } } return value; From 801d453a3dd73a5bd43e77fc50b0b5291e4f8ba1 Mon Sep 17 00:00:00 2001 From: Yunfan Li <56597220+liyunfan1223@users.noreply.github.com> Date: Mon, 4 Mar 2024 19:00:07 +0800 Subject: [PATCH 07/22] Update and rename cmake-multi-platform.yml to core-build.yml --- ...make-multi-platform.yml => core-build.yml} | 26 +++++++++---------- 1 file changed, 13 insertions(+), 13 deletions(-) rename .github/workflows/{cmake-multi-platform.yml => core-build.yml} (88%) diff --git a/.github/workflows/cmake-multi-platform.yml b/.github/workflows/core-build.yml similarity index 88% rename from .github/workflows/cmake-multi-platform.yml rename to .github/workflows/core-build.yml index 1d0836f3d..2d9bd2d7b 100644 --- a/.github/workflows/cmake-multi-platform.yml +++ b/.github/workflows/core-build.yml @@ -27,9 +27,9 @@ jobs: build_type: [Release] c_compiler: [gcc, clang, cl] include: - - os: windows-latest - c_compiler: cl - cpp_compiler: cl + # - os: windows-latest + # c_compiler: cl + # cpp_compiler: cl - os: ubuntu-latest c_compiler: gcc cpp_compiler: g++ @@ -37,10 +37,10 @@ jobs: c_compiler: clang cpp_compiler: clang++ exclude: - - os: windows-latest - c_compiler: gcc - - os: windows-latest - c_compiler: clang + # - os: windows-latest + # c_compiler: gcc + # - os: windows-latest + # c_compiler: clang - os: ubuntu-latest c_compiler: cl @@ -51,12 +51,12 @@ jobs: repository: 'liyunfan1223/azerothcore-wotlk' ref: 'Playerbot' - - name: Set reusable strings - # Turn repeated input strings (such as the build output directory) into step outputs. These step outputs can be used throughout the workflow file. - id: strings - shell: bash - run: | - echo "build-output-dir=${{ github.workspace }}/build" >> "$GITHUB_OUTPUT" + # - name: Set reusable strings + # # Turn repeated input strings (such as the build output directory) into step outputs. These step outputs can be used throughout the workflow file. + # id: strings + # shell: bash + # run: | + # echo "build-output-dir=${{ github.workspace }}/build" >> "$GITHUB_OUTPUT" - name: Clone Playerbot Module run: git clone --depth=1 --branch=master https://github.com/liyunfan1223/mod-playerbots.git modules/mod-playerbot From 72b7d71a3c5c8d0422e0ffc273a5d1d0692b4806 Mon Sep 17 00:00:00 2001 From: Yunfan Li <56597220+liyunfan1223@users.noreply.github.com> Date: Mon, 4 Mar 2024 19:11:27 +0800 Subject: [PATCH 08/22] Update core-build.yml --- .github/workflows/core-build.yml | 12 ++++++------ 1 file changed, 6 insertions(+), 6 deletions(-) diff --git a/.github/workflows/core-build.yml b/.github/workflows/core-build.yml index 2d9bd2d7b..4b29cbbfc 100644 --- a/.github/workflows/core-build.yml +++ b/.github/workflows/core-build.yml @@ -51,12 +51,12 @@ jobs: repository: 'liyunfan1223/azerothcore-wotlk' ref: 'Playerbot' - # - name: Set reusable strings - # # Turn repeated input strings (such as the build output directory) into step outputs. These step outputs can be used throughout the workflow file. - # id: strings - # shell: bash - # run: | - # echo "build-output-dir=${{ github.workspace }}/build" >> "$GITHUB_OUTPUT" + - name: Set reusable strings + # Turn repeated input strings (such as the build output directory) into step outputs. These step outputs can be used throughout the workflow file. + id: strings + shell: bash + run: | + echo "build-output-dir=${{ github.workspace }}/build" >> "$GITHUB_OUTPUT" - name: Clone Playerbot Module run: git clone --depth=1 --branch=master https://github.com/liyunfan1223/mod-playerbots.git modules/mod-playerbot From 089229f96a0768052528e1da855d4e47f04489e0 Mon Sep 17 00:00:00 2001 From: Yunfan Li <56597220+liyunfan1223@users.noreply.github.com> Date: Mon, 4 Mar 2024 19:14:24 +0800 Subject: [PATCH 09/22] Create windows_build.yml --- .github/workflows/windows_build.yml | 47 +++++++++++++++++++++++++++++ 1 file changed, 47 insertions(+) create mode 100644 .github/workflows/windows_build.yml diff --git a/.github/workflows/windows_build.yml b/.github/workflows/windows_build.yml new file mode 100644 index 000000000..1c41b84fa --- /dev/null +++ b/.github/workflows/windows_build.yml @@ -0,0 +1,47 @@ +name: windows-build +on: + push: + branches: [ "master" ] + pull_request: + branches: [ "master" ] + + +concurrency: + group: ${{ github.head_ref }} || concat(${{ github.ref }}, ${{ github.workflow }}) + cancel-in-progress: true + +jobs: + windows-build: + strategy: + fail-fast: false + matrix: + os: [windows-latest] + runs-on: ${{ matrix.os }} + name: ${{ matrix.os }} + env: + BOOST_ROOT: C:\local\boost_1_82_0 + if: | + github.repository == 'azerothcore/azerothcore-wotlk' + && !github.event.pull_request.draft + && (github.ref == 'refs/heads/master' || contains(github.event.pull_request.labels.*.name, 'run-build') || github.event.label.name == 'run-build') + steps: + - name: Checkout AzerothCore + uses: actions/checkout@v3 + with: + repository: 'liyunfan1223/azerothcore-wotlk' + ref: 'Playerbot' + - name: Clone Playerbot Module + run: git clone --depth=1 --branch=master https://github.com/liyunfan1223/mod-playerbots.git modules/mod-playerbot + - name: ccache + uses: hendrikmuhs/ccache-action@v1.2.9 + - name: Configure OS + shell: bash + env: + CONTINUOUS_INTEGRATION: true + run: | + ./acore.sh install-deps + - name: Build + shell: bash + run: | + export CTOOLS_BUILD=all + ./acore.sh compiler build From 0575f799b41b526f78608277dba532e057099afb Mon Sep 17 00:00:00 2001 From: Yunfan Li <56597220+liyunfan1223@users.noreply.github.com> Date: Mon, 4 Mar 2024 19:19:38 +0800 Subject: [PATCH 10/22] Update core-build.yml --- .github/workflows/core-build.yml | 21 ++------------------- 1 file changed, 2 insertions(+), 19 deletions(-) diff --git a/.github/workflows/core-build.yml b/.github/workflows/core-build.yml index 4b29cbbfc..112c55c08 100644 --- a/.github/workflows/core-build.yml +++ b/.github/workflows/core-build.yml @@ -25,24 +25,7 @@ jobs: matrix: os: [ubuntu-latest] build_type: [Release] - c_compiler: [gcc, clang, cl] - include: - # - os: windows-latest - # c_compiler: cl - # cpp_compiler: cl - - os: ubuntu-latest - c_compiler: gcc - cpp_compiler: g++ - - os: ubuntu-latest - c_compiler: clang - cpp_compiler: clang++ - exclude: - # - os: windows-latest - # c_compiler: gcc - # - os: windows-latest - # c_compiler: clang - - os: ubuntu-latest - c_compiler: cl + c_compiler: [clang] steps: - name: Checkout AzerothCore @@ -59,7 +42,7 @@ jobs: echo "build-output-dir=${{ github.workspace }}/build" >> "$GITHUB_OUTPUT" - name: Clone Playerbot Module - run: git clone --depth=1 --branch=master https://github.com/liyunfan1223/mod-playerbots.git modules/mod-playerbot + run: git clone --depth=1 --branch=master https://github.com/liyunfan1223/mod-playerbots.git modules/mod-playerbots - name: Install Requirements run: sudo apt-get update && sudo apt-get install git cmake make gcc g++ clang libmysqlclient-dev libssl-dev libbz2-dev libreadline-dev libncurses-dev mysql-server libboost-all-dev From 002f2f4e8e809c0bb51357abf28cfe8fb7e6d9d0 Mon Sep 17 00:00:00 2001 From: Yunfan Li Date: Mon, 4 Mar 2024 19:23:20 +0800 Subject: [PATCH 11/22] Update workflow --- .github/workflows/core-build.yml | 4 ++++ .github/workflows/windows_build.yml | 9 --------- 2 files changed, 4 insertions(+), 9 deletions(-) diff --git a/.github/workflows/core-build.yml b/.github/workflows/core-build.yml index 112c55c08..c7d18e25d 100644 --- a/.github/workflows/core-build.yml +++ b/.github/workflows/core-build.yml @@ -26,6 +26,10 @@ jobs: os: [ubuntu-latest] build_type: [Release] c_compiler: [clang] + include: + - os: ubuntu-latest + c_compiler: clang + cpp_compiler: clang++ steps: - name: Checkout AzerothCore diff --git a/.github/workflows/windows_build.yml b/.github/workflows/windows_build.yml index 1c41b84fa..5d3f06713 100644 --- a/.github/workflows/windows_build.yml +++ b/.github/workflows/windows_build.yml @@ -5,11 +5,6 @@ on: pull_request: branches: [ "master" ] - -concurrency: - group: ${{ github.head_ref }} || concat(${{ github.ref }}, ${{ github.workflow }}) - cancel-in-progress: true - jobs: windows-build: strategy: @@ -20,10 +15,6 @@ jobs: name: ${{ matrix.os }} env: BOOST_ROOT: C:\local\boost_1_82_0 - if: | - github.repository == 'azerothcore/azerothcore-wotlk' - && !github.event.pull_request.draft - && (github.ref == 'refs/heads/master' || contains(github.event.pull_request.labels.*.name, 'run-build') || github.event.label.name == 'run-build') steps: - name: Checkout AzerothCore uses: actions/checkout@v3 From b50c287ac3767817b409d59f6f3a99297e3bd776 Mon Sep 17 00:00:00 2001 From: Yunfan Li Date: Mon, 4 Mar 2024 19:28:15 +0800 Subject: [PATCH 12/22] Update core-build.yml --- .github/workflows/core-build.yml | 15 ++++++++++++++- 1 file changed, 14 insertions(+), 1 deletion(-) diff --git a/.github/workflows/core-build.yml b/.github/workflows/core-build.yml index c7d18e25d..716bedac2 100644 --- a/.github/workflows/core-build.yml +++ b/.github/workflows/core-build.yml @@ -25,11 +25,24 @@ jobs: matrix: os: [ubuntu-latest] build_type: [Release] - c_compiler: [clang] + c_compiler: [gcc, clang, cl] include: + # - os: windows-latest + # c_compiler: cl + # cpp_compiler: cl + - os: ubuntu-latest + c_compiler: gcc + cpp_compiler: g++ - os: ubuntu-latest c_compiler: clang cpp_compiler: clang++ + exclude: + # - os: windows-latest + # c_compiler: gcc + # - os: windows-latest + # c_compiler: clang + - os: ubuntu-latest + c_compiler: cl steps: - name: Checkout AzerothCore From e30c47f868cce3ebda258fc3c69804cf8d90a85d Mon Sep 17 00:00:00 2001 From: Yunfan Li Date: Mon, 4 Mar 2024 19:42:50 +0800 Subject: [PATCH 13/22] Update workflows --- .github/workflows/core-build.yml | 31 ++++++++++++++++++----------- .github/workflows/windows_build.yml | 2 +- 2 files changed, 20 insertions(+), 13 deletions(-) diff --git a/.github/workflows/core-build.yml b/.github/workflows/core-build.yml index 716bedac2..16839e14c 100644 --- a/.github/workflows/core-build.yml +++ b/.github/workflows/core-build.yml @@ -23,19 +23,26 @@ jobs: # # To add more build types (Release, Debug, RelWithDebInfo, etc.) customize the build_type list. matrix: - os: [ubuntu-latest] - build_type: [Release] - c_compiler: [gcc, clang, cl] + # the result of the matrix will be the combination of all attributes, so we get os*compiler builds include: - # - os: windows-latest - # c_compiler: cl - # cpp_compiler: cl - - os: ubuntu-latest - c_compiler: gcc - cpp_compiler: g++ - - os: ubuntu-latest - c_compiler: clang - cpp_compiler: clang++ + - os: ubuntu-20.04 + compiler: clang12 + - os: ubuntu-20.04 + compiler: gcc10 + # matrix: + # os: [ubuntu-latest] + # build_type: [Release] + # c_compiler: [gcc, clang, cl] + # include: + # # - os: windows-latest + # # c_compiler: cl + # # cpp_compiler: cl + # - os: ubuntu-latest + # c_compiler: gcc + # cpp_compiler: g++ + # - os: ubuntu-latest + # c_compiler: clang + # cpp_compiler: clang++ exclude: # - os: windows-latest # c_compiler: gcc diff --git a/.github/workflows/windows_build.yml b/.github/workflows/windows_build.yml index 5d3f06713..87c9e5e2d 100644 --- a/.github/workflows/windows_build.yml +++ b/.github/workflows/windows_build.yml @@ -22,7 +22,7 @@ jobs: repository: 'liyunfan1223/azerothcore-wotlk' ref: 'Playerbot' - name: Clone Playerbot Module - run: git clone --depth=1 --branch=master https://github.com/liyunfan1223/mod-playerbots.git modules/mod-playerbot + run: git clone --depth=1 --branch=master https://github.com/liyunfan1223/mod-playerbots.git modules/mod-playerbots - name: ccache uses: hendrikmuhs/ccache-action@v1.2.9 - name: Configure OS From b95ea94fa5dc2d307b9e3e34e7ae10a3e5db62c3 Mon Sep 17 00:00:00 2001 From: Yunfan Li Date: Mon, 4 Mar 2024 19:44:49 +0800 Subject: [PATCH 14/22] Update core-build.yml --- .github/workflows/core-build.yml | 23 ++--------------------- 1 file changed, 2 insertions(+), 21 deletions(-) diff --git a/.github/workflows/core-build.yml b/.github/workflows/core-build.yml index 16839e14c..8bfed7a96 100644 --- a/.github/workflows/core-build.yml +++ b/.github/workflows/core-build.yml @@ -29,27 +29,8 @@ jobs: compiler: clang12 - os: ubuntu-20.04 compiler: gcc10 - # matrix: - # os: [ubuntu-latest] - # build_type: [Release] - # c_compiler: [gcc, clang, cl] - # include: - # # - os: windows-latest - # # c_compiler: cl - # # cpp_compiler: cl - # - os: ubuntu-latest - # c_compiler: gcc - # cpp_compiler: g++ - # - os: ubuntu-latest - # c_compiler: clang - # cpp_compiler: clang++ - exclude: - # - os: windows-latest - # c_compiler: gcc - # - os: windows-latest - # c_compiler: clang - - os: ubuntu-latest - c_compiler: cl + runs-on: ${{ matrix.os }} + name: ${{ matrix.os }}-${{ matrix.compiler }} steps: - name: Checkout AzerothCore From 07f79729ca05f42d2e75d9ffa4405f119f40a94b Mon Sep 17 00:00:00 2001 From: Yunfan Li Date: Mon, 4 Mar 2024 19:50:01 +0800 Subject: [PATCH 15/22] Update core-build.yml --- .github/workflows/core-build.yml | 18 +++++++----------- 1 file changed, 7 insertions(+), 11 deletions(-) diff --git a/.github/workflows/core-build.yml b/.github/workflows/core-build.yml index 8bfed7a96..32d9ee66c 100644 --- a/.github/workflows/core-build.yml +++ b/.github/workflows/core-build.yml @@ -10,25 +10,21 @@ on: jobs: build: - runs-on: ${{ matrix.os }} - strategy: # Set fail-fast to false to ensure that feedback is delivered for all matrix combinations. Consider changing this to true when your workflow is stable. fail-fast: false - - # Set up a matrix to run the following 3 configurations: - # 1. - # 2. - # 3. - # - # To add more build types (Release, Debug, RelWithDebInfo, etc.) customize the build_type list. matrix: # the result of the matrix will be the combination of all attributes, so we get os*compiler builds include: - os: ubuntu-20.04 - compiler: clang12 + c_compiler: clang12 + cpp_compiler: clang12++ + build_type: Release - os: ubuntu-20.04 - compiler: gcc10 + c_compiler: gcc10 + cpp_compiler: g++10 + build_type: Release + runs-on: ${{ matrix.os }} name: ${{ matrix.os }}-${{ matrix.compiler }} From d99e6d9fbbe09a4664acb937e99de04ba242887d Mon Sep 17 00:00:00 2001 From: Yunfan Li Date: Mon, 4 Mar 2024 19:53:34 +0800 Subject: [PATCH 16/22] Update core-build.yml --- .github/workflows/core-build.yml | 12 ++++++------ 1 file changed, 6 insertions(+), 6 deletions(-) diff --git a/.github/workflows/core-build.yml b/.github/workflows/core-build.yml index 32d9ee66c..8bf52f1ff 100644 --- a/.github/workflows/core-build.yml +++ b/.github/workflows/core-build.yml @@ -17,16 +17,16 @@ jobs: # the result of the matrix will be the combination of all attributes, so we get os*compiler builds include: - os: ubuntu-20.04 - c_compiler: clang12 - cpp_compiler: clang12++ + c_compiler: clang + cpp_compiler: clang++ build_type: Release - os: ubuntu-20.04 - c_compiler: gcc10 - cpp_compiler: g++10 + c_compiler: gcc + cpp_compiler: g++ build_type: Release - + runs-on: ${{ matrix.os }} - name: ${{ matrix.os }}-${{ matrix.compiler }} + name: ${{ matrix.os }}-${{ matrix.cpp_compiler }} steps: - name: Checkout AzerothCore From b7b334af9929abbdd7acfd5cf4546f13947acf21 Mon Sep 17 00:00:00 2001 From: Yunfan Li Date: Tue, 5 Mar 2024 00:11:53 +0800 Subject: [PATCH 17/22] PremadeSpecGlyph config (unimplemented) --- .github/workflows/core-build.yml | 8 ++++++-- src/PlayerbotAIConfig.cpp | 10 ++++++++++ src/PlayerbotAIConfig.h | 2 ++ src/strategy/actions/LfgActions.cpp | 2 +- src/strategy/actions/LootRollAction.cpp | 2 +- .../priest/ShadowPriestStrategyActionNodeFactory.h | 10 ++++++++++ 6 files changed, 30 insertions(+), 4 deletions(-) diff --git a/.github/workflows/core-build.yml b/.github/workflows/core-build.yml index 8bf52f1ff..38855d351 100644 --- a/.github/workflows/core-build.yml +++ b/.github/workflows/core-build.yml @@ -1,6 +1,6 @@ # This starter workflow is for a CMake project running on multiple platforms. There is a different starter workflow if you just want a single platform. # See: https://github.com/actions/starter-workflows/blob/main/ci/cmake-single-platform.yml -name: CMake on multiple platforms +name: ubuntu-build on: push: @@ -24,7 +24,11 @@ jobs: c_compiler: gcc cpp_compiler: g++ build_type: Release - + - os: ubuntu-latest + c_compiler: gcc + cpp_compiler: g++ + build_type: Release + runs-on: ${{ matrix.os }} name: ${{ matrix.os }}-${{ matrix.cpp_compiler }} diff --git a/src/PlayerbotAIConfig.cpp b/src/PlayerbotAIConfig.cpp index e3b0f2bd8..bbcb44fea 100644 --- a/src/PlayerbotAIConfig.cpp +++ b/src/PlayerbotAIConfig.cpp @@ -172,6 +172,16 @@ bool PlayerbotAIConfig::Initialize() std::ostringstream os; os << "AiPlayerbot.PremadeSpecName." << cls << "." << spec; premadeSpecName[cls][spec] = sConfigMgr->GetOption(os.str().c_str(), "", false); + os.str(""); + os.clear(); + os << "AiPlayerbot.PremadeSpecGlyph." << cls << "." << spec; + premadeSpecGlyph[cls][spec] = sConfigMgr->GetOption(os.str().c_str(), "", false); + std::vector splitSpecGlyph = split(premadeSpecGlyph[cls][spec], ','); + for (std::string &split : splitSpecGlyph) { + if (split.size() != 0) { + parsedSpecGlyph[cls][spec].push_back(atoi(split.c_str())); + } + } for (uint32 level = 0; level < MAX_LEVEL; ++level) { std::ostringstream os; os << "AiPlayerbot.PremadeSpecLink." << cls << "." << spec << "." << level; diff --git a/src/PlayerbotAIConfig.h b/src/PlayerbotAIConfig.h index 2dc450d75..29199c9e4 100644 --- a/src/PlayerbotAIConfig.h +++ b/src/PlayerbotAIConfig.h @@ -97,6 +97,8 @@ class PlayerbotAIConfig // ClassSpecs classSpecs[MAX_CLASSES]; std::string premadeSpecName[MAX_CLASSES][MAX_SPECNO]; + std::string premadeSpecGlyph[MAX_CLASSES][MAX_SPECNO]; + std::vector parsedSpecGlyph[MAX_CLASSES][MAX_SPECNO]; std::string premadeSpecLink[MAX_CLASSES][MAX_SPECNO][MAX_LEVEL]; std::vector> parsedSpecLinkOrder[MAX_CLASSES][MAX_SPECNO][MAX_LEVEL]; uint32 randomClassSpecProb[MAX_CLASSES][MAX_SPECNO]; diff --git a/src/strategy/actions/LfgActions.cpp b/src/strategy/actions/LfgActions.cpp index 86f9cd473..99802ddff 100644 --- a/src/strategy/actions/LfgActions.cpp +++ b/src/strategy/actions/LfgActions.cpp @@ -33,7 +33,7 @@ uint32 LfgJoinAction::GetRoles() case CLASS_DRUID: if (spec == 2) return PLAYER_ROLE_HEALER; - else if (spec == 1 && bot->getLevel() >= 20) + else if (spec == 1) return (PLAYER_ROLE_TANK | PLAYER_ROLE_DAMAGE); else return PLAYER_ROLE_DAMAGE; diff --git a/src/strategy/actions/LootRollAction.cpp b/src/strategy/actions/LootRollAction.cpp index d549b3da0..9f5db411c 100644 --- a/src/strategy/actions/LootRollAction.cpp +++ b/src/strategy/actions/LootRollAction.cpp @@ -36,7 +36,7 @@ bool LootRollAction::Execute(Event event) { case ITEM_CLASS_WEAPON: case ITEM_CLASS_ARMOR: - if (usage == ITEM_USAGE_EQUIP || usage == ITEM_USAGE_REPLACE) { + if (usage == ITEM_USAGE_EQUIP || usage == ITEM_USAGE_REPLACE || usage == ITEM_USAGE_BAD_EQUIP) { vote = NEED; } else if (usage != ITEM_USAGE_NONE) { diff --git a/src/strategy/priest/ShadowPriestStrategyActionNodeFactory.h b/src/strategy/priest/ShadowPriestStrategyActionNodeFactory.h index acbc517eb..49bc26a39 100644 --- a/src/strategy/priest/ShadowPriestStrategyActionNodeFactory.h +++ b/src/strategy/priest/ShadowPriestStrategyActionNodeFactory.h @@ -18,6 +18,7 @@ class ShadowPriestStrategyActionNodeFactory : public NamedObjectFactory Date: Tue, 5 Mar 2024 00:13:41 +0800 Subject: [PATCH 18/22] Update macos_build.yml --- .github/workflows/macos_build.yml | 38 +++++++++++++++++++++++++++++++ 1 file changed, 38 insertions(+) create mode 100644 .github/workflows/macos_build.yml diff --git a/.github/workflows/macos_build.yml b/.github/workflows/macos_build.yml new file mode 100644 index 000000000..549e9cf76 --- /dev/null +++ b/.github/workflows/macos_build.yml @@ -0,0 +1,38 @@ +name: windows-build +on: + push: + branches: [ "master" ] + pull_request: + branches: [ "master" ] + +jobs: + macos-build: + strategy: + fail-fast: false + matrix: + os: + - macos-12 + runs-on: ${{ matrix.os }} + name: ${{ matrix.os }} + steps: + - name: Checkout AzerothCore + uses: actions/checkout@v3 + with: + repository: 'liyunfan1223/azerothcore-wotlk' + ref: 'Playerbot' + - name: Clone Playerbot Module + run: git clone --depth=1 --branch=master https://github.com/liyunfan1223/mod-playerbots.git modules/mod-playerbots + - name: Cache + uses: actions/cache@v3 + with: + path: ~/Library/Caches/ccache + key: ccache:${{ matrix.os }}:${{ github.ref }}:${{ github.sha }} + restore-keys: | + ccache:${{ matrix.os }}:${{ github.ref }} + ccache:${{ matrix.os }} + - name: Install latest bash + run: brew install bash + - name: Configure OS + run: source ./acore.sh install-deps + - name: Build + run: source ./apps/ci/mac/ci-compile.sh From f6d4915f179d6ab8f8172ef157bd644edfdc432e Mon Sep 17 00:00:00 2001 From: Yunfan Li <56597220+liyunfan1223@users.noreply.github.com> Date: Tue, 5 Mar 2024 08:22:05 +0800 Subject: [PATCH 19/22] Update macos_build.yml --- .github/workflows/macos_build.yml | 74 +++++++++++++++---------------- 1 file changed, 37 insertions(+), 37 deletions(-) diff --git a/.github/workflows/macos_build.yml b/.github/workflows/macos_build.yml index 549e9cf76..dfa4f73a3 100644 --- a/.github/workflows/macos_build.yml +++ b/.github/workflows/macos_build.yml @@ -1,38 +1,38 @@ -name: windows-build -on: - push: - branches: [ "master" ] - pull_request: - branches: [ "master" ] +# name: macos-build +# on: +# push: +# branches: [ "master" ] +# pull_request: +# branches: [ "master" ] -jobs: - macos-build: - strategy: - fail-fast: false - matrix: - os: - - macos-12 - runs-on: ${{ matrix.os }} - name: ${{ matrix.os }} - steps: - - name: Checkout AzerothCore - uses: actions/checkout@v3 - with: - repository: 'liyunfan1223/azerothcore-wotlk' - ref: 'Playerbot' - - name: Clone Playerbot Module - run: git clone --depth=1 --branch=master https://github.com/liyunfan1223/mod-playerbots.git modules/mod-playerbots - - name: Cache - uses: actions/cache@v3 - with: - path: ~/Library/Caches/ccache - key: ccache:${{ matrix.os }}:${{ github.ref }}:${{ github.sha }} - restore-keys: | - ccache:${{ matrix.os }}:${{ github.ref }} - ccache:${{ matrix.os }} - - name: Install latest bash - run: brew install bash - - name: Configure OS - run: source ./acore.sh install-deps - - name: Build - run: source ./apps/ci/mac/ci-compile.sh +# jobs: +# macos-build: +# strategy: +# fail-fast: false +# matrix: +# os: +# - macos-12 +# runs-on: ${{ matrix.os }} +# name: ${{ matrix.os }} +# steps: +# - name: Checkout AzerothCore +# uses: actions/checkout@v3 +# with: +# repository: 'liyunfan1223/azerothcore-wotlk' +# ref: 'Playerbot' +# - name: Clone Playerbot Module +# run: git clone --depth=1 --branch=master https://github.com/liyunfan1223/mod-playerbots.git modules/mod-playerbots +# - name: Cache +# uses: actions/cache@v3 +# with: +# path: ~/Library/Caches/ccache +# key: ccache:${{ matrix.os }}:${{ github.ref }}:${{ github.sha }} +# restore-keys: | +# ccache:${{ matrix.os }}:${{ github.ref }} +# ccache:${{ matrix.os }} +# - name: Install latest bash +# run: brew install bash +# - name: Configure OS +# run: source ./acore.sh install-deps +# - name: Build +# run: source ./apps/ci/mac/ci-compile.sh From c3aa0c6bf41e0123e85466dcfc718ae702c24f71 Mon Sep 17 00:00:00 2001 From: Yunfan Li <56597220+liyunfan1223@users.noreply.github.com> Date: Tue, 5 Mar 2024 11:06:57 +0800 Subject: [PATCH 20/22] Switch to AGPL-3.0 LICENSE --- LICENSE | 682 ++++++++++++++++++++++++++++++++++++++++++++++++++++++-- 1 file changed, 661 insertions(+), 21 deletions(-) diff --git a/LICENSE b/LICENSE index 9031171d1..dbbe35581 100644 --- a/LICENSE +++ b/LICENSE @@ -1,21 +1,661 @@ -MIT License - -Copyright (c) 2021 AzerothCore - -Permission is hereby granted, free of charge, to any person obtaining a copy -of this software and associated documentation files (the "Software"), to deal -in the Software without restriction, including without limitation the rights -to use, copy, modify, merge, publish, distribute, sublicense, and/or sell -copies of the Software, and to permit persons to whom the Software is -furnished to do so, subject to the following conditions: - -The above copyright notice and this permission notice shall be included in all -copies or substantial portions of the Software. - -THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR -IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, -FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE -AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER -LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, -OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE -SOFTWARE. + GNU AFFERO GENERAL PUBLIC LICENSE + Version 3, 19 November 2007 + + Copyright (C) 2007 Free Software Foundation, Inc. + Everyone is permitted to copy and distribute verbatim copies + of this license document, but changing it is not allowed. + + Preamble + + The GNU Affero General Public License is a free, copyleft license for +software and other kinds of works, specifically designed to ensure +cooperation with the community in the case of network server software. + + The licenses for most software and other practical works are designed +to take away your freedom to share and change the works. By contrast, +our General Public Licenses are intended to guarantee your freedom to +share and change all versions of a program--to make sure it remains free +software for all its users. + + When we speak of free software, we are referring to freedom, not +price. Our General Public Licenses are designed to make sure that you +have the freedom to distribute copies of free software (and charge for +them if you wish), that you receive source code or can get it if you +want it, that you can change the software or use pieces of it in new +free programs, and that you know you can do these things. + + Developers that use our General Public Licenses protect your rights +with two steps: (1) assert copyright on the software, and (2) offer +you this License which gives you legal permission to copy, distribute +and/or modify the software. + + A secondary benefit of defending all users' freedom is that +improvements made in alternate versions of the program, if they +receive widespread use, become available for other developers to +incorporate. Many developers of free software are heartened and +encouraged by the resulting cooperation. However, in the case of +software used on network servers, this result may fail to come about. +The GNU General Public License permits making a modified version and +letting the public access it on a server without ever releasing its +source code to the public. + + The GNU Affero General Public License is designed specifically to +ensure that, in such cases, the modified source code becomes available +to the community. It requires the operator of a network server to +provide the source code of the modified version running there to the +users of that server. Therefore, public use of a modified version, on +a publicly accessible server, gives the public access to the source +code of the modified version. + + An older license, called the Affero General Public License and +published by Affero, was designed to accomplish similar goals. This is +a different license, not a version of the Affero GPL, but Affero has +released a new version of the Affero GPL which permits relicensing under +this license. + + The precise terms and conditions for copying, distribution and +modification follow. + + TERMS AND CONDITIONS + + 0. Definitions. + + "This License" refers to version 3 of the GNU Affero General Public License. + + "Copyright" also means copyright-like laws that apply to other kinds of +works, such as semiconductor masks. + + "The Program" refers to any copyrightable work licensed under this +License. Each licensee is addressed as "you". "Licensees" and +"recipients" may be individuals or organizations. + + To "modify" a work means to copy from or adapt all or part of the work +in a fashion requiring copyright permission, other than the making of an +exact copy. The resulting work is called a "modified version" of the +earlier work or a work "based on" the earlier work. + + A "covered work" means either the unmodified Program or a work based +on the Program. + + To "propagate" a work means to do anything with it that, without +permission, would make you directly or secondarily liable for +infringement under applicable copyright law, except executing it on a +computer or modifying a private copy. Propagation includes copying, +distribution (with or without modification), making available to the +public, and in some countries other activities as well. + + To "convey" a work means any kind of propagation that enables other +parties to make or receive copies. Mere interaction with a user through +a computer network, with no transfer of a copy, is not conveying. + + An interactive user interface displays "Appropriate Legal Notices" +to the extent that it includes a convenient and prominently visible +feature that (1) displays an appropriate copyright notice, and (2) +tells the user that there is no warranty for the work (except to the +extent that warranties are provided), that licensees may convey the +work under this License, and how to view a copy of this License. If +the interface presents a list of user commands or options, such as a +menu, a prominent item in the list meets this criterion. + + 1. Source Code. + + The "source code" for a work means the preferred form of the work +for making modifications to it. "Object code" means any non-source +form of a work. + + A "Standard Interface" means an interface that either is an official +standard defined by a recognized standards body, or, in the case of +interfaces specified for a particular programming language, one that +is widely used among developers working in that language. + + The "System Libraries" of an executable work include anything, other +than the work as a whole, that (a) is included in the normal form of +packaging a Major Component, but which is not part of that Major +Component, and (b) serves only to enable use of the work with that +Major Component, or to implement a Standard Interface for which an +implementation is available to the public in source code form. A +"Major Component", in this context, means a major essential component +(kernel, window system, and so on) of the specific operating system +(if any) on which the executable work runs, or a compiler used to +produce the work, or an object code interpreter used to run it. + + The "Corresponding Source" for a work in object code form means all +the source code needed to generate, install, and (for an executable +work) run the object code and to modify the work, including scripts to +control those activities. However, it does not include the work's +System Libraries, or general-purpose tools or generally available free +programs which are used unmodified in performing those activities but +which are not part of the work. For example, Corresponding Source +includes interface definition files associated with source files for +the work, and the source code for shared libraries and dynamically +linked subprograms that the work is specifically designed to require, +such as by intimate data communication or control flow between those +subprograms and other parts of the work. + + The Corresponding Source need not include anything that users +can regenerate automatically from other parts of the Corresponding +Source. + + The Corresponding Source for a work in source code form is that +same work. + + 2. Basic Permissions. + + All rights granted under this License are granted for the term of +copyright on the Program, and are irrevocable provided the stated +conditions are met. This License explicitly affirms your unlimited +permission to run the unmodified Program. The output from running a +covered work is covered by this License only if the output, given its +content, constitutes a covered work. This License acknowledges your +rights of fair use or other equivalent, as provided by copyright law. + + You may make, run and propagate covered works that you do not +convey, without conditions so long as your license otherwise remains +in force. You may convey covered works to others for the sole purpose +of having them make modifications exclusively for you, or provide you +with facilities for running those works, provided that you comply with +the terms of this License in conveying all material for which you do +not control copyright. Those thus making or running the covered works +for you must do so exclusively on your behalf, under your direction +and control, on terms that prohibit them from making any copies of +your copyrighted material outside their relationship with you. + + Conveying under any other circumstances is permitted solely under +the conditions stated below. Sublicensing is not allowed; section 10 +makes it unnecessary. + + 3. Protecting Users' Legal Rights From Anti-Circumvention Law. + + No covered work shall be deemed part of an effective technological +measure under any applicable law fulfilling obligations under article +11 of the WIPO copyright treaty adopted on 20 December 1996, or +similar laws prohibiting or restricting circumvention of such +measures. + + When you convey a covered work, you waive any legal power to forbid +circumvention of technological measures to the extent such circumvention +is effected by exercising rights under this License with respect to +the covered work, and you disclaim any intention to limit operation or +modification of the work as a means of enforcing, against the work's +users, your or third parties' legal rights to forbid circumvention of +technological measures. + + 4. Conveying Verbatim Copies. + + You may convey verbatim copies of the Program's source code as you +receive it, in any medium, provided that you conspicuously and +appropriately publish on each copy an appropriate copyright notice; +keep intact all notices stating that this License and any +non-permissive terms added in accord with section 7 apply to the code; +keep intact all notices of the absence of any warranty; and give all +recipients a copy of this License along with the Program. + + You may charge any price or no price for each copy that you convey, +and you may offer support or warranty protection for a fee. + + 5. Conveying Modified Source Versions. + + You may convey a work based on the Program, or the modifications to +produce it from the Program, in the form of source code under the +terms of section 4, provided that you also meet all of these conditions: + + a) The work must carry prominent notices stating that you modified + it, and giving a relevant date. + + b) The work must carry prominent notices stating that it is + released under this License and any conditions added under section + 7. This requirement modifies the requirement in section 4 to + "keep intact all notices". + + c) You must license the entire work, as a whole, under this + License to anyone who comes into possession of a copy. This + License will therefore apply, along with any applicable section 7 + additional terms, to the whole of the work, and all its parts, + regardless of how they are packaged. This License gives no + permission to license the work in any other way, but it does not + invalidate such permission if you have separately received it. + + d) If the work has interactive user interfaces, each must display + Appropriate Legal Notices; however, if the Program has interactive + interfaces that do not display Appropriate Legal Notices, your + work need not make them do so. + + A compilation of a covered work with other separate and independent +works, which are not by their nature extensions of the covered work, +and which are not combined with it such as to form a larger program, +in or on a volume of a storage or distribution medium, is called an +"aggregate" if the compilation and its resulting copyright are not +used to limit the access or legal rights of the compilation's users +beyond what the individual works permit. Inclusion of a covered work +in an aggregate does not cause this License to apply to the other +parts of the aggregate. + + 6. Conveying Non-Source Forms. + + You may convey a covered work in object code form under the terms +of sections 4 and 5, provided that you also convey the +machine-readable Corresponding Source under the terms of this License, +in one of these ways: + + a) Convey the object code in, or embodied in, a physical product + (including a physical distribution medium), accompanied by the + Corresponding Source fixed on a durable physical medium + customarily used for software interchange. + + b) Convey the object code in, or embodied in, a physical product + (including a physical distribution medium), accompanied by a + written offer, valid for at least three years and valid for as + long as you offer spare parts or customer support for that product + model, to give anyone who possesses the object code either (1) a + copy of the Corresponding Source for all the software in the + product that is covered by this License, on a durable physical + medium customarily used for software interchange, for a price no + more than your reasonable cost of physically performing this + conveying of source, or (2) access to copy the + Corresponding Source from a network server at no charge. + + c) Convey individual copies of the object code with a copy of the + written offer to provide the Corresponding Source. This + alternative is allowed only occasionally and noncommercially, and + only if you received the object code with such an offer, in accord + with subsection 6b. + + d) Convey the object code by offering access from a designated + place (gratis or for a charge), and offer equivalent access to the + Corresponding Source in the same way through the same place at no + further charge. You need not require recipients to copy the + Corresponding Source along with the object code. If the place to + copy the object code is a network server, the Corresponding Source + may be on a different server (operated by you or a third party) + that supports equivalent copying facilities, provided you maintain + clear directions next to the object code saying where to find the + Corresponding Source. Regardless of what server hosts the + Corresponding Source, you remain obligated to ensure that it is + available for as long as needed to satisfy these requirements. + + e) Convey the object code using peer-to-peer transmission, provided + you inform other peers where the object code and Corresponding + Source of the work are being offered to the general public at no + charge under subsection 6d. + + A separable portion of the object code, whose source code is excluded +from the Corresponding Source as a System Library, need not be +included in conveying the object code work. + + A "User Product" is either (1) a "consumer product", which means any +tangible personal property which is normally used for personal, family, +or household purposes, or (2) anything designed or sold for incorporation +into a dwelling. In determining whether a product is a consumer product, +doubtful cases shall be resolved in favor of coverage. For a particular +product received by a particular user, "normally used" refers to a +typical or common use of that class of product, regardless of the status +of the particular user or of the way in which the particular user +actually uses, or expects or is expected to use, the product. A product +is a consumer product regardless of whether the product has substantial +commercial, industrial or non-consumer uses, unless such uses represent +the only significant mode of use of the product. + + "Installation Information" for a User Product means any methods, +procedures, authorization keys, or other information required to install +and execute modified versions of a covered work in that User Product from +a modified version of its Corresponding Source. The information must +suffice to ensure that the continued functioning of the modified object +code is in no case prevented or interfered with solely because +modification has been made. + + If you convey an object code work under this section in, or with, or +specifically for use in, a User Product, and the conveying occurs as +part of a transaction in which the right of possession and use of the +User Product is transferred to the recipient in perpetuity or for a +fixed term (regardless of how the transaction is characterized), the +Corresponding Source conveyed under this section must be accompanied +by the Installation Information. But this requirement does not apply +if neither you nor any third party retains the ability to install +modified object code on the User Product (for example, the work has +been installed in ROM). + + The requirement to provide Installation Information does not include a +requirement to continue to provide support service, warranty, or updates +for a work that has been modified or installed by the recipient, or for +the User Product in which it has been modified or installed. Access to a +network may be denied when the modification itself materially and +adversely affects the operation of the network or violates the rules and +protocols for communication across the network. + + Corresponding Source conveyed, and Installation Information provided, +in accord with this section must be in a format that is publicly +documented (and with an implementation available to the public in +source code form), and must require no special password or key for +unpacking, reading or copying. + + 7. Additional Terms. + + "Additional permissions" are terms that supplement the terms of this +License by making exceptions from one or more of its conditions. +Additional permissions that are applicable to the entire Program shall +be treated as though they were included in this License, to the extent +that they are valid under applicable law. If additional permissions +apply only to part of the Program, that part may be used separately +under those permissions, but the entire Program remains governed by +this License without regard to the additional permissions. + + When you convey a copy of a covered work, you may at your option +remove any additional permissions from that copy, or from any part of +it. (Additional permissions may be written to require their own +removal in certain cases when you modify the work.) You may place +additional permissions on material, added by you to a covered work, +for which you have or can give appropriate copyright permission. + + Notwithstanding any other provision of this License, for material you +add to a covered work, you may (if authorized by the copyright holders of +that material) supplement the terms of this License with terms: + + a) Disclaiming warranty or limiting liability differently from the + terms of sections 15 and 16 of this License; or + + b) Requiring preservation of specified reasonable legal notices or + author attributions in that material or in the Appropriate Legal + Notices displayed by works containing it; or + + c) Prohibiting misrepresentation of the origin of that material, or + requiring that modified versions of such material be marked in + reasonable ways as different from the original version; or + + d) Limiting the use for publicity purposes of names of licensors or + authors of the material; or + + e) Declining to grant rights under trademark law for use of some + trade names, trademarks, or service marks; or + + f) Requiring indemnification of licensors and authors of that + material by anyone who conveys the material (or modified versions of + it) with contractual assumptions of liability to the recipient, for + any liability that these contractual assumptions directly impose on + those licensors and authors. + + All other non-permissive additional terms are considered "further +restrictions" within the meaning of section 10. If the Program as you +received it, or any part of it, contains a notice stating that it is +governed by this License along with a term that is a further +restriction, you may remove that term. If a license document contains +a further restriction but permits relicensing or conveying under this +License, you may add to a covered work material governed by the terms +of that license document, provided that the further restriction does +not survive such relicensing or conveying. + + If you add terms to a covered work in accord with this section, you +must place, in the relevant source files, a statement of the +additional terms that apply to those files, or a notice indicating +where to find the applicable terms. + + Additional terms, permissive or non-permissive, may be stated in the +form of a separately written license, or stated as exceptions; +the above requirements apply either way. + + 8. Termination. + + You may not propagate or modify a covered work except as expressly +provided under this License. Any attempt otherwise to propagate or +modify it is void, and will automatically terminate your rights under +this License (including any patent licenses granted under the third +paragraph of section 11). + + However, if you cease all violation of this License, then your +license from a particular copyright holder is reinstated (a) +provisionally, unless and until the copyright holder explicitly and +finally terminates your license, and (b) permanently, if the copyright +holder fails to notify you of the violation by some reasonable means +prior to 60 days after the cessation. + + Moreover, your license from a particular copyright holder is +reinstated permanently if the copyright holder notifies you of the +violation by some reasonable means, this is the first time you have +received notice of violation of this License (for any work) from that +copyright holder, and you cure the violation prior to 30 days after +your receipt of the notice. + + Termination of your rights under this section does not terminate the +licenses of parties who have received copies or rights from you under +this License. If your rights have been terminated and not permanently +reinstated, you do not qualify to receive new licenses for the same +material under section 10. + + 9. Acceptance Not Required for Having Copies. + + You are not required to accept this License in order to receive or +run a copy of the Program. Ancillary propagation of a covered work +occurring solely as a consequence of using peer-to-peer transmission +to receive a copy likewise does not require acceptance. However, +nothing other than this License grants you permission to propagate or +modify any covered work. These actions infringe copyright if you do +not accept this License. Therefore, by modifying or propagating a +covered work, you indicate your acceptance of this License to do so. + + 10. Automatic Licensing of Downstream Recipients. + + Each time you convey a covered work, the recipient automatically +receives a license from the original licensors, to run, modify and +propagate that work, subject to this License. You are not responsible +for enforcing compliance by third parties with this License. + + An "entity transaction" is a transaction transferring control of an +organization, or substantially all assets of one, or subdividing an +organization, or merging organizations. If propagation of a covered +work results from an entity transaction, each party to that +transaction who receives a copy of the work also receives whatever +licenses to the work the party's predecessor in interest had or could +give under the previous paragraph, plus a right to possession of the +Corresponding Source of the work from the predecessor in interest, if +the predecessor has it or can get it with reasonable efforts. + + You may not impose any further restrictions on the exercise of the +rights granted or affirmed under this License. For example, you may +not impose a license fee, royalty, or other charge for exercise of +rights granted under this License, and you may not initiate litigation +(including a cross-claim or counterclaim in a lawsuit) alleging that +any patent claim is infringed by making, using, selling, offering for +sale, or importing the Program or any portion of it. + + 11. Patents. + + A "contributor" is a copyright holder who authorizes use under this +License of the Program or a work on which the Program is based. The +work thus licensed is called the contributor's "contributor version". + + A contributor's "essential patent claims" are all patent claims +owned or controlled by the contributor, whether already acquired or +hereafter acquired, that would be infringed by some manner, permitted +by this License, of making, using, or selling its contributor version, +but do not include claims that would be infringed only as a +consequence of further modification of the contributor version. For +purposes of this definition, "control" includes the right to grant +patent sublicenses in a manner consistent with the requirements of +this License. + + Each contributor grants you a non-exclusive, worldwide, royalty-free +patent license under the contributor's essential patent claims, to +make, use, sell, offer for sale, import and otherwise run, modify and +propagate the contents of its contributor version. + + In the following three paragraphs, a "patent license" is any express +agreement or commitment, however denominated, not to enforce a patent +(such as an express permission to practice a patent or covenant not to +sue for patent infringement). To "grant" such a patent license to a +party means to make such an agreement or commitment not to enforce a +patent against the party. + + If you convey a covered work, knowingly relying on a patent license, +and the Corresponding Source of the work is not available for anyone +to copy, free of charge and under the terms of this License, through a +publicly available network server or other readily accessible means, +then you must either (1) cause the Corresponding Source to be so +available, or (2) arrange to deprive yourself of the benefit of the +patent license for this particular work, or (3) arrange, in a manner +consistent with the requirements of this License, to extend the patent +license to downstream recipients. "Knowingly relying" means you have +actual knowledge that, but for the patent license, your conveying the +covered work in a country, or your recipient's use of the covered work +in a country, would infringe one or more identifiable patents in that +country that you have reason to believe are valid. + + If, pursuant to or in connection with a single transaction or +arrangement, you convey, or propagate by procuring conveyance of, a +covered work, and grant a patent license to some of the parties +receiving the covered work authorizing them to use, propagate, modify +or convey a specific copy of the covered work, then the patent license +you grant is automatically extended to all recipients of the covered +work and works based on it. + + A patent license is "discriminatory" if it does not include within +the scope of its coverage, prohibits the exercise of, or is +conditioned on the non-exercise of one or more of the rights that are +specifically granted under this License. You may not convey a covered +work if you are a party to an arrangement with a third party that is +in the business of distributing software, under which you make payment +to the third party based on the extent of your activity of conveying +the work, and under which the third party grants, to any of the +parties who would receive the covered work from you, a discriminatory +patent license (a) in connection with copies of the covered work +conveyed by you (or copies made from those copies), or (b) primarily +for and in connection with specific products or compilations that +contain the covered work, unless you entered into that arrangement, +or that patent license was granted, prior to 28 March 2007. + + Nothing in this License shall be construed as excluding or limiting +any implied license or other defenses to infringement that may +otherwise be available to you under applicable patent law. + + 12. No Surrender of Others' Freedom. + + If conditions are imposed on you (whether by court order, agreement or +otherwise) that contradict the conditions of this License, they do not +excuse you from the conditions of this License. If you cannot convey a +covered work so as to satisfy simultaneously your obligations under this +License and any other pertinent obligations, then as a consequence you may +not convey it at all. For example, if you agree to terms that obligate you +to collect a royalty for further conveying from those to whom you convey +the Program, the only way you could satisfy both those terms and this +License would be to refrain entirely from conveying the Program. + + 13. Remote Network Interaction; Use with the GNU General Public License. + + Notwithstanding any other provision of this License, if you modify the +Program, your modified version must prominently offer all users +interacting with it remotely through a computer network (if your version +supports such interaction) an opportunity to receive the Corresponding +Source of your version by providing access to the Corresponding Source +from a network server at no charge, through some standard or customary +means of facilitating copying of software. This Corresponding Source +shall include the Corresponding Source for any work covered by version 3 +of the GNU General Public License that is incorporated pursuant to the +following paragraph. + + Notwithstanding any other provision of this License, you have +permission to link or combine any covered work with a work licensed +under version 3 of the GNU General Public License into a single +combined work, and to convey the resulting work. The terms of this +License will continue to apply to the part which is the covered work, +but the work with which it is combined will remain governed by version +3 of the GNU General Public License. + + 14. Revised Versions of this License. + + The Free Software Foundation may publish revised and/or new versions of +the GNU Affero General Public License from time to time. Such new versions +will be similar in spirit to the present version, but may differ in detail to +address new problems or concerns. + + Each version is given a distinguishing version number. If the +Program specifies that a certain numbered version of the GNU Affero General +Public License "or any later version" applies to it, you have the +option of following the terms and conditions either of that numbered +version or of any later version published by the Free Software +Foundation. If the Program does not specify a version number of the +GNU Affero General Public License, you may choose any version ever published +by the Free Software Foundation. + + If the Program specifies that a proxy can decide which future +versions of the GNU Affero General Public License can be used, that proxy's +public statement of acceptance of a version permanently authorizes you +to choose that version for the Program. + + Later license versions may give you additional or different +permissions. However, no additional obligations are imposed on any +author or copyright holder as a result of your choosing to follow a +later version. + + 15. Disclaimer of Warranty. + + THERE IS NO WARRANTY FOR THE PROGRAM, TO THE EXTENT PERMITTED BY +APPLICABLE LAW. EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT +HOLDERS AND/OR OTHER PARTIES PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY +OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, +THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR +PURPOSE. THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE PROGRAM +IS WITH YOU. SHOULD THE PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF +ALL NECESSARY SERVICING, REPAIR OR CORRECTION. + + 16. Limitation of Liability. + + IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING +WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MODIFIES AND/OR CONVEYS +THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, INCLUDING ANY +GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE +USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED TO LOSS OF +DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD +PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER PROGRAMS), +EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF +SUCH DAMAGES. + + 17. Interpretation of Sections 15 and 16. + + If the disclaimer of warranty and limitation of liability provided +above cannot be given local legal effect according to their terms, +reviewing courts shall apply local law that most closely approximates +an absolute waiver of all civil liability in connection with the +Program, unless a warranty or assumption of liability accompanies a +copy of the Program in return for a fee. + + END OF TERMS AND CONDITIONS + + How to Apply These Terms to Your New Programs + + If you develop a new program, and you want it to be of the greatest +possible use to the public, the best way to achieve this is to make it +free software which everyone can redistribute and change under these terms. + + To do so, attach the following notices to the program. It is safest +to attach them to the start of each source file to most effectively +state the exclusion of warranty; and each file should have at least +the "copyright" line and a pointer to where the full notice is found. + + + Copyright (C) + + This program is free software: you can redistribute it and/or modify + it under the terms of the GNU Affero General Public License as published + by the Free Software Foundation, either version 3 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU Affero General Public License for more details. + + You should have received a copy of the GNU Affero General Public License + along with this program. If not, see . + +Also add information on how to contact you by electronic and paper mail. + + If your software can interact with users remotely through a computer +network, you should also make sure that it provides a way for users to +get its source. For example, if your program is a web application, its +interface could display a "Source" link that leads users to an archive +of the code. There are many ways you could offer source, and different +solutions will be better for different programs; see section 13 for the +specific requirements. + + You should also get your employer (if you work as a programmer) or school, +if any, to sign a "copyright disclaimer" for the program, if necessary. +For more information on this, and how to apply and follow the GNU AGPL, see +. From fdf1e2ec1c58fba09b1994cedb65e7e7a5e8258c Mon Sep 17 00:00:00 2001 From: Yunfan Li Date: Tue, 5 Mar 2024 17:52:30 +0800 Subject: [PATCH 21/22] Rogue poison --- src/PlayerbotAI.cpp | 10 +++-- src/PlayerbotAI.h | 2 +- src/strategy/actions/UseItemAction.cpp | 2 +- .../rogue/GenericRogueNonCombatStrategy.cpp | 23 ++++++++++ .../rogue/GenericRogueNonCombatStrategy.h | 2 +- src/strategy/rogue/RogueActions.cpp | 42 ++++++++++++++++--- src/strategy/rogue/RogueActions.h | 8 ++++ src/strategy/rogue/RogueAiObjectContext.cpp | 2 + 8 files changed, 79 insertions(+), 12 deletions(-) diff --git a/src/PlayerbotAI.cpp b/src/PlayerbotAI.cpp index a7d7c1d86..efa9d84ae 100644 --- a/src/PlayerbotAI.cpp +++ b/src/PlayerbotAI.cpp @@ -2125,7 +2125,7 @@ bool PlayerbotAI::CanCastSpell(std::string const name, Unit* target, Item* itemT return CanCastSpell(aiObjectContext->GetValue("spell id", name)->Get(), target, true, itemTarget); } -bool PlayerbotAI::CanCastSpell(uint32 spellid, Unit* target, bool checkHasSpell, Item* itemTarget) +bool PlayerbotAI::CanCastSpell(uint32 spellid, Unit* target, bool checkHasSpell, Item* itemTarget, Item* castItem) { if (!spellid) { if (!sPlayerbotAIConfig->logInGroupOnly || (bot->GetGroup() && HasRealPlayerMaster())) { @@ -2249,9 +2249,11 @@ bool PlayerbotAI::CanCastSpell(uint32 spellid, Unit* target, bool checkHasSpell, Spell* spell = new Spell(bot, spellInfo, TRIGGERED_NONE); spell->m_targets.SetUnitTarget(target); - - spell->m_CastItem = itemTarget ? itemTarget : aiObjectContext->GetValue("item for spell", spellid)->Get(); - spell->m_targets.SetItemTarget(spell->m_CastItem); + spell->m_CastItem = castItem; + if (itemTarget == nullptr) { + itemTarget = aiObjectContext->GetValue("item for spell", spellid)->Get();; + } + spell->m_targets.SetItemTarget(itemTarget); SpellCastResult result = spell->CheckCast(true); delete spell; diff --git a/src/PlayerbotAI.h b/src/PlayerbotAI.h index 7011f0127..e515ab402 100644 --- a/src/PlayerbotAI.h +++ b/src/PlayerbotAI.h @@ -387,7 +387,7 @@ class PlayerbotAI : public PlayerbotAIBase virtual bool IsInterruptableSpellCasting(Unit* player, std::string const spell); virtual bool HasAuraToDispel(Unit* player, uint32 dispelType); - bool CanCastSpell(uint32 spellid, Unit* target, bool checkHasSpell = true, Item* itemTarget = nullptr); + bool CanCastSpell(uint32 spellid, Unit* target, bool checkHasSpell = true, Item* itemTarget = nullptr, Item* castItem = nullptr); bool CanCastSpell(uint32 spellid, GameObject* goTarget, uint8 effectMask, bool checkHasSpell = true); bool CanCastSpell(uint32 spellid, float x, float y, float z, uint8 effectMask, bool checkHasSpell = true, Item* itemTarget = nullptr); diff --git a/src/strategy/actions/UseItemAction.cpp b/src/strategy/actions/UseItemAction.cpp index 1c50c7c00..0c8b49f34 100644 --- a/src/strategy/actions/UseItemAction.cpp +++ b/src/strategy/actions/UseItemAction.cpp @@ -86,7 +86,7 @@ bool UseItemAction::UseItem(Item* item, ObjectGuid goGuid, Item* itemTarget, Uni if (item->GetTemplate()->Spells[i].SpellId > 0) { spellId = item->GetTemplate()->Spells[i].SpellId; - if (!botAI->CanCastSpell(spellId, bot, false, item)) { + if (!botAI->CanCastSpell(spellId, bot, false, itemTarget, item)) { return false; } } diff --git a/src/strategy/rogue/GenericRogueNonCombatStrategy.cpp b/src/strategy/rogue/GenericRogueNonCombatStrategy.cpp index 52c10ddc6..74d953132 100644 --- a/src/strategy/rogue/GenericRogueNonCombatStrategy.cpp +++ b/src/strategy/rogue/GenericRogueNonCombatStrategy.cpp @@ -5,6 +5,29 @@ #include "GenericRogueNonCombatStrategy.h" #include "Playerbots.h" + +class GenericRogueNonCombatStrategyActionNodeFactory : public NamedObjectFactory +{ + public: + GenericRogueNonCombatStrategyActionNodeFactory() + { + creators["use deadly poison on off hand"] = &use_deadly_poison_on_off_hand; + } + + private: + static ActionNode* use_deadly_poison_on_off_hand(PlayerbotAI* botAI) + { + return new ActionNode ("use deadly poison on off hand", + /*P*/ nullptr, + /*A*/ NextAction::array(0, new NextAction("use instant poison on off hand"), nullptr), + /*C*/ nullptr); + } +}; + +GenericRogueNonCombatStrategy::GenericRogueNonCombatStrategy(PlayerbotAI* botAI) : NonCombatStrategy(botAI) { + actionNodeFactories.Add(new GenericRogueNonCombatStrategyActionNodeFactory()); +} + void GenericRogueNonCombatStrategy::InitTriggers(std::vector& triggers) { NonCombatStrategy::InitTriggers(triggers); diff --git a/src/strategy/rogue/GenericRogueNonCombatStrategy.h b/src/strategy/rogue/GenericRogueNonCombatStrategy.h index 9a482419a..a7d2a6c66 100644 --- a/src/strategy/rogue/GenericRogueNonCombatStrategy.h +++ b/src/strategy/rogue/GenericRogueNonCombatStrategy.h @@ -12,7 +12,7 @@ class PlayerbotAI; class GenericRogueNonCombatStrategy : public NonCombatStrategy { public: - GenericRogueNonCombatStrategy(PlayerbotAI* botAI) : NonCombatStrategy(botAI) { } + GenericRogueNonCombatStrategy(PlayerbotAI* botAI); std::string const getName() override { return "nc"; } void InitTriggers(std::vector& triggers) override; diff --git a/src/strategy/rogue/RogueActions.cpp b/src/strategy/rogue/RogueActions.cpp index e0ece34c3..18df897c7 100644 --- a/src/strategy/rogue/RogueActions.cpp +++ b/src/strategy/rogue/RogueActions.cpp @@ -51,7 +51,7 @@ bool UseDeadlyPoisonAction::Execute(Event event) { std::vector items; std::string poison_name; for (std::string& suffix: poison_suffixs) { - poison_name = getName() + suffix; + poison_name = "Deadly Poison" + suffix; items = AI_VALUE2(std::vector, "inventory items", poison_name); if (!items.empty()) { break; @@ -70,7 +70,7 @@ bool UseDeadlyPoisonAction::isPossible() { std::vector items; std::string poison_name; for (std::string& suffix: poison_suffixs) { - poison_name = getName() + suffix; + poison_name = "Deadly Poison" + suffix; items = AI_VALUE2(std::vector, "inventory items", poison_name); if (!items.empty()) { break; @@ -84,7 +84,7 @@ bool UseInstantPoisonAction::Execute(Event event) { std::vector items; std::string poison_name; for (std::string& suffix: poison_suffixs) { - poison_name = getName() + suffix; + poison_name = "Instant Poison" + suffix; items = AI_VALUE2(std::vector, "inventory items", poison_name); if (!items.empty()) { break; @@ -102,11 +102,43 @@ bool UseInstantPoisonAction::isPossible() { std::vector items; std::string poison_name; for (std::string& suffix: poison_suffixs) { - poison_name = getName() + suffix; + poison_name = "Instant Poison" + suffix; items = AI_VALUE2(std::vector, "inventory items", poison_name); if (!items.empty()) { break; } } return !items.empty(); -} \ No newline at end of file +} + +bool UseInstantPoisonOffHandAction::Execute(Event event) { + std::vector poison_suffixs = {" IX", " VIII", " VII", " VI", " V", " IV", " III", " II", ""}; + std::vector items; + std::string poison_name; + for (std::string& suffix: poison_suffixs) { + poison_name = "Instant Poison" + suffix; + items = AI_VALUE2(std::vector, "inventory items", poison_name); + if (!items.empty()) { + break; + } + } + if (items.empty()) { + return false; + } + Item* const itemForSpell = bot->GetItemByPos( INVENTORY_SLOT_BAG_0, EQUIPMENT_SLOT_OFFHAND ); + return UseItem(*items.begin(), ObjectGuid::Empty, itemForSpell); +} + +bool UseInstantPoisonOffHandAction::isPossible() { + std::vector poison_suffixs = {" IX", " VIII", " VII", " VI", " V", " IV", " III", " II", ""}; + std::vector items; + std::string poison_name; + for (std::string& suffix: poison_suffixs) { + poison_name = "Instant Poison" + suffix; + items = AI_VALUE2(std::vector, "inventory items", poison_name); + if (!items.empty()) { + break; + } + } + return !items.empty(); +} diff --git a/src/strategy/rogue/RogueActions.h b/src/strategy/rogue/RogueActions.h index 4ddff1cef..b6f34972c 100644 --- a/src/strategy/rogue/RogueActions.h +++ b/src/strategy/rogue/RogueActions.h @@ -149,6 +149,14 @@ class UseInstantPoisonAction : public UseItemAction virtual bool isPossible() override; }; +class UseInstantPoisonOffHandAction : public UseItemAction +{ + public: + UseInstantPoisonOffHandAction(PlayerbotAI* ai) : UseItemAction(ai, "Instant Poison Off Hand") {} + virtual bool Execute(Event event) override; + virtual bool isPossible() override; +}; + class FanOfKnivesAction : public CastMeleeSpellAction { public: diff --git a/src/strategy/rogue/RogueAiObjectContext.cpp b/src/strategy/rogue/RogueAiObjectContext.cpp index cdb6792e9..469ab00ed 100644 --- a/src/strategy/rogue/RogueAiObjectContext.cpp +++ b/src/strategy/rogue/RogueAiObjectContext.cpp @@ -133,6 +133,7 @@ class RogueAiObjectContextInternal : public NamedObjectContext creators["tricks of the trade on main tank"] = &RogueAiObjectContextInternal::tricks_of_the_trade_on_main_tank; creators["use instant poison on main hand"] = &RogueAiObjectContextInternal::use_instant_poison; creators["use deadly poison on off hand"] = &RogueAiObjectContextInternal::use_deadly_poison; + creators["use instant poison on off hand"] = &RogueAiObjectContextInternal::use_instant_poison_off_hand; creators["fan of knives"] = &RogueAiObjectContextInternal::fan_of_knives; creators["killing spree"] = &RogueAiObjectContextInternal::killing_spree; } @@ -169,6 +170,7 @@ class RogueAiObjectContextInternal : public NamedObjectContext static Action* tricks_of_the_trade_on_main_tank(PlayerbotAI* ai) { return new CastTricksOfTheTradeOnMainTankAction(ai); } static Action* use_instant_poison(PlayerbotAI* ai) { return new UseInstantPoisonAction(ai); } static Action* use_deadly_poison(PlayerbotAI* ai) { return new UseDeadlyPoisonAction(ai); } + static Action* use_instant_poison_off_hand(PlayerbotAI* ai) { return new UseInstantPoisonOffHandAction(ai); } static Action* fan_of_knives(PlayerbotAI* ai) { return new FanOfKnivesAction(ai); } static Action* killing_spree(PlayerbotAI* ai) { return new CastKillingSpreeAction(ai); } }; From 7ec64345fa9d65808139a7df4895cda8b0a45b7e Mon Sep 17 00:00:00 2001 From: Yunfan Li Date: Tue, 5 Mar 2024 18:24:21 +0800 Subject: [PATCH 22/22] Remove tell master cooldown --- src/PlayerbotAI.cpp | 21 +++++++++++---------- 1 file changed, 11 insertions(+), 10 deletions(-) diff --git a/src/PlayerbotAI.cpp b/src/PlayerbotAI.cpp index efa9d84ae..4c5531201 100644 --- a/src/PlayerbotAI.cpp +++ b/src/PlayerbotAI.cpp @@ -1878,18 +1878,19 @@ bool PlayerbotAI::TellMasterNoFacing(std::string const text, PlayerbotSecurityLe return false; time_t lastSaid = whispers[text]; - if (!lastSaid || (time(nullptr) - lastSaid) >= sPlayerbotAIConfig->repeatDelay / 1000) - { - whispers[text] = time(nullptr); + // Yunfan: Remove tell cooldown + // if (!lastSaid || (time(nullptr) - lastSaid) >= sPlayerbotAIConfig->repeatDelay / 1000) + // { + whispers[text] = time(nullptr); - ChatMsg type = CHAT_MSG_WHISPER; - if (currentChat.second - time(nullptr) >= 1) - type = currentChat.first; + ChatMsg type = CHAT_MSG_WHISPER; + if (currentChat.second - time(nullptr) >= 1) + type = currentChat.first; - WorldPacket data; - ChatHandler::BuildChatPacket(data, type == CHAT_MSG_ADDON ? CHAT_MSG_PARTY : type, type == CHAT_MSG_ADDON ? LANG_ADDON : LANG_UNIVERSAL, bot, nullptr, text.c_str()); - master->SendDirectMessage(&data); - } + WorldPacket data; + ChatHandler::BuildChatPacket(data, type == CHAT_MSG_ADDON ? CHAT_MSG_PARTY : type, type == CHAT_MSG_ADDON ? LANG_ADDON : LANG_UNIVERSAL, bot, nullptr, text.c_str()); + master->SendDirectMessage(&data); + // } return true; }