diff --git a/common/database/database_update_manifest_bots.cpp b/common/database/database_update_manifest_bots.cpp index 27cc883c1..8e20f8a4c 100644 --- a/common/database/database_update_manifest_bots.cpp +++ b/common/database/database_update_manifest_bots.cpp @@ -61,6 +61,29 @@ DROP TABLE IF EXISTS `bot_group_members`; SET FOREIGN_KEY_CHECKS = 1; )", }, + ManifestEntry{ + .version = 9040, + .description = "2023_11_16_bot_starting_items.sql", + .check = "SHOW TABLES LIKE 'bot_starting_items'", + .condition = "", + .match = "empty", + .sql = R"( +CREATE TABLE `bot_starting_items` ( +`id` int(11) UNSIGNED NOT NULL AUTO_INCREMENT, +`races` int(11) UNSIGNED NOT NULL DEFAULT 0, +`classes` int(11) UNSIGNED NOT NULL DEFAULT 0, +`item_id` int(11) UNSIGNED NOT NULL DEFAULT 0, +`item_charges` tinyint(3) UNSIGNED NOT NULL DEFAULT 1, +`min_status` tinyint(3) UNSIGNED NOT NULL DEFAULT 0, +`slot_id` mediumint(9) NOT NULL DEFAULT -1, +`min_expansion` tinyint(4) NOT NULL DEFAULT -1, +`max_expansion` tinyint(4) NOT NULL DEFAULT -1, +`content_flags` varchar(100) CHARACTER SET latin1 COLLATE latin1_swedish_ci NULL DEFAULT NULL, +`content_flags_disabled` varchar(100) CHARACTER SET latin1 COLLATE latin1_swedish_ci NULL DEFAULT NULL, +PRIMARY KEY (`id`) +) ENGINE = InnoDB CHARACTER SET = latin1 COLLATE = latin1_swedish_ci; +)" + } // -- template; copy/paste this when you need to create a new entry // ManifestEntry{ // .version = 9228, diff --git a/common/repositories/base/base_bot_starting_items_repository.h b/common/repositories/base/base_bot_starting_items_repository.h new file mode 100644 index 000000000..da0ad2ccc --- /dev/null +++ b/common/repositories/base/base_bot_starting_items_repository.h @@ -0,0 +1,414 @@ +/** + * DO NOT MODIFY THIS FILE + * + * This repository was automatically generated and is NOT to be modified directly. + * Any repository modifications are meant to be made to the repository extending the base. + * Any modifications to base repositories are to be made by the generator only + * + * @generator ./utils/scripts/generators/repository-generator.pl + * @docs https://eqemu.gitbook.io/server/in-development/developer-area/repositories + */ + +#ifndef EQEMU_BASE_BOT_STARTING_ITEMS_REPOSITORY_H +#define EQEMU_BASE_BOT_STARTING_ITEMS_REPOSITORY_H + +#include "../../database.h" +#include "../../strings.h" +#include + + +class BaseBotStartingItemsRepository { +public: + struct BotStartingItems { + uint32_t id; + uint32_t races; + uint32_t classes; + uint32_t item_id; + uint8_t item_charges; + int32_t slot_id; + int8_t min_expansion; + int8_t max_expansion; + std::string content_flags; + std::string content_flags_disabled; + }; + + static std::string PrimaryKey() + { + return std::string("id"); + } + + static std::vector Columns() + { + return { + "id", + "races", + "classes", + "item_id", + "item_charges", + "slot_id", + "min_expansion", + "max_expansion", + "content_flags", + "content_flags_disabled", + }; + } + + static std::vector SelectColumns() + { + return { + "id", + "races", + "classes", + "item_id", + "item_charges", + "slot_id", + "min_expansion", + "max_expansion", + "content_flags", + "content_flags_disabled", + }; + } + + static std::string ColumnsRaw() + { + return std::string(Strings::Implode(", ", Columns())); + } + + static std::string SelectColumnsRaw() + { + return std::string(Strings::Implode(", ", SelectColumns())); + } + + static std::string TableName() + { + return std::string("bot_starting_items"); + } + + static std::string BaseSelect() + { + return fmt::format( + "SELECT {} FROM {}", + SelectColumnsRaw(), + TableName() + ); + } + + static std::string BaseInsert() + { + return fmt::format( + "INSERT INTO {} ({}) ", + TableName(), + ColumnsRaw() + ); + } + + static BotStartingItems NewEntity() + { + BotStartingItems e{}; + + e.id = 0; + e.races = 0; + e.classes = 0; + e.item_id = 0; + e.item_charges = 1; + e.slot_id = -1; + e.min_expansion = -1; + e.max_expansion = -1; + e.content_flags = ""; + e.content_flags_disabled = ""; + + return e; + } + + static BotStartingItems GetBotStartingItems( + const std::vector &bot_starting_itemss, + int bot_starting_items_id + ) + { + for (auto &bot_starting_items : bot_starting_itemss) { + if (bot_starting_items.id == bot_starting_items_id) { + return bot_starting_items; + } + } + + return NewEntity(); + } + + static BotStartingItems FindOne( + Database& db, + int bot_starting_items_id + ) + { + auto results = db.QueryDatabase( + fmt::format( + "{} WHERE {} = {} LIMIT 1", + BaseSelect(), + PrimaryKey(), + bot_starting_items_id + ) + ); + + auto row = results.begin(); + if (results.RowCount() == 1) { + BotStartingItems e{}; + + e.id = static_cast(strtoul(row[0], nullptr, 10)); + e.races = static_cast(strtoul(row[1], nullptr, 10)); + e.classes = static_cast(strtoul(row[2], nullptr, 10)); + e.item_id = static_cast(strtoul(row[3], nullptr, 10)); + e.item_charges = static_cast(strtoul(row[4], nullptr, 10)); + e.slot_id = static_cast(atoi(row[5])); + e.min_expansion = static_cast(atoi(row[6])); + e.max_expansion = static_cast(atoi(row[7])); + e.content_flags = row[8] ? row[8] : ""; + e.content_flags_disabled = row[9] ? row[9] : ""; + + return e; + } + + return NewEntity(); + } + + static int DeleteOne( + Database& db, + int bot_starting_items_id + ) + { + auto results = db.QueryDatabase( + fmt::format( + "DELETE FROM {} WHERE {} = {}", + TableName(), + PrimaryKey(), + bot_starting_items_id + ) + ); + + return (results.Success() ? results.RowsAffected() : 0); + } + + static int UpdateOne( + Database& db, + const BotStartingItems &e + ) + { + std::vector v; + + auto columns = Columns(); + + v.push_back(columns[1] + " = " + std::to_string(e.races)); + v.push_back(columns[2] + " = " + std::to_string(e.classes)); + v.push_back(columns[3] + " = " + std::to_string(e.item_id)); + v.push_back(columns[4] + " = " + std::to_string(e.item_charges)); + v.push_back(columns[5] + " = " + std::to_string(e.slot_id)); + v.push_back(columns[6] + " = " + std::to_string(e.min_expansion)); + v.push_back(columns[7] + " = " + std::to_string(e.max_expansion)); + v.push_back(columns[8] + " = '" + Strings::Escape(e.content_flags) + "'"); + v.push_back(columns[9] + " = '" + Strings::Escape(e.content_flags_disabled) + "'"); + + auto results = db.QueryDatabase( + fmt::format( + "UPDATE {} SET {} WHERE {} = {}", + TableName(), + Strings::Implode(", ", v), + PrimaryKey(), + e.id + ) + ); + + return (results.Success() ? results.RowsAffected() : 0); + } + + static BotStartingItems InsertOne( + Database& db, + BotStartingItems e + ) + { + std::vector v; + + v.push_back(std::to_string(e.id)); + v.push_back(std::to_string(e.races)); + v.push_back(std::to_string(e.classes)); + v.push_back(std::to_string(e.item_id)); + v.push_back(std::to_string(e.item_charges)); + v.push_back(std::to_string(e.slot_id)); + v.push_back(std::to_string(e.min_expansion)); + v.push_back(std::to_string(e.max_expansion)); + v.push_back("'" + Strings::Escape(e.content_flags) + "'"); + v.push_back("'" + Strings::Escape(e.content_flags_disabled) + "'"); + + auto results = db.QueryDatabase( + fmt::format( + "{} VALUES ({})", + BaseInsert(), + Strings::Implode(",", v) + ) + ); + + if (results.Success()) { + e.id = results.LastInsertedID(); + return e; + } + + e = NewEntity(); + + return e; + } + + static int InsertMany( + Database& db, + const std::vector &entries + ) + { + std::vector insert_chunks; + + for (auto &e: entries) { + std::vector v; + + v.push_back(std::to_string(e.id)); + v.push_back(std::to_string(e.races)); + v.push_back(std::to_string(e.classes)); + v.push_back(std::to_string(e.item_id)); + v.push_back(std::to_string(e.item_charges)); + v.push_back(std::to_string(e.slot_id)); + v.push_back(std::to_string(e.min_expansion)); + v.push_back(std::to_string(e.max_expansion)); + v.push_back("'" + Strings::Escape(e.content_flags) + "'"); + v.push_back("'" + Strings::Escape(e.content_flags_disabled) + "'"); + + insert_chunks.push_back("(" + Strings::Implode(",", v) + ")"); + } + + std::vector v; + + auto results = db.QueryDatabase( + fmt::format( + "{} VALUES {}", + BaseInsert(), + Strings::Implode(",", insert_chunks) + ) + ); + + return (results.Success() ? results.RowsAffected() : 0); + } + + static std::vector All(Database& db) + { + std::vector all_entries; + + auto results = db.QueryDatabase( + fmt::format( + "{}", + BaseSelect() + ) + ); + + all_entries.reserve(results.RowCount()); + + for (auto row = results.begin(); row != results.end(); ++row) { + BotStartingItems e{}; + + e.id = static_cast(strtoul(row[0], nullptr, 10)); + e.races = static_cast(strtoul(row[1], nullptr, 10)); + e.classes = static_cast(strtoul(row[2], nullptr, 10)); + e.item_id = static_cast(strtoul(row[3], nullptr, 10)); + e.item_charges = static_cast(strtoul(row[4], nullptr, 10)); + e.slot_id = static_cast(atoi(row[5])); + e.min_expansion = static_cast(atoi(row[6])); + e.max_expansion = static_cast(atoi(row[7])); + e.content_flags = row[8] ? row[8] : ""; + e.content_flags_disabled = row[9] ? row[9] : ""; + + all_entries.push_back(e); + } + + return all_entries; + } + + static std::vector GetWhere(Database& db, const std::string &where_filter) + { + std::vector all_entries; + + auto results = db.QueryDatabase( + fmt::format( + "{} WHERE {}", + BaseSelect(), + where_filter + ) + ); + + all_entries.reserve(results.RowCount()); + + for (auto row = results.begin(); row != results.end(); ++row) { + BotStartingItems e{}; + + e.id = static_cast(strtoul(row[0], nullptr, 10)); + e.races = static_cast(strtoul(row[1], nullptr, 10)); + e.classes = static_cast(strtoul(row[2], nullptr, 10)); + e.item_id = static_cast(strtoul(row[3], nullptr, 10)); + e.item_charges = static_cast(strtoul(row[4], nullptr, 10)); + e.slot_id = static_cast(atoi(row[5])); + e.min_expansion = static_cast(atoi(row[6])); + e.max_expansion = static_cast(atoi(row[7])); + e.content_flags = row[8] ? row[8] : ""; + e.content_flags_disabled = row[9] ? row[9] : ""; + + all_entries.push_back(e); + } + + return all_entries; + } + + static int DeleteWhere(Database& db, const std::string &where_filter) + { + auto results = db.QueryDatabase( + fmt::format( + "DELETE FROM {} WHERE {}", + TableName(), + where_filter + ) + ); + + return (results.Success() ? results.RowsAffected() : 0); + } + + static int Truncate(Database& db) + { + auto results = db.QueryDatabase( + fmt::format( + "TRUNCATE TABLE {}", + TableName() + ) + ); + + return (results.Success() ? results.RowsAffected() : 0); + } + + static int64 GetMaxId(Database& db) + { + auto results = db.QueryDatabase( + fmt::format( + "SELECT COALESCE(MAX({}), 0) FROM {}", + PrimaryKey(), + TableName() + ) + ); + + return (results.Success() && results.begin()[0] ? strtoll(results.begin()[0], nullptr, 10) : 0); + } + + static int64 Count(Database& db, const std::string &where_filter = "") + { + auto results = db.QueryDatabase( + fmt::format( + "SELECT COUNT(*) FROM {} {}", + TableName(), + (where_filter.empty() ? "" : "WHERE " + where_filter) + ) + ); + + return (results.Success() && results.begin()[0] ? strtoll(results.begin()[0], nullptr, 10) : 0); + } + +}; + +#endif //EQEMU_BASE_BOT_STARTING_ITEMS_REPOSITORY_H diff --git a/common/repositories/bot_starting_items_repository.h b/common/repositories/bot_starting_items_repository.h new file mode 100644 index 000000000..6dbb5915d --- /dev/null +++ b/common/repositories/bot_starting_items_repository.h @@ -0,0 +1,50 @@ +#ifndef EQEMU_BOT_STARTING_ITEMS_REPOSITORY_H +#define EQEMU_BOT_STARTING_ITEMS_REPOSITORY_H + +#include "../database.h" +#include "../strings.h" +#include "base/base_bot_starting_items_repository.h" + +class BotStartingItemsRepository: public BaseBotStartingItemsRepository { +public: + + /** + * This file was auto generated and can be modified and extended upon + * + * Base repository methods are automatically + * generated in the "base" version of this repository. The base repository + * is immutable and to be left untouched, while methods in this class + * are used as extension methods for more specific persistence-layer + * accessors or mutators. + * + * Base Methods (Subject to be expanded upon in time) + * + * Note: Not all tables are designed appropriately to fit functionality with all base methods + * + * InsertOne + * UpdateOne + * DeleteOne + * FindOne + * GetWhere(std::string where_filter) + * DeleteWhere(std::string where_filter) + * InsertMany + * All + * + * Example custom methods in a repository + * + * BotStartingItemsRepository::GetByZoneAndVersion(int zone_id, int zone_version) + * BotStartingItemsRepository::GetWhereNeverExpires() + * BotStartingItemsRepository::GetWhereXAndY() + * BotStartingItemsRepository::DeleteWhereXAndY() + * + * Most of the above could be covered by base methods, but if you as a developer + * find yourself re-using logic for other parts of the code, its best to just make a + * method that can be re-used easily elsewhere especially if it can use a base repository + * method and encapsulate filters there + */ + + // Custom extended repository methods here + +}; + +#endif //EQEMU_BOT_STARTING_ITEMS_REPOSITORY_H diff --git a/common/version.h b/common/version.h index 4cc176908..8121bf0a8 100644 --- a/common/version.h +++ b/common/version.h @@ -44,7 +44,7 @@ #define CURRENT_BINARY_DATABASE_VERSION 9237 -#define CURRENT_BINARY_BOTS_DATABASE_VERSION 9039 +#define CURRENT_BINARY_BOTS_DATABASE_VERSION 9040 #endif diff --git a/zone/bot.cpp b/zone/bot.cpp index 0a22ea4f8..77b6c1c47 100644 --- a/zone/bot.cpp +++ b/zone/bot.cpp @@ -22,8 +22,11 @@ #include "doors.h" #include "quest_parser_collection.h" #include "lua_parser.h" +#include "../common/repositories/bot_inventories_repository.h" #include "../common/repositories/bot_spell_settings_repository.h" +#include "../common/repositories/bot_starting_items_repository.h" #include "../common/data_verification.h" +#include "../common/repositories/criteria/content_filter_criteria.h" // This constructor is used during the bot create command Bot::Bot(NPCType *npcTypeData, Client* botOwner) : NPC(npcTypeData, nullptr, glm::vec4(), Ground, false), rest_timer(1), ping_timer(1) { @@ -8727,4 +8730,48 @@ bool Bot::CheckSpawnConditions(Client* c) { return true; } +void Bot::AddBotStartingItems(uint16 race_id, uint8 class_id) +{ + if (!IsPlayerRace(race_id) || !IsPlayerClass(class_id)) { + return; + } + + const uint16 race_bitmask = GetPlayerRaceBit(race_id); + const uint16 class_bitmask = GetPlayerClassBit(class_id); + + const auto& l = BotStartingItemsRepository::GetWhere( + content_db, + fmt::format( + "(races & {} OR races = 0) AND " + "(classes & {} OR classes = 0) {}", + race_bitmask, + class_bitmask, + ContentFilterCriteria::apply() + ) + ); + + if (l.empty()) { + return; + } + + std::vector v; + + for (const auto& e : l) { + if ( + CanClassEquipItem(e.item_id) && + (CanRaceEquipItem(e.item_id) || RuleB(Bots, AllowBotEquipAnyRaceGear)) + ) { + auto i = BotInventoriesRepository::NewEntity(); + i.bot_id = GetBotID(); + i.slot_id = e.slot_id; + i.item_id = e.item_id; + i.inst_charges = e.item_charges; + + v.emplace_back(i); + } + } + + BotInventoriesRepository::InsertMany(content_db, v); +} + uint8 Bot::spell_casting_chances[SPELL_TYPE_COUNT][PLAYER_CLASS_COUNT][EQ::constants::STANCE_TYPE_COUNT][cntHSND] = { 0 }; diff --git a/zone/bot.h b/zone/bot.h index 12fbabf4c..b1c7706f5 100644 --- a/zone/bot.h +++ b/zone/bot.h @@ -460,6 +460,8 @@ public: uint8 gender ); + void AddBotStartingItems(uint16 race_id, uint8 class_id); + // Static Bot Group Methods static bool AddBotToGroup(Bot* bot, Group* group); static bool RemoveBotFromGroup(Bot* bot, Group* group); diff --git a/zone/bot_command.cpp b/zone/bot_command.cpp index 049b8fe68..0ece538be 100644 --- a/zone/bot_command.cpp +++ b/zone/bot_command.cpp @@ -9041,6 +9041,8 @@ uint32 helper_bot_create(Client *bot_owner, std::string bot_name, uint8 bot_clas parse->EventPlayer(EVENT_BOT_CREATE, bot_owner, export_string, 0); } + my_bot->AddBotStartingItems(bot_race, bot_class); + safe_delete(my_bot); return bot_id; diff --git a/zone/questmgr.cpp b/zone/questmgr.cpp index 06bd4bb93..8e1bc724b 100644 --- a/zone/questmgr.cpp +++ b/zone/questmgr.cpp @@ -2650,6 +2650,8 @@ bool QuestManager::createBot(const char *name, const char *lastname, uint8 level ).c_str() ); } else { + new_bot->AddBotStartingItems(race, botclass); + initiator->Message( Chat::White, fmt::format(