From e3805d5920e31920e2d803afde99adaed8d491a4 Mon Sep 17 00:00:00 2001 From: Uleat Date: Sun, 27 Oct 2013 13:03:41 -0400 Subject: [PATCH] Converted SkillType typedef enumeration to SkillUseTypes enumeration --- changelog.txt | 1 + common/eq_constants.h | 170 ++++++++++++----------- common/shareddb.cpp | 8 +- common/shareddb.h | 4 +- common/skills.h | 162 +++++++++++++++++++++- common/spdat.h | 2 +- world/client.cpp | 52 +++---- zone/AA.cpp | 2 +- zone/MobAI.cpp | 4 +- zone/attack.cpp | 139 ++++++++++--------- zone/beacon.h | 4 +- zone/bot.cpp | 200 +++++++++++++-------------- zone/bot.h | 20 +-- zone/client.cpp | 72 +++++----- zone/client.h | 38 +++--- zone/client_mods.cpp | 42 +++--- zone/client_packet.cpp | 102 +++++++------- zone/client_process.cpp | 50 +++---- zone/command.cpp | 30 ++-- zone/corpse.h | 4 +- zone/doors.cpp | 6 +- zone/entity.cpp | 6 +- zone/forage.cpp | 12 +- zone/lua_client.cpp | 16 +-- zone/lua_mob.cpp | 34 ++--- zone/merc.cpp | 32 ++--- zone/merc.h | 12 +- zone/mob.cpp | 50 +++---- zone/mob.h | 36 ++--- zone/mod_functions.cpp | 10 +- zone/npc.cpp | 6 +- zone/npc.h | 8 +- zone/object.h | 2 +- zone/perl_client.cpp | 16 +-- zone/perl_mob.cpp | 14 +- zone/questmgr.cpp | 10 +- zone/skills.h | 152 ++++++++++----------- zone/special_attacks.cpp | 288 +++++++++++++++++++-------------------- zone/spell_effects.cpp | 8 +- zone/spells.cpp | 88 ++++++------ zone/titles.cpp | 6 +- zone/tradeskills.cpp | 148 ++++++++++---------- zone/zonedb.h | 2 +- 43 files changed, 1119 insertions(+), 949 deletions(-) diff --git a/changelog.txt b/changelog.txt index 71ebeaa16..e1f64f67d 100644 --- a/changelog.txt +++ b/changelog.txt @@ -14,6 +14,7 @@ Uleat: Changed ItemUseType to ItemInstTypes to better reflect the definition (al Uleat: Changed ItemClass to ItemClassTypes Uleat: Converted MATERIAL defines to MaterialUseSlots enumeration - use of scripted 'Bracer' and 'Max' are deprecated Uleat: Changed ItemTypes to ItemUseTypes - retained the 'ItemType' prefix to avoid too much confusion. Also adopted the '1H Piercing' model found in later clients +Uleat: Converted SkillType typedef enumeration to SkillUseTypes enumeration - Some prep work for adding the newer skills == 10/24/2013 == demonstar55: Fix some memory leaks in Mob::SpellOnTarget diff --git a/common/eq_constants.h b/common/eq_constants.h index a4d83963d..d612017ad 100644 --- a/common/eq_constants.h +++ b/common/eq_constants.h @@ -547,88 +547,96 @@ enum GroupUpdateAction GUA_Started = 9 }; -//0x1c is something... -static const uint8 FallingDamageType = 0xFC; -static const uint8 SpellDamageType = 0xe7; -static const uint8 DamageTypeUnknown = 0xFF; +static const uint8 DamageTypeSomething = 0x1C; //0x1c is something... +static const uint8 DamageTypeFalling = 0xFC; +static const uint8 DamageTypeSpell = 0xE7; +static const uint8 DamageTypeUnknown = 0xFF; -//indexed by 'SkillType' -static const uint8 SkillDamageTypes[HIGHEST_SKILL+1] = { - /* _1H_BLUNT */ 0, - /* _1H_SLASHING */ 1, - /* _2H_BLUNT */ 0, - /* _2H_SLASHING */ 1, - /* ABJURE */ SpellDamageType, - /* ALTERATION */ SpellDamageType, - /* APPLY_POISON */ DamageTypeUnknown, - /* ARCHERY */ 7, - /* BACKSTAB */ 8, - /* BIND_WOUND */ DamageTypeUnknown, - /* BASH */ 10, - /* BLOCKSKILL */ DamageTypeUnknown, - /* BRASS_INSTRUMENTS */ SpellDamageType, - /* CHANNELING */ DamageTypeUnknown, - /* CONJURATION */ SpellDamageType, - /* DEFENSE */ DamageTypeUnknown, - /* DISARM */ DamageTypeUnknown, - /* DISARM_TRAPS */ DamageTypeUnknown, - /* DIVINATION */ SpellDamageType, - /* DODGE */ DamageTypeUnknown, - /* DOUBLE_ATTACK */ DamageTypeUnknown, - /* DRAGON_PUNCH */ 21, - /* DUAL_WIELD */ DamageTypeUnknown, - /* EAGLE_STRIKE */ 23, - /* EVOCATION */ SpellDamageType, - /* FEIGN_DEATH */ 4, - /* FLYING_KICK */ 30, - /* FORAGE */ DamageTypeUnknown, - /* HAND_TO_HAND */ 4, - /* HIDE */ DamageTypeUnknown, - /* KICK */ 30, - /* MEDITATE */ DamageTypeUnknown, - /* MEND */ DamageTypeUnknown, - /* OFFENSE */ DamageTypeUnknown, - /* PARRY */ DamageTypeUnknown, - /* PICK_LOCK */ DamageTypeUnknown, - /* PIERCING */ 36, - /* RIPOSTE */ DamageTypeUnknown, - /* ROUND_KICK */ 30, - /* SAFE_FALL */ DamageTypeUnknown, - /* SENSE_HEADING */ DamageTypeUnknown, - /* SINGING */ SpellDamageType, - /* SNEAK */ DamageTypeUnknown, - /* SPECIALIZE_ABJURE */ DamageTypeUnknown, - /* SPECIALIZE_ALTERATION */ DamageTypeUnknown, - /* SPECIALIZE_CONJURATION */ DamageTypeUnknown, - /* SPECIALIZE_DIVINATION */ DamageTypeUnknown, - /* SPECIALIZE_EVOCATION */ DamageTypeUnknown, - /* PICK_POCKETS */ DamageTypeUnknown, - /* STRINGED_INSTRUMENTS */ SpellDamageType, - /* SWIMMING */ DamageTypeUnknown, - /* THROWING */ 51, - /* TIGER_CLAW */ 23, - /* TRACKING */ DamageTypeUnknown, - /* WIND_INSTRUMENTS */ SpellDamageType, - /* FISHING */ DamageTypeUnknown, - /* MAKE_POISON */ DamageTypeUnknown, - /* TINKERING */ DamageTypeUnknown, - /* RESEARCH */ DamageTypeUnknown, - /* ALCHEMY */ DamageTypeUnknown, - /* BAKING */ DamageTypeUnknown, - /* TAILORING */ DamageTypeUnknown, - /* SENSE_TRAPS */ DamageTypeUnknown, - /* BLACKSMITHING */ DamageTypeUnknown, - /* FLETCHING */ DamageTypeUnknown, - /* BREWING */ DamageTypeUnknown, - /* ALCOHOL_TOLERANCE */ DamageTypeUnknown, - /* BEGGING */ DamageTypeUnknown, - /* JEWELRY_MAKING */ DamageTypeUnknown, - /* POTTERY */ DamageTypeUnknown, - /* PERCUSSION_INSTRUMENTS */ SpellDamageType, - /* INTIMIDATION */ DamageTypeUnknown, - /* BERSERKING */ DamageTypeUnknown, - /* TAUNT */ DamageTypeUnknown, - /* FRENZY */ 74 +/* +** Skill damage types +** +** (indexed by 'Skill' of SkillUseTypes) +*/ +static const uint8 SkillDamageTypes[HIGHEST_SKILL + 1] = // change to _SkillServerArraySize once activated +{ +/*1HBlunt*/ 0, +/*1HSlashing*/ 1, +/*2HBlunt*/ 0, +/*2HSlashing*/ 1, +/*Abjuration*/ DamageTypeSpell, +/*Alteration*/ DamageTypeSpell, +/*ApplyPoison*/ DamageTypeUnknown, +/*Archery*/ 7, +/*Backstab*/ 8, +/*BindWound*/ DamageTypeUnknown, +/*Bash*/ 10, +/*Block*/ DamageTypeUnknown, +/*BrassInstruments*/ DamageTypeSpell, +/*Channeling*/ DamageTypeUnknown, +/*Conjuration*/ DamageTypeSpell, +/*Defense*/ DamageTypeUnknown, +/*Disarm*/ DamageTypeUnknown, +/*DisarmTraps*/ DamageTypeUnknown, +/*Divination*/ DamageTypeSpell, +/*Dodge*/ DamageTypeUnknown, +/*DoubleAttack*/ DamageTypeUnknown, +/*DragonPunch*/ 21, +/*DualWield*/ DamageTypeUnknown, +/*EagleStrike*/ 23, +/*Evocation*/ DamageTypeSpell, +/*FeignDeath*/ 4, +/*FlyingKick*/ 30, +/*Forage*/ DamageTypeUnknown, +/*HandtoHand*/ 4, +/*Hide*/ DamageTypeUnknown, +/*Kick*/ 30, +/*Meditate*/ DamageTypeUnknown, +/*Mend*/ DamageTypeUnknown, +/*Offense*/ DamageTypeUnknown, +/*Parry*/ DamageTypeUnknown, +/*PickLock*/ DamageTypeUnknown, +/*1HPiercing*/ 36, +/*Riposte*/ DamageTypeUnknown, +/*RoundKick*/ 30, +/*SafeFall*/ DamageTypeUnknown, +/*SsenseHeading*/ DamageTypeUnknown, +/*Singing*/ DamageTypeSpell, +/*Sneak*/ DamageTypeUnknown, +/*SpecializeAbjure*/ DamageTypeUnknown, +/*SpecializeAlteration*/ DamageTypeUnknown, +/*SpecializeConjuration*/ DamageTypeUnknown, +/*SpecializeDivination*/ DamageTypeUnknown, +/*SpecializeEvocation*/ DamageTypeUnknown, +/*PickPockets*/ DamageTypeUnknown, +/*StringedInstruments*/ DamageTypeSpell, +/*Swimming*/ DamageTypeUnknown, +/*Throwing*/ 51, +/*TigerClaw*/ 23, +/*Tracking*/ DamageTypeUnknown, +/*WindInstruments*/ DamageTypeSpell, +/*Fishing*/ DamageTypeUnknown, +/*MakePoison*/ DamageTypeUnknown, +/*Tinkering*/ DamageTypeUnknown, +/*Research*/ DamageTypeUnknown, +/*Alchemy*/ DamageTypeUnknown, +/*Baking*/ DamageTypeUnknown, +/*Tailoring*/ DamageTypeUnknown, +/*SenseTraps*/ DamageTypeUnknown, +/*Blacksmithing*/ DamageTypeUnknown, +/*Fletching*/ DamageTypeUnknown, +/*Brewing*/ DamageTypeUnknown, +/*AlcoholTolerance*/ DamageTypeUnknown, +/*Begging*/ DamageTypeUnknown, +/*JewelryMaking*/ DamageTypeUnknown, +/*Pottery*/ DamageTypeUnknown, +/*PercussionInstruments*/ DamageTypeSpell, +/*Intimidation*/ DamageTypeUnknown, +/*Berserking*/ DamageTypeUnknown, +/*Taunt*/ DamageTypeUnknown, +/*Frenzy*/ 74 //, +// /*RemoveTrap*/ DamageTypeUnknown, // Needs research (set for SenseTrap value) +// /*TripleAttack*/ DamageTypeUnknown, // Needs research (set for DoubleAttack value) +// /*2HPiercing*/ 36 // Needs research (set for 1HPiercing value - similar to slash/blunt) }; /* diff --git a/common/shareddb.cpp b/common/shareddb.cpp index 00f5355ab..6b87dcc25 100644 --- a/common/shareddb.cpp +++ b/common/shareddb.cpp @@ -1475,7 +1475,7 @@ void SharedDatabase::LoadSkillCaps(void *data) { } } -uint16 SharedDatabase::GetSkillCap(uint8 Class_, SkillType Skill, uint8 Level) { +uint16 SharedDatabase::GetSkillCap(uint8 Class_, SkillUseTypes Skill, uint8 Level) { if(!skill_caps_mmf) { return 0; } @@ -1504,7 +1504,7 @@ uint16 SharedDatabase::GetSkillCap(uint8 Class_, SkillType Skill, uint8 Level) { return skill_caps_table[index]; } -uint8 SharedDatabase::GetTrainLevel(uint8 Class_, SkillType Skill, uint8 Level) { +uint8 SharedDatabase::GetTrainLevel(uint8 Class_, SkillUseTypes Skill, uint8 Level) { if(!skill_caps_mmf) { return 0; } @@ -1682,9 +1682,9 @@ void SharedDatabase::LoadSpells(void *data, int max_spells) { sp[tempid].basediff=atoi(row[99]); int tmp_skill = atoi(row[100]);; if(tmp_skill < 0 || tmp_skill > HIGHEST_SKILL) - sp[tempid].skill = BEGGING; /* not much better we can do. */ + sp[tempid].skill = SkillBegging; /* not much better we can do. */ // can probably be changed to client-based 'SkillNone' once activated else - sp[tempid].skill = (SkillType) tmp_skill; + sp[tempid].skill = (SkillUseTypes) tmp_skill; sp[tempid].zonetype=atoi(row[101]); sp[tempid].EnvironmentType=atoi(row[102]); sp[tempid].TimeOfDay=atoi(row[103]); diff --git a/common/shareddb.h b/common/shareddb.h index d10ec894e..4902f9063 100644 --- a/common/shareddb.h +++ b/common/shareddb.h @@ -103,8 +103,8 @@ public: void LoadSkillCaps(void *data); bool LoadSkillCaps(); - uint16 GetSkillCap(uint8 Class_, SkillType Skill, uint8 Level); - uint8 GetTrainLevel(uint8 Class_, SkillType Skill, uint8 Level); + uint16 GetSkillCap(uint8 Class_, SkillUseTypes Skill, uint8 Level); + uint8 GetTrainLevel(uint8 Class_, SkillUseTypes Skill, uint8 Level); int GetMaxSpellID(); void LoadSpells(void *data, int max_spells); diff --git a/common/skills.h b/common/skills.h index 0b0c6e025..ef5ae6e11 100644 --- a/common/skills.h +++ b/common/skills.h @@ -18,7 +18,165 @@ #ifndef SKILLS_H #define SKILLS_H -// Correct Skill Numbers as of 4-14-2002 +/* +** This is really messed up... Are we using SkillTypes as a pseudo repository? The 76th skill really throws +** things for standardization... +** +** Below is an attempt to clean this up a little... +*/ + +/* +** Skill use types +** +** (ref: eqstr_us.txt [05-10-2013]) +*/ +enum SkillUseTypes : uint32 +{ +/*13855*/ Skill1HBlunt = 0, +/*13856*/ Skill1HSlashing, +/*13857*/ Skill2HBlunt, +/*13858*/ Skill2HSlashing, +/*13859*/ SkillAbjuration, +/*13861*/ SkillAlteration, +/*13862*/ SkillApplyPoison, +/*13863*/ SkillArchery, +/*13864*/ SkillBackstab, +/*13866*/ SkillBindWound, +/*13867*/ SkillBash, +/*13871*/ SkillBlock, +/*13872*/ SkillBrassInstruments, +/*13874*/ SkillChanneling, +/*13875*/ SkillConjuration, +/*13876*/ SkillDefense, +/*13877*/ SkillDisarm, +/*13878*/ SkillDisarmTraps, +/*13879*/ SkillDivination, +/*13880*/ SkillDodge, +/*13881*/ SkillDoubleAttack, +/*13882*/ SkillDragonPunch, /*13924 SkillTailRake*/ +/*13883*/ SkillDualWield, +/*13884*/ SkillEagleStrike, +/*13885*/ SkillEvocation, +/*13886*/ SkillFeignDeath, +/*13888*/ SkillFlyingKick, +/*13889*/ SkillForage, +/*13890*/ SkillHandtoHand, +/*13891*/ SkillHide, +/*13893*/ SkillKick, +/*13894*/ SkillMeditate, +/*13895*/ SkillMend, +/*13896*/ SkillOffense, +/*13897*/ SkillParry, +/*13899*/ SkillPickLock, +/*13900*/ Skill1HPiercing, // Changed in RoF2(05-10-2013) +/*13903*/ SkillRiposte, +/*13904*/ SkillRoundKick, +/*13905*/ SkillSafeFall, +/*13906*/ SkillSenseHeading, +/*13908*/ SkillSinging, +/*13909*/ SkillSneak, +/*13910*/ SkillSpecializeAbjure, // No idea why they truncated this one..especially when there are longer ones... +/*13911*/ SkillSpecializeAlteration, +/*13912*/ SkillSpecializeConjuration, +/*13913*/ SkillSpecializeDivination, +/*13914*/ SkillSpecializeEvocation, +/*13915*/ SkillPickPockets, +/*13916*/ SkillStringedInstruments, +/*13917*/ SkillSwimming, +/*13919*/ SkillThrowing, +/*13920*/ SkillTigerClaw, +/*13921*/ SkillTracking, +/*13923*/ SkillWindInstruments, +/*13854*/ SkillFishing, +/*13853*/ SkillMakePoison, +/*13852*/ SkillTinkering, +/*13851*/ SkillResearch, +/*13850*/ SkillAlchemy, +/*13865*/ SkillBaking, +/*13918*/ SkillTailoring, +/*13907*/ SkillSenseTraps, +/*13870*/ SkillBlacksmithing, +/*13887*/ SkillFletching, +/*13873*/ SkillBrewing, +/*13860*/ SkillAlcoholTolerance, +/*13868*/ SkillBegging, +/*13892*/ SkillJewelryMaking, +/*13901*/ SkillPottery, +/*13898*/ SkillPercussionInstruments, +/*13922*/ SkillIntimidation, +/*13869*/ SkillBerserking, +/*13902*/ SkillTaunt, +/*05837*/ SkillFrenzy, // This appears to be the only listed one not grouped with the others + +// SoF+ specific skills +// /*03670*/ SkillRemoveTraps, +// /*13049*/ SkillTripleAttack, + +// RoF2+ specific skills +// /*00789*/ Skill2HPiercing, +// /*01216*/ SkillNone, // This needs to move down as new skills are added + +// Skill Counts +// /*-----*/ _SkillCount_62 = 75, // use for Ti and earlier max skill checks +// /*-----*/ _SkillCount_SoF = 77, // use for SoF thru RoF1 max skill checks +// /*-----*/ _SkillCount_RoF2 = 78, // use for RoF2 max skill checks + +// Support values +// /*-----*/ _SkillServerArraySize = _SkillCount_RoF2, // Should reflect last client '_SkillCount' +// /*-----*/ _SkillPacketArraySize = 100, // Currently supported clients appear to iterate full 100 dword buffer range + +// Superfluous additions to SkillUseTypes..server-use only +// /*-----*/ ExtSkillGenericTradeskill = 100 + +/* ([EQClientVersion] [0] - Unknown, [3] - SoF, [7] - RoF2[05-10-2013]) + [Skill] [index] | [0] [1] [2] [3] [4] [5] [6] [7] + Frenzy (05837) | --- 074 074 074 074 074 074 074 + Remove Traps (03670) | --- --- --- 075 075 075 075 075 + Triple Attack (13049) | --- --- --- 076 076 076 076 076 + 2H Piercing (00789) | --- --- --- --- --- --- --- 077 +*/ + +/* + [SkillCaps.txt] (SoF+) + a^b^c^d(^e) (^e is RoF+, but cursory glance appears to be all zeros) + + a - Class + b - Skill + c - Level + d - Max Value + (e - Unknown) +*/ + +/* + NOTE: Disregard this until it is sorted out + + I changed (tradeskill==75) to ExtSkillGenericTradeskill in tradeskills.cpp for both instances. If it's a pseudo-enumeration of + an AA ability, then use the 'ExtSkill' ('ExtentedSkill') prefix with a value >= 100. (current implementation) + + We probably need to recode ALL of the skill checks to use the new Skill2HPiercing and ensure that the animation value is + properly changed in the patch files. As far as earlier clients using this new skill, it can be done, but we just need to ensure + that skill address is not inadvertently passed to the client..and we can just send an actual message for the skill-up. Use of a + command can tell the player what that particular skill value is. + + Nothing on SkillTripleAttack just yet..haven't looked into its current implementation. + + In addition to the above re-coding, we're probably going to need to rework the database pp blob to reserve space for the current + 100-dword buffer allocation. This way, we can just add new ones without having to rework it each time. + + -U +*/ +}; + +// temporary until it can be sorted out... +#define HIGHEST_SKILL SkillFrenzy + +// TODO: add string return for skill names + +/* +** Old typedef enumeration +** +*/ +/* Correct Skill Numbers as of 4-14-2002 typedef enum { _1H_BLUNT = 0, _1H_SLASHING = 1, @@ -99,6 +257,6 @@ typedef enum { } SkillType; #define HIGHEST_SKILL FRENZY +*/ #endif - diff --git a/common/spdat.h b/common/spdat.h index 27dfb4ef2..225dbf0f1 100644 --- a/common/spdat.h +++ b/common/spdat.h @@ -641,7 +641,7 @@ struct SPDat_Spell_Struct /* 086 */ int effectid[EFFECT_COUNT]; // Spell's effects /* 098 */ SpellTargetType targettype; // Spell's Target /* 099 */ int basediff; // base difficulty fizzle adjustment -/* 100 */ SkillType skill; +/* 100 */ SkillUseTypes skill; /* 101 */ int8 zonetype; // 01=Outdoors, 02=dungeons, ff=Any /* 102 */ int8 EnvironmentType; /* 103 */ int8 TimeOfDay; diff --git a/world/client.cpp b/world/client.cpp index da213ef92..fd45567c6 100644 --- a/world/client.cpp +++ b/world/client.cpp @@ -1446,7 +1446,7 @@ bool Client::OPCharCreate(char *name, CharCreate_Struct *cc) SetRacialLanguages( &pp ); // bUsh SetRaceStartingSkills( &pp ); // bUsh SetClassStartingSkills( &pp ); // bUsh - pp.skills[SENSE_HEADING] = 200; + pp.skills[SkillSenseHeading] = 200; // Some one fucking fix this to use a field name. -Doodman //pp.unknown3596[28] = 15; // @bp: This is to enable disc usage // strcpy(pp.servername, WorldConfig::get()->ShortName.c_str()); @@ -1835,26 +1835,26 @@ void Client::SetClassStartingSkills( PlayerProfile_Struct *pp ) { for(uint32 i = 0; i <= HIGHEST_SKILL; ++i) { if(pp->skills[i] == 0) { - if(i >= SPECIALIZE_ABJURE && i <= SPECIALIZE_EVOCATION) { + if(i >= SkillSpecializeAbjure && i <= SkillSpecializeEvocation) { continue; } - if(i == MAKE_POISON || - i == TINKERING || - i == RESEARCH || - i == ALCHEMY || - i == BAKING || - i == TAILORING || - i == BLACKSMITHING || - i == FLETCHING || - i == BREWING || - i == POTTERY || - i == JEWELRY_MAKING || - i == BEGGING) { + if(i == SkillMakePoison || + i == SkillTinkering || + i == SkillResearch || + i == SkillAlchemy || + i == SkillBaking || + i == SkillTailoring || + i == SkillBlacksmithing || + i == SkillFletching || + i == SkillBrewing || + i == SkillPottery || + i == SkillJewelryMaking || + i == SkillBegging) { continue; } - pp->skills[i] = database.GetSkillCap(pp->class_, (SkillType)i, 1); + pp->skills[i] = database.GetSkillCap(pp->class_, (SkillUseTypes)i, 1); } } } @@ -1878,41 +1878,41 @@ void Client::SetRaceStartingSkills( PlayerProfile_Struct *pp ) } case DARK_ELF: { - pp->skills[HIDE] = 50; + pp->skills[SkillHide] = 50; break; } case FROGLOK: { - pp->skills[SWIMMING] = 125; + pp->skills[SkillSwimming] = 125; break; } case GNOME: { - pp->skills[TINKERING] = 50; + pp->skills[SkillTinkering] = 50; break; } case HALFLING: { - pp->skills[HIDE] = 50; - pp->skills[SNEAK] = 50; + pp->skills[SkillHide] = 50; + pp->skills[SkillSneak] = 50; break; } case IKSAR: { - pp->skills[FORAGE] = 50; - pp->skills[SWIMMING] = 100; + pp->skills[SkillForage] = 50; + pp->skills[SkillSwimming] = 100; break; } case WOOD_ELF: { - pp->skills[FORAGE] = 50; - pp->skills[HIDE] = 50; + pp->skills[SkillForage] = 50; + pp->skills[SkillHide] = 50; break; } case VAHSHIR: { - pp->skills[SAFE_FALL] = 50; - pp->skills[SNEAK] = 50; + pp->skills[SkillSafeFall] = 50; + pp->skills[SkillSneak] = 50; break; } } diff --git a/zone/AA.cpp b/zone/AA.cpp index 71af74de0..171f397d3 100644 --- a/zone/AA.cpp +++ b/zone/AA.cpp @@ -432,7 +432,7 @@ void Client::HandleAAAction(aaID activate) { int curhp = GetTarget()->GetHP(); target = aaTargetCurrent; GetTarget()->HealDamage(curhp, this); - Death(this, 0, SPELL_UNKNOWN, HAND_TO_HAND); + Death(this, 0, SPELL_UNKNOWN, SkillHandtoHand); } break; diff --git a/zone/MobAI.cpp b/zone/MobAI.cpp index 4b4950a56..7840444c0 100644 --- a/zone/MobAI.cpp +++ b/zone/MobAI.cpp @@ -885,7 +885,7 @@ void Client::AI_Process() float DualWieldProbability = 0.0f; int16 Ambidexterity = aabonuses.Ambidexterity + spellbonuses.Ambidexterity + itembonuses.Ambidexterity; - DualWieldProbability = (GetSkill(DUAL_WIELD) + GetLevel() + Ambidexterity) / 400.0f; // 78.0 max + DualWieldProbability = (GetSkill(SkillDualWield) + GetLevel() + Ambidexterity) / 400.0f; // 78.0 max int16 DWBonus = spellbonuses.DualWieldChance + itembonuses.DualWieldChance; DualWieldProbability += DualWieldProbability*float(DWBonus)/ 100.0f; @@ -1313,7 +1313,7 @@ void Mob::AI_Process() { int myclass = GetClass(); //can only dual wield without a weapon if your a monk if(GetSpecialAbility(SPECATK_INNATE_DW) || (GetEquipment(MaterialSecondary) != 0 && GetLevel() > 29) || myclass == MONK || myclass == MONKGM) { - float DualWieldProbability = (GetSkill(DUAL_WIELD) + GetLevel()) / 400.0f; + float DualWieldProbability = (GetSkill(SkillDualWield) + GetLevel()) / 400.0f; if(MakeRandomFloat(0.0, 1.0) < DualWieldProbability) { Attack(target, 14); diff --git a/zone/attack.cpp b/zone/attack.cpp index e975a85a0..1c2c52b2d 100644 --- a/zone/attack.cpp +++ b/zone/attack.cpp @@ -53,7 +53,7 @@ extern WorldServer worldserver; extern EntityList entity_list; extern Zone* zone; -bool Mob::AttackAnimation(SkillType &skillinuse, int Hand, const ItemInst* weapon) +bool Mob::AttackAnimation(SkillUseTypes &skillinuse, int Hand, const ItemInst* weapon) { // Determine animation int type = 0; @@ -66,49 +66,49 @@ bool Mob::AttackAnimation(SkillType &skillinuse, int Hand, const ItemInst* weapo { case ItemType1HSlash: // 1H Slashing { - skillinuse = _1H_SLASHING; + skillinuse = Skill1HSlashing; type = anim1HWeapon; break; } case ItemType2HSlash: // 2H Slashing { - skillinuse = _2H_SLASHING; + skillinuse = Skill2HSlashing; type = anim2HSlashing; break; } case ItemType1HPiercing: // Piercing { - skillinuse = PIERCING; + skillinuse = Skill1HPiercing; type = animPiercing; break; } case ItemType1HBlunt: // 1H Blunt { - skillinuse = _1H_BLUNT; + skillinuse = Skill1HBlunt; type = anim1HWeapon; break; } case ItemType2HBlunt: // 2H Blunt { - skillinuse = _2H_BLUNT; + skillinuse = Skill2HBlunt; type = anim2HWeapon; break; } case ItemType2HPiercing: // 2H Piercing { - skillinuse = PIERCING; + skillinuse = Skill1HPiercing; // change to Skill2HPiercing once activated type = anim2HWeapon; break; } case ItemTypeMartial: { - skillinuse = HAND_TO_HAND; + skillinuse = SkillHandtoHand; type = animHand2Hand; break; } default: { - skillinuse = HAND_TO_HAND; + skillinuse = SkillHandtoHand; type = animHand2Hand; break; } @@ -118,37 +118,37 @@ bool Mob::AttackAnimation(SkillType &skillinuse, int Hand, const ItemInst* weapo switch (skillinuse) { - case _1H_SLASHING: // 1H Slashing + case Skill1HSlashing: // 1H Slashing { type = anim1HWeapon; break; } - case _2H_SLASHING: // 2H Slashing + case Skill2HSlashing: // 2H Slashing { type = anim2HSlashing; break; } - case PIERCING: // Piercing + case Skill1HPiercing: // Piercing { type = animPiercing; break; } - case _1H_BLUNT: // 1H Blunt + case Skill1HBlunt: // 1H Blunt { type = anim1HWeapon; break; } - case _2H_BLUNT: // 2H Blunt + case Skill2HBlunt: // 2H Blunt { type = anim2HWeapon; break; } - case 99: // 2H Piercing + case 99: // 2H Piercing // change to Skill2HPiercing once activated { type = anim2HWeapon; break; } - case HAND_TO_HAND: + case SkillHandtoHand: { type = animHand2Hand; break; @@ -161,7 +161,7 @@ bool Mob::AttackAnimation(SkillType &skillinuse, int Hand, const ItemInst* weapo }// switch } else { - skillinuse = HAND_TO_HAND; + skillinuse = SkillHandtoHand; type = animHand2Hand; } @@ -175,7 +175,7 @@ bool Mob::AttackAnimation(SkillType &skillinuse, int Hand, const ItemInst* weapo // called when a mob is attacked, does the checks to see if it's a hit // and does other mitigation checks. 'this' is the mob being attacked. -bool Mob::CheckHitChance(Mob* other, SkillType skillinuse, int Hand, int16 chance_mod) +bool Mob::CheckHitChance(Mob* other, SkillUseTypes skillinuse, int Hand, int16 chance_mod) { /*/ //Reworked a lot of this code to achieve better balance at higher levels. @@ -254,7 +254,7 @@ bool Mob::CheckHitChance(Mob* other, SkillType skillinuse, int Hand, int16 chanc if(defender->IsClient()) { - chancetohit += (RuleR(Combat,WeaponSkillFalloff) * (defender->CastToClient()->MaxSkill(DEFENSE) - defender->GetSkill(DEFENSE))); + chancetohit += (RuleR(Combat,WeaponSkillFalloff) * (defender->CastToClient()->MaxSkill(SkillDefense) - defender->GetSkill(SkillDefense))); mlog(COMBAT__TOHIT, "Chance to hit after weapon falloff calc (defense) %.2f", chancetohit); } @@ -314,7 +314,7 @@ bool Mob::CheckHitChance(Mob* other, SkillType skillinuse, int Hand, int16 chanc chancetohit += ((chancetohit * hitBonus) / 100.0f); - if(skillinuse == ARCHERY) + if(skillinuse == SkillArchery) chancetohit -= (chancetohit * RuleR(Combat, ArcheryHitPenalty)) / 100.0f; chancetohit = mod_hit_chance(chancetohit, skillinuse, attacker); @@ -389,9 +389,9 @@ bool Mob::AvoidDamage(Mob* other, int32 &damage, bool CanRiposte) if (CanRiposte && damage > 0 && CanThisClassRiposte() && !other->BehindMob(this, other->GetX(), other->GetY())) { riposte_chance = (100.0f + (float)defender->aabonuses.RiposteChance + (float)defender->spellbonuses.RiposteChance + (float)defender->itembonuses.RiposteChance) / 100.0f; - skill = GetSkill(RIPOSTE); + skill = GetSkill(SkillRiposte); if (IsClient()) { - CastToClient()->CheckIncreaseSkill(RIPOSTE, other, -10); + CastToClient()->CheckIncreaseSkill(SkillRiposte, other, -10); } if (!ghit) { //if they are not using a garunteed hit discipline @@ -429,9 +429,9 @@ bool Mob::AvoidDamage(Mob* other, int32 &damage, bool CanRiposte) float block_chance = 0.0f; if (damage > 0 && CanThisClassBlock() && (!other->BehindMob(this, other->GetX(), other->GetY()) || bBlockFromRear)) { block_chance = (100.0f + (float)spellbonuses.IncreaseBlockChance + (float)itembonuses.IncreaseBlockChance) / 100.0f; - skill = CastToClient()->GetSkill(BLOCKSKILL); + skill = CastToClient()->GetSkill(SkillBlock); if (IsClient()) { - CastToClient()->CheckIncreaseSkill(BLOCKSKILL, other, -10); + CastToClient()->CheckIncreaseSkill(SkillBlock, other, -10); } if (!ghit) { //if they are not using a garunteed hit discipline @@ -480,9 +480,9 @@ bool Mob::AvoidDamage(Mob* other, int32 &damage, bool CanRiposte) if (damage > 0 && CanThisClassParry() && !other->BehindMob(this, other->GetX(), other->GetY())) { parry_chance = (100.0f + (float)defender->spellbonuses.ParryChance + (float)defender->itembonuses.ParryChance) / 100.0f; - skill = CastToClient()->GetSkill(PARRY); + skill = CastToClient()->GetSkill(SkillParry); if (IsClient()) { - CastToClient()->CheckIncreaseSkill(PARRY, other, -10); + CastToClient()->CheckIncreaseSkill(SkillParry, other, -10); } if (!ghit) { //if they are not using a garunteed hit discipline @@ -503,9 +503,9 @@ bool Mob::AvoidDamage(Mob* other, int32 &damage, bool CanRiposte) if (damage > 0 && CanThisClassDodge() && !other->BehindMob(this, other->GetX(), other->GetY())) { dodge_chance = (100.0f + (float)defender->spellbonuses.DodgeChance + (float)defender->itembonuses.DodgeChance) / 100.0f; - skill = CastToClient()->GetSkill(DODGE); + skill = CastToClient()->GetSkill(SkillDodge); if (IsClient()) { - CastToClient()->CheckIncreaseSkill(DODGE, other, -10); + CastToClient()->CheckIncreaseSkill(SkillDodge, other, -10); } if (!ghit) { //if they are not using a garunteed hit discipline @@ -644,11 +644,11 @@ void Mob::MeleeMitigation(Mob *attacker, int32 &damage, int32 minhit, ExtraAttac mitigation_rating = 0.0; if(GetClass() == WIZARD || GetClass() == MAGICIAN || GetClass() == NECROMANCER || GetClass() == ENCHANTER) { - mitigation_rating = ((GetSkill(DEFENSE) + itembonuses.HeroicAGI/10) / 4.0) + armor + 1; + mitigation_rating = ((GetSkill(SkillDefense) + itembonuses.HeroicAGI/10) / 4.0) + armor + 1; } else { - mitigation_rating = ((GetSkill(DEFENSE) + itembonuses.HeroicAGI/10) / 3.0) + (armor * 1.333333) + 1; + mitigation_rating = ((GetSkill(SkillDefense) + itembonuses.HeroicAGI/10) / 3.0) + (armor * 1.333333) + 1; } mitigation_rating *= 0.847; @@ -656,11 +656,11 @@ void Mob::MeleeMitigation(Mob *attacker, int32 &damage, int32 minhit, ExtraAttac if(attacker->IsClient()) { - attack_rating = (attacker->CastToClient()->CalcATK() + ((attacker->GetSTR()-66) * 0.9) + (attacker->GetSkill(OFFENSE)*1.345)); + attack_rating = (attacker->CastToClient()->CalcATK() + ((attacker->GetSTR()-66) * 0.9) + (attacker->GetSkill(SkillOffense)*1.345)); } else { - attack_rating = (attacker->GetATK() + (attacker->GetSkill(OFFENSE)*1.345) + ((attacker->GetSTR()-66) * 0.9)); + attack_rating = (attacker->GetATK() + (attacker->GetSkill(SkillOffense)*1.345) + ((attacker->GetSTR()-66) * 0.9)); } attack_rating = attacker->mod_attack_rating(attack_rating, this); @@ -1156,7 +1156,7 @@ bool Client::Attack(Mob* other, int Hand, bool bRiposte, bool IsStrikethrough, b // calculate attack_skill and skillinuse depending on hand and weapon // also send Packet to near clients - SkillType skillinuse; + SkillUseTypes skillinuse; AttackAnimation(skillinuse, Hand, weapon); mlog(COMBAT__ATTACKS, "Attacking with %s in slot %d using skill %d", weapon?weapon->GetItem()->Name:"Fist", Hand, skillinuse); @@ -1192,7 +1192,7 @@ bool Client::Attack(Mob* other, int Hand, bool bRiposte, bool IsStrikethrough, b max_hit = (RuleI(Combat, HitCapPre20)); CheckIncreaseSkill(skillinuse, other, -15); - CheckIncreaseSkill(OFFENSE, other, -15); + CheckIncreaseSkill(SkillOffense, other, -15); // *************************************************************** @@ -1385,7 +1385,7 @@ void Mob::Heal() SendHPUpdate(); } -void Client::Damage(Mob* other, int32 damage, uint16 spell_id, SkillType attack_skill, bool avoidable, int8 buffslot, bool iBuffTic) +void Client::Damage(Mob* other, int32 damage, uint16 spell_id, SkillUseTypes attack_skill, bool avoidable, int8 buffslot, bool iBuffTic) { if(dead || IsCorpse()) return; @@ -1407,7 +1407,7 @@ void Client::Damage(Mob* other, int32 damage, uint16 spell_id, SkillType attack_ //Don't do PvP mitigation if the caster is damaging himself if(other && other->IsClient() && (other != this) && damage > 0) { int PvPMitigation = 100; - if(attack_skill == ARCHERY) + if(attack_skill == SkillArchery) PvPMitigation = 80; else PvPMitigation = 67; @@ -1423,11 +1423,11 @@ void Client::Damage(Mob* other, int32 damage, uint16 spell_id, SkillType attack_ if (damage > 0) { if (spell_id == SPELL_UNKNOWN) - CheckIncreaseSkill(DEFENSE, other, -15); + CheckIncreaseSkill(SkillDefense, other, -15); } } -bool Client::Death(Mob* killerMob, int32 damage, uint16 spell, SkillType attack_skill) +bool Client::Death(Mob* killerMob, int32 damage, uint16 spell, SkillUseTypes attack_skill) { if(!ClientFinishedLoading()) return false; @@ -1743,13 +1743,13 @@ bool NPC::Attack(Mob* other, int Hand, bool bRiposte, bool IsStrikethrough, bool FaceTarget(GetTarget()); - SkillType skillinuse = HAND_TO_HAND; + SkillUseTypes skillinuse = SkillHandtoHand; if (Hand == 13) { - skillinuse = static_cast(GetPrimSkill()); + skillinuse = static_cast(GetPrimSkill()); OffHandAtk(false); } if (Hand == 14) { - skillinuse = static_cast(GetSecSkill()); + skillinuse = static_cast(GetSecSkill()); OffHandAtk(true); } @@ -1772,30 +1772,32 @@ bool NPC::Attack(Mob* other, int Hand, bool bRiposte, bool IsStrikethrough, bool switch(weapon->ItemType){ case ItemType1HSlash: - skillinuse = _1H_SLASHING; + skillinuse = Skill1HSlashing; break; case ItemType2HSlash: - skillinuse = _2H_SLASHING; + skillinuse = Skill2HSlashing; break; case ItemType1HPiercing: + //skillinuse = Skill1HPiercing; + //break; case ItemType2HPiercing: - skillinuse = PIERCING; + skillinuse = Skill1HPiercing; // change to Skill2HPiercing once activated break; case ItemType1HBlunt: - skillinuse = _1H_BLUNT; + skillinuse = Skill1HBlunt; break; case ItemType2HBlunt: - skillinuse = _2H_BLUNT; + skillinuse = Skill2HBlunt; break; case ItemTypeBow: - skillinuse = ARCHERY; + skillinuse = SkillArchery; break; case ItemTypeLargeThrowing: case ItemTypeSmallThrowing: - skillinuse = THROWING; + skillinuse = SkillThrowing; break; default: - skillinuse = HAND_TO_HAND; + skillinuse = SkillHandtoHand; break; } } @@ -1807,9 +1809,10 @@ bool NPC::Attack(Mob* other, int Hand, bool bRiposte, bool IsStrikethrough, bool ItemInst weapon_inst(weapon, charges); AttackAnimation(skillinuse, Hand, &weapon_inst); + // Remove this once Skill2HPiercing is activated //Work-around for there being no 2HP skill - We use 99 for the 2HB animation and 36 for pierce messages if(skillinuse == 99) - skillinuse = static_cast(36); + skillinuse = static_cast(36); //basically "if not immune" then do the attack if((weapon_damage) > 0) { @@ -1996,7 +1999,7 @@ bool NPC::Attack(Mob* other, int Hand, bool bRiposte, bool IsStrikethrough, bool return false; } -void NPC::Damage(Mob* other, int32 damage, uint16 spell_id, SkillType attack_skill, bool avoidable, int8 buffslot, bool iBuffTic) { +void NPC::Damage(Mob* other, int32 damage, uint16 spell_id, SkillUseTypes attack_skill, bool avoidable, int8 buffslot, bool iBuffTic) { if(spell_id==0) spell_id = SPELL_UNKNOWN; @@ -2039,7 +2042,7 @@ void NPC::Damage(Mob* other, int32 damage, uint16 spell_id, SkillType attack_ski } } -bool NPC::Death(Mob* killerMob, int32 damage, uint16 spell, SkillType attack_skill) { +bool NPC::Death(Mob* killerMob, int32 damage, uint16 spell, SkillUseTypes attack_skill) { mlog(COMBAT__HITS, "Fatal blow dealt by %s with %d damage, spell %d, skill %d", killerMob->GetName(), damage, spell, attack_skill); Mob *oos = nullptr; @@ -2600,7 +2603,7 @@ void Mob::DamageShield(Mob* attacker, bool spell_ds) { } DS -= DS * attacker->itembonuses.DSMitigation / 100; } - attacker->Damage(this, -DS, spellid, ABJURE/*hackish*/, false); + attacker->Damage(this, -DS, spellid, SkillAbjuration/*hackish*/, false); //we can assume there is a spell now EQApplicationPacket* outapp = new EQApplicationPacket(OP_Damage, sizeof(CombatDamage_Struct)); CombatDamage_Struct* cds = (CombatDamage_Struct*)outapp->pBuffer; @@ -2627,7 +2630,7 @@ void Mob::DamageShield(Mob* attacker, bool spell_ds) { if(rev_ds < 0) { mlog(COMBAT__HITS, "Applying Reverse Damage Shield of value %d to %s", rev_ds, attacker->GetName()); - attacker->Damage(this, -rev_ds, rev_ds_spell_id, ABJURE/*hackish*/, false); //"this" (us) will get the hate, etc. not sure how this works on Live, but it'll works for now, and tanks will love us for this + attacker->Damage(this, -rev_ds, rev_ds_spell_id, SkillAbjuration/*hackish*/, false); //"this" (us) will get the hate, etc. not sure how this works on Live, but it'll works for now, and tanks will love us for this //do we need to send a damage packet here also? } } @@ -3285,12 +3288,12 @@ bool Client::CheckDoubleAttack(bool tripleAttack) { //Check for bonuses that give you a double attack chance regardless of skill (ie Bestial Frenzy/Harmonious Attack AA) uint16 bonusGiveDA = aabonuses.GiveDoubleAttack + spellbonuses.GiveDoubleAttack + itembonuses.GiveDoubleAttack; - if(!HasSkill(DOUBLE_ATTACK) && !bonusGiveDA) + if(!HasSkill(SkillDoubleAttack) && !bonusGiveDA) return false; float chance = 0.0f; - uint16 skill = GetSkill(DOUBLE_ATTACK); + uint16 skill = GetSkill(SkillDoubleAttack); int16 bonusDA = aabonuses.DoubleAttackChance + spellbonuses.DoubleAttackChance + itembonuses.DoubleAttackChance; @@ -3317,9 +3320,9 @@ bool Client::CheckDoubleAttack(bool tripleAttack) { return false; } -void Mob::CommonDamage(Mob* attacker, int32 &damage, const uint16 spell_id, const SkillType skill_used, bool &avoidable, const int8 buffslot, const bool iBuffTic) { +void Mob::CommonDamage(Mob* attacker, int32 &damage, const uint16 spell_id, const SkillUseTypes skill_used, bool &avoidable, const int8 buffslot, const bool iBuffTic) { // This method is called with skill_used=ABJURE for Damage Shield damage. - bool FromDamageShield = (skill_used == ABJURE); + bool FromDamageShield = (skill_used == SkillAbjuration); mlog(COMBAT__HITS, "Applying damage %d done by %s with skill %d and spell %d, avoidable? %s, is %sa buff tic in slot %d", damage, attacker?attacker->GetName():"NOBODY", skill_used, spell_id, avoidable?"yes":"no", iBuffTic?"":"not ", buffslot); @@ -3334,7 +3337,7 @@ void Mob::CommonDamage(Mob* attacker, int32 &damage, const uint16 spell_id, cons // only apply DS if physical damage (no spell damage) // damage shield calls this function with spell_id set, so its unavoidable - if (attacker && damage > 0 && spell_id == SPELL_UNKNOWN && skill_used != ARCHERY && skill_used != THROWING) { + if (attacker && damage > 0 && spell_id == SPELL_UNKNOWN && skill_used != SkillArchery && skill_used != SkillThrowing) { DamageShield(attacker); if (spellbonuses.DamageShield) @@ -3450,7 +3453,7 @@ void Mob::CommonDamage(Mob* attacker, int32 &damage, const uint16 spell_id, cons } //check stun chances if bashing - if (damage > 0 && ((skill_used == BASH || skill_used == KICK) && attacker)) + if (damage > 0 && ((skill_used == SkillBash || skill_used == SkillKick) && attacker)) { // NPCs can stun with their bash/kick as soon as they recieve it. // Clients can stun mobs under level 56 with their bash/kick when they get level 55 or greater. @@ -3821,16 +3824,16 @@ void Mob::TryDefensiveProc(const ItemInst* weapon, Mob *on, uint16 hand, int dam if (bSkillProc && damage < 0){ if (damage == -1) - TrySkillProc(on, BLOCKSKILL, ProcChance); + TrySkillProc(on, SkillBlock, ProcChance); if (damage == -2) - TrySkillProc(on, PARRY, ProcChance); + TrySkillProc(on, SkillParry, ProcChance); if (damage == -3) - TrySkillProc(on, RIPOSTE, ProcChance); + TrySkillProc(on, SkillRiposte, ProcChance); if (damage == -4) - TrySkillProc(on, DODGE, ProcChance); + TrySkillProc(on, SkillDodge, ProcChance); } } @@ -4109,10 +4112,10 @@ void Mob::TryCriticalHit(Mob *defender, uint16 skill, int32 &damage, ExtraAttack critChance += RuleI(Combat, WarBerBaseCritChance); } - if(skill == ARCHERY && GetClass() == RANGER && GetSkill(ARCHERY) >= 65) + if(skill == SkillArchery && GetClass() == RANGER && GetSkill(SkillArchery) >= 65) critChance += 6; - if(skill == THROWING && GetClass() == ROGUE && GetSkill(THROWING) >= 65) + if(skill == SkillThrowing && GetClass() == ROGUE && GetSkill(SkillThrowing) >= 65) critChance += 6; int CritChanceBonus = GetCriticalChanceBonus(skill); @@ -4178,7 +4181,7 @@ void Mob::TryCriticalHit(Mob *defender, uint16 skill, int32 &damage, ExtraAttack } -bool Mob::TryFinishingBlow(Mob *defender, SkillType skillinuse) +bool Mob::TryFinishingBlow(Mob *defender, SkillUseTypes skillinuse) { if (!defender) @@ -4271,7 +4274,7 @@ bool Mob::HasDied() { return Result; } -uint16 Mob::GetDamageTable(SkillType skillinuse) +uint16 Mob::GetDamageTable(SkillUseTypes skillinuse) { if(GetLevel() <= 51) { diff --git a/zone/beacon.h b/zone/beacon.h index 071bb8cc8..32709fdf2 100644 --- a/zone/beacon.h +++ b/zone/beacon.h @@ -31,8 +31,8 @@ public: ~Beacon(); //abstract virtual function implementations requird by base abstract class - virtual bool Death(Mob* killerMob, int32 damage, uint16 spell_id, SkillType attack_skill) { return true; } - virtual void Damage(Mob* from, int32 damage, uint16 spell_id, SkillType attack_skill, bool avoidable = true, int8 buffslot = -1, bool iBuffTic = false) { return; } + virtual bool Death(Mob* killerMob, int32 damage, uint16 spell_id, SkillUseTypes attack_skill) { return true; } + virtual void Damage(Mob* from, int32 damage, uint16 spell_id, SkillUseTypes attack_skill, bool avoidable = true, int8 buffslot = -1, bool iBuffTic = false) { return; } virtual bool Attack(Mob* other, int Hand = 13, bool FromRiposte = false, bool IsStrikethrough = false, bool IsFromSpell = false, ExtraAttackOptions *opts = nullptr) { return false; } virtual bool HasRaid() { return false; } diff --git a/zone/bot.cpp b/zone/bot.cpp index c29d42086..3f9ce45ac 100644 --- a/zone/bot.cpp +++ b/zone/bot.cpp @@ -1251,19 +1251,19 @@ void Bot::GenerateArmorClass() { /// new formula int avoidance = 0; - avoidance = (acmod() + ((GetSkill(DEFENSE)*16)/9)); + avoidance = (acmod() + ((GetSkill(SkillDefense)*16)/9)); if(avoidance < 0) avoidance = 0; int mitigation = 0; if(GetClass() == WIZARD || GetClass() == MAGICIAN || GetClass() == NECROMANCER || GetClass() == ENCHANTER) { - mitigation = GetSkill(DEFENSE)/4 + (itembonuses.AC+1); + mitigation = GetSkill(SkillDefense)/4 + (itembonuses.AC+1); mitigation -= 4; } else { - mitigation = GetSkill(DEFENSE)/3 + ((itembonuses.AC*4)/3); + mitigation = GetSkill(SkillDefense)/3 + ((itembonuses.AC*4)/3); if(GetClass() == MONK) mitigation += GetLevel() * 13/10; //the 13/10 might be wrong, but it is close... } @@ -1290,12 +1290,12 @@ void Bot::GenerateArmorClass() uint16 Bot::GetPrimarySkillValue() { - SkillType skill = HIGHEST_SKILL; //because nullptr == 0, which is 1H Slashing, & we want it to return 0 from GetSkill + SkillUseTypes skill = HIGHEST_SKILL; //because nullptr == 0, which is 1H Slashing, & we want it to return 0 from GetSkill bool equiped = m_inv.GetItem(SLOT_PRIMARY); if(!equiped) { - skill = HAND_TO_HAND; + skill = SkillHandtoHand; } else { @@ -1304,42 +1304,42 @@ uint16 Bot::GetPrimarySkillValue() { case ItemType1HSlash: // 1H Slashing { - skill = _1H_SLASHING; + skill = Skill1HSlashing; break; } case ItemType2HSlash: // 2H Slashing { - skill = _2H_SLASHING; + skill = Skill2HSlashing; break; } case ItemType1HPiercing: // Piercing { - skill = PIERCING; + skill = Skill1HPiercing; break; } case ItemType1HBlunt: // 1H Blunt { - skill = _1H_BLUNT; + skill = Skill1HBlunt; break; } case ItemType2HBlunt: // 2H Blunt { - skill = _2H_BLUNT; + skill = Skill2HBlunt; break; } case ItemType2HPiercing: // 2H Piercing { - skill = PIERCING; + skill = Skill1HPiercing; // change to Skill2HPiercing once activated break; } case ItemTypeMartial: // Hand to Hand { - skill = HAND_TO_HAND; + skill = SkillHandtoHand; break; } default: // All other types default to Hand to Hand { - skill = HAND_TO_HAND; + skill = SkillHandtoHand; break; } } @@ -1348,7 +1348,7 @@ uint16 Bot::GetPrimarySkillValue() return GetSkill(skill); } -uint16 Bot::MaxSkill(SkillType skillid, uint16 class_, uint16 level) const { +uint16 Bot::MaxSkill(SkillUseTypes skillid, uint16 class_, uint16 level) const { return(database.GetSkillCap(class_, skillid, level)); } @@ -1358,7 +1358,7 @@ uint16 Bot::GetTotalATK() uint16 WornCap = itembonuses.ATK; if(IsBot()) { - AttackRating = ((WornCap * 1.342) + (GetSkill(OFFENSE) * 1.345) + ((GetSTR() - 66) * 0.9) + (GetPrimarySkillValue() * 2.69)); + AttackRating = ((WornCap * 1.342) + (GetSkill(SkillOffense) * 1.345) + ((GetSTR() - 66) * 0.9) + (GetPrimarySkillValue() * 2.69)); AttackRating += aabonuses.ATK + GroupLeadershipAAOffenseEnhancement(); if (AttackRating < 10) @@ -1376,7 +1376,7 @@ uint16 Bot::GetATKRating() { uint16 AttackRating = 0; if(IsBot()) { - AttackRating = (GetSkill(OFFENSE) * 1.345) + ((GetSTR() - 66) * 0.9) + (GetPrimarySkillValue() * 2.69); + AttackRating = (GetSkill(SkillOffense) * 1.345) + ((GetSTR() - 66) * 0.9) + (GetPrimarySkillValue() * 2.69); if (AttackRating < 10) AttackRating = 10; @@ -3206,7 +3206,7 @@ void Bot::BotRangedAttack(Mob* other) { return; } - SendItemAnimation(other, Ammo, ARCHERY); + SendItemAnimation(other, Ammo, SkillArchery); DoArcheryAttackDmg(GetTarget(), rangedItem, ammoItem); @@ -3248,13 +3248,13 @@ bool Bot::CheckBotDoubleAttack(bool tripleAttack) { uint16 bonusGiveDA = aabonuses.GiveDoubleAttack + spellbonuses.GiveDoubleAttack + itembonuses.GiveDoubleAttack; // If you don't have the double attack skill, return - if(!GetSkill(DOUBLE_ATTACK) && !(GetClass() == BARD || GetClass() == BEASTLORD)) + if(!GetSkill(SkillDoubleAttack) && !(GetClass() == BARD || GetClass() == BEASTLORD)) return false; // You start with no chance of double attacking float chance = 0.0f; - uint16 skill = GetSkill(DOUBLE_ATTACK); + uint16 skill = GetSkill(SkillDoubleAttack); int16 bonusDA = aabonuses.DoubleAttackChance + spellbonuses.DoubleAttackChance + itembonuses.DoubleAttackChance; @@ -3281,15 +3281,15 @@ bool Bot::CheckBotDoubleAttack(bool tripleAttack) { return false; } -void Bot::DoMeleeSkillAttackDmg(Mob* other, uint16 weapon_damage, SkillType skillinuse, int16 chance_mod, int16 focus, bool CanRiposte) +void Bot::DoMeleeSkillAttackDmg(Mob* other, uint16 weapon_damage, SkillUseTypes skillinuse, int16 chance_mod, int16 focus, bool CanRiposte) { if (!CanDoSpecialAttack(other)) return; //For spells using skill value 98 (feral swipe ect) server sets this to 67 automatically. //Kayen: This is unlikely to be completely accurate but use OFFENSE skill value for these effects. - if (skillinuse == BEGGING) - skillinuse = OFFENSE; + if (skillinuse == SkillBegging) + skillinuse = SkillOffense; int damage = 0; uint32 hate = 0; @@ -3351,7 +3351,7 @@ void Bot::DoMeleeSkillAttackDmg(Mob* other, uint16 weapon_damage, SkillType skil else damage = -5; - if(skillinuse == BASH){ + if(skillinuse == SkillBash){ const ItemInst* inst = GetBotItem(SLOT_SECONDARY); const Item_Struct* botweapon = 0; if(inst) @@ -3367,8 +3367,8 @@ void Bot::DoMeleeSkillAttackDmg(Mob* other, uint16 weapon_damage, SkillType skil other->AddToHateList(this, hate); bool CanSkillProc = true; - if (skillinuse == OFFENSE){ //Hack to allow damage to display. - skillinuse = TIGER_CLAW; //'strike' your opponent - Arbitrary choice for message. + if (skillinuse == SkillOffense){ //Hack to allow damage to display. + skillinuse = SkillTigerClaw; //'strike' your opponent - Arbitrary choice for message. CanSkillProc = false; //Disable skill procs } @@ -3377,7 +3377,7 @@ void Bot::DoMeleeSkillAttackDmg(Mob* other, uint16 weapon_damage, SkillType skil if (HasDied()) return; - if((skillinuse == DRAGON_PUNCH) && GetAA(aaDragonPunch) && MakeRandomInt(0, 99) < 25){ + if((skillinuse == SkillDragonPunch) && GetAA(aaDragonPunch) && MakeRandomInt(0, 99) < 25){ SpellFinished(904, other, 10, 0, -1, spells[904].ResistDiff); other->Stun(100); } @@ -3388,26 +3388,26 @@ void Bot::DoMeleeSkillAttackDmg(Mob* other, uint16 weapon_damage, SkillType skil } } -void Bot::ApplySpecialAttackMod(SkillType skill, int32 &dmg, int32 &mindmg) { +void Bot::ApplySpecialAttackMod(SkillUseTypes skill, int32 &dmg, int32 &mindmg) { int item_slot = -1; //1: Apply bonus from AC (BOOT/SHIELD/HANDS) est. 40AC=6dmg switch (skill){ - case FLYING_KICK: - case ROUND_KICK: - case KICK: + case SkillFlyingKick: + case SkillRoundKick: + case SkillKick: item_slot = SLOT_FEET; break; - case BASH: + case SkillBash: item_slot = SLOT_SECONDARY; break; - case DRAGON_PUNCH: - case EAGLE_STRIKE: - case TIGER_CLAW: + case SkillDragonPunch: + case SkillEagleStrike: + case SkillTigerClaw: item_slot = SLOT_HANDS; break; } @@ -3847,7 +3847,7 @@ void Bot::AI_Process() { float DualWieldProbability = 0.0f; int16 Ambidexterity = aabonuses.Ambidexterity + spellbonuses.Ambidexterity + itembonuses.Ambidexterity; - DualWieldProbability = (GetSkill(DUAL_WIELD) + GetLevel() + Ambidexterity) / 400.0f; // 78.0 max + DualWieldProbability = (GetSkill(SkillDualWield) + GetLevel() + Ambidexterity) / 400.0f; // 78.0 max int16 DWBonus = spellbonuses.DualWieldChance + itembonuses.DualWieldChance; DualWieldProbability += DualWieldProbability*float(DWBonus)/ 100.0f; @@ -4127,7 +4127,7 @@ void Bot::PetAIProcess() { { if(botPet->GetOwner()->GetLevel() >= 24) { - float DualWieldProbability = (botPet->GetSkill(DUAL_WIELD) + botPet->GetLevel()) / 400.0f; + float DualWieldProbability = (botPet->GetSkill(SkillDualWield) + botPet->GetLevel()) / 400.0f; DualWieldProbability -= MakeRandomFloat(0, 1); if(DualWieldProbability < 0){ botPet->Attack(botPet->GetTarget(), 14); @@ -6195,7 +6195,7 @@ void Bot::PerformTradeWithClient(int16 beginSlotID, int16 endSlotID, Client* cli } } -bool Bot::Death(Mob *killerMob, int32 damage, uint16 spell_id, SkillType attack_skill) { +bool Bot::Death(Mob *killerMob, int32 damage, uint16 spell_id, SkillUseTypes attack_skill) { if(!NPC::Death(killerMob, damage, spell_id, attack_skill)) return false; @@ -6300,7 +6300,7 @@ bool Bot::Death(Mob *killerMob, int32 damage, uint16 spell_id, SkillType attack_ return true; } -void Bot::Damage(Mob *from, int32 damage, uint16 spell_id, SkillType attack_skill, bool avoidable, int8 buffslot, bool iBuffTic) { +void Bot::Damage(Mob *from, int32 damage, uint16 spell_id, SkillUseTypes attack_skill, bool avoidable, int8 buffslot, bool iBuffTic) { if(spell_id==0) spell_id = SPELL_UNKNOWN; @@ -6425,7 +6425,7 @@ bool Bot::Attack(Mob* other, int Hand, bool FromRiposte, bool IsStrikethrough, b // calculate attack_skill and skillinuse depending on hand and weapon // also send Packet to near clients - SkillType skillinuse; + SkillUseTypes skillinuse; AttackAnimation(skillinuse, Hand, weapon); mlog(COMBAT__ATTACKS, "Attacking with %s in slot %d using skill %d", weapon?weapon->GetItem()->Name:"Fist", Hand, skillinuse); @@ -7828,7 +7828,7 @@ bool Bot::AvoidDamage(Mob* other, int32 &damage, bool CanRiposte) if (CanRiposte && damage > 0 && CanThisClassRiposte() && !other->BehindMob(this, other->GetX(), other->GetY())) { riposte_chance = (100.0f + (float)defender->GetAABonuses().RiposteChance + (float)defender->GetSpellBonuses().RiposteChance + (float)defender->GetItemBonuses().RiposteChance) / 100.0f; - skill = GetSkill(RIPOSTE); + skill = GetSkill(SkillRiposte); if (!ghit) { //if they are not using a garunteed hit discipline bonus = 2.0 + skill/60.0 + (GetDEX()/200); @@ -7864,7 +7864,7 @@ bool Bot::AvoidDamage(Mob* other, int32 &damage, bool CanRiposte) float block_chance = 0.0f; if (damage > 0 && CanThisClassBlock() && (!other->BehindMob(this, other->GetX(), other->GetY()) || bBlockFromRear)) { block_chance = (100.0f + (float)spellbonuses.IncreaseBlockChance + (float)itembonuses.IncreaseBlockChance) / 100.0f; - skill = GetSkill(BLOCKSKILL); + skill = GetSkill(SkillBlock); if (!ghit) { //if they are not using a garunteed hit discipline bonus = 2.0 + skill/35.0 + (GetDEX()/200); @@ -7912,7 +7912,7 @@ bool Bot::AvoidDamage(Mob* other, int32 &damage, bool CanRiposte) if (damage > 0 && CanThisClassParry() && !other->BehindMob(this, other->GetX(), other->GetY())) { parry_chance = (100.0f + (float)defender->GetSpellBonuses().ParryChance + (float)defender->GetItemBonuses().ParryChance) / 100.0f; - skill = GetSkill(PARRY); + skill = GetSkill(SkillParry); if (!ghit) { //if they are not using a garunteed hit discipline bonus = 2.0 + skill/60.0 + (GetDEX()/200); @@ -7931,7 +7931,7 @@ bool Bot::AvoidDamage(Mob* other, int32 &damage, bool CanRiposte) if (damage > 0 && CanThisClassDodge() && !other->BehindMob(this, other->GetX(), other->GetY())) { dodge_chance = (100.0f + (float)defender->GetSpellBonuses().DodgeChance + (float)defender->GetItemBonuses().DodgeChance) / 100.0f; - skill = GetSkill(DODGE); + skill = GetSkill(SkillDodge); if (!ghit) { //if they are not using a garunteed hit discipline bonus = 2.0 + skill/60.0 + (GetAGI()/200); @@ -8001,7 +8001,7 @@ int Bot::GetMonkHandToHandDamage(void) return damage[Level]; } -bool Bot::TryFinishingBlow(Mob *defender, SkillType skillinuse) +bool Bot::TryFinishingBlow(Mob *defender, SkillUseTypes skillinuse) { if (!defender) return false; @@ -8058,7 +8058,7 @@ void Bot::DoRiposte(Mob* defender) { } } -void Bot::DoSpecialAttackDamage(Mob *who, SkillType skill, int32 max_damage, int32 min_damage, int32 hate_override,int ReuseTime, bool HitChance) { +void Bot::DoSpecialAttackDamage(Mob *who, SkillUseTypes skill, int32 max_damage, int32 min_damage, int32 hate_override,int ReuseTime, bool HitChance) { //this really should go through the same code as normal melee damage to //pick up all the special behavior there @@ -8066,7 +8066,7 @@ void Bot::DoSpecialAttackDamage(Mob *who, SkillType skill, int32 max_damage, int if(hate_override > -1) hate = hate_override; - if(skill == BASH) { + if(skill == SkillBash) { const ItemInst* inst = GetBotItem(SLOT_SECONDARY); const Item_Struct* botweapon = 0; if(inst) @@ -8086,7 +8086,7 @@ void Bot::DoSpecialAttackDamage(Mob *who, SkillType skill, int32 max_damage, int else{ bool CanRiposte = true; - if(skill == THROWING || skill == ARCHERY) // changed from '&&' + if(skill == SkillThrowing || skill == SkillArchery) // changed from '&&' CanRiposte = false; who->AvoidDamage(this, max_damage, CanRiposte); @@ -8175,7 +8175,7 @@ void Bot::TryBackstab(Mob *other, int ReuseTime) { else { RogueBackstab(other); if (level > 54) { - float DoubleAttackProbability = (GetSkill(DOUBLE_ATTACK) + GetLevel()) / 500.0f; // 62.4 max + float DoubleAttackProbability = (GetSkill(SkillDoubleAttack) + GetLevel()) / 500.0f; // 62.4 max // Check for double attack with main hand assuming maxed DA Skill (MS) if(MakeRandomFloat(0, 1) < DoubleAttackProbability) // Max 62.4 % chance of DA @@ -8195,7 +8195,7 @@ void Bot::TryBackstab(Mob *other, int ReuseTime) { //we can stab from any angle, we do min damage though. RogueBackstab(other, true); if (level > 54) { - float DoubleAttackProbability = (GetSkill(DOUBLE_ATTACK) + GetLevel()) / 500.0f; // 62.4 max + float DoubleAttackProbability = (GetSkill(SkillDoubleAttack) + GetLevel()) / 500.0f; // 62.4 max // Check for double attack with main hand assuming maxed DA Skill (MS) if(MakeRandomFloat(0, 1) < DoubleAttackProbability) // Max 62.4 % chance of DA if(other->GetHP() > 0) @@ -8241,12 +8241,12 @@ void Bot::RogueBackstab(Mob* other, bool min_damage, int ReuseTime) if(primaryweapondamage > 0){ if(level > 25){ - max_hit = (((2*backstab_dmg) * GetDamageTable(BACKSTAB) / 100) * 10 * GetSkill(BACKSTAB) / 355) + ((level-25)/3) + 1; - hate = 20 * backstab_dmg * GetSkill(BACKSTAB) / 355; + max_hit = (((2*backstab_dmg) * GetDamageTable(SkillBackstab) / 100) * 10 * GetSkill(SkillBackstab) / 355) + ((level-25)/3) + 1; + hate = 20 * backstab_dmg * GetSkill(SkillBackstab) / 355; } else{ - max_hit = (((2*backstab_dmg) * GetDamageTable(BACKSTAB) / 100) * 10 * GetSkill(BACKSTAB) / 355) + 1; - hate = 20 * backstab_dmg * GetSkill(BACKSTAB) / 355; + max_hit = (((2*backstab_dmg) * GetDamageTable(SkillBackstab) / 100) * 10 * GetSkill(SkillBackstab) / 355) + 1; + hate = 20 * backstab_dmg * GetSkill(SkillBackstab) / 355; } // determine minimum hits @@ -8260,7 +8260,7 @@ void Bot::RogueBackstab(Mob* other, bool min_damage, int ReuseTime) min_hit = (level * ( level*5 - 105)) / 100; } - if(!other->CheckHitChance(this, BACKSTAB, 0)) { + if(!other->CheckHitChance(this, SkillBackstab, 0)) { ndamage = 0; } else{ @@ -8284,7 +8284,7 @@ void Bot::RogueBackstab(Mob* other, bool min_damage, int ReuseTime) ndamage = -5; } - DoSpecialAttackDamage(other, BACKSTAB, ndamage, min_hit, hate, ReuseTime); + DoSpecialAttackDamage(other, SkillBackstab, ndamage, min_hit, hate, ReuseTime); DoAnim(animPiercing); } @@ -8293,10 +8293,10 @@ void Bot::RogueAssassinate(Mob* other) ItemInst* botweaponInst = GetBotItem(SLOT_PRIMARY); if(botweaponInst) { if(GetWeaponDamage(other, botweaponInst)) { - other->Damage(this, 32000, SPELL_UNKNOWN, BACKSTAB); + other->Damage(this, 32000, SPELL_UNKNOWN, SkillBackstab); } else { - other->Damage(this, -5, SPELL_UNKNOWN, BACKSTAB); + other->Damage(this, -5, SPELL_UNKNOWN, SkillBackstab); } } @@ -8389,18 +8389,18 @@ void Bot::DoClassAttacks(Mob *target, bool IsRiposte) { } if(!canBash || MakeRandomInt(0, 100) > 25) { //tested on live, warrior mobs both kick and bash, kick about 75% of the time, casting doesn't seem to make a difference. - skill_to_use = KICK; + skill_to_use = SkillKick; } else { - skill_to_use = BASH; + skill_to_use = SkillBash; } } case RANGER: case BEASTLORD: - skill_to_use = KICK; + skill_to_use = SkillKick; break; case BERSERKER: - skill_to_use = FRENZY; + skill_to_use = SkillFrenzy; break; case CLERIC: case SHADOWKNIGHT: @@ -8412,38 +8412,38 @@ void Bot::DoClassAttacks(Mob *target, bool IsRiposte) { || m_inv.GetItem(SLOT_PRIMARY)->GetItem()->ItemType == ItemType2HBlunt || m_inv.GetItem(SLOT_PRIMARY)->GetItem()->ItemType == ItemType2HPiercing) && GetAA(aa2HandBash) >= 1)) { //Using 2 hand weapon, but has AA 2 Hand Bash - skill_to_use = BASH; + skill_to_use = SkillBash; } } break; case MONK: if(GetLevel() >= 30) { - skill_to_use = FLYING_KICK; + skill_to_use = SkillFlyingKick; } else if(GetLevel() >= 25) { - skill_to_use = DRAGON_PUNCH; + skill_to_use = SkillDragonPunch; } else if(GetLevel() >= 20) { - skill_to_use = EAGLE_STRIKE; + skill_to_use = SkillEagleStrike; } else if(GetLevel() >= 10) { - skill_to_use = TIGER_CLAW; + skill_to_use = SkillTigerClaw; } else if(GetLevel() >= 5) { - skill_to_use = ROUND_KICK; + skill_to_use = SkillRoundKick; } else { - skill_to_use = KICK; + skill_to_use = SkillKick; } break; case ROGUE: - skill_to_use = BACKSTAB; + skill_to_use = SkillBackstab; break; } @@ -8451,7 +8451,7 @@ void Bot::DoClassAttacks(Mob *target, bool IsRiposte) { return; - if(skill_to_use == BASH) + if(skill_to_use == SkillBash) { if (target!=this) { @@ -8462,7 +8462,7 @@ void Bot::DoClassAttacks(Mob *target, bool IsRiposte) { dmg = -5; } else{ - if(!target->CheckHitChance(this, BASH, 0)) { + if(!target->CheckHitChance(this, SkillBash, 0)) { dmg = 0; } else{ @@ -8477,7 +8477,7 @@ void Bot::DoClassAttacks(Mob *target, bool IsRiposte) { reuse = BashReuseTime * 1000; //reuse = (reuse*HasteModifier)/100; - DoSpecialAttackDamage(target, BASH, dmg, 1,-1,reuse); + DoSpecialAttackDamage(target, SkillBash, dmg, 1,-1,reuse); did_attack = true; @@ -8488,13 +8488,13 @@ void Bot::DoClassAttacks(Mob *target, bool IsRiposte) { } } - if(skill_to_use == FRENZY) + if(skill_to_use == SkillFrenzy) { int AtkRounds = 3; int skillmod = 0; - if(MaxSkill(FRENZY) > 0) - skillmod = 100*GetSkill(FRENZY)/MaxSkill(FRENZY); + if(MaxSkill(SkillFrenzy) > 0) + skillmod = 100*GetSkill(SkillFrenzy)/MaxSkill(SkillFrenzy); int32 max_dmg = (26 + ((((GetLevel()-6) * 2)*skillmod)/100)) * ((100+RuleI(Combat, FrenzyBonus))/100); int32 min_dmg = 0; @@ -8517,7 +8517,7 @@ void Bot::DoClassAttacks(Mob *target, bool IsRiposte) { while(AtkRounds > 0) { if (GetTarget() && (AtkRounds == 1 || MakeRandomInt(0,100) < 75)){ - DoSpecialAttackDamage(GetTarget(), FRENZY, max_dmg, min_dmg, max_dmg , reuse, true); + DoSpecialAttackDamage(GetTarget(), SkillFrenzy, max_dmg, min_dmg, max_dmg , reuse, true); } AtkRounds--; } @@ -8527,7 +8527,7 @@ void Bot::DoClassAttacks(Mob *target, bool IsRiposte) { } } - if(skill_to_use == KICK) + if(skill_to_use == SkillKick) { if(target!=this) { @@ -8537,7 +8537,7 @@ void Bot::DoClassAttacks(Mob *target, bool IsRiposte) { dmg = -5; } else{ - if(!target->CheckHitChance(this, KICK, 0)) { + if(!target->CheckHitChance(this, SkillKick, 0)) { dmg = 0; } else{ @@ -8550,17 +8550,17 @@ void Bot::DoClassAttacks(Mob *target, bool IsRiposte) { reuse = KickReuseTime * 1000; - DoSpecialAttackDamage(target, KICK, dmg, 1,-1, reuse); + DoSpecialAttackDamage(target, SkillKick, dmg, 1,-1, reuse); did_attack = true; } } - if(skill_to_use == FLYING_KICK || - skill_to_use == DRAGON_PUNCH || - skill_to_use == EAGLE_STRIKE || - skill_to_use == TIGER_CLAW || - skill_to_use == ROUND_KICK) + if(skill_to_use == SkillFlyingKick || + skill_to_use == SkillDragonPunch || + skill_to_use == SkillEagleStrike || + skill_to_use == SkillTigerClaw || + skill_to_use == SkillRoundKick) { reuse = MonkSpecialAttack(target, skill_to_use) - 1; MonkSpecialAttack(target, skill_to_use); @@ -8569,7 +8569,7 @@ void Bot::DoClassAttacks(Mob *target, bool IsRiposte) { uint16 bDoubleSpecialAttack = itembonuses.DoubleSpecialAttack + spellbonuses.DoubleSpecialAttack + aabonuses.DoubleSpecialAttack; if( bDoubleSpecialAttack && (bDoubleSpecialAttack >= 100 || bDoubleSpecialAttack > MakeRandomInt(0,100))) { - int MonkSPA [5] = { FLYING_KICK, DRAGON_PUNCH, EAGLE_STRIKE, TIGER_CLAW, ROUND_KICK }; + int MonkSPA [5] = { SkillFlyingKick, SkillDragonPunch, SkillEagleStrike, SkillTigerClaw, SkillRoundKick }; MonkSpecialAttack(target, MonkSPA[MakeRandomInt(0,4)]); int TripleChance = 25; @@ -8586,7 +8586,7 @@ void Bot::DoClassAttacks(Mob *target, bool IsRiposte) { did_attack = true; } - if(skill_to_use == BACKSTAB) + if(skill_to_use == SkillBackstab) { reuse = BackstabReuseTime * 1000; did_attack = true; @@ -8600,10 +8600,10 @@ void Bot::DoClassAttacks(Mob *target, bool IsRiposte) { classattack_timer.Start(reuse*HasteModifier/100); } -bool Bot::TryHeadShot(Mob* defender, SkillType skillInUse) { +bool Bot::TryHeadShot(Mob* defender, SkillUseTypes skillInUse) { bool Result = false; - if(defender && (defender->GetBodyType() == BT_Humanoid) && (skillInUse == ARCHERY) && (GetClass() == RANGER) && (GetLevel() >= 62)) { + if(defender && (defender->GetBodyType() == BT_Humanoid) && (skillInUse == SkillArchery) && (GetClass() == RANGER) && (GetLevel() >= 62)) { int defenderLevel = defender->GetLevel(); int rangerLevel = GetLevel(); // Bot Ranger Headshot AA through level 85(Underfoot) @@ -9036,7 +9036,7 @@ void Bot::SetAttackTimer() { } //clients must have the skill to use it... - if(!GetSkill(DUAL_WIELD)) { + if(!GetSkill(SkillDualWield)) { attack_dw_timer.Disable(); continue; } @@ -10610,7 +10610,7 @@ int32 Bot::CalcManaRegen() { BuffFadeBySitModifier(); if(botclass != WARRIOR && botclass != MONK && botclass != ROGUE && botclass != BERSERKER) { - regen = (((GetSkill(MEDITATE) / 10) + (level - (level / 4))) / 4) + 4; + regen = (((GetSkill(SkillMeditate) / 10) + (level - (level / 4))) / 4) + 4; regen += spellbonuses.ManaRegen + itembonuses.ManaRegen; } else @@ -11572,7 +11572,7 @@ void Bot::CalcBotStats(bool showtext) { // Test Code if(GetClass() == BARD) GetBotOwner()->Message(15, "Bard Skills-- Brass: %i, Percussion: %i, Singing: %i, Stringed: %i, Wind: %i", - GetSkill(BRASS_INSTRUMENTS), GetSkill(PERCUSSION_INSTRUMENTS), GetSkill(SINGING), GetSkill(STRINGED_INSTRUMENTS), GetSkill(WIND_INSTRUMENTS)); + GetSkill(SkillBrassInstruments), GetSkill(SkillPercussionInstruments), GetSkill(SkillSinging), GetSkill(SkillStringedInstruments), GetSkill(SkillWindInstruments)); } /*if(this->Save()) @@ -11591,11 +11591,11 @@ void Bot::CalcBotStats(bool showtext) { // Test Code if(GetClass() == BARD) { GetBotOwner()->Message(15, "Bard Skills-- Brass: %i, Percussion: %i, Singing: %i, Stringed: %i, Wind: %i", - GetSkill(BRASS_INSTRUMENTS) + GetBrassMod(), - GetSkill(PERCUSSION_INSTRUMENTS) + GetPercMod(), - GetSkill(SINGING) + GetSingMod(), - GetSkill(STRINGED_INSTRUMENTS) + GetStringMod(), - GetSkill(WIND_INSTRUMENTS) + GetWindMod()); + GetSkill(SkillBrassInstruments) + GetBrassMod(), + GetSkill(SkillPercussionInstruments) + GetPercMod(), + GetSkill(SkillSinging) + GetSingMod(), + GetSkill(SkillStringedInstruments) + GetStringMod(), + GetSkill(SkillWindInstruments) + GetWindMod()); GetBotOwner()->Message(15, "Bard Skill Mods-- Brass: %i, Percussion: %i, Singing: %i, Stringed: %i, Wind: %i", GetBrassMod(), GetPercMod(), GetSingMod(), GetStringMod(), GetWindMod()); } } @@ -15061,7 +15061,7 @@ void Bot::ProcessBotCommands(Client *c, const Seperator *sep) { c->Message(13, "You must target a bot that you own."); if(targetedBot) { - if(targetedBot->GetSkill(TAUNT) > 0) { + if(targetedBot->GetSkill(SkillTaunt) > 0) { if(toggle) taunt = !targetedBot->taunting; @@ -16336,16 +16336,16 @@ void EntityList::BotPickLock(Bot* rogue) float bonus1 = 0.0f; float bonus2 = 0.0f; - float skill = rogue->GetSkill(PICK_LOCK); + float skill = rogue->GetSkill(SkillPickLock); if(item1) { // Hand slot item - if(item1->GetItem()->SkillModType == PICK_LOCK) { + if(item1->GetItem()->SkillModType == SkillPickLock) { bonus1 = skill * (((float)item1->GetItem()->SkillModValue) / 100.0f); } } if(item2) { // Primary slot item - if(item2->GetItem()->SkillModType == PICK_LOCK) { + if(item2->GetItem()->SkillModType == SkillPickLock) { bonus2 = skill * (((float)item2->GetItem()->SkillModValue) / 100.0f); } } diff --git a/zone/bot.h b/zone/bot.h index 9d6fc2ae5..2330bf366 100644 --- a/zone/bot.h +++ b/zone/bot.h @@ -134,8 +134,8 @@ public: Bot(uint32 botID, uint32 botOwnerCharacterID, uint32 botSpellsID, double totalPlayTime, uint32 lastZoneId, NPCType npcTypeData); //abstract virtual function implementations requird by base abstract class - virtual bool Death(Mob* killerMob, int32 damage, uint16 spell_id, SkillType attack_skill); - virtual void Damage(Mob* from, int32 damage, uint16 spell_id, SkillType attack_skill, bool avoidable = true, int8 buffslot = -1, bool iBuffTic = false); + virtual bool Death(Mob* killerMob, int32 damage, uint16 spell_id, SkillUseTypes attack_skill); + virtual void Damage(Mob* from, int32 damage, uint16 spell_id, SkillUseTypes attack_skill, bool avoidable = true, int8 buffslot = -1, bool iBuffTic = false); virtual bool Attack(Mob* other, int Hand = 13, bool FromRiposte = false, bool IsStrikethrough = false, bool IsFromSpell = false, ExtraAttackOptions *opts = nullptr); virtual bool HasRaid() { return (GetRaid() ? true : false); } @@ -169,23 +169,23 @@ public: virtual float GetProcChances(float &ProcBonus, float &ProcChance, uint16 weapon_speed, uint16 hand); virtual bool AvoidDamage(Mob* other, int32 &damage, bool CanRiposte); virtual int GetMonkHandToHandDamage(void); - virtual bool TryFinishingBlow(Mob *defender, SkillType skillinuse); + virtual bool TryFinishingBlow(Mob *defender, SkillUseTypes skillinuse); virtual void DoRiposte(Mob* defender); - inline virtual int16 GetATK() const { return ATK + itembonuses.ATK + spellbonuses.ATK + ((GetSTR() + GetSkill(OFFENSE)) * 9 / 10); } + inline virtual int16 GetATK() const { return ATK + itembonuses.ATK + spellbonuses.ATK + ((GetSTR() + GetSkill(SkillOffense)) * 9 / 10); } inline virtual int16 GetATKBonus() const { return itembonuses.ATK + spellbonuses.ATK; } uint16 GetTotalATK(); uint16 GetATKRating(); uint16 GetPrimarySkillValue(); - uint16 MaxSkill(SkillType skillid, uint16 class_, uint16 level) const; - inline uint16 MaxSkill(SkillType skillid) const { return MaxSkill(skillid, GetClass(), GetLevel()); } - virtual void DoSpecialAttackDamage(Mob *who, SkillType skill, int32 max_damage, int32 min_damage = 1, int32 hate_override = -1, int ReuseTime = 10, bool HitChance=false); + uint16 MaxSkill(SkillUseTypes skillid, uint16 class_, uint16 level) const; + inline uint16 MaxSkill(SkillUseTypes skillid) const { return MaxSkill(skillid, GetClass(), GetLevel()); } + virtual void DoSpecialAttackDamage(Mob *who, SkillUseTypes skill, int32 max_damage, int32 min_damage = 1, int32 hate_override = -1, int ReuseTime = 10, bool HitChance=false); virtual void TryBackstab(Mob *other,int ReuseTime = 10); virtual void RogueBackstab(Mob* other, bool min_damage = false, int ReuseTime = 10); virtual void RogueAssassinate(Mob* other); virtual void DoClassAttacks(Mob *target, bool IsRiposte=false); - virtual bool TryHeadShot(Mob* defender, SkillType skillInUse); - virtual void DoMeleeSkillAttackDmg(Mob* other, uint16 weapon_damage, SkillType skillinuse, int16 chance_mod=0, int16 focus=0, bool CanRiposte=false); - virtual void ApplySpecialAttackMod(SkillType skill, int32 &dmg, int32 &mindmg); + virtual bool TryHeadShot(Mob* defender, SkillUseTypes skillInUse); + virtual void DoMeleeSkillAttackDmg(Mob* other, uint16 weapon_damage, SkillUseTypes skillinuse, int16 chance_mod=0, int16 focus=0, bool CanRiposte=false); + virtual void ApplySpecialAttackMod(SkillUseTypes skill, int32 &dmg, int32 &mindmg); bool CanDoSpecialAttack(Mob *other); virtual int32 CheckAggroAmount(uint16 spellid); virtual void CalcBonuses(); diff --git a/zone/client.cpp b/zone/client.cpp index cd15d255f..b043536b3 100644 --- a/zone/client.cpp +++ b/zone/client.cpp @@ -1386,7 +1386,7 @@ bool Client::UpdateLDoNPoints(int32 points, uint32 theme) return(false); } -void Client::SetSkill(SkillType skillid, uint16 value) { +void Client::SetSkill(SkillUseTypes skillid, uint16 value) { if (skillid > HIGHEST_SKILL) return; m_pp.skills[skillid] = value; // We need to be able to #setskill 254 and 255 to reset skills @@ -1419,7 +1419,7 @@ void Client::IncreaseLanguageSkill(int skill_id, int value) { Message_StringID( MT_Skills, LANG_SKILL_IMPROVED ); //Notify client } -void Client::AddSkill(SkillType skillid, uint16 value) { +void Client::AddSkill(SkillUseTypes skillid, uint16 value) { if (skillid > HIGHEST_SKILL) return; value = GetRawSkill(skillid) + value; @@ -2295,7 +2295,7 @@ uint64 Client::GetAllMoney() { (static_cast(m_pp.platinum_shared) * 1000))))); } -bool Client::CheckIncreaseSkill(SkillType skillid, Mob *against_who, int chancemodi) { +bool Client::CheckIncreaseSkill(SkillUseTypes skillid, Mob *against_who, int chancemodi) { if (IsAIControlled()) // no skillups while chamred =p return false; if (skillid > HIGHEST_SKILL) @@ -2357,24 +2357,24 @@ void Client::CheckLanguageSkillIncrease(uint8 langid, uint8 TeacherSkill) { } } -bool Client::HasSkill(SkillType skill_id) const { +bool Client::HasSkill(SkillUseTypes skill_id) const { return((GetSkill(skill_id) > 0) && CanHaveSkill(skill_id)); } -bool Client::CanHaveSkill(SkillType skill_id) const { +bool Client::CanHaveSkill(SkillUseTypes skill_id) const { return(database.GetSkillCap(GetClass(), skill_id, RuleI(Character, MaxLevel)) > 0); //if you don't have it by max level, then odds are you never will? } -uint16 Client::MaxSkill(SkillType skillid, uint16 class_, uint16 level) const { +uint16 Client::MaxSkill(SkillUseTypes skillid, uint16 class_, uint16 level) const { return(database.GetSkillCap(class_, skillid, level)); } -uint8 Client::SkillTrainLevel(SkillType skillid, uint16 class_){ +uint8 Client::SkillTrainLevel(SkillUseTypes skillid, uint16 class_){ return(database.GetTrainLevel(class_, skillid, RuleI(Character, MaxLevel))); } -uint16 Client::GetMaxSkillAfterSpecializationRules(SkillType skillid, uint16 maxSkill) +uint16 Client::GetMaxSkillAfterSpecializationRules(SkillUseTypes skillid, uint16 maxSkill) { uint16 Result = maxSkill; @@ -2384,13 +2384,13 @@ uint16 Client::GetMaxSkillAfterSpecializationRules(SkillType skillid, uint16 max uint16 MaxSpecializations = GetAA(aaSecondaryForte) ? 2 : 1; - if(skillid >= SPECIALIZE_ABJURE && skillid <= SPECIALIZE_EVOCATION) + if(skillid >= SkillSpecializeAbjure && skillid <= SkillSpecializeEvocation) { bool HasPrimarySpecSkill = false; int NumberOfPrimarySpecSkills = 0; - for(int i = SPECIALIZE_ABJURE; i <= SPECIALIZE_EVOCATION; ++i) + for(int i = SkillSpecializeAbjure; i <= SkillSpecializeEvocation; ++i) { if(m_pp.skills[i] > 50) { @@ -2447,8 +2447,8 @@ uint16 Client::GetMaxSkillAfterSpecializationRules(SkillType skillid, uint16 max Message(13, "Your spell casting specializations skills have been reset. " "Only %i primary specialization skill is allowed.", MaxSpecializations); - for(int i = SPECIALIZE_ABJURE; i <= SPECIALIZE_EVOCATION; ++i) - SetSkill((SkillType)i, 1); + for(int i = SkillSpecializeAbjure; i <= SkillSpecializeEvocation; ++i) + SetSkill((SkillUseTypes)i, 1); Save(); @@ -2461,7 +2461,7 @@ uint16 Client::GetMaxSkillAfterSpecializationRules(SkillType skillid, uint16 max // This should possibly be handled by bonuses rather than here. switch(skillid) { - case TRACKING: + case SkillTracking: { Result += ((GetAA(aaAdvancedTracking) * 10) + (GetAA(aaTuneofPursuance) * 10)); break; @@ -2679,13 +2679,13 @@ bool Client::BindWound(Mob* bindmob, bool start, bool fail){ bind_out->type = 1; // Done QueuePacket(outapp); bind_out->type = 0; - CheckIncreaseSkill(BIND_WOUND, nullptr, 5); + CheckIncreaseSkill(SkillBindWound, nullptr, 5); int maxHPBonus = spellbonuses.MaxBindWound + itembonuses.MaxBindWound + aabonuses.MaxBindWound; int max_percent = 50 + 10 * maxHPBonus; - if(GetClass() == MONK && GetSkill(BIND_WOUND) > 200) { + if(GetClass() == MONK && GetSkill(SkillBindWound) > 200) { max_percent = 70 + 10 * maxHPBonus; } @@ -2699,10 +2699,10 @@ bool Client::BindWound(Mob* bindmob, bool start, bool fail){ int bindhps = 3; - if (GetSkill(BIND_WOUND) > 200) { - bindhps += GetSkill(BIND_WOUND)*4/10; - } else if (GetSkill(BIND_WOUND) >= 10) { - bindhps += GetSkill(BIND_WOUND)/4; + if (GetSkill(SkillBindWound) > 200) { + bindhps += GetSkill(SkillBindWound)*4/10; + } else if (GetSkill(SkillBindWound) >= 10) { + bindhps += GetSkill(SkillBindWound)/4; } //Implementation of aaMithanielsBinding is a guess (the multiplier) @@ -3700,7 +3700,7 @@ void Client::SendPickPocketResponse(Mob *from, uint32 amt, int type, const Item_ pick_out->coin = amt; pick_out->from = GetID(); pick_out->to = from->GetID(); - pick_out->myskill = GetSkill(PICK_POCKETS); + pick_out->myskill = GetSkill(SkillPickPockets); if((type >= PickPocketPlatinum) && (type <= PickPocketCopper) && (amt == 0)) type = PickPocketFailed; @@ -3973,11 +3973,11 @@ void Client::UpdateLFP() { uint16 Client::GetPrimarySkillValue() { - SkillType skill = HIGHEST_SKILL; //because nullptr == 0, which is 1H Slashing, & we want it to return 0 from GetSkill + SkillUseTypes skill = HIGHEST_SKILL; //because nullptr == 0, which is 1H Slashing, & we want it to return 0 from GetSkill bool equiped = m_inv.GetItem(13); if (!equiped) - skill = HAND_TO_HAND; + skill = SkillHandtoHand; else { @@ -3987,42 +3987,42 @@ uint16 Client::GetPrimarySkillValue() { case ItemType1HSlash: // 1H Slashing { - skill = _1H_SLASHING; + skill = Skill1HSlashing; break; } case ItemType2HSlash: // 2H Slashing { - skill = _2H_SLASHING; + skill = Skill2HSlashing; break; } case ItemType1HPiercing: // Piercing { - skill = PIERCING; + skill = Skill1HPiercing; break; } case ItemType1HBlunt: // 1H Blunt { - skill = _1H_BLUNT; + skill = Skill1HBlunt; break; } case ItemType2HBlunt: // 2H Blunt { - skill = _2H_BLUNT; + skill = Skill2HBlunt; break; } case ItemType2HPiercing: // 2H Piercing { - skill = PIERCING; + skill = Skill1HPiercing; // change to Skill2HPiercing once activated break; } case ItemTypeMartial: // Hand to Hand { - skill = HAND_TO_HAND; + skill = SkillHandtoHand; break; } default: // All other types default to Hand to Hand { - skill = HAND_TO_HAND; + skill = SkillHandtoHand; break; } } @@ -4037,7 +4037,7 @@ uint16 Client::GetTotalATK() uint16 WornCap = itembonuses.ATK; if(IsClient()) { - AttackRating = ((WornCap * 1.342) + (GetSkill(OFFENSE) * 1.345) + ((GetSTR() - 66) * 0.9) + (GetPrimarySkillValue() * 2.69)); + AttackRating = ((WornCap * 1.342) + (GetSkill(SkillOffense) * 1.345) + ((GetSTR() - 66) * 0.9) + (GetPrimarySkillValue() * 2.69)); AttackRating += aabonuses.ATK + GroupLeadershipAAOffenseEnhancement(); if (AttackRating < 10) @@ -4055,7 +4055,7 @@ uint16 Client::GetATKRating() { uint16 AttackRating = 0; if(IsClient()) { - AttackRating = (GetSkill(OFFENSE) * 1.345) + ((GetSTR() - 66) * 0.9) + (GetPrimarySkillValue() * 2.69); + AttackRating = (GetSkill(SkillOffense) * 1.345) + ((GetSTR() - 66) * 0.9) + (GetPrimarySkillValue() * 2.69); if (AttackRating < 10) AttackRating = 10; @@ -4406,7 +4406,7 @@ void Client::HandleLDoNOpen(NPC *target) AddEXP(target->GetLevel()*target->GetLevel()*2625/10, GetLevelCon(target->GetLevel())); } } - target->Death(this, 1, SPELL_UNKNOWN, HAND_TO_HAND); + target->Death(this, 1, SPELL_UNKNOWN, SkillHandtoHand); } } } @@ -4724,8 +4724,8 @@ void Client::ShowSkillsWindow() const char *WindowTitle = "Skills"; std::string WindowText; // using a map for easy alphabetizing of the skills list - std::map Skills; - std::map::iterator it; + std::map Skills; + std::map::iterator it; // this list of names must keep the same order as that in common/skills.h const char* SkillName[] = {"1H Blunt","1H Slashing","2H Blunt","2H Slashing","Abjuration","Alteration","Apply Poison","Archery", @@ -4737,7 +4737,7 @@ void Client::ShowSkillsWindow() "Alchemy","Baking","Tailoring","Sense Traps","Blacksmithing","Fletching","Brewing","Alcohol Tolerance","Begging","Jewelry Making", "Pottery","Percussion Instruments","Intimidation","Berserking","Taunt","Frenzy"}; for(int i = 0; i <= (int)HIGHEST_SKILL; i++) - Skills[SkillName[i]] = (SkillType)i; + Skills[SkillName[i]] = (SkillUseTypes)i; // print out all available skills for(it = Skills.begin(); it != Skills.end(); it++) { diff --git a/zone/client.h b/zone/client.h index 85cc6eecb..0209d422a 100644 --- a/zone/client.h +++ b/zone/client.h @@ -212,8 +212,8 @@ public: ~Client(); //abstract virtual function implementations requird by base abstract class - virtual bool Death(Mob* killerMob, int32 damage, uint16 spell_id, SkillType attack_skill); - virtual void Damage(Mob* from, int32 damage, uint16 spell_id, SkillType attack_skill, bool avoidable = true, int8 buffslot = -1, bool iBuffTic = false); + virtual bool Death(Mob* killerMob, int32 damage, uint16 spell_id, SkillUseTypes attack_skill); + virtual void Damage(Mob* from, int32 damage, uint16 spell_id, SkillUseTypes attack_skill, bool avoidable = true, int8 buffslot = -1, bool iBuffTic = false); virtual bool Attack(Mob* other, int Hand = 13, bool FromRiposte = false, bool IsStrikethrough = false, bool IsFromSpell = false, ExtraAttackOptions *opts = nullptr); virtual bool HasRaid() { return (GetRaid() ? true : false); } @@ -284,7 +284,7 @@ public: void VoiceMacroReceived(uint32 Type, char *Target, uint32 MacroNumber); void SendSound(); void LearnRecipe(uint32 recipeID); - bool CanIncreaseTradeskill(SkillType tradeskill); + bool CanIncreaseTradeskill(SkillUseTypes tradeskill); EQApplicationPacket* ReturnItemPacket(int16 slot_id, const ItemInst* inst, ItemPacketType packet_type); @@ -391,7 +391,7 @@ public: virtual void CalcBonuses(); //these are all precalculated now inline virtual int16 GetAC() const { return AC; } - inline virtual int16 GetATK() const { return ATK + itembonuses.ATK + spellbonuses.ATK + ((GetSTR() + GetSkill(OFFENSE)) * 9 / 10); } + inline virtual int16 GetATK() const { return ATK + itembonuses.ATK + spellbonuses.ATK + ((GetSTR() + GetSkill(SkillOffense)) * 9 / 10); } inline virtual int16 GetATKBonus() const { return itembonuses.ATK + spellbonuses.ATK; } inline virtual int GetHaste() const { return Haste; } int GetRawACNoShield(int &shield_ac) const; @@ -650,29 +650,29 @@ public: void IncreaseSkill(int skill_id, int value = 1) { if (skill_id <= HIGHEST_SKILL) { m_pp.skills[skill_id] += value; } } void IncreaseLanguageSkill(int skill_id, int value = 1); - virtual uint16 GetSkill(SkillType skill_id) const { if (skill_id <= HIGHEST_SKILL) { return((itembonuses.skillmod[skill_id] > 0)? m_pp.skills[skill_id]*(100 + itembonuses.skillmod[skill_id])/100 : m_pp.skills[skill_id]); } return 0; } - uint32 GetRawSkill(SkillType skill_id) const { if (skill_id <= HIGHEST_SKILL) { return(m_pp.skills[skill_id]); } return 0; } - bool HasSkill(SkillType skill_id) const; - bool CanHaveSkill(SkillType skill_id) const; - void SetSkill(SkillType skill_num, uint16 value); - void AddSkill(SkillType skillid, uint16 value); + virtual uint16 GetSkill(SkillUseTypes skill_id) const { if (skill_id <= HIGHEST_SKILL) { return((itembonuses.skillmod[skill_id] > 0)? m_pp.skills[skill_id]*(100 + itembonuses.skillmod[skill_id])/100 : m_pp.skills[skill_id]); } return 0; } + uint32 GetRawSkill(SkillUseTypes skill_id) const { if (skill_id <= HIGHEST_SKILL) { return(m_pp.skills[skill_id]); } return 0; } + bool HasSkill(SkillUseTypes skill_id) const; + bool CanHaveSkill(SkillUseTypes skill_id) const; + void SetSkill(SkillUseTypes skill_num, uint16 value); + void AddSkill(SkillUseTypes skillid, uint16 value); void CheckSpecializeIncrease(uint16 spell_id); void CheckSongSkillIncrease(uint16 spell_id); - bool CheckIncreaseSkill(SkillType skillid, Mob *against_who, int chancemodi = 0); + bool CheckIncreaseSkill(SkillUseTypes skillid, Mob *against_who, int chancemodi = 0); void CheckLanguageSkillIncrease(uint8 langid, uint8 TeacherSkill); void SetLanguageSkill(int langid, int value); void SetHoTT(uint32 mobid); void ShowSkillsWindow(); void SendStatsWindow(Client* client, bool use_window); - uint16 MaxSkill(SkillType skillid, uint16 class_, uint16 level) const; - inline uint16 MaxSkill(SkillType skillid) const { return MaxSkill(skillid, GetClass(), GetLevel()); } - uint8 SkillTrainLevel(SkillType skillid, uint16 class_); + uint16 MaxSkill(SkillUseTypes skillid, uint16 class_, uint16 level) const; + inline uint16 MaxSkill(SkillUseTypes skillid) const { return MaxSkill(skillid, GetClass(), GetLevel()); } + uint8 SkillTrainLevel(SkillUseTypes skillid, uint16 class_); void TradeskillSearchResults(const char *query, unsigned long qlen, unsigned long objtype, unsigned long someid); void SendTradeskillDetails(uint32 recipe_id); bool TradeskillExecute(DBTradeskillRecipe_Struct *spec); - void CheckIncreaseTradeskill(int16 bonusstat, int16 stat_modifier, float skillup_modifier, uint16 success_modifier, SkillType tradeskill); + void CheckIncreaseTradeskill(int16 bonusstat, int16 stat_modifier, float skillup_modifier, uint16 success_modifier, SkillUseTypes tradeskill); void GMKill(); inline bool IsMedding() const {return medding;} @@ -885,7 +885,7 @@ public: int GetNextAvailableSpellBookSlot(int starting_slot = 0); inline uint32 GetSpellByBookSlot(int book_slot) { return m_pp.spell_book[book_slot]; } inline bool HasSpellScribed(int spellid) { return (FindSpellBookSlotBySpellID(spellid) != -1 ? true : false); } - uint16 GetMaxSkillAfterSpecializationRules(SkillType skillid, uint16 maxSkill); + uint16 GetMaxSkillAfterSpecializationRules(SkillUseTypes skillid, uint16 maxSkill); void SendPopupToClient(const char *Title, const char *Text, uint32 PopupID = 0, uint32 Buttons = 0, uint32 Duration = 0); void SendWindow(uint32 PopupID, uint32 NegativeID, uint32 Buttons, const char *ButtonName0, const char *ButtonName1, uint32 Duration, int title_type, Client* target, const char *Title, const char *Text, ...); bool PendingTranslocate; @@ -1153,11 +1153,11 @@ public: int16 GetActCHA() { return( std::min(GetMaxCHA(), GetCHA()) ); } void LoadAccountFlags(); void SetAccountFlag(std::string flag, std::string val); - std::string GetAccountFlag(std::string flag); float GetDamageMultiplier(SkillType); + std::string GetAccountFlag(std::string flag); float GetDamageMultiplier(SkillUseTypes); void Consume(const Item_Struct *item, uint8 type, int16 slot, bool auto_consume); - int mod_client_damage(int damage, SkillType skillinuse, int hand, const ItemInst* weapon, Mob* other); + int mod_client_damage(int damage, SkillUseTypes skillinuse, int hand, const ItemInst* weapon, Mob* other); bool mod_client_message(char* message, uint8 chan_num); - bool mod_can_increase_skill(SkillType skillid, Mob* against_who); + bool mod_can_increase_skill(SkillUseTypes skillid, Mob* against_who); int16 mod_increase_skill_chance(int16 chance, Mob* against_who); int mod_bindwound_percent(int max_percent, Mob* bindmob); int mod_bindwound_hp(int bindhps, Mob* bindmob); diff --git a/zone/client_mods.cpp b/zone/client_mods.cpp index b05b30e77..33238ec0e 100644 --- a/zone/client_mods.cpp +++ b/zone/client_mods.cpp @@ -855,7 +855,7 @@ int16 Client::acmod() { int16 Client::CalcAC() { // new formula - int avoidance = (acmod() + ((GetSkill(DEFENSE) + itembonuses.HeroicAGI/10)*16)/9); + int avoidance = (acmod() + ((GetSkill(SkillDefense) + itembonuses.HeroicAGI/10)*16)/9); if (avoidance < 0) avoidance = 0; @@ -863,12 +863,12 @@ int16 Client::CalcAC() { if (m_pp.class_ == WIZARD || m_pp.class_ == MAGICIAN || m_pp.class_ == NECROMANCER || m_pp.class_ == ENCHANTER) { //something is wrong with this, naked casters have the wrong natural AC // mitigation = (spellbonuses.AC/3) + (GetSkill(DEFENSE)/2) + (itembonuses.AC+1); - mitigation = (GetSkill(DEFENSE) + itembonuses.HeroicAGI/10)/4 + (itembonuses.AC+1); + mitigation = (GetSkill(SkillDefense) + itembonuses.HeroicAGI/10)/4 + (itembonuses.AC+1); //this might be off by 4.. mitigation -= 4; } else { // mitigation = (spellbonuses.AC/4) + (GetSkill(DEFENSE)/3) + ((itembonuses.AC*4)/3); - mitigation = (GetSkill(DEFENSE) + itembonuses.HeroicAGI/10)/3 + ((itembonuses.AC*4)/3); + mitigation = (GetSkill(SkillDefense) + itembonuses.HeroicAGI/10)/3 + ((itembonuses.AC*4)/3); if(m_pp.class_ == MONK) mitigation += GetLevel() * 13/10; //the 13/10 might be wrong, but it is close... } @@ -907,11 +907,11 @@ int16 Client::GetACMit() { int mitigation = 0; if (m_pp.class_ == WIZARD || m_pp.class_ == MAGICIAN || m_pp.class_ == NECROMANCER || m_pp.class_ == ENCHANTER) { - mitigation = (GetSkill(DEFENSE) + itembonuses.HeroicAGI/10)/4 + (itembonuses.AC+1); + mitigation = (GetSkill(SkillDefense) + itembonuses.HeroicAGI/10)/4 + (itembonuses.AC+1); mitigation -= 4; } else { - mitigation = (GetSkill(DEFENSE) + itembonuses.HeroicAGI/10)/3 + ((itembonuses.AC*4)/3); + mitigation = (GetSkill(SkillDefense) + itembonuses.HeroicAGI/10)/3 + ((itembonuses.AC*4)/3); if(m_pp.class_ == MONK) mitigation += GetLevel() * 13/10; //the 13/10 might be wrong, but it is close... } @@ -931,7 +931,7 @@ int16 Client::GetACMit() { int16 Client::GetACAvoid() { - int avoidance = (acmod() + ((GetSkill(DEFENSE) + itembonuses.HeroicAGI/10)*16)/9); + int avoidance = (acmod() + ((GetSkill(SkillDefense) + itembonuses.HeroicAGI/10)*16)/9); if (avoidance < 0) avoidance = 0; @@ -1099,8 +1099,8 @@ int32 Client::CalcBaseManaRegen() int32 regen = 0; if (IsSitting() || (GetHorseId() != 0)) { - if(HasSkill(MEDITATE)) - regen = (((GetSkill(MEDITATE) / 10) + (clevel - (clevel / 4))) / 4) + 4; + if(HasSkill(SkillMeditate)) + regen = (((GetSkill(SkillMeditate) / 10) + (clevel - (clevel / 4))) / 4) + 4; else regen = 2; } @@ -1118,11 +1118,11 @@ int32 Client::CalcManaRegen() if (IsSitting() || (GetHorseId() != 0)) { BuffFadeBySitModifier(); - if(HasSkill(MEDITATE)) { + if(HasSkill(SkillMeditate)) { this->medding = true; - regen = (((GetSkill(MEDITATE) / 10) + (clevel - (clevel / 4))) / 4) + 4; + regen = (((GetSkill(SkillMeditate) / 10) + (clevel - (clevel / 4))) / 4) + 4; regen += spellbonuses.ManaRegen + itembonuses.ManaRegen; - CheckIncreaseSkill(MEDITATE, nullptr, -5); + CheckIncreaseSkill(SkillMeditate, nullptr, -5); } else regen = 2 + spellbonuses.ManaRegen + itembonuses.ManaRegen; @@ -1836,47 +1836,47 @@ uint16 Mob::GetInstrumentMod(uint16 spell_id) const { //item mods are in 10ths of percent increases switch(spells[spell_id].skill) { - case PERCUSSION_INSTRUMENTS: + case SkillPercussionInstruments: if(itembonuses.percussionMod == 0 && spellbonuses.percussionMod == 0) effectmod = 10; - else if(GetSkill(PERCUSSION_INSTRUMENTS) == 0) + else if(GetSkill(SkillPercussionInstruments) == 0) effectmod = 10; else if(itembonuses.percussionMod > spellbonuses.percussionMod) effectmod = itembonuses.percussionMod; else effectmod = spellbonuses.percussionMod; break; - case STRINGED_INSTRUMENTS: + case SkillStringedInstruments: if(itembonuses.stringedMod == 0 && spellbonuses.stringedMod == 0) effectmod = 10; - else if(GetSkill(STRINGED_INSTRUMENTS) == 0) + else if(GetSkill(SkillStringedInstruments) == 0) effectmod = 10; else if(itembonuses.stringedMod > spellbonuses.stringedMod) effectmod = itembonuses.stringedMod; else effectmod = spellbonuses.stringedMod; break; - case WIND_INSTRUMENTS: + case SkillWindInstruments: if(itembonuses.windMod == 0 && spellbonuses.windMod == 0) effectmod = 10; - else if(GetSkill(WIND_INSTRUMENTS) == 0) + else if(GetSkill(SkillWindInstruments) == 0) effectmod = 10; else if(itembonuses.windMod > spellbonuses.windMod) effectmod = itembonuses.windMod; else effectmod = spellbonuses.windMod; break; - case BRASS_INSTRUMENTS: + case SkillBrassInstruments: if(itembonuses.brassMod == 0 && spellbonuses.brassMod == 0) effectmod = 10; - else if(GetSkill(BRASS_INSTRUMENTS) == 0) + else if(GetSkill(SkillBrassInstruments) == 0) effectmod = 10; else if(itembonuses.brassMod > spellbonuses.brassMod) effectmod = itembonuses.brassMod; else effectmod = spellbonuses.brassMod; break; - case SINGING: + case SkillSinging: if(itembonuses.singingMod == 0 && spellbonuses.singingMod == 0) effectmod = 10; else if(itembonuses.singingMod > spellbonuses.singingMod) @@ -1889,7 +1889,7 @@ uint16 Mob::GetInstrumentMod(uint16 spell_id) const { break; } - if(spells[spell_id].skill == SINGING) + if(spells[spell_id].skill == SkillSinging) { effectmod += 2*GetAA(aaSingingMastery); effectmod += 2*GetAA(aaImprovedSingingMastery); diff --git a/zone/client_packet.cpp b/zone/client_packet.cpp index cdaf81ac8..df9d73849 100644 --- a/zone/client_packet.cpp +++ b/zone/client_packet.cpp @@ -1232,7 +1232,7 @@ void Client::Handle_OP_ClientUpdate(const EQApplicationPacket *app) if(IsTracking() && ((x_pos!=ppu->x_pos) || (y_pos!=ppu->y_pos))){ if(MakeRandomFloat(0, 100) < 70)//should be good - CheckIncreaseSkill(TRACKING, nullptr, -20); + CheckIncreaseSkill(SkillTracking, nullptr, -20); } // Break Hide if moving without sneaking and set rewind timer if moved @@ -1275,7 +1275,7 @@ void Client::Handle_OP_ClientUpdate(const EQApplicationPacket *app) { if(zone->watermap->InLiquid(x_pos, y_pos, z_pos)) { - CheckIncreaseSkill(SWIMMING, nullptr, -17); + CheckIncreaseSkill(SkillSwimming, nullptr, -17); } } @@ -2591,7 +2591,7 @@ void Client::Handle_OP_Begging(const EQApplicationPacket *app) return; } - if(!HasSkill(BEGGING) || !GetTarget()) + if(!HasSkill(SkillBegging) || !GetTarget()) return; if(GetTarget()->GetClass() == LDON_TREASURE) @@ -2629,7 +2629,7 @@ void Client::Handle_OP_Begging(const EQApplicationPacket *app) return; } - uint16 CurrentSkill = GetSkill(BEGGING); + uint16 CurrentSkill = GetSkill(SkillBegging); float ChanceToBeg=((float)(CurrentSkill/700.0f) + 0.15f) * 100; @@ -2651,7 +2651,7 @@ void Client::Handle_OP_Begging(const EQApplicationPacket *app) } QueuePacket(outapp); safe_delete(outapp); - CheckIncreaseSkill(BEGGING, nullptr, -10); + CheckIncreaseSkill(SkillBegging, nullptr, -10); } void Client::Handle_OP_TestBuff(const EQApplicationPacket *app) @@ -2914,7 +2914,7 @@ void Client::Handle_OP_SpawnAppearance(const EQApplicationPacket *app) if (sa->type == AT_Invis) { if(sa->parameter != 0) { - if(!HasSkill(HIDE) && GetSkill(HIDE) == 0) + if(!HasSkill(SkillHide) && GetSkill(SkillHide) == 0) { if(GetClientVersion() < EQClientSoF) { @@ -3015,7 +3015,7 @@ void Client::Handle_OP_SpawnAppearance(const EQApplicationPacket *app) else if (sa->type == AT_Sneak) { if(sa->parameter != 0) { - if(!HasSkill(SNEAK)) + if(!HasSkill(SkillSneak)) { char *hack_str = nullptr; MakeAnyLenString(&hack_str, "Player sent OP_SpawnAppearance with AT_Sneak: %i", sa->parameter); @@ -3099,7 +3099,7 @@ void Client::Handle_OP_Death(const EQApplicationPacket *app) return; Mob* killer = entity_list.GetMob(ds->killer_id); - Death(killer, ds->damage, ds->spell_id, (SkillType)ds->attack_skill); + Death(killer, ds->damage, ds->spell_id, (SkillUseTypes)ds->attack_skill); return; } @@ -3354,8 +3354,8 @@ void Client::Handle_OP_FeignDeath(const EQApplicationPacket *app) //BreakInvis(); - uint16 primfeign = GetSkill(FEIGN_DEATH); - uint16 secfeign = GetSkill(FEIGN_DEATH); + uint16 primfeign = GetSkill(SkillFeignDeath); + uint16 secfeign = GetSkill(SkillFeignDeath); if (primfeign > 100) { primfeign = 100; secfeign = secfeign - 100; @@ -3373,13 +3373,13 @@ void Client::Handle_OP_FeignDeath(const EQApplicationPacket *app) SetFeigned(true); } - CheckIncreaseSkill(FEIGN_DEATH, nullptr, 5); + CheckIncreaseSkill(SkillFeignDeath, nullptr, 5); return; } void Client::Handle_OP_Sneak(const EQApplicationPacket *app) { - if(!HasSkill(SNEAK) && GetSkill(SNEAK) == 0) { + if(!HasSkill(SkillSneak) && GetSkill(SkillSneak) == 0) { return; //You cannot sneak if you do not have sneak } @@ -3403,9 +3403,9 @@ void Client::Handle_OP_Sneak(const EQApplicationPacket *app) safe_delete(outapp); } else { - CheckIncreaseSkill(SNEAK, nullptr, 5); + CheckIncreaseSkill(SkillSneak, nullptr, 5); } - float hidechance = ((GetSkill(SNEAK)/300.0f) + .25) * 100; + float hidechance = ((GetSkill(SkillSneak)/300.0f) + .25) * 100; float random = MakeRandomFloat(0, 99); if(!was && random < hidechance) { sneaking = true; @@ -3434,7 +3434,7 @@ void Client::Handle_OP_Sneak(const EQApplicationPacket *app) void Client::Handle_OP_Hide(const EQApplicationPacket *app) { - if(!HasSkill(HIDE) && GetSkill(HIDE) == 0) + if(!HasSkill(SkillHide) && GetSkill(SkillHide) == 0) { //Can not be able to train hide but still have it from racial though return; //You cannot hide if you do not have hide @@ -3447,9 +3447,9 @@ void Client::Handle_OP_Hide(const EQApplicationPacket *app) int reuse = HideReuseTime - GetAA(209); p_timers.Start(pTimerHide, reuse-1); - float hidechance = ((GetSkill(HIDE)/250.0f) + .25) * 100; + float hidechance = ((GetSkill(SkillHide)/250.0f) + .25) * 100; float random = MakeRandomFloat(0, 100); - CheckIncreaseSkill(HIDE, nullptr, 5); + CheckIncreaseSkill(SkillHide, nullptr, 5); if (random < hidechance) { EQApplicationPacket* outapp = new EQApplicationPacket(OP_SpawnAppearance, sizeof(SpawnAppearance_Struct)); SpawnAppearance_Struct* sa_out = (SpawnAppearance_Struct*)outapp->pBuffer; @@ -3470,7 +3470,7 @@ void Client::Handle_OP_Hide(const EQApplicationPacket *app) SimpleMessage_Struct *msg=(SimpleMessage_Struct *)outapp->pBuffer; msg->color=0x010E; if (!auto_attack && entity_list.Fighting(this)) { - if (MakeRandomInt(0, 260) < (int)GetSkill(HIDE)) { + if (MakeRandomInt(0, 260) < (int)GetSkill(SkillHide)) { msg->string_id=343; entity_list.Evade(this); } else { @@ -3753,14 +3753,14 @@ void Client::Handle_OP_LDoNSenseTraps(const EQApplicationPacket *app) Mob * target = GetTarget(); if(target->IsNPC()) { - if(HasSkill(SENSE_TRAPS)) + if(HasSkill(SkillSenseTraps)) { if(DistNoRootNoZ(*target) > RuleI(Adventure, LDoNTrapDistanceUse)) { Message(13, "%s is too far away.", target->GetCleanName()); return; } - HandleLDoNSenseTraps(target->CastToNPC(), GetSkill(SENSE_TRAPS), LDoNTypeMechanical); + HandleLDoNSenseTraps(target->CastToNPC(), GetSkill(SkillSenseTraps), LDoNTypeMechanical); } else Message(13, "You do not have the sense traps skill."); @@ -3772,14 +3772,14 @@ void Client::Handle_OP_LDoNDisarmTraps(const EQApplicationPacket *app) Mob * target = GetTarget(); if(target->IsNPC()) { - if(HasSkill(DISARM_TRAPS)) + if(HasSkill(SkillDisarmTraps)) { if(DistNoRootNoZ(*target) > RuleI(Adventure, LDoNTrapDistanceUse)) { Message(13, "%s is too far away.", target->GetCleanName()); return; } - HandleLDoNDisarm(target->CastToNPC(), GetSkill(DISARM_TRAPS), LDoNTypeMechanical); + HandleLDoNDisarm(target->CastToNPC(), GetSkill(SkillDisarmTraps), LDoNTypeMechanical); } else Message(13, "You do not have the disarm trap skill."); @@ -3791,14 +3791,14 @@ void Client::Handle_OP_LDoNPickLock(const EQApplicationPacket *app) Mob * target = GetTarget(); if(target->IsNPC()) { - if(HasSkill(PICK_LOCK)) + if(HasSkill(SkillPickLock)) { if(DistNoRootNoZ(*target) > RuleI(Adventure, LDoNTrapDistanceUse)) { Message(13, "%s is too far away.", target->GetCleanName()); return; } - HandleLDoNPickLock(target->CastToNPC(), GetSkill(PICK_LOCK), LDoNTypeMechanical); + HandleLDoNPickLock(target->CastToNPC(), GetSkill(SkillPickLock), LDoNTypeMechanical); } else Message(13, "You do not have the pick locks skill."); @@ -4643,9 +4643,9 @@ void Client::Handle_OP_DeleteItem(const EQApplicationPacket *app) const ItemInst *inst = GetInv().GetItem(alc->from_slot); if (inst && inst->GetItem()->ItemType == ItemTypeAlcohol) { entity_list.MessageClose_StringID(this, true, 50, 0, DRINKING_MESSAGE, GetName(), inst->GetItem()->Name); - CheckIncreaseSkill(ALCOHOL_TOLERANCE, nullptr, 25); + CheckIncreaseSkill(SkillAlcoholTolerance, nullptr, 25); - int16 AlcoholTolerance = GetSkill(ALCOHOL_TOLERANCE); + int16 AlcoholTolerance = GetSkill(SkillAlcoholTolerance); int16 IntoxicationIncrease; if(GetClientVersion() < EQClientSoD) @@ -7574,7 +7574,7 @@ void Client::Handle_OP_Forage(const EQApplicationPacket *app) void Client::Handle_OP_Mend(const EQApplicationPacket *app) { - if(!HasSkill(MEND)) + if(!HasSkill(SkillMend)) return; if(!p_timers.Expired(&database, pTimerMend, false)) { @@ -7585,7 +7585,7 @@ void Client::Handle_OP_Mend(const EQApplicationPacket *app) int mendhp = GetMaxHP() / 4; int currenthp = GetHP(); - if (MakeRandomInt(0, 199) < (int)GetSkill(MEND)) { + if (MakeRandomInt(0, 199) < (int)GetSkill(SkillMend)) { int criticalchance = 0; switch(GetAA(aaCriticalMend)){ case 1: @@ -7614,7 +7614,7 @@ void Client::Handle_OP_Mend(const EQApplicationPacket *app) 0 skill - 25% chance to worsen 20 skill - 23% chance to worsen 50 skill - 16% chance to worsen */ - if ((GetSkill(MEND) <= 75) && (MakeRandomInt(GetSkill(MEND),100) < 75) && (MakeRandomInt(1, 3) == 1)) + if ((GetSkill(SkillMend) <= 75) && (MakeRandomInt(GetSkill(SkillMend),100) < 75) && (MakeRandomInt(1, 3) == 1)) { SetHP(currenthp > mendhp ? (GetHP() - mendhp) : 1); SendHPUpdate(); @@ -7624,7 +7624,7 @@ void Client::Handle_OP_Mend(const EQApplicationPacket *app) Message_StringID(4,MEND_FAIL); } - CheckIncreaseSkill(MEND, nullptr, 10); + CheckIncreaseSkill(SkillMend, nullptr, 10); return; } @@ -7682,7 +7682,7 @@ void Client::Handle_OP_EnvDamage(const EQApplicationPacket *app) { mod_client_death_env(); - Death(0, 32000, SPELL_UNKNOWN, HAND_TO_HAND); + Death(0, 32000, SPELL_UNKNOWN, SkillHandtoHand); } SendHPUpdate(); return; @@ -7700,7 +7700,7 @@ void Client::Handle_OP_Damage(const EQApplicationPacket *app) // Broadcast to other clients CombatDamage_Struct* damage = (CombatDamage_Struct*)app->pBuffer; //dont send to originator of falling damage packets - entity_list.QueueClients(this, app, (damage->type==FallingDamageType)); + entity_list.QueueClients(this, app, (damage->type==DamageTypeFalling)); return; } @@ -7958,7 +7958,7 @@ void Client::Handle_OP_PickPocket(const EQApplicationPacket *app) DumpPacket(app); } - if(!HasSkill(PICK_POCKETS)) + if(!HasSkill(SkillPickPockets)) { return; } @@ -7983,7 +7983,7 @@ void Client::Handle_OP_PickPocket(const EQApplicationPacket *app) pick_out->coin = 0; pick_out->from = victim->GetID(); pick_out->to = GetID(); - pick_out->myskill = GetSkill(PICK_POCKETS); + pick_out->myskill = GetSkill(SkillPickPockets); pick_out->type = 0; //if we do not send this packet the client will lock up and require the player to relog. QueuePacket(outapp); @@ -7996,7 +7996,7 @@ void Client::Handle_OP_PickPocket(const EQApplicationPacket *app) pick_out->coin = 0; pick_out->from = victim->GetID(); pick_out->to = GetID(); - pick_out->myskill = GetSkill(PICK_POCKETS); + pick_out->myskill = GetSkill(SkillPickPockets); pick_out->type = 0; //if we do not send this packet the client will lock up and require the player to relog. QueuePacket(outapp); @@ -8012,7 +8012,7 @@ void Client::Handle_OP_PickPocket(const EQApplicationPacket *app) pick_out->coin = 0; pick_out->from = victim->GetID(); pick_out->to = GetID(); - pick_out->myskill = GetSkill(PICK_POCKETS); + pick_out->myskill = GetSkill(SkillPickPockets); pick_out->type = 0; //if we do not send this packet the client will lock up and require the player to relog. QueuePacket(outapp); @@ -8062,10 +8062,10 @@ void Client::Handle_OP_Track(const EQApplicationPacket *app) if(GetClass() != RANGER && GetClass() != DRUID && GetClass() != BARD) return; - if( GetSkill(TRACKING)==0 ) - SetSkill(TRACKING,1); + if( GetSkill(SkillTracking)==0 ) + SetSkill(SkillTracking,1); else - CheckIncreaseSkill(TRACKING, nullptr, 15); + CheckIncreaseSkill(SkillTracking, nullptr, 15); if(!entity_list.MakeTrackPacket(this)) LogFile->write(EQEMuLog::Error, "Unable to generate OP_Track packet requested by client."); @@ -8145,7 +8145,7 @@ void Client::Handle_OP_Split(const EQApplicationPacket *app) void Client::Handle_OP_SenseTraps(const EQApplicationPacket *app) { - if (!HasSkill(SENSE_TRAPS)) + if (!HasSkill(SkillSenseTraps)) return; if(!p_timers.Expired(&database, pTimerSenseTraps, false)) { @@ -8168,10 +8168,10 @@ void Client::Handle_OP_SenseTraps(const EQApplicationPacket *app) Trap* trap = entity_list.FindNearbyTrap(this,800); - CheckIncreaseSkill(SENSE_TRAPS, nullptr); + CheckIncreaseSkill(SkillSenseTraps, nullptr); if (trap && trap->skill > 0) { - int uskill = GetSkill(SENSE_TRAPS); + int uskill = GetSkill(SkillSenseTraps); if ((MakeRandomInt(0,99) + uskill) >= (MakeRandomInt(0,99) + trap->skill*0.75)) { float xdif = trap->x - GetX(); @@ -8212,7 +8212,7 @@ void Client::Handle_OP_SenseTraps(const EQApplicationPacket *app) void Client::Handle_OP_DisarmTraps(const EQApplicationPacket *app) { - if (!HasSkill(DISARM_TRAPS)) + if (!HasSkill(SkillDisarmTraps)) return; if(!p_timers.Expired(&database, pTimerDisarmTraps, false)) { @@ -8236,7 +8236,7 @@ void Client::Handle_OP_DisarmTraps(const EQApplicationPacket *app) Trap* trap = entity_list.FindNearbyTrap(this,60); if (trap && trap->detected) { - int uskill = GetSkill(DISARM_TRAPS); + int uskill = GetSkill(SkillDisarmTraps); if ((MakeRandomInt(0, 49) + uskill) >= (MakeRandomInt(0, 49) + trap->skill)) { Message(MT_Skills,"You disarm a trap."); @@ -8254,7 +8254,7 @@ void Client::Handle_OP_DisarmTraps(const EQApplicationPacket *app) Message(MT_Skills,"You failed to disarm a trap."); } } - CheckIncreaseSkill(DISARM_TRAPS, nullptr); + CheckIncreaseSkill(SkillDisarmTraps, nullptr); return; } Message(MT_Skills,"You did not find any traps close enough to disarm."); @@ -8476,8 +8476,8 @@ void Client::Handle_OP_SetRunMode(const EQApplicationPacket *app) void Client::Handle_OP_SafeFallSuccess(const EQApplicationPacket *app) // bit of a misnomer, sent whenever safe fall is used (success of fail) { - if(HasSkill(SAFE_FALL)) //this should only get called if the client has safe fall, but just in case... - CheckIncreaseSkill(SAFE_FALL, nullptr); //check for skill up + if(HasSkill(SkillSafeFall)) //this should only get called if the client has safe fall, but just in case... + CheckIncreaseSkill(SkillSafeFall, nullptr); //check for skill up } void Client::Handle_OP_Heartbeat(const EQApplicationPacket *app) @@ -8910,8 +8910,8 @@ bool Client::FinishConnState2(DBAsyncWork* dbaw) { if(m_pp.ldon_points_available > 0x77359400) m_pp.ldon_points_available = 0x77359400; - if(GetSkill(SWIMMING) < 100) - SetSkill(SWIMMING,100); + if(GetSkill(SkillSwimming) < 100) + SetSkill(SkillSwimming,100); //pull AAs from the PP for(uint32 a=0; a < MAX_PP_AA_ARRAY; a++){ @@ -11031,10 +11031,10 @@ void Client::Handle_OP_ApplyPoison(const EQApplicationPacket *app) { { if ((PrimaryWeapon && PrimaryWeapon->GetItem()->ItemType == ItemType1HPiercing) || (SecondaryWeapon && SecondaryWeapon->GetItem()->ItemType == ItemType1HPiercing)) { - float SuccessChance = (GetSkill(APPLY_POISON) + GetLevel()) / 400.0f; + float SuccessChance = (GetSkill(SkillApplyPoison) + GetLevel()) / 400.0f; double ChanceRoll = MakeRandomFloat(0, 1); - CheckIncreaseSkill(APPLY_POISON, nullptr, 10); + CheckIncreaseSkill(SkillApplyPoison, nullptr, 10); if(ChanceRoll < SuccessChance) { ApplyPoisonSuccessResult = 1; diff --git a/zone/client_process.cpp b/zone/client_process.cpp index 97dd242ac..8bb3fd67c 100644 --- a/zone/client_process.cpp +++ b/zone/client_process.cpp @@ -405,7 +405,7 @@ bool Client::Process() { bool tripleAttackSuccess = false; if( auto_attack_target && CanThisClassDoubleAttack() ) { - CheckIncreaseSkill(DOUBLE_ATTACK, auto_attack_target, -10); + CheckIncreaseSkill(SkillDoubleAttack, auto_attack_target, -10); if(CheckDoubleAttack()) { //should we allow rampage on double attack? if(CheckAAEffect(aaEffectRampage)) { @@ -494,12 +494,12 @@ bool Client::Process() { float DualWieldProbability = 0.0f; int16 Ambidexterity = aabonuses.Ambidexterity + spellbonuses.Ambidexterity + itembonuses.Ambidexterity; - DualWieldProbability = (GetSkill(DUAL_WIELD) + GetLevel() + Ambidexterity) / 400.0f; // 78.0 max + DualWieldProbability = (GetSkill(SkillDualWield) + GetLevel() + Ambidexterity) / 400.0f; // 78.0 max int16 DWBonus = spellbonuses.DualWieldChance + itembonuses.DualWieldChance; DualWieldProbability += DualWieldProbability*float(DWBonus)/ 100.0f; float random = MakeRandomFloat(0, 1); - CheckIncreaseSkill(DUAL_WIELD, auto_attack_target, -10); + CheckIncreaseSkill(SkillDualWield, auto_attack_target, -10); if (random < DualWieldProbability){ // Max 78% of DW if(CheckAAEffect(aaEffectRampage)) { entity_list.AEAttack(this, 30, 14); @@ -1589,9 +1589,9 @@ void Client::OPGMTraining(const EQApplicationPacket *app) if(DistNoRoot(*pTrainer) > USE_NPC_RANGE2) return; - SkillType sk; - for (sk = _1H_BLUNT; sk <= HIGHEST_SKILL; sk = (SkillType)(sk+1)) { - if(sk == TINKERING && GetRace() != GNOME) { + SkillUseTypes sk; + for (sk = Skill1HBlunt; sk <= HIGHEST_SKILL; sk = (SkillUseTypes)(sk+1)) { + if(sk == SkillTinkering && GetRace() != GNOME) { gmtrain->skills[sk] = 0; //Non gnomes can't tinker! } else { gmtrain->skills[sk] = GetMaxSkillAfterSpecializationRules(sk, MaxSkill(sk, GetClass(), RuleI(Character, MaxLevel))); @@ -1688,7 +1688,7 @@ void Client::OPGMTrainSkill(const EQApplicationPacket *app) return; } - SkillType skill = (SkillType) gmskill->skill_id; + SkillUseTypes skill = (SkillUseTypes) gmskill->skill_id; if(!CanHaveSkill(skill)) { mlog(CLIENT__ERROR, "Tried to train skill %d, which is not allowed.", skill); @@ -1712,27 +1712,27 @@ void Client::OPGMTrainSkill(const EQApplicationPacket *app) SetSkill(skill, t_level); } else { switch(skill) { - case BREWING: - case MAKE_POISON: - case TINKERING: - case RESEARCH: - case ALCHEMY: - case BAKING: - case TAILORING: - case BLACKSMITHING: - case FLETCHING: - case JEWELRY_MAKING: - case POTTERY: + case SkillBrewing: + case SkillMakePoison: + case SkillTinkering: + case SkillResearch: + case SkillAlchemy: + case SkillBaking: + case SkillTailoring: + case SkillBlacksmithing: + case SkillFletching: + case SkillJewelryMaking: + case SkillPottery: if(skilllevel >= RuleI(Skills, MaxTrainTradeskills)) { Message_StringID(13, MORE_SKILLED_THAN_I, pTrainer->GetCleanName()); return; } break; - case SPECIALIZE_ABJURE: - case SPECIALIZE_ALTERATION: - case SPECIALIZE_CONJURATION: - case SPECIALIZE_DIVINATION: - case SPECIALIZE_EVOCATION: + case SkillSpecializeAbjure: + case SkillSpecializeAlteration: + case SkillSpecializeConjuration: + case SkillSpecializeDivination: + case SkillSpecializeEvocation: if(skilllevel >= RuleI(Skills, MaxTrainSpecializations)) { Message_StringID(13, MORE_SKILLED_THAN_I, pTrainer->GetCleanName()); return; @@ -1749,7 +1749,7 @@ void Client::OPGMTrainSkill(const EQApplicationPacket *app) return; } - if(gmskill->skill_id >= SPECIALIZE_ABJURE && gmskill->skill_id <= SPECIALIZE_EVOCATION) + if(gmskill->skill_id >= SkillSpecializeAbjure && gmskill->skill_id <= SkillSpecializeEvocation) { int MaxSpecSkill = GetMaxSkillAfterSpecializationRules(skill, MaxSkillValue); if (skilllevel >= MaxSpecSkill) @@ -1787,7 +1787,7 @@ void Client::OPGMTrainSkill(const EQApplicationPacket *app) gmtsc->SkillID += 100; } else - gmtsc->NewSkill = (GetRawSkill((SkillType)gmtsc->SkillID) == 1); + gmtsc->NewSkill = (GetRawSkill((SkillUseTypes)gmtsc->SkillID) == 1); gmtsc->Cost = Cost; diff --git a/zone/command.cpp b/zone/command.cpp index 7080b4f3c..0c6793b51 100644 --- a/zone/command.cpp +++ b/zone/command.cpp @@ -2462,7 +2462,7 @@ void command_showskills(Client *c, const Seperator *sep) t=c->GetTarget()->CastToClient(); c->Message(0, "Skills for %s", t->GetName()); - for (SkillType i=_1H_BLUNT; i <= HIGHEST_SKILL; i=(SkillType)(i+1)) + for (SkillUseTypes i=Skill1HBlunt; i <= HIGHEST_SKILL; i=(SkillUseTypes)(i+1)) c->Message(0, "Skill [%d] is at [%d]", i, t->GetSkill(i)); } @@ -2623,7 +2623,7 @@ void command_setskill(Client *c, const Seperator *sep) int skill_num = atoi(sep->arg[1]); uint16 skill_value = atoi(sep->arg[2]); if(skill_num < HIGHEST_SKILL) - c->GetTarget()->CastToClient()->SetSkill((SkillType)skill_num, skill_value); + c->GetTarget()->CastToClient()->SetSkill((SkillUseTypes)skill_num, skill_value); } } @@ -2641,7 +2641,7 @@ void command_setskillall(Client *c, const Seperator *sep) if (c->Admin() >= commandSetSkillsOther || c->GetTarget()==c || c->GetTarget()==0) { LogFile->write(EQEMuLog::Normal,"Set ALL skill request from %s, target:%s", c->GetName(), c->GetTarget()->GetName()); uint16 level = atoi(sep->arg[1]); - for(SkillType skill_num=_1H_BLUNT;skill_num <= HIGHEST_SKILL;skill_num=(SkillType)(skill_num+1)) { + for(SkillUseTypes skill_num=Skill1HBlunt;skill_num <= HIGHEST_SKILL;skill_num=(SkillUseTypes)(skill_num+1)) { c->GetTarget()->CastToClient()->SetSkill(skill_num, level); } } @@ -4586,7 +4586,7 @@ void command_damage(Client *c, const Seperator *sep) if (nkdmg > 2100000000) c->Message(0, "Enter a value less then 2,100,000,000."); else - c->GetTarget()->Damage(c, nkdmg, SPELL_UNKNOWN, HAND_TO_HAND, false); + c->GetTarget()->Damage(c, nkdmg, SPELL_UNKNOWN, SkillHandtoHand, false); } } @@ -5302,7 +5302,7 @@ void command_manaburn(Client *c, const Seperator *sep) int nukedmg=(c->GetMana())*2; if (nukedmg>0) { - target->Damage(c, nukedmg, 2751, ABJURE/*hackish*/); + target->Damage(c, nukedmg, 2751, SkillAbjuration/*hackish*/); c->Message(4,"You unleash an enormous blast of magical energies."); } LogFile->write(EQEMuLog::Normal,"Manaburn request from %s, damage: %d", c->GetName(), nukedmg); @@ -11042,14 +11042,14 @@ void command_max_all_skills(Client *c, const Seperator *sep) { for(int i = 0; i <= HIGHEST_SKILL; ++i) { - if(i >= SPECIALIZE_ABJURE && i <= SPECIALIZE_EVOCATION) + if(i >= SkillSpecializeAbjure && i <= SkillSpecializeEvocation) { - c->SetSkill((SkillType)i, 50); + c->SetSkill((SkillUseTypes)i, 50); } else { - int max_skill_level = database.GetSkillCap(c->GetClass(), (SkillType)i, c->GetLevel()); - c->SetSkill((SkillType)i, max_skill_level); + int max_skill_level = database.GetSkillCap(c->GetClass(), (SkillUseTypes)i, c->GetLevel()); + c->SetSkill((SkillUseTypes)i, max_skill_level); } } } @@ -11139,14 +11139,14 @@ void command_disarmtrap(Client *c, const Seperator *sep) if(target->IsNPC()) { - if(c->HasSkill(DISARM_TRAPS)) + if(c->HasSkill(SkillDisarmTraps)) { if(c->DistNoRootNoZ(*target) > RuleI(Adventure, LDoNTrapDistanceUse)) { c->Message(13, "%s is too far away.", target->GetCleanName()); return; } - c->HandleLDoNDisarm(target->CastToNPC(), c->GetSkill(DISARM_TRAPS), LDoNTypeMechanical); + c->HandleLDoNDisarm(target->CastToNPC(), c->GetSkill(SkillDisarmTraps), LDoNTypeMechanical); } else c->Message(13, "You do not have the disarm trap skill."); @@ -11164,14 +11164,14 @@ void command_sensetrap(Client *c, const Seperator *sep) if(target->IsNPC()) { - if(c->HasSkill(SENSE_TRAPS)) + if(c->HasSkill(SkillSenseTraps)) { if(c->DistNoRootNoZ(*target) > RuleI(Adventure, LDoNTrapDistanceUse)) { c->Message(13, "%s is too far away.", target->GetCleanName()); return; } - c->HandleLDoNSenseTraps(target->CastToNPC(), c->GetSkill(SENSE_TRAPS), LDoNTypeMechanical); + c->HandleLDoNSenseTraps(target->CastToNPC(), c->GetSkill(SkillSenseTraps), LDoNTypeMechanical); } else c->Message(13, "You do not have the sense traps skill."); @@ -11189,14 +11189,14 @@ void command_picklock(Client *c, const Seperator *sep) if(target->IsNPC()) { - if(c->HasSkill(PICK_LOCK)) + if(c->HasSkill(SkillPickLock)) { if(c->DistNoRootNoZ(*target) > RuleI(Adventure, LDoNTrapDistanceUse)) { c->Message(13, "%s is too far away.", target->GetCleanName()); return; } - c->HandleLDoNPickLock(target->CastToNPC(), c->GetSkill(PICK_LOCK), LDoNTypeMechanical); + c->HandleLDoNPickLock(target->CastToNPC(), c->GetSkill(SkillPickLock), LDoNTypeMechanical); } else c->Message(13, "You do not have the pick locks skill."); diff --git a/zone/corpse.h b/zone/corpse.h index 79580f71b..b9999e79b 100644 --- a/zone/corpse.h +++ b/zone/corpse.h @@ -39,8 +39,8 @@ public: ~Corpse(); //abstract virtual function implementations requird by base abstract class - virtual bool Death(Mob* killerMob, int32 damage, uint16 spell_id, SkillType attack_skill) { return true; } - virtual void Damage(Mob* from, int32 damage, uint16 spell_id, SkillType attack_skill, bool avoidable = true, int8 buffslot = -1, bool iBuffTic = false) { return; } + virtual bool Death(Mob* killerMob, int32 damage, uint16 spell_id, SkillUseTypes attack_skill) { return true; } + virtual void Damage(Mob* from, int32 damage, uint16 spell_id, SkillUseTypes attack_skill, bool avoidable = true, int8 buffslot = -1, bool iBuffTic = false) { return; } virtual bool Attack(Mob* other, int Hand = 13, bool FromRiposte = false, bool IsStrikethrough = true, bool IsFromSpell = false, ExtraAttackOptions *opts = nullptr) { return false; } virtual bool HasRaid() { return false; } diff --git a/zone/doors.cpp b/zone/doors.cpp index e6c3c9c65..0d11206a2 100644 --- a/zone/doors.cpp +++ b/zone/doors.cpp @@ -292,12 +292,12 @@ void Doors::HandleClick(Client* sender, uint8 trigger) } else if(lockpicks != nullptr) { - if(sender->GetSkill(PICK_LOCK)) + if(sender->GetSkill(SkillPickLock)) { if(lockpicks->GetItem()->ItemType == ItemTypeLockPick) { - float modskill=sender->GetSkill(PICK_LOCK); - sender->CheckIncreaseSkill(PICK_LOCK, nullptr, 1); + float modskill=sender->GetSkill(SkillPickLock); + sender->CheckIncreaseSkill(SkillPickLock, nullptr, 1); #if EQDEBUG>=5 LogFile->write(EQEMuLog::Debug, "Client has lockpicks: skill=%f", modskill); diff --git a/zone/entity.cpp b/zone/entity.cpp index aae28b9fc..29b417559 100644 --- a/zone/entity.cpp +++ b/zone/entity.cpp @@ -3234,11 +3234,11 @@ bool EntityList::MakeTrackPacket(Client* client) float MobDistance; if(client->GetClass() == DRUID) - distance = (client->GetSkill(TRACKING)*10); + distance = (client->GetSkill(SkillTracking)*10); else if(client->GetClass() == RANGER) - distance = (client->GetSkill(TRACKING)*12); + distance = (client->GetSkill(SkillTracking)*12); else if(client->GetClass() == BARD) - distance = (client->GetSkill(TRACKING)*7); + distance = (client->GetSkill(SkillTracking)*7); if(distance <= 0) return false; if(distance<300) diff --git a/zone/forage.cpp b/zone/forage.cpp index 3bc553a92..7f9e145fb 100644 --- a/zone/forage.cpp +++ b/zone/forage.cpp @@ -294,7 +294,7 @@ void Client::GoFish() //success formula is not researched at all - int fishing_skill = GetSkill(FISHING); //will take into account skill bonuses on pole & bait + int fishing_skill = GetSkill(SkillFishing); //will take into account skill bonuses on pole & bait //make sure we still have a fishing pole on: int32 bslot = m_inv.HasItemByUse(ItemTypeFishingBait, 1, invWhereWorn|invWherePersonal); @@ -303,7 +303,7 @@ void Client::GoFish() Bait = m_inv.GetItem(bslot); //if the bait isnt equipped, need to add its skill bonus - if(bslot >= IDX_INV && Bait->GetItem()->SkillModType == FISHING) { + if(bslot >= IDX_INV && Bait->GetItem()->SkillModType == SkillFishing) { fishing_skill += Bait->GetItem()->SkillModValue; } @@ -398,16 +398,16 @@ void Client::GoFish() DeleteItemInInventory(13,0,true); } - if(CheckIncreaseSkill(FISHING, nullptr, 5)) + if(CheckIncreaseSkill(SkillFishing, nullptr, 5)) { - if(title_manager.IsNewTradeSkillTitleAvailable(FISHING, GetRawSkill(FISHING))) + if(title_manager.IsNewTradeSkillTitleAvailable(SkillFishing, GetRawSkill(SkillFishing))) NotifyNewTitlesAvailable(); } } void Client::ForageItem(bool guarantee) { - int skill_level = GetSkill(FORAGE); + int skill_level = GetSkill(SkillForage); //be wary of the string ids in switch below when changing this. uint32 common_food_ids[MAX_COMMON_FOOD_IDS] = { @@ -498,7 +498,7 @@ void Client::ForageItem(bool guarantee) { parse->EventPlayer(EVENT_FORAGE_FAILURE, this, "", 0); } - CheckIncreaseSkill(FORAGE, nullptr, 5); + CheckIncreaseSkill(SkillForage, nullptr, 5); } diff --git a/zone/lua_client.cpp b/zone/lua_client.cpp index dd48b88d2..86ad83c57 100644 --- a/zone/lua_client.cpp +++ b/zone/lua_client.cpp @@ -422,27 +422,27 @@ void Lua_Client::IncreaseLanguageSkill(int skill_id, int value) { int Lua_Client::GetRawSkill(int skill_id) { Lua_Safe_Call_Int(); - return self->GetRawSkill(static_cast(skill_id)); + return self->GetRawSkill(static_cast(skill_id)); } bool Lua_Client::HasSkill(int skill_id) { Lua_Safe_Call_Bool(); - return self->HasSkill(static_cast(skill_id)); + return self->HasSkill(static_cast(skill_id)); } bool Lua_Client::CanHaveSkill(int skill_id) { Lua_Safe_Call_Bool(); - return self->CanHaveSkill(static_cast(skill_id)); + return self->CanHaveSkill(static_cast(skill_id)); } void Lua_Client::SetSkill(int skill_id, int value) { Lua_Safe_Call_Void(); - self->SetSkill(static_cast(skill_id), value); + self->SetSkill(static_cast(skill_id), value); } void Lua_Client::AddSkill(int skill_id, int value) { Lua_Safe_Call_Void(); - self->AddSkill(static_cast(skill_id), value); + self->AddSkill(static_cast(skill_id), value); } void Lua_Client::CheckSpecializeIncrease(int spell_id) { @@ -452,12 +452,12 @@ void Lua_Client::CheckSpecializeIncrease(int spell_id) { void Lua_Client::CheckIncreaseSkill(int skill_id, Lua_Mob target) { Lua_Safe_Call_Void(); - self->CheckIncreaseSkill(static_cast(skill_id), target); + self->CheckIncreaseSkill(static_cast(skill_id), target); } void Lua_Client::CheckIncreaseSkill(int skill_id, Lua_Mob target, int chance_mod) { Lua_Safe_Call_Void(); - self->CheckIncreaseSkill(static_cast(skill_id), target, chance_mod); + self->CheckIncreaseSkill(static_cast(skill_id), target, chance_mod); } void Lua_Client::SetLanguageSkill(int language, int value) { @@ -467,7 +467,7 @@ void Lua_Client::SetLanguageSkill(int language, int value) { int Lua_Client::MaxSkill(int skill_id) { Lua_Safe_Call_Int(); - return self->MaxSkill(static_cast(skill_id)); + return self->MaxSkill(static_cast(skill_id)); } bool Lua_Client::IsMedding() { diff --git a/zone/lua_mob.cpp b/zone/lua_mob.cpp index f3e5d6cbc..851c1293a 100644 --- a/zone/lua_mob.cpp +++ b/zone/lua_mob.cpp @@ -178,22 +178,22 @@ bool Lua_Mob::Attack(Lua_Mob other, int hand, bool from_riposte, bool is_striket void Lua_Mob::Damage(Lua_Mob from, int damage, int spell_id, int attack_skill) { Lua_Safe_Call_Void(); - return self->Damage(from, damage, spell_id, static_cast(attack_skill)); + return self->Damage(from, damage, spell_id, static_cast(attack_skill)); } void Lua_Mob::Damage(Lua_Mob from, int damage, int spell_id, int attack_skill, bool avoidable) { Lua_Safe_Call_Void(); - return self->Damage(from, damage, spell_id, static_cast(attack_skill), avoidable); + return self->Damage(from, damage, spell_id, static_cast(attack_skill), avoidable); } void Lua_Mob::Damage(Lua_Mob from, int damage, int spell_id, int attack_skill, bool avoidable, int buffslot) { Lua_Safe_Call_Void(); - return self->Damage(from, damage, spell_id, static_cast(attack_skill), avoidable, buffslot); + return self->Damage(from, damage, spell_id, static_cast(attack_skill), avoidable, buffslot); } void Lua_Mob::Damage(Lua_Mob from, int damage, int spell_id, int attack_skill, bool avoidable, int buffslot, bool buff_tic) { Lua_Safe_Call_Void(); - return self->Damage(from, damage, spell_id, static_cast(attack_skill), avoidable, buffslot, buff_tic); + return self->Damage(from, damage, spell_id, static_cast(attack_skill), avoidable, buffslot, buff_tic); } void Lua_Mob::RangedAttack(Lua_Mob other) { @@ -1222,28 +1222,28 @@ bool Lua_Mob::CombatRange(Lua_Mob other) { void Lua_Mob::DoSpecialAttackDamage(Lua_Mob other, int skill, int max_damage) { Lua_Safe_Call_Void(); - self->DoSpecialAttackDamage(other, static_cast(skill), max_damage); + self->DoSpecialAttackDamage(other, static_cast(skill), max_damage); } void Lua_Mob::DoSpecialAttackDamage(Lua_Mob other, int skill, int max_damage, int min_damage) { Lua_Safe_Call_Void(); - self->DoSpecialAttackDamage(other, static_cast(skill), max_damage, min_damage); + self->DoSpecialAttackDamage(other, static_cast(skill), max_damage, min_damage); } void Lua_Mob::DoSpecialAttackDamage(Lua_Mob other, int skill, int max_damage, int min_damage, int hate_override) { Lua_Safe_Call_Void(); - self->DoSpecialAttackDamage(other, static_cast(skill), max_damage, min_damage, hate_override); + self->DoSpecialAttackDamage(other, static_cast(skill), max_damage, min_damage, hate_override); } void Lua_Mob::DoSpecialAttackDamage(Lua_Mob other, int skill, int max_damage, int min_damage, int hate_override, int reuse_time) { Lua_Safe_Call_Void(); - self->DoSpecialAttackDamage(other, static_cast(skill), max_damage, min_damage, hate_override, reuse_time); + self->DoSpecialAttackDamage(other, static_cast(skill), max_damage, min_damage, hate_override, reuse_time); } void Lua_Mob::DoSpecialAttackDamage(Lua_Mob other, int skill, int max_damage, int min_damage, int hate_override, int reuse_time, bool hit_chance) { Lua_Safe_Call_Void(); - self->DoSpecialAttackDamage(other, static_cast(skill), max_damage, min_damage, hate_override, reuse_time, hit_chance); + self->DoSpecialAttackDamage(other, static_cast(skill), max_damage, min_damage, hate_override, reuse_time, hit_chance); } void Lua_Mob::DoThrowingAttackDmg(Lua_Mob other) { @@ -1279,22 +1279,22 @@ void Lua_Mob::DoThrowingAttackDmg(Lua_Mob other, Lua_ItemInst range_weapon, Lua_ void Lua_Mob::DoMeleeSkillAttackDmg(Lua_Mob other, int weapon_damage, int skill) { Lua_Safe_Call_Void(); - self->DoMeleeSkillAttackDmg(other, weapon_damage, static_cast(skill)); + self->DoMeleeSkillAttackDmg(other, weapon_damage, static_cast(skill)); } void Lua_Mob::DoMeleeSkillAttackDmg(Lua_Mob other, int weapon_damage, int skill, int chance_mod) { Lua_Safe_Call_Void(); - self->DoMeleeSkillAttackDmg(other, weapon_damage, static_cast(skill), chance_mod); + self->DoMeleeSkillAttackDmg(other, weapon_damage, static_cast(skill), chance_mod); } void Lua_Mob::DoMeleeSkillAttackDmg(Lua_Mob other, int weapon_damage, int skill, int chance_mod, int focus) { Lua_Safe_Call_Void(); - self->DoMeleeSkillAttackDmg(other, weapon_damage, static_cast(skill), chance_mod, focus); + self->DoMeleeSkillAttackDmg(other, weapon_damage, static_cast(skill), chance_mod, focus); } void Lua_Mob::DoMeleeSkillAttackDmg(Lua_Mob other, int weapon_damage, int skill, int chance_mod, int focus, bool can_riposte) { Lua_Safe_Call_Void(); - self->DoMeleeSkillAttackDmg(other, weapon_damage, static_cast(skill), chance_mod, focus, can_riposte); + self->DoMeleeSkillAttackDmg(other, weapon_damage, static_cast(skill), chance_mod, focus, can_riposte); } void Lua_Mob::DoArcheryAttackDmg(Lua_Mob other) { @@ -1698,17 +1698,17 @@ void Lua_Mob::SetTargetable(bool on) { void Lua_Mob::ModSkillDmgTaken(int skill, int value) { Lua_Safe_Call_Void(); - self->ModSkillDmgTaken(static_cast(skill), value); + self->ModSkillDmgTaken(static_cast(skill), value); } int Lua_Mob::GetModSkillDmgTaken(int skill) { Lua_Safe_Call_Int(); - return self->GetModSkillDmgTaken(static_cast(skill)); + return self->GetModSkillDmgTaken(static_cast(skill)); } int Lua_Mob::GetSkillDmgTaken(int skill) { Lua_Safe_Call_Int(); - return self->GetSkillDmgTaken(static_cast(skill)); + return self->GetSkillDmgTaken(static_cast(skill)); } void Lua_Mob::SetAllowBeneficial(bool value) { @@ -1758,7 +1758,7 @@ int Lua_Mob::GetFlurryChance() { int Lua_Mob::GetSkill(int skill) { Lua_Safe_Call_Int(); - return self->GetSkill(static_cast(skill)); + return self->GetSkill(static_cast(skill)); } int Lua_Mob::GetSpecialAbility(int ability) { diff --git a/zone/merc.cpp b/zone/merc.cpp index 8d1e110a0..7930e2604 100644 --- a/zone/merc.cpp +++ b/zone/merc.cpp @@ -59,7 +59,7 @@ Merc::Merc(const NPCType* d, float x, float y, float z, float heading) int r; for(r = 0; r <= HIGHEST_SKILL; r++) { - skills[r] = database.GetSkillCap(GetClass(),(SkillType)r,GetLevel()); + skills[r] = database.GetSkillCap(GetClass(),(SkillUseTypes)r,GetLevel()); } GetMercSize(); @@ -983,8 +983,8 @@ int32 Merc::CalcBaseManaRegen() int32 regen = 0; if (IsSitting()) { - if(HasSkill(MEDITATE)) - regen = (((GetSkill(MEDITATE) / 10) + (clevel - (clevel / 4))) / 4) + 4; + if(HasSkill(SkillMeditate)) + regen = (((GetSkill(SkillMeditate) / 10) + (clevel - (clevel / 4))) / 4) + 4; else regen = 2; } @@ -1000,9 +1000,9 @@ int32 Merc::CalcManaRegen() if (IsSitting()) { BuffFadeBySitModifier(); - if(HasSkill(MEDITATE)) { + if(HasSkill(SkillMeditate)) { this->_medding = true; - regen = ((GetSkill(MEDITATE) / 10) + mana_regen); + regen = ((GetSkill(SkillMeditate) / 10) + mana_regen); regen += spellbonuses.ManaRegen + itembonuses.ManaRegen; } else @@ -1223,16 +1223,16 @@ void Merc::CalcRestState() { RestRegenEndurance = (GetMaxEndurance() * RuleI(Character, RestRegenPercent) / 100); } -bool Merc::HasSkill(SkillType skill_id) const { +bool Merc::HasSkill(SkillUseTypes skill_id) const { return((GetSkill(skill_id) > 0) && CanHaveSkill(skill_id)); } -bool Merc::CanHaveSkill(SkillType skill_id) const { +bool Merc::CanHaveSkill(SkillUseTypes skill_id) const { return(database.GetSkillCap(GetClass(), skill_id, RuleI(Character, MaxLevel)) > 0); //if you don't have it by max level, then odds are you never will? } -uint16 Merc::MaxSkill(SkillType skillid, uint16 class_, uint16 level) const { +uint16 Merc::MaxSkill(SkillUseTypes skillid, uint16 class_, uint16 level) const { return(database.GetSkillCap(class_, skillid, level)); } @@ -1719,7 +1719,7 @@ void Merc::AI_Process() { float DualWieldProbability = 0.0f; int16 Ambidexterity = aabonuses.Ambidexterity + spellbonuses.Ambidexterity + itembonuses.Ambidexterity; - DualWieldProbability = (GetSkill(DUAL_WIELD) + GetLevel() + Ambidexterity) / 400.0f; // 78.0 max + DualWieldProbability = (GetSkill(SkillDualWield) + GetLevel() + Ambidexterity) / 400.0f; // 78.0 max int16 DWBonus = spellbonuses.DualWieldChance + itembonuses.DualWieldChance; DualWieldProbability += DualWieldProbability*float(DWBonus)/ 100.0f; @@ -2403,7 +2403,7 @@ bool Merc::AICastSpell(int8 iChance, int32 iSpellTypes) { continue; } - if(spells[selectedMercSpell.spellid].skill == BACKSTAB && spells[selectedMercSpell.spellid].targettype == ST_Self) { + if(spells[selectedMercSpell.spellid].skill == SkillBackstab && spells[selectedMercSpell.spellid].targettype == ST_Self) { if(!hidden) { continue; } @@ -4658,7 +4658,7 @@ void Merc::DoClassAttacks(Mob *target) { dmg = -5; } else{ - if(target->CheckHitChance(this, KICK, 0)) { + if(target->CheckHitChance(this, SkillKick, 0)) { if(RuleB(Combat, UseIntervalAC)) dmg = GetKickDamage(); else @@ -4668,7 +4668,7 @@ void Merc::DoClassAttacks(Mob *target) { } reuse = KickReuseTime * 1000; - DoSpecialAttackDamage(target, KICK, dmg, 1, -1, reuse); + DoSpecialAttackDamage(target, SkillKick, dmg, 1, -1, reuse); did_attack = true; } else @@ -4680,7 +4680,7 @@ void Merc::DoClassAttacks(Mob *target) { dmg = -5; } else{ - if(target->CheckHitChance(this, BASH, 0)) { + if(target->CheckHitChance(this, SkillBash, 0)) { if(RuleB(Combat, UseIntervalAC)) dmg = GetBashDamage(); else @@ -4689,7 +4689,7 @@ void Merc::DoClassAttacks(Mob *target) { } reuse = BashReuseTime * 1000; - DoSpecialAttackDamage(target, BASH, dmg, 1, -1, reuse); + DoSpecialAttackDamage(target, SkillBash, dmg, 1, -1, reuse); did_attack = true; } } @@ -4711,7 +4711,7 @@ bool Merc::Attack(Mob* other, int Hand, bool bRiposte, bool IsStrikethrough, boo return NPC::Attack(other, Hand, bRiposte, IsStrikethrough, IsFromSpell, opts); } -void Merc::Damage(Mob* other, int32 damage, uint16 spell_id, SkillType attack_skill, bool avoidable, int8 buffslot, bool iBuffTic) +void Merc::Damage(Mob* other, int32 damage, uint16 spell_id, SkillUseTypes attack_skill, bool avoidable, int8 buffslot, bool iBuffTic) { if(IsDead() || IsCorpse()) return; @@ -4752,7 +4752,7 @@ Mob* Merc::GetOwnerOrSelf() { return Result; } -bool Merc::Death(Mob* killerMob, int32 damage, uint16 spell, SkillType attack_skill) +bool Merc::Death(Mob* killerMob, int32 damage, uint16 spell, SkillUseTypes attack_skill) { if(!NPC::Death(killerMob, damage, spell, attack_skill)) return false; diff --git a/zone/merc.h b/zone/merc.h index a72216285..192b56575 100644 --- a/zone/merc.h +++ b/zone/merc.h @@ -46,8 +46,8 @@ public: virtual ~Merc(); //abstract virtual function implementations requird by base abstract class - virtual bool Death(Mob* killerMob, int32 damage, uint16 spell_id, SkillType attack_skill); - virtual void Damage(Mob* from, int32 damage, uint16 spell_id, SkillType attack_skill, bool avoidable = true, int8 buffslot = -1, bool iBuffTic = false); + virtual bool Death(Mob* killerMob, int32 damage, uint16 spell_id, SkillUseTypes attack_skill); + virtual void Damage(Mob* from, int32 damage, uint16 spell_id, SkillUseTypes attack_skill, bool avoidable = true, int8 buffslot = -1, bool iBuffTic = false); virtual bool Attack(Mob* other, int Hand = SLOT_PRIMARY, bool FromRiposte = false, bool IsStrikethrough = false, bool IsFromSpell = false, ExtraAttackOptions *opts = nullptr); virtual bool HasRaid() { return false; } @@ -166,10 +166,10 @@ public: inline const uint8 GetClientVersion() const { return _OwnerClientVersion; } virtual void SetTarget(Mob* mob); - bool HasSkill(SkillType skill_id) const; - bool CanHaveSkill(SkillType skill_id) const; - uint16 MaxSkill(SkillType skillid, uint16 class_, uint16 level) const; - inline uint16 MaxSkill(SkillType skillid) const { return MaxSkill(skillid, GetClass(), GetLevel()); } + bool HasSkill(SkillUseTypes skill_id) const; + bool CanHaveSkill(SkillUseTypes skill_id) const; + uint16 MaxSkill(SkillUseTypes skillid, uint16 class_, uint16 level) const; + inline uint16 MaxSkill(SkillUseTypes skillid) const { return MaxSkill(skillid, GetClass(), GetLevel()); } virtual void DoClassAttacks(Mob *target); void CheckHateList(); bool CheckTaunt(); diff --git a/zone/mob.cpp b/zone/mob.cpp index 64a2e7d1f..6780a1ca1 100644 --- a/zone/mob.cpp +++ b/zone/mob.cpp @@ -1918,7 +1918,7 @@ void Mob::SetZone(uint32 zone_id, uint32 instance_id) } void Mob::Kill() { - Death(this, 0, SPELL_UNKNOWN, HAND_TO_HAND); + Death(this, 0, SPELL_UNKNOWN, SkillHandtoHand); } void Mob::SetAttackTimer() { @@ -2077,7 +2077,7 @@ void Mob::SetAttackTimer() { bool Mob::CanThisClassDualWield(void) const { if (!IsClient()) { - return(GetSkill(DUAL_WIELD) > 0); + return(GetSkill(SkillDualWield) > 0); } else { const ItemInst* inst = CastToClient()->GetInv().GetItem(SLOT_PRIMARY); // 2HS, 2HB, or 2HP @@ -2093,19 +2093,19 @@ bool Mob::CanThisClassDualWield(void) const } } - return (CastToClient()->HasSkill(DUAL_WIELD)); // No skill = no chance + return (CastToClient()->HasSkill(SkillDualWield)); // No skill = no chance } } bool Mob::CanThisClassDoubleAttack(void) const { if(!IsClient()) { - return(GetSkill(DOUBLE_ATTACK) > 0); + return(GetSkill(SkillDoubleAttack) > 0); } else { if(aabonuses.GiveDoubleAttack || itembonuses.GiveDoubleAttack || spellbonuses.GiveDoubleAttack) { return true; } - return(CastToClient()->HasSkill(DOUBLE_ATTACK)); + return(CastToClient()->HasSkill(SkillDoubleAttack)); } } @@ -2145,36 +2145,36 @@ bool Mob::IsWarriorClass(void) const bool Mob::CanThisClassParry(void) const { if(!IsClient()) { - return(GetSkill(PARRY) > 0); + return(GetSkill(SkillParry) > 0); } else { - return(CastToClient()->HasSkill(PARRY)); + return(CastToClient()->HasSkill(SkillParry)); } } bool Mob::CanThisClassDodge(void) const { if(!IsClient()) { - return(GetSkill(DODGE) > 0); + return(GetSkill(SkillDodge) > 0); } else { - return(CastToClient()->HasSkill(DODGE)); + return(CastToClient()->HasSkill(SkillDodge)); } } bool Mob::CanThisClassRiposte(void) const { if(!IsClient()) { - return(GetSkill(RIPOSTE) > 0); + return(GetSkill(SkillRiposte) > 0); } else { - return(CastToClient()->HasSkill(RIPOSTE)); + return(CastToClient()->HasSkill(SkillRiposte)); } } bool Mob::CanThisClassBlock(void) const { if(!IsClient()) { - return(GetSkill(BLOCKSKILL) > 0); + return(GetSkill(SkillBlock) > 0); } else { - return(CastToClient()->HasSkill(BLOCKSKILL)); + return(CastToClient()->HasSkill(SkillBlock)); } } @@ -3308,7 +3308,7 @@ int32 Mob::GetVulnerability(int32 damage, Mob *caster, uint32 spell_id, uint32 t return damage; } -int16 Mob::GetSkillDmgTaken(const SkillType skill_used) +int16 Mob::GetSkillDmgTaken(const SkillUseTypes skill_used) { int skilldmg_mod = 0; @@ -4414,7 +4414,7 @@ void Mob::SetBodyType(bodyType new_body, bool overwrite_orig) { } -void Mob::ModSkillDmgTaken(SkillType skill_num, int value) +void Mob::ModSkillDmgTaken(SkillUseTypes skill_num, int value) { if (skill_num <= HIGHEST_SKILL) SkillDmgTaken_Mod[skill_num] = value; @@ -4424,7 +4424,7 @@ void Mob::ModSkillDmgTaken(SkillType skill_num, int value) SkillDmgTaken_Mod[HIGHEST_SKILL+1] = value; } -int16 Mob::GetModSkillDmgTaken(const SkillType skill_num) +int16 Mob::GetModSkillDmgTaken(const SkillUseTypes skill_num) { if (skill_num <= HIGHEST_SKILL) return SkillDmgTaken_Mod[skill_num]; @@ -4537,23 +4537,23 @@ uint16 Mob::GetSkillByItemType(int ItemType) switch (ItemType) { case ItemType1HSlash: - return _1H_SLASHING; + return Skill1HSlashing; case ItemType2HSlash: - return _2H_SLASHING; + return Skill2HSlashing; case ItemType1HPiercing: - return PIERCING; + return Skill1HPiercing; case ItemType1HBlunt: - return _1H_BLUNT; + return Skill1HBlunt; case ItemType2HBlunt: - return _2H_BLUNT; + return Skill2HBlunt; case ItemType2HPiercing: - return PIERCING; + return Skill1HPiercing; // change to 2HPiercing once activated case ItemTypeMartial: - return HAND_TO_HAND; + return SkillHandtoHand; default: - return HAND_TO_HAND; + return SkillHandtoHand; } - return HAND_TO_HAND; + return SkillHandtoHand; } diff --git a/zone/mob.h b/zone/mob.h index f64133782..eec54e57c 100644 --- a/zone/mob.h +++ b/zone/mob.h @@ -117,11 +117,11 @@ public: virtual void TryBackstab(Mob *other,int ReuseTime = 10); void TriggerDefensiveProcs(const ItemInst* weapon, Mob *on, uint16 hand = 13, int damage = 0); virtual bool AvoidDamage(Mob* attacker, int32 &damage, bool CanRiposte = true); - virtual bool CheckHitChance(Mob* attacker, SkillType skillinuse, int Hand, int16 chance_mod = 0); + virtual bool CheckHitChance(Mob* attacker, SkillUseTypes skillinuse, int Hand, int16 chance_mod = 0); virtual void TryCriticalHit(Mob *defender, uint16 skill, int32 &damage, ExtraAttackOptions *opts = nullptr); void TryPetCriticalHit(Mob *defender, uint16 skill, int32 &damage); - virtual bool TryFinishingBlow(Mob *defender, SkillType skillinuse); - virtual bool TryHeadShot(Mob* defender, SkillType skillInUse); + virtual bool TryFinishingBlow(Mob *defender, SkillUseTypes skillinuse); + virtual bool TryHeadShot(Mob* defender, SkillUseTypes skillInUse); virtual void DoRiposte(Mob* defender); void ApplyMeleeDamageBonus(uint16 skill, int32 &damage); virtual void MeleeMitigation(Mob *attacker, int32 &damage, int32 minhit, ExtraAttackOptions *opts = nullptr); @@ -147,7 +147,7 @@ public: inline bool SeeImprovedHide() const { return see_improved_hide; } bool IsInvisible(Mob* other = 0) const; void SetInvisible(uint8 state); - bool AttackAnimation(SkillType &skillinuse, int Hand, const ItemInst* weapon); + bool AttackAnimation(SkillUseTypes &skillinuse, int Hand, const ItemInst* weapon); //Song bool UseBardSpellLogic(uint16 spell_id = 0xffff, int slot = -1); @@ -257,14 +257,14 @@ public: void TempName(const char *newname = nullptr); void SetTargetable(bool on); bool IsTargetable() const { return m_targetable; } - virtual uint16 GetSkill(SkillType skill_num) const { return 0; } + virtual uint16 GetSkill(SkillUseTypes skill_num) const { return 0; } virtual uint32 GetEquipment(uint8 material_slot) const { return(0); } virtual int32 GetEquipmentMaterial(uint8 material_slot) const; virtual uint32 GetEquipmentColor(uint8 material_slot) const; virtual uint32 IsEliteMaterialItem(uint8 material_slot) const; bool AffectedBySpellExcludingSlot(int slot, int effect); - virtual bool Death(Mob* killerMob, int32 damage, uint16 spell_id, SkillType attack_skill) = 0; - virtual void Damage(Mob* from, int32 damage, uint16 spell_id, SkillType attack_skill, + virtual bool Death(Mob* killerMob, int32 damage, uint16 spell_id, SkillUseTypes attack_skill) = 0; + virtual void Damage(Mob* from, int32 damage, uint16 spell_id, SkillUseTypes attack_skill, bool avoidable = true, int8 buffslot = -1, bool iBuffTic = false) = 0; inline virtual void SetHP(int32 hp) { if (hp >= max_hp) cur_hp = max_hp; else cur_hp = hp;} bool ChangeHP(Mob* other, int32 amount, uint16 spell_id = 0, int8 buffslot = -1, bool iBuffTic = false); @@ -537,7 +537,7 @@ public: int16 GetCriticalHealRate(uint16 spell_id); int32 GetVulnerability(int32 damage, Mob *caster, uint32 spell_id, uint32 ticsremaining); int32 GetAdditionalDamage(Mob *caster, uint32 spell_id, bool use_skill = false, uint16 skill=0); - int16 GetSkillDmgTaken(const SkillType skill_used); + int16 GetSkillDmgTaken(const SkillUseTypes skill_used); void DoKnockback(Mob *caster, uint32 pushback, uint32 pushup); int16 CalcResistChanceBonus(); int16 CalcFearResistChance(); @@ -559,8 +559,8 @@ public: bool DoHPToManaCovert(uint16 mana_cost = 0); int32 ApplySpellEffectiveness(Mob* caster, int16 spell_id, int32 value, bool IsBard = false); - void ModSkillDmgTaken(SkillType skill_num, int value); - int16 GetModSkillDmgTaken(const SkillType skill_num); + void ModSkillDmgTaken(SkillUseTypes skill_num, int value); + int16 GetModSkillDmgTaken(const SkillUseTypes skill_num); void ModVulnerability(uint8 resist, int16 value); int16 GetModVulnerability(const uint8 resist); @@ -623,7 +623,7 @@ public: virtual int GetHaste(); uint8 GetWeaponDamageBonus(const Item_Struct* Weapon); - uint16 GetDamageTable(SkillType skillinuse); + uint16 GetDamageTable(SkillUseTypes skillinuse); virtual int GetMonkHandToHandDamage(void); bool CanThisClassDoubleAttack(void) const; @@ -644,9 +644,9 @@ public: int32 ReduceDamage(int32 damage); int32 AffectMagicalDamage(int32 damage, uint16 spell_id, const bool iBuffTic, Mob* attacker); - virtual void DoSpecialAttackDamage(Mob *who, SkillType skill, int32 max_damage, int32 min_damage = 1, int32 hate_override = -1, int ReuseTime = 10, bool HitChance=false); + virtual void DoSpecialAttackDamage(Mob *who, SkillUseTypes skill, int32 max_damage, int32 min_damage = 1, int32 hate_override = -1, int ReuseTime = 10, bool HitChance=false); virtual void DoThrowingAttackDmg(Mob* other, const ItemInst* RangeWeapon=nullptr, const Item_Struct* item=nullptr, uint16 weapon_damage=0, int16 chance_mod=0,int16 focus=0); - virtual void DoMeleeSkillAttackDmg(Mob* other, uint16 weapon_damage, SkillType skillinuse, int16 chance_mod=0, int16 focus=0, bool CanRiposte=false); + virtual void DoMeleeSkillAttackDmg(Mob* other, uint16 weapon_damage, SkillUseTypes skillinuse, int16 chance_mod=0, int16 focus=0, bool CanRiposte=false); virtual void DoArcheryAttackDmg(Mob* other, const ItemInst* RangeWeapon=nullptr, const ItemInst* Ammo=nullptr, uint16 weapon_damage=0, int16 chance_mod=0, int16 focus=0); bool CanDoSpecialAttack(Mob *other); bool Flurry(ExtraAttackOptions *opts); @@ -760,7 +760,7 @@ public: // HP Event inline int GetNextHPEvent() const { return nexthpevent; } void SetNextHPEvent( int hpevent ); - void SendItemAnimation(Mob *to, const Item_Struct *item, SkillType skillInUse); + void SendItemAnimation(Mob *to, const Item_Struct *item, SkillUseTypes skillInUse); inline int& GetNextIncHPEvent() { return nextinchpevent; } void SetNextIncHPEvent( int inchpevent ); @@ -810,7 +810,7 @@ public: bool HasSpellEffect(int effectid); int mod_effect_value(int effect_value, uint16 spell_id, int effect_type, Mob* caster); - float mod_hit_chance(float chancetohit, SkillType skillinuse, Mob* attacker); + float mod_hit_chance(float chancetohit, SkillUseTypes skillinuse, Mob* attacker); float mod_riposte_chance(float ripostchance, Mob* attacker); float mod_block_chance(float blockchance, Mob* attacker); float mod_parry_chance(float parrychance, Mob* attacker); @@ -821,7 +821,7 @@ public: int32 mod_kick_damage(int32 dmg); int32 mod_bash_damage(int32 dmg); int32 mod_frenzy_damage(int32 dmg); - int32 mod_monk_special_damage(int32 ndamage, SkillType skill_type); + int32 mod_monk_special_damage(int32 ndamage, SkillUseTypes skill_type); int32 mod_backstab_damage(int32 ndamage); int mod_archery_bonus_chance(int bonuschance, const ItemInst* RangeWeapon); uint32 mod_archery_bonus_damage(uint32 MaxDmg, const ItemInst* RangeWeapon); @@ -835,7 +835,7 @@ public: bool mod_will_aggro(Mob *attacker, Mob *on); protected: - void CommonDamage(Mob* other, int32 &damage, const uint16 spell_id, const SkillType attack_skill, bool &avoidable, const int8 buffslot, const bool iBuffTic); + void CommonDamage(Mob* other, int32 &damage, const uint16 spell_id, const SkillUseTypes attack_skill, bool &avoidable, const int8 buffslot, const bool iBuffTic); static uint16 GetProcID(uint16 spell_id, uint8 effect_index); float _GetMovementSpeed(int mod) const; virtual bool MakeNewPositionAndSendUpdate(float x, float y, float z, float speed, bool checkZ); @@ -941,7 +941,7 @@ protected: int GetWeaponDamage(Mob *against, const ItemInst *weapon_item, uint32 *hate = nullptr); int GetKickDamage(); int GetBashDamage(); - virtual void ApplySpecialAttackMod(SkillType skill, int32 &dmg, int32 &mindmg); + virtual void ApplySpecialAttackMod(SkillUseTypes skill, int32 &dmg, int32 &mindmg); bool HasDied(); void CalculateNewFearpoint(); float FindGroundZ(float new_x, float new_y, float z_offset=0.0); diff --git a/zone/mod_functions.cpp b/zone/mod_functions.cpp index 62f226197..31aa32d75 100644 --- a/zone/mod_functions.cpp +++ b/zone/mod_functions.cpp @@ -33,7 +33,7 @@ void Zone::mod_repop() { return; } void NPC::mod_prespawn(Spawn2 *sp) { return; } //Base damage from NPC::Attack -int NPC::mod_npc_damage(int damage, SkillType skillinuse, int hand, const Item_Struct* weapon, Mob* other) { return(damage); } +int NPC::mod_npc_damage(int damage, SkillUseTypes skillinuse, int hand, const Item_Struct* weapon, Mob* other) { return(damage); } //Mob c has been given credit for a kill. This is called after the regular EVENT_KILLED_MERIT event. void NPC::mod_npc_killed_merit(Mob* c) { return; } @@ -42,7 +42,7 @@ void NPC::mod_npc_killed_merit(Mob* c) { return; } void NPC::mod_npc_killed(Mob* oos) { return; } //Base damage from Client::Attack - can cover myriad skill types -int Client::mod_client_damage(int damage, SkillType skillinuse, int hand, const ItemInst* weapon, Mob* other) { return(damage); } +int Client::mod_client_damage(int damage, SkillUseTypes skillinuse, int hand, const ItemInst* weapon, Mob* other) { return(damage); } //message is char[4096], don't screw it up. Return true for normal behavior, false to return immediately. // Channels: @@ -62,7 +62,7 @@ bool Client::mod_client_message(char* message, uint8 chan_num) { return(true); } //Skillup override. When this is called the regular skillup check has failed. Return false to proceed with default behavior. //This will NOT allow a client to increase skill past a cap. -bool Client::mod_can_increase_skill(SkillType skillid, Mob* against_who) { return(false); } +bool Client::mod_can_increase_skill(SkillUseTypes skillid, Mob* against_who) { return(false); } //chance of general skill increase, rolled against 0-99 where higher chance is better. int16 Client::mod_increase_skill_chance(int16 chance, Mob* against_who) { return(chance); } @@ -118,7 +118,7 @@ int Client::mod_drink_value(const Item_Struct *item, int change) { return(change int Mob::mod_effect_value(int effect_value, uint16 spell_id, int effect_type, Mob* caster) { return(effect_value); } //chancetohit - 0 to 100 percent - set over 1000 for a guaranteed hit -float Mob::mod_hit_chance(float chancetohit, SkillType skillinuse, Mob* attacker) { return(chancetohit); } +float Mob::mod_hit_chance(float chancetohit, SkillUseTypes skillinuse, Mob* attacker) { return(chancetohit); } //Final riposte chance float Mob::mod_riposte_chance(float ripostechance, Mob* attacker) { return(ripostechance); } @@ -150,7 +150,7 @@ int32 Mob::mod_bash_damage(int32 dmg) { return(dmg); } int32 Mob::mod_frenzy_damage(int32 dmg) { return(dmg); } //Special attack damage after all other bonuses are applied. -int32 Mob::mod_monk_special_damage(int32 ndamage, SkillType skill_type) { return(ndamage); } +int32 Mob::mod_monk_special_damage(int32 ndamage, SkillUseTypes skill_type) { return(ndamage); } //ndamage - Backstab damage as calculated by default formulas int32 Mob::mod_backstab_damage(int32 ndamage) { return(ndamage); } diff --git a/zone/npc.cpp b/zone/npc.cpp index f287c9d8d..ca10b7406 100644 --- a/zone/npc.cpp +++ b/zone/npc.cpp @@ -266,7 +266,7 @@ NPC::NPC(const NPCType* d, Spawn2* in_respawn, float x, float y, float z, float //give NPCs skill values... int r; for(r = 0; r <= HIGHEST_SKILL; r++) { - skills[r] = database.GetSkillCap(GetClass(),(SkillType)r,moblevel); + skills[r] = database.GetSkillCap(GetClass(),(SkillUseTypes)r,moblevel); } if(d->trap_template > 0) @@ -1240,7 +1240,7 @@ uint32 NPC::GetMaxDamage(uint8 tlevel) void NPC::PickPocket(Client* thief) { - thief->CheckIncreaseSkill(PICK_POCKETS, nullptr, 5); + thief->CheckIncreaseSkill(SkillPickPockets, nullptr, 5); //make sure were allowed to targte them: int olevel = GetLevel(); @@ -1259,7 +1259,7 @@ void NPC::PickPocket(Client* thief) { return; } - int steal_skill = thief->GetSkill(PICK_POCKETS); + int steal_skill = thief->GetSkill(SkillPickPockets); int stealchance = steal_skill*100/(5*olevel+5); ItemInst* inst = 0; int x = 0; diff --git a/zone/npc.h b/zone/npc.h index 8fa44db8f..25730543b 100644 --- a/zone/npc.h +++ b/zone/npc.h @@ -79,8 +79,8 @@ public: virtual ~NPC(); //abstract virtual function implementations requird by base abstract class - virtual bool Death(Mob* killerMob, int32 damage, uint16 spell_id, SkillType attack_skill); - virtual void Damage(Mob* from, int32 damage, uint16 spell_id, SkillType attack_skill, bool avoidable = true, int8 buffslot = -1, bool iBuffTic = false); + virtual bool Death(Mob* killerMob, int32 damage, uint16 spell_id, SkillUseTypes attack_skill); + virtual void Damage(Mob* from, int32 damage, uint16 spell_id, SkillUseTypes attack_skill, bool avoidable = true, int8 buffslot = -1, bool iBuffTic = false); virtual bool Attack(Mob* other, int Hand = 13, bool FromRiposte = false, bool IsStrikethrough = false, bool IsFromSpell = false, ExtraAttackOptions *opts = nullptr); virtual bool HasRaid() { return false; } @@ -117,7 +117,7 @@ public: int32 SpellFocusHeal; virtual void SetTarget(Mob* mob); - virtual uint16 GetSkill(SkillType skill_num) const { if (skill_num <= HIGHEST_SKILL) { return skills[skill_num]; } return 0; } + virtual uint16 GetSkill(SkillUseTypes skill_num) const { if (skill_num <= HIGHEST_SKILL) { return skills[skill_num]; } return 0; } void CalcItemBonuses(StatBonuses *newbon); virtual void CalcBonuses(); @@ -352,7 +352,7 @@ public: uint32 GetSpawnKillCount(); int GetScore(); void mod_prespawn(Spawn2 *sp); - int mod_npc_damage(int damage, SkillType skillinuse, int hand, const Item_Struct* weapon, Mob* other); + int mod_npc_damage(int damage, SkillUseTypes skillinuse, int hand, const Item_Struct* weapon, Mob* other); void mod_npc_killed_merit(Mob* c); void mod_npc_killed(Mob* oos); diff --git a/zone/object.h b/zone/object.h index 942b4a20f..1f0955c1f 100644 --- a/zone/object.h +++ b/zone/object.h @@ -109,7 +109,7 @@ public: static void HandleAugmentation(Client* user, const AugmentItem_Struct* in_augment, Object *worldo); static void HandleAutoCombine(Client* user, const RecipeAutoCombine_Struct* rac); - static SkillType TypeToSkill(uint32 type); + static SkillUseTypes TypeToSkill(uint32 type); // Packet functions void CreateSpawnPacket(EQApplicationPacket* app); diff --git a/zone/perl_client.cpp b/zone/perl_client.cpp index 3fb012329..6a848a140 100644 --- a/zone/perl_client.cpp +++ b/zone/perl_client.cpp @@ -1898,7 +1898,7 @@ XS(XS_Client_GetSkill) Client * THIS; uint16 RETVAL; dXSTARG; - SkillType skill_id = (SkillType)SvUV(ST(1)); + SkillUseTypes skill_id = (SkillUseTypes)SvUV(ST(1)); if (sv_derived_from(ST(0), "Client")) { IV tmp = SvIV((SV*)SvRV(ST(0))); @@ -1925,7 +1925,7 @@ XS(XS_Client_GetRawSkill) Client * THIS; uint32 RETVAL; dXSTARG; - SkillType skill_id = (SkillType)SvUV(ST(1)); + SkillUseTypes skill_id = (SkillUseTypes)SvUV(ST(1)); if (sv_derived_from(ST(0), "Client")) { IV tmp = SvIV((SV*)SvRV(ST(0))); @@ -1951,7 +1951,7 @@ XS(XS_Client_HasSkill) { Client * THIS; bool RETVAL; - SkillType skill_id = (SkillType)SvUV(ST(1)); + SkillUseTypes skill_id = (SkillUseTypes)SvUV(ST(1)); if (sv_derived_from(ST(0), "Client")) { IV tmp = SvIV((SV*)SvRV(ST(0))); @@ -1978,7 +1978,7 @@ XS(XS_Client_CanHaveSkill) { Client * THIS; bool RETVAL; - SkillType skill_id = (SkillType)SvUV(ST(1)); + SkillUseTypes skill_id = (SkillUseTypes)SvUV(ST(1)); if (sv_derived_from(ST(0), "Client")) { IV tmp = SvIV((SV*)SvRV(ST(0))); @@ -2004,7 +2004,7 @@ XS(XS_Client_SetSkill) Perl_croak(aTHX_ "Usage: Client::SetSkill(THIS, skill_num, value)"); { Client * THIS; - SkillType skill_num = (SkillType)SvUV(ST(1)); + SkillUseTypes skill_num = (SkillUseTypes)SvUV(ST(1)); uint16 value = (uint16)SvUV(ST(2)); if (sv_derived_from(ST(0), "Client")) { @@ -2029,7 +2029,7 @@ XS(XS_Client_AddSkill) Perl_croak(aTHX_ "Usage: Client::AddSkill(THIS, skillid, value)"); { Client * THIS; - SkillType skillid = (SkillType)SvUV(ST(1)); + SkillUseTypes skillid = (SkillUseTypes)SvUV(ST(1)); uint16 value = (uint16)SvUV(ST(2)); if (sv_derived_from(ST(0), "Client")) { @@ -2079,7 +2079,7 @@ XS(XS_Client_CheckIncreaseSkill) { Client * THIS; bool RETVAL; - SkillType skillid = (SkillType)SvUV(ST(1)); + SkillUseTypes skillid = (SkillUseTypes)SvUV(ST(1)); int chancemodi; if (sv_derived_from(ST(0), "Client")) { @@ -2138,7 +2138,7 @@ XS(XS_Client_MaxSkill) { Client * THIS; uint16 RETVAL; - SkillType skillid = (SkillType)SvUV(ST(1)); + SkillUseTypes skillid = (SkillUseTypes)SvUV(ST(1)); uint16 class_ = 0; uint16 level = 0; dXSTARG; diff --git a/zone/perl_mob.cpp b/zone/perl_mob.cpp index 037a46270..13698cea9 100644 --- a/zone/perl_mob.cpp +++ b/zone/perl_mob.cpp @@ -619,7 +619,7 @@ XS(XS_Mob_GetSkill) Mob * THIS; uint32 RETVAL; dXSTARG; - SkillType skill_num = (SkillType)SvUV(ST(1)); + SkillUseTypes skill_num = (SkillUseTypes)SvUV(ST(1)); if (sv_derived_from(ST(0), "Mob")) { IV tmp = SvIV((SV*)SvRV(ST(0))); @@ -901,7 +901,7 @@ XS(XS_Mob_Damage) Mob* from; int32 damage = (int32)SvIV(ST(2)); uint16 spell_id = (uint16)SvUV(ST(3)); - SkillType attack_skill = (SkillType)SvUV(ST(4)); + SkillUseTypes attack_skill = (SkillUseTypes)SvUV(ST(4)); bool avoidable; int8 buffslot; bool iBuffTic; @@ -6639,7 +6639,7 @@ XS(XS_Mob_DoSpecialAttackDamage) { Mob * THIS; Mob* target; - SkillType attack_skill = (SkillType)SvUV(ST(2)); + SkillUseTypes attack_skill = (SkillUseTypes)SvUV(ST(2)); int32 max_damage = (int32)SvIV(ST(3)); int32 min_damage = 1; int32 hate_override = -11; @@ -7644,7 +7644,7 @@ XS(XS_Mob_ModSkillDmgTaken) Perl_croak(aTHX_ "Usage: Mob::ModSkillDmgTaken(THIS, skill, value)"); { Mob * THIS; - SkillType skill_num = (SkillType)SvUV(ST(1)); + SkillUseTypes skill_num = (SkillUseTypes)SvUV(ST(1)); int16 value = (int16)SvIV(ST(2)); if (sv_derived_from(ST(0), "Mob")) { @@ -7671,7 +7671,7 @@ XS(XS_Mob_GetModSkillDmgTaken) Mob * THIS; uint32 RETVAL; dXSTARG; - SkillType skill_num = (SkillType)SvUV(ST(1)); + SkillUseTypes skill_num = (SkillUseTypes)SvUV(ST(1)); if (sv_derived_from(ST(0), "Mob")) { IV tmp = SvIV((SV*)SvRV(ST(0))); @@ -7698,7 +7698,7 @@ XS(XS_Mob_GetSkillDmgTaken) Mob * THIS; int32 RETVAL; dXSTARG; - SkillType skill_num = (SkillType)SvUV(ST(1)); + SkillUseTypes skill_num = (SkillUseTypes)SvUV(ST(1)); if (sv_derived_from(ST(0), "Mob")) { IV tmp = SvIV((SV*)SvRV(ST(0))); @@ -7864,7 +7864,7 @@ XS(XS_Mob_DoMeleeSkillAttackDmg) Mob * THIS; Mob* target; uint16 weapon_damage = (uint16)SvIV(ST(2)); - SkillType skill = (SkillType)SvUV(ST(3)); + SkillUseTypes skill = (SkillUseTypes)SvUV(ST(3)); int16 chance_mod = (int16)SvIV(ST(4)); int16 focus = (int16)SvIV(ST(5)); uint8 CanRiposte = (uint8)SvIV(ST(6)); diff --git a/zone/questmgr.cpp b/zone/questmgr.cpp index 06cd6b2cf..c7db06831 100644 --- a/zone/questmgr.cpp +++ b/zone/questmgr.cpp @@ -1073,7 +1073,7 @@ void QuestManager::addskill(int skill_id, int value) { if(skill_id < 0 || skill_id > HIGHEST_SKILL) return; if (initiator && initiator->IsClient()) - initiator->AddSkill((SkillType) skill_id, value); + initiator->AddSkill((SkillUseTypes) skill_id, value); } void QuestManager::setlanguage(int skill_id, int value) { @@ -1087,7 +1087,7 @@ void QuestManager::setskill(int skill_id, int value) { if(skill_id < 0 || skill_id > HIGHEST_SKILL) return; if (initiator && initiator->IsClient()) - initiator->SetSkill((SkillType) skill_id, value); + initiator->SetSkill((SkillUseTypes) skill_id, value); } void QuestManager::setallskill(int value) { @@ -1095,8 +1095,8 @@ void QuestManager::setallskill(int value) { if (!initiator) return; if (initiator && initiator->IsClient()) { - SkillType sk; - for (sk = _1H_BLUNT; sk <= HIGHEST_SKILL; sk = (SkillType)(sk+1)) { + SkillUseTypes sk; + for (sk = Skill1HBlunt; sk <= HIGHEST_SKILL; sk = (SkillUseTypes)(sk+1)) { initiator->SetSkill(sk, value); } } @@ -1710,7 +1710,7 @@ void QuestManager::clear_zone_flag(int zone_id) { void QuestManager::sethp(int hpperc) { QuestManagerCurrentQuestVars(); int newhp = (owner->GetMaxHP() * (100 - hpperc)) / 100; - owner->Damage(owner, newhp, SPELL_UNKNOWN, HAND_TO_HAND, false, 0, false); + owner->Damage(owner, newhp, SPELL_UNKNOWN, SkillHandtoHand, false, 0, false); } bool QuestManager::summonburriedplayercorpse(uint32 char_id, float dest_x, float dest_y, float dest_z, float dest_heading) { diff --git a/zone/skills.h b/zone/skills.h index 581b66647..8c994a378 100644 --- a/zone/skills.h +++ b/zone/skills.h @@ -18,84 +18,84 @@ #ifndef SKILLS_H #define SKILLS_H -#define HIGHEST_SKILL 74 +#define HIGHEST_SKILL_UNUSED 74 // Correct Skill Numbers as of 4-14-2002 -#define _1H_BLUNT 0 -#define _1H_SLASHING 1 -#define _2H_BLUNT 2 -#define _2H_SLASHING 3 -#define ABJURE 4 -#define ALTERATION 5 -#define APPLY_POISON 6 -#define ARCHERY 7 -#define BACKSTAB 8 -#define BIND_WOUND 9 -#define BASH 10 -#define BLOCKSKILL 11 -#define BRASS_INSTRUMENTS 12 -#define CHANNELING 13 -#define CONJURATION 14 -#define DEFENSE 15 -#define DISARM 16 -#define DISARM_TRAPS 17 -#define DIVINATION 18 -#define DODGE 19 -#define DOUBLE_ATTACK 20 -#define DRAGON_PUNCH 21 -#define DUAL_WIELD 22 -#define EAGLE_STRIKE 23 -#define EVOCATION 24 -#define FEIGN_DEATH 25 -#define FLYING_KICK 26 -#define FORAGE 27 -#define HAND_TO_HAND 28 -#define HIDE 29 -#define KICK 30 -#define MEDITATE 31 -#define MEND 32 -#define OFFENSE 33 -#define PARRY 34 -#define PICK_LOCK 35 -#define PIERCING 36 -#define RIPOSTE 37 -#define ROUND_KICK 38 -#define SAFE_FALL 39 -#define SENSE_HEADING 40 -#define SINGING 41 -#define SNEAK 42 -#define SPECIALIZE_ABJURE 43 -#define SPECIALIZE_ALTERATION 44 -#define SPECIALIZE_CONJURATION 45 -#define SPECIALIZE_DIVINATION 46 -#define SPECIALIZE_EVOCATION 47 -#define PICK_POCKETS 48 -#define STRINGED_INSTRUMENTS 49 -#define SWIMMING 50 -#define THROWING 51 -#define TIGER_CLAW 52 -#define TRACKING 53 -#define WIND_INSTRUMENTS 54 -#define FISHING 55 -#define MAKE_POISON 56 -#define TINKERING 57 -#define RESEARCH 58 -#define ALCHEMY 59 -#define BAKING 60 -#define TAILORING 61 -#define SENSE_TRAPS 62 -#define BLACKSMITHING 63 -#define FLETCHING 64 -#define BREWING 65 -#define ALCOHOL_TOLERANCE 66 -#define BEGGING 67 -#define JEWELRY_MAKING 68 -#define POTTERY 69 -#define PERCUSSION_INSTRUMENTS 70 -#define INTIMIDATION 71 -#define BERSERKING 72 -#define TAUNT 73 -#define FRENZY 74 +#define _1H_BLUNT_UNUSED 0 +#define _1H_SLASHING_UNUSED 1 +#define _2H_BLUNT_UNUSED 2 +#define _2H_SLASHING_UNUSED 3 +#define ABJURE_UNUSED 4 +#define ALTERATION_UNUSED 5 +#define APPLY_POISON_UNUSED 6 +#define ARCHERY_UNUSED 7 +#define BACKSTAB_UNUSED 8 +#define BIND_WOUND_UNUSED 9 +#define BASH_UNUSED 10 +#define BLOCKSKILL_UNUSED 11 +#define BRASS_INSTRUMENTS_UNUSED 12 +#define CHANNELING_UNUSED 13 +#define CONJURATION_UNUSED 14 +#define DEFENSE_UNUSED 15 +#define DISARM_UNUSED 16 +#define DISARM_TRAPS_UNUSED 17 +#define DIVINATION_UNUSED 18 +#define DODGE_UNUSED 19 +#define DOUBLE_ATTACK_UNUSED 20 +#define DRAGON_PUNCH_UNUSED 21 +#define DUAL_WIELD_UNUSED 22 +#define EAGLE_STRIKE_UNUSED 23 +#define EVOCATION_UNUSED 24 +#define FEIGN_DEATH_UNUSED 25 +#define FLYING_KICK_UNUSED 26 +#define FORAGE_UNUSED 27 +#define HAND_TO_HAND_UNUSED 28 +#define HIDE_UNUSED 29 +#define KICK_UNUSED 30 +#define MEDITATE_UNUSED 31 +#define MEND_UNUSED 32 +#define OFFENSE_UNUSED 33 +#define PARRY_UNUSED 34 +#define PICK_LOCK_UNUSED 35 +#define PIERCING_UNUSED 36 +#define RIPOSTE_UNUSED 37 +#define ROUND_KICK_UNUSED 38 +#define SAFE_FALL_UNUSED 39 +#define SENSE_HEADING_UNUSED 40 +#define SINGING_UNUSED 41 +#define SNEAK_UNUSED 42 +#define SPECIALIZE_ABJURE_UNUSED 43 +#define SPECIALIZE_ALTERATION_UNUSED 44 +#define SPECIALIZE_CONJURATION_UNUSED 45 +#define SPECIALIZE_DIVINATION_UNUSED 46 +#define SPECIALIZE_EVOCATION_UNUSED 47 +#define PICK_POCKETS_UNUSED 48 +#define STRINGED_INSTRUMENTS_UNUSED 49 +#define SWIMMING_UNUSED 50 +#define THROWING_UNUSED 51 +#define TIGER_CLAW_UNUSED 52 +#define TRACKING_UNUSED 53 +#define WIND_INSTRUMENTS_UNUSED 54 +#define FISHING_UNUSED 55 +#define MAKE_POISON_UNUSED 56 +#define TINKERING_UNUSED 57 +#define RESEARCH_UNUSED 58 +#define ALCHEMY_UNUSED 59 +#define BAKING_UNUSED 60 +#define TAILORING_UNUSED 61 +#define SENSE_TRAPS_UNUSED 62 +#define BLACKSMITHING_UNUSED 63 +#define FLETCHING_UNUSED 64 +#define BREWING_UNUSED 65 +#define ALCOHOL_TOLERANCE_UNUSED 66 +#define BEGGING_UNUSED 67 +#define JEWELRY_MAKING_UNUSED 68 +#define POTTERY_UNUSED 69 +#define PERCUSSION_INSTRUMENTS_UNUSED 70 +#define INTIMIDATION_UNUSED 71 +#define BERSERKING_UNUSED 72 +#define TAUNT_UNUSED 73 +#define FRENZY_UNUSED 74 #endif diff --git a/zone/special_attacks.cpp b/zone/special_attacks.cpp index c43285aac..9e6e2e48d 100644 --- a/zone/special_attacks.cpp +++ b/zone/special_attacks.cpp @@ -33,14 +33,14 @@ int Mob::GetKickDamage() { int multiple=(GetLevel()*100/5); multiple += 100; - int32 dmg=(((GetSkill(KICK) + GetSTR() + GetLevel())*100 / 9000) * multiple) + 600; //Set a base of 6 damage, 1 seemed too low at the sub level 30 level. + int32 dmg=(((GetSkill(SkillKick) + GetSTR() + GetLevel())*100 / 9000) * multiple) + 600; //Set a base of 6 damage, 1 seemed too low at the sub level 30 level. if(GetClass() == WARRIOR || GetClass() == WARRIORGM ||GetClass() == BERSERKER || GetClass() == BERSERKERGM) { dmg*=12/10;//small increase for warriors } dmg /= 100; int32 mindmg = 1; - ApplySpecialAttackMod(KICK, dmg,mindmg); + ApplySpecialAttackMod(SkillKick, dmg,mindmg); dmg = mod_kick_damage(dmg); @@ -52,18 +52,18 @@ int Mob::GetBashDamage() { multiple += 100; //this is complete shite - int32 dmg=((((GetSkill(BASH) + GetSTR())*100 + GetLevel()*100/2) / 10000) * multiple) + 600; //Set a base of 6 damage, 1 seemed too low at the sub level 30 level. + int32 dmg=((((GetSkill(SkillBash) + GetSTR())*100 + GetLevel()*100/2) / 10000) * multiple) + 600; //Set a base of 6 damage, 1 seemed too low at the sub level 30 level. dmg /= 100; int32 mindmg = 1; - ApplySpecialAttackMod(BASH, dmg, mindmg); + ApplySpecialAttackMod(SkillBash, dmg, mindmg); dmg = mod_bash_damage(dmg); return(dmg); } -void Mob::ApplySpecialAttackMod(SkillType skill, int32 &dmg, int32 &mindmg) { +void Mob::ApplySpecialAttackMod(SkillUseTypes skill, int32 &dmg, int32 &mindmg) { int item_slot = -1; //1: Apply bonus from AC (BOOT/SHIELD/HANDS) est. 40AC=6dmg @@ -71,19 +71,19 @@ void Mob::ApplySpecialAttackMod(SkillType skill, int32 &dmg, int32 &mindmg) { switch (skill){ - case FLYING_KICK: - case ROUND_KICK: - case KICK: + case SkillFlyingKick: + case SkillRoundKick: + case SkillKick: item_slot = SLOT_FEET; break; - case BASH: + case SkillBash: item_slot = SLOT_SECONDARY; break; - case DRAGON_PUNCH: - case EAGLE_STRIKE: - case TIGER_CLAW: + case SkillDragonPunch: + case SkillEagleStrike: + case SkillTigerClaw: item_slot = SLOT_HANDS; break; @@ -100,7 +100,7 @@ void Mob::ApplySpecialAttackMod(SkillType skill, int32 &dmg, int32 &mindmg) { } } -void Mob::DoSpecialAttackDamage(Mob *who, SkillType skill, int32 max_damage, int32 min_damage, int32 hate_override,int ReuseTime, bool HitChance) { +void Mob::DoSpecialAttackDamage(Mob *who, SkillUseTypes skill, int32 max_damage, int32 min_damage, int32 hate_override,int ReuseTime, bool HitChance) { //this really should go through the same code as normal melee damage to //pick up all the special behavior there @@ -108,7 +108,7 @@ void Mob::DoSpecialAttackDamage(Mob *who, SkillType skill, int32 max_damage, int if(hate_override > -1) hate = hate_override; - if(skill == BASH) + if(skill == SkillBash) { if(IsClient()) { @@ -132,7 +132,7 @@ void Mob::DoSpecialAttackDamage(Mob *who, SkillType skill, int32 max_damage, int else{ bool CanRiposte = true; - if(skill == THROWING || skill == ARCHERY) // changed from '&&' + if(skill == SkillThrowing || skill == SkillArchery) // changed from '&&' CanRiposte = false; who->AvoidDamage(this, max_damage, CanRiposte); @@ -194,13 +194,13 @@ void Client::OPCombatAbility(const EQApplicationPacket *app) { //allready do their checking in conjunction with the attack timer //throwing weapons if(ca_atk->m_atk == 11) { - if (ca_atk->m_skill == THROWING) { + if (ca_atk->m_skill == SkillThrowing) { SetAttackTimer(); ThrowingAttack(GetTarget()); return; } //ranged attack (archery) - if (ca_atk->m_skill == ARCHERY) { + if (ca_atk->m_skill == SkillArchery) { SetAttackTimer(); RangedAttack(GetTarget()); return; @@ -231,10 +231,10 @@ void Client::OPCombatAbility(const EQApplicationPacket *app) { int32 skill_reduction = this->GetSkillReuseTime(ca_atk->m_skill); - if ((ca_atk->m_atk == 100) && (ca_atk->m_skill == BASH)) { // SLAM - Bash without a shield equipped + if ((ca_atk->m_atk == 100) && (ca_atk->m_skill == SkillBash)) { // SLAM - Bash without a shield equipped if (GetTarget() != this) { - CheckIncreaseSkill(BASH, GetTarget(), 10); + CheckIncreaseSkill(SkillBash, GetTarget(), 10); DoAnim(animTailRake); int32 ht = 0; @@ -243,7 +243,7 @@ void Client::OPCombatAbility(const EQApplicationPacket *app) { dmg = -5; } else{ - if(!GetTarget()->CheckHitChance(this, BASH, 0)) { + if(!GetTarget()->CheckHitChance(this, SkillBash, 0)) { dmg = 0; ht = GetBashDamage(); } @@ -258,7 +258,7 @@ void Client::OPCombatAbility(const EQApplicationPacket *app) { ReuseTime = BashReuseTime-1-skill_reduction; ReuseTime = (ReuseTime*HasteMod)/100; - DoSpecialAttackDamage(GetTarget(), BASH, dmg, 1, ht, ReuseTime); + DoSpecialAttackDamage(GetTarget(), SkillBash, dmg, 1, ht, ReuseTime); if(ReuseTime > 0) { p_timers.Start(pTimerCombatAbility, ReuseTime); @@ -267,11 +267,11 @@ void Client::OPCombatAbility(const EQApplicationPacket *app) { return; } - if ((ca_atk->m_atk == 100) && (ca_atk->m_skill == FRENZY)) + if ((ca_atk->m_atk == 100) && (ca_atk->m_skill == SkillFrenzy)) { - CheckIncreaseSkill(FRENZY, GetTarget(), 10); + CheckIncreaseSkill(SkillFrenzy, GetTarget(), 10); int AtkRounds = 3; - int skillmod = 100*GetSkill(FRENZY)/MaxSkill(FRENZY); + int skillmod = 100*GetSkill(SkillFrenzy)/MaxSkill(SkillFrenzy); int32 max_dmg = (26 + ((((GetLevel()-6) * 2)*skillmod)/100)) * ((100+RuleI(Combat, FrenzyBonus))/100); int32 min_dmg = 0; DoAnim(anim2HSlashing); @@ -293,7 +293,7 @@ void Client::OPCombatAbility(const EQApplicationPacket *app) { while(AtkRounds > 0) { if (GetTarget() && (AtkRounds == 1 || MakeRandomInt(0,100) < 75)){ - DoSpecialAttackDamage(GetTarget(), FRENZY, max_dmg, min_dmg, max_dmg , ReuseTime, true); + DoSpecialAttackDamage(GetTarget(), SkillFrenzy, max_dmg, min_dmg, max_dmg , ReuseTime, true); } AtkRounds--; } @@ -310,11 +310,11 @@ void Client::OPCombatAbility(const EQApplicationPacket *app) { case WARRIOR: case RANGER: case BEASTLORD: - if (ca_atk->m_atk != 100 || ca_atk->m_skill != KICK) { + if (ca_atk->m_atk != 100 || ca_atk->m_skill != SkillKick) { break; } if (GetTarget() != this) { - CheckIncreaseSkill(KICK, GetTarget(), 10); + CheckIncreaseSkill(SkillKick, GetTarget(), 10); DoAnim(animKick); int32 ht = 0; @@ -322,7 +322,7 @@ void Client::OPCombatAbility(const EQApplicationPacket *app) { dmg = -5; } else{ - if(!GetTarget()->CheckHitChance(this, KICK, 0)) { + if(!GetTarget()->CheckHitChance(this, SkillKick, 0)) { dmg = 0; ht = GetKickDamage(); } @@ -335,7 +335,7 @@ void Client::OPCombatAbility(const EQApplicationPacket *app) { } ReuseTime = KickReuseTime-1-skill_reduction; - DoSpecialAttackDamage(GetTarget(), KICK, dmg, 1, ht, ReuseTime); + DoSpecialAttackDamage(GetTarget(), SkillKick, dmg, 1, ht, ReuseTime); } break; @@ -346,7 +346,7 @@ void Client::OPCombatAbility(const EQApplicationPacket *app) { uint16 bDoubleSpecialAttack = itembonuses.DoubleSpecialAttack + spellbonuses.DoubleSpecialAttack + aabonuses.DoubleSpecialAttack; if( bDoubleSpecialAttack && (bDoubleSpecialAttack >= 100 || bDoubleSpecialAttack > MakeRandomInt(0,100)) ) { - int MonkSPA [5] = { FLYING_KICK, DRAGON_PUNCH, EAGLE_STRIKE, TIGER_CLAW, ROUND_KICK }; + int MonkSPA [5] = { SkillFlyingKick, SkillDragonPunch, SkillEagleStrike, SkillTigerClaw, SkillRoundKick }; MonkSpecialAttack(GetTarget(), MonkSPA[MakeRandomInt(0,4)]); int TripleChance = 25; @@ -363,12 +363,12 @@ void Client::OPCombatAbility(const EQApplicationPacket *app) { //hackish... but we return a huge reuse time if this is an // invalid skill, otherwise, we can safely assume it is a // valid monk skill and just cast it to a SkillType - CheckIncreaseSkill((SkillType) ca_atk->m_skill, GetTarget(), 10); + CheckIncreaseSkill((SkillUseTypes) ca_atk->m_skill, GetTarget(), 10); } break; } case ROGUE: { - if (ca_atk->m_atk != 100 || ca_atk->m_skill != BACKSTAB) { + if (ca_atk->m_atk != 100 || ca_atk->m_skill != SkillBackstab) { break; } TryBackstab(GetTarget(), ReuseTime); @@ -398,13 +398,13 @@ int Mob::MonkSpecialAttack(Mob* other, uint8 unchecked_type) int32 max_dmg = 0; int32 min_dmg = 1; int reuse = 0; - SkillType skill_type; //to avoid casting... even though it "would work" + SkillUseTypes skill_type; //to avoid casting... even though it "would work" uint8 itemslot = SLOT_FEET; switch(unchecked_type) { - case FLYING_KICK:{ - skill_type = FLYING_KICK; + case SkillFlyingKick:{ + skill_type = SkillFlyingKick; max_dmg = ((GetSTR()+GetSkill(skill_type)) * RuleI(Combat, FlyingKickBonus) / 100) + 35; min_dmg = ((level*8)/10); ApplySpecialAttackMod(skill_type, max_dmg, min_dmg); @@ -412,8 +412,8 @@ int Mob::MonkSpecialAttack(Mob* other, uint8 unchecked_type) reuse = FlyingKickReuseTime; break; } - case DRAGON_PUNCH:{ - skill_type = DRAGON_PUNCH; + case SkillDragonPunch:{ + skill_type = SkillDragonPunch; max_dmg = ((GetSTR()+GetSkill(skill_type)) * RuleI(Combat, DragonPunchBonus) / 100) + 26; itemslot = SLOT_HANDS; ApplySpecialAttackMod(skill_type, max_dmg, min_dmg); @@ -422,8 +422,8 @@ int Mob::MonkSpecialAttack(Mob* other, uint8 unchecked_type) break; } - case EAGLE_STRIKE:{ - skill_type = EAGLE_STRIKE; + case SkillEagleStrike:{ + skill_type = SkillEagleStrike; max_dmg = ((GetSTR()+GetSkill(skill_type)) * RuleI(Combat, EagleStrikeBonus) / 100) + 19; itemslot = SLOT_HANDS; ApplySpecialAttackMod(skill_type, max_dmg, min_dmg); @@ -432,8 +432,8 @@ int Mob::MonkSpecialAttack(Mob* other, uint8 unchecked_type) break; } - case TIGER_CLAW:{ - skill_type = TIGER_CLAW; + case SkillTigerClaw:{ + skill_type = SkillTigerClaw; max_dmg = ((GetSTR()+GetSkill(skill_type)) * RuleI(Combat, TigerClawBonus) / 100) + 12; itemslot = SLOT_HANDS; ApplySpecialAttackMod(skill_type, max_dmg, min_dmg); @@ -442,8 +442,8 @@ int Mob::MonkSpecialAttack(Mob* other, uint8 unchecked_type) break; } - case ROUND_KICK:{ - skill_type = ROUND_KICK; + case SkillRoundKick:{ + skill_type = SkillRoundKick; max_dmg = ((GetSTR()+GetSkill(skill_type)) * RuleI(Combat, RoundKickBonus) / 100) + 10; ApplySpecialAttackMod(skill_type, max_dmg, min_dmg); DoAnim(animRoundKick); @@ -451,8 +451,8 @@ int Mob::MonkSpecialAttack(Mob* other, uint8 unchecked_type) break; } - case KICK:{ - skill_type = KICK; + case SkillKick:{ + skill_type = SkillKick; max_dmg = GetKickDamage(); DoAnim(animKick); reuse = KickReuseTime; @@ -544,13 +544,13 @@ void Mob::TryBackstab(Mob *other, int ReuseTime) { ) { entity_list.MessageClose_StringID(this, false, 200, MT_CritMelee, ASSASSINATES, GetName()); if(IsClient()) - CastToClient()->CheckIncreaseSkill(BACKSTAB, other, 10); + CastToClient()->CheckIncreaseSkill(SkillBackstab, other, 10); RogueAssassinate(other); } else { RogueBackstab(other); if (level > 54) { - float DoubleAttackProbability = (GetSkill(DOUBLE_ATTACK) + GetLevel()) / 500.0f; // 62.4 max + float DoubleAttackProbability = (GetSkill(SkillDoubleAttack) + GetLevel()) / 500.0f; // 62.4 max // Check for double attack with main hand assuming maxed DA Skill (MS) if(MakeRandomFloat(0, 1) < DoubleAttackProbability) // Max 62.4 % chance of DA @@ -563,7 +563,7 @@ void Mob::TryBackstab(Mob *other, int ReuseTime) { } } if(IsClient()) - CastToClient()->CheckIncreaseSkill(BACKSTAB, other, 10); + CastToClient()->CheckIncreaseSkill(SkillBackstab, other, 10); } } //Live AA - Chaotic Backstab @@ -572,9 +572,9 @@ void Mob::TryBackstab(Mob *other, int ReuseTime) { //we can stab from any angle, we do min damage though. RogueBackstab(other, true); if (level > 54) { - float DoubleAttackProbability = (GetSkill(DOUBLE_ATTACK) + GetLevel()) / 500.0f; // 62.4 max + float DoubleAttackProbability = (GetSkill(SkillDoubleAttack) + GetLevel()) / 500.0f; // 62.4 max if(IsClient()) - CastToClient()->CheckIncreaseSkill(BACKSTAB, other, 10); + CastToClient()->CheckIncreaseSkill(SkillBackstab, other, 10); // Check for double attack with main hand assuming maxed DA Skill (MS) if(MakeRandomFloat(0, 1) < DoubleAttackProbability) // Max 62.4 % chance of DA if(other->GetHP() > 0) @@ -620,12 +620,12 @@ void Mob::RogueBackstab(Mob* other, bool min_damage, int ReuseTime) if(primaryweapondamage > 0){ if(level > 25){ - max_hit = (((2*backstab_dmg) * GetDamageTable(BACKSTAB) / 100) * 10 * GetSkill(BACKSTAB) / 355) + ((level-25)/3) + 1; - hate = 20 * backstab_dmg * GetSkill(BACKSTAB) / 355; + max_hit = (((2*backstab_dmg) * GetDamageTable(SkillBackstab) / 100) * 10 * GetSkill(SkillBackstab) / 355) + ((level-25)/3) + 1; + hate = 20 * backstab_dmg * GetSkill(SkillBackstab) / 355; } else{ - max_hit = (((2*backstab_dmg) * GetDamageTable(BACKSTAB) / 100) * 10 * GetSkill(BACKSTAB) / 355) + 1;; - hate = 20 * backstab_dmg * GetSkill(BACKSTAB) / 355; + max_hit = (((2*backstab_dmg) * GetDamageTable(SkillBackstab) / 100) * 10 * GetSkill(SkillBackstab) / 355) + 1;; + hate = 20 * backstab_dmg * GetSkill(SkillBackstab) / 355; } // determine minimum hits @@ -639,7 +639,7 @@ void Mob::RogueBackstab(Mob* other, bool min_damage, int ReuseTime) min_hit = (level * ( level*5 - 105)) / 100; } - if(!other->CheckHitChance(this, BACKSTAB, 0)) { + if(!other->CheckHitChance(this, SkillBackstab, 0)) { ndamage = 0; } else{ @@ -665,7 +665,7 @@ void Mob::RogueBackstab(Mob* other, bool min_damage, int ReuseTime) ndamage = mod_backstab_damage(ndamage); - DoSpecialAttackDamage(other, BACKSTAB, ndamage, min_hit, hate, ReuseTime); + DoSpecialAttackDamage(other, SkillBackstab, ndamage, min_hit, hate, ReuseTime); DoAnim(animPiercing); } @@ -675,9 +675,9 @@ void Mob::RogueAssassinate(Mob* other) //can you dodge, parry, etc.. an assassinate?? //if so, use DoSpecialAttackDamage(other, BACKSTAB, 32000); instead if(GetWeaponDamage(other, IsClient()?CastToClient()->GetInv().GetItem(SLOT_PRIMARY):(const ItemInst*)nullptr) > 0){ - other->Damage(this, 32000, SPELL_UNKNOWN, BACKSTAB); + other->Damage(this, 32000, SPELL_UNKNOWN, SkillBackstab); }else{ - other->Damage(this, -5, SPELL_UNKNOWN, BACKSTAB); + other->Damage(this, -5, SPELL_UNKNOWN, SkillBackstab); } DoAnim(animPiercing); //piercing animation } @@ -794,7 +794,7 @@ void Client::RangedAttack(Mob* other) { return; } - SendItemAnimation(GetTarget(), AmmoItem, ARCHERY); + SendItemAnimation(GetTarget(), AmmoItem, SkillArchery); DoArcheryAttackDmg(GetTarget(), RangeWeapon, Ammo); @@ -809,7 +809,7 @@ void Client::RangedAttack(Mob* other) { mlog(COMBAT__RANGED, "Endless Quiver prevented ammo consumption."); } - CheckIncreaseSkill(ARCHERY, GetTarget(), -15); + CheckIncreaseSkill(SkillArchery, GetTarget(), -15); //break invis when you attack if(invisible) { @@ -848,13 +848,13 @@ void Mob::DoArcheryAttackDmg(Mob* other, const ItemInst* RangeWeapon, const Item if (!CanDoSpecialAttack(other)) return; - if (!other->CheckHitChance(this, ARCHERY, 13,chance_mod)) { + if (!other->CheckHitChance(this, SkillArchery, 13,chance_mod)) { mlog(COMBAT__RANGED, "Ranged attack missed %s.", other->GetName()); - other->Damage(this, 0, SPELL_UNKNOWN, ARCHERY); + other->Damage(this, 0, SPELL_UNKNOWN, SkillArchery); } else { mlog(COMBAT__RANGED, "Ranged attack hit %s.", other->GetName()); - if(!TryHeadShot(other, ARCHERY)) + if(!TryHeadShot(other, SkillArchery)) { int32 TotalDmg = 0; int16 WDmg = 0; @@ -872,7 +872,7 @@ void Mob::DoArcheryAttackDmg(Mob* other, const ItemInst* RangeWeapon, const Item WDmg = 0; if(ADmg < 0) ADmg = 0; - uint32 MaxDmg = (RuleR(Combat, ArcheryBaseDamageBonus)*(WDmg+ADmg)*GetDamageTable(ARCHERY)) / 100; + uint32 MaxDmg = (RuleR(Combat, ArcheryBaseDamageBonus)*(WDmg+ADmg)*GetDamageTable(SkillArchery)) / 100; int32 hate = ((WDmg+ADmg)); uint16 bonusArcheryDamageModifier = aabonuses.ArcheryDamageModifier + itembonuses.ArcheryDamageModifier + spellbonuses.ArcheryDamageModifier; @@ -927,7 +927,7 @@ void Mob::DoArcheryAttackDmg(Mob* other, const ItemInst* RangeWeapon, const Item //twice, for ammo and weapon TotalDmg += (2*((GetLevel()-25)/3)); minDmg += (2*((GetLevel()-25)/3)); - minDmg += minDmg * GetMeleeMinDamageMod_SE(ARCHERY) / 100; + minDmg += minDmg * GetMeleeMinDamageMod_SE(SkillArchery) / 100; hate += (2*((GetLevel()-25)/3)); } @@ -936,20 +936,20 @@ void Mob::DoArcheryAttackDmg(Mob* other, const ItemInst* RangeWeapon, const Item if(TotalDmg > 0) { TotalDmg += TotalDmg*focus/100; - ApplyMeleeDamageBonus(ARCHERY, TotalDmg); - TotalDmg += other->GetAdditionalDamage(this, 0, true, ARCHERY); - TotalDmg += (itembonuses.HeroicDEX / 10) + (TotalDmg * other->GetSkillDmgTaken(ARCHERY) / 100) + GetSkillDmgAmt(ARCHERY); + ApplyMeleeDamageBonus(SkillArchery, TotalDmg); + TotalDmg += other->GetAdditionalDamage(this, 0, true, SkillArchery); + TotalDmg += (itembonuses.HeroicDEX / 10) + (TotalDmg * other->GetSkillDmgTaken(SkillArchery) / 100) + GetSkillDmgAmt(SkillArchery); TotalDmg = mod_archery_damage(TotalDmg, dobonus, RangeWeapon); - TryCriticalHit(other, ARCHERY, TotalDmg); + TryCriticalHit(other, SkillArchery, TotalDmg); other->AddToHateList(this, hate, 0, false); } } else TotalDmg = -5; - other->Damage(this, TotalDmg, SPELL_UNKNOWN, ARCHERY); + other->Damage(this, TotalDmg, SPELL_UNKNOWN, SkillArchery); } } @@ -1013,16 +1013,16 @@ void NPC::RangedAttack(Mob* other) } if(ammo) - SendItemAnimation(GetTarget(), ammo, ARCHERY); + SendItemAnimation(GetTarget(), ammo, SkillArchery); // Face the Target FaceTarget(GetTarget()); // Hit? - if (!GetTarget()->CheckHitChance(this, ARCHERY, 13)) + if (!GetTarget()->CheckHitChance(this, SkillArchery, 13)) { mlog(COMBAT__RANGED, "Ranged attack missed %s.", GetTarget()->GetName()); - GetTarget()->Damage(this, 0, SPELL_UNKNOWN, ARCHERY); + GetTarget()->Damage(this, 0, SPELL_UNKNOWN, SkillArchery); } else { @@ -1044,14 +1044,14 @@ void NPC::RangedAttack(Mob* other) int32 hate = TotalDmg; GetTarget()->MeleeMitigation(this, TotalDmg, MinDmg); - ApplyMeleeDamageBonus(ARCHERY, TotalDmg); - TryCriticalHit(GetTarget(), ARCHERY, TotalDmg); + ApplyMeleeDamageBonus(SkillArchery, TotalDmg); + TryCriticalHit(GetTarget(), SkillArchery, TotalDmg); GetTarget()->AddToHateList(this, hate, 0, false); - GetTarget()->Damage(this, TotalDmg, SPELL_UNKNOWN, ARCHERY); + GetTarget()->Damage(this, TotalDmg, SPELL_UNKNOWN, SkillArchery); } else { - GetTarget()->Damage(this, -5, SPELL_UNKNOWN, ARCHERY); + GetTarget()->Damage(this, -5, SPELL_UNKNOWN, SkillArchery); } } @@ -1090,7 +1090,7 @@ void NPC::RangedAttack(Mob* other) uint16 Mob::GetThrownDamage(int16 wDmg, int32& TotalDmg, int& minDmg) { - uint16 MaxDmg = (((2 * wDmg) * GetDamageTable(THROWING)) / 100); + uint16 MaxDmg = (((2 * wDmg) * GetDamageTable(SkillThrowing)) / 100); if (MaxDmg == 0) MaxDmg = 1; @@ -1105,7 +1105,7 @@ uint16 Mob::GetThrownDamage(int16 wDmg, int32& TotalDmg, int& minDmg) { TotalDmg += ((GetLevel()-25)/3); minDmg += ((GetLevel()-25)/3); - minDmg += minDmg * GetMeleeMinDamageMod_SE(THROWING) / 100; + minDmg += minDmg * GetMeleeMinDamageMod_SE(SkillThrowing) / 100; } if(MaxDmg < minDmg) @@ -1189,13 +1189,13 @@ void Client::ThrowingAttack(Mob* other) { //old was 51 return; } //send item animation, also does the throw animation - SendItemAnimation(GetTarget(), item, THROWING); + SendItemAnimation(GetTarget(), item, SkillThrowing); DoThrowingAttackDmg(GetTarget(), RangeWeapon, item); //consume ammo DeleteItemInInventory(ammo_slot, 1, true); - CheckIncreaseSkill(THROWING, GetTarget()); + CheckIncreaseSkill(SkillThrowing, GetTarget()); //break invis when you attack if(invisible) { @@ -1234,9 +1234,9 @@ void Mob::DoThrowingAttackDmg(Mob* other, const ItemInst* RangeWeapon, const Ite if (!CanDoSpecialAttack(other)) return; - if (!other->CheckHitChance(this, THROWING, 13, chance_mod)){ + if (!other->CheckHitChance(this, SkillThrowing, 13, chance_mod)){ mlog(COMBAT__RANGED, "Ranged attack missed %s.", other->GetName()); - other->Damage(this, 0, SPELL_UNKNOWN, THROWING); + other->Damage(this, 0, SPELL_UNKNOWN, SkillThrowing); } else { mlog(COMBAT__RANGED, "Throwing attack hit %s.", other->GetName()); @@ -1260,10 +1260,10 @@ void Mob::DoThrowingAttackDmg(Mob* other, const ItemInst* RangeWeapon, const Ite if(TotalDmg > 0) { TotalDmg += TotalDmg*focus/100; - ApplyMeleeDamageBonus(THROWING, TotalDmg); - TotalDmg += other->GetAdditionalDamage(this, 0, true, THROWING); - TotalDmg += (itembonuses.HeroicDEX / 10) + (TotalDmg * other->GetSkillDmgTaken(THROWING) / 100) + GetSkillDmgAmt(THROWING); - TryCriticalHit(other, THROWING, TotalDmg); + ApplyMeleeDamageBonus(SkillThrowing, TotalDmg); + TotalDmg += other->GetAdditionalDamage(this, 0, true, SkillThrowing); + TotalDmg += (itembonuses.HeroicDEX / 10) + (TotalDmg * other->GetSkillDmgTaken(SkillThrowing) / 100) + GetSkillDmgAmt(SkillThrowing); + TryCriticalHit(other, SkillThrowing, TotalDmg); int32 hate = (2*WDmg); other->AddToHateList(this, hate, 0, false); } @@ -1272,14 +1272,14 @@ void Mob::DoThrowingAttackDmg(Mob* other, const ItemInst* RangeWeapon, const Ite else TotalDmg = -5; - other->Damage(this, TotalDmg, SPELL_UNKNOWN, THROWING); + other->Damage(this, TotalDmg, SPELL_UNKNOWN, SkillThrowing); } if((RangeWeapon != nullptr) && GetTarget() && other && (other->GetHP() > -10)) TryWeaponProc(RangeWeapon, other, 11); } -void Mob::SendItemAnimation(Mob *to, const Item_Struct *item, SkillType skillInUse) { +void Mob::SendItemAnimation(Mob *to, const Item_Struct *item, SkillUseTypes skillInUse) { EQApplicationPacket *outapp = new EQApplicationPacket(OP_SomeItemPacketMaybe, sizeof(Arrow_Struct)); Arrow_Struct *as = (Arrow_Struct *) outapp->pBuffer; as->type = 1; @@ -1450,17 +1450,17 @@ void NPC::DoClassAttacks(Mob *target) { } break; case MONK: case MONKGM: { - uint8 satype = KICK; + uint8 satype = SkillKick; if(level > 29) { - satype = FLYING_KICK; + satype = SkillFlyingKick; } else if(level > 24) { - satype = DRAGON_PUNCH; + satype = SkillDragonPunch; } else if(level > 19) { - satype = EAGLE_STRIKE; + satype = SkillEagleStrike; } else if(level > 9) { - satype = TIGER_CLAW; + satype = SkillTigerClaw; } else if(level > 4) { - satype = ROUND_KICK; + satype = SkillRoundKick; } reuse = MonkSpecialAttack(target, satype); @@ -1479,7 +1479,7 @@ void NPC::DoClassAttacks(Mob *target) { dmg = -5; } else{ - if(target->CheckHitChance(this, KICK, 0)) { + if(target->CheckHitChance(this, SkillKick, 0)) { if(RuleB(Combat, UseIntervalAC)) dmg = GetKickDamage(); else @@ -1489,7 +1489,7 @@ void NPC::DoClassAttacks(Mob *target) { } reuse = KickReuseTime * 1000; - DoSpecialAttackDamage(target, KICK, dmg, 1, -1, reuse); + DoSpecialAttackDamage(target, SkillKick, dmg, 1, -1, reuse); did_attack = true; } else @@ -1501,7 +1501,7 @@ void NPC::DoClassAttacks(Mob *target) { dmg = -5; } else{ - if(target->CheckHitChance(this, BASH, 0)) { + if(target->CheckHitChance(this, SkillBash, 0)) { if(RuleB(Combat, UseIntervalAC)) dmg = GetBashDamage(); else @@ -1510,7 +1510,7 @@ void NPC::DoClassAttacks(Mob *target) { } reuse = BashReuseTime * 1000; - DoSpecialAttackDamage(target, BASH, dmg, 1, -1, reuse); + DoSpecialAttackDamage(target, SkillBash, dmg, 1, -1, reuse); did_attack = true; } } @@ -1536,7 +1536,7 @@ void NPC::DoClassAttacks(Mob *target) { while(AtkRounds > 0) { if (GetTarget() && (AtkRounds == 1 || MakeRandomInt(0,100) < 75)){ - DoSpecialAttackDamage(GetTarget(), FRENZY, max_dmg, min_dmg, -1 , reuse, true); + DoSpecialAttackDamage(GetTarget(), SkillFrenzy, max_dmg, min_dmg, -1 , reuse, true); } AtkRounds--; } @@ -1556,7 +1556,7 @@ void NPC::DoClassAttacks(Mob *target) { dmg = -5; } else{ - if(target->CheckHitChance(this, KICK, 0)) { + if(target->CheckHitChance(this, SkillKick, 0)) { if(RuleB(Combat, UseIntervalAC)) dmg = GetKickDamage(); else @@ -1565,7 +1565,7 @@ void NPC::DoClassAttacks(Mob *target) { } reuse = KickReuseTime * 1000; - DoSpecialAttackDamage(target, KICK, dmg, 1, -1, reuse); + DoSpecialAttackDamage(target, SkillKick, dmg, 1, -1, reuse); did_attack = true; } break; @@ -1582,7 +1582,7 @@ void NPC::DoClassAttacks(Mob *target) { dmg = -5; } else{ - if(target->CheckHitChance(this, BASH, 0)) { + if(target->CheckHitChance(this, SkillBash, 0)) { if(RuleB(Combat, UseIntervalAC)) dmg = GetBashDamage(); else @@ -1591,7 +1591,7 @@ void NPC::DoClassAttacks(Mob *target) { } reuse = BashReuseTime * 1000; - DoSpecialAttackDamage(target, BASH, dmg, 1, -1, reuse); + DoSpecialAttackDamage(target, SkillBash, dmg, 1, -1, reuse); did_attack = true; } break; @@ -1643,43 +1643,43 @@ void Client::DoClassAttacks(Mob *ca_target, uint16 skill, bool IsRiposte) case WARRIOR: case RANGER: case BEASTLORD: - skill_to_use = KICK; + skill_to_use = SkillKick; break; case BERSERKER: - skill_to_use = FRENZY; + skill_to_use = SkillFrenzy; break; case SHADOWKNIGHT: case PALADIN: - skill_to_use = BASH; + skill_to_use = SkillBash; break; case MONK: if(GetLevel() >= 30) { - skill_to_use = FLYING_KICK; + skill_to_use = SkillFlyingKick; } else if(GetLevel() >= 25) { - skill_to_use = DRAGON_PUNCH; + skill_to_use = SkillDragonPunch; } else if(GetLevel() >= 20) { - skill_to_use = EAGLE_STRIKE; + skill_to_use = SkillEagleStrike; } else if(GetLevel() >= 10) { - skill_to_use = TIGER_CLAW; + skill_to_use = SkillTigerClaw; } else if(GetLevel() >= 5) { - skill_to_use = ROUND_KICK; + skill_to_use = SkillRoundKick; } else { - skill_to_use = KICK; + skill_to_use = SkillKick; } break; case ROGUE: - skill_to_use = BACKSTAB; + skill_to_use = SkillBackstab; break; } } @@ -1690,7 +1690,7 @@ void Client::DoClassAttacks(Mob *ca_target, uint16 skill, bool IsRiposte) if(skill_to_use == -1) return; - if(skill_to_use == BASH) + if(skill_to_use == SkillBash) { if (ca_target!=this) { @@ -1701,7 +1701,7 @@ void Client::DoClassAttacks(Mob *ca_target, uint16 skill, bool IsRiposte) dmg = -5; } else{ - if(!ca_target->CheckHitChance(this, BASH, 0)) { + if(!ca_target->CheckHitChance(this, SkillBash, 0)) { dmg = 0; } else{ @@ -1716,7 +1716,7 @@ void Client::DoClassAttacks(Mob *ca_target, uint16 skill, bool IsRiposte) ReuseTime = BashReuseTime-1; ReuseTime = (ReuseTime*HasteMod)/100; - DoSpecialAttackDamage(ca_target, BASH, dmg, 1,-1,ReuseTime); + DoSpecialAttackDamage(ca_target, SkillBash, dmg, 1,-1,ReuseTime); if(ReuseTime > 0 && !IsRiposte) { @@ -1726,11 +1726,11 @@ void Client::DoClassAttacks(Mob *ca_target, uint16 skill, bool IsRiposte) return; } - if(skill_to_use == FRENZY) + if(skill_to_use == SkillFrenzy) { - CheckIncreaseSkill(FRENZY, GetTarget(), 10); + CheckIncreaseSkill(SkillFrenzy, GetTarget(), 10); int AtkRounds = 3; - int skillmod = 100*GetSkill(FRENZY)/MaxSkill(FRENZY); + int skillmod = 100*GetSkill(SkillFrenzy)/MaxSkill(SkillFrenzy); int32 max_dmg = (26 + ((((GetLevel()-6) * 2)*skillmod)/100)) * ((100+RuleI(Combat, FrenzyBonus))/100); int32 min_dmg = 0; DoAnim(anim2HSlashing); @@ -1750,7 +1750,7 @@ void Client::DoClassAttacks(Mob *ca_target, uint16 skill, bool IsRiposte) while(AtkRounds > 0) { if (GetTarget() && (AtkRounds == 1 || MakeRandomInt(0,100) < 75)){ - DoSpecialAttackDamage(GetTarget(), FRENZY, max_dmg, min_dmg, max_dmg , ReuseTime, true); + DoSpecialAttackDamage(GetTarget(), SkillFrenzy, max_dmg, min_dmg, max_dmg , ReuseTime, true); } AtkRounds--; } @@ -1761,7 +1761,7 @@ void Client::DoClassAttacks(Mob *ca_target, uint16 skill, bool IsRiposte) return; } - if(skill_to_use == KICK) + if(skill_to_use == SkillKick) { if(ca_target!=this) { @@ -1771,7 +1771,7 @@ void Client::DoClassAttacks(Mob *ca_target, uint16 skill, bool IsRiposte) dmg = -5; } else{ - if(!ca_target->CheckHitChance(this, KICK, 0)) { + if(!ca_target->CheckHitChance(this, SkillKick, 0)) { dmg = 0; } else{ @@ -1784,15 +1784,15 @@ void Client::DoClassAttacks(Mob *ca_target, uint16 skill, bool IsRiposte) ReuseTime = KickReuseTime-1; - DoSpecialAttackDamage(ca_target, KICK, dmg, 1,-1, ReuseTime); + DoSpecialAttackDamage(ca_target, SkillKick, dmg, 1,-1, ReuseTime); } } - if(skill_to_use == FLYING_KICK || - skill_to_use == DRAGON_PUNCH || - skill_to_use == EAGLE_STRIKE || - skill_to_use == TIGER_CLAW || - skill_to_use == ROUND_KICK) + if(skill_to_use == SkillFlyingKick || + skill_to_use == SkillDragonPunch || + skill_to_use == SkillEagleStrike || + skill_to_use == SkillTigerClaw || + skill_to_use == SkillRoundKick) { ReuseTime = MonkSpecialAttack(ca_target, skill_to_use) - 1; MonkSpecialAttack(ca_target, skill_to_use); @@ -1804,7 +1804,7 @@ void Client::DoClassAttacks(Mob *ca_target, uint16 skill, bool IsRiposte) uint16 bDoubleSpecialAttack = itembonuses.DoubleSpecialAttack + spellbonuses.DoubleSpecialAttack + aabonuses.DoubleSpecialAttack; if( bDoubleSpecialAttack && (bDoubleSpecialAttack >= 100 || bDoubleSpecialAttack > MakeRandomInt(0,100))) { - int MonkSPA [5] = { FLYING_KICK, DRAGON_PUNCH, EAGLE_STRIKE, TIGER_CLAW, ROUND_KICK }; + int MonkSPA [5] = { SkillFlyingKick, SkillDragonPunch, SkillEagleStrike, SkillTigerClaw, SkillRoundKick }; MonkSpecialAttack(ca_target, MonkSPA[MakeRandomInt(0,4)]); int TripleChance = 25; @@ -1818,7 +1818,7 @@ void Client::DoClassAttacks(Mob *ca_target, uint16 skill, bool IsRiposte) } } - if(skill_to_use == BACKSTAB) + if(skill_to_use == SkillBackstab) { ReuseTime = BackstabReuseTime-1; @@ -1933,7 +1933,7 @@ void Mob::Taunt(NPC* who, bool always_succeed, float chance_bonus) { return; if(!always_succeed && IsClient()) - CastToClient()->CheckIncreaseSkill(TAUNT, who, 10); + CastToClient()->CheckIncreaseSkill(SkillTaunt, who, 10); Mob *hate_top = who->GetHateMost(); @@ -1971,7 +1971,7 @@ void Mob::Taunt(NPC* who, bool always_succeed, float chance_bonus) { //TauntSkillFalloff rate is not based on any real data. Default of 33% gives a reasonable result. if (IsClient() && !always_succeed) - tauntchance -= (RuleR(Combat,TauntSkillFalloff) * (CastToClient()->MaxSkill(TAUNT) - GetSkill(TAUNT))); + tauntchance -= (RuleR(Combat,TauntSkillFalloff) * (CastToClient()->MaxSkill(SkillTaunt) - GetSkill(SkillTaunt))); //From SE_Taunt (Does a taunt with a chance modifier) if (chance_bonus) @@ -2004,7 +2004,7 @@ void Mob::Taunt(NPC* who, bool always_succeed, float chance_bonus) { if (HasSkillProcs()){ float chance = (float)TauntReuseTime*RuleR(Combat, AvgProcsPerMinute)/60000.0f; - TrySkillProc(who, TAUNT, chance); + TrySkillProc(who, SkillTaunt, chance); } } @@ -2026,14 +2026,14 @@ void Mob::InstillDoubt(Mob *who) { if(IsClient()) { - CastToClient()->CheckIncreaseSkill(INTIMIDATION, who, 10); + CastToClient()->CheckIncreaseSkill(SkillIntimidation, who, 10); } //I think this formula needs work int value = 0; //user's bonus - value += GetSkill(INTIMIDATION) + GetCHA()/4; + value += GetSkill(SkillIntimidation) + GetCHA()/4; //target's counters value -= target->GetLevel()*4 + who->GetWIS()/4; @@ -2055,10 +2055,10 @@ void Mob::InstillDoubt(Mob *who) { } } -bool Mob::TryHeadShot(Mob* defender, SkillType skillInUse) { +bool Mob::TryHeadShot(Mob* defender, SkillUseTypes skillInUse) { bool Result = false; - if(defender && skillInUse == ARCHERY) { + if(defender && skillInUse == SkillArchery) { if(GetAA(aaHeadshot) && defender->GetBodyType() == BT_Humanoid) { if((GetLevelCon(GetLevel(), defender->GetLevel()) == CON_LIGHTBLUE || GetLevelCon(GetLevel(), defender->GetLevel()) == CON_GREEN) && defender->GetLevel() <= 60 && !defender->IsClient()) { // WildcardX: These chance formula's below are arbitrary. If someone has a better formula that is more @@ -2081,15 +2081,15 @@ bool Mob::TryHeadShot(Mob* defender, SkillType skillInUse) { return Result; } -void Mob::DoMeleeSkillAttackDmg(Mob* other, uint16 weapon_damage, SkillType skillinuse, int16 chance_mod, int16 focus, bool CanRiposte) +void Mob::DoMeleeSkillAttackDmg(Mob* other, uint16 weapon_damage, SkillUseTypes skillinuse, int16 chance_mod, int16 focus, bool CanRiposte) { if (!CanDoSpecialAttack(other)) return; //For spells using skill value 98 (feral swipe ect) server sets this to 67 automatically. //Kayen: This is unlikely to be completely accurate but use OFFENSE skill value for these effects. - if (skillinuse == BEGGING) - skillinuse = OFFENSE; + if (skillinuse == SkillBegging) + skillinuse = SkillOffense; int damage = 0; uint32 hate = 0; @@ -2151,7 +2151,7 @@ void Mob::DoMeleeSkillAttackDmg(Mob* other, uint16 weapon_damage, SkillType skil else damage = -5; - if(skillinuse == BASH){ + if(skillinuse == SkillBash){ if(IsClient()){ ItemInst *item = CastToClient()->GetInv().GetItem(SLOT_SECONDARY); if(item){ @@ -2167,8 +2167,8 @@ void Mob::DoMeleeSkillAttackDmg(Mob* other, uint16 weapon_damage, SkillType skil other->AddToHateList(this, hate); bool CanSkillProc = true; - if (skillinuse == OFFENSE){ //Hack to allow damage to display. - skillinuse = TIGER_CLAW; //'strike' your opponent - Arbitrary choice for message. + if (skillinuse == SkillOffense){ //Hack to allow damage to display. + skillinuse = SkillTigerClaw; //'strike' your opponent - Arbitrary choice for message. CanSkillProc = false; //Disable skill procs } diff --git a/zone/spell_effects.cpp b/zone/spell_effects.cpp index b43046649..acd041f05 100644 --- a/zone/spell_effects.cpp +++ b/zone/spell_effects.cpp @@ -2113,11 +2113,11 @@ bool Mob::SpellEffect(Mob* caster, uint16 spell_id, float partial) switch(spells[spell_id].skill) { - case THROWING: + case SkillThrowing: caster->DoThrowingAttackDmg(this, nullptr, nullptr, spells[spell_id].base[i],spells[spell_id].base2[i], focus); break; - case ARCHERY: + case SkillArchery: caster->DoArcheryAttackDmg(this, nullptr, nullptr, spells[spell_id].base[i],spells[spell_id].base2[i],focus); break; @@ -3238,11 +3238,11 @@ void Mob::DoBuffTic(uint16 spell_id, int slot, uint32 ticsremaining, uint8 caste double break_chance = 2.0; if(caster) { - break_chance -= (2 * (((double)caster->GetSkill(DIVINATION) + ((double)caster->GetLevel() * 3.0)) / 650.0)); + break_chance -= (2 * (((double)caster->GetSkill(SkillDivination) + ((double)caster->GetLevel() * 3.0)) / 650.0)); } else { - break_chance -= (2 * (((double)GetSkill(DIVINATION) + ((double)GetLevel() * 3.0)) / 650.0)); + break_chance -= (2 * (((double)GetSkill(SkillDivination) + ((double)GetLevel() * 3.0)) / 650.0)); } if(MakeRandomFloat(0.0, 100.0) < break_chance) diff --git a/zone/spells.cpp b/zone/spells.cpp index eab8abf44..68997eec3 100644 --- a/zone/spells.cpp +++ b/zone/spells.cpp @@ -479,16 +479,16 @@ bool Mob::DoCastSpell(uint16 spell_id, uint16 target_id, uint16 slot, uint16 Mob::GetSpecializeSkillValue(uint16 spell_id) const { switch(spells[spell_id].skill) { - case ABJURE: - return(GetSkill(SPECIALIZE_ABJURE)); - case ALTERATION: - return(GetSkill(SPECIALIZE_ALTERATION)); - case CONJURATION: - return(GetSkill(SPECIALIZE_CONJURATION)); - case DIVINATION: - return(GetSkill(SPECIALIZE_DIVINATION)); - case EVOCATION: - return(GetSkill(SPECIALIZE_EVOCATION)); + case SkillAbjuration: + return(GetSkill(SkillSpecializeAbjure)); + case SkillAlteration: + return(GetSkill(SkillSpecializeAlteration)); + case SkillConjuration: + return(GetSkill(SkillSpecializeConjuration)); + case SkillDivination: + return(GetSkill(SkillSpecializeDivination)); + case SkillEvocation: + return(GetSkill(SkillSpecializeEvocation)); default: //wtf... break; @@ -498,20 +498,20 @@ uint16 Mob::GetSpecializeSkillValue(uint16 spell_id) const { void Client::CheckSpecializeIncrease(uint16 spell_id) { switch(spells[spell_id].skill) { - case ABJURE: - CheckIncreaseSkill(SPECIALIZE_ABJURE, nullptr); + case SkillAbjuration: + CheckIncreaseSkill(SkillSpecializeAbjure, nullptr); break; - case ALTERATION: - CheckIncreaseSkill(SPECIALIZE_ALTERATION, nullptr); + case SkillAlteration: + CheckIncreaseSkill(SkillSpecializeAlteration, nullptr); break; - case CONJURATION: - CheckIncreaseSkill(SPECIALIZE_CONJURATION, nullptr); + case SkillConjuration: + CheckIncreaseSkill(SkillSpecializeConjuration, nullptr); break; - case DIVINATION: - CheckIncreaseSkill(SPECIALIZE_DIVINATION, nullptr); + case SkillDivination: + CheckIncreaseSkill(SkillSpecializeDivination, nullptr); break; - case EVOCATION: - CheckIncreaseSkill(SPECIALIZE_EVOCATION, nullptr); + case SkillEvocation: + CheckIncreaseSkill(SkillSpecializeEvocation, nullptr); break; default: //wtf... @@ -522,48 +522,48 @@ void Client::CheckSpecializeIncrease(uint16 spell_id) { void Client::CheckSongSkillIncrease(uint16 spell_id){ switch(spells[spell_id].skill) { - case SINGING: - CheckIncreaseSkill(SINGING, nullptr, -15); + case SkillSinging: + CheckIncreaseSkill(SkillSinging, nullptr, -15); break; - case PERCUSSION_INSTRUMENTS: + case SkillPercussionInstruments: if(this->itembonuses.percussionMod > 0) { - if(GetRawSkill(PERCUSSION_INSTRUMENTS) > 0) // no skill increases if not trained in the instrument - CheckIncreaseSkill(PERCUSSION_INSTRUMENTS, nullptr, -15); + if(GetRawSkill(SkillPercussionInstruments) > 0) // no skill increases if not trained in the instrument + CheckIncreaseSkill(SkillPercussionInstruments, nullptr, -15); else Message_StringID(13,NO_INSTRUMENT_SKILL); // tell the client that they need instrument training } else - CheckIncreaseSkill(SINGING, nullptr, -15); + CheckIncreaseSkill(SkillSinging, nullptr, -15); break; - case STRINGED_INSTRUMENTS: + case SkillStringedInstruments: if(this->itembonuses.stringedMod > 0) { - if(GetRawSkill(STRINGED_INSTRUMENTS) > 0) - CheckIncreaseSkill(STRINGED_INSTRUMENTS, nullptr, -15); + if(GetRawSkill(SkillStringedInstruments) > 0) + CheckIncreaseSkill(SkillStringedInstruments, nullptr, -15); else Message_StringID(13,NO_INSTRUMENT_SKILL); } else - CheckIncreaseSkill(SINGING, nullptr, -15); + CheckIncreaseSkill(SkillSinging, nullptr, -15); break; - case WIND_INSTRUMENTS: + case SkillWindInstruments: if(this->itembonuses.windMod > 0) { - if(GetRawSkill(WIND_INSTRUMENTS) > 0) - CheckIncreaseSkill(WIND_INSTRUMENTS, nullptr, -15); + if(GetRawSkill(SkillWindInstruments) > 0) + CheckIncreaseSkill(SkillWindInstruments, nullptr, -15); else Message_StringID(13,NO_INSTRUMENT_SKILL); } else - CheckIncreaseSkill(SINGING, nullptr, -15); + CheckIncreaseSkill(SkillSinging, nullptr, -15); break; - case BRASS_INSTRUMENTS: + case SkillBrassInstruments: if(this->itembonuses.brassMod > 0) { - if(GetRawSkill(BRASS_INSTRUMENTS) > 0) - CheckIncreaseSkill(BRASS_INSTRUMENTS, nullptr, -15); + if(GetRawSkill(SkillBrassInstruments) > 0) + CheckIncreaseSkill(SkillBrassInstruments, nullptr, -15); else Message_StringID(13,NO_INSTRUMENT_SKILL); } else - CheckIncreaseSkill(SINGING, nullptr, -15); + CheckIncreaseSkill(SkillSinging, nullptr, -15); break; default: break; @@ -904,7 +904,7 @@ void Mob::CastedSpellFinished(uint16 spell_id, uint32 target_id, uint16 slot, channelbonuses += spellbonuses.ChannelChanceSpells + itembonuses.ChannelChanceSpells + aabonuses.ChannelChanceSpells; // max 93% chance at 252 skill - channelchance = 30 + GetSkill(CHANNELING) / 400.0f * 100; + channelchance = 30 + GetSkill(SkillChanneling) / 400.0f * 100; channelchance -= attacked_count * 2; channelchance += channelchance * channelbonuses / 100.0f; } @@ -918,7 +918,7 @@ void Mob::CastedSpellFinished(uint16 spell_id, uint32 target_id, uint16 slot, channelbonuses += spellbonuses.ChannelChanceSpells + itembonuses.ChannelChanceSpells + aabonuses.ChannelChanceSpells; // max 93% chance at 252 skill - channelchance = 30 + GetSkill(CHANNELING) / 400.0f * 100; + channelchance = 30 + GetSkill(SkillChanneling) / 400.0f * 100; channelchance -= attacked_count * 2; channelchance += channelchance * channelbonuses / 100.0f; } @@ -950,7 +950,7 @@ void Mob::CastedSpellFinished(uint16 spell_id, uint32 target_id, uint16 slot, } } - mlog(SPELLS__CASTING, "Checking Interruption: spell x: %f spell y: %f cur x: %f cur y: %f channelchance %f channeling skill %d\n", GetSpellX(), GetSpellY(), GetX(), GetY(), channelchance, GetSkill(CHANNELING)); + mlog(SPELLS__CASTING, "Checking Interruption: spell x: %f spell y: %f cur x: %f cur y: %f channelchance %f channeling skill %d\n", GetSpellX(), GetSpellY(), GetX(), GetY(), channelchance, GetSkill(SkillChanneling)); if(MakeRandomFloat(0, 100) > channelchance) { mlog(SPELLS__CASTING_ERR, "Casting of %d canceled: interrupted.", spell_id); @@ -1239,7 +1239,7 @@ void Mob::CastedSpellFinished(uint16 spell_id, uint32 target_id, uint16 slot, c->CheckIncreaseSkill(spells[spell_id].skill, nullptr); // increased chance of gaining channel skill if you regained concentration - c->CheckIncreaseSkill(CHANNELING, nullptr, regain_conc ? 5 : 0); + c->CheckIncreaseSkill(SkillChanneling, nullptr, regain_conc ? 5 : 0); c->CheckSpecializeIncrease(spell_id); } @@ -2251,7 +2251,7 @@ void Mob::BardPulse(uint16 spell_id, Mob *caster) { action->instrument_mod = caster->GetInstrumentMod(spell_id); action->buff_unknown = 0; action->level = buffs[buffs_i].casterlevel; - action->type = SpellDamageType; + action->type = DamageTypeSpell; entity_list.QueueCloseClients(this, packet, false, 200, 0, true, IsClient() ? FilterPCSpells : FilterNPCSpells); action->buff_unknown = 4; @@ -2317,7 +2317,7 @@ void Mob::BardPulse(uint16 spell_id, Mob *caster) { CombatDamage_Struct *cd = (CombatDamage_Struct *)message_packet->pBuffer; cd->target = action->target; cd->source = action->source; - cd->type = SpellDamageType; + cd->type = DamageTypeSpell; cd->spellid = action->spell; cd->sequence = action->sequence; cd->damage = 0; diff --git a/zone/titles.cpp b/zone/titles.cpp index c2f5a484d..5e2484b39 100644 --- a/zone/titles.cpp +++ b/zone/titles.cpp @@ -51,7 +51,7 @@ bool TitleManager::LoadTitles() while ((row = mysql_fetch_row(result))) { Title.TitleID = atoi(row[0]); - Title.SkillID = (SkillType) atoi(row[1]); + Title.SkillID = (SkillUseTypes) atoi(row[1]); Title.MinSkillValue = atoi(row[2]); Title.MaxSkillValue = atoi(row[3]); Title.MinAAPoints = atoi(row[4]); @@ -193,10 +193,10 @@ bool TitleManager::IsClientEligibleForTitle(Client *c, std::vector:: if(Title->SkillID >= 0) { - if((Title->MinSkillValue >= 0) && (c->GetRawSkill(static_cast(Title->SkillID)) < static_cast(Title->MinSkillValue))) + if((Title->MinSkillValue >= 0) && (c->GetRawSkill(static_cast(Title->SkillID)) < static_cast(Title->MinSkillValue))) return false; - if((Title->MaxSkillValue >= 0) && (c->GetRawSkill(static_cast(Title->SkillID)) > static_cast(Title->MaxSkillValue))) + if((Title->MaxSkillValue >= 0) && (c->GetRawSkill(static_cast(Title->SkillID)) > static_cast(Title->MaxSkillValue))) return false; } diff --git a/zone/tradeskills.cpp b/zone/tradeskills.cpp index ae4f0e7fe..cb1104a2f 100644 --- a/zone/tradeskills.cpp +++ b/zone/tradeskills.cpp @@ -35,7 +35,7 @@ #include "../common/rulesys.h" #include "QuestParserCollection.h" -static const SkillType TradeskillUnknown = _1H_BLUNT; /* an arbitrary non-tradeskill */ +static const SkillUseTypes TradeskillUnknown = Skill1HBlunt; /* an arbitrary non-tradeskill */ void Object::HandleAugmentation(Client* user, const AugmentItem_Struct* in_augment, Object *worldo) { @@ -315,7 +315,7 @@ void Object::HandleCombine(Client* user, const NewCombine_Struct* in_combine, Ob } //changing from a switch to string of if's since we don't need to iterate through all of the skills in the SkillType enum - if (spec.tradeskill == ALCHEMY) { + if (spec.tradeskill == SkillAlchemy) { if (user_pp.class_ != SHAMAN) { user->Message(13, "This tradeskill can only be performed by a shaman."); return; @@ -325,13 +325,13 @@ void Object::HandleCombine(Client* user, const NewCombine_Struct* in_combine, Ob return; } } - else if (spec.tradeskill == TINKERING) { + else if (spec.tradeskill == SkillTinkering) { if (user_pp.race != GNOME) { user->Message(13, "Only gnomes can tinker."); return; } } - else if (spec.tradeskill == MAKE_POISON) { + else if (spec.tradeskill == SkillMakePoison) { if (user_pp.class_ != ROGUE) { user->Message(13, "Only rogues can mix poisons."); return; @@ -576,18 +576,18 @@ void Object::HandleAutoCombine(Client* user, const RecipeAutoCombine_Struct* rac parse->EventPlayer(EVENT_COMBINE_FAILURE, user, spec.name.c_str(), spec.recipe_id); } -SkillType Object::TypeToSkill(uint32 type) +SkillUseTypes Object::TypeToSkill(uint32 type) { - switch(type) // grouped and ordered by SkillType name - new types need to be verified for proper SkillType and use + switch(type) // grouped and ordered by SkillUseTypes name - new types need to be verified for proper SkillUseTypes and use { - /*ALCHEMY*/ - case BagTypeMedicineBag: { return (SkillType)ALCHEMY; } +/*SkillAlchemy*/ + case BagTypeMedicineBag: { return SkillAlchemy; } - /*BAKING*/ - // case BagType_MixingBowl: // No idea... - case BagTypeOven: { return (SkillType)BAKING; } +/*SkillBaking*/ + // case BagTypeMixingBowl: // No idea... + case BagTypeOven: { return SkillBaking; } - /*BLACKSMITHING*/ +/*SkillBlacksmithing*/ case BagTypeForge: // case BagTypeKoadaDalForge: case BagTypeTeirDalForge: @@ -600,51 +600,51 @@ SkillType Object::TypeToSkill(uint32 type) // case BagTypeRoyalQeynosForge: // case BagTypeTrollForge: case BagTypeFierDalForge: - case BagTypeValeForge: { return (SkillType)BLACKSMITHING; } // Delete return if BagTypeGuktaForge enabled + case BagTypeValeForge: { return SkillBlacksmithing; } // Delete return if BagTypeGuktaForge enabled // case BagTypeErudForge: - // case BagTypeGuktaForge: { return (SkillType)BLACKSMITHING; } + // case BagTypeGuktaForge: { return SkillBlacksmithing; } - /*BREWING*/ +/*SkillBrewing*/ // case BagTypeIceCreamChurn: // No idea... - case BagTypeBrewBarrel: { return (SkillType)BREWING; } + case BagTypeBrewBarrel: { return SkillBrewing; } - /*FISHING*/ - case BagTypeTackleBox: { return (SkillType)FISHING; } +/*SkillFishing*/ + case BagTypeTackleBox: { return SkillFishing; } - /*FLETCHING*/ - case BagTypeFletchingKit: { return (SkillType)FLETCHING; } // Delete return if BagTypeFierDalFletchingKit enabled - // case BagTypeFierDalFletchingKit: { return (SkillType)FLETCHING; } +/*SkillFletching*/ + case BagTypeFletchingKit: { return SkillFletching; } // Delete return if BagTypeFierDalFletchingKit enabled + // case BagTypeFierDalFletchingKit: { return SkillFletching; } - /*JEWELRY_MAKING*/ - case BagTypeJewelersKit: { return (SkillType)JEWELRY_MAKING; } +/*SkillJewelryMaking*/ + case BagTypeJewelersKit: { return SkillJewelryMaking; } - /*MAKE_POISON*/ - // This is a guess and needs to be verified... (Could be ALCHEMY) - // case BagTypeMortar: { return (SkillType)MAKE_POISON; } +/*SkillMakePoison*/ + // This is a guess and needs to be verified... (Could be SkillAlchemy) + // case BagTypeMortar: { return SkillMakePoison; } - /*POTTERY*/ +/*SkillPottery*/ case BagTypePotteryWheel: - case BagTypeKiln: { return (SkillType)POTTERY; } // Delete return if BagTypeIksarPotteryWheel enabled - // case BagTypeIksarPotteryWheel: { return (SkillType)POTTERY; } + case BagTypeKiln: { return SkillPottery; } // Delete return if BagTypeIksarPotteryWheel enabled + // case BagTypeIksarPotteryWheel: { return SkillPottery; } - /*RESEARCH*/ +/*SkillResearch*/ // case BagTypeLexicon: case BagTypeWizardsLexicon: case BagTypeMagesLexicon: case BagTypeNecromancersLexicon: - case BagTypeEnchantersLexicon: { return (SkillType)RESEARCH; } // Delete return if BagTypeConcordanceofResearch enabled - // case BagTypeConcordanceofResearch: { return (SkillType)RESEARCH; } + case BagTypeEnchantersLexicon: { return SkillResearch; } // Delete return if BagTypeConcordanceofResearch enabled + // case BagTypeConcordanceofResearch: { return SkillResearch; } - /*TAILORING*/ - case BagTypeSewingKit: { return (SkillType)TAILORING; } // Delete return if BagTypeFierDalTailoringKit enabled +/*SkillTailoring*/ + case BagTypeSewingKit: { return SkillTailoring; } // Delete return if BagTypeFierDalTailoringKit enabled // case BagTypeHalflingTailoringKit: // case BagTypeErudTailoringKit: - // case BagTypeFierDalTailoringKit: { return (SkillType)TAILORING; } + // case BagTypeFierDalTailoringKit: { return SkillTailoring; } - /*TINKERING*/ - case BagTypeToolBox: { return (SkillType)TINKERING; } +/*SkillTinkering*/ + case BagTypeToolBox: { return SkillTinkering; } - /*Undefined*/ +/*Undefined*/ default: { break; } } @@ -689,7 +689,7 @@ void Client::TradeskillSearchResults(const char *query, unsigned long qlen, unsi // Recipes that have either been made before or were // explicitly learned are excempt from that limit if (RuleB(Skills, UseLimitTradeskillSearchSkillDiff)) { - if (((int32)trivial - (int32)GetSkill((SkillType)tradeskill)) > RuleI(Skills, MaxTradeskillSearchSkillDiff) + if (((int32)trivial - (int32)GetSkill((SkillUseTypes)tradeskill)) > RuleI(Skills, MaxTradeskillSearchSkillDiff) && row[4] == nullptr) { continue; @@ -855,17 +855,17 @@ bool Client::TradeskillExecute(DBTradeskillRecipe_Struct *spec) { // If you want to customize the stage1 success rate do it here. // Remember: skillup_modifier is (float). Lower is better switch(spec->tradeskill) { - case FLETCHING: - case ALCHEMY: - case JEWELRY_MAKING: - case POTTERY: + case SkillFletching: + case SkillAlchemy: + case SkillJewelryMaking: + case SkillPottery: skillup_modifier = 4; break; - case BAKING: - case BREWING: + case SkillBaking: + case SkillBrewing: skillup_modifier = 3; break; - case RESEARCH: + case SkillResearch: skillup_modifier = 1; break; default: @@ -876,10 +876,10 @@ bool Client::TradeskillExecute(DBTradeskillRecipe_Struct *spec) { // Some tradeskills take the higher of one additional stat beside INT and WIS // to determine the skillup rate. Additionally these tradeskills do not have an // -15 modifier on their statbonus. - if (spec->tradeskill == FLETCHING || spec->tradeskill == MAKE_POISON) { + if (spec->tradeskill == SkillFletching || spec->tradeskill == SkillMakePoison) { thirdstat = GetDEX(); stat_modifier = 0; - } else if (spec->tradeskill == BLACKSMITHING) { + } else if (spec->tradeskill == SkillBlacksmithing) { thirdstat = GetSTR(); stat_modifier = 0; } @@ -932,7 +932,7 @@ bool Client::TradeskillExecute(DBTradeskillRecipe_Struct *spec) { //AA modifiers //can we do this with nested switches? - if(spec->tradeskill == ALCHEMY){ + if(spec->tradeskill == SkillAlchemy){ switch(GetAA(aaAlchemyMastery)){ case 1: AAChance = 10; @@ -946,7 +946,7 @@ bool Client::TradeskillExecute(DBTradeskillRecipe_Struct *spec) { } } - if(spec->tradeskill == JEWELRY_MAKING){ + if(spec->tradeskill == SkillJewelryMaking){ switch(GetAA(aaJewelCraftMastery)){ case 1: AAChance = 10; @@ -961,7 +961,7 @@ bool Client::TradeskillExecute(DBTradeskillRecipe_Struct *spec) { } const Item_Struct* item = nullptr; - if (spec->tradeskill == BLACKSMITHING) { + if (spec->tradeskill == SkillBlacksmithing) { switch(GetAA(aaBlacksmithingMastery)) { case 1: AAChance = 10; @@ -975,7 +975,7 @@ bool Client::TradeskillExecute(DBTradeskillRecipe_Struct *spec) { } } - if (spec->tradeskill == BAKING) { + if (spec->tradeskill == SkillBaking) { switch(GetAA(aaBakingMastery)) { case 1: AAChance = 10; @@ -989,7 +989,7 @@ bool Client::TradeskillExecute(DBTradeskillRecipe_Struct *spec) { } } - if (spec->tradeskill == BREWING) { + if (spec->tradeskill == SkillBrewing) { switch(GetAA(aaBrewingMastery)) { case 1: AAChance = 10; @@ -1003,7 +1003,7 @@ bool Client::TradeskillExecute(DBTradeskillRecipe_Struct *spec) { } } - if (spec->tradeskill == FLETCHING) { + if (spec->tradeskill == SkillFletching) { switch(GetAA(aaFletchingMastery2)) { case 1: AAChance = 10; @@ -1017,7 +1017,7 @@ bool Client::TradeskillExecute(DBTradeskillRecipe_Struct *spec) { } } - if (spec->tradeskill == POTTERY) { + if (spec->tradeskill == SkillPottery) { switch(GetAA(aaPotteryMastery)) { case 1: AAChance = 10; @@ -1031,7 +1031,7 @@ bool Client::TradeskillExecute(DBTradeskillRecipe_Struct *spec) { } } - if (spec->tradeskill == TAILORING) { + if (spec->tradeskill == SkillTailoring) { switch(GetAA(aaTailoringMastery)) { case 1: AAChance = 10; @@ -1045,7 +1045,7 @@ bool Client::TradeskillExecute(DBTradeskillRecipe_Struct *spec) { } } - if (spec->tradeskill == RESEARCH) { + if (spec->tradeskill == SkillResearch) { switch(GetAA(aaArcaneTongues)) { case 1: AAChance = 10; @@ -1124,7 +1124,7 @@ bool Client::TradeskillExecute(DBTradeskillRecipe_Struct *spec) { return(false); } -void Client::CheckIncreaseTradeskill(int16 bonusstat, int16 stat_modifier, float skillup_modifier, uint16 success_modifier, SkillType tradeskill) +void Client::CheckIncreaseTradeskill(int16 bonusstat, int16 stat_modifier, float skillup_modifier, uint16 success_modifier, SkillUseTypes tradeskill) { uint16 current_raw_skill = GetRawSkill(tradeskill); @@ -1405,7 +1405,7 @@ bool ZoneDatabase::GetTradeRecipe(uint32 recipe_id, uint8 c_type, uint32 some_id } row = mysql_fetch_row(result); - spec->tradeskill = (SkillType)atoi(row[1]); + spec->tradeskill = (SkillUseTypes)atoi(row[1]); spec->skill_needed = (int16)atoi(row[2]); spec->trivial = (uint16)atoi(row[3]); spec->nofail = atoi(row[4]) ? true : false; @@ -1559,31 +1559,31 @@ void Client::LearnRecipe(uint32 recipeID) } -bool Client::CanIncreaseTradeskill(SkillType tradeskill) { +bool Client::CanIncreaseTradeskill(SkillUseTypes tradeskill) { uint32 rawskill = GetRawSkill(tradeskill); uint16 maxskill = MaxSkill(tradeskill); if (rawskill >= maxskill) //Max skill sanity check return false; - uint8 Baking = (GetRawSkill(BAKING) > 200) ? 1 : 0; - uint8 Smithing = (GetRawSkill(BLACKSMITHING) > 200) ? 1 : 0; - uint8 Brewing = (GetRawSkill(BREWING) > 200) ? 1 : 0; - uint8 Fletching = (GetRawSkill(FLETCHING) > 200) ? 1 : 0; - uint8 Jewelry = (GetRawSkill(JEWELRY_MAKING) > 200) ? 1 : 0; - uint8 Pottery = (GetRawSkill(POTTERY) > 200) ? 1 : 0; - uint8 Tailoring = (GetRawSkill(TAILORING) > 200) ? 1 : 0; + uint8 Baking = (GetRawSkill(SkillBaking) > 200) ? 1 : 0; + uint8 Smithing = (GetRawSkill(SkillBlacksmithing) > 200) ? 1 : 0; + uint8 Brewing = (GetRawSkill(SkillBrewing) > 200) ? 1 : 0; + uint8 Fletching = (GetRawSkill(SkillFletching) > 200) ? 1 : 0; + uint8 Jewelry = (GetRawSkill(SkillJewelryMaking) > 200) ? 1 : 0; + uint8 Pottery = (GetRawSkill(SkillPottery) > 200) ? 1 : 0; + uint8 Tailoring = (GetRawSkill(SkillTailoring) > 200) ? 1 : 0; uint8 SkillTotal = Baking + Smithing + Brewing + Fletching + Jewelry + Pottery + Tailoring; //Tradeskills above 200 uint32 aaLevel = GetAA(aaNewTanaanCraftingMastery); //New Tanaan AA: Each level allows an additional tradeskill above 200 (first one is free) switch (tradeskill) { - case BAKING: - case BLACKSMITHING: - case BREWING: - case FLETCHING: - case JEWELRY_MAKING: - case POTTERY: - case TAILORING: + case SkillBaking: + case SkillBlacksmithing: + case SkillBrewing: + case SkillFletching: + case SkillJewelryMaking: + case SkillPottery: + case SkillTailoring: if (aaLevel == 6) break; //Maxed AA if (SkillTotal == 0) diff --git a/zone/zonedb.h b/zone/zonedb.h index 60ed0e65e..42e9e52be 100644 --- a/zone/zonedb.h +++ b/zone/zonedb.h @@ -39,7 +39,7 @@ struct DBnpcspells_Struct { }; struct DBTradeskillRecipe_Struct { - SkillType tradeskill; + SkillUseTypes tradeskill; int16 skill_needed; uint16 trivial; bool nofail;