pa/eqemu-server
2
0
Fork 0
mirror of https://github.com/EQEmu/Server.git synced 2025-12-11 21:01:29 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

Converted SkillType typedef enumeration to SkillUseTypes enumeration

Browse Source
This commit is contained in:
Uleat 2013-10-27 13:03:41 -04:00
parent 3e6be197e6
commit e3805d5920
43 changed files with 1119 additions and 949 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
changelog.txt
View File

@ -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

170
common/eq_constants.h
View File

@ -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)
};
/*

8
common/shareddb.cpp
View File

@ -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]);

4
common/shareddb.h
View File

@ -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);

162
common/skills.h
View File

@ -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

2
common/spdat.h
View File

@ -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;

52
world/client.cpp
View File

@ -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;
}
}

2
zone/AA.cpp
View File

@ -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;

4
zone/MobAI.cpp
View File

@ -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);

139
zone/attack.cpp
View File

@ -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<SkillType>(GetPrimSkill());
skillinuse = static_cast<SkillUseTypes>(GetPrimSkill());
OffHandAtk(false);
}
if (Hand == 14) {
skillinuse = static_cast<SkillType>(GetSecSkill());
skillinuse = static_cast<SkillUseTypes>(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<SkillType>(36);
skillinuse = static_cast<SkillUseTypes>(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)
{

4
zone/beacon.h
View File

@ -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; }

200
zone/bot.cpp
View File

@ -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);
}
}

20
zone/bot.h
View File

@ -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();

72
zone/client.cpp
View File

@ -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<uint64>(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<std::string, SkillType> Skills;
std::map<std::string, SkillType>::iterator it;
std::map<std::string, SkillUseTypes> Skills;
std::map<std::string, SkillUseTypes>::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++) {

38
zone/client.h
View File

@ -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);

42
zone/client_mods.cpp
View File

@ -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);

102
zone/client_packet.cpp
View File

@ -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;

50
zone/client_process.cpp
View File

@ -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;

30
zone/command.cpp
View File

@ -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.");

4
zone/corpse.h
View File

@ -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; }

6
zone/doors.cpp
View File

@ -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);

6
zone/entity.cpp
View File

@ -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)

12
zone/forage.cpp
View File

@ -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);
}

16
zone/lua_client.cpp
View File

@ -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<SkillType>(skill_id));
return self->GetRawSkill(static_cast<SkillUseTypes>(skill_id));
}
bool Lua_Client::HasSkill(int skill_id) {
Lua_Safe_Call_Bool();
return self->HasSkill(static_cast<SkillType>(skill_id));
return self->HasSkill(static_cast<SkillUseTypes>(skill_id));
}
bool Lua_Client::CanHaveSkill(int skill_id) {
Lua_Safe_Call_Bool();
return self->CanHaveSkill(static_cast<SkillType>(skill_id));
return self->CanHaveSkill(static_cast<SkillUseTypes>(skill_id));
}
void Lua_Client::SetSkill(int skill_id, int value) {
Lua_Safe_Call_Void();
self->SetSkill(static_cast<SkillType>(skill_id), value);
self->SetSkill(static_cast<SkillUseTypes>(skill_id), value);
}
void Lua_Client::AddSkill(int skill_id, int value) {
Lua_Safe_Call_Void();
self->AddSkill(static_cast<SkillType>(skill_id), value);
self->AddSkill(static_cast<SkillUseTypes>(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<SkillType>(skill_id), target);
self->CheckIncreaseSkill(static_cast<SkillUseTypes>(skill_id), target);
}
void Lua_Client::CheckIncreaseSkill(int skill_id, Lua_Mob target, int chance_mod) {
Lua_Safe_Call_Void();
self->CheckIncreaseSkill(static_cast<SkillType>(skill_id), target, chance_mod);
self->CheckIncreaseSkill(static_cast<SkillUseTypes>(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<SkillType>(skill_id));
return self->MaxSkill(static_cast<SkillUseTypes>(skill_id));
}
bool Lua_Client::IsMedding() {

34
zone/lua_mob.cpp
View File

@ -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<SkillType>(attack_skill));
return self->Damage(from, damage, spell_id, static_cast<SkillUseTypes>(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<SkillType>(attack_skill), avoidable);
return self->Damage(from, damage, spell_id, static_cast<SkillUseTypes>(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<SkillType>(attack_skill), avoidable, buffslot);
return self->Damage(from, damage, spell_id, static_cast<SkillUseTypes>(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<SkillType>(attack_skill), avoidable, buffslot, buff_tic);
return self->Damage(from, damage, spell_id, static_cast<SkillUseTypes>(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<SkillType>(skill), max_damage);
self->DoSpecialAttackDamage(other, static_cast<SkillUseTypes>(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<SkillType>(skill), max_damage, min_damage);
self->DoSpecialAttackDamage(other, static_cast<SkillUseTypes>(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<SkillType>(skill), max_damage, min_damage, hate_override);
self->DoSpecialAttackDamage(other, static_cast<SkillUseTypes>(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<SkillType>(skill), max_damage, min_damage, hate_override, reuse_time);
self->DoSpecialAttackDamage(other, static_cast<SkillUseTypes>(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<SkillType>(skill), max_damage, min_damage, hate_override, reuse_time, hit_chance);
self->DoSpecialAttackDamage(other, static_cast<SkillUseTypes>(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<SkillType>(skill));
self->DoMeleeSkillAttackDmg(other, weapon_damage, static_cast<SkillUseTypes>(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<SkillType>(skill), chance_mod);
self->DoMeleeSkillAttackDmg(other, weapon_damage, static_cast<SkillUseTypes>(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<SkillType>(skill), chance_mod, focus);
self->DoMeleeSkillAttackDmg(other, weapon_damage, static_cast<SkillUseTypes>(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<SkillType>(skill), chance_mod, focus, can_riposte);
self->DoMeleeSkillAttackDmg(other, weapon_damage, static_cast<SkillUseTypes>(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<SkillType>(skill), value);
self->ModSkillDmgTaken(static_cast<SkillUseTypes>(skill), value);
}
int Lua_Mob::GetModSkillDmgTaken(int skill) {
Lua_Safe_Call_Int();
return self->GetModSkillDmgTaken(static_cast<SkillType>(skill));
return self->GetModSkillDmgTaken(static_cast<SkillUseTypes>(skill));
}
int Lua_Mob::GetSkillDmgTaken(int skill) {
Lua_Safe_Call_Int();
return self->GetSkillDmgTaken(static_cast<SkillType>(skill));
return self->GetSkillDmgTaken(static_cast<SkillUseTypes>(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<SkillType>(skill));
return self->GetSkill(static_cast<SkillUseTypes>(skill));
}
int Lua_Mob::GetSpecialAbility(int ability) {

32
zone/merc.cpp
View File

@ -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;

12
zone/merc.h
View File

@ -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();

50
zone/mob.cpp
View File

@ -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;
}

36
zone/mob.h
View File

@ -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);

10
zone/mod_functions.cpp
View File

@ -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); }

6
zone/npc.cpp
View File

@ -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;

8
zone/npc.h
View File

@ -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);

2
zone/object.h
View File

@ -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);

16
zone/perl_client.cpp
View File

@ -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;

14
zone/perl_mob.cpp
View File

@ -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));

10
zone/questmgr.cpp
View File

@ -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) {

152
zone/skills.h
View File

@ -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

288
zone/special_attacks.cpp
View File

@ -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
}

8
zone/spell_effects.cpp
View File

@ -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)

88
zone/spells.cpp
View File

@ -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;

6
zone/titles.cpp
View File

@ -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<TitleEntry>::
if(Title->SkillID >= 0)
{
if((Title->MinSkillValue >= 0) && (c->GetRawSkill(static_cast<SkillType>(Title->SkillID)) < static_cast<uint32>(Title->MinSkillValue)))
if((Title->MinSkillValue >= 0) && (c->GetRawSkill(static_cast<SkillUseTypes>(Title->SkillID)) < static_cast<uint32>(Title->MinSkillValue)))
return false;
if((Title->MaxSkillValue >= 0) && (c->GetRawSkill(static_cast<SkillType>(Title->SkillID)) > static_cast<uint32>(Title->MaxSkillValue)))
if((Title->MaxSkillValue >= 0) && (c->GetRawSkill(static_cast<SkillUseTypes>(Title->SkillID)) > static_cast<uint32>(Title->MaxSkillValue)))
return false;
}

148
zone/tradeskills.cpp
View File

@ -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)

2
zone/zonedb.h
View File

@ -39,7 +39,7 @@ struct DBnpcspells_Struct {
};
struct DBTradeskillRecipe_Struct {
SkillType tradeskill;
SkillUseTypes tradeskill;
int16 skill_needed;
uint16 trivial;
bool nofail;