diff --git a/data/XML/vocations.xml b/data/XML/vocations.xml index 22535452a2b..7d23db6ba1b 100644 --- a/data/XML/vocations.xml +++ b/data/XML/vocations.xml @@ -1,6 +1,6 @@ - + @@ -11,6 +11,20 @@ + + + + + + + + + + + + + + @@ -23,6 +37,20 @@ + + + + + + + + + + + + + + @@ -35,6 +63,20 @@ + + + + + + + + + + + + + + @@ -47,6 +89,20 @@ + + + + + + + + + + + + + + @@ -59,6 +115,20 @@ + + + + + + + + + + + + + + @@ -71,6 +141,20 @@ + + + + + + + + + + + + + + @@ -83,6 +167,20 @@ + + + + + + + + + + + + + + @@ -95,6 +193,20 @@ + + + + + + + + + + + + + + @@ -107,6 +219,20 @@ + + + + + + + + + + + + + + @@ -119,6 +245,20 @@ + + + + + + + + + + + + + + @@ -134,6 +274,20 @@ + + + + + + + + + + + + + + @@ -149,6 +303,20 @@ + + + + + + + + + + + + + + @@ -164,6 +332,20 @@ + + + + + + + + + + + + + + diff --git a/data/scripts/talkactions/god/add_skill.lua b/data/scripts/talkactions/god/add_skill.lua index 3d082f656af..d260b1002d8 100644 --- a/data/scripts/talkactions/god/add_skill.lua +++ b/data/scripts/talkactions/god/add_skill.lua @@ -2,9 +2,11 @@ local skillMap = { club = SKILL_CLUB, sword = SKILL_SWORD, axe = SKILL_AXE, - dist = SKILL_DISTANCE, + distance = SKILL_DISTANCE, shield = SKILL_SHIELD, - fish = SKILL_FISHING, + fishing = SKILL_FISHING, + --[[woodcutting = SKILL_WOODCUTTING, + mining = SKILL_MINING,]] --XXXXX NOT WORKING ON NEW SKILLS? } local function getSkillId(skillName) diff --git a/schema.sql b/schema.sql index 86ea9e1bf6b..506020bd9ea 100644 --- a/schema.sql +++ b/schema.sql @@ -109,6 +109,34 @@ CREATE TABLE IF NOT EXISTS `players` ( `skill_shielding_tries` bigint(20) UNSIGNED NOT NULL DEFAULT '0', `skill_fishing` int(10) UNSIGNED NOT NULL DEFAULT '10', `skill_fishing_tries` bigint(20) UNSIGNED NOT NULL DEFAULT '0', + `skill_mining` int(10) UNSIGNED NOT NULL DEFAULT '10', + `skill_mining_tries` bigint(20) UNSIGNED NOT NULL DEFAULT '0', + `skill_smithing` int(10) UNSIGNED NOT NULL DEFAULT '10', + `skill_smithing_tries` bigint(20) UNSIGNED NOT NULL DEFAULT '0', + `skill_enchanting` int(10) UNSIGNED NOT NULL DEFAULT '10', + `skill_enchanting_tries` bigint(20) UNSIGNED NOT NULL DEFAULT '0', + `skill_woodcutting` int(10) UNSIGNED NOT NULL DEFAULT '10', + `skill_woodcutting_tries` bigint(20) UNSIGNED NOT NULL DEFAULT '0', + `skill_fletching` int(10) UNSIGNED NOT NULL DEFAULT '10', + `skill_fletching_tries` bigint(20) UNSIGNED NOT NULL DEFAULT '0', + `skill_hunting` int(10) UNSIGNED NOT NULL DEFAULT '10', + `skill_hunting_tries` bigint(20) UNSIGNED NOT NULL DEFAULT '0', + `skill_farming` int(10) UNSIGNED NOT NULL DEFAULT '10', + `skill_farming_tries` bigint(20) UNSIGNED NOT NULL DEFAULT '0', + `skill_cooking` int(10) UNSIGNED NOT NULL DEFAULT '10', + `skill_cooking_tries` bigint(20) UNSIGNED NOT NULL DEFAULT '0', + `skill_crafting` int(10) UNSIGNED NOT NULL DEFAULT '10', + `skill_crafting_tries` bigint(20) UNSIGNED NOT NULL DEFAULT '0', + `skill_herblore` int(10) UNSIGNED NOT NULL DEFAULT '10', + `skill_herblore_tries` bigint(20) UNSIGNED NOT NULL DEFAULT '0', + `skill_alchemy` int(10) UNSIGNED NOT NULL DEFAULT '10', + `skill_alchemy_tries` bigint(20) UNSIGNED NOT NULL DEFAULT '0', + `skill_archaeology` int(10) UNSIGNED NOT NULL DEFAULT '10', + `skill_archaeology_tries` bigint(20) UNSIGNED NOT NULL DEFAULT '0', + `skill_music` int(10) UNSIGNED NOT NULL DEFAULT '10', + `skill_music_tries` bigint(20) UNSIGNED NOT NULL DEFAULT '0', + `skill_wisdom` int(10) UNSIGNED NOT NULL DEFAULT '10', + `skill_wisdom_tries` bigint(20) UNSIGNED NOT NULL DEFAULT '0', `skill_critical_hit_chance` int(10) UNSIGNED NOT NULL DEFAULT '0', `skill_critical_hit_chance_tries` bigint(20) UNSIGNED NOT NULL DEFAULT '0', `skill_critical_hit_damage` int(10) UNSIGNED NOT NULL DEFAULT '0', diff --git a/src/creatures/combat/condition.cpp b/src/creatures/combat/condition.cpp index da90b03f65a..6eb2fbc9afe 100644 --- a/src/creatures/combat/condition.cpp +++ b/src/creatures/combat/condition.cpp @@ -931,6 +931,146 @@ bool ConditionAttributes::setParam(ConditionParam_t param, int32_t value) { return true; } + case CONDITION_PARAM_SKILL_MINING: { + skills[SKILL_MINING] = value; + return true; + } + + case CONDITION_PARAM_SKILL_MININGPERCENT: { + skillsPercent[SKILL_MINING] = value; + return true; + } + + case CONDITION_PARAM_SKILL_SMITHING: { + skills[SKILL_SMITHING] = value; + return true; + } + + case CONDITION_PARAM_SKILL_SMITHINGPERCENT: { + skillsPercent[SKILL_SMITHING] = value; + return true; + } + + case CONDITION_PARAM_SKILL_ENCHANTING: { + skills[SKILL_ENCHANTING] = value; + return true; + } + + case CONDITION_PARAM_SKILL_ENCHANTINGPERCENT: { + skillsPercent[SKILL_ENCHANTING] = value; + return true; + } + + case CONDITION_PARAM_SKILL_WOODCUTTING: { + skills[SKILL_WOODCUTTING] = value; + return true; + } + + case CONDITION_PARAM_SKILL_WOODCUTTINGPERCENT: { + skillsPercent[SKILL_WOODCUTTING] = value; + return true; + } + + case CONDITION_PARAM_SKILL_FLETCHING: { + skills[SKILL_FLETCHING] = value; + return true; + } + + case CONDITION_PARAM_SKILL_FLETCHINGPERCENT: { + skillsPercent[SKILL_FLETCHING] = value; + return true; + } + + case CONDITION_PARAM_SKILL_HUNTING: { + skills[SKILL_HUNTING] = value; + return true; + } + + case CONDITION_PARAM_SKILL_HUNTINGPERCENT: { + skillsPercent[SKILL_HUNTING] = value; + return true; + } + + case CONDITION_PARAM_SKILL_FARMING: { + skills[SKILL_FARMING] = value; + return true; + } + + case CONDITION_PARAM_SKILL_FARMINGPERCENT: { + skillsPercent[SKILL_FARMING] = value; + return true; + } + + case CONDITION_PARAM_SKILL_COOKING: { + skills[SKILL_COOKING] = value; + return true; + } + + case CONDITION_PARAM_SKILL_COOKINGPERCENT: { + skillsPercent[SKILL_COOKING] = value; + return true; + } + + case CONDITION_PARAM_SKILL_CRAFTING: { + skills[SKILL_CRAFTING] = value; + return true; + } + + case CONDITION_PARAM_SKILL_CRAFTINGPERCENT: { + skillsPercent[SKILL_CRAFTING] = value; + return true; + } + + case CONDITION_PARAM_SKILL_HERBLORE: { + skills[SKILL_HERBLORE] = value; + return true; + } + + case CONDITION_PARAM_SKILL_HERBLOREPERCENT: { + skillsPercent[SKILL_HERBLORE] = value; + return true; + } + + case CONDITION_PARAM_SKILL_ALCHEMY: { + skills[SKILL_ALCHEMY] = value; + return true; + } + + case CONDITION_PARAM_SKILL_ALCHEMYPERCENT: { + skillsPercent[SKILL_ALCHEMY] = value; + return true; + } + + case CONDITION_PARAM_SKILL_ARCHAEOLOGY: { + skills[SKILL_ARCHAEOLOGY] = value; + return true; + } + + case CONDITION_PARAM_SKILL_ARCHAEOLOGYPERCENT: { + skillsPercent[SKILL_ARCHAEOLOGY] = value; + return true; + } + + case CONDITION_PARAM_SKILL_MUSIC: { + skills[SKILL_MUSIC] = value; + return true; + } + + case CONDITION_PARAM_SKILL_MUSICPERCENT: { + skillsPercent[SKILL_MUSIC] = value; + return true; + } + + case CONDITION_PARAM_SKILL_WISDOM: { + skills[SKILL_WISDOM] = value; + return true; + } + + case CONDITION_PARAM_SKILL_WISDOMPERCENT: { + skillsPercent[SKILL_WISDOM] = value; + return true; + } + case CONDITION_PARAM_SKILL_CRITICAL_HIT_CHANCE: { skills[SKILL_CRITICAL_HIT_CHANCE] = value; return true; diff --git a/src/creatures/creatures_definitions.hpp b/src/creatures/creatures_definitions.hpp index aa7438c5aa6..89b90c049a1 100644 --- a/src/creatures/creatures_definitions.hpp +++ b/src/creatures/creatures_definitions.hpp @@ -222,6 +222,34 @@ enum ConditionParam_t { CONDITION_PARAM_INCREASE_MANADRAINPERCENT = 80, CONDITION_PARAM_INCREASE_DROWNPERCENT = 81, CONDITION_PARAM_CHARM_CHANCE_MODIFIER = 82, + CONDITION_PARAM_SKILL_MINING = 200, + CONDITION_PARAM_SKILL_MININGPERCENT = 201, + CONDITION_PARAM_SKILL_SMITHING = 202, + CONDITION_PARAM_SKILL_SMITHINGPERCENT = 203, + CONDITION_PARAM_SKILL_ENCHANTING = 204, + CONDITION_PARAM_SKILL_ENCHANTINGPERCENT = 205, + CONDITION_PARAM_SKILL_WOODCUTTING = 206, + CONDITION_PARAM_SKILL_WOODCUTTINGPERCENT = 207, + CONDITION_PARAM_SKILL_FLETCHING = 208, + CONDITION_PARAM_SKILL_FLETCHINGPERCENT = 209, + CONDITION_PARAM_SKILL_HUNTING = 210, + CONDITION_PARAM_SKILL_HUNTINGPERCENT = 211, + CONDITION_PARAM_SKILL_FARMING = 212, + CONDITION_PARAM_SKILL_FARMINGPERCENT = 213, + CONDITION_PARAM_SKILL_COOKING = 214, + CONDITION_PARAM_SKILL_COOKINGPERCENT = 215, + CONDITION_PARAM_SKILL_CRAFTING = 216, + CONDITION_PARAM_SKILL_CRAFTINGPERCENT = 217, + CONDITION_PARAM_SKILL_HERBLORE = 218, + CONDITION_PARAM_SKILL_HERBLOREPERCENT = 219, + CONDITION_PARAM_SKILL_ALCHEMY = 220, + CONDITION_PARAM_SKILL_ALCHEMYPERCENT = 221, + CONDITION_PARAM_SKILL_ARCHAEOLOGY = 222, + CONDITION_PARAM_SKILL_ARCHAEOLOGYPERCENT = 223, + CONDITION_PARAM_SKILL_MUSIC = 224, + CONDITION_PARAM_SKILL_MUSICPERCENT = 225, + CONDITION_PARAM_SKILL_WISDOM = 226, + CONDITION_PARAM_SKILL_WISDOMPERCENT = 227, }; enum stats_t { @@ -413,15 +441,28 @@ enum skills_t : int8_t { SKILL_DISTANCE = 4, SKILL_SHIELD = 5, SKILL_FISHING = 6, - SKILL_CRITICAL_HIT_CHANCE = 7, - SKILL_CRITICAL_HIT_DAMAGE = 8, - SKILL_LIFE_LEECH_CHANCE = 9, - SKILL_LIFE_LEECH_AMOUNT = 10, - SKILL_MANA_LEECH_CHANCE = 11, - SKILL_MANA_LEECH_AMOUNT = 12, - - SKILL_MAGLEVEL = 13, - SKILL_LEVEL = 14, + SKILL_MINING = 7, + SKILL_SMITHING = 8, + SKILL_ENCHANTING = 9, + SKILL_WOODCUTTING = 10, + SKILL_FLETCHING = 11, + SKILL_HUNTING = 12, + SKILL_FARMING = 13, + SKILL_COOKING = 14, + SKILL_CRAFTING = 15, + SKILL_HERBLORE = 16, + SKILL_ALCHEMY = 17, + SKILL_ARCHAEOLOGY = 18, + SKILL_MUSIC = 19, + SKILL_WISDOM = 20, + SKILL_CRITICAL_HIT_CHANCE = 21, + SKILL_CRITICAL_HIT_DAMAGE = 22, + SKILL_LIFE_LEECH_CHANCE = 23, + SKILL_LIFE_LEECH_AMOUNT = 24, + SKILL_MANA_LEECH_CHANCE = 25, + SKILL_MANA_LEECH_AMOUNT = 26, + SKILL_MAGLEVEL = 27, + SKILL_LEVEL = 28, SKILL_FIRST = SKILL_FIST, SKILL_LAST = SKILL_MANA_LEECH_AMOUNT diff --git a/src/creatures/players/vocations/vocation.cpp b/src/creatures/players/vocations/vocation.cpp index f36494895f5..ef2c5a4d5dd 100644 --- a/src/creatures/players/vocations/vocation.cpp +++ b/src/creatures/players/vocations/vocation.cpp @@ -233,7 +233,7 @@ uint16_t Vocations::getPromotedVocation(uint16_t vocationId) const { return VOCATION_NONE; } -uint32_t Vocation::skillBase[SKILL_LAST + 1] = { 50, 50, 50, 50, 30, 100, 20 }; +uint32_t Vocation::skillBase[SKILL_LAST + 1] = { 50, 50, 50, 50, 30, 100, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20 }; constexpr uint16_t minSkillLevel = 10; const std::string &Vocation::getVocName() const { diff --git a/src/creatures/players/vocations/vocation.hpp b/src/creatures/players/vocations/vocation.hpp index 21a4ea79710..640f2c822c4 100644 --- a/src/creatures/players/vocations/vocation.hpp +++ b/src/creatures/players/vocations/vocation.hpp @@ -89,7 +89,7 @@ class Vocation { std::string name = "none"; std::string description; - float skillMultipliers[SKILL_LAST + 1] = { 1.5f, 2.0f, 2.0f, 2.0f, 2.0f, 1.5f, 1.1f }; + float skillMultipliers[SKILL_LAST + 1] = { 1.5f, 2.0f, 2.0f, 2.0f, 2.0f, 1.5f, 1.1f, 1.1f, 1.1f, 1.1f, 1.1f, 1.1f, 1.1f, 1.1f, 1.1f, 1.1f, 1.1f, 1.1f, 1.1f, 1.1f, 1.1f }; float manaMultiplier = 4.0f; uint32_t gainHealthTicks = 6; diff --git a/src/game/game.cpp b/src/game/game.cpp index 5c7dc7aaf16..5e2ebfebf77 100644 --- a/src/game/game.cpp +++ b/src/game/game.cpp @@ -368,6 +368,20 @@ Game::Game() { { static_cast(DROME), "Drome Score" }, { static_cast(EXPERIENCE), "Experience Points" }, { static_cast(FISHING), "Fishing" }, + { static_cast(MINING), "Mining" }, + { static_cast(SMITHING), "Smithing" }, + { static_cast(ENCHANTING), "Enchanting" }, + { static_cast(WOODCUTTING), "Woodcutting" }, + { static_cast(FLETCHING), "Fletching" }, + { static_cast(HUNTING), "Hunting" }, + { static_cast(FARMING), "Farming" }, + { static_cast(COOKING), "Cooking" }, + { static_cast(CRAFTING), "Crafting" }, + { static_cast(HERBLORE), "Herblore" }, + { static_cast(ALCHEMY), "Alchemy" }, + { static_cast(ARCHAEOLOGY), "Archaeology" }, + { static_cast(MUSIC), "Music" }, + { static_cast(WISDOM), "Wisdom" }, { static_cast(FIST_FIGHTING), "Fist Fighting" }, { static_cast(GOSHNAR), "Goshnar's Taint" }, { static_cast(LOYALTY_POINTS), "Loyalty Points" }, @@ -385,6 +399,20 @@ Game::Game() { HighscoreCategory("Distance Fighting", static_cast(HighscoreCategories_t::DISTANCE_FIGHTING)), HighscoreCategory("Shielding", static_cast(HighscoreCategories_t::SHIELDING)), HighscoreCategory("Fishing", static_cast(HighscoreCategories_t::FISHING)), + HighscoreCategory("Mining", static_cast(HighscoreCategories_t::MINING)), + HighscoreCategory("Smithing", static_cast(HighscoreCategories_t::SMITHING)), + HighscoreCategory("Enchanting", static_cast(HighscoreCategories_t::ENCHANTING)), + HighscoreCategory("Woodcutting", static_cast(HighscoreCategories_t::WOODCUTTING)), + HighscoreCategory("Fletching", static_cast(HighscoreCategories_t::FLETCHING)), + HighscoreCategory("Hunting", static_cast(HighscoreCategories_t::HUNTING)), + HighscoreCategory("Farming", static_cast(HighscoreCategories_t::FARMING)), + HighscoreCategory("Cooking", static_cast(HighscoreCategories_t::COOKING)), + HighscoreCategory("Crafting", static_cast(HighscoreCategories_t::CRAFTING)), + HighscoreCategory("Herblore", static_cast(HighscoreCategories_t::HERBLORE)), + HighscoreCategory("Alchemy", static_cast(HighscoreCategories_t::ALCHEMY)), + HighscoreCategory("Archaeology", static_cast(HighscoreCategories_t::ARCHAEOLOGY)), + HighscoreCategory("Music", static_cast(HighscoreCategories_t::MUSIC)), + HighscoreCategory("Wisdom", static_cast(HighscoreCategories_t::WISDOM)), HighscoreCategory("Magic Level", static_cast(HighscoreCategories_t::MAGIC_LEVEL)) }; @@ -8687,6 +8715,34 @@ std::string Game::getSkillNameById(uint8_t &skill) { return "skill_shielding"; case HighscoreCategories_t::FISHING: return "skill_fishing"; + case HighscoreCategories_t::MINING: + return "skill_mining"; + case HighscoreCategories_t::SMITHING: + return "skill_smithing"; + case HighscoreCategories_t::ENCHANTING: + return "skill_enchanting"; + case HighscoreCategories_t::WOODCUTTING: + return "skill_woodcutting"; + case HighscoreCategories_t::FLETCHING: + return "skill_fletching"; + case HighscoreCategories_t::HUNTING: + return "skill_hunting"; + case HighscoreCategories_t::FARMING: + return "skill_farming"; + case HighscoreCategories_t::COOKING: + return "skill_cooking"; + case HighscoreCategories_t::CRAFTING: + return "skill_crafting"; + case HighscoreCategories_t::HERBLORE: + return "skill_herblore"; + case HighscoreCategories_t::ALCHEMY: + return "skill_alchemy"; + case HighscoreCategories_t::ARCHAEOLOGY: + return "skill_archaeology"; + case HighscoreCategories_t::MUSIC: + return "skill_music"; + case HighscoreCategories_t::WISDOM: + return "skill_wisdom"; case HighscoreCategories_t::MAGIC_LEVEL: return "maglevel"; case HighscoreCategories_t::BOSS_POINTS: diff --git a/src/game/game_definitions.hpp b/src/game/game_definitions.hpp index 50fa1307764..06f9651c850 100644 --- a/src/game/game_definitions.hpp +++ b/src/game/game_definitions.hpp @@ -93,13 +93,27 @@ enum class HighscoreCategories_t : uint8_t { DISTANCE_FIGHTING = 5, SHIELDING = 6, FISHING = 7, - MAGIC_LEVEL = 8, - LOYALTY_POINTS = 9, - ACHIEVEMENTS = 10, - CHARMS = 11, - DROME = 12, - GOSHNAR = 13, - BOSS_POINTS = 14, + MINING = 8, + SMITHING = 9, + ENCHANTING = 10, + WOODCUTTING = 11, + FLETCHING = 12, + HUNTING = 13, + FARMING = 14, + COOKING = 15, + CRAFTING = 16, + HERBLORE = 17, + ALCHEMY = 18, + ARCHAEOLOGY = 19, + MUSIC = 20, + WISDOM = 21, + MAGIC_LEVEL = 24, + LOYALTY_POINTS = 25, + ACHIEVEMENTS = 26, + CHARMS = 27, + DROME = 28, + GOSHNAR = 29, + BOSS_POINTS = 30, }; enum HighscoreType_t : uint8_t { diff --git a/src/io/functions/iologindata_load_player.cpp b/src/io/functions/iologindata_load_player.cpp index e724d0ceda9..ee60070938a 100644 --- a/src/io/functions/iologindata_load_player.cpp +++ b/src/io/functions/iologindata_load_player.cpp @@ -334,8 +334,8 @@ void IOLoginDataLoad::loadPlayerSkill(const std::shared_ptr &player, con return; } - static const std::array skillNames = { "skill_fist", "skill_club", "skill_sword", "skill_axe", "skill_dist", "skill_shielding", "skill_fishing", "skill_critical_hit_chance", "skill_critical_hit_damage", "skill_life_leech_chance", "skill_life_leech_amount", "skill_mana_leech_chance", "skill_mana_leech_amount" }; - static const std::array skillNameTries = { "skill_fist_tries", "skill_club_tries", "skill_sword_tries", "skill_axe_tries", "skill_dist_tries", "skill_shielding_tries", "skill_fishing_tries", "skill_critical_hit_chance_tries", "skill_critical_hit_damage_tries", "skill_life_leech_chance_tries", "skill_life_leech_amount_tries", "skill_mana_leech_chance_tries", "skill_mana_leech_amount_tries" }; + static const std::array skillNames = { "skill_fist", "skill_club", "skill_sword", "skill_axe", "skill_dist", "skill_shielding", "skill_fishing", "skill_mining", "skill_smithing", "skill_enchanting", "skill_woodcutting", "skill_fletching", "skill_hunting", "skill_farming", "skill_cooking", "skill_crafting", "skill_herblore", "skill_alchemy", "skill_archaeology", "skill_music", "skill_wisdom", "skill_critical_hit_chance", "skill_critical_hit_damage", "skill_life_leech_chance", "skill_life_leech_amount", "skill_mana_leech_chance", "skill_mana_leech_amount" }; + static const std::array skillNameTries = { "skill_fist_tries", "skill_club_tries", "skill_sword_tries", "skill_axe_tries", "skill_dist_tries", "skill_shielding_tries", "skill_fishing_tries", "skill_mining_tries", "skill_smithing_tries", "skill_enchanting_tries", "skill_woodcutting_tries", "skill_fletching_tries", "skill_hunting_tries", "skill_farming_tries", "skill_cooking_tries", "skill_crafting_tries", "skill_herblore_tries", "skill_alchemy_tries", "skill_archaeology_tries", "skill_music_tries", "skill_wisdom_tries", "skill_critical_hit_chance_tries", "skill_critical_hit_damage_tries", "skill_life_leech_chance_tries", "skill_life_leech_amount_tries", "skill_mana_leech_chance_tries", "skill_mana_leech_amount_tries" }; for (size_t i = 0; i < skillNames.size(); ++i) { auto skillLevel = result->getNumber(skillNames[i]); auto skillTries = result->getNumber(skillNameTries[i]); diff --git a/src/io/functions/iologindata_save_player.cpp b/src/io/functions/iologindata_save_player.cpp index 613fdac1cb0..6b357d4b026 100644 --- a/src/io/functions/iologindata_save_player.cpp +++ b/src/io/functions/iologindata_save_player.cpp @@ -284,6 +284,34 @@ bool IOLoginDataSave::savePlayerFirst(const std::shared_ptr &player) { query << "`skill_shielding_tries` = " << player->skills[SKILL_SHIELD].tries << ","; query << "`skill_fishing` = " << player->skills[SKILL_FISHING].level << ","; query << "`skill_fishing_tries` = " << player->skills[SKILL_FISHING].tries << ","; + query << "`skill_mining` = " << player->skills[SKILL_MINING].level << ","; + query << "`skill_mining_tries` = " << player->skills[SKILL_MINING].tries << ","; + query << "`skill_smithing` = " << player->skills[SKILL_SMITHING].level << ","; + query << "`skill_smithing_tries` = " << player->skills[SKILL_SMITHING].tries << ","; + query << "`skill_enchanting` = " << player->skills[SKILL_ENCHANTING].level << ","; + query << "`skill_enchanting_tries` = " << player->skills[SKILL_ENCHANTING].tries << ","; + query << "`skill_woodcutting` = " << player->skills[SKILL_WOODCUTTING].level << ","; + query << "`skill_woodcutting_tries` = " << player->skills[SKILL_WOODCUTTING].tries << ","; + query << "`skill_fletching` = " << player->skills[SKILL_FLETCHING].level << ","; + query << "`skill_fletching_tries` = " << player->skills[SKILL_FLETCHING].tries << ","; + query << "`skill_hunting` = " << player->skills[SKILL_HUNTING].level << ","; + query << "`skill_hunting_tries` = " << player->skills[SKILL_HUNTING].tries << ","; + query << "`skill_farming` = " << player->skills[SKILL_FARMING].level << ","; + query << "`skill_farming_tries` = " << player->skills[SKILL_FARMING].tries << ","; + query << "`skill_cooking` = " << player->skills[SKILL_COOKING].level << ","; + query << "`skill_cooking_tries` = " << player->skills[SKILL_COOKING].tries << ","; + query << "`skill_crafting` = " << player->skills[SKILL_CRAFTING].level << ","; + query << "`skill_crafting_tries` = " << player->skills[SKILL_CRAFTING].tries << ","; + query << "`skill_herblore` = " << player->skills[SKILL_HERBLORE].level << ","; + query << "`skill_herblore_tries` = " << player->skills[SKILL_HERBLORE].tries << ","; + query << "`skill_alchemy` = " << player->skills[SKILL_ALCHEMY].level << ","; + query << "`skill_alchemy_tries` = " << player->skills[SKILL_ALCHEMY].tries << ","; + query << "`skill_archaeology` = " << player->skills[SKILL_ARCHAEOLOGY].level << ","; + query << "`skill_archaeology_tries` = " << player->skills[SKILL_ARCHAEOLOGY].tries << ","; + query << "`skill_music` = " << player->skills[SKILL_MUSIC].level << ","; + query << "`skill_music_tries` = " << player->skills[SKILL_MUSIC].tries << ","; + query << "`skill_wisdom` = " << player->skills[SKILL_WISDOM].level << ","; + query << "`skill_wisdom_tries` = " << player->skills[SKILL_WISDOM].tries << ","; query << "`skill_critical_hit_chance` = " << player->skills[SKILL_CRITICAL_HIT_CHANCE].level << ","; query << "`skill_critical_hit_chance_tries` = " << player->skills[SKILL_CRITICAL_HIT_CHANCE].tries << ","; query << "`skill_critical_hit_damage` = " << player->skills[SKILL_CRITICAL_HIT_DAMAGE].level << ","; diff --git a/src/items/functions/item/item_parse.cpp b/src/items/functions/item/item_parse.cpp index 357e0c03e8b..fa46cd691a6 100644 --- a/src/items/functions/item/item_parse.cpp +++ b/src/items/functions/item/item_parse.cpp @@ -457,6 +457,34 @@ void ItemParse::parseSkills(const std::string &stringValue, pugi::xml_attribute itemType.getAbilities().skills[SKILL_DISTANCE] = pugi::cast(valueAttribute.value()); } else if (stringValue == "skillfish") { itemType.getAbilities().skills[SKILL_FISHING] = pugi::cast(valueAttribute.value()); + } else if (stringValue == "skillmining") { + itemType.getAbilities().skills[SKILL_MINING] = pugi::cast(valueAttribute.value()); + } else if (stringValue == "skillsmithing") { + itemType.getAbilities().skills[SKILL_SMITHING] = pugi::cast(valueAttribute.value()); + } else if (stringValue == "skillenchanting") { + itemType.getAbilities().skills[SKILL_ENCHANTING] = pugi::cast(valueAttribute.value()); + } else if (stringValue == "skillwoodcutting") { + itemType.getAbilities().skills[SKILL_WOODCUTTING] = pugi::cast(valueAttribute.value()); + } else if (stringValue == "skillfletching") { + itemType.getAbilities().skills[SKILL_FLETCHING] = pugi::cast(valueAttribute.value()); + } else if (stringValue == "skillhunting") { + itemType.getAbilities().skills[SKILL_HUNTING] = pugi::cast(valueAttribute.value()); + } else if (stringValue == "skillfarming") { + itemType.getAbilities().skills[SKILL_FARMING] = pugi::cast(valueAttribute.value()); + } else if (stringValue == "skillcooking") { + itemType.getAbilities().skills[SKILL_COOKING] = pugi::cast(valueAttribute.value()); + } else if (stringValue == "skillcrafting") { + itemType.getAbilities().skills[SKILL_CRAFTING] = pugi::cast(valueAttribute.value()); + } else if (stringValue == "skillherblore") { + itemType.getAbilities().skills[SKILL_HERBLORE] = pugi::cast(valueAttribute.value()); + } else if (stringValue == "skillalchemy") { + itemType.getAbilities().skills[SKILL_ALCHEMY] = pugi::cast(valueAttribute.value()); + } else if (stringValue == "skillarchaeology") { + itemType.getAbilities().skills[SKILL_ARCHAEOLOGY] = pugi::cast(valueAttribute.value()); + } else if (stringValue == "skillmusic") { + itemType.getAbilities().skills[SKILL_MUSIC] = pugi::cast(valueAttribute.value()); + } else if (stringValue == "skillwisdom") { + itemType.getAbilities().skills[SKILL_WISDOM] = pugi::cast(valueAttribute.value()); } else if (stringValue == "skillshield") { itemType.getAbilities().skills[SKILL_SHIELD] = pugi::cast(valueAttribute.value()); } else if (stringValue == "skillfist") { diff --git a/src/items/functions/item/item_parse.hpp b/src/items/functions/item/item_parse.hpp index 627fdaacd0c..c469a66253b 100644 --- a/src/items/functions/item/item_parse.hpp +++ b/src/items/functions/item/item_parse.hpp @@ -72,6 +72,20 @@ const phmap::flat_hash_map ItemParseAttribut { "skillclub", ITEM_PARSE_SKILLCLUB }, { "skilldist", ITEM_PARSE_SKILLDIST }, { "skillfish", ITEM_PARSE_SKILLFISH }, + { "skillmining", ITEM_PARSE_SKILLMINING }, + { "skillsmithing", ITEM_PARSE_SKILLSMITHING }, + { "skillenchanting", ITEM_PARSE_SKILLENCHANTING }, + { "skillwoodcutting", ITEM_PARSE_SKILLWOODCUTTING }, + { "skillfletching", ITEM_PARSE_SKILLFLETCHING }, + { "skillhunting", ITEM_PARSE_SKILLHUNTING }, + { "skillfarming", ITEM_PARSE_SKILLFARMING }, + { "skillcooking", ITEM_PARSE_SKILLCOOKING }, + { "skillcrafting", ITEM_PARSE_SKILLCRAFTING }, + { "skillherblore", ITEM_PARSE_SKILLHERBLORE }, + { "skillalchemy", ITEM_PARSE_SKILLALCHEMY }, + { "skillarchaeology", ITEM_PARSE_SKILLARCHAEOLOGY }, + { "skillmusic", ITEM_PARSE_SKILLMUSIC }, + { "skillwisdom", ITEM_PARSE_SKILLWISDOM }, { "skillshield", ITEM_PARSE_SKILLSHIELD }, { "skillfist", ITEM_PARSE_SKILLFIST }, { "criticalhitchance", ITEM_PARSE_CRITICALHITCHANCE }, diff --git a/src/items/item.cpp b/src/items/item.cpp index 14af2cfb47f..fd97afd7187 100644 --- a/src/items/item.cpp +++ b/src/items/item.cpp @@ -1346,7 +1346,7 @@ Item::getDescriptions(const ItemType &it, const std::shared_ptr &item /*= skillBoost = true; } - for (uint8_t i = SKILL_FIRST; i <= SKILL_FISHING; i++) { + for (uint8_t i = SKILL_FIRST; i <= SKILL_WISDOM; i++) { if (!it.abilities->skills[i]) { continue; } @@ -1765,7 +1765,7 @@ Item::getDescriptions(const ItemType &it, const std::shared_ptr &item /*= skillBoost = true; } - for (uint8_t i = SKILL_FIRST; i <= SKILL_FISHING; i++) { + for (uint8_t i = SKILL_FIRST; i <= SKILL_WISDOM; i++) { if (!it.abilities->skills[i]) { continue; } @@ -2217,7 +2217,7 @@ std::string Item::parseShowAttributesDescription(const std::shared_ptr &it } if (itemType.abilities) { - for (uint8_t i = SKILL_FIRST; i <= SKILL_FISHING; i++) { + for (uint8_t i = SKILL_FIRST; i <= SKILL_WISDOM; i++) { if (!itemType.abilities->skills[i]) { continue; } @@ -2515,7 +2515,7 @@ std::string Item::getDescription(const ItemType &it, int32_t lookDistance, const } if (it.abilities) { - for (uint8_t i = SKILL_FIRST; i <= SKILL_FISHING; i++) { + for (uint8_t i = SKILL_FIRST; i <= SKILL_WISDOM; i++) { if (!it.abilities->skills[i]) { continue; } @@ -2787,7 +2787,7 @@ std::string Item::getDescription(const ItemType &it, int32_t lookDistance, const } if (it.abilities) { - for (uint8_t i = SKILL_FIRST; i <= SKILL_FISHING; i++) { + for (uint8_t i = SKILL_FIRST; i <= SKILL_WISDOM; i++) { if (!it.abilities->skills[i]) { continue; } diff --git a/src/items/items_definitions.hpp b/src/items/items_definitions.hpp index 9b6990c0cb7..aefdbbf0802 100644 --- a/src/items/items_definitions.hpp +++ b/src/items/items_definitions.hpp @@ -119,6 +119,20 @@ enum ReturnValue : uint16_t { RETURNVALUE_NOTENOUGHDISTANCELEVEL, RETURNVALUE_NOTENOUGHSHIELDLEVEL, RETURNVALUE_NOTENOUGHFISHLEVEL, + RETURNVALUE_NOTENOUGHMININGLEVEL, + RETURNVALUE_NOTENOUGHSMITHINGLEVEL, + RETURNVALUE_NOTENOUGHENCHANTINGLEVEL, + RETURNVALUE_NOTENOUGHWOODCUTTINGLEVEL, + RETURNVALUE_NOTENOUGHFLETCHINGLEVEL, + RETURNVALUE_NOTENOUGHHUNTINGLEVEL, + RETURNVALUE_NOTENOUGHFARMINGLEVEL, + RETURNVALUE_NOTENOUGHCOOKINGLEVEL, + RETURNVALUE_NOTENOUGHCRAFTINGLEVEL, + RETURNVALUE_NOTENOUGHHERBLORELEVEL, + RETURNVALUE_NOTENOUGHALCHEMYLEVEL, + RETURNVALUE_NOTENOUGHARCHAEOLOGYLEVEL, + RETURNVALUE_NOTENOUGHMUSICLEVEL, + RETURNVALUE_NOTENOUGHWISDOMLEVEL, RETURNVALUE_REWARDCHESTISEMPTY, RETURNVALUE_REWARDCONTAINERISEMPTY, RETURNVALUE_CONTACTADMINISTRATOR, @@ -540,6 +554,20 @@ enum ItemParseAttributes_t { ITEM_PARSE_SKILLCLUB, ITEM_PARSE_SKILLDIST, ITEM_PARSE_SKILLFISH, + ITEM_PARSE_SKILLMINING, + ITEM_PARSE_SKILLSMITHING, + ITEM_PARSE_SKILLENCHANTING, + ITEM_PARSE_SKILLWOODCUTTING, + ITEM_PARSE_SKILLFLETCHING, + ITEM_PARSE_SKILLHUNTING, + ITEM_PARSE_SKILLFARMING, + ITEM_PARSE_SKILLCOOKING, + ITEM_PARSE_SKILLCRAFTING, + ITEM_PARSE_SKILLHERBLORE, + ITEM_PARSE_SKILLALCHEMY, + ITEM_PARSE_SKILLARCHAEOLOGY, + ITEM_PARSE_SKILLMUSIC, + ITEM_PARSE_SKILLWISDOM, ITEM_PARSE_SKILLSHIELD, ITEM_PARSE_SKILLFIST, ITEM_PARSE_CRITICALHITCHANCE, diff --git a/src/lua/functions/core/game/lua_enums.cpp b/src/lua/functions/core/game/lua_enums.cpp index 2136a3e5927..7b4365b9184 100644 --- a/src/lua/functions/core/game/lua_enums.cpp +++ b/src/lua/functions/core/game/lua_enums.cpp @@ -378,6 +378,20 @@ void LuaEnums::initConditionParamEnums(lua_State* L) { registerEnum(L, CONDITION_PARAM_SKILL_DISTANCE); registerEnum(L, CONDITION_PARAM_SKILL_SHIELD); registerEnum(L, CONDITION_PARAM_SKILL_FISHING); + registerEnum(L, CONDITION_PARAM_SKILL_MINING); + registerEnum(L, CONDITION_PARAM_SKILL_SMITHING); + registerEnum(L, CONDITION_PARAM_SKILL_ENCHANTING); + registerEnum(L, CONDITION_PARAM_SKILL_WOODCUTTING); + registerEnum(L, CONDITION_PARAM_SKILL_FLETCHING); + registerEnum(L, CONDITION_PARAM_SKILL_HUNTING); + registerEnum(L, CONDITION_PARAM_SKILL_FARMING); + registerEnum(L, CONDITION_PARAM_SKILL_COOKING); + registerEnum(L, CONDITION_PARAM_SKILL_CRAFTING); + registerEnum(L, CONDITION_PARAM_SKILL_HERBLORE); + registerEnum(L, CONDITION_PARAM_SKILL_ALCHEMY); + registerEnum(L, CONDITION_PARAM_SKILL_ARCHAEOLOGY); + registerEnum(L, CONDITION_PARAM_SKILL_MUSIC); + registerEnum(L, CONDITION_PARAM_SKILL_WISDOM); registerEnum(L, CONDITION_PARAM_SKILL_CRITICAL_HIT_CHANCE); registerEnum(L, CONDITION_PARAM_SKILL_CRITICAL_HIT_DAMAGE); registerEnum(L, CONDITION_PARAM_SKILL_LIFE_LEECH_CHANCE); @@ -399,6 +413,20 @@ void LuaEnums::initConditionParamEnums(lua_State* L) { registerEnum(L, CONDITION_PARAM_SKILL_DISTANCEPERCENT); registerEnum(L, CONDITION_PARAM_SKILL_SHIELDPERCENT); registerEnum(L, CONDITION_PARAM_SKILL_FISHINGPERCENT); + registerEnum(L, CONDITION_PARAM_SKILL_MININGPERCENT); + registerEnum(L, CONDITION_PARAM_SKILL_SMITHINGPERCENT); + registerEnum(L, CONDITION_PARAM_SKILL_ENCHANTINGPERCENT); + registerEnum(L, CONDITION_PARAM_SKILL_WOODCUTTINGPERCENT); + registerEnum(L, CONDITION_PARAM_SKILL_FLETCHINGPERCENT); + registerEnum(L, CONDITION_PARAM_SKILL_HUNTINGPERCENT); + registerEnum(L, CONDITION_PARAM_SKILL_FARMINGPERCENT); + registerEnum(L, CONDITION_PARAM_SKILL_COOKINGPERCENT); + registerEnum(L, CONDITION_PARAM_SKILL_CRAFTINGPERCENT); + registerEnum(L, CONDITION_PARAM_SKILL_HERBLOREPERCENT); + registerEnum(L, CONDITION_PARAM_SKILL_ALCHEMYPERCENT); + registerEnum(L, CONDITION_PARAM_SKILL_ARCHAEOLOGYPERCENT); + registerEnum(L, CONDITION_PARAM_SKILL_MUSICPERCENT); + registerEnum(L, CONDITION_PARAM_SKILL_WISDOMPERCENT); registerEnum(L, CONDITION_PARAM_BUFF_SPELL); registerEnum(L, CONDITION_PARAM_SUBID); registerEnum(L, CONDITION_PARAM_FIELD); diff --git a/src/server/network/protocol/protocolgame.cpp b/src/server/network/protocol/protocolgame.cpp index 9c09f5ead38..55262ef3841 100644 --- a/src/server/network/protocol/protocolgame.cpp +++ b/src/server/network/protocol/protocolgame.cpp @@ -3502,7 +3502,7 @@ void ProtocolGame::sendCyclopediaCharacterGeneralStats() { msg.add(player->getMagicLevelPercent() * 100); for (uint8_t i = SKILL_FIRST; i < SKILL_CRITICAL_HIT_CHANCE; ++i) { - static const uint8_t HardcodedSkillIds[] = { 11, 9, 8, 10, 7, 6, 13 }; + static const uint8_t HardcodedSkillIds[] = { 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 27 }; const auto skill = static_cast(i); msg.addByte(HardcodedSkillIds[i]); msg.add(std::min(player->getSkillLevel(skill), std::numeric_limits::max())); @@ -5923,7 +5923,7 @@ void ProtocolGame::sendMarketDetail(uint16_t itemId, uint8_t tier) { std::ostringstream ss; bool separator = false; - for (uint8_t i = SKILL_FIRST; i <= SKILL_FISHING; i++) { + for (uint8_t i = SKILL_FIRST; i <= SKILL_WISDOM; i++) { if (!it.abilities->skills[i]) { continue; } @@ -7879,7 +7879,7 @@ void ProtocolGame::AddPlayerSkills(NetworkMessage &msg) { msg.addByte(0xA1); if (oldProtocol) { - for (uint8_t i = SKILL_FIRST; i <= SKILL_FISHING; ++i) { + for (uint8_t i = SKILL_FIRST; i <= SKILL_WISDOM; ++i) { auto skill = static_cast(i); msg.add(std::min(player->getSkillLevel(skill), std::numeric_limits::max())); msg.add(player->getBaseSkill(skill)); @@ -7891,7 +7891,7 @@ void ProtocolGame::AddPlayerSkills(NetworkMessage &msg) { msg.add(player->getLoyaltyMagicLevel()); msg.add(player->getMagicLevelPercent() * 100); - for (uint8_t i = SKILL_FIRST; i <= SKILL_FISHING; ++i) { + for (uint8_t i = SKILL_FIRST; i <= SKILL_WISDOM; ++i) { auto skill = static_cast(i); msg.add(std::min(player->getSkillLevel(skill), std::numeric_limits::max())); msg.add(player->getBaseSkill(skill)); diff --git a/src/utils/tools.cpp b/src/utils/tools.cpp index 57c9c873282..104f35738e3 100644 --- a/src/utils/tools.cpp +++ b/src/utils/tools.cpp @@ -978,6 +978,48 @@ std::string getSkillName(uint8_t skillid) { case SKILL_FISHING: return "fishing"; + case SKILL_MINING: + return "mining"; + + case SKILL_SMITHING: + return "smithing"; + + case SKILL_ENCHANTING: + return "enchanting"; + + case SKILL_WOODCUTTING: + return "woodcutting"; + + case SKILL_FLETCHING: + return "fletching"; + + case SKILL_HUNTING: + return "hunting"; + + case SKILL_FARMING: + return "farming"; + + case SKILL_COOKING: + return "cooking"; + + case SKILL_CRAFTING: + return "crafting"; + + case SKILL_HERBLORE: + return "herblore"; + + case SKILL_ALCHEMY: + return "alchemy"; + + case SKILL_ARCHAEOLOGY: + return "archaeology"; + + case SKILL_MUSIC: + return "music"; + + case SKILL_WISDOM: + return "wisdom"; + case SKILL_CRITICAL_HIT_CHANCE: return "critical hit chance";