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

Renamed and moved SkillUseTypes enumeration to EQEmu::skills::SkillType; eq_dictionary work

Browse Source
This commit is contained in:
Uleat
2016-05-25 18:50:26 -04:00
parent 615158e701
commit 71f128731f
86 changed files with 4987 additions and 3074 deletions
Download Patch File Download Diff File Expand all files Collapse all files
zone/attack.cpp
+89 -89
View File
@@ -50,7 +50,7 @@ extern WorldServer worldserver;
extern EntityList entity_list;
extern Zone* zone;
bool Mob::AttackAnimation(SkillUseTypes &skillinuse, int Hand, const ItemInst* weapon)
bool Mob::AttackAnimation(EQEmu::skills::SkillType &skillinuse, int Hand, const ItemInst* weapon)
{
// Determine animation
int type = 0;
@@ -61,63 +61,63 @@ bool Mob::AttackAnimation(SkillUseTypes &skillinuse, int Hand, const ItemInst* w
switch (item->ItemType) {
case EQEmu::item::ItemType1HSlash: // 1H Slashing
skillinuse = Skill1HSlashing;
skillinuse = EQEmu::skills::Skill1HSlashing;
type = anim1HWeapon;
break;
case EQEmu::item::ItemType2HSlash: // 2H Slashing
skillinuse = Skill2HSlashing;
skillinuse = EQEmu::skills::Skill2HSlashing;
type = anim2HSlashing;
break;
case EQEmu::item::ItemType1HPiercing: // Piercing
skillinuse = Skill1HPiercing;
skillinuse = EQEmu::skills::Skill1HPiercing;
type = anim1HPiercing;
break;
case EQEmu::item::ItemType1HBlunt: // 1H Blunt
skillinuse = Skill1HBlunt;
skillinuse = EQEmu::skills::Skill1HBlunt;
type = anim1HWeapon;
break;
case EQEmu::item::ItemType2HBlunt: // 2H Blunt
skillinuse = Skill2HBlunt;
skillinuse = EQEmu::skills::Skill2HBlunt;
type = anim2HSlashing; //anim2HWeapon
break;
case EQEmu::item::ItemType2HPiercing: // 2H Piercing
if (IsClient() && CastToClient()->ClientVersion() < EQEmu::versions::ClientVersion::RoF2)
skillinuse = Skill1HPiercing;
skillinuse = EQEmu::skills::Skill1HPiercing;
else
skillinuse = Skill2HPiercing;
skillinuse = EQEmu::skills::Skill2HPiercing;
type = anim2HWeapon;
break;
case EQEmu::item::ItemTypeMartial:
skillinuse = SkillHandtoHand;
skillinuse = EQEmu::skills::SkillHandtoHand;
type = animHand2Hand;
break;
default:
skillinuse = SkillHandtoHand;
skillinuse = EQEmu::skills::SkillHandtoHand;
type = animHand2Hand;
break;
}// switch
}
else if(IsNPC()) {
switch (skillinuse) {
case Skill1HSlashing: // 1H Slashing
case EQEmu::skills::Skill1HSlashing: // 1H Slashing
type = anim1HWeapon;
break;
case Skill2HSlashing: // 2H Slashing
case EQEmu::skills::Skill2HSlashing: // 2H Slashing
type = anim2HSlashing;
break;
case Skill1HPiercing: // Piercing
case EQEmu::skills::Skill1HPiercing: // Piercing
type = anim1HPiercing;
break;
case Skill1HBlunt: // 1H Blunt
case EQEmu::skills::Skill1HBlunt: // 1H Blunt
type = anim1HWeapon;
break;
case Skill2HBlunt: // 2H Blunt
case EQEmu::skills::Skill2HBlunt: // 2H Blunt
type = anim2HSlashing; //anim2HWeapon
break;
case Skill2HPiercing: // 2H Piercing
case EQEmu::skills::Skill2HPiercing: // 2H Piercing
type = anim2HWeapon;
break;
case SkillHandtoHand:
case EQEmu::skills::SkillHandtoHand:
type = animHand2Hand;
break;
default:
@@ -126,7 +126,7 @@ bool Mob::AttackAnimation(SkillUseTypes &skillinuse, int Hand, const ItemInst* w
}// switch
}
else {
skillinuse = SkillHandtoHand;
skillinuse = EQEmu::skills::SkillHandtoHand;
type = animHand2Hand;
}
@@ -140,7 +140,7 @@ bool Mob::AttackAnimation(SkillUseTypes &skillinuse, int Hand, const ItemInst* w
// 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, SkillUseTypes skillinuse, int Hand, int16 chance_mod)
bool Mob::CheckHitChance(Mob* other, EQEmu::skills::SkillType skillinuse, int Hand, int16 chance_mod)
{
/*/
//Reworked a lot of this code to achieve better balance at higher levels.
@@ -218,7 +218,7 @@ bool Mob::CheckHitChance(Mob* other, SkillUseTypes skillinuse, int Hand, int16 c
if(defender->IsClient())
{
chancetohit += (RuleR(Combat,WeaponSkillFalloff) * (defender->CastToClient()->MaxSkill(SkillDefense) - defender->GetSkill(SkillDefense)));
chancetohit += (RuleR(Combat, WeaponSkillFalloff) * (defender->CastToClient()->MaxSkill(EQEmu::skills::SkillDefense) - defender->GetSkill(EQEmu::skills::SkillDefense)));
Log.Out(Logs::Detail, Logs::Attack, "Chance to hit after weapon falloff calc (defense) %.2f", chancetohit);
}
@@ -254,15 +254,15 @@ bool Mob::CheckHitChance(Mob* other, SkillUseTypes skillinuse, int Hand, int16 c
hitBonus += attacker->itembonuses.HitChanceEffect[skillinuse] +
attacker->spellbonuses.HitChanceEffect[skillinuse]+
attacker->aabonuses.HitChanceEffect[skillinuse]+
attacker->itembonuses.HitChanceEffect[HIGHEST_SKILL+1] +
attacker->spellbonuses.HitChanceEffect[HIGHEST_SKILL+1] +
attacker->aabonuses.HitChanceEffect[HIGHEST_SKILL+1];
attacker->itembonuses.HitChanceEffect[EQEmu::skills::HIGHEST_SKILL + 1] +
attacker->spellbonuses.HitChanceEffect[EQEmu::skills::HIGHEST_SKILL + 1] +
attacker->aabonuses.HitChanceEffect[EQEmu::skills::HIGHEST_SKILL + 1];
//Accuracy = Spell Effect , HitChance = 'Accuracy' from Item Effect
//Only AA derived accuracy can be skill limited. ie (Precision of the Pathfinder, Dead Aim)
hitBonus += (attacker->itembonuses.Accuracy[HIGHEST_SKILL+1] +
attacker->spellbonuses.Accuracy[HIGHEST_SKILL+1] +
attacker->aabonuses.Accuracy[HIGHEST_SKILL+1] +
hitBonus += (attacker->itembonuses.Accuracy[EQEmu::skills::HIGHEST_SKILL + 1] +
attacker->spellbonuses.Accuracy[EQEmu::skills::HIGHEST_SKILL + 1] +
attacker->aabonuses.Accuracy[EQEmu::skills::HIGHEST_SKILL + 1] +
attacker->aabonuses.Accuracy[skillinuse] +
attacker->itembonuses.HitChance) / 15.0f; //Item Mod 'Accuracy'
@@ -271,7 +271,7 @@ bool Mob::CheckHitChance(Mob* other, SkillUseTypes skillinuse, int Hand, int16 c
if(attacker->IsNPC())
hitBonus += (attacker->CastToNPC()->GetAccuracyRating() / 10.0f); //Modifier from database
if(skillinuse == SkillArchery)
if (skillinuse == EQEmu::skills::SkillArchery)
hitBonus -= hitBonus*RuleR(Combat, ArcheryHitPenalty);
//Calculate final chance to hit
@@ -382,13 +382,13 @@ bool Mob::AvoidDamage(Mob *other, int32 &damage, int hand)
// Need to check if we have something in MainHand to actually attack with (or fists)
if (hand != EQEmu::legacy::SlotRange && CanThisClassRiposte() && InFront && !ImmuneRipo) {
if (IsClient())
CastToClient()->CheckIncreaseSkill(SkillRiposte, other, -10);
CastToClient()->CheckIncreaseSkill(EQEmu::skills::SkillRiposte, other, -10);
// check auto discs ... I guess aa/items too :P
if (spellbonuses.RiposteChance == 10000 || aabonuses.RiposteChance == 10000 || itembonuses.RiposteChance == 10000) {
damage = -3;
return true;
}
int chance = GetSkill(SkillRiposte) + 100;
int chance = GetSkill(EQEmu::skills::SkillRiposte) + 100;
chance += (chance * (aabonuses.RiposteChance + spellbonuses.RiposteChance + itembonuses.RiposteChance)) / 100;
chance /= 50;
chance += itembonuses.HeroicDEX / 25; // live has "heroic strickthrough" here to counter
@@ -420,14 +420,14 @@ bool Mob::AvoidDamage(Mob *other, int32 &damage, int hand)
if (CanThisClassBlock() && (InFront || bBlockFromRear)) {
if (IsClient())
CastToClient()->CheckIncreaseSkill(SkillBlock, other, -10);
CastToClient()->CheckIncreaseSkill(EQEmu::skills::SkillBlock, other, -10);
// check auto discs ... I guess aa/items too :P
if (spellbonuses.IncreaseBlockChance == 10000 || aabonuses.IncreaseBlockChance == 10000 ||
itembonuses.IncreaseBlockChance == 10000) {
damage = -1;
return true;
}
int chance = GetSkill(SkillBlock) + 100;
int chance = GetSkill(EQEmu::skills::SkillBlock) + 100;
chance += (chance * (aabonuses.IncreaseBlockChance + spellbonuses.IncreaseBlockChance + itembonuses.IncreaseBlockChance)) / 100;
chance /= 25;
chance += itembonuses.HeroicDEX / 25; // live has "heroic strickthrough" here to counter
@@ -444,13 +444,13 @@ bool Mob::AvoidDamage(Mob *other, int32 &damage, int hand)
// parry
if (CanThisClassParry() && InFront && hand != EQEmu::legacy::SlotRange) {
if (IsClient())
CastToClient()->CheckIncreaseSkill(SkillParry, other, -10);
CastToClient()->CheckIncreaseSkill(EQEmu::skills::SkillParry, other, -10);
// check auto discs ... I guess aa/items too :P
if (spellbonuses.ParryChance == 10000 || aabonuses.ParryChance == 10000 || itembonuses.ParryChance == 10000) {
damage = -2;
return true;
}
int chance = GetSkill(SkillParry) + 100;
int chance = GetSkill(EQEmu::skills::SkillParry) + 100;
chance += (chance * (aabonuses.ParryChance + spellbonuses.ParryChance + itembonuses.ParryChance)) / 100;
chance /= 45;
chance += itembonuses.HeroicDEX / 25; // live has "heroic strickthrough" here to counter
@@ -467,13 +467,13 @@ bool Mob::AvoidDamage(Mob *other, int32 &damage, int hand)
// dodge
if (CanThisClassDodge() && (InFront || GetClass() == MONK) ) {
if (IsClient())
CastToClient()->CheckIncreaseSkill(SkillDodge, other, -10);
CastToClient()->CheckIncreaseSkill(EQEmu::skills::SkillDodge, other, -10);
// check auto discs ... I guess aa/items too :P
if (spellbonuses.DodgeChance == 10000 || aabonuses.DodgeChance == 10000 || itembonuses.DodgeChance == 10000) {
damage = -4;
return true;
}
int chance = GetSkill(SkillDodge) + 100;
int chance = GetSkill(EQEmu::skills::SkillDodge) + 100;
chance += (chance * (aabonuses.DodgeChance + spellbonuses.DodgeChance + itembonuses.DodgeChance)) / 100;
chance /= 45;
chance += itembonuses.HeroicAGI / 25; // live has "heroic strickthrough" here to counter
@@ -525,7 +525,7 @@ void Mob::MeleeMitigation(Mob *attacker, int32 &damage, int32 minhit, ExtraAttac
spellbonuses.CombatStability) / 100.0f;
if (RuleB(Combat, UseIntervalAC)) {
float softcap = (GetSkill(SkillDefense) + GetLevel()) *
float softcap = (GetSkill(EQEmu::skills::SkillDefense) + GetLevel()) *
RuleR(Combat, SoftcapFactor) * (1.0 + aa_mit);
float mitigation_rating = 0.0;
float attack_rating = 0.0;
@@ -625,17 +625,17 @@ void Mob::MeleeMitigation(Mob *attacker, int32 &damage, int32 minhit, ExtraAttac
if (GetClass() == WIZARD || GetClass() == MAGICIAN ||
GetClass() == NECROMANCER || GetClass() == ENCHANTER)
mitigation_rating = ((GetSkill(SkillDefense) + itembonuses.HeroicAGI/10) / 4.0) + armor + 1;
mitigation_rating = ((GetSkill(EQEmu::skills::SkillDefense) + itembonuses.HeroicAGI / 10) / 4.0) + armor + 1;
else
mitigation_rating = ((GetSkill(SkillDefense) + itembonuses.HeroicAGI/10) / 3.0) + (armor * 1.333333) + 1;
mitigation_rating = ((GetSkill(EQEmu::skills::SkillDefense) + itembonuses.HeroicAGI / 10) / 3.0) + (armor * 1.333333) + 1;
mitigation_rating *= 0.847;
mitigation_rating = mod_mitigation_rating(mitigation_rating, attacker);
if (attacker->IsClient())
attack_rating = (attacker->CastToClient()->CalcATK() + ((attacker->GetSTR()-66) * 0.9) + (attacker->GetSkill(SkillOffense)*1.345));
attack_rating = (attacker->CastToClient()->CalcATK() + ((attacker->GetSTR() - 66) * 0.9) + (attacker->GetSkill(EQEmu::skills::SkillOffense)*1.345));
else
attack_rating = (attacker->GetATK() + (attacker->GetSkill(SkillOffense)*1.345) + ((attacker->GetSTR()-66) * 0.9));
attack_rating = (attacker->GetATK() + (attacker->GetSkill(EQEmu::skills::SkillOffense)*1.345) + ((attacker->GetSTR() - 66) * 0.9));
attack_rating = attacker->mod_attack_rating(attack_rating, this);
@@ -1059,7 +1059,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
SkillUseTypes skillinuse;
EQEmu::skills::SkillType skillinuse;
AttackAnimation(skillinuse, Hand, weapon);
Log.Out(Logs::Detail, Logs::Combat, "Attacking with %s in slot %d using skill %d", weapon?weapon->GetItem()->Name:"Fist", Hand, skillinuse);
@@ -1095,7 +1095,7 @@ bool Client::Attack(Mob* other, int Hand, bool bRiposte, bool IsStrikethrough, b
max_hit = (RuleI(Combat, HitCapPre20));
CheckIncreaseSkill(skillinuse, other, -15);
CheckIncreaseSkill(SkillOffense, other, -15);
CheckIncreaseSkill(EQEmu::skills::SkillOffense, other, -15);
// ***************************************************************
// *** Calculate the damage bonus, if applicable, for this hit ***
@@ -1236,7 +1236,7 @@ void Mob::Heal()
SendHPUpdate();
}
void Client::Damage(Mob* other, int32 damage, uint16 spell_id, SkillUseTypes attack_skill, bool avoidable, int8 buffslot, bool iBuffTic, int special)
void Client::Damage(Mob* other, int32 damage, uint16 spell_id, EQEmu::skills::SkillType attack_skill, bool avoidable, int8 buffslot, bool iBuffTic, int special)
{
if(dead || IsCorpse())
return;
@@ -1249,7 +1249,7 @@ void Client::Damage(Mob* other, int32 damage, uint16 spell_id, SkillUseTypes att
//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 == SkillArchery)
if (attack_skill == EQEmu::skills::SkillArchery)
PvPMitigation = 80;
else
PvPMitigation = 67;
@@ -1265,11 +1265,11 @@ void Client::Damage(Mob* other, int32 damage, uint16 spell_id, SkillUseTypes att
if (damage > 0) {
if (spell_id == SPELL_UNKNOWN)
CheckIncreaseSkill(SkillDefense, other, -15);
CheckIncreaseSkill(EQEmu::skills::SkillDefense, other, -15);
}
}
bool Client::Death(Mob* killerMob, int32 damage, uint16 spell, SkillUseTypes attack_skill)
bool Client::Death(Mob* killerMob, int32 damage, uint16 spell, EQEmu::skills::SkillType attack_skill)
{
if(!ClientFinishedLoading())
return false;
@@ -1584,13 +1584,13 @@ bool NPC::Attack(Mob* other, int Hand, bool bRiposte, bool IsStrikethrough, bool
FaceTarget(GetTarget());
SkillUseTypes skillinuse = SkillHandtoHand;
EQEmu::skills::SkillType skillinuse = EQEmu::skills::SkillHandtoHand;
if (Hand == EQEmu::legacy::SlotPrimary) {
skillinuse = static_cast<SkillUseTypes>(GetPrimSkill());
skillinuse = static_cast<EQEmu::skills::SkillType>(GetPrimSkill());
OffHandAtk(false);
}
if (Hand == EQEmu::legacy::SlotSecondary) {
skillinuse = static_cast<SkillUseTypes>(GetSecSkill());
skillinuse = static_cast<EQEmu::skills::SkillType>(GetSecSkill());
OffHandAtk(true);
}
@@ -1613,32 +1613,32 @@ bool NPC::Attack(Mob* other, int Hand, bool bRiposte, bool IsStrikethrough, bool
switch(weapon->ItemType) {
case EQEmu::item::ItemType1HSlash:
skillinuse = Skill1HSlashing;
skillinuse = EQEmu::skills::Skill1HSlashing;
break;
case EQEmu::item::ItemType2HSlash:
skillinuse = Skill2HSlashing;
skillinuse = EQEmu::skills::Skill2HSlashing;
break;
case EQEmu::item::ItemType1HPiercing:
skillinuse = Skill1HPiercing;
skillinuse = EQEmu::skills::Skill1HPiercing;
break;
case EQEmu::item::ItemType2HPiercing:
skillinuse = Skill2HPiercing;
skillinuse = EQEmu::skills::Skill2HPiercing;
break;
case EQEmu::item::ItemType1HBlunt:
skillinuse = Skill1HBlunt;
skillinuse = EQEmu::skills::Skill1HBlunt;
break;
case EQEmu::item::ItemType2HBlunt:
skillinuse = Skill2HBlunt;
skillinuse = EQEmu::skills::Skill2HBlunt;
break;
case EQEmu::item::ItemTypeBow:
skillinuse = SkillArchery;
skillinuse = EQEmu::skills::SkillArchery;
break;
case EQEmu::item::ItemTypeLargeThrowing:
case EQEmu::item::ItemTypeSmallThrowing:
skillinuse = SkillThrowing;
skillinuse = EQEmu::skills::SkillThrowing;
break;
default:
skillinuse = SkillHandtoHand;
skillinuse = EQEmu::skills::SkillHandtoHand;
break;
}
}
@@ -1795,7 +1795,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, SkillUseTypes attack_skill, bool avoidable, int8 buffslot, bool iBuffTic, int special) {
void NPC::Damage(Mob* other, int32 damage, uint16 spell_id, EQEmu::skills::SkillType attack_skill, bool avoidable, int8 buffslot, bool iBuffTic, int special) {
if(spell_id==0)
spell_id = SPELL_UNKNOWN;
@@ -1838,7 +1838,7 @@ void NPC::Damage(Mob* other, int32 damage, uint16 spell_id, SkillUseTypes attack
}
}
bool NPC::Death(Mob* killer_mob, int32 damage, uint16 spell, SkillUseTypes attack_skill)
bool NPC::Death(Mob* killer_mob, int32 damage, uint16 spell, EQEmu::skills::SkillType attack_skill)
{
Log.Out(Logs::Detail, Logs::Combat, "Fatal blow dealt by %s with %d damage, spell %d, skill %d",
((killer_mob) ? (killer_mob->GetName()) : ("[nullptr]")), damage, spell, attack_skill);
@@ -2485,7 +2485,7 @@ void Mob::DamageShield(Mob* attacker, bool spell_ds) {
}
DS -= DS * attacker->itembonuses.DSMitigation / 100;
}
attacker->Damage(this, -DS, spellid, SkillAbjuration/*hackish*/, false);
attacker->Damage(this, -DS, spellid, EQEmu::skills::SkillAbjuration/*hackish*/, false);
//we can assume there is a spell now
auto outapp = new EQApplicationPacket(OP_Damage, sizeof(CombatDamage_Struct));
CombatDamage_Struct* cds = (CombatDamage_Struct*)outapp->pBuffer;
@@ -2512,7 +2512,7 @@ void Mob::DamageShield(Mob* attacker, bool spell_ds) {
if(rev_ds < 0) {
Log.Out(Logs::Detail, Logs::Combat, "Applying Reverse Damage Shield of value %d to %s", rev_ds, attacker->GetName());
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
attacker->Damage(this, -rev_ds, rev_ds_spell_id, EQEmu::skills::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?
}
}
@@ -2584,7 +2584,7 @@ int Mob::GetHandToHandDamage(void)
{
if (RuleB(Combat, UseRevampHandToHand)) {
// everyone uses this in the revamp!
int skill = GetSkill(SkillHandtoHand);
int skill = GetSkill(EQEmu::skills::SkillHandtoHand);
int epic = 0;
if (IsClient() && CastToClient()->GetItemIDAt(12) == 10652 && GetLevel() > 46)
epic = 280;
@@ -2625,7 +2625,7 @@ int Mob::GetHandToHandDelay(void)
{
if (RuleB(Combat, UseRevampHandToHand)) {
// everyone uses this in the revamp!
int skill = GetSkill(SkillHandtoHand);
int skill = GetSkill(EQEmu::skills::SkillHandtoHand);
int epic = 0;
int iksar = 0;
if (IsClient() && CastToClient()->GetItemIDAt(12) == 10652 && GetLevel() > 46)
@@ -2968,7 +2968,7 @@ bool Mob::HasRangedProcs() const
bool Client::CheckDoubleAttack()
{
int chance = 0;
int skill = GetSkill(SkillDoubleAttack);
int skill = GetSkill(EQEmu::skills::SkillDoubleAttack);
//Check for bonuses that give you a double attack chance regardless of skill (ie Bestial Frenzy/Harmonious Attack AA)
int bonusGiveDA = aabonuses.GiveDoubleAttack + spellbonuses.GiveDoubleAttack + itembonuses.GiveDoubleAttack;
if (skill > 0)
@@ -2989,7 +2989,7 @@ bool Client::CheckDoubleAttack()
// with varying triple attack skill (1-3% error at least)
bool Client::CheckTripleAttack()
{
int chance = GetSkill(SkillTripleAttack);
int chance = GetSkill(EQEmu::skills::SkillTripleAttack);
if (chance < 1)
return false;
@@ -3013,7 +3013,7 @@ bool Mob::CheckDoubleAttack()
{
// Not 100% certain pets follow this or if it's just from pets not always
// having the same skills as most mobs
int chance = GetSkill(SkillDoubleAttack);
int chance = GetSkill(EQEmu::skills::SkillDoubleAttack);
if (GetLevel() > 35)
chance += GetLevel();
@@ -3024,9 +3024,9 @@ bool Mob::CheckDoubleAttack()
return zone->random.Int(1, 500) <= chance;
}
void Mob::CommonDamage(Mob* attacker, int32 &damage, const uint16 spell_id, const SkillUseTypes skill_used, bool &avoidable, const int8 buffslot, const bool iBuffTic, int special) {
void Mob::CommonDamage(Mob* attacker, int32 &damage, const uint16 spell_id, const EQEmu::skills::SkillType skill_used, bool &avoidable, const int8 buffslot, const bool iBuffTic, int special) {
// This method is called with skill_used=ABJURE for Damage Shield damage.
bool FromDamageShield = (skill_used == SkillAbjuration);
bool FromDamageShield = (skill_used == EQEmu::skills::SkillAbjuration);
Log.Out(Logs::Detail, Logs::Combat, "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);
@@ -3041,7 +3041,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 != SkillArchery && skill_used != SkillThrowing) {
if (attacker && damage > 0 && spell_id == SPELL_UNKNOWN && skill_used != EQEmu::skills::SkillArchery && skill_used != EQEmu::skills::SkillThrowing) {
DamageShield(attacker);
}
@@ -3167,7 +3167,7 @@ void Mob::CommonDamage(Mob* attacker, int32 &damage, const uint16 spell_id, cons
}
//check stun chances if bashing
if (damage > 0 && ((skill_used == SkillBash || skill_used == SkillKick) && attacker)) {
if (damage > 0 && ((skill_used == EQEmu::skills::SkillBash || skill_used == EQEmu::skills::SkillKick) && attacker)) {
// NPCs can stun with their bash/kick as soon as they receive it.
// Clients can stun mobs under level 56 with their kick when they get level 55 or greater.
// Clients have a chance to stun if the mob is 56+
@@ -3181,15 +3181,15 @@ void Mob::CommonDamage(Mob* attacker, int32 &damage, const uint16 spell_id, cons
// Less than base immunity
// Client vs. Client always uses the chance
if (!IsClient() && GetLevel() <= RuleI(Spells, BaseImmunityLevel)) {
if (skill_used == SkillBash) // Bash always will
if (skill_used == EQEmu::skills::SkillBash) // Bash always will
stun_chance = 100;
else if (attacker->GetLevel() >= RuleI(Combat, ClientStunLevel))
stun_chance = 100; // only if you're over level 55 and using kick
} else { // higher than base immunity or Client vs. Client
// not sure on this number, use same as NPC for now
if (skill_used == SkillKick && attacker->GetLevel() < RuleI(Combat, ClientStunLevel))
if (skill_used == EQEmu::skills::SkillKick && attacker->GetLevel() < RuleI(Combat, ClientStunLevel))
stun_chance = RuleI(Combat, NPCBashKickStunChance);
else if (skill_used == SkillBash)
else if (skill_used == EQEmu::skills::SkillBash)
stun_chance = RuleI(Combat, NPCBashKickStunChance) +
attacker->spellbonuses.StunBashChance +
attacker->itembonuses.StunBashChance +
@@ -3268,7 +3268,7 @@ void Mob::CommonDamage(Mob* attacker, int32 &damage, const uint16 spell_id, cons
a->meleepush_xy = attacker->GetHeading() * 2.0f;
if (RuleB(Combat, MeleePush) && damage > 0 && !IsRooted() &&
(IsClient() || zone->random.Roll(RuleI(Combat, MeleePushChance)))) {
a->force = EQEmu::GetSkillMeleePushForce(skill_used);
a->force = EQEmu::skills::GetSkillMeleePushForce(skill_used);
// update NPC stuff
auto new_pos = glm::vec3(m_Position.x + (a->force * std::sin(a->meleepush_xy) + m_Delta.x),
m_Position.y + (a->force * std::cos(a->meleepush_xy) + m_Delta.y), m_Position.z);
@@ -3868,10 +3868,10 @@ void Mob::TryCriticalHit(Mob *defender, uint16 skill, int32 &damage, ExtraAttack
int deadlyChance = 0;
int deadlyMod = 0;
if(skill == SkillArchery && GetClass() == RANGER && GetSkill(SkillArchery) >= 65)
if (skill == EQEmu::skills::SkillArchery && GetClass() == RANGER && GetSkill(EQEmu::skills::SkillArchery) >= 65)
critChance += 6;
if (skill == SkillThrowing && GetClass() == ROGUE && GetSkill(SkillThrowing) >= 65) {
if (skill == EQEmu::skills::SkillThrowing && GetClass() == ROGUE && GetSkill(EQEmu::skills::SkillThrowing) >= 65) {
critChance += RuleI(Combat, RogueCritThrowingChance);
deadlyChance = RuleI(Combat, RogueDeadlyStrikeChance);
deadlyMod = RuleI(Combat, RogueDeadlyStrikeMod);
@@ -3952,7 +3952,7 @@ void Mob::TryCriticalHit(Mob *defender, uint16 skill, int32 &damage, ExtraAttack
}
}
bool Mob::TryFinishingBlow(Mob *defender, SkillUseTypes skillinuse)
bool Mob::TryFinishingBlow(Mob *defender, EQEmu::skills::SkillType skillinuse)
{
if (defender && !defender->IsClient() && defender->GetHPRatio() < 10){
@@ -4024,7 +4024,7 @@ void Mob::DoRiposte(Mob *defender)
if (defender->GetClass() == MONK)
defender->MonkSpecialAttack(this, defender->aabonuses.GiveDoubleRiposte[2]);
else if (defender->IsClient() && defender->CastToClient()->HasSkill((SkillUseTypes)defender->aabonuses.GiveDoubleRiposte[2]))
else if (defender->IsClient() && defender->CastToClient()->HasSkill((EQEmu::skills::SkillType)defender->aabonuses.GiveDoubleRiposte[2]))
defender->CastToClient()->DoClassAttacks(this, defender->aabonuses.GiveDoubleRiposte[2], true);
}
}
@@ -4063,7 +4063,7 @@ bool Mob::HasDied() {
return Result;
}
uint16 Mob::GetDamageTable(SkillUseTypes skillinuse)
uint16 Mob::GetDamageTable(EQEmu::skills::SkillType skillinuse)
{
if(GetLevel() <= 51)
{
@@ -4156,7 +4156,7 @@ void Mob::TrySkillProc(Mob *on, uint16 skill, uint16 ReuseTime, bool Success, ui
ProcMod = static_cast<float>(spells[base_spell_id].base2[i]);
}
else if (spells[base_spell_id].effectid[i] == SE_LimitToSkill && spells[base_spell_id].base[i] <= HIGHEST_SKILL) {
else if (spells[base_spell_id].effectid[i] == SE_LimitToSkill && spells[base_spell_id].base[i] <= EQEmu::skills::HIGHEST_SKILL) {
if (CanProc && spells[base_spell_id].base[i] == skill && IsValidSpell(proc_spell_id)) {
float final_chance = chance * (ProcMod / 100.0f);
@@ -4200,7 +4200,7 @@ void Mob::TrySkillProc(Mob *on, uint16 skill, uint16 ReuseTime, bool Success, ui
ProcMod = static_cast<float>(spells[base_spell_id].base2[i]);
}
else if (spells[base_spell_id].effectid[i] == SE_LimitToSkill && spells[base_spell_id].base[i] <= HIGHEST_SKILL) {
else if (spells[base_spell_id].effectid[i] == SE_LimitToSkill && spells[base_spell_id].base[i] <= EQEmu::skills::HIGHEST_SKILL) {
if (CanProc && spells[base_spell_id].base[i] == skill && IsValidSpell(proc_spell_id)) {
float final_chance = chance * (ProcMod / 100.0f);
@@ -4261,7 +4261,7 @@ void Mob::TrySkillProc(Mob *on, uint16 skill, uint16 ReuseTime, bool Success, ui
proc_spell_id = base1;
ProcMod = static_cast<float>(base2);
}
else if(effect_id == SE_LimitToSkill && base1 <= HIGHEST_SKILL) {
else if (effect_id == SE_LimitToSkill && base1 <= EQEmu::skills::HIGHEST_SKILL) {
if (CanProc && base1 == skill && IsValidSpell(proc_spell_id)) {
float final_chance = chance * (ProcMod / 100.0f);
@@ -4406,7 +4406,7 @@ int32 Mob::RuneAbsorb(int32 damage, uint16 type)
return damage;
}
void Mob::CommonOutgoingHitSuccess(Mob* defender, int32 &damage, SkillUseTypes skillInUse, ExtraAttackOptions *opts)
void Mob::CommonOutgoingHitSuccess(Mob* defender, int32 &damage, EQEmu::skills::SkillType skillInUse, ExtraAttackOptions *opts)
{
if (!defender)
return;
@@ -4623,15 +4623,15 @@ void Client::DoAttackRounds(Mob *target, int hand, bool IsFromSpell)
// extra off hand non-sense, can only double with skill of 150 or above
// or you have any amount of GiveDoubleAttack
if (candouble && hand == EQEmu::legacy::SlotSecondary)
candouble = GetSkill(SkillDoubleAttack) > 149 || (aabonuses.GiveDoubleAttack + spellbonuses.GiveDoubleAttack + itembonuses.GiveDoubleAttack) > 0;
candouble = GetSkill(EQEmu::skills::SkillDoubleAttack) > 149 || (aabonuses.GiveDoubleAttack + spellbonuses.GiveDoubleAttack + itembonuses.GiveDoubleAttack) > 0;
if (candouble) {
CheckIncreaseSkill(SkillDoubleAttack, target, -10);
CheckIncreaseSkill(EQEmu::skills::SkillDoubleAttack, target, -10);
if (CheckDoubleAttack()) {
Attack(target, hand, false, false, IsFromSpell);
// you can only triple from the main hand
if (hand == EQEmu::legacy::SlotPrimary && CanThisClassTripleAttack()) {
CheckIncreaseSkill(SkillTripleAttack, target, -10);
CheckIncreaseSkill(EQEmu::skills::SkillTripleAttack, target, -10);
if (CheckTripleAttack())
Attack(target, hand, false, false, IsFromSpell);
}
@@ -4659,7 +4659,7 @@ bool Mob::CheckDualWield()
{
// Pets /might/ follow a slightly different progression
// although it could all be from pets having different skills than most mobs
int chance = GetSkill(SkillDualWield);
int chance = GetSkill(EQEmu::skills::SkillDualWield);
if (GetLevel() > 35)
chance += GetLevel();
@@ -4673,7 +4673,7 @@ bool Mob::CheckDualWield()
bool Client::CheckDualWield()
{
int chance = GetSkill(SkillDualWield) + GetLevel();
int chance = GetSkill(EQEmu::skills::SkillDualWield) + GetLevel();
chance += aabonuses.Ambidexterity + spellbonuses.Ambidexterity + itembonuses.Ambidexterity;
int per_inc = spellbonuses.DualWieldChance + aabonuses.DualWieldChance + itembonuses.DualWieldChance;
zone/beacon.h
+2 -2
View File
@@ -34,8 +34,8 @@ public:
~Beacon();
//abstract virtual function implementations requird by base abstract class
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, int special = 0) { return; }
virtual bool Death(Mob* killerMob, int32 damage, uint16 spell_id, EQEmu::skills::SkillType attack_skill) { return true; }
virtual void Damage(Mob* from, int32 damage, uint16 spell_id, EQEmu::skills::SkillType attack_skill, bool avoidable = true, int8 buffslot = -1, bool iBuffTic = false, int special = 0) { return; }
virtual bool Attack(Mob* other, int Hand = EQEmu::legacy::SlotPrimary, bool FromRiposte = false, bool IsStrikethrough = false, bool IsFromSpell = false,
ExtraAttackOptions *opts = nullptr, int special = 0) { return false; }
virtual bool HasRaid() { return false; }
zone/bonuses.cpp
+71 -71
View File
@@ -507,7 +507,7 @@ void Client::AddItemBonuses(const ItemInst *inst, StatBonuses *newbon, bool isAu
}
}
if (item->ExtraDmgSkill != 0 && item->ExtraDmgSkill <= HIGHEST_SKILL) {
if (item->ExtraDmgSkill != 0 && item->ExtraDmgSkill <= EQEmu::skills::HIGHEST_SKILL) {
if ((newbon->SkillDamageAmount[item->ExtraDmgSkill] + item->ExtraDmgAmt) >
RuleI(Character, ItemExtraDmgCap))
newbon->SkillDamageAmount[item->ExtraDmgSkill] = RuleI(Character, ItemExtraDmgCap);
@@ -517,7 +517,7 @@ void Client::AddItemBonuses(const ItemInst *inst, StatBonuses *newbon, bool isAu
}
// Process when ammo_slot_item = true or false
if (item->SkillModValue != 0 && item->SkillModType <= HIGHEST_SKILL) {
if (item->SkillModValue != 0 && item->SkillModType <= EQEmu::skills::HIGHEST_SKILL) {
if ((item->SkillModValue > 0 && newbon->skillmod[item->SkillModType] < item->SkillModValue) ||
(item->SkillModValue < 0 && newbon->skillmod[item->SkillModType] > item->SkillModValue)) {
@@ -672,10 +672,10 @@ void Mob::ApplyAABonuses(const AA::Rank &rank, StatBonuses *newbon)
// Note: AA effects that use accuracy are skill limited, while spell effect is not.
case SE_Accuracy:
// Bad data or unsupported new skill
if (base2 > HIGHEST_SKILL)
if (base2 > EQEmu::skills::HIGHEST_SKILL)
break;
if ((base2 == ALL_SKILLS) && (newbon->Accuracy[HIGHEST_SKILL + 1] < base1))
newbon->Accuracy[HIGHEST_SKILL + 1] = base1;
if ((base2 == ALL_SKILLS) && (newbon->Accuracy[EQEmu::skills::HIGHEST_SKILL + 1] < base1))
newbon->Accuracy[EQEmu::skills::HIGHEST_SKILL + 1] = base1;
else if (newbon->Accuracy[base2] < base1)
newbon->Accuracy[base2] += base1;
break;
@@ -1015,10 +1015,10 @@ void Mob::ApplyAABonuses(const AA::Rank &rank, StatBonuses *newbon)
case SE_HitChance: {
// Bad data or unsupported new skill
if (base2 > HIGHEST_SKILL)
if (base2 > EQEmu::skills::HIGHEST_SKILL)
break;
if (base2 == ALL_SKILLS)
newbon->HitChanceEffect[HIGHEST_SKILL + 1] += base1;
newbon->HitChanceEffect[EQEmu::skills::HIGHEST_SKILL + 1] += base1;
else
newbon->HitChanceEffect[base2] += base1;
}
@@ -1069,21 +1069,21 @@ void Mob::ApplyAABonuses(const AA::Rank &rank, StatBonuses *newbon)
case SE_CriticalHitChance: {
// Bad data or unsupported new skill
if (base2 > HIGHEST_SKILL)
if (base2 > EQEmu::skills::HIGHEST_SKILL)
break;
if (base2 == ALL_SKILLS)
newbon->CriticalHitChance[HIGHEST_SKILL + 1] += base1;
newbon->CriticalHitChance[EQEmu::skills::HIGHEST_SKILL + 1] += base1;
else
newbon->CriticalHitChance[base2] += base1;
} break;
case SE_CriticalDamageMob: {
// Bad data or unsupported new skill
if (base2 > HIGHEST_SKILL)
if (base2 > EQEmu::skills::HIGHEST_SKILL)
break;
// base1 = effect value, base2 = skill restrictions(-1 for all)
if (base2 == ALL_SKILLS)
newbon->CritDmgMob[HIGHEST_SKILL + 1] += base1;
newbon->CritDmgMob[EQEmu::skills::HIGHEST_SKILL + 1] += base1;
else
newbon->CritDmgMob[base2] += base1;
break;
@@ -1109,10 +1109,10 @@ void Mob::ApplyAABonuses(const AA::Rank &rank, StatBonuses *newbon)
case SE_SkillDamageAmount: {
// Bad data or unsupported new skill
if (base2 > HIGHEST_SKILL)
if (base2 > EQEmu::skills::HIGHEST_SKILL)
break;
if (base2 == ALL_SKILLS)
newbon->SkillDamageAmount[HIGHEST_SKILL + 1] += base1;
newbon->SkillDamageAmount[EQEmu::skills::HIGHEST_SKILL + 1] += base1;
else
newbon->SkillDamageAmount[base2] += base1;
break;
@@ -1128,10 +1128,10 @@ void Mob::ApplyAABonuses(const AA::Rank &rank, StatBonuses *newbon)
case SE_DamageModifier: {
// Bad data or unsupported new skill
if (base2 > HIGHEST_SKILL)
if (base2 > EQEmu::skills::HIGHEST_SKILL)
break;
if (base2 == ALL_SKILLS)
newbon->DamageModifier[HIGHEST_SKILL + 1] += base1;
newbon->DamageModifier[EQEmu::skills::HIGHEST_SKILL + 1] += base1;
else
newbon->DamageModifier[base2] += base1;
break;
@@ -1139,10 +1139,10 @@ void Mob::ApplyAABonuses(const AA::Rank &rank, StatBonuses *newbon)
case SE_DamageModifier2: {
// Bad data or unsupported new skill
if (base2 > HIGHEST_SKILL)
if (base2 > EQEmu::skills::HIGHEST_SKILL)
break;
if (base2 == ALL_SKILLS)
newbon->DamageModifier2[HIGHEST_SKILL + 1] += base1;
newbon->DamageModifier2[EQEmu::skills::HIGHEST_SKILL + 1] += base1;
else
newbon->DamageModifier2[base2] += base1;
break;
@@ -1178,7 +1178,7 @@ void Mob::ApplyAABonuses(const AA::Rank &rank, StatBonuses *newbon)
// Physically raises skill cap ie if 55/55 it will raise to 55/60
case SE_RaiseSkillCap: {
if (base2 > HIGHEST_SKILL)
if (base2 > EQEmu::skills::HIGHEST_SKILL)
break;
if (newbon->RaiseSkillCap[base2] < base1)
@@ -1350,9 +1350,9 @@ void Mob::ApplyAABonuses(const AA::Rank &rank, StatBonuses *newbon)
case SE_LimitToSkill: {
// Bad data or unsupported new skill
if (base2 > HIGHEST_SKILL)
if (base2 > EQEmu::skills::HIGHEST_SKILL)
break;
if (base1 <= HIGHEST_SKILL)
if (base1 <= EQEmu::skills::HIGHEST_SKILL)
newbon->LimitToSkill[base1] = true;
break;
}
@@ -1416,7 +1416,7 @@ void Mob::ApplyAABonuses(const AA::Rank &rank, StatBonuses *newbon)
case SE_ReduceTradeskillFail:{
if (base2 > HIGHEST_SKILL)
if (base2 > EQEmu::skills::HIGHEST_SKILL)
break;
newbon->ReduceTradeskillFail[base2] += base1;
@@ -1938,26 +1938,26 @@ void Mob::ApplySpellsBonuses(uint16 spell_id, uint8 casterlevel, StatBonuses *ne
case SE_CriticalHitChance:
{
// Bad data or unsupported new skill
if (base2 > HIGHEST_SKILL)
if (base2 > EQEmu::skills::HIGHEST_SKILL)
break;
if (AdditiveWornBonus) {
if(base2 == ALL_SKILLS)
new_bonus->CriticalHitChance[HIGHEST_SKILL+1] += effect_value;
new_bonus->CriticalHitChance[EQEmu::skills::HIGHEST_SKILL + 1] += effect_value;
else
new_bonus->CriticalHitChance[base2] += effect_value;
}
else if(effect_value < 0) {
if(base2 == ALL_SKILLS && new_bonus->CriticalHitChance[HIGHEST_SKILL+1] > effect_value)
new_bonus->CriticalHitChance[HIGHEST_SKILL+1] = effect_value;
if (base2 == ALL_SKILLS && new_bonus->CriticalHitChance[EQEmu::skills::HIGHEST_SKILL + 1] > effect_value)
new_bonus->CriticalHitChance[EQEmu::skills::HIGHEST_SKILL + 1] = effect_value;
else if(base2 != ALL_SKILLS && new_bonus->CriticalHitChance[base2] > effect_value)
new_bonus->CriticalHitChance[base2] = effect_value;
}
else if(base2 == ALL_SKILLS && new_bonus->CriticalHitChance[HIGHEST_SKILL+1] < effect_value)
new_bonus->CriticalHitChance[HIGHEST_SKILL+1] = effect_value;
else if (base2 == ALL_SKILLS && new_bonus->CriticalHitChance[EQEmu::skills::HIGHEST_SKILL + 1] < effect_value)
new_bonus->CriticalHitChance[EQEmu::skills::HIGHEST_SKILL + 1] = effect_value;
else if(base2 != ALL_SKILLS && new_bonus->CriticalHitChance[base2] < effect_value)
new_bonus->CriticalHitChance[base2] = effect_value;
@@ -2144,24 +2144,24 @@ void Mob::ApplySpellsBonuses(uint16 spell_id, uint8 casterlevel, StatBonuses *ne
case SE_HitChance:
{
// Bad data or unsupported new skill
if (base2 > HIGHEST_SKILL)
if (base2 > EQEmu::skills::HIGHEST_SKILL)
break;
if (AdditiveWornBonus){
if(base2 == ALL_SKILLS)
new_bonus->HitChanceEffect[HIGHEST_SKILL+1] += effect_value;
new_bonus->HitChanceEffect[EQEmu::skills::HIGHEST_SKILL + 1] += effect_value;
else
new_bonus->HitChanceEffect[base2] += effect_value;
}
else if(base2 == ALL_SKILLS){
if ((effect_value < 0) && (new_bonus->HitChanceEffect[HIGHEST_SKILL+1] > effect_value))
new_bonus->HitChanceEffect[HIGHEST_SKILL+1] = effect_value;
if ((effect_value < 0) && (new_bonus->HitChanceEffect[EQEmu::skills::HIGHEST_SKILL + 1] > effect_value))
new_bonus->HitChanceEffect[EQEmu::skills::HIGHEST_SKILL + 1] = effect_value;
else if (!new_bonus->HitChanceEffect[HIGHEST_SKILL+1] ||
((new_bonus->HitChanceEffect[HIGHEST_SKILL+1] > 0) && (new_bonus->HitChanceEffect[HIGHEST_SKILL+1] < effect_value)))
new_bonus->HitChanceEffect[HIGHEST_SKILL+1] = effect_value;
else if (!new_bonus->HitChanceEffect[EQEmu::skills::HIGHEST_SKILL + 1] ||
((new_bonus->HitChanceEffect[EQEmu::skills::HIGHEST_SKILL + 1] > 0) && (new_bonus->HitChanceEffect[EQEmu::skills::HIGHEST_SKILL + 1] < effect_value)))
new_bonus->HitChanceEffect[EQEmu::skills::HIGHEST_SKILL + 1] = effect_value;
}
else {
@@ -2181,9 +2181,9 @@ void Mob::ApplySpellsBonuses(uint16 spell_id, uint8 casterlevel, StatBonuses *ne
case SE_DamageModifier:
{
// Bad data or unsupported new skill
if (base2 > HIGHEST_SKILL)
if (base2 > EQEmu::skills::HIGHEST_SKILL)
break;
int skill = base2 == ALL_SKILLS ? HIGHEST_SKILL + 1 : base2;
int skill = base2 == ALL_SKILLS ? EQEmu::skills::HIGHEST_SKILL + 1 : base2;
if (effect_value < 0 && new_bonus->DamageModifier[skill] > effect_value)
new_bonus->DamageModifier[skill] = effect_value;
else if (effect_value > 0 && new_bonus->DamageModifier[skill] < effect_value)
@@ -2194,9 +2194,9 @@ void Mob::ApplySpellsBonuses(uint16 spell_id, uint8 casterlevel, StatBonuses *ne
case SE_DamageModifier2:
{
// Bad data or unsupported new skill
if (base2 > HIGHEST_SKILL)
if (base2 > EQEmu::skills::HIGHEST_SKILL)
break;
int skill = base2 == ALL_SKILLS ? HIGHEST_SKILL + 1 : base2;
int skill = base2 == ALL_SKILLS ? EQEmu::skills::HIGHEST_SKILL + 1 : base2;
if (effect_value < 0 && new_bonus->DamageModifier2[skill] > effect_value)
new_bonus->DamageModifier2[skill] = effect_value;
else if (effect_value > 0 && new_bonus->DamageModifier2[skill] < effect_value)
@@ -2207,9 +2207,9 @@ void Mob::ApplySpellsBonuses(uint16 spell_id, uint8 casterlevel, StatBonuses *ne
case SE_MinDamageModifier:
{
// Bad data or unsupported new skill
if (base2 > HIGHEST_SKILL)
if (base2 > EQEmu::skills::HIGHEST_SKILL)
break;
int skill = base2 == ALL_SKILLS ? HIGHEST_SKILL + 1 : base2;
int skill = base2 == ALL_SKILLS ? EQEmu::skills::HIGHEST_SKILL + 1 : base2;
if (effect_value < 0 && new_bonus->MinDamageModifier[skill] > effect_value)
new_bonus->MinDamageModifier[skill] = effect_value;
else if (effect_value > 0 && new_bonus->MinDamageModifier[skill] < effect_value)
@@ -2284,14 +2284,14 @@ void Mob::ApplySpellsBonuses(uint16 spell_id, uint8 casterlevel, StatBonuses *ne
case SE_Accuracy:
{
// Bad data or unsupported new skill
if (base2 > HIGHEST_SKILL)
if (base2 > EQEmu::skills::HIGHEST_SKILL)
break;
if ((effect_value < 0) && (new_bonus->Accuracy[HIGHEST_SKILL+1] > effect_value))
new_bonus->Accuracy[HIGHEST_SKILL+1] = effect_value;
if ((effect_value < 0) && (new_bonus->Accuracy[EQEmu::skills::HIGHEST_SKILL + 1] > effect_value))
new_bonus->Accuracy[EQEmu::skills::HIGHEST_SKILL + 1] = effect_value;
else if (!new_bonus->Accuracy[HIGHEST_SKILL+1] ||
((new_bonus->Accuracy[HIGHEST_SKILL+1] > 0) && (new_bonus->Accuracy[HIGHEST_SKILL+1] < effect_value)))
new_bonus->Accuracy[HIGHEST_SKILL+1] = effect_value;
else if (!new_bonus->Accuracy[EQEmu::skills::HIGHEST_SKILL + 1] ||
((new_bonus->Accuracy[EQEmu::skills::HIGHEST_SKILL + 1] > 0) && (new_bonus->Accuracy[EQEmu::skills::HIGHEST_SKILL + 1] < effect_value)))
new_bonus->Accuracy[EQEmu::skills::HIGHEST_SKILL + 1] = effect_value;
break;
}
@@ -2310,19 +2310,19 @@ void Mob::ApplySpellsBonuses(uint16 spell_id, uint8 casterlevel, StatBonuses *ne
case SE_SkillDamageTaken:
{
// Bad data or unsupported new skill
if (base2 > HIGHEST_SKILL)
if (base2 > EQEmu::skills::HIGHEST_SKILL)
break;
//When using npc_spells_effects if MAX value set, use stackable quest based modifier.
if (IsAISpellEffect && max){
if(base2 == ALL_SKILLS)
SkillDmgTaken_Mod[HIGHEST_SKILL+1] = effect_value;
SkillDmgTaken_Mod[EQEmu::skills::HIGHEST_SKILL + 1] = effect_value;
else
SkillDmgTaken_Mod[base2] = effect_value;
}
else {
if(base2 == ALL_SKILLS)
new_bonus->SkillDmgTaken[HIGHEST_SKILL+1] += effect_value;
new_bonus->SkillDmgTaken[EQEmu::skills::HIGHEST_SKILL + 1] += effect_value;
else
new_bonus->SkillDmgTaken[base2] += effect_value;
@@ -2431,10 +2431,10 @@ void Mob::ApplySpellsBonuses(uint16 spell_id, uint8 casterlevel, StatBonuses *ne
case SE_CriticalDamageMob:
{
// Bad data or unsupported new skill
if (base2 > HIGHEST_SKILL)
if (base2 > EQEmu::skills::HIGHEST_SKILL)
break;
if(base2 == ALL_SKILLS)
new_bonus->CritDmgMob[HIGHEST_SKILL+1] += effect_value;
new_bonus->CritDmgMob[EQEmu::skills::HIGHEST_SKILL + 1] += effect_value;
else
new_bonus->CritDmgMob[base2] += effect_value;
break;
@@ -2450,10 +2450,10 @@ void Mob::ApplySpellsBonuses(uint16 spell_id, uint8 casterlevel, StatBonuses *ne
case SE_SkillDamageAmount:
{
// Bad data or unsupported new skill
if (base2 > HIGHEST_SKILL)
if (base2 > EQEmu::skills::HIGHEST_SKILL)
break;
if(base2 == ALL_SKILLS)
new_bonus->SkillDamageAmount[HIGHEST_SKILL+1] += effect_value;
new_bonus->SkillDamageAmount[EQEmu::skills::HIGHEST_SKILL + 1] += effect_value;
else
new_bonus->SkillDamageAmount[base2] += effect_value;
break;
@@ -2558,10 +2558,10 @@ void Mob::ApplySpellsBonuses(uint16 spell_id, uint8 casterlevel, StatBonuses *ne
case SE_SkillDamageAmount2:
{
// Bad data or unsupported new skill
if (base2 > HIGHEST_SKILL)
if (base2 > EQEmu::skills::HIGHEST_SKILL)
break;
if(base2 == ALL_SKILLS)
new_bonus->SkillDamageAmount2[HIGHEST_SKILL+1] += effect_value;
new_bonus->SkillDamageAmount2[EQEmu::skills::HIGHEST_SKILL + 1] += effect_value;
else
new_bonus->SkillDamageAmount2[base2] += effect_value;
break;
@@ -3096,9 +3096,9 @@ void Mob::ApplySpellsBonuses(uint16 spell_id, uint8 casterlevel, StatBonuses *ne
case SE_LimitToSkill:{
// Bad data or unsupported new skill
if (base2 > HIGHEST_SKILL)
if (base2 > EQEmu::skills::HIGHEST_SKILL)
break;
if (effect_value <= HIGHEST_SKILL){
if (effect_value <= EQEmu::skills::HIGHEST_SKILL){
new_bonus->LimitToSkill[effect_value] = true;
}
break;
@@ -3155,7 +3155,7 @@ void Mob::ApplySpellsBonuses(uint16 spell_id, uint8 casterlevel, StatBonuses *ne
case SE_ReduceTradeskillFail:{
if (base2 > HIGHEST_SKILL)
if (base2 > EQEmu::skills::HIGHEST_SKILL)
break;
new_bonus->ReduceTradeskillFail[base2] += effect_value;
@@ -3168,7 +3168,7 @@ void Mob::ApplySpellsBonuses(uint16 spell_id, uint8 casterlevel, StatBonuses *ne
break;
case SE_RaiseSkillCap: {
if (base2 > HIGHEST_SKILL)
if (base2 > EQEmu::skills::HIGHEST_SKILL)
break;
if (new_bonus->RaiseSkillCap[base2] < effect_value)
@@ -3866,7 +3866,7 @@ void Mob::NegateSpellsBonuses(uint16 spell_id)
case SE_CriticalHitChance:
{
for(int e = 0; e < HIGHEST_SKILL+1; e++)
for (int e = 0; e < EQEmu::skills::HIGHEST_SKILL + 1; e++)
{
spellbonuses.CriticalHitChance[e] = effect_value;
aabonuses.CriticalHitChance[e] = effect_value;
@@ -3984,7 +3984,7 @@ void Mob::NegateSpellsBonuses(uint16 spell_id)
case SE_HitChance:
{
for(int e = 0; e < HIGHEST_SKILL+1; e++)
for (int e = 0; e < EQEmu::skills::HIGHEST_SKILL + 1; e++)
{
spellbonuses.HitChanceEffect[e] = effect_value;
aabonuses.HitChanceEffect[e] = effect_value;
@@ -3995,7 +3995,7 @@ void Mob::NegateSpellsBonuses(uint16 spell_id)
case SE_DamageModifier:
{
for(int e = 0; e < HIGHEST_SKILL+1; e++)
for (int e = 0; e < EQEmu::skills::HIGHEST_SKILL + 1; e++)
{
spellbonuses.DamageModifier[e] = effect_value;
aabonuses.DamageModifier[e] = effect_value;
@@ -4006,7 +4006,7 @@ void Mob::NegateSpellsBonuses(uint16 spell_id)
case SE_DamageModifier2:
{
for(int e = 0; e < HIGHEST_SKILL+1; e++)
for (int e = 0; e < EQEmu::skills::HIGHEST_SKILL + 1; e++)
{
spellbonuses.DamageModifier2[e] = effect_value;
aabonuses.DamageModifier2[e] = effect_value;
@@ -4017,7 +4017,7 @@ void Mob::NegateSpellsBonuses(uint16 spell_id)
case SE_MinDamageModifier:
{
for(int e = 0; e < HIGHEST_SKILL+1; e++)
for (int e = 0; e < EQEmu::skills::HIGHEST_SKILL + 1; e++)
{
spellbonuses.MinDamageModifier[e] = effect_value;
aabonuses.MinDamageModifier[e] = effect_value;
@@ -4058,10 +4058,10 @@ void Mob::NegateSpellsBonuses(uint16 spell_id)
case SE_Accuracy:
{
spellbonuses.Accuracy[HIGHEST_SKILL+1] = effect_value;
itembonuses.Accuracy[HIGHEST_SKILL+1] = effect_value;
spellbonuses.Accuracy[EQEmu::skills::HIGHEST_SKILL + 1] = effect_value;
itembonuses.Accuracy[EQEmu::skills::HIGHEST_SKILL + 1] = effect_value;
for(int e = 0; e < HIGHEST_SKILL+1; e++)
for (int e = 0; e < EQEmu::skills::HIGHEST_SKILL + 1; e++)
{
aabonuses.Accuracy[e] = effect_value;
}
@@ -4088,7 +4088,7 @@ void Mob::NegateSpellsBonuses(uint16 spell_id)
case SE_SkillDamageTaken:
{
for(int e = 0; e < HIGHEST_SKILL+1; e++)
for (int e = 0; e < EQEmu::skills::HIGHEST_SKILL + 1; e++)
{
spellbonuses.SkillDmgTaken[e] = effect_value;
aabonuses.SkillDmgTaken[e] = effect_value;
@@ -4193,7 +4193,7 @@ void Mob::NegateSpellsBonuses(uint16 spell_id)
case SE_CriticalDamageMob:
{
for(int e = 0; e < HIGHEST_SKILL+1; e++)
for (int e = 0; e < EQEmu::skills::HIGHEST_SKILL + 1; e++)
{
spellbonuses.CritDmgMob[e] = effect_value;
aabonuses.CritDmgMob[e] = effect_value;
@@ -4204,7 +4204,7 @@ void Mob::NegateSpellsBonuses(uint16 spell_id)
case SE_SkillDamageAmount:
{
for(int e = 0; e < HIGHEST_SKILL+1; e++)
for (int e = 0; e < EQEmu::skills::HIGHEST_SKILL + 1; e++)
{
spellbonuses.SkillDamageAmount[e] = effect_value;
aabonuses.SkillDamageAmount[e] = effect_value;
@@ -4255,7 +4255,7 @@ void Mob::NegateSpellsBonuses(uint16 spell_id)
case SE_SkillDamageAmount2:
{
for(int e = 0; e < HIGHEST_SKILL+1; e++)
for (int e = 0; e < EQEmu::skills::HIGHEST_SKILL + 1; e++)
{
spellbonuses.SkillDamageAmount2[e] = effect_value;
aabonuses.SkillDamageAmount2[e] = effect_value;
zone/bot.cpp
+104 -103
View File
@@ -23,6 +23,7 @@
#include "doors.h"
#include "quest_parser_collection.h"
#include "../common/string_util.h"
#include "../common/say_link.h"
extern volatile bool is_zone_loaded;
@@ -1139,16 +1140,16 @@ int32 Bot::acmod() {
void Bot::GenerateArmorClass() {
/// new formula
int avoidance = 0;
avoidance = (acmod() + ((GetSkill(SkillDefense) * 16) / 9));
avoidance = (acmod() + ((GetSkill(EQEmu::skills::SkillDefense) * 16) / 9));
if(avoidance < 0)
avoidance = 0;
int mitigation = 0;
if(GetClass() == WIZARD || GetClass() == MAGICIAN || GetClass() == NECROMANCER || GetClass() == ENCHANTER) {
mitigation = (GetSkill(SkillDefense) / 4 + (itembonuses.AC + 1));
mitigation = (GetSkill(EQEmu::skills::SkillDefense) / 4 + (itembonuses.AC + 1));
mitigation -= 4;
} else {
mitigation = (GetSkill(SkillDefense) / 3 + ((itembonuses.AC * 4) / 3));
mitigation = (GetSkill(EQEmu::skills::SkillDefense) / 3 + ((itembonuses.AC * 4) / 3));
if(GetClass() == MONK)
mitigation += (GetLevel() * 13 / 10); //the 13/10 might be wrong, but it is close...
}
@@ -1173,36 +1174,36 @@ void Bot::GenerateArmorClass() {
}
uint16 Bot::GetPrimarySkillValue() {
SkillUseTypes skill = HIGHEST_SKILL; //because nullptr == 0, which is 1H Slashing, & we want it to return 0 from GetSkill
EQEmu::skills::SkillType skill = EQEmu::skills::HIGHEST_SKILL; //because nullptr == 0, which is 1H Slashing, & we want it to return 0 from GetSkill
bool equiped = m_inv.GetItem(EQEmu::legacy::SlotPrimary);
if(!equiped)
skill = SkillHandtoHand;
skill = EQEmu::skills::SkillHandtoHand;
else {
uint8 type = m_inv.GetItem(EQEmu::legacy::SlotPrimary)->GetItem()->ItemType; //is this the best way to do this?
switch(type) {
case EQEmu::item::ItemType1HSlash:
skill = Skill1HSlashing;
skill = EQEmu::skills::Skill1HSlashing;
break;
case EQEmu::item::ItemType2HSlash:
skill = Skill2HSlashing;
skill = EQEmu::skills::Skill2HSlashing;
break;
case EQEmu::item::ItemType1HPiercing:
skill = Skill1HPiercing;
skill = EQEmu::skills::Skill1HPiercing;
break;
case EQEmu::item::ItemType1HBlunt:
skill = Skill1HBlunt;
skill = EQEmu::skills::Skill1HBlunt;
break;
case EQEmu::item::ItemType2HBlunt:
skill = Skill2HBlunt;
skill = EQEmu::skills::Skill2HBlunt;
break;
case EQEmu::item::ItemType2HPiercing:
skill = Skill2HPiercing;
skill = EQEmu::skills::Skill2HPiercing;
break;
case EQEmu::item::ItemTypeMartial:
skill = SkillHandtoHand;
skill = EQEmu::skills::SkillHandtoHand;
break;
default:
skill = SkillHandtoHand;
skill = EQEmu::skills::SkillHandtoHand;
break;
}
}
@@ -1210,7 +1211,7 @@ uint16 Bot::GetPrimarySkillValue() {
return GetSkill(skill);
}
uint16 Bot::MaxSkill(SkillUseTypes skillid, uint16 class_, uint16 level) const {
uint16 Bot::MaxSkill(EQEmu::skills::SkillType skillid, uint16 class_, uint16 level) const {
return(database.GetSkillCap(class_, skillid, level));
}
@@ -1218,7 +1219,7 @@ uint32 Bot::GetTotalATK() {
uint32 AttackRating = 0;
uint32 WornCap = itembonuses.ATK;
if(IsBot()) {
AttackRating = ((WornCap * 1.342) + (GetSkill(SkillOffense) * 1.345) + ((GetSTR() - 66) * 0.9) + (GetPrimarySkillValue() * 2.69));
AttackRating = ((WornCap * 1.342) + (GetSkill(EQEmu::skills::SkillOffense) * 1.345) + ((GetSTR() - 66) * 0.9) + (GetPrimarySkillValue() * 2.69));
AttackRating += aabonuses.ATK + GroupLeadershipAAOffenseEnhancement();
if (AttackRating < 10)
AttackRating = 10;
@@ -1233,7 +1234,7 @@ uint32 Bot::GetTotalATK() {
uint32 Bot::GetATKRating() {
uint32 AttackRating = 0;
if(IsBot()) {
AttackRating = (GetSkill(SkillOffense) * 1.345) + ((GetSTR() - 66) * 0.9) + (GetPrimarySkillValue() * 2.69);
AttackRating = (GetSkill(EQEmu::skills::SkillOffense) * 1.345) + ((GetSTR() - 66) * 0.9) + (GetPrimarySkillValue() * 2.69);
if (AttackRating < 10)
AttackRating = 10;
}
@@ -1914,7 +1915,7 @@ void Bot::BotRangedAttack(Mob* other) {
if(!IsAttackAllowed(other) || IsCasting() || DivineAura() || IsStunned() || IsMezzed() || (GetAppearance() == eaDead))
return;
SendItemAnimation(other, Ammo, SkillArchery);
SendItemAnimation(other, Ammo, EQEmu::skills::SkillArchery);
//DoArcheryAttackDmg(GetTarget(), rangedItem, ammoItem);
DoArcheryAttackDmg(other, rangedItem, ammoItem); // watch
@@ -1959,12 +1960,12 @@ bool Bot::CheckBotDoubleAttack(bool tripleAttack) {
//Check for bonuses that give you a double attack chance regardless of skill (ie Bestial Frenzy/Harmonious Attack AA)
uint32 bonusGiveDA = (aabonuses.GiveDoubleAttack + spellbonuses.GiveDoubleAttack + itembonuses.GiveDoubleAttack);
// If you don't have the double attack skill, return
if(!GetSkill(SkillDoubleAttack) && !(GetClass() == BARD || GetClass() == BEASTLORD))
if (!GetSkill(EQEmu::skills::SkillDoubleAttack) && !(GetClass() == BARD || GetClass() == BEASTLORD))
return false;
// You start with no chance of double attacking
float chance = 0.0f;
uint16 skill = GetSkill(SkillDoubleAttack);
uint16 skill = GetSkill(EQEmu::skills::SkillDoubleAttack);
int32 bonusDA = (aabonuses.DoubleAttackChance + spellbonuses.DoubleAttackChance + itembonuses.DoubleAttackChance);
//Use skill calculations otherwise, if you only have AA applied GiveDoubleAttack chance then use that value as the base.
if (skill)
@@ -1989,13 +1990,13 @@ bool Bot::CheckBotDoubleAttack(bool tripleAttack) {
return false;
}
void Bot::DoMeleeSkillAttackDmg(Mob* other, uint16 weapon_damage, SkillUseTypes skillinuse, int16 chance_mod, int16 focus, bool CanRiposte, int ReuseTime) {
void Bot::DoMeleeSkillAttackDmg(Mob* other, uint16 weapon_damage, EQEmu::skills::SkillType skillinuse, int16 chance_mod, int16 focus, bool CanRiposte, int ReuseTime) {
if (!CanDoSpecialAttack(other))
return;
//For spells using skill value 98 (feral swipe ect) server sets this to 67 automatically.
if (skillinuse == SkillBegging)
skillinuse = SkillOffense;
if (skillinuse == EQEmu::skills::SkillBegging)
skillinuse = EQEmu::skills::SkillOffense;
int damage = 0;
uint32 hate = 0;
@@ -2052,7 +2053,7 @@ void Bot::DoMeleeSkillAttackDmg(Mob* other, uint16 weapon_damage, SkillUseTypes
else
damage = -5;
if(skillinuse == SkillBash){
if (skillinuse == EQEmu::skills::SkillBash){
const ItemInst* inst = GetBotItem(EQEmu::legacy::SlotSecondary);
const EQEmu::Item_Struct* botweapon = 0;
if(inst)
@@ -2069,8 +2070,8 @@ void Bot::DoMeleeSkillAttackDmg(Mob* other, uint16 weapon_damage, SkillUseTypes
other->AddToHateList(this, hate);
bool CanSkillProc = true;
if (skillinuse == SkillOffense){ //Hack to allow damage to display.
skillinuse = SkillTigerClaw; //'strike' your opponent - Arbitrary choice for message.
if (skillinuse == EQEmu::skills::SkillOffense){ //Hack to allow damage to display.
skillinuse = EQEmu::skills::SkillTigerClaw; //'strike' your opponent - Arbitrary choice for message.
CanSkillProc = false; //Disable skill procs
}
@@ -2081,7 +2082,7 @@ void Bot::DoMeleeSkillAttackDmg(Mob* other, uint16 weapon_damage, SkillUseTypes
if (damage > 0)
CheckNumHitsRemaining(NumHit::OutgoingHitSuccess);
if((skillinuse == SkillDragonPunch) && GetAA(aaDragonPunch) && zone->random.Int(0, 99) < 25){
if ((skillinuse == EQEmu::skills::SkillDragonPunch) && GetAA(aaDragonPunch) && zone->random.Int(0, 99) < 25){
SpellFinished(904, other, 10, 0, -1, spells[904].ResistDiff);
other->Stun(100);
}
@@ -2093,23 +2094,23 @@ void Bot::DoMeleeSkillAttackDmg(Mob* other, uint16 weapon_damage, SkillUseTypes
TrySkillProc(other, skillinuse, ReuseTime, true);
}
void Bot::ApplySpecialAttackMod(SkillUseTypes skill, int32 &dmg, int32 &mindmg) {
void Bot::ApplySpecialAttackMod(EQEmu::skills::SkillType skill, int32 &dmg, int32 &mindmg) {
int item_slot = -1;
//1: Apply bonus from AC (BOOT/SHIELD/HANDS) est. 40AC=6dmg
switch (skill) {
case SkillFlyingKick:
case SkillRoundKick:
case SkillKick:
item_slot = EQEmu::legacy::SlotFeet;
break;
case SkillBash:
item_slot = EQEmu::legacy::SlotSecondary;
break;
case SkillDragonPunch:
case SkillEagleStrike:
case SkillTigerClaw:
item_slot = EQEmu::legacy::SlotHands;
break;
case EQEmu::skills::SkillFlyingKick:
case EQEmu::skills::SkillRoundKick:
case EQEmu::skills::SkillKick:
item_slot = EQEmu::legacy::SlotFeet;
break;
case EQEmu::skills::SkillBash:
item_slot = EQEmu::legacy::SlotSecondary;
break;
case EQEmu::skills::SkillDragonPunch:
case EQEmu::skills::SkillEagleStrike:
case EQEmu::skills::SkillTigerClaw:
item_slot = EQEmu::legacy::SlotHands;
break;
}
if (item_slot >= EQEmu::legacy::EQUIPMENT_BEGIN){
@@ -2518,7 +2519,7 @@ void Bot::AI_Process() {
if (bIsFist || !weapon->IsType2HWeapon()) {
float DualWieldProbability = 0.0f;
int32 Ambidexterity = (aabonuses.Ambidexterity + spellbonuses.Ambidexterity + itembonuses.Ambidexterity);
DualWieldProbability = ((GetSkill(SkillDualWield) + GetLevel() + Ambidexterity) / 400.0f); // 78.0 max
DualWieldProbability = ((GetSkill(EQEmu::skills::SkillDualWield) + GetLevel() + Ambidexterity) / 400.0f); // 78.0 max
int32 DWBonus = (spellbonuses.DualWieldChance + itembonuses.DualWieldChance);
DualWieldProbability += (DualWieldProbability * float(DWBonus) / 100.0f);
float random = zone->random.Real(0, 1);
@@ -2739,7 +2740,7 @@ void Bot::PetAIProcess() {
// Ok now, let's check pet's offhand.
if (botPet->GetAttackDWTimer().Check() && botPet->GetOwnerID() && botPet->GetOwner() && ((botPet->GetOwner()->GetClass() == MAGICIAN) || (botPet->GetOwner()->GetClass() == NECROMANCER) || (botPet->GetOwner()->GetClass() == SHADOWKNIGHT) || (botPet->GetOwner()->GetClass() == BEASTLORD))) {
if(botPet->GetOwner()->GetLevel() >= 24) {
float DualWieldProbability = ((botPet->GetSkill(SkillDualWield) + botPet->GetLevel()) / 400.0f);
float DualWieldProbability = ((botPet->GetSkill(EQEmu::skills::SkillDualWield) + botPet->GetLevel()) / 400.0f);
DualWieldProbability -= zone->random.Real(0, 1);
if(DualWieldProbability < 0) {
botPet->Attack(botPet->GetTarget(), EQEmu::legacy::SlotSecondary);
@@ -3586,7 +3587,7 @@ void Bot::PerformTradeWithClient(int16 beginSlotID, int16 endSlotID, Client* cli
}
}
bool Bot::Death(Mob *killerMob, int32 damage, uint16 spell_id, SkillUseTypes attack_skill) {
bool Bot::Death(Mob *killerMob, int32 damage, uint16 spell_id, EQEmu::skills::SkillType attack_skill) {
if(!NPC::Death(killerMob, damage, spell_id, attack_skill))
return false;
@@ -3661,7 +3662,7 @@ bool Bot::Death(Mob *killerMob, int32 damage, uint16 spell_id, SkillUseTypes att
return true;
}
void Bot::Damage(Mob *from, int32 damage, uint16 spell_id, SkillUseTypes attack_skill, bool avoidable, int8 buffslot, bool iBuffTic, int special) {
void Bot::Damage(Mob *from, int32 damage, uint16 spell_id, EQEmu::skills::SkillType attack_skill, bool avoidable, int8 buffslot, bool iBuffTic, int special) {
if(spell_id == 0)
spell_id = SPELL_UNKNOWN;
@@ -3758,7 +3759,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
SkillUseTypes skillinuse;
EQEmu::skills::SkillType skillinuse;
AttackAnimation(skillinuse, Hand, weapon);
Log.Out(Logs::Detail, Logs::Combat, "Attacking with %s in slot %d using skill %d", weapon?weapon->GetItem()->Name:"Fist", Hand, skillinuse);
/// Now figure out damage
@@ -4776,7 +4777,7 @@ float Bot::GetProcChances(float ProcBonus, uint16 hand) {
int Bot::GetHandToHandDamage(void) {
if (RuleB(Combat, UseRevampHandToHand)) {
// everyone uses this in the revamp!
int skill = GetSkill(SkillHandtoHand);
int skill = GetSkill(EQEmu::skills::SkillHandtoHand);
int epic = 0;
if (CastToNPC()->GetEquipment(EQEmu::legacy::MaterialHands) == 10652 && GetLevel() > 46)
epic = 280;
@@ -4813,7 +4814,7 @@ int Bot::GetHandToHandDamage(void) {
return 2;
}
bool Bot::TryFinishingBlow(Mob *defender, SkillUseTypes skillinuse) {
bool Bot::TryFinishingBlow(Mob *defender, EQEmu::skills::SkillType skillinuse) {
if (!defender)
return false;
@@ -4855,12 +4856,12 @@ void Bot::DoRiposte(Mob* defender) {
}
}
void Bot::DoSpecialAttackDamage(Mob *who, SkillUseTypes skill, int32 max_damage, int32 min_damage, int32 hate_override,int ReuseTime, bool HitChance) {
void Bot::DoSpecialAttackDamage(Mob *who, EQEmu::skills::SkillType skill, int32 max_damage, int32 min_damage, int32 hate_override, int ReuseTime, bool HitChance) {
int32 hate = max_damage;
if(hate_override > -1)
hate = hate_override;
if(skill == SkillBash) {
if (skill == EQEmu::skills::SkillBash) {
const ItemInst* inst = GetBotItem(EQEmu::legacy::SlotSecondary);
const EQEmu::Item_Struct* botweapon = 0;
if(inst)
@@ -4876,7 +4877,7 @@ void Bot::DoSpecialAttackDamage(Mob *who, SkillUseTypes skill, int32 max_damage,
min_damage += (min_damage * GetMeleeMinDamageMod_SE(skill) / 100);
int hand = EQEmu::legacy::SlotPrimary;
if (skill == SkillThrowing || skill == SkillArchery)
if (skill == EQEmu::skills::SkillThrowing || skill == EQEmu::skills::SkillArchery)
hand = EQEmu::legacy::SlotRange;
if (who->AvoidDamage(this, max_damage, hand)) {
if (max_damage == -3)
@@ -4953,7 +4954,7 @@ void Bot::TryBackstab(Mob *other, int ReuseTime) {
} else {
RogueBackstab(other);
if (level > 54) {
float DoubleAttackProbability = ((GetSkill(SkillDoubleAttack) + GetLevel()) / 500.0f);
float DoubleAttackProbability = ((GetSkill(EQEmu::skills::SkillDoubleAttack) + GetLevel()) / 500.0f);
if(zone->random.Real(0, 1) < DoubleAttackProbability) {
if(other->GetHP() > 0)
RogueBackstab(other,false,ReuseTime);
@@ -4966,7 +4967,7 @@ void Bot::TryBackstab(Mob *other, int ReuseTime) {
} else if(aabonuses.FrontalBackstabMinDmg || itembonuses.FrontalBackstabMinDmg || spellbonuses.FrontalBackstabMinDmg) {
RogueBackstab(other, true);
if (level > 54) {
float DoubleAttackProbability = ((GetSkill(SkillDoubleAttack) + GetLevel()) / 500.0f);
float DoubleAttackProbability = ((GetSkill(EQEmu::skills::SkillDoubleAttack) + GetLevel()) / 500.0f);
if(zone->random.Real(0, 1) < DoubleAttackProbability)
if(other->GetHP() > 0)
RogueBackstab(other,true, ReuseTime);
@@ -5002,11 +5003,11 @@ void Bot::RogueBackstab(Mob* other, bool min_damage, int ReuseTime) {
if(primaryweapondamage > 0) {
if(level > 25) {
max_hit = (((((2 * backstab_dmg) * GetDamageTable(SkillBackstab) / 100) * 10 * GetSkill(SkillBackstab) / 355) + ((level - 25) / 3) + 1) * ((100 + RuleI(Combat, BackstabBonus)) / 100));
hate = (20 * backstab_dmg * GetSkill(SkillBackstab) / 355);
max_hit = (((((2 * backstab_dmg) * GetDamageTable(EQEmu::skills::SkillBackstab) / 100) * 10 * GetSkill(EQEmu::skills::SkillBackstab) / 355) + ((level - 25) / 3) + 1) * ((100 + RuleI(Combat, BackstabBonus)) / 100));
hate = (20 * backstab_dmg * GetSkill(EQEmu::skills::SkillBackstab) / 355);
} else {
max_hit = (((((2 * backstab_dmg) * GetDamageTable(SkillBackstab) / 100) * 10 * GetSkill(SkillBackstab) / 355) + 1) * ((100 + RuleI(Combat, BackstabBonus)) / 100));
hate = (20 * backstab_dmg * GetSkill(SkillBackstab) / 355);
max_hit = (((((2 * backstab_dmg) * GetDamageTable(EQEmu::skills::SkillBackstab) / 100) * 10 * GetSkill(EQEmu::skills::SkillBackstab) / 355) + 1) * ((100 + RuleI(Combat, BackstabBonus)) / 100));
hate = (20 * backstab_dmg * GetSkill(EQEmu::skills::SkillBackstab) / 355);
}
if (level < 51)
@@ -5014,7 +5015,7 @@ void Bot::RogueBackstab(Mob* other, bool min_damage, int ReuseTime) {
else
min_hit = ((level * ( level * 5 - 105)) / 100);
if(!other->CheckHitChance(this, SkillBackstab, 0))
if (!other->CheckHitChance(this, EQEmu::skills::SkillBackstab, 0))
ndamage = 0;
else {
if (min_damage) {
@@ -5029,7 +5030,7 @@ void Bot::RogueBackstab(Mob* other, bool min_damage, int ReuseTime) {
} else
ndamage = -5;
DoSpecialAttackDamage(other, SkillBackstab, ndamage, min_hit, hate, ReuseTime);
DoSpecialAttackDamage(other, EQEmu::skills::SkillBackstab, ndamage, min_hit, hate, ReuseTime);
DoAnim(anim1HPiercing);
}
@@ -5037,9 +5038,9 @@ void Bot::RogueAssassinate(Mob* other) {
ItemInst* botweaponInst = GetBotItem(EQEmu::legacy::SlotPrimary);
if(botweaponInst) {
if(GetWeaponDamage(other, botweaponInst))
other->Damage(this, 32000, SPELL_UNKNOWN, SkillBackstab);
other->Damage(this, 32000, SPELL_UNKNOWN, EQEmu::skills::SkillBackstab);
else
other->Damage(this, -5, SPELL_UNKNOWN, SkillBackstab);
other->Damage(this, -5, SPELL_UNKNOWN, EQEmu::skills::SkillBackstab);
}
DoAnim(anim1HPiercing);
@@ -5104,54 +5105,54 @@ void Bot::DoClassAttacks(Mob *target, bool IsRiposte) {
canBash = true;
if(!canBash || zone->random.Int(0, 100) > 25)
skill_to_use = SkillKick;
skill_to_use = EQEmu::skills::SkillKick;
else
skill_to_use = SkillBash;
skill_to_use = EQEmu::skills::SkillBash;
}
case RANGER:
case BEASTLORD:
skill_to_use = SkillKick;
skill_to_use = EQEmu::skills::SkillKick;
break;
case BERSERKER:
skill_to_use = SkillFrenzy;
skill_to_use = EQEmu::skills::SkillFrenzy;
break;
case CLERIC:
case SHADOWKNIGHT:
case PALADIN:
if(level >= RuleI(Combat, NPCBashKickLevel)){
if ((GetRace() == OGRE || GetRace() == TROLL || GetRace() == BARBARIAN) || (m_inv.GetItem(EQEmu::legacy::SlotSecondary) && m_inv.GetItem(EQEmu::legacy::SlotSecondary)->GetItem()->ItemType == EQEmu::item::ItemTypeShield) || (m_inv.GetItem(EQEmu::legacy::SlotPrimary) && m_inv.GetItem(EQEmu::legacy::SlotPrimary)->GetItem()->IsType2HWeapon() && GetAA(aa2HandBash) >= 1))
skill_to_use = SkillBash;
skill_to_use = EQEmu::skills::SkillBash;
}
break;
case MONK:
if(GetLevel() >= 30)
skill_to_use = SkillFlyingKick;
skill_to_use = EQEmu::skills::SkillFlyingKick;
else if(GetLevel() >= 25)
skill_to_use = SkillDragonPunch;
skill_to_use = EQEmu::skills::SkillDragonPunch;
else if(GetLevel() >= 20)
skill_to_use = SkillEagleStrike;
skill_to_use = EQEmu::skills::SkillEagleStrike;
else if(GetLevel() >= 10)
skill_to_use = SkillTigerClaw;
skill_to_use = EQEmu::skills::SkillTigerClaw;
else if(GetLevel() >= 5)
skill_to_use = SkillRoundKick;
skill_to_use = EQEmu::skills::SkillRoundKick;
else
skill_to_use = SkillKick;
skill_to_use = EQEmu::skills::SkillKick;
break;
case ROGUE:
skill_to_use = SkillBackstab;
skill_to_use = EQEmu::skills::SkillBackstab;
break;
}
if(skill_to_use == -1)
return;
if(skill_to_use == SkillBash) {
if (skill_to_use == EQEmu::skills::SkillBash) {
if (target != this) {
DoAnim(animTailRake);
if (GetWeaponDamage(target, GetBotItem(EQEmu::legacy::SlotSecondary)) <= 0 && GetWeaponDamage(target, GetBotItem(EQEmu::legacy::SlotShoulders)) <= 0)
dmg = -5;
else {
if(!target->CheckHitChance(this, SkillBash, 0))
if (!target->CheckHitChance(this, EQEmu::skills::SkillBash, 0))
dmg = 0;
else {
if(RuleB(Combat, UseIntervalAC))
@@ -5161,16 +5162,16 @@ void Bot::DoClassAttacks(Mob *target, bool IsRiposte) {
}
}
reuse = (BashReuseTime * 1000);
DoSpecialAttackDamage(target, SkillBash, dmg, 1, -1,reuse);
DoSpecialAttackDamage(target, EQEmu::skills::SkillBash, dmg, 1, -1, reuse);
did_attack = true;
}
}
if(skill_to_use == SkillFrenzy) {
if (skill_to_use == EQEmu::skills::SkillFrenzy) {
int AtkRounds = 3;
int skillmod = 0;
if(MaxSkill(SkillFrenzy) > 0)
skillmod = (100 * GetSkill(SkillFrenzy)/MaxSkill(SkillFrenzy));
if (MaxSkill(EQEmu::skills::SkillFrenzy) > 0)
skillmod = (100 * GetSkill(EQEmu::skills::SkillFrenzy) / MaxSkill(EQEmu::skills::SkillFrenzy));
int32 max_dmg = (26 + ((((GetLevel() - 6) * 2) * skillmod) / 100)) * ((100 + RuleI(Combat, FrenzyBonus)) / 100);
int32 min_dmg = 0;
@@ -5188,20 +5189,20 @@ void Bot::DoClassAttacks(Mob *target, bool IsRiposte) {
did_attack = true;
while(AtkRounds > 0) {
if (GetTarget() && (AtkRounds == 1 || zone->random.Int(0, 100) < 75)) {
DoSpecialAttackDamage(GetTarget(), SkillFrenzy, max_dmg, min_dmg, max_dmg, reuse, true);
DoSpecialAttackDamage(GetTarget(), EQEmu::skills::SkillFrenzy, max_dmg, min_dmg, max_dmg, reuse, true);
}
AtkRounds--;
}
}
if(skill_to_use == SkillKick) {
if (skill_to_use == EQEmu::skills::SkillKick) {
if(target != this) {
DoAnim(animKick);
if (GetWeaponDamage(target, GetBotItem(EQEmu::legacy::SlotFeet)) <= 0)
dmg = -5;
else {
if(!target->CheckHitChance(this, SkillKick, 0))
if (!target->CheckHitChance(this, EQEmu::skills::SkillKick, 0))
dmg = 0;
else {
if(RuleB(Combat, UseIntervalAC))
@@ -5211,17 +5212,17 @@ void Bot::DoClassAttacks(Mob *target, bool IsRiposte) {
}
}
reuse = (KickReuseTime * 1000);
DoSpecialAttackDamage(target, SkillKick, dmg, 1, -1, reuse);
DoSpecialAttackDamage(target, EQEmu::skills::SkillKick, dmg, 1, -1, reuse);
did_attack = true;
}
}
if(skill_to_use == SkillFlyingKick || skill_to_use == SkillDragonPunch || skill_to_use == SkillEagleStrike || skill_to_use == SkillTigerClaw || skill_to_use == SkillRoundKick) {
if (skill_to_use == EQEmu::skills::SkillFlyingKick || skill_to_use == EQEmu::skills::SkillDragonPunch || skill_to_use == EQEmu::skills::SkillEagleStrike || skill_to_use == EQEmu::skills::SkillTigerClaw || skill_to_use == EQEmu::skills::SkillRoundKick) {
reuse = (MonkSpecialAttack(target, skill_to_use) - 1);
MonkSpecialAttack(target, skill_to_use);
uint32 bDoubleSpecialAttack = (itembonuses.DoubleSpecialAttack + spellbonuses.DoubleSpecialAttack + aabonuses.DoubleSpecialAttack);
if(bDoubleSpecialAttack && (bDoubleSpecialAttack >= 100 || bDoubleSpecialAttack > zone->random.Int(0, 100))) {
int MonkSPA [5] = { SkillFlyingKick, SkillDragonPunch, SkillEagleStrike, SkillTigerClaw, SkillRoundKick };
int MonkSPA[5] = { EQEmu::skills::SkillFlyingKick, EQEmu::skills::SkillDragonPunch, EQEmu::skills::SkillEagleStrike, EQEmu::skills::SkillTigerClaw, EQEmu::skills::SkillRoundKick };
MonkSpecialAttack(target, MonkSPA[zone->random.Int(0, 4)]);
int TripleChance = 25;
if (bDoubleSpecialAttack > 100)
@@ -5235,7 +5236,7 @@ void Bot::DoClassAttacks(Mob *target, bool IsRiposte) {
did_attack = true;
}
if(skill_to_use == SkillBackstab) {
if (skill_to_use == EQEmu::skills::SkillBackstab) {
reuse = (BackstabReuseTime * 1000);
did_attack = true;
if (IsRiposte)
@@ -5246,9 +5247,9 @@ void Bot::DoClassAttacks(Mob *target, bool IsRiposte) {
classattack_timer.Start(reuse / HasteModifier);
}
bool Bot::TryHeadShot(Mob* defender, SkillUseTypes skillInUse) {
bool Bot::TryHeadShot(Mob* defender, EQEmu::skills::SkillType skillInUse) {
bool Result = false;
if(defender && (defender->GetBodyType() == BT_Humanoid) && (skillInUse == SkillArchery) && (GetClass() == RANGER) && (GetLevel() >= 62)) {
if (defender && (defender->GetBodyType() == BT_Humanoid) && (skillInUse == EQEmu::skills::SkillArchery) && (GetClass() == RANGER) && (GetLevel() >= 62)) {
int defenderLevel = defender->GetLevel();
int rangerLevel = GetLevel();
if(GetAA(aaHeadshot) && ((defenderLevel - 46) <= GetAA(aaHeadshot) * 2)) {
@@ -5515,7 +5516,7 @@ void Bot::SetAttackTimer() {
}
}
if (!GetSkill(SkillDualWield)) {
if (!GetSkill(EQEmu::skills::SkillDualWield)) {
attack_dw_timer.Disable();
continue;
}
@@ -6731,7 +6732,7 @@ int32 Bot::CalcManaRegen() {
if (IsSitting()) {
BuffFadeBySitModifier();
if(botclass != WARRIOR && botclass != MONK && botclass != ROGUE && botclass != BERSERKER) {
regen = ((((GetSkill(SkillMeditate) / 10) + (level - (level / 4))) / 4) + 4);
regen = ((((GetSkill(EQEmu::skills::SkillMeditate) / 10) + (level - (level / 4))) / 4) + 4);
regen += (spellbonuses.ManaRegen + itembonuses.ManaRegen);
} else
regen = (2 + spellbonuses.ManaRegen + itembonuses.ManaRegen);
@@ -7202,11 +7203,11 @@ void Bot::ProcessBotInspectionRequest(Bot* inspectedBot, Client* client) {
if(inst) {
item = inst->GetItem();
if(item) {
strcpy(insr->itemnames[SoF::inventory::SlotPowerSource], item->Name);
insr->itemicons[SoF::inventory::SlotPowerSource] = item->Icon;
strcpy(insr->itemnames[SoF::invslot::PossessionsPowerSource], item->Name);
insr->itemicons[SoF::invslot::PossessionsPowerSource] = item->Icon;
}
else
insr->itemicons[SoF::inventory::SlotPowerSource] = 0xFFFFFFFF;
insr->itemicons[SoF::invslot::PossessionsPowerSource] = 0xFFFFFFFF;
}
inst = inspectedBot->GetBotItem(EQEmu::legacy::SlotAmmo);
@@ -7214,11 +7215,11 @@ void Bot::ProcessBotInspectionRequest(Bot* inspectedBot, Client* client) {
if(inst) {
item = inst->GetItem();
if(item) {
strcpy(insr->itemnames[SoF::inventory::SlotAmmo], item->Name);
insr->itemicons[SoF::inventory::SlotAmmo] = item->Icon;
strcpy(insr->itemnames[SoF::invslot::PossessionsAmmo], item->Name);
insr->itemicons[SoF::invslot::PossessionsAmmo] = item->Icon;
}
else
insr->itemicons[SoF::inventory::SlotAmmo] = 0xFFFFFFFF;
insr->itemicons[SoF::invslot::PossessionsAmmo] = 0xFFFFFFFF;
}
strcpy(insr->text, inspectedBot->GetInspectMessage().text);
@@ -7527,7 +7528,7 @@ void Bot::AddItemBonuses(const ItemInst *inst, StatBonuses* newbon, bool isAug,
}
}
if (item->SkillModValue != 0 && item->SkillModType <= HIGHEST_SKILL){
if (item->SkillModValue != 0 && item->SkillModType <= EQEmu::skills::HIGHEST_SKILL){
if ((item->SkillModValue > 0 && newbon->skillmod[item->SkillModType] < item->SkillModValue) ||
(item->SkillModValue < 0 && newbon->skillmod[item->SkillModType] > item->SkillModValue))
{
@@ -7535,7 +7536,7 @@ void Bot::AddItemBonuses(const ItemInst *inst, StatBonuses* newbon, bool isAug,
}
}
if (item->ExtraDmgSkill != 0 && item->ExtraDmgSkill <= HIGHEST_SKILL) {
if (item->ExtraDmgSkill != 0 && item->ExtraDmgSkill <= EQEmu::skills::HIGHEST_SKILL) {
if((newbon->SkillDamageAmount[item->ExtraDmgSkill] + item->ExtraDmgAmt) > RuleI(Character, ItemExtraDmgCap))
newbon->SkillDamageAmount[item->ExtraDmgSkill] = RuleI(Character, ItemExtraDmgCap);
else
@@ -7598,7 +7599,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(SkillBrassInstruments), GetSkill(SkillPercussionInstruments), GetSkill(SkillSinging), GetSkill(SkillStringedInstruments), GetSkill(SkillWindInstruments));
GetSkill(EQEmu::skills::SkillBrassInstruments), GetSkill(EQEmu::skills::SkillPercussionInstruments), GetSkill(EQEmu::skills::SkillSinging), GetSkill(EQEmu::skills::SkillStringedInstruments), GetSkill(EQEmu::skills::SkillWindInstruments));
}
/*if(this->Save())
@@ -7617,11 +7618,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(SkillBrassInstruments) + GetBrassMod(),
GetSkill(SkillPercussionInstruments) + GetPercMod(),
GetSkill(SkillSinging) + GetSingMod(),
GetSkill(SkillStringedInstruments) + GetStringMod(),
GetSkill(SkillWindInstruments) + GetWindMod());
GetSkill(EQEmu::skills::SkillBrassInstruments) + GetBrassMod(),
GetSkill(EQEmu::skills::SkillPercussionInstruments) + GetPercMod(),
GetSkill(EQEmu::skills::SkillSinging) + GetSingMod(),
GetSkill(EQEmu::skills::SkillStringedInstruments) + GetStringMod(),
GetSkill(EQEmu::skills::SkillWindInstruments) + GetWindMod());
GetBotOwner()->Message(15, "Bard Skill Mods-- Brass: %i, Percussion: %i, Singing: %i, Stringed: %i, Wind: %i", GetBrassMod(), GetPercMod(), GetSingMod(), GetStringMod(), GetWindMod());
}
}
zone/bot.h
+10 -10
View File
@@ -205,8 +205,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, 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, int special = 0);
virtual bool Death(Mob* killerMob, int32 damage, uint16 spell_id, EQEmu::skills::SkillType attack_skill);
virtual void Damage(Mob* from, int32 damage, uint16 spell_id, EQEmu::skills::SkillType attack_skill, bool avoidable = true, int8 buffslot = -1, bool iBuffTic = false, int special = 0);
virtual bool Attack(Mob* other, int Hand = EQEmu::legacy::SlotPrimary, bool FromRiposte = false, bool IsStrikethrough = false, bool IsFromSpell = false,
ExtraAttackOptions *opts = nullptr, int special = 0);
virtual bool HasRaid() { return (GetRaid() ? true : false); }
@@ -239,23 +239,23 @@ public:
uint16 BotGetSpellPriority(int spellslot) { return AIspells[spellslot].priority; }
virtual float GetProcChances(float ProcBonus, uint16 hand);
virtual int GetHandToHandDamage(void);
virtual bool TryFinishingBlow(Mob *defender, SkillUseTypes skillinuse);
virtual bool TryFinishingBlow(Mob *defender, EQEmu::skills::SkillType skillinuse);
virtual void DoRiposte(Mob* defender);
inline virtual int32 GetATK() const { return ATK + itembonuses.ATK + spellbonuses.ATK + ((GetSTR() + GetSkill(SkillOffense)) * 9 / 10); }
inline virtual int32 GetATK() const { return ATK + itembonuses.ATK + spellbonuses.ATK + ((GetSTR() + GetSkill(EQEmu::skills::SkillOffense)) * 9 / 10); }
inline virtual int32 GetATKBonus() const { return itembonuses.ATK + spellbonuses.ATK; }
uint32 GetTotalATK();
uint32 GetATKRating();
uint16 GetPrimarySkillValue();
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);
uint16 MaxSkill(EQEmu::skills::SkillType skillid, uint16 class_, uint16 level) const;
inline uint16 MaxSkill(EQEmu::skills::SkillType skillid) const { return MaxSkill(skillid, GetClass(), GetLevel()); }
virtual void DoSpecialAttackDamage(Mob *who, EQEmu::skills::SkillType 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, SkillUseTypes skillInUse);
virtual void DoMeleeSkillAttackDmg(Mob* other, uint16 weapon_damage, SkillUseTypes skillinuse, int16 chance_mod=0, int16 focus=0, bool CanRiposte=false, int ReuseTime =0);
virtual void ApplySpecialAttackMod(SkillUseTypes skill, int32 &dmg, int32 &mindmg);
virtual bool TryHeadShot(Mob* defender, EQEmu::skills::SkillType skillInUse);
virtual void DoMeleeSkillAttackDmg(Mob* other, uint16 weapon_damage, EQEmu::skills::SkillType skillinuse, int16 chance_mod = 0, int16 focus = 0, bool CanRiposte = false, int ReuseTime = 0);
virtual void ApplySpecialAttackMod(EQEmu::skills::SkillType skill, int32 &dmg, int32 &mindmg);
bool CanDoSpecialAttack(Mob *other);
virtual int32 CheckAggroAmount(uint16 spellid);
virtual void CalcBonuses();
zone/bot_command.cpp
+6 -5
View File
@@ -54,6 +54,7 @@
#include "../common/rulesys.h"
#include "../common/serverinfo.h"
#include "../common/string_util.h"
#include "../common/say_link.h"
#include "../common/eqemu_logsys.h"
@@ -335,11 +336,11 @@ public:
while (spells[spell_id].typedescnum == 27) {
if (!spells[spell_id].goodEffect)
break;
if (spells[spell_id].skill != SkillOffense && spells[spell_id].skill != SkillDefense)
if (spells[spell_id].skill != EQEmu::skills::SkillOffense && spells[spell_id].skill != EQEmu::skills::SkillDefense)
break;
entry_prototype = new STStanceEntry();
if (spells[spell_id].skill == SkillOffense)
if (spells[spell_id].skill == EQEmu::skills::SkillOffense)
entry_prototype->SafeCastToStance()->stance_type = BCEnum::StT_Aggressive;
else
entry_prototype->SafeCastToStance()->stance_type = BCEnum::StT_Defensive;
@@ -2388,7 +2389,7 @@ namespace ActionableBots
sbl.remove_if([bot_owner](Bot* l) { return (!l->IsBotArcher()); });
}
static void Filter_ByHighestSkill(Client* bot_owner, std::list<Bot*>& sbl, SkillUseTypes skill_type, float& skill_value) {
static void Filter_ByHighestSkill(Client* bot_owner, std::list<Bot*>& sbl, EQEmu::skills::SkillType skill_type, float& skill_value) {
sbl.remove_if([bot_owner](Bot* l) { return (!MyBots::IsMyBot(bot_owner, l)); });
skill_value = 0.0f;
@@ -2425,7 +2426,7 @@ namespace ActionableBots
sbl.remove_if([bot_owner](const Bot* l) { return (l->GetClass() == ROGUE && l->GetLevel() < 5); });
sbl.remove_if([bot_owner](const Bot* l) { return (l->GetClass() == BARD && l->GetLevel() < 40); });
ActionableBots::Filter_ByHighestSkill(bot_owner, sbl, SkillPickLock, pick_lock_value);
ActionableBots::Filter_ByHighestSkill(bot_owner, sbl, EQEmu::skills::SkillPickLock, pick_lock_value);
}
};
@@ -3906,7 +3907,7 @@ void bot_command_taunt(Client *c, const Seperator *sep)
int taunting_count = 0;
for (auto bot_iter : sbl) {
if (!bot_iter->GetSkill(SkillTaunt))
if (!bot_iter->GetSkill(EQEmu::skills::SkillTaunt))
continue;
if (toggle_taunt)
zone/client.cpp
+54 -53
View File
@@ -1433,8 +1433,8 @@ bool Client::UpdateLDoNPoints(int32 points, uint32 theme)
return(false);
}
void Client::SetSkill(SkillUseTypes skillid, uint16 value) {
if (skillid > HIGHEST_SKILL)
void Client::SetSkill(EQEmu::skills::SkillType skillid, uint16 value) {
if (skillid > EQEmu::skills::HIGHEST_SKILL)
return;
m_pp.skills[skillid] = value; // We need to be able to #setskill 254 and 255 to reset skills
@@ -1470,8 +1470,8 @@ void Client::IncreaseLanguageSkill(int skill_id, int value) {
Message_StringID( MT_Skills, LANG_SKILL_IMPROVED ); //Notify client
}
void Client::AddSkill(SkillUseTypes skillid, uint16 value) {
if (skillid > HIGHEST_SKILL)
void Client::AddSkill(EQEmu::skills::SkillType skillid, uint16 value) {
if (skillid > EQEmu::skills::HIGHEST_SKILL)
return;
value = GetRawSkill(skillid) + value;
uint16 max = GetMaxSkillAfterSpecializationRules(skillid, MaxSkill(skillid));
@@ -2289,12 +2289,12 @@ uint64 Client::GetAllMoney() {
(static_cast<uint64>(m_pp.platinum_shared) * 1000)))));
}
bool Client::CheckIncreaseSkill(SkillUseTypes skillid, Mob *against_who, int chancemodi) {
bool Client::CheckIncreaseSkill(EQEmu::skills::SkillType skillid, Mob *against_who, int chancemodi) {
if (IsDead() || IsUnconscious())
return false;
if (IsAIControlled()) // no skillups while chamred =p
return false;
if (skillid > HIGHEST_SKILL)
if (skillid > EQEmu::skills::HIGHEST_SKILL)
return false;
int skillval = GetRawSkill(skillid);
int maxskill = GetMaxSkillAfterSpecializationRules(skillid, MaxSkill(skillid));
@@ -2359,34 +2359,34 @@ void Client::CheckLanguageSkillIncrease(uint8 langid, uint8 TeacherSkill) {
}
}
bool Client::HasSkill(SkillUseTypes skill_id) const {
bool Client::HasSkill(EQEmu::skills::SkillType skill_id) const {
return((GetSkill(skill_id) > 0) && CanHaveSkill(skill_id));
}
bool Client::CanHaveSkill(SkillUseTypes skill_id) const {
if (ClientVersion() < EQEmu::versions::ClientVersion::RoF2 && class_ == BERSERKER && skill_id == Skill1HPiercing)
skill_id = Skill2HPiercing;
bool Client::CanHaveSkill(EQEmu::skills::SkillType skill_id) const {
if (ClientVersion() < EQEmu::versions::ClientVersion::RoF2 && class_ == BERSERKER && skill_id == EQEmu::skills::Skill1HPiercing)
skill_id = EQEmu::skills::Skill2HPiercing;
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(SkillUseTypes skillid, uint16 class_, uint16 level) const {
if (ClientVersion() < EQEmu::versions::ClientVersion::RoF2 && class_ == BERSERKER && skillid == Skill1HPiercing)
skillid = Skill2HPiercing;
uint16 Client::MaxSkill(EQEmu::skills::SkillType skillid, uint16 class_, uint16 level) const {
if (ClientVersion() < EQEmu::versions::ClientVersion::RoF2 && class_ == BERSERKER && skillid == EQEmu::skills::Skill1HPiercing)
skillid = EQEmu::skills::Skill2HPiercing;
return(database.GetSkillCap(class_, skillid, level));
}
uint8 Client::SkillTrainLevel(SkillUseTypes skillid, uint16 class_)
uint8 Client::SkillTrainLevel(EQEmu::skills::SkillType skillid, uint16 class_)
{
if (ClientVersion() < EQEmu::versions::ClientVersion::RoF2 && class_ == BERSERKER && skillid == Skill1HPiercing)
skillid = Skill2HPiercing;
if (ClientVersion() < EQEmu::versions::ClientVersion::RoF2 && class_ == BERSERKER && skillid == EQEmu::skills::Skill1HPiercing)
skillid = EQEmu::skills::Skill2HPiercing;
return(database.GetTrainLevel(class_, skillid, RuleI(Character, MaxLevel)));
}
uint16 Client::GetMaxSkillAfterSpecializationRules(SkillUseTypes skillid, uint16 maxSkill)
uint16 Client::GetMaxSkillAfterSpecializationRules(EQEmu::skills::SkillType skillid, uint16 maxSkill)
{
uint16 Result = maxSkill;
@@ -2396,13 +2396,13 @@ uint16 Client::GetMaxSkillAfterSpecializationRules(SkillUseTypes skillid, uint16
uint16 MaxSpecializations = GetAA(aaSecondaryForte) ? 2 : 1;
if(skillid >= SkillSpecializeAbjure && skillid <= SkillSpecializeEvocation)
if (skillid >= EQEmu::skills::SkillSpecializeAbjure && skillid <= EQEmu::skills::SkillSpecializeEvocation)
{
bool HasPrimarySpecSkill = false;
int NumberOfPrimarySpecSkills = 0;
for(int i = SkillSpecializeAbjure; i <= SkillSpecializeEvocation; ++i)
for (int i = EQEmu::skills::SkillSpecializeAbjure; i <= EQEmu::skills::SkillSpecializeEvocation; ++i)
{
if(m_pp.skills[i] > 50)
{
@@ -2459,8 +2459,8 @@ uint16 Client::GetMaxSkillAfterSpecializationRules(SkillUseTypes skillid, uint16
Message(13, "Your spell casting specializations skills have been reset. "
"Only %i primary specialization skill is allowed.", MaxSpecializations);
for(int i = SkillSpecializeAbjure; i <= SkillSpecializeEvocation; ++i)
SetSkill((SkillUseTypes)i, 1);
for (int i = EQEmu::skills::SkillSpecializeAbjure; i <= EQEmu::skills::SkillSpecializeEvocation; ++i)
SetSkill((EQEmu::skills::SkillType)i, 1);
Save();
@@ -2643,14 +2643,14 @@ bool Client::BindWound(Mob *bindmob, bool start, bool fail)
bind_out->type = 1; // Done
QueuePacket(outapp);
bind_out->type = 0;
CheckIncreaseSkill(SkillBindWound, nullptr, 5);
CheckIncreaseSkill(EQEmu::skills::SkillBindWound, nullptr, 5);
int maxHPBonus = spellbonuses.MaxBindWound + itembonuses.MaxBindWound +
aabonuses.MaxBindWound;
int max_percent = 50 + 10 * maxHPBonus;
if (GetClass() == MONK && GetSkill(SkillBindWound) > 200) {
if (GetClass() == MONK && GetSkill(EQEmu::skills::SkillBindWound) > 200) {
max_percent = 70 + 10 * maxHPBonus;
}
@@ -2663,10 +2663,11 @@ bool Client::BindWound(Mob *bindmob, bool start, bool fail)
// 0.120 per skill point, 0.60 per skill level, minimum 3 max 30
int bindhps = 3;
if (GetSkill(SkillBindWound) > 200) {
bindhps += GetSkill(SkillBindWound) * 4 / 10;
} else if (GetSkill(SkillBindWound) >= 10) {
bindhps += GetSkill(SkillBindWound) / 4;
if (GetSkill(EQEmu::skills::SkillBindWound) > 200) {
bindhps += GetSkill(EQEmu::skills::SkillBindWound) * 4 / 10;
}
else if (GetSkill(EQEmu::skills::SkillBindWound) >= 10) {
bindhps += GetSkill(EQEmu::skills::SkillBindWound) / 4;
}
// Implementation of aaMithanielsBinding is a guess (the multiplier)
@@ -3774,7 +3775,7 @@ void Client::SendPickPocketResponse(Mob *from, uint32 amt, int type, const EQEmu
pick_out->coin = amt;
pick_out->from = GetID();
pick_out->to = from->GetID();
pick_out->myskill = GetSkill(SkillPickPockets);
pick_out->myskill = GetSkill(EQEmu::skills::SkillPickPockets);
if ((type >= PickPocketPlatinum) && (type <= PickPocketCopper) && (amt == 0))
type = PickPocketFailed;
@@ -4196,11 +4197,11 @@ bool Client::GroupFollow(Client* inviter) {
uint16 Client::GetPrimarySkillValue()
{
SkillUseTypes skill = HIGHEST_SKILL; //because nullptr == 0, which is 1H Slashing, & we want it to return 0 from GetSkill
EQEmu::skills::SkillType skill = EQEmu::skills::HIGHEST_SKILL; //because nullptr == 0, which is 1H Slashing, & we want it to return 0 from GetSkill
bool equiped = m_inv.GetItem(EQEmu::legacy::SlotPrimary);
if (!equiped)
skill = SkillHandtoHand;
skill = EQEmu::skills::SkillHandtoHand;
else {
@@ -4208,31 +4209,31 @@ uint16 Client::GetPrimarySkillValue()
switch (type) {
case EQEmu::item::ItemType1HSlash: // 1H Slashing
skill = Skill1HSlashing;
skill = EQEmu::skills::Skill1HSlashing;
break;
case EQEmu::item::ItemType2HSlash: // 2H Slashing
skill = Skill2HSlashing;
skill = EQEmu::skills::Skill2HSlashing;
break;
case EQEmu::item::ItemType1HPiercing: // Piercing
skill = Skill1HPiercing;
skill = EQEmu::skills::Skill1HPiercing;
break;
case EQEmu::item::ItemType1HBlunt: // 1H Blunt
skill = Skill1HBlunt;
skill = EQEmu::skills::Skill1HBlunt;
break;
case EQEmu::item::ItemType2HBlunt: // 2H Blunt
skill = Skill2HBlunt;
skill = EQEmu::skills::Skill2HBlunt;
break;
case EQEmu::item::ItemType2HPiercing: // 2H Piercing
if (IsClient() && CastToClient()->ClientVersion() < EQEmu::versions::ClientVersion::RoF2)
skill = Skill1HPiercing;
skill = EQEmu::skills::Skill1HPiercing;
else
skill = Skill2HPiercing;
skill = EQEmu::skills::Skill2HPiercing;
break;
case EQEmu::item::ItemTypeMartial: // Hand to Hand
skill = SkillHandtoHand;
skill = EQEmu::skills::SkillHandtoHand;
break;
default: // All other types default to Hand to Hand
skill = SkillHandtoHand;
skill = EQEmu::skills::SkillHandtoHand;
break;
}
}
@@ -4246,7 +4247,7 @@ uint32 Client::GetTotalATK()
uint32 WornCap = itembonuses.ATK;
if(IsClient()) {
AttackRating = ((WornCap * 1.342) + (GetSkill(SkillOffense) * 1.345) + ((GetSTR() - 66) * 0.9) + (GetPrimarySkillValue() * 2.69));
AttackRating = ((WornCap * 1.342) + (GetSkill(EQEmu::skills::SkillOffense) * 1.345) + ((GetSTR() - 66) * 0.9) + (GetPrimarySkillValue() * 2.69));
AttackRating += aabonuses.ATK + GroupLeadershipAAOffenseEnhancement();
if (AttackRating < 10)
@@ -4264,7 +4265,7 @@ uint32 Client::GetATKRating()
{
uint32 AttackRating = 0;
if(IsClient()) {
AttackRating = (GetSkill(SkillOffense) * 1.345) + ((GetSTR() - 66) * 0.9) + (GetPrimarySkillValue() * 2.69);
AttackRating = (GetSkill(EQEmu::skills::SkillOffense) * 1.345) + ((GetSTR() - 66) * 0.9) + (GetPrimarySkillValue() * 2.69);
if (AttackRating < 10)
AttackRating = 10;
@@ -4639,7 +4640,7 @@ void Client::HandleLDoNOpen(NPC *target)
AddEXP(target->GetLevel()*target->GetLevel()*2625/10, GetLevelCon(target->GetLevel()));
}
}
target->Death(this, 0, SPELL_UNKNOWN, SkillHandtoHand);
target->Death(this, 0, SPELL_UNKNOWN, EQEmu::skills::SkillHandtoHand);
}
}
}
@@ -4952,14 +4953,14 @@ void Client::ShowSkillsWindow()
{
const char *WindowTitle = "Skills";
std::string WindowText;
std::map<SkillUseTypes, std::string> Skills = EQEmu::GetSkillUseTypesMap();
std::map<EQEmu::skills::SkillType, std::string> Skills = EQEmu::skills::GetSkillTypeMap();
if (ClientVersion() < EQEmu::versions::ClientVersion::RoF2)
Skills[Skill1HPiercing] = "Piercing";
Skills[EQEmu::skills::Skill1HPiercing] = "Piercing";
// print out all available skills
for (auto skills_iter : Skills) {
if (skills_iter.first == Skill2HPiercing && ClientVersion() < EQEmu::versions::ClientVersion::RoF2)
if (skills_iter.first == EQEmu::skills::Skill2HPiercing && ClientVersion() < EQEmu::versions::ClientVersion::RoF2)
continue;
if (!GetSkill(skills_iter.first) && !MaxSkill(skills_iter.first))
continue;
@@ -5721,11 +5722,11 @@ void Client::ProcessInspectRequest(Client* requestee, Client* requester) {
if(item) {
// we shouldn't do this..but, that's the way it's coded atm...
// (this type of action should be handled exclusively in the client translator)
strcpy(insr->itemnames[SoF::inventory::SlotPowerSource], item->Name);
insr->itemicons[SoF::inventory::SlotPowerSource] = item->Icon;
strcpy(insr->itemnames[SoF::invslot::PossessionsPowerSource], item->Name);
insr->itemicons[SoF::invslot::PossessionsPowerSource] = item->Icon;
}
else
insr->itemicons[SoF::inventory::SlotPowerSource] = 0xFFFFFFFF;
insr->itemicons[SoF::invslot::PossessionsPowerSource] = 0xFFFFFFFF;
}
inst = requestee->GetInv().GetItem(EQEmu::legacy::SlotAmmo);
@@ -5733,11 +5734,11 @@ void Client::ProcessInspectRequest(Client* requestee, Client* requester) {
if(inst) {
item = inst->GetItem();
if(item) {
strcpy(insr->itemnames[SoF::inventory::SlotAmmo], item->Name);
insr->itemicons[SoF::inventory::SlotAmmo] = item->Icon;
strcpy(insr->itemnames[SoF::invslot::PossessionsAmmo], item->Name);
insr->itemicons[SoF::invslot::PossessionsAmmo] = item->Icon;
}
else
insr->itemicons[SoF::inventory::SlotAmmo] = 0xFFFFFFFF;
insr->itemicons[SoF::invslot::PossessionsAmmo] = 0xFFFFFFFF;
}
strcpy(insr->text, requestee->GetInspectMessage().text);
@@ -6750,7 +6751,7 @@ void Client::SendStatsWindow(Client* client, bool use_window)
};
std::string skill_mods = "";
for(int j = 0; j <= HIGHEST_SKILL; j++) {
for (int j = 0; j <= EQEmu::skills::HIGHEST_SKILL; j++) {
if(itembonuses.skillmod[j] > 0)
skill_mods += indP + skill_list[j] + " : +" + itoa(itembonuses.skillmod[j]) + "%<br>";
else if(itembonuses.skillmod[j] < 0)
@@ -6758,7 +6759,7 @@ void Client::SendStatsWindow(Client* client, bool use_window)
}
std::string skill_dmgs = "";
for(int j = 0; j <= HIGHEST_SKILL; j++) {
for (int j = 0; j <= EQEmu::skills::HIGHEST_SKILL; j++) {
if((itembonuses.SkillDamageAmount[j] + spellbonuses.SkillDamageAmount[j]) > 0)
skill_dmgs += indP + skill_list[j] + " : +" + itoa(itembonuses.SkillDamageAmount[j] + spellbonuses.SkillDamageAmount[j]) + "<br>";
else if((itembonuses.SkillDamageAmount[j] + spellbonuses.SkillDamageAmount[j]) < 0)
zone/client.h
+21 -20
View File
@@ -220,8 +220,8 @@ public:
~Client();
//abstract virtual function implementations required by base abstract class
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, int special = 0);
virtual bool Death(Mob* killerMob, int32 damage, uint16 spell_id, EQEmu::skills::SkillType attack_skill);
virtual void Damage(Mob* from, int32 damage, uint16 spell_id, EQEmu::skills::SkillType attack_skill, bool avoidable = true, int8 buffslot = -1, bool iBuffTic = false, int special = 0);
virtual bool Attack(Mob* other, int Hand = EQEmu::legacy::SlotPrimary, bool FromRiposte = false, bool IsStrikethrough = false, bool IsFromSpell = false,
ExtraAttackOptions *opts = nullptr, int special = 0);
virtual bool HasRaid() { return (GetRaid() ? true : false); }
@@ -306,7 +306,7 @@ public:
void VoiceMacroReceived(uint32 Type, char *Target, uint32 MacroNumber);
void SendSound();
void LearnRecipe(uint32 recipeID);
bool CanIncreaseTradeskill(SkillUseTypes tradeskill);
bool CanIncreaseTradeskill(EQEmu::skills::SkillType tradeskill);
EQApplicationPacket* ReturnItemPacket(int16 slot_id, const ItemInst* inst, ItemPacketType packet_type);
@@ -418,7 +418,7 @@ public:
virtual void CalcBonuses();
//these are all precalculated now
inline virtual int32 GetAC() const { return AC; }
inline virtual int32 GetATK() const { return ATK + itembonuses.ATK + spellbonuses.ATK + ((GetSTR() + GetSkill(SkillOffense)) * 9 / 10); }
inline virtual int32 GetATK() const { return ATK + itembonuses.ATK + spellbonuses.ATK + ((GetSTR() + GetSkill(EQEmu::skills::SkillOffense)) * 9 / 10); }
inline virtual int32 GetATKBonus() const { return itembonuses.ATK + spellbonuses.ATK; }
inline virtual int GetHaste() const { return Haste; }
int GetRawACNoShield(int &shield_ac) const;
@@ -682,31 +682,31 @@ public:
uint16 GetSkillPoints() { return m_pp.points;}
void SetSkillPoints(int inp) { m_pp.points = inp;}
void IncreaseSkill(int skill_id, int value = 1) { if (skill_id <= HIGHEST_SKILL) { m_pp.skills[skill_id] += value; } }
void IncreaseSkill(int skill_id, int value = 1) { if (skill_id <= EQEmu::skills::HIGHEST_SKILL) { m_pp.skills[skill_id] += value; } }
void IncreaseLanguageSkill(int skill_id, int value = 1);
virtual uint16 GetSkill(SkillUseTypes skill_id) const {if (skill_id <= HIGHEST_SKILL) {return(itembonuses.skillmod[skill_id] > 0 ? (itembonuses.skillmodmax[skill_id] > 0 ? std::min(m_pp.skills[skill_id] + itembonuses.skillmodmax[skill_id], m_pp.skills[skill_id] * (100 + itembonuses.skillmod[skill_id]) / 100) : 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);
virtual uint16 GetSkill(EQEmu::skills::SkillType skill_id) const { if (skill_id <= EQEmu::skills::HIGHEST_SKILL) { return(itembonuses.skillmod[skill_id] > 0 ? (itembonuses.skillmodmax[skill_id] > 0 ? std::min(m_pp.skills[skill_id] + itembonuses.skillmodmax[skill_id], m_pp.skills[skill_id] * (100 + itembonuses.skillmod[skill_id]) / 100) : m_pp.skills[skill_id] * (100 + itembonuses.skillmod[skill_id]) / 100) : m_pp.skills[skill_id]); } return 0; }
uint32 GetRawSkill(EQEmu::skills::SkillType skill_id) const { if (skill_id <= EQEmu::skills::HIGHEST_SKILL) { return(m_pp.skills[skill_id]); } return 0; }
bool HasSkill(EQEmu::skills::SkillType skill_id) const;
bool CanHaveSkill(EQEmu::skills::SkillType skill_id) const;
void SetSkill(EQEmu::skills::SkillType skill_num, uint16 value);
void AddSkill(EQEmu::skills::SkillType skillid, uint16 value);
void CheckSpecializeIncrease(uint16 spell_id);
void CheckSongSkillIncrease(uint16 spell_id);
bool CheckIncreaseSkill(SkillUseTypes skillid, Mob *against_who, int chancemodi = 0);
bool CheckIncreaseSkill(EQEmu::skills::SkillType 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(SkillUseTypes skillid, uint16 class_, uint16 level) const;
inline uint16 MaxSkill(SkillUseTypes skillid) const { return MaxSkill(skillid, GetClass(), GetLevel()); }
uint8 SkillTrainLevel(SkillUseTypes skillid, uint16 class_);
uint16 MaxSkill(EQEmu::skills::SkillType skillid, uint16 class_, uint16 level) const;
inline uint16 MaxSkill(EQEmu::skills::SkillType skillid) const { return MaxSkill(skillid, GetClass(), GetLevel()); }
uint8 SkillTrainLevel(EQEmu::skills::SkillType skillid, uint16 class_);
void TradeskillSearchResults(const std::string &query, 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, SkillUseTypes tradeskill);
void CheckIncreaseTradeskill(int16 bonusstat, int16 stat_modifier, float skillup_modifier, uint16 success_modifier, EQEmu::skills::SkillType tradeskill);
void GMKill();
inline bool IsMedding() const {return medding;}
@@ -928,7 +928,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(SkillUseTypes skillid, uint16 maxSkill);
uint16 GetMaxSkillAfterSpecializationRules(EQEmu::skills::SkillType 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;
@@ -1176,13 +1176,14 @@ public:
int32 GetActCHA() { return( std::min(GetMaxCHA(), GetCHA()) ); }
void LoadAccountFlags();
void SetAccountFlag(std::string flag, std::string val);
std::string GetAccountFlag(std::string flag); float GetDamageMultiplier(SkillUseTypes);
std::string GetAccountFlag(std::string flag);
float GetDamageMultiplier(EQEmu::skills::SkillType how_long_has_this_been_missing);
void Consume(const EQEmu::Item_Struct *item, uint8 type, int16 slot, bool auto_consume);
void PlayMP3(const char* fname);
void ExpeditionSay(const char *str, int ExpID);
int mod_client_damage(int damage, SkillUseTypes skillinuse, int hand, const ItemInst* weapon, Mob* other);
int mod_client_damage(int damage, EQEmu::skills::SkillType skillinuse, int hand, const ItemInst* weapon, Mob* other);
bool mod_client_message(char* message, uint8 chan_num);
bool mod_can_increase_skill(SkillUseTypes skillid, Mob* against_who);
bool mod_can_increase_skill(EQEmu::skills::SkillType 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);
zone/client_mods.cpp
+21 -21
View File
@@ -1032,7 +1032,7 @@ int32 Client::acmod()
int32 Client::CalcAC()
{
// new formula
int avoidance = (acmod() + ((GetSkill(SkillDefense) + itembonuses.HeroicAGI / 10) * 16) / 9);
int avoidance = (acmod() + ((GetSkill(EQEmu::skills::SkillDefense) + itembonuses.HeroicAGI / 10) * 16) / 9);
if (avoidance < 0) {
avoidance = 0;
}
@@ -1040,13 +1040,13 @@ int32 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(SkillDefense) + itembonuses.HeroicAGI / 10) / 4 + (itembonuses.AC + 1);
mitigation = (GetSkill(EQEmu::skills::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(SkillDefense) + itembonuses.HeroicAGI / 10) / 3 + ((itembonuses.AC * 4) / 3);
mitigation = (GetSkill(EQEmu::skills::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...
}
@@ -1085,11 +1085,11 @@ int32 Client::GetACMit()
{
int mitigation = 0;
if (m_pp.class_ == WIZARD || m_pp.class_ == MAGICIAN || m_pp.class_ == NECROMANCER || m_pp.class_ == ENCHANTER) {
mitigation = (GetSkill(SkillDefense) + itembonuses.HeroicAGI / 10) / 4 + (itembonuses.AC + 1);
mitigation = (GetSkill(EQEmu::skills::SkillDefense) + itembonuses.HeroicAGI / 10) / 4 + (itembonuses.AC + 1);
mitigation -= 4;
}
else {
mitigation = (GetSkill(SkillDefense) + itembonuses.HeroicAGI / 10) / 3 + ((itembonuses.AC * 4) / 3);
mitigation = (GetSkill(EQEmu::skills::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...
}
@@ -1109,7 +1109,7 @@ int32 Client::GetACMit()
int32 Client::GetACAvoid()
{
int32 avoidance = (acmod() + ((GetSkill(SkillDefense) + itembonuses.HeroicAGI / 10) * 16) / 9);
int32 avoidance = (acmod() + ((GetSkill(EQEmu::skills::SkillDefense) + itembonuses.HeroicAGI / 10) * 16) / 9);
if (avoidance < 0) {
avoidance = 0;
}
@@ -1247,8 +1247,8 @@ int32 Client::CalcBaseManaRegen()
uint8 clevel = GetLevel();
int32 regen = 0;
if (IsSitting() || (GetHorseId() != 0)) {
if (HasSkill(SkillMeditate)) {
regen = (((GetSkill(SkillMeditate) / 10) + (clevel - (clevel / 4))) / 4) + 4;
if (HasSkill(EQEmu::skills::SkillMeditate)) {
regen = (((GetSkill(EQEmu::skills::SkillMeditate) / 10) + (clevel - (clevel / 4))) / 4) + 4;
}
else {
regen = 2;
@@ -1267,11 +1267,11 @@ int32 Client::CalcManaRegen()
//this should be changed so we dont med while camping, etc...
if (IsSitting() || (GetHorseId() != 0)) {
BuffFadeBySitModifier();
if (HasSkill(SkillMeditate)) {
if (HasSkill(EQEmu::skills::SkillMeditate)) {
this->medding = true;
regen = (((GetSkill(SkillMeditate) / 10) + (clevel - (clevel / 4))) / 4) + 4;
regen = (((GetSkill(EQEmu::skills::SkillMeditate) / 10) + (clevel - (clevel / 4))) / 4) + 4;
regen += spellbonuses.ManaRegen + itembonuses.ManaRegen;
CheckIncreaseSkill(SkillMeditate, nullptr, -5);
CheckIncreaseSkill(EQEmu::skills::SkillMeditate, nullptr, -5);
}
else {
regen = 2 + spellbonuses.ManaRegen + itembonuses.ManaRegen;
@@ -1355,7 +1355,7 @@ uint32 Client::CalcCurrentWeight()
This is the ONLY instance I have seen where the client is hard coded to particular Item IDs to set a certain property for an item. It is very odd.
*/
// SoD+ client has no weight for coin
if (EQEmu::limits::CoinHasWeight(EQEmu::versions::ConvertClientVersionToInventoryVersion(ClientVersion()))) {
if (EQEmu::profile::CoinHasWeight(EQEmu::versions::ConvertClientVersionToInventoryVersion(ClientVersion()))) {
Total += (m_pp.platinum + m_pp.gold + m_pp.silver + m_pp.copper) / 4;
}
float Packrat = (float)spellbonuses.Packrat + (float)aabonuses.Packrat + (float)itembonuses.Packrat;
@@ -2046,10 +2046,10 @@ uint32 Mob::GetInstrumentMod(uint16 spell_id) const
// clickies (Symphony of Battle) that have a song skill don't get AA bonus for some reason
// but clickies that are songs (selo's on Composers Greaves) do get AA mod as well
switch (spells[spell_id].skill) {
case SkillPercussionInstruments:
case EQEmu::skills::SkillPercussionInstruments:
if (itembonuses.percussionMod == 0 && spellbonuses.percussionMod == 0)
effectmod = 10;
else if (GetSkill(SkillPercussionInstruments) == 0)
else if (GetSkill(EQEmu::skills::SkillPercussionInstruments) == 0)
effectmod = 10;
else if (itembonuses.percussionMod > spellbonuses.percussionMod)
effectmod = itembonuses.percussionMod;
@@ -2058,10 +2058,10 @@ uint32 Mob::GetInstrumentMod(uint16 spell_id) const
if (IsBardSong(spell_id))
effectmod += aabonuses.percussionMod;
break;
case SkillStringedInstruments:
case EQEmu::skills::SkillStringedInstruments:
if (itembonuses.stringedMod == 0 && spellbonuses.stringedMod == 0)
effectmod = 10;
else if (GetSkill(SkillStringedInstruments) == 0)
else if (GetSkill(EQEmu::skills::SkillStringedInstruments) == 0)
effectmod = 10;
else if (itembonuses.stringedMod > spellbonuses.stringedMod)
effectmod = itembonuses.stringedMod;
@@ -2070,10 +2070,10 @@ uint32 Mob::GetInstrumentMod(uint16 spell_id) const
if (IsBardSong(spell_id))
effectmod += aabonuses.stringedMod;
break;
case SkillWindInstruments:
case EQEmu::skills::SkillWindInstruments:
if (itembonuses.windMod == 0 && spellbonuses.windMod == 0)
effectmod = 10;
else if (GetSkill(SkillWindInstruments) == 0)
else if (GetSkill(EQEmu::skills::SkillWindInstruments) == 0)
effectmod = 10;
else if (itembonuses.windMod > spellbonuses.windMod)
effectmod = itembonuses.windMod;
@@ -2082,10 +2082,10 @@ uint32 Mob::GetInstrumentMod(uint16 spell_id) const
if (IsBardSong(spell_id))
effectmod += aabonuses.windMod;
break;
case SkillBrassInstruments:
case EQEmu::skills::SkillBrassInstruments:
if (itembonuses.brassMod == 0 && spellbonuses.brassMod == 0)
effectmod = 10;
else if (GetSkill(SkillBrassInstruments) == 0)
else if (GetSkill(EQEmu::skills::SkillBrassInstruments) == 0)
effectmod = 10;
else if (itembonuses.brassMod > spellbonuses.brassMod)
effectmod = itembonuses.brassMod;
@@ -2094,7 +2094,7 @@ uint32 Mob::GetInstrumentMod(uint16 spell_id) const
if (IsBardSong(spell_id))
effectmod += aabonuses.brassMod;
break;
case SkillSinging:
case EQEmu::skills::SkillSinging:
if (itembonuses.singingMod == 0 && spellbonuses.singingMod == 0)
effectmod = 10;
else if (itembonuses.singingMod > spellbonuses.singingMod)
zone/client_packet.cpp
+58 -58
View File
@@ -2830,10 +2830,10 @@ void Client::Handle_OP_ApplyPoison(const EQApplicationPacket *app)
{
if ((PrimaryWeapon && PrimaryWeapon->GetItem()->ItemType == EQEmu::item::ItemType1HPiercing) ||
(SecondaryWeapon && SecondaryWeapon->GetItem()->ItemType == EQEmu::item::ItemType1HPiercing)) {
float SuccessChance = (GetSkill(SkillApplyPoison) + GetLevel()) / 400.0f;
float SuccessChance = (GetSkill(EQEmu::skills::SkillApplyPoison) + GetLevel()) / 400.0f;
double ChanceRoll = zone->random.Real(0, 1);
CheckIncreaseSkill(SkillApplyPoison, nullptr, 10);
CheckIncreaseSkill(EQEmu::skills::SkillApplyPoison, nullptr, 10);
if (ChanceRoll < SuccessChance) {
ApplyPoisonSuccessResult = 1;
@@ -3630,7 +3630,7 @@ void Client::Handle_OP_Begging(const EQApplicationPacket *app)
return;
}
if (!HasSkill(SkillBegging) || !GetTarget())
if (!HasSkill(EQEmu::skills::SkillBegging) || !GetTarget())
return;
if (GetTarget()->GetClass() == LDON_TREASURE)
@@ -3668,7 +3668,7 @@ void Client::Handle_OP_Begging(const EQApplicationPacket *app)
return;
}
uint16 CurrentSkill = GetSkill(SkillBegging);
uint16 CurrentSkill = GetSkill(EQEmu::skills::SkillBegging);
float ChanceToBeg = ((float)(CurrentSkill / 700.0f) + 0.15f) * 100;
@@ -3690,7 +3690,7 @@ void Client::Handle_OP_Begging(const EQApplicationPacket *app)
}
QueuePacket(outapp);
safe_delete(outapp);
CheckIncreaseSkill(SkillBegging, nullptr, -10);
CheckIncreaseSkill(EQEmu::skills::SkillBegging, nullptr, -10);
}
void Client::Handle_OP_Bind_Wound(const EQApplicationPacket *app)
@@ -4526,7 +4526,7 @@ void Client::Handle_OP_ClientUpdate(const EQApplicationPacket *app)
if(IsTracking() && ((m_Position.x!=ppu->x_pos) || (m_Position.y!=ppu->y_pos))){
if(zone->random.Real(0, 100) < 70)//should be good
CheckIncreaseSkill(SkillTracking, nullptr, -20);
CheckIncreaseSkill(EQEmu::skills::SkillTracking, nullptr, -20);
}
// Break Hide if moving without sneaking and set rewind timer if moved
@@ -4581,7 +4581,7 @@ void Client::Handle_OP_ClientUpdate(const EQApplicationPacket *app)
}
if(zone->watermap && zone->watermap->InLiquid(glm::vec3(m_Position)))
CheckIncreaseSkill(SkillSwimming, nullptr, -17);
CheckIncreaseSkill(EQEmu::skills::SkillSwimming, nullptr, -17);
return;
}
@@ -5070,7 +5070,7 @@ void Client::Handle_OP_Death(const EQApplicationPacket *app)
Death_Struct* ds = (Death_Struct*)app->pBuffer;
//I think this attack_skill value is really a value from SkillDamageTypes...
if (ds->attack_skill > HIGHEST_SKILL) {
if (ds->attack_skill > EQEmu::skills::HIGHEST_SKILL) {
return;
}
@@ -5078,7 +5078,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, (SkillUseTypes)ds->attack_skill);
Death(killer, ds->damage, ds->spell_id, (EQEmu::skills::SkillType)ds->attack_skill);
return;
}
@@ -5139,9 +5139,9 @@ void Client::Handle_OP_DeleteItem(const EQApplicationPacket *app)
const ItemInst *inst = GetInv().GetItem(alc->from_slot);
if (inst && inst->GetItem()->ItemType == EQEmu::item::ItemTypeAlcohol) {
entity_list.MessageClose_StringID(this, true, 50, 0, DRINKING_MESSAGE, GetName(), inst->GetItem()->Name);
CheckIncreaseSkill(SkillAlcoholTolerance, nullptr, 25);
CheckIncreaseSkill(EQEmu::skills::SkillAlcoholTolerance, nullptr, 25);
int16 AlcoholTolerance = GetSkill(SkillAlcoholTolerance);
int16 AlcoholTolerance = GetSkill(EQEmu::skills::SkillAlcoholTolerance);
int16 IntoxicationIncrease;
if (ClientVersion() < EQEmu::versions::ClientVersion::SoD)
@@ -5209,7 +5209,7 @@ void Client::Handle_OP_DeleteSpell(const EQApplicationPacket *app)
void Client::Handle_OP_DisarmTraps(const EQApplicationPacket *app)
{
if (!HasSkill(SkillDisarmTraps))
if (!HasSkill(EQEmu::skills::SkillDisarmTraps))
return;
if (!p_timers.Expired(&database, pTimerDisarmTraps, false)) {
@@ -5217,7 +5217,7 @@ void Client::Handle_OP_DisarmTraps(const EQApplicationPacket *app)
return;
}
int reuse = DisarmTrapsReuseTime - GetSkillReuseTime(SkillDisarmTraps);
int reuse = DisarmTrapsReuseTime - GetSkillReuseTime(EQEmu::skills::SkillDisarmTraps);
if (reuse < 1)
reuse = 1;
@@ -5227,7 +5227,7 @@ void Client::Handle_OP_DisarmTraps(const EQApplicationPacket *app)
Trap* trap = entity_list.FindNearbyTrap(this, 60);
if (trap && trap->detected)
{
int uskill = GetSkill(SkillDisarmTraps);
int uskill = GetSkill(EQEmu::skills::SkillDisarmTraps);
if ((zone->random.Int(0, 49) + uskill) >= (zone->random.Int(0, 49) + trap->skill))
{
Message(MT_Skills, "You disarm a trap.");
@@ -5245,7 +5245,7 @@ void Client::Handle_OP_DisarmTraps(const EQApplicationPacket *app)
Message(MT_Skills, "You failed to disarm a trap.");
}
}
CheckIncreaseSkill(SkillDisarmTraps, nullptr);
CheckIncreaseSkill(EQEmu::skills::SkillDisarmTraps, nullptr);
return;
}
Message(MT_Skills, "You did not find any traps close enough to disarm.");
@@ -5527,7 +5527,7 @@ void Client::Handle_OP_EnvDamage(const EQApplicationPacket *app)
if (GetHP() <= 0) {
mod_client_death_env();
Death(0, 32000, SPELL_UNKNOWN, SkillHandtoHand);
Death(0, 32000, SPELL_UNKNOWN, EQEmu::skills::SkillHandtoHand);
}
SendHPUpdate();
return;
@@ -5571,7 +5571,7 @@ void Client::Handle_OP_FeignDeath(const EQApplicationPacket *app)
}
int reuse = FeignDeathReuseTime;
reuse -= GetSkillReuseTime(SkillFeignDeath);
reuse -= GetSkillReuseTime(EQEmu::skills::SkillFeignDeath);
if (reuse < 1)
reuse = 1;
@@ -5580,8 +5580,8 @@ void Client::Handle_OP_FeignDeath(const EQApplicationPacket *app)
//BreakInvis();
uint16 primfeign = GetSkill(SkillFeignDeath);
uint16 secfeign = GetSkill(SkillFeignDeath);
uint16 primfeign = GetSkill(EQEmu::skills::SkillFeignDeath);
uint16 secfeign = GetSkill(EQEmu::skills::SkillFeignDeath);
if (primfeign > 100) {
primfeign = 100;
secfeign = secfeign - 100;
@@ -5599,7 +5599,7 @@ void Client::Handle_OP_FeignDeath(const EQApplicationPacket *app)
SetFeigned(true);
}
CheckIncreaseSkill(SkillFeignDeath, nullptr, 5);
CheckIncreaseSkill(EQEmu::skills::SkillFeignDeath, nullptr, 5);
return;
}
@@ -7859,7 +7859,7 @@ void Client::Handle_OP_Heartbeat(const EQApplicationPacket *app)
void Client::Handle_OP_Hide(const EQApplicationPacket *app)
{
if (!HasSkill(SkillHide) && GetSkill(SkillHide) == 0)
if (!HasSkill(EQEmu::skills::SkillHide) && GetSkill(EQEmu::skills::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
@@ -7869,16 +7869,16 @@ void Client::Handle_OP_Hide(const EQApplicationPacket *app)
Message(13, "Ability recovery time not yet met.");
return;
}
int reuse = HideReuseTime - GetSkillReuseTime(SkillHide);
int reuse = HideReuseTime - GetSkillReuseTime(EQEmu::skills::SkillHide);
if (reuse < 1)
reuse = 1;
p_timers.Start(pTimerHide, reuse - 1);
float hidechance = ((GetSkill(SkillHide) / 250.0f) + .25) * 100;
float hidechance = ((GetSkill(EQEmu::skills::SkillHide) / 250.0f) + .25) * 100;
float random = zone->random.Real(0, 100);
CheckIncreaseSkill(SkillHide, nullptr, 5);
CheckIncreaseSkill(EQEmu::skills::SkillHide, nullptr, 5);
if (random < hidechance) {
auto outapp = new EQApplicationPacket(OP_SpawnAppearance, sizeof(SpawnAppearance_Struct));
SpawnAppearance_Struct* sa_out = (SpawnAppearance_Struct*)outapp->pBuffer;
@@ -7901,7 +7901,7 @@ void Client::Handle_OP_Hide(const EQApplicationPacket *app)
Mob *evadetar = GetTarget();
if (!auto_attack && (evadetar && evadetar->CheckAggro(this)
&& evadetar->IsNPC())) {
if (zone->random.Int(0, 260) < (int)GetSkill(SkillHide)) {
if (zone->random.Int(0, 260) < (int)GetSkill(EQEmu::skills::SkillHide)) {
msg->string_id = EVADE_SUCCESS;
RogueEvade(evadetar);
}
@@ -8023,10 +8023,10 @@ void Client::Handle_OP_InspectAnswer(const EQApplicationPacket *app)
if (item) {
// another one..I did these, didn't I!!?
strcpy(insr->itemnames[SoF::inventory::SlotAmmo], item->Name);
insr->itemicons[SoF::inventory::SlotAmmo] = item->Icon;
strcpy(insr->itemnames[SoF::invslot::PossessionsAmmo], item->Name);
insr->itemicons[SoF::invslot::PossessionsAmmo] = item->Icon;
}
else { insr->itemicons[SoF::inventory::SlotAmmo] = 0xFFFFFFFF; }
else { insr->itemicons[SoF::invslot::PossessionsAmmo] = 0xFFFFFFFF; }
InspectMessage_Struct* newmessage = (InspectMessage_Struct*)insr->text;
InspectMessage_Struct& playermessage = this->GetInspectMessage();
@@ -8689,14 +8689,14 @@ void Client::Handle_OP_LDoNDisarmTraps(const EQApplicationPacket *app)
Mob * target = GetTarget();
if (target->IsNPC())
{
if (HasSkill(SkillDisarmTraps))
if (HasSkill(EQEmu::skills::SkillDisarmTraps))
{
if (DistanceSquaredNoZ(m_Position, target->GetPosition()) > RuleI(Adventure, LDoNTrapDistanceUse))
{
Message(13, "%s is too far away.", target->GetCleanName());
return;
}
HandleLDoNDisarm(target->CastToNPC(), GetSkill(SkillDisarmTraps), LDoNTypeMechanical);
HandleLDoNDisarm(target->CastToNPC(), GetSkill(EQEmu::skills::SkillDisarmTraps), LDoNTypeMechanical);
}
else
Message(13, "You do not have the disarm trap skill.");
@@ -8722,14 +8722,14 @@ void Client::Handle_OP_LDoNPickLock(const EQApplicationPacket *app)
Mob * target = GetTarget();
if (target->IsNPC())
{
if (HasSkill(SkillPickLock))
if (HasSkill(EQEmu::skills::SkillPickLock))
{
if (DistanceSquaredNoZ(m_Position, target->GetPosition()) > RuleI(Adventure, LDoNTrapDistanceUse))
{
Message(13, "%s is too far away.", target->GetCleanName());
return;
}
HandleLDoNPickLock(target->CastToNPC(), GetSkill(SkillPickLock), LDoNTypeMechanical);
HandleLDoNPickLock(target->CastToNPC(), GetSkill(EQEmu::skills::SkillPickLock), LDoNTypeMechanical);
}
else
Message(13, "You do not have the pick locks skill.");
@@ -8741,14 +8741,14 @@ void Client::Handle_OP_LDoNSenseTraps(const EQApplicationPacket *app)
Mob * target = GetTarget();
if (target->IsNPC())
{
if (HasSkill(SkillSenseTraps))
if (HasSkill(EQEmu::skills::SkillSenseTraps))
{
if (DistanceSquaredNoZ(m_Position, target->GetPosition()) > RuleI(Adventure, LDoNTrapDistanceUse))
{
Message(13, "%s is too far away.", target->GetCleanName());
return;
}
HandleLDoNSenseTraps(target->CastToNPC(), GetSkill(SkillSenseTraps), LDoNTypeMechanical);
HandleLDoNSenseTraps(target->CastToNPC(), GetSkill(EQEmu::skills::SkillSenseTraps), LDoNTypeMechanical);
}
else
Message(13, "You do not have the sense traps skill.");
@@ -9251,7 +9251,7 @@ void Client::Handle_OP_MemorizeSpell(const EQApplicationPacket *app)
void Client::Handle_OP_Mend(const EQApplicationPacket *app)
{
if (!HasSkill(SkillMend))
if (!HasSkill(EQEmu::skills::SkillMend))
return;
if (!p_timers.Expired(&database, pTimerMend, false)) {
@@ -9262,7 +9262,7 @@ void Client::Handle_OP_Mend(const EQApplicationPacket *app)
int mendhp = GetMaxHP() / 4;
int currenthp = GetHP();
if (zone->random.Int(0, 199) < (int)GetSkill(SkillMend)) {
if (zone->random.Int(0, 199) < (int)GetSkill(EQEmu::skills::SkillMend)) {
int criticalchance = spellbonuses.CriticalMend + itembonuses.CriticalMend + aabonuses.CriticalMend;
@@ -9281,7 +9281,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(SkillMend) <= 75) && (zone->random.Int(GetSkill(SkillMend), 100) < 75) && (zone->random.Int(1, 3) == 1))
if ((GetSkill(EQEmu::skills::SkillMend) <= 75) && (zone->random.Int(GetSkill(EQEmu::skills::SkillMend), 100) < 75) && (zone->random.Int(1, 3) == 1))
{
SetHP(currenthp > mendhp ? (GetHP() - mendhp) : 1);
SendHPUpdate();
@@ -9291,7 +9291,7 @@ void Client::Handle_OP_Mend(const EQApplicationPacket *app)
Message_StringID(4, MEND_FAIL);
}
CheckIncreaseSkill(SkillMend, nullptr, 10);
CheckIncreaseSkill(EQEmu::skills::SkillMend, nullptr, 10);
return;
}
@@ -10440,7 +10440,7 @@ void Client::Handle_OP_PickPocket(const EQApplicationPacket *app)
DumpPacket(app);
}
if (!HasSkill(SkillPickPockets))
if (!HasSkill(EQEmu::skills::SkillPickPockets))
{
return;
}
@@ -10465,7 +10465,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(SkillPickPockets);
pick_out->myskill = GetSkill(EQEmu::skills::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);
@@ -10478,7 +10478,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(SkillPickPockets);
pick_out->myskill = GetSkill(EQEmu::skills::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);
@@ -10494,7 +10494,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(SkillPickPockets);
pick_out->myskill = GetSkill(EQEmu::skills::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);
@@ -11739,8 +11739,8 @@ void Client::Handle_OP_Sacrifice(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(SkillSafeFall)) //this should only get called if the client has safe fall, but just in case...
CheckIncreaseSkill(SkillSafeFall, nullptr); //check for skill up
if (HasSkill(EQEmu::skills::SkillSafeFall)) //this should only get called if the client has safe fall, but just in case...
CheckIncreaseSkill(EQEmu::skills::SkillSafeFall, nullptr); //check for skill up
}
void Client::Handle_OP_SafePoint(const EQApplicationPacket *app)
@@ -11777,7 +11777,7 @@ void Client::Handle_OP_SelectTribute(const EQApplicationPacket *app)
void Client::Handle_OP_SenseHeading(const EQApplicationPacket *app)
{
if (!HasSkill(SkillSenseHeading))
if (!HasSkill(EQEmu::skills::SkillSenseHeading))
return;
int chancemod=0;
@@ -11791,14 +11791,14 @@ void Client::Handle_OP_SenseHeading(const EQApplicationPacket *app)
if (GetLevel() <= 8)
chancemod += (9-level) * 10;
CheckIncreaseSkill(SkillSenseHeading, nullptr, chancemod);
CheckIncreaseSkill(EQEmu::skills::SkillSenseHeading, nullptr, chancemod);
return;
}
void Client::Handle_OP_SenseTraps(const EQApplicationPacket *app)
{
if (!HasSkill(SkillSenseTraps))
if (!HasSkill(EQEmu::skills::SkillSenseTraps))
return;
if (!p_timers.Expired(&database, pTimerSenseTraps, false)) {
@@ -11806,7 +11806,7 @@ void Client::Handle_OP_SenseTraps(const EQApplicationPacket *app)
return;
}
int reuse = SenseTrapsReuseTime - GetSkillReuseTime(SkillSenseTraps);
int reuse = SenseTrapsReuseTime - GetSkillReuseTime(EQEmu::skills::SkillSenseTraps);
if (reuse < 1)
reuse = 1;
@@ -11815,10 +11815,10 @@ void Client::Handle_OP_SenseTraps(const EQApplicationPacket *app)
Trap* trap = entity_list.FindNearbyTrap(this, 800);
CheckIncreaseSkill(SkillSenseTraps, nullptr);
CheckIncreaseSkill(EQEmu::skills::SkillSenseTraps, nullptr);
if (trap && trap->skill > 0) {
int uskill = GetSkill(SkillSenseTraps);
int uskill = GetSkill(EQEmu::skills::SkillSenseTraps);
if ((zone->random.Int(0, 99) + uskill) >= (zone->random.Int(0, 99) + trap->skill*0.75))
{
auto diff = trap->m_Position - glm::vec3(GetPosition());
@@ -12621,7 +12621,7 @@ void Client::Handle_OP_ShopRequest(const EQApplicationPacket *app)
void Client::Handle_OP_Sneak(const EQApplicationPacket *app)
{
if (!HasSkill(SkillSneak) && GetSkill(SkillSneak) == 0) {
if (!HasSkill(EQEmu::skills::SkillSneak) && GetSkill(EQEmu::skills::SkillSneak) == 0) {
return; //You cannot sneak if you do not have sneak
}
@@ -12645,9 +12645,9 @@ void Client::Handle_OP_Sneak(const EQApplicationPacket *app)
safe_delete(outapp);
}
else {
CheckIncreaseSkill(SkillSneak, nullptr, 5);
CheckIncreaseSkill(EQEmu::skills::SkillSneak, nullptr, 5);
}
float hidechance = ((GetSkill(SkillSneak) / 300.0f) + .25) * 100;
float hidechance = ((GetSkill(EQEmu::skills::SkillSneak) / 300.0f) + .25) * 100;
float random = zone->random.Real(0, 99);
if (!was && random < hidechance) {
sneaking = true;
@@ -12688,7 +12688,7 @@ void Client::Handle_OP_SpawnAppearance(const EQApplicationPacket *app)
if (sa->type == AT_Invis) {
if (sa->parameter != 0)
{
if (!HasSkill(SkillHide) && GetSkill(SkillHide) == 0)
if (!HasSkill(EQEmu::skills::SkillHide) && GetSkill(EQEmu::skills::SkillHide) == 0)
{
if (ClientVersion() < EQEmu::versions::ClientVersion::SoF)
{
@@ -12790,7 +12790,7 @@ void Client::Handle_OP_SpawnAppearance(const EQApplicationPacket *app)
if (sa->parameter != 0)
{
if (!HasSkill(SkillSneak))
if (!HasSkill(EQEmu::skills::SkillSneak))
{
char *hack_str = nullptr;
MakeAnyLenString(&hack_str, "Player sent OP_SpawnAppearance with AT_Sneak: %i", sa->parameter);
@@ -13234,10 +13234,10 @@ void Client::Handle_OP_Track(const EQApplicationPacket *app)
if (GetClass() != RANGER && GetClass() != DRUID && GetClass() != BARD)
return;
if (GetSkill(SkillTracking) == 0)
SetSkill(SkillTracking, 1);
if (GetSkill(EQEmu::skills::SkillTracking) == 0)
SetSkill(EQEmu::skills::SkillTracking, 1);
else
CheckIncreaseSkill(SkillTracking, nullptr, 15);
CheckIncreaseSkill(EQEmu::skills::SkillTracking, nullptr, 15);
if (!entity_list.MakeTrackPacket(this))
Log.Out(Logs::General, Logs::Error, "Unable to generate OP_Track packet requested by client.");
zone/client_process.cpp
+26 -26
View File
@@ -428,7 +428,7 @@ bool Client::Process() {
//you can't see your target
}
else if(auto_attack_target->GetHP() > -10) {
CheckIncreaseSkill(SkillDualWield, auto_attack_target, -10);
CheckIncreaseSkill(EQEmu::skills::SkillDualWield, auto_attack_target, -10);
if (CheckDualWield()) {
ItemInst *wpn = GetInv().GetItem(EQEmu::legacy::SlotSecondary);
TryWeaponProc(wpn, auto_attack_target, EQEmu::legacy::SlotSecondary);
@@ -1481,19 +1481,19 @@ void Client::OPGMTraining(const EQApplicationPacket *app)
// if this for-loop acts up again (crashes linux), try enabling the before and after #pragmas
//#pragma GCC push_options
//#pragma GCC optimize ("O0")
for (int sk = Skill1HBlunt; sk <= HIGHEST_SKILL; ++sk) {
if(sk == SkillTinkering && GetRace() != GNOME) {
for (int sk = EQEmu::skills::Skill1HBlunt; sk <= EQEmu::skills::HIGHEST_SKILL; ++sk) {
if (sk == EQEmu::skills::SkillTinkering && GetRace() != GNOME) {
gmtrain->skills[sk] = 0; //Non gnomes can't tinker!
} else {
gmtrain->skills[sk] = GetMaxSkillAfterSpecializationRules((SkillUseTypes)sk, MaxSkill((SkillUseTypes)sk, GetClass(), RuleI(Character, MaxLevel)));
gmtrain->skills[sk] = GetMaxSkillAfterSpecializationRules((EQEmu::skills::SkillType)sk, MaxSkill((EQEmu::skills::SkillType)sk, GetClass(), RuleI(Character, MaxLevel)));
//this is the highest level that the trainer can train you to, this is enforced clientside so we can't just
//Set it to 1 with CanHaveSkill or you wont be able to train past 1.
}
}
if (ClientVersion() < EQEmu::versions::ClientVersion::RoF2 && GetClass() == BERSERKER) {
gmtrain->skills[Skill1HPiercing] = gmtrain->skills[Skill2HPiercing];
gmtrain->skills[Skill2HPiercing] = 0;
gmtrain->skills[EQEmu::skills::Skill1HPiercing] = gmtrain->skills[EQEmu::skills::Skill2HPiercing];
gmtrain->skills[EQEmu::skills::Skill2HPiercing] = 0;
}
//#pragma GCC pop_options
@@ -1578,14 +1578,14 @@ void Client::OPGMTrainSkill(const EQApplicationPacket *app)
else if (gmskill->skillbank == 0x00)
{
// normal skills go here
if (gmskill->skill_id > HIGHEST_SKILL)
if (gmskill->skill_id > EQEmu::skills::HIGHEST_SKILL)
{
std::cout << "Wrong Training Skill (abilities)" << std::endl;
DumpPacket(app);
return;
}
SkillUseTypes skill = (SkillUseTypes) gmskill->skill_id;
EQEmu::skills::SkillType skill = (EQEmu::skills::SkillType)gmskill->skill_id;
if(!CanHaveSkill(skill)) {
Log.Out(Logs::Detail, Logs::Skills, "Tried to train skill %d, which is not allowed.", skill);
@@ -1610,27 +1610,27 @@ void Client::OPGMTrainSkill(const EQApplicationPacket *app)
SetSkill(skill, t_level);
} else {
switch(skill) {
case SkillBrewing:
case SkillMakePoison:
case SkillTinkering:
case SkillResearch:
case SkillAlchemy:
case SkillBaking:
case SkillTailoring:
case SkillBlacksmithing:
case SkillFletching:
case SkillJewelryMaking:
case SkillPottery:
case EQEmu::skills::SkillBrewing:
case EQEmu::skills::SkillMakePoison:
case EQEmu::skills::SkillTinkering:
case EQEmu::skills::SkillResearch:
case EQEmu::skills::SkillAlchemy:
case EQEmu::skills::SkillBaking:
case EQEmu::skills::SkillTailoring:
case EQEmu::skills::SkillBlacksmithing:
case EQEmu::skills::SkillFletching:
case EQEmu::skills::SkillJewelryMaking:
case EQEmu::skills::SkillPottery:
if(skilllevel >= RuleI(Skills, MaxTrainTradeskills)) {
Message_StringID(13, MORE_SKILLED_THAN_I, pTrainer->GetCleanName());
return;
}
break;
case SkillSpecializeAbjure:
case SkillSpecializeAlteration:
case SkillSpecializeConjuration:
case SkillSpecializeDivination:
case SkillSpecializeEvocation:
case EQEmu::skills::SkillSpecializeAbjure:
case EQEmu::skills::SkillSpecializeAlteration:
case EQEmu::skills::SkillSpecializeConjuration:
case EQEmu::skills::SkillSpecializeDivination:
case EQEmu::skills::SkillSpecializeEvocation:
if(skilllevel >= RuleI(Skills, MaxTrainSpecializations)) {
Message_StringID(13, MORE_SKILLED_THAN_I, pTrainer->GetCleanName());
return;
@@ -1647,7 +1647,7 @@ void Client::OPGMTrainSkill(const EQApplicationPacket *app)
return;
}
if(gmskill->skill_id >= SkillSpecializeAbjure && gmskill->skill_id <= SkillSpecializeEvocation)
if (gmskill->skill_id >= EQEmu::skills::SkillSpecializeAbjure && gmskill->skill_id <= EQEmu::skills::SkillSpecializeEvocation)
{
int MaxSpecSkill = GetMaxSkillAfterSpecializationRules(skill, MaxSkillValue);
if (skilllevel >= MaxSpecSkill)
@@ -1685,7 +1685,7 @@ void Client::OPGMTrainSkill(const EQApplicationPacket *app)
gmtsc->SkillID += 100;
}
else
gmtsc->NewSkill = (GetRawSkill((SkillUseTypes)gmtsc->SkillID) == 1);
gmtsc->NewSkill = (GetRawSkill((EQEmu::skills::SkillType)gmtsc->SkillID) == 1);
gmtsc->Cost = Cost;
zone/command.cpp
+19 -18
View File
@@ -52,6 +52,7 @@
#include "../common/rulesys.h"
#include "../common/serverinfo.h"
#include "../common/string_util.h"
#include "../say_link.h"
#include "../common/eqemu_logsys.h"
@@ -2129,7 +2130,7 @@ void command_showskills(Client *c, const Seperator *sep)
t=c->GetTarget()->CastToClient();
c->Message(0, "Skills for %s", t->GetName());
for (SkillUseTypes i=Skill1HBlunt; i <= HIGHEST_SKILL; i=(SkillUseTypes)(i+1))
for (EQEmu::skills::SkillType i = EQEmu::skills::Skill1HBlunt; i <= EQEmu::skills::HIGHEST_SKILL; i = (EQEmu::skills::SkillType)(i + 1))
c->Message(0, "Skill [%d] is at [%d] - %u", i, t->GetSkill(i), t->GetRawSkill(i));
}
@@ -2277,20 +2278,20 @@ void command_setskill(Client *c, const Seperator *sep)
c->Message(0, "Error: #setskill: Target must be a client.");
}
else if (
!sep->IsNumber(1) || atoi(sep->arg[1]) < 0 || atoi(sep->arg[1]) > HIGHEST_SKILL ||
!sep->IsNumber(1) || atoi(sep->arg[1]) < 0 || atoi(sep->arg[1]) > EQEmu::skills::HIGHEST_SKILL ||
!sep->IsNumber(2) || atoi(sep->arg[2]) < 0 || atoi(sep->arg[2]) > HIGHEST_CAN_SET_SKILL
)
{
c->Message(0, "Usage: #setskill skill x ");
c->Message(0, " skill = 0 to %d", HIGHEST_SKILL);
c->Message(0, " skill = 0 to %d", EQEmu::skills::HIGHEST_SKILL);
c->Message(0, " x = 0 to %d", HIGHEST_CAN_SET_SKILL);
}
else {
Log.Out(Logs::General, Logs::Normal, "Set skill request from %s, target:%s skill_id:%i value:%i", c->GetName(), c->GetTarget()->GetName(), atoi(sep->arg[1]), atoi(sep->arg[2]) );
int skill_num = atoi(sep->arg[1]);
uint16 skill_value = atoi(sep->arg[2]);
if(skill_num <= HIGHEST_SKILL)
c->GetTarget()->CastToClient()->SetSkill((SkillUseTypes)skill_num, skill_value);
if (skill_num <= EQEmu::skills::HIGHEST_SKILL)
c->GetTarget()->CastToClient()->SetSkill((EQEmu::skills::SkillType)skill_num, skill_value);
}
}
@@ -2308,7 +2309,7 @@ void command_setskillall(Client *c, const Seperator *sep)
if (c->Admin() >= commandSetSkillsOther || c->GetTarget()==c || c->GetTarget()==0) {
Log.Out(Logs::General, Logs::Normal, "Set ALL skill request from %s, target:%s", c->GetName(), c->GetTarget()->GetName());
uint16 level = atoi(sep->arg[1]);
for(SkillUseTypes skill_num=Skill1HBlunt;skill_num <= HIGHEST_SKILL;skill_num=(SkillUseTypes)(skill_num+1)) {
for (EQEmu::skills::SkillType skill_num = EQEmu::skills::Skill1HBlunt; skill_num <= EQEmu::skills::HIGHEST_SKILL; skill_num = (EQEmu::skills::SkillType)(skill_num + 1)) {
c->GetTarget()->CastToClient()->SetSkill(skill_num, level);
}
}
@@ -4197,7 +4198,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, SkillHandtoHand, false);
c->GetTarget()->Damage(c, nkdmg, SPELL_UNKNOWN, EQEmu::skills::SkillHandtoHand, false);
}
}
@@ -9942,16 +9943,16 @@ void command_max_all_skills(Client *c, const Seperator *sep)
{
if(c)
{
for(int i = 0; i <= HIGHEST_SKILL; ++i)
for (int i = 0; i <= EQEmu::skills::HIGHEST_SKILL; ++i)
{
if(i >= SkillSpecializeAbjure && i <= SkillSpecializeEvocation)
if (i >= EQEmu::skills::SkillSpecializeAbjure && i <= EQEmu::skills::SkillSpecializeEvocation)
{
c->SetSkill((SkillUseTypes)i, 50);
c->SetSkill((EQEmu::skills::SkillType)i, 50);
}
else
{
int max_skill_level = database.GetSkillCap(c->GetClass(), (SkillUseTypes)i, c->GetLevel());
c->SetSkill((SkillUseTypes)i, max_skill_level);
int max_skill_level = database.GetSkillCap(c->GetClass(), (EQEmu::skills::SkillType)i, c->GetLevel());
c->SetSkill((EQEmu::skills::SkillType)i, max_skill_level);
}
}
}
@@ -10037,14 +10038,14 @@ void command_disarmtrap(Client *c, const Seperator *sep)
if(target->IsNPC())
{
if(c->HasSkill(SkillDisarmTraps))
if (c->HasSkill(EQEmu::skills::SkillDisarmTraps))
{
if(DistanceSquaredNoZ(c->GetPosition(), target->GetPosition()) > RuleI(Adventure, LDoNTrapDistanceUse))
{
c->Message(13, "%s is too far away.", target->GetCleanName());
return;
}
c->HandleLDoNDisarm(target->CastToNPC(), c->GetSkill(SkillDisarmTraps), LDoNTypeMechanical);
c->HandleLDoNDisarm(target->CastToNPC(), c->GetSkill(EQEmu::skills::SkillDisarmTraps), LDoNTypeMechanical);
}
else
c->Message(13, "You do not have the disarm trap skill.");
@@ -10062,14 +10063,14 @@ void command_sensetrap(Client *c, const Seperator *sep)
if(target->IsNPC())
{
if(c->HasSkill(SkillSenseTraps))
if (c->HasSkill(EQEmu::skills::SkillSenseTraps))
{
if(DistanceSquaredNoZ(c->GetPosition(), target->GetPosition()) > RuleI(Adventure, LDoNTrapDistanceUse))
{
c->Message(13, "%s is too far away.", target->GetCleanName());
return;
}
c->HandleLDoNSenseTraps(target->CastToNPC(), c->GetSkill(SkillSenseTraps), LDoNTypeMechanical);
c->HandleLDoNSenseTraps(target->CastToNPC(), c->GetSkill(EQEmu::skills::SkillSenseTraps), LDoNTypeMechanical);
}
else
c->Message(13, "You do not have the sense traps skill.");
@@ -10087,14 +10088,14 @@ void command_picklock(Client *c, const Seperator *sep)
if(target->IsNPC())
{
if(c->HasSkill(SkillPickLock))
if (c->HasSkill(EQEmu::skills::SkillPickLock))
{
if(DistanceSquaredNoZ(c->GetPosition(), target->GetPosition()) > RuleI(Adventure, LDoNTrapDistanceUse))
{
c->Message(13, "%s is too far away.", target->GetCleanName());
return;
}
c->HandleLDoNPickLock(target->CastToNPC(), c->GetSkill(SkillPickLock), LDoNTypeMechanical);
c->HandleLDoNPickLock(target->CastToNPC(), c->GetSkill(EQEmu::skills::SkillPickLock), LDoNTypeMechanical);
}
else
c->Message(13, "You do not have the pick locks skill.");
zone/common.h
+16 -16
View File
@@ -277,8 +277,8 @@ struct StatBonuses {
int32 inhibitmelee;
float AggroRange; // when calculate just replace original value with this
float AssistRange;
int32 skillmod[HIGHEST_SKILL+1];
int32 skillmodmax[HIGHEST_SKILL+1];
int32 skillmod[EQEmu::skills::HIGHEST_SKILL + 1];
int32 skillmodmax[EQEmu::skills::HIGHEST_SKILL + 1];
int effective_casting_level;
int reflect_chance; // chance to reflect incoming spell
uint32 singingMod;
@@ -294,7 +294,7 @@ struct StatBonuses {
int32 StrikeThrough; // PoP: Strike Through %
int32 MeleeMitigation; //i = Shielding
int32 MeleeMitigationEffect; //i = Spell Effect Melee Mitigation
int32 CriticalHitChance[HIGHEST_SKILL+2]; //i
int32 CriticalHitChance[EQEmu::skills::HIGHEST_SKILL + 2]; //i
int32 CriticalSpellChance; //i
int32 SpellCritDmgIncrease; //i
int32 SpellCritDmgIncNoStack; // increase
@@ -321,10 +321,10 @@ struct StatBonuses {
int32 MeleeSkillCheck; //i
uint8 MeleeSkillCheckSkill;
int32 HitChance; //HitChance/15 == % increase i = Accuracy (Item: Accuracy)
int32 HitChanceEffect[HIGHEST_SKILL+2]; //Spell effect Chance to Hit, straight percent increase
int32 DamageModifier[HIGHEST_SKILL+2]; //i
int32 DamageModifier2[HIGHEST_SKILL+2]; //i
int32 MinDamageModifier[HIGHEST_SKILL+2]; //i
int32 HitChanceEffect[EQEmu::skills::HIGHEST_SKILL + 2]; //Spell effect Chance to Hit, straight percent increase
int32 DamageModifier[EQEmu::skills::HIGHEST_SKILL + 2]; //i
int32 DamageModifier2[EQEmu::skills::HIGHEST_SKILL + 2]; //i
int32 MinDamageModifier[EQEmu::skills::HIGHEST_SKILL + 2]; //i
int32 ProcChance; // ProcChance/10 == % increase i = CombatEffects
int32 ProcChanceSPA; // ProcChance from spell effects
int32 ExtraAttackChance;
@@ -332,13 +332,13 @@ struct StatBonuses {
int32 DivineSaveChance[2]; // Second Chance (base1 = chance, base2 = spell on trigger)
uint32 DeathSave[4]; // Death Pact [0](value = 1 partial 2 = full) [1]=slot [2]=LvLimit [3]=HealAmt
int32 FlurryChance;
int32 Accuracy[HIGHEST_SKILL+2]; //Accuracy/15 == % increase [Spell Effect: Accuracy)
int32 Accuracy[EQEmu::skills::HIGHEST_SKILL + 2]; //Accuracy/15 == % increase [Spell Effect: Accuracy)
int32 HundredHands; //extra haste, stacks with all other haste i
int32 MeleeLifetap; //i
int32 Vampirism; //i
int32 HealRate; // Spell effect that influences effectiveness of heals
int32 MaxHPChange; // Spell Effect
int16 SkillDmgTaken[HIGHEST_SKILL+2]; // All Skills + -1
int16 SkillDmgTaken[EQEmu::skills::HIGHEST_SKILL + 2]; // All Skills + -1
int32 HealAmt; // Item Effect
int32 SpellDmg; // Item Effect
int32 Clairvoyance; // Item Effect
@@ -347,9 +347,9 @@ struct StatBonuses {
uint32 SpellTriggers[MAX_SPELL_TRIGGER]; // Innate/Spell/Item Spells that trigger when you cast
uint32 SpellOnKill[MAX_SPELL_TRIGGER*3]; // Chance to proc after killing a mob
uint32 SpellOnDeath[MAX_SPELL_TRIGGER*2]; // Chance to have effect cast when you die
int32 CritDmgMob[HIGHEST_SKILL+2]; // All Skills + -1
int32 SkillReuseTime[HIGHEST_SKILL+1]; // Reduces skill timers
int32 SkillDamageAmount[HIGHEST_SKILL+2]; // All Skills + -1
int32 CritDmgMob[EQEmu::skills::HIGHEST_SKILL + 2]; // All Skills + -1
int32 SkillReuseTime[EQEmu::skills::HIGHEST_SKILL + 1]; // Reduces skill timers
int32 SkillDamageAmount[EQEmu::skills::HIGHEST_SKILL + 2]; // All Skills + -1
int32 TwoHandBluntBlock; // chance to block when wielding two hand blunt weapon
uint32 ItemManaRegenCap; // Increases the amount of mana you have can over the cap(aa effect)
int32 GravityEffect; // Indictor of spell effect
@@ -372,7 +372,7 @@ struct StatBonuses {
uint8 FocusEffects[HIGHEST_FOCUS+1]; // Stores the focus effectid for each focustype you have.
int16 FocusEffectsWorn[HIGHEST_FOCUS+1]; // Optional to allow focus effects to be applied additively from worn slot
bool NegateEffects; // Check if you contain a buff with negate effect. (only spellbonuses)
int32 SkillDamageAmount2[HIGHEST_SKILL+2]; // Adds skill specific damage
int32 SkillDamageAmount2[EQEmu::skills::HIGHEST_SKILL + 2]; // Adds skill specific damage
uint32 NegateAttacks[3]; // 0 = bool HasEffect 1 = Buff Slot 2 = Max damage absorbed per hit
uint32 MitigateMeleeRune[4]; // 0 = Mitigation value 1 = Buff Slot 2 = Max mitigation per hit 3 = Rune Amt
uint32 MeleeThresholdGuard[3]; // 0 = Mitigation value 1 = Buff Slot 2 = Min damage to trigger.
@@ -405,7 +405,7 @@ struct StatBonuses {
int32 Metabolism; // Food/drink consumption rates.
bool Sanctuary; // Sanctuary effect, lowers place on hate list until cast on others.
int32 FactionModPct; // Modifies amount of faction gained.
bool LimitToSkill[HIGHEST_SKILL+2]; // Determines if we need to search for a skill proc.
bool LimitToSkill[EQEmu::skills::HIGHEST_SKILL + 2]; // Determines if we need to search for a skill proc.
uint32 SkillProc[MAX_SKILL_PROCS]; // Max number of spells containing skill_procs.
uint32 SkillProcSuccess[MAX_SKILL_PROCS]; // Max number of spells containing skill_procs_success.
uint32 PC_Pet_Rampage[2]; // 0= % chance to rampage, 1=damage modifier
@@ -440,7 +440,7 @@ struct StatBonuses {
int32 CombatStability; // Melee damage mitigation.
int32 DoubleRiposte; // Chance to double riposte
int32 GiveDoubleRiposte[3]; // 0=Regular Chance, 1=Skill Attack Chance, 2=Skill
uint32 RaiseSkillCap[HIGHEST_SKILL+1]; // Raise a specific skill cap (base1= value, base2=skill)
uint32 RaiseSkillCap[EQEmu::skills::HIGHEST_SKILL + 1]; // Raise a specific skill cap (base1= value, base2=skill)
int32 Ambidexterity; // Increase chance to duel wield by adding bonus 'skill'.
int32 PetMaxHP; // Increase the max hp of your pet.
int32 PetFlurry; // Chance for pet to flurry.
@@ -470,7 +470,7 @@ struct StatBonuses {
uint16 extra_xtargets; // extra xtarget entries
bool ShroudofStealth; // rogue improved invisiblity
uint16 ReduceFallDamage; // reduce fall damage by percent
int32 ReduceTradeskillFail[HIGHEST_SKILL+1]; // Reduces chance for trade skills to fail by percent.
int32 ReduceTradeskillFail[EQEmu::skills::HIGHEST_SKILL + 1]; // Reduces chance for trade skills to fail by percent.
uint8 TradeSkillMastery; // Allow number of tradeskills to exceed 200 skill.
int16 NoBreakAESneak; // Percent value
int16 FeignedCastOnChance; // Percent Value
zone/corpse.cpp
+3 -2
View File
@@ -34,6 +34,7 @@ Child of the Mob class.
#include "../common/eqemu_logsys.h"
#include "../common/rulesys.h"
#include "../common/string_util.h"
#include "../common/say_link.h"
#include "client.h"
#include "corpse.h"
@@ -997,7 +998,7 @@ void Corpse::MakeLootRequestPackets(Client* client, const EQApplicationPacket* a
cur = itemlist.begin();
end = itemlist.end();
int corpselootlimit = EQEmu::limits::InventoryTypeSize(EQEmu::versions::ConvertClientVersionToInventoryVersion(client->ClientVersion()), EQEmu::legacy::TypeCorpse);
int corpselootlimit = EQEmu::inventory::InventoryTypeSize(EQEmu::versions::ConvertClientVersionToInventoryVersion(client->ClientVersion()), EQEmu::legacy::TypeCorpse);
for(; cur != end; ++cur) {
ServerLootItem_Struct* item_data = *cur;
@@ -1291,7 +1292,7 @@ void Corpse::QueryLoot(Client* to) {
cur = itemlist.begin();
end = itemlist.end();
int corpselootlimit = EQEmu::limits::InventoryTypeSize(EQEmu::versions::ConvertClientVersionToInventoryVersion(to->ClientVersion()), EQEmu::legacy::TypeCorpse);
int corpselootlimit = EQEmu::inventory::InventoryTypeSize(EQEmu::versions::ConvertClientVersionToInventoryVersion(to->ClientVersion()), EQEmu::legacy::TypeCorpse);
for(; cur != end; ++cur) {
ServerLootItem_Struct* sitem = *cur;
zone/corpse.h
+2 -2
View File
@@ -47,8 +47,8 @@ class Corpse : public Mob {
static Corpse* LoadCharacterCorpseEntity(uint32 in_dbid, uint32 in_charid, std::string in_charname, const glm::vec4& position, std::string time_of_death, bool rezzed, bool was_at_graveyard);
/* Corpse: General */
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, int special = 0) { return; }
virtual bool Death(Mob* killerMob, int32 damage, uint16 spell_id, EQEmu::skills::SkillType attack_skill) { return true; }
virtual void Damage(Mob* from, int32 damage, uint16 spell_id, EQEmu::skills::SkillType attack_skill, bool avoidable = true, int8 buffslot = -1, bool iBuffTic = false, int special = 0) { return; }
virtual bool Attack(Mob* other, int Hand = EQEmu::legacy::SlotPrimary, bool FromRiposte = false, bool IsStrikethrough = true, bool IsFromSpell = false, ExtraAttackOptions *opts = nullptr, int special = 0) { return false; }
virtual bool HasRaid() { return false; }
virtual bool HasGroup() { return false; }
zone/doors.cpp
+3 -3
View File
@@ -284,12 +284,12 @@ void Doors::HandleClick(Client* sender, uint8 trigger)
}
else if(lockpicks != nullptr)
{
if(sender->GetSkill(SkillPickLock))
if (sender->GetSkill(EQEmu::skills::SkillPickLock))
{
if(lockpicks->GetItem()->ItemType == EQEmu::item::ItemTypeLockPick)
{
float modskill=sender->GetSkill(SkillPickLock);
sender->CheckIncreaseSkill(SkillPickLock, nullptr, 1);
float modskill = sender->GetSkill(EQEmu::skills::SkillPickLock);
sender->CheckIncreaseSkill(EQEmu::skills::SkillPickLock, nullptr, 1);
Log.Out(Logs::General, Logs::Skills, "Client has lockpicks: skill=%f", modskill);
zone/encounter.h
+2 -2
View File
@@ -34,8 +34,8 @@ public:
~Encounter();
//abstract virtual function implementations required by base abstract class
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, int special = 0) { return; }
virtual bool Death(Mob* killerMob, int32 damage, uint16 spell_id, EQEmu::skills::SkillType attack_skill) { return true; }
virtual void Damage(Mob* from, int32 damage, uint16 spell_id, EQEmu::skills::SkillType attack_skill, bool avoidable = true, int8 buffslot = -1, bool iBuffTic = false, int special = 0) { return; }
virtual bool Attack(Mob* other, int Hand = EQEmu::legacy::SlotPrimary, bool FromRiposte = false, bool IsStrikethrough = false, bool IsFromSpell = false,
ExtraAttackOptions *opts = nullptr, int special = 0) {
return false;
zone/entity.cpp
+3 -3
View File
@@ -3008,11 +3008,11 @@ bool EntityList::MakeTrackPacket(Client *client)
float MobDistance;
if (client->GetClass() == DRUID)
distance = (client->GetSkill(SkillTracking) * 10);
distance = (client->GetSkill(EQEmu::skills::SkillTracking) * 10);
else if (client->GetClass() == RANGER)
distance = (client->GetSkill(SkillTracking) * 12);
distance = (client->GetSkill(EQEmu::skills::SkillTracking) * 12);
else if (client->GetClass() == BARD)
distance = (client->GetSkill(SkillTracking) * 7);
distance = (client->GetSkill(EQEmu::skills::SkillTracking) * 7);
if (distance <= 0)
return false;
if (distance < 300)
zone/forage.cpp
+6 -6
View File
@@ -249,7 +249,7 @@ void Client::GoFish()
//success formula is not researched at all
int fishing_skill = GetSkill(SkillFishing); //will take into account skill bonuses on pole & bait
int fishing_skill = GetSkill(EQEmu::skills::SkillFishing); //will take into account skill bonuses on pole & bait
//make sure we still have a fishing pole on:
int32 bslot = m_inv.HasItemByUse(EQEmu::item::ItemTypeFishingBait, 1, invWhereWorn | invWherePersonal);
@@ -258,7 +258,7 @@ void Client::GoFish()
Bait = m_inv.GetItem(bslot);
//if the bait isnt equipped, need to add its skill bonus
if (bslot >= EQEmu::legacy::GENERAL_BEGIN && Bait != nullptr && Bait->GetItem()->SkillModType == SkillFishing) {
if (bslot >= EQEmu::legacy::GENERAL_BEGIN && Bait != nullptr && Bait->GetItem()->SkillModType == EQEmu::skills::SkillFishing) {
fishing_skill += Bait->GetItem()->SkillModValue;
}
@@ -357,16 +357,16 @@ void Client::GoFish()
DeleteItemInInventory(EQEmu::legacy::SlotPrimary, 0, true);
}
if(CheckIncreaseSkill(SkillFishing, nullptr, 5))
if (CheckIncreaseSkill(EQEmu::skills::SkillFishing, nullptr, 5))
{
if(title_manager.IsNewTradeSkillTitleAvailable(SkillFishing, GetRawSkill(SkillFishing)))
if (title_manager.IsNewTradeSkillTitleAvailable(EQEmu::skills::SkillFishing, GetRawSkill(EQEmu::skills::SkillFishing)))
NotifyNewTitlesAvailable();
}
}
void Client::ForageItem(bool guarantee) {
int skill_level = GetSkill(SkillForage);
int skill_level = GetSkill(EQEmu::skills::SkillForage);
//be wary of the string ids in switch below when changing this.
uint32 common_food_ids[MAX_COMMON_FOOD_IDS] = {
@@ -457,7 +457,7 @@ void Client::ForageItem(bool guarantee) {
parse->EventPlayer(EVENT_FORAGE_FAILURE, this, "", 0);
}
CheckIncreaseSkill(SkillForage, nullptr, 5);
CheckIncreaseSkill(EQEmu::skills::SkillForage, nullptr, 5);
}
zone/lua_client.cpp
+8 -8
View File
@@ -432,27 +432,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<SkillUseTypes>(skill_id));
return self->GetRawSkill(static_cast<EQEmu::skills::SkillType>(skill_id));
}
bool Lua_Client::HasSkill(int skill_id) {
Lua_Safe_Call_Bool();
return self->HasSkill(static_cast<SkillUseTypes>(skill_id));
return self->HasSkill(static_cast<EQEmu::skills::SkillType>(skill_id));
}
bool Lua_Client::CanHaveSkill(int skill_id) {
Lua_Safe_Call_Bool();
return self->CanHaveSkill(static_cast<SkillUseTypes>(skill_id));
return self->CanHaveSkill(static_cast<EQEmu::skills::SkillType>(skill_id));
}
void Lua_Client::SetSkill(int skill_id, int value) {
Lua_Safe_Call_Void();
self->SetSkill(static_cast<SkillUseTypes>(skill_id), value);
self->SetSkill(static_cast<EQEmu::skills::SkillType>(skill_id), value);
}
void Lua_Client::AddSkill(int skill_id, int value) {
Lua_Safe_Call_Void();
self->AddSkill(static_cast<SkillUseTypes>(skill_id), value);
self->AddSkill(static_cast<EQEmu::skills::SkillType>(skill_id), value);
}
void Lua_Client::CheckSpecializeIncrease(int spell_id) {
@@ -462,12 +462,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<SkillUseTypes>(skill_id), target);
self->CheckIncreaseSkill(static_cast<EQEmu::skills::SkillType>(skill_id), target);
}
void Lua_Client::CheckIncreaseSkill(int skill_id, Lua_Mob target, int chance_mod) {
Lua_Safe_Call_Void();
self->CheckIncreaseSkill(static_cast<SkillUseTypes>(skill_id), target, chance_mod);
self->CheckIncreaseSkill(static_cast<EQEmu::skills::SkillType>(skill_id), target, chance_mod);
}
void Lua_Client::SetLanguageSkill(int language, int value) {
@@ -477,7 +477,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<SkillUseTypes>(skill_id));
return self->MaxSkill(static_cast<EQEmu::skills::SkillType>(skill_id));
}
bool Lua_Client::IsMedding() {
zone/lua_mob.cpp
+17 -17
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<SkillUseTypes>(attack_skill));
return self->Damage(from, damage, spell_id, static_cast<EQEmu::skills::SkillType>(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<SkillUseTypes>(attack_skill), avoidable);
return self->Damage(from, damage, spell_id, static_cast<EQEmu::skills::SkillType>(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<SkillUseTypes>(attack_skill), avoidable, buffslot);
return self->Damage(from, damage, spell_id, static_cast<EQEmu::skills::SkillType>(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<SkillUseTypes>(attack_skill), avoidable, buffslot, buff_tic);
return self->Damage(from, damage, spell_id, static_cast<EQEmu::skills::SkillType>(attack_skill), avoidable, buffslot, buff_tic);
}
void Lua_Mob::RangedAttack(Lua_Mob other) {
@@ -1252,28 +1252,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<SkillUseTypes>(skill), max_damage);
self->DoSpecialAttackDamage(other, static_cast<EQEmu::skills::SkillType>(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<SkillUseTypes>(skill), max_damage, min_damage);
self->DoSpecialAttackDamage(other, static_cast<EQEmu::skills::SkillType>(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<SkillUseTypes>(skill), max_damage, min_damage, hate_override);
self->DoSpecialAttackDamage(other, static_cast<EQEmu::skills::SkillType>(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<SkillUseTypes>(skill), max_damage, min_damage, hate_override, reuse_time);
self->DoSpecialAttackDamage(other, static_cast<EQEmu::skills::SkillType>(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<SkillUseTypes>(skill), max_damage, min_damage, hate_override, reuse_time, hit_chance);
self->DoSpecialAttackDamage(other, static_cast<EQEmu::skills::SkillType>(skill), max_damage, min_damage, hate_override, reuse_time, hit_chance);
}
void Lua_Mob::DoThrowingAttackDmg(Lua_Mob other) {
@@ -1309,22 +1309,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<SkillUseTypes>(skill));
self->DoMeleeSkillAttackDmg(other, weapon_damage, static_cast<EQEmu::skills::SkillType>(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<SkillUseTypes>(skill), chance_mod);
self->DoMeleeSkillAttackDmg(other, weapon_damage, static_cast<EQEmu::skills::SkillType>(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<SkillUseTypes>(skill), chance_mod, focus);
self->DoMeleeSkillAttackDmg(other, weapon_damage, static_cast<EQEmu::skills::SkillType>(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<SkillUseTypes>(skill), chance_mod, focus, can_riposte);
self->DoMeleeSkillAttackDmg(other, weapon_damage, static_cast<EQEmu::skills::SkillType>(skill), chance_mod, focus, can_riposte);
}
void Lua_Mob::DoArcheryAttackDmg(Lua_Mob other) {
@@ -1713,17 +1713,17 @@ void Lua_Mob::SetTargetable(bool on) {
void Lua_Mob::ModSkillDmgTaken(int skill, int value) {
Lua_Safe_Call_Void();
self->ModSkillDmgTaken(static_cast<SkillUseTypes>(skill), value);
self->ModSkillDmgTaken(static_cast<EQEmu::skills::SkillType>(skill), value);
}
int Lua_Mob::GetModSkillDmgTaken(int skill) {
Lua_Safe_Call_Int();
return self->GetModSkillDmgTaken(static_cast<SkillUseTypes>(skill));
return self->GetModSkillDmgTaken(static_cast<EQEmu::skills::SkillType>(skill));
}
int Lua_Mob::GetSkillDmgTaken(int skill) {
Lua_Safe_Call_Int();
return self->GetSkillDmgTaken(static_cast<SkillUseTypes>(skill));
return self->GetSkillDmgTaken(static_cast<EQEmu::skills::SkillType>(skill));
}
void Lua_Mob::SetAllowBeneficial(bool value) {
@@ -1773,7 +1773,7 @@ int Lua_Mob::GetFlurryChance() {
int Lua_Mob::GetSkill(int skill) {
Lua_Safe_Call_Int();
return self->GetSkill(static_cast<SkillUseTypes>(skill));
return self->GetSkill(static_cast<EQEmu::skills::SkillType>(skill));
}
int Lua_Mob::GetSpecialAbility(int ability) {
zone/merc.cpp
+19 -19
View File
@@ -70,8 +70,8 @@ Merc::Merc(const NPCType* d, float x, float y, float z, float heading)
rest_timer.Disable();
int r;
for(r = 0; r <= HIGHEST_SKILL; r++) {
skills[r] = database.GetSkillCap(GetClass(),(SkillUseTypes)r,GetLevel());
for (r = 0; r <= EQEmu::skills::HIGHEST_SKILL; r++) {
skills[r] = database.GetSkillCap(GetClass(), (EQEmu::skills::SkillType)r, GetLevel());
}
size = d->size;
@@ -512,7 +512,7 @@ void Merc::AddItemBonuses(const EQEmu::Item_Struct *item, StatBonuses* newbon) {
}
}
if (item->SkillModValue != 0 && item->SkillModType <= HIGHEST_SKILL){
if (item->SkillModValue != 0 && item->SkillModType <= EQEmu::skills::HIGHEST_SKILL){
if ((item->SkillModValue > 0 && newbon->skillmod[item->SkillModType] < item->SkillModValue) ||
(item->SkillModValue < 0 && newbon->skillmod[item->SkillModType] > item->SkillModValue))
{
@@ -566,7 +566,7 @@ void Merc::AddItemBonuses(const EQEmu::Item_Struct *item, StatBonuses* newbon) {
}
}
if (item->ExtraDmgSkill != 0 && item->ExtraDmgSkill <= HIGHEST_SKILL) {
if (item->ExtraDmgSkill != 0 && item->ExtraDmgSkill <= EQEmu::skills::HIGHEST_SKILL) {
if((newbon->SkillDamageAmount[item->ExtraDmgSkill] + item->ExtraDmgAmt) > RuleI(Character, ItemExtraDmgCap))
newbon->SkillDamageAmount[item->ExtraDmgSkill] = RuleI(Character, ItemExtraDmgCap);
else
@@ -931,8 +931,8 @@ int32 Merc::CalcBaseManaRegen()
int32 regen = 0;
if (IsSitting())
{
if(HasSkill(SkillMeditate))
regen = (((GetSkill(SkillMeditate) / 10) + (clevel - (clevel / 4))) / 4) + 4;
if (HasSkill(EQEmu::skills::SkillMeditate))
regen = (((GetSkill(EQEmu::skills::SkillMeditate) / 10) + (clevel - (clevel / 4))) / 4) + 4;
else
regen = 2;
}
@@ -948,9 +948,9 @@ int32 Merc::CalcManaRegen()
if (IsSitting())
{
BuffFadeBySitModifier();
if(HasSkill(SkillMeditate)) {
if (HasSkill(EQEmu::skills::SkillMeditate)) {
this->_medding = true;
regen = ((GetSkill(SkillMeditate) / 10) + mana_regen);
regen = ((GetSkill(EQEmu::skills::SkillMeditate) / 10) + mana_regen);
regen += spellbonuses.ManaRegen + itembonuses.ManaRegen;
}
else
@@ -1179,16 +1179,16 @@ void Merc::CalcRestState() {
RestRegenEndurance = (GetMaxEndurance() * RuleI(Character, RestRegenPercent) / 100);
}
bool Merc::HasSkill(SkillUseTypes skill_id) const {
bool Merc::HasSkill(EQEmu::skills::SkillType skill_id) const {
return((GetSkill(skill_id) > 0) && CanHaveSkill(skill_id));
}
bool Merc::CanHaveSkill(SkillUseTypes skill_id) const {
bool Merc::CanHaveSkill(EQEmu::skills::SkillType 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(SkillUseTypes skillid, uint16 class_, uint16 level) const {
uint16 Merc::MaxSkill(EQEmu::skills::SkillType skillid, uint16 class_, uint16 level) const {
return(database.GetSkillCap(class_, skillid, level));
}
@@ -1627,7 +1627,7 @@ void Merc::AI_Process() {
float DualWieldProbability = 0.0f;
int16 Ambidexterity = aabonuses.Ambidexterity + spellbonuses.Ambidexterity + itembonuses.Ambidexterity;
DualWieldProbability = (GetSkill(SkillDualWield) + GetLevel() + Ambidexterity) / 400.0f; // 78.0 max
DualWieldProbability = (GetSkill(EQEmu::skills::SkillDualWield) + GetLevel() + Ambidexterity) / 400.0f; // 78.0 max
int16 DWBonus = spellbonuses.DualWieldChance + itembonuses.DualWieldChance;
DualWieldProbability += DualWieldProbability*float(DWBonus)/ 100.0f;
@@ -2318,7 +2318,7 @@ bool Merc::AICastSpell(int8 iChance, int32 iSpellTypes) {
continue;
}
if(spells[selectedMercSpell.spellid].skill == SkillBackstab && spells[selectedMercSpell.spellid].targettype == ST_Self) {
if (spells[selectedMercSpell.spellid].skill == EQEmu::skills::SkillBackstab && spells[selectedMercSpell.spellid].targettype == ST_Self) {
if(!hidden) {
continue;
}
@@ -4432,7 +4432,7 @@ void Merc::DoClassAttacks(Mob *target) {
dmg = -5;
}
else{
if(target->CheckHitChance(this, SkillKick, 0)) {
if (target->CheckHitChance(this, EQEmu::skills::SkillKick, 0)) {
if(RuleB(Combat, UseIntervalAC))
dmg = GetKickDamage();
else
@@ -4442,7 +4442,7 @@ void Merc::DoClassAttacks(Mob *target) {
}
reuse = KickReuseTime * 1000;
DoSpecialAttackDamage(target, SkillKick, dmg, 1, -1, reuse);
DoSpecialAttackDamage(target, EQEmu::skills::SkillKick, dmg, 1, -1, reuse);
did_attack = true;
}
else
@@ -4454,7 +4454,7 @@ void Merc::DoClassAttacks(Mob *target) {
dmg = -5;
}
else{
if(target->CheckHitChance(this, SkillBash, 0)) {
if (target->CheckHitChance(this, EQEmu::skills::SkillBash, 0)) {
if(RuleB(Combat, UseIntervalAC))
dmg = GetBashDamage();
else
@@ -4463,7 +4463,7 @@ void Merc::DoClassAttacks(Mob *target) {
}
reuse = BashReuseTime * 1000;
DoSpecialAttackDamage(target, SkillBash, dmg, 1, -1, reuse);
DoSpecialAttackDamage(target, EQEmu::skills::SkillBash, dmg, 1, -1, reuse);
did_attack = true;
}
}
@@ -4485,7 +4485,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, SkillUseTypes attack_skill, bool avoidable, int8 buffslot, bool iBuffTic, int special)
void Merc::Damage(Mob* other, int32 damage, uint16 spell_id, EQEmu::skills::SkillType attack_skill, bool avoidable, int8 buffslot, bool iBuffTic, int special)
{
if(IsDead() || IsCorpse())
return;
@@ -4526,7 +4526,7 @@ Mob* Merc::GetOwnerOrSelf() {
return Result;
}
bool Merc::Death(Mob* killerMob, int32 damage, uint16 spell, SkillUseTypes attack_skill)
bool Merc::Death(Mob* killerMob, int32 damage, uint16 spell, EQEmu::skills::SkillType attack_skill)
{
if(!NPC::Death(killerMob, damage, spell, attack_skill))
{
zone/merc.h
+7 -7
View File
@@ -64,8 +64,8 @@ public:
virtual ~Merc();
//abstract virtual function implementations requird by base abstract class
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, int special = 0);
virtual bool Death(Mob* killerMob, int32 damage, uint16 spell_id, EQEmu::skills::SkillType attack_skill);
virtual void Damage(Mob* from, int32 damage, uint16 spell_id, EQEmu::skills::SkillType attack_skill, bool avoidable = true, int8 buffslot = -1, bool iBuffTic = false, int special = 0);
virtual bool Attack(Mob* other, int Hand = EQEmu::legacy::SlotPrimary, bool FromRiposte = false, bool IsStrikethrough = false,
bool IsFromSpell = false, ExtraAttackOptions *opts = nullptr, int special = 0);
virtual bool HasRaid() { return false; }
@@ -181,10 +181,10 @@ public:
inline const uint8 GetClientVersion() const { return _OwnerClientVersion; }
virtual void SetTarget(Mob* mob);
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()); }
bool HasSkill(EQEmu::skills::SkillType skill_id) const;
bool CanHaveSkill(EQEmu::skills::SkillType skill_id) const;
uint16 MaxSkill(EQEmu::skills::SkillType skillid, uint16 class_, uint16 level) const;
inline uint16 MaxSkill(EQEmu::skills::SkillType skillid) const { return MaxSkill(skillid, GetClass(), GetLevel()); }
virtual void DoClassAttacks(Mob *target);
void CheckHateList();
bool CheckTaunt();
@@ -291,7 +291,7 @@ protected:
std::vector<MercSpell> merc_spells;
std::map<uint32,MercTimer> timers;
uint16 skills[HIGHEST_SKILL+1];
uint16 skills[EQEmu::skills::HIGHEST_SKILL + 1];
uint32 equipment[EQEmu::legacy::EQUIPMENT_SIZE]; //this is an array of item IDs
uint16 d_melee_texture1; //this is an item Material value
uint16 d_melee_texture2; //this is an item Material value (offhand)
zone/mob.cpp
+57 -57
View File
@@ -427,7 +427,7 @@ Mob::Mob(const char* in_name,
m_AllowBeneficial = false;
m_DisableMelee = false;
for (int i = 0; i < HIGHEST_SKILL+2; i++) { SkillDmgTaken_Mod[i] = 0; }
for (int i = 0; i < EQEmu::skills::HIGHEST_SKILL + 2; i++) { SkillDmgTaken_Mod[i] = 0; }
for (int i = 0; i < HIGHEST_RESIST+2; i++) { Vulnerability_Mod[i] = 0; }
emoteid = 0;
@@ -2369,14 +2369,14 @@ void Mob::SetZone(uint32 zone_id, uint32 instance_id)
}
void Mob::Kill() {
Death(this, 0, SPELL_UNKNOWN, SkillHandtoHand);
Death(this, 0, SPELL_UNKNOWN, EQEmu::skills::SkillHandtoHand);
}
bool Mob::CanThisClassDualWield(void) const {
if(!IsClient()) {
return(GetSkill(SkillDualWield) > 0);
return(GetSkill(EQEmu::skills::SkillDualWield) > 0);
}
else if(CastToClient()->HasSkill(SkillDualWield)) {
else if (CastToClient()->HasSkill(EQEmu::skills::SkillDualWield)) {
const ItemInst* pinst = CastToClient()->GetInv().GetItem(EQEmu::legacy::SlotPrimary);
const ItemInst* sinst = CastToClient()->GetInv().GetItem(EQEmu::legacy::SlotSecondary);
@@ -2406,12 +2406,12 @@ bool Mob::CanThisClassDualWield(void) const {
bool Mob::CanThisClassDoubleAttack(void) const
{
if(!IsClient()) {
return(GetSkill(SkillDoubleAttack) > 0);
return(GetSkill(EQEmu::skills::SkillDoubleAttack) > 0);
} else {
if(aabonuses.GiveDoubleAttack || itembonuses.GiveDoubleAttack || spellbonuses.GiveDoubleAttack) {
return true;
}
return(CastToClient()->HasSkill(SkillDoubleAttack));
return(CastToClient()->HasSkill(EQEmu::skills::SkillDoubleAttack));
}
}
@@ -2420,7 +2420,7 @@ bool Mob::CanThisClassTripleAttack() const
if (!IsClient())
return false; // When they added the real triple attack skill, mobs lost the ability to triple
else
return CastToClient()->HasSkill(SkillTripleAttack);
return CastToClient()->HasSkill(EQEmu::skills::SkillTripleAttack);
}
bool Mob::IsWarriorClass(void) const
@@ -2459,36 +2459,36 @@ bool Mob::IsWarriorClass(void) const
bool Mob::CanThisClassParry(void) const
{
if(!IsClient()) {
return(GetSkill(SkillParry) > 0);
return(GetSkill(EQEmu::skills::SkillParry) > 0);
} else {
return(CastToClient()->HasSkill(SkillParry));
return(CastToClient()->HasSkill(EQEmu::skills::SkillParry));
}
}
bool Mob::CanThisClassDodge(void) const
{
if(!IsClient()) {
return(GetSkill(SkillDodge) > 0);
return(GetSkill(EQEmu::skills::SkillDodge) > 0);
} else {
return(CastToClient()->HasSkill(SkillDodge));
return(CastToClient()->HasSkill(EQEmu::skills::SkillDodge));
}
}
bool Mob::CanThisClassRiposte(void) const
{
if(!IsClient()) {
return(GetSkill(SkillRiposte) > 0);
return(GetSkill(EQEmu::skills::SkillRiposte) > 0);
} else {
return(CastToClient()->HasSkill(SkillRiposte));
return(CastToClient()->HasSkill(EQEmu::skills::SkillRiposte));
}
}
bool Mob::CanThisClassBlock(void) const
{
if(!IsClient()) {
return(GetSkill(SkillBlock) > 0);
return(GetSkill(EQEmu::skills::SkillBlock) > 0);
} else {
return(CastToClient()->HasSkill(SkillBlock));
return(CastToClient()->HasSkill(EQEmu::skills::SkillBlock));
}
}
/*
@@ -3411,19 +3411,19 @@ void Mob::TriggerDefensiveProcs(Mob *on, uint16 hand, bool FromSkillProc, int da
uint16 skillinuse = 0;
switch (damage) {
case (-1):
skillinuse = SkillBlock;
skillinuse = EQEmu::skills::SkillBlock;
break;
case (-2):
skillinuse = SkillParry;
skillinuse = EQEmu::skills::SkillParry;
break;
case (-3):
skillinuse = SkillRiposte;
skillinuse = EQEmu::skills::SkillRiposte;
break;
case (-4):
skillinuse = SkillDodge;
skillinuse = EQEmu::skills::SkillDodge;
break;
}
@@ -3784,15 +3784,15 @@ int32 Mob::GetVulnerability(Mob* caster, uint32 spell_id, uint32 ticsremaining)
return value;
}
int16 Mob::GetSkillDmgTaken(const SkillUseTypes skill_used, ExtraAttackOptions *opts)
int16 Mob::GetSkillDmgTaken(const EQEmu::skills::SkillType skill_used, ExtraAttackOptions *opts)
{
int skilldmg_mod = 0;
// All skill dmg mod + Skill specific
skilldmg_mod += itembonuses.SkillDmgTaken[HIGHEST_SKILL+1] + spellbonuses.SkillDmgTaken[HIGHEST_SKILL+1] +
skilldmg_mod += itembonuses.SkillDmgTaken[EQEmu::skills::HIGHEST_SKILL + 1] + spellbonuses.SkillDmgTaken[EQEmu::skills::HIGHEST_SKILL + 1] +
itembonuses.SkillDmgTaken[skill_used] + spellbonuses.SkillDmgTaken[skill_used];
skilldmg_mod += SkillDmgTaken_Mod[skill_used] + SkillDmgTaken_Mod[HIGHEST_SKILL+1];
skilldmg_mod += SkillDmgTaken_Mod[skill_used] + SkillDmgTaken_Mod[EQEmu::skills::HIGHEST_SKILL + 1];
if (opts)
skilldmg_mod += opts->skilldmgtaken_bonus_flat;
@@ -4606,7 +4606,7 @@ int16 Mob::GetCritDmgMob(uint16 skill)
int critDmg_mod = 0;
// All skill dmg mod + Skill specific
critDmg_mod += itembonuses.CritDmgMob[HIGHEST_SKILL+1] + spellbonuses.CritDmgMob[HIGHEST_SKILL+1] + aabonuses.CritDmgMob[HIGHEST_SKILL+1] +
critDmg_mod += itembonuses.CritDmgMob[EQEmu::skills::HIGHEST_SKILL + 1] + spellbonuses.CritDmgMob[EQEmu::skills::HIGHEST_SKILL + 1] + aabonuses.CritDmgMob[EQEmu::skills::HIGHEST_SKILL + 1] +
itembonuses.CritDmgMob[skill] + spellbonuses.CritDmgMob[skill] + aabonuses.CritDmgMob[skill];
if(critDmg_mod < -100)
@@ -4651,7 +4651,7 @@ int16 Mob::GetCriticalChanceBonus(uint16 skill)
int critical_chance = 0;
// All skills + Skill specific
critical_chance += itembonuses.CriticalHitChance[HIGHEST_SKILL+1] + spellbonuses.CriticalHitChance[HIGHEST_SKILL+1] + aabonuses.CriticalHitChance[HIGHEST_SKILL+1] +
critical_chance += itembonuses.CriticalHitChance[EQEmu::skills::HIGHEST_SKILL + 1] + spellbonuses.CriticalHitChance[EQEmu::skills::HIGHEST_SKILL + 1] + aabonuses.CriticalHitChance[EQEmu::skills::HIGHEST_SKILL + 1] +
itembonuses.CriticalHitChance[skill] + spellbonuses.CriticalHitChance[skill] + aabonuses.CriticalHitChance[skill];
if(critical_chance < -100)
@@ -4665,10 +4665,10 @@ int16 Mob::GetMeleeDamageMod_SE(uint16 skill)
int dmg_mod = 0;
// All skill dmg mod + Skill specific
dmg_mod += itembonuses.DamageModifier[HIGHEST_SKILL+1] + spellbonuses.DamageModifier[HIGHEST_SKILL+1] + aabonuses.DamageModifier[HIGHEST_SKILL+1] +
dmg_mod += itembonuses.DamageModifier[EQEmu::skills::HIGHEST_SKILL + 1] + spellbonuses.DamageModifier[EQEmu::skills::HIGHEST_SKILL + 1] + aabonuses.DamageModifier[EQEmu::skills::HIGHEST_SKILL + 1] +
itembonuses.DamageModifier[skill] + spellbonuses.DamageModifier[skill] + aabonuses.DamageModifier[skill];
dmg_mod += itembonuses.DamageModifier2[HIGHEST_SKILL+1] + spellbonuses.DamageModifier2[HIGHEST_SKILL+1] + aabonuses.DamageModifier2[HIGHEST_SKILL+1] +
dmg_mod += itembonuses.DamageModifier2[EQEmu::skills::HIGHEST_SKILL + 1] + spellbonuses.DamageModifier2[EQEmu::skills::HIGHEST_SKILL + 1] + aabonuses.DamageModifier2[EQEmu::skills::HIGHEST_SKILL + 1] +
itembonuses.DamageModifier2[skill] + spellbonuses.DamageModifier2[skill] + aabonuses.DamageModifier2[skill];
if (HasShieldEquiped() && !IsOffHandAtk())
@@ -4685,7 +4685,7 @@ int16 Mob::GetMeleeMinDamageMod_SE(uint16 skill)
int dmg_mod = 0;
dmg_mod = itembonuses.MinDamageModifier[skill] + spellbonuses.MinDamageModifier[skill] +
itembonuses.MinDamageModifier[HIGHEST_SKILL+1] + spellbonuses.MinDamageModifier[HIGHEST_SKILL+1];
itembonuses.MinDamageModifier[EQEmu::skills::HIGHEST_SKILL + 1] + spellbonuses.MinDamageModifier[EQEmu::skills::HIGHEST_SKILL + 1];
if(dmg_mod < -100)
dmg_mod = -100;
@@ -4717,10 +4717,10 @@ int16 Mob::GetSkillDmgAmt(uint16 skill)
int skill_dmg = 0;
// All skill dmg(only spells do this) + Skill specific
skill_dmg += spellbonuses.SkillDamageAmount[HIGHEST_SKILL+1] + itembonuses.SkillDamageAmount[HIGHEST_SKILL+1] + aabonuses.SkillDamageAmount[HIGHEST_SKILL+1]
skill_dmg += spellbonuses.SkillDamageAmount[EQEmu::skills::HIGHEST_SKILL + 1] + itembonuses.SkillDamageAmount[EQEmu::skills::HIGHEST_SKILL + 1] + aabonuses.SkillDamageAmount[EQEmu::skills::HIGHEST_SKILL + 1]
+ itembonuses.SkillDamageAmount[skill] + spellbonuses.SkillDamageAmount[skill] + aabonuses.SkillDamageAmount[skill];
skill_dmg += spellbonuses.SkillDamageAmount2[HIGHEST_SKILL+1] + itembonuses.SkillDamageAmount2[HIGHEST_SKILL+1]
skill_dmg += spellbonuses.SkillDamageAmount2[EQEmu::skills::HIGHEST_SKILL + 1] + itembonuses.SkillDamageAmount2[EQEmu::skills::HIGHEST_SKILL + 1]
+ itembonuses.SkillDamageAmount2[skill] + spellbonuses.SkillDamageAmount2[skill];
return skill_dmg;
@@ -4740,7 +4740,7 @@ void Mob::MeleeLifeTap(int32 damage) {
if (lifetap_amt > 0)
HealDamage(lifetap_amt); //Heal self for modified damage amount.
else
Damage(this, -lifetap_amt,0, SkillEvocation,false); //Dmg self for modified damage amount.
Damage(this, -lifetap_amt, 0, EQEmu::skills::SkillEvocation, false); //Dmg self for modified damage amount.
}
}
@@ -4914,21 +4914,21 @@ void Mob::SetBodyType(bodyType new_body, bool overwrite_orig) {
}
void Mob::ModSkillDmgTaken(SkillUseTypes skill_num, int value)
void Mob::ModSkillDmgTaken(EQEmu::skills::SkillType skill_num, int value)
{
if (skill_num == ALL_SKILLS)
SkillDmgTaken_Mod[HIGHEST_SKILL+1] = value;
SkillDmgTaken_Mod[EQEmu::skills::HIGHEST_SKILL + 1] = value;
else if (skill_num >= 0 && skill_num <= HIGHEST_SKILL)
else if (skill_num >= 0 && skill_num <= EQEmu::skills::HIGHEST_SKILL)
SkillDmgTaken_Mod[skill_num] = value;
}
int16 Mob::GetModSkillDmgTaken(const SkillUseTypes skill_num)
int16 Mob::GetModSkillDmgTaken(const EQEmu::skills::SkillType skill_num)
{
if (skill_num == ALL_SKILLS)
return SkillDmgTaken_Mod[HIGHEST_SKILL+1];
return SkillDmgTaken_Mod[EQEmu::skills::HIGHEST_SKILL + 1];
else if (skill_num >= 0 && skill_num <= HIGHEST_SKILL)
else if (skill_num >= 0 && skill_num <= EQEmu::skills::HIGHEST_SKILL)
return SkillDmgTaken_Mod[skill_num];
return 0;
@@ -5021,52 +5021,52 @@ uint16 Mob::GetSkillByItemType(int ItemType)
{
switch (ItemType) {
case EQEmu::item::ItemType1HSlash:
return Skill1HSlashing;
return EQEmu::skills::Skill1HSlashing;
case EQEmu::item::ItemType2HSlash:
return Skill2HSlashing;
return EQEmu::skills::Skill2HSlashing;
case EQEmu::item::ItemType1HPiercing:
return Skill1HPiercing;
return EQEmu::skills::Skill1HPiercing;
case EQEmu::item::ItemType1HBlunt:
return Skill1HBlunt;
return EQEmu::skills::Skill1HBlunt;
case EQEmu::item::ItemType2HBlunt:
return Skill2HBlunt;
return EQEmu::skills::Skill2HBlunt;
case EQEmu::item::ItemType2HPiercing:
if (IsClient() && CastToClient()->ClientVersion() < EQEmu::versions::ClientVersion::RoF2)
return Skill1HPiercing;
return EQEmu::skills::Skill1HPiercing;
else
return Skill2HPiercing;
return EQEmu::skills::Skill2HPiercing;
case EQEmu::item::ItemTypeBow:
return SkillArchery;
return EQEmu::skills::SkillArchery;
case EQEmu::item::ItemTypeLargeThrowing:
case EQEmu::item::ItemTypeSmallThrowing:
return SkillThrowing;
return EQEmu::skills::SkillThrowing;
case EQEmu::item::ItemTypeMartial:
return SkillHandtoHand;
return EQEmu::skills::SkillHandtoHand;
default:
return SkillHandtoHand;
return EQEmu::skills::SkillHandtoHand;
}
}
uint8 Mob::GetItemTypeBySkill(SkillUseTypes skill)
uint8 Mob::GetItemTypeBySkill(EQEmu::skills::SkillType skill)
{
switch (skill) {
case SkillThrowing:
case EQEmu::skills::SkillThrowing:
return EQEmu::item::ItemTypeSmallThrowing;
case SkillArchery:
case EQEmu::skills::SkillArchery:
return EQEmu::item::ItemTypeArrow;
case Skill1HSlashing:
case EQEmu::skills::Skill1HSlashing:
return EQEmu::item::ItemType1HSlash;
case Skill2HSlashing:
case EQEmu::skills::Skill2HSlashing:
return EQEmu::item::ItemType2HSlash;
case Skill1HPiercing:
case EQEmu::skills::Skill1HPiercing:
return EQEmu::item::ItemType1HPiercing;
case Skill2HPiercing: // watch for undesired client behavior
case EQEmu::skills::Skill2HPiercing: // watch for undesired client behavior
return EQEmu::item::ItemType2HPiercing;
case Skill1HBlunt:
case EQEmu::skills::Skill1HBlunt:
return EQEmu::item::ItemType1HBlunt;
case Skill2HBlunt:
case EQEmu::skills::Skill2HBlunt:
return EQEmu::item::ItemType2HBlunt;
case SkillHandtoHand:
case EQEmu::skills::SkillHandtoHand:
return EQEmu::item::ItemTypeMartial;
default:
return EQEmu::item::ItemTypeMartial;
zone/mob.h
+26 -25
View File
@@ -25,6 +25,7 @@
#include "position.h"
#include "aa_ability.h"
#include "aa.h"
#include "../common/light_source.h"
#include <set>
#include <vector>
#include <memory>
@@ -157,12 +158,12 @@ public:
int MonkSpecialAttack(Mob* other, uint8 skill_used);
virtual void TryBackstab(Mob *other,int ReuseTime = 10);
bool AvoidDamage(Mob* attacker, int32 &damage, int hand);
virtual bool CheckHitChance(Mob* attacker, SkillUseTypes skillinuse, int Hand, int16 chance_mod = 0);
virtual bool CheckHitChance(Mob* attacker, EQEmu::skills::SkillType 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, SkillUseTypes skillinuse);
uint32 TryHeadShot(Mob* defender, SkillUseTypes skillInUse);
uint32 TryAssassinate(Mob* defender, SkillUseTypes skillInUse, uint16 ReuseTime);
virtual bool TryFinishingBlow(Mob *defender, EQEmu::skills::SkillType skillinuse);
uint32 TryHeadShot(Mob* defender, EQEmu::skills::SkillType skillInUse);
uint32 TryAssassinate(Mob* defender, EQEmu::skills::SkillType skillInUse, uint16 ReuseTime);
virtual void DoRiposte(Mob* defender);
void ApplyMeleeDamageBonus(uint16 skill, int32 &damage,ExtraAttackOptions *opts = nullptr);
virtual void MeleeMitigation(Mob *attacker, int32 &damage, int32 minhit, ExtraAttackOptions *opts = nullptr);
@@ -170,7 +171,7 @@ public:
bool CombatRange(Mob* other);
virtual inline bool IsBerserk() { return false; } // only clients
void RogueEvade(Mob *other);
void CommonOutgoingHitSuccess(Mob* defender, int32 &damage, SkillUseTypes skillInUse,ExtraAttackOptions *opts = nullptr);
void CommonOutgoingHitSuccess(Mob* defender, int32 &damage, EQEmu::skills::SkillType skillInUse, ExtraAttackOptions *opts = nullptr);
void BreakInvisibleSpells();
void CommonBreakInvisibleFromCombat();
bool HasDied();
@@ -203,7 +204,7 @@ public:
virtual void WearChange(uint8 material_slot, uint16 texture, uint32 color, uint32 hero_forge_model = 0);
void DoAnim(const int animnum, int type=0, bool ackreq = true, eqFilterType filter = FilterNone);
void ProjectileAnimation(Mob* to, int item_id, bool IsArrow = false, float speed = 0,
float angle = 0, float tilt = 0, float arc = 0, const char *IDFile = nullptr, SkillUseTypes skillInUse = SkillArchery);
float angle = 0, float tilt = 0, float arc = 0, const char *IDFile = nullptr, EQEmu::skills::SkillType skillInUse = EQEmu::skills::SkillArchery);
void ChangeSize(float in_size, bool bNoRestriction = false);
inline uint8 SeeInvisible() const { return see_invis; }
inline bool SeeInvisibleUndead() const { return see_invis_undead; }
@@ -211,7 +212,7 @@ public:
inline bool SeeImprovedHide() const { return see_improved_hide; }
bool IsInvisible(Mob* other = 0) const;
void SetInvisible(uint8 state);
bool AttackAnimation(SkillUseTypes &skillinuse, int Hand, const ItemInst* weapon);
bool AttackAnimation(EQEmu::skills::SkillType &skillinuse, int Hand, const ItemInst* weapon);
//Song
bool UseBardSpellLogic(uint16 spell_id = 0xffff, int slot = -1);
@@ -348,7 +349,7 @@ public:
inline void SetTwoHandBluntEquiped(bool val) { has_twohandbluntequiped = val; }
bool HasTwoHanderEquipped() { return has_twohanderequipped; }
void SetTwoHanderEquipped(bool val) { has_twohanderequipped = val; }
virtual uint16 GetSkill(SkillUseTypes skill_num) const { return 0; }
virtual uint16 GetSkill(EQEmu::skills::SkillType skill_num) const { return 0; }
virtual uint32 GetEquipment(uint8 material_slot) const { return(0); }
virtual int32 GetEquipmentMaterial(uint8 material_slot) const;
virtual int32 GetHerosForgeModel(uint8 material_slot) const;
@@ -356,8 +357,8 @@ public:
virtual uint32 IsEliteMaterialItem(uint8 material_slot) const;
bool CanClassEquipItem(uint32 item_id);
bool AffectedBySpellExcludingSlot(int slot, int effect);
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,
virtual bool Death(Mob* killerMob, int32 damage, uint16 spell_id, EQEmu::skills::SkillType attack_skill) = 0;
virtual void Damage(Mob* from, int32 damage, uint16 spell_id, EQEmu::skills::SkillType attack_skill,
bool avoidable = true, int8 buffslot = -1, bool iBuffTic = false, int special = 0) = 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);
@@ -556,7 +557,7 @@ public:
static uint8 GetDefaultGender(uint16 in_race, uint8 in_gender = 0xFF);
static bool IsPlayerRace(uint16 in_race);
uint16 GetSkillByItemType(int ItemType);
uint8 GetItemTypeBySkill(SkillUseTypes skill);
uint8 GetItemTypeBySkill(EQEmu::skills::SkillType skill);
virtual void MakePet(uint16 spell_id, const char* pettype, const char *petname = nullptr);
virtual void MakePoweredPet(uint16 spell_id, const char* pettype, int16 petpower, const char *petname = nullptr, float in_size = 0.0f);
bool IsWarriorClass() const;
@@ -649,7 +650,7 @@ public:
int32 GetVulnerability(Mob* caster, uint32 spell_id, uint32 ticsremaining);
int32 GetFcDamageAmtIncoming(Mob *caster, uint32 spell_id, bool use_skill = false, uint16 skill=0);
int32 GetFocusIncoming(focusType type, int effect, Mob *caster, uint32 spell_id);
int16 GetSkillDmgTaken(const SkillUseTypes skill_used,ExtraAttackOptions *opts=nullptr);
int16 GetSkillDmgTaken(const EQEmu::skills::SkillType skill_used, ExtraAttackOptions *opts = nullptr);
void DoKnockback(Mob *caster, uint32 pushback, uint32 pushup);
int16 CalcResistChanceBonus();
int16 CalcFearResistChance();
@@ -682,8 +683,8 @@ public:
inline void SetSpellPowerDistanceMod(int16 value) { SpellPowerDistanceMod = value; };
int32 GetSpellStat(uint32 spell_id, const char *identifier, uint8 slot = 0);
void ModSkillDmgTaken(SkillUseTypes skill_num, int value);
int16 GetModSkillDmgTaken(const SkillUseTypes skill_num);
void ModSkillDmgTaken(EQEmu::skills::SkillType skill_num, int value);
int16 GetModSkillDmgTaken(const EQEmu::skills::SkillType skill_num);
void ModVulnerability(uint8 resist, int16 value);
int16 GetModVulnerability(const uint8 resist);
@@ -768,7 +769,7 @@ public:
int32 GetMeleeMitigation();
uint8 GetWeaponDamageBonus(const EQEmu::Item_Struct* weapon, bool offhand = false);
uint16 GetDamageTable(SkillUseTypes skillinuse);
uint16 GetDamageTable(EQEmu::skills::SkillType skillinuse);
virtual int GetHandToHandDamage(void);
bool CanThisClassDoubleAttack(void) const;
@@ -791,11 +792,11 @@ public:
int32 AffectMagicalDamage(int32 damage, uint16 spell_id, const bool iBuffTic, Mob* attacker);
int32 ReduceAllDamage(int32 damage);
virtual void DoSpecialAttackDamage(Mob *who, SkillUseTypes skill, int32 max_damage, int32 min_damage = 1, int32 hate_override = -1, int ReuseTime = 10, bool CheckHitChance=false, bool CanAvoid=true);
virtual void DoSpecialAttackDamage(Mob *who, EQEmu::skills::SkillType skill, int32 max_damage, int32 min_damage = 1, int32 hate_override = -1, int ReuseTime = 10, bool CheckHitChance = false, bool CanAvoid = true);
virtual void DoThrowingAttackDmg(Mob* other, const ItemInst* RangeWeapon=nullptr, const EQEmu::Item_Struct* AmmoItem=nullptr, uint16 weapon_damage=0, int16 chance_mod=0,int16 focus=0, int ReuseTime=0, uint32 range_id=0, int AmmoSlot=0, float speed = 4.0f);
virtual void DoMeleeSkillAttackDmg(Mob* other, uint16 weapon_damage, SkillUseTypes skillinuse, int16 chance_mod=0, int16 focus=0, bool CanRiposte=false, int ReuseTime=0);
virtual void DoMeleeSkillAttackDmg(Mob* other, uint16 weapon_damage, EQEmu::skills::SkillType skillinuse, int16 chance_mod = 0, int16 focus = 0, bool CanRiposte = false, int ReuseTime = 0);
virtual void DoArcheryAttackDmg(Mob* other, const ItemInst* RangeWeapon=nullptr, const ItemInst* Ammo=nullptr, uint16 weapon_damage=0, int16 chance_mod=0, int16 focus=0, int ReuseTime=0, uint32 range_id=0, uint32 ammo_id=0, const EQEmu::Item_Struct *AmmoItem=nullptr, int AmmoSlot=0, float speed= 4.0f);
bool TryProjectileAttack(Mob* other, const EQEmu::Item_Struct *item, SkillUseTypes skillInUse, uint16 weapon_dmg, const ItemInst* RangeWeapon, const ItemInst* Ammo, int AmmoSlot, float speed);
bool TryProjectileAttack(Mob* other, const EQEmu::Item_Struct *item, EQEmu::skills::SkillType skillInUse, uint16 weapon_dmg, const ItemInst* RangeWeapon, const ItemInst* Ammo, int AmmoSlot, float speed);
void ProjectileAttack();
inline bool HasProjectileAttack() const { return ActiveProjectileATK; }
inline void SetProjectileAttack(bool value) { ActiveProjectileATK = value; }
@@ -913,7 +914,7 @@ public:
// HP Event
inline int GetNextHPEvent() const { return nexthpevent; }
void SetNextHPEvent( int hpevent );
void SendItemAnimation(Mob *to, const EQEmu::Item_Struct *item, SkillUseTypes skillInUse, float velocity= 4.0);
void SendItemAnimation(Mob *to, const EQEmu::Item_Struct *item, EQEmu::skills::SkillType skillInUse, float velocity = 4.0);
inline int& GetNextIncHPEvent() { return nextinchpevent; }
void SetNextIncHPEvent( int inchpevent );
@@ -964,7 +965,7 @@ public:
bool HasSpellEffect(int effectid);
int mod_effect_value(int effect_value, uint16 spell_id, int effect_type, Mob* caster, uint16 caster_id);
float mod_hit_chance(float chancetohit, SkillUseTypes skillinuse, Mob* attacker);
float mod_hit_chance(float chancetohit, EQEmu::skills::SkillType 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);
@@ -975,7 +976,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, SkillUseTypes skill_type);
int32 mod_monk_special_damage(int32 ndamage, EQEmu::skills::SkillType 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);
@@ -994,7 +995,7 @@ public:
uint32 Tune_GetMeanDamage(Mob* GM, Mob *attacker, int32 damage, int32 minhit, ExtraAttackOptions *opts = nullptr, int Msg = 0,int ac_override=0, int atk_override=0, int add_ac=0, int add_atk = 0);
void Tune_FindATKByPctMitigation(Mob* defender, Mob *attacker, float pct_mitigation, int interval = 50, int max_loop = 100, int ac_override=0,int Msg =0);
void Tune_FindACByPctMitigation(Mob* defender, Mob *attacker, float pct_mitigation, int interval = 50, int max_loop = 100, int atk_override=0,int Msg =0);
float Tune_CheckHitChance(Mob* defender, Mob* attacker, SkillUseTypes skillinuse, int Hand, int16 chance_mod, int Msg = 1,int acc_override=0, int avoid_override=0, int add_acc=0, int add_avoid = 0);
float Tune_CheckHitChance(Mob* defender, Mob* attacker, EQEmu::skills::SkillType skillinuse, int Hand, int16 chance_mod, int Msg = 1, int acc_override = 0, int avoid_override = 0, int add_acc = 0, int add_avoid = 0);
void Tune_FindAccuaryByHitChance(Mob* defender, Mob *attacker, float hit_chance, int interval, int max_loop, int avoid_override, int Msg = 0);
void Tune_FindAvoidanceByHitChance(Mob* defender, Mob *attacker, float hit_chance, int interval, int max_loop, int acc_override, int Msg = 0);
@@ -1031,7 +1032,7 @@ public:
#endif
protected:
void CommonDamage(Mob* other, int32 &damage, const uint16 spell_id, const SkillUseTypes attack_skill, bool &avoidable, const int8 buffslot, const bool iBuffTic, int special = 0);
void CommonDamage(Mob* other, int32 &damage, const uint16 spell_id, const EQEmu::skills::SkillType attack_skill, bool &avoidable, const int8 buffslot, const bool iBuffTic, int special = 0);
static uint16 GetProcID(uint16 spell_id, uint8 effect_index);
float _GetMovementSpeed(int mod) const;
int _GetWalkSpeed() const;
@@ -1049,7 +1050,7 @@ protected:
std::vector<uint16> RampageArray;
std::map<std::string, std::string> m_EntityVariables;
int16 SkillDmgTaken_Mod[HIGHEST_SKILL+2];
int16 SkillDmgTaken_Mod[EQEmu::skills::HIGHEST_SKILL + 2];
int16 Vulnerability_Mod[HIGHEST_RESIST+2];
bool m_AllowBeneficial;
bool m_DisableMelee;
@@ -1165,7 +1166,7 @@ protected:
int GetWeaponDamage(Mob *against, const ItemInst *weapon_item, uint32 *hate = nullptr);
int GetKickDamage();
int GetBashDamage();
virtual void ApplySpecialAttackMod(SkillUseTypes skill, int32 &dmg, int32 &mindmg);
virtual void ApplySpecialAttackMod(EQEmu::skills::SkillType skill, int32 &dmg, int32 &mindmg);
virtual int16 GetFocusEffect(focusType type, uint16 spell_id) { return 0; }
void CalculateNewFearpoint();
float FindGroundZ(float new_x, float new_y, float z_offset=0.0);
zone/mod_functions.cpp
+5 -5
View File
@@ -29,7 +29,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, SkillUseTypes skillinuse, int hand, const EQEmu::Item_Struct* weapon, Mob* other) { return(damage); }
int NPC::mod_npc_damage(int damage, EQEmu::skills::SkillType skillinuse, int hand, const EQEmu::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; }
@@ -38,7 +38,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, SkillUseTypes skillinuse, int hand, const ItemInst* weapon, Mob* other) { return(damage); }
int Client::mod_client_damage(int damage, EQEmu::skills::SkillType 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:
@@ -58,7 +58,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(SkillUseTypes skillid, Mob* against_who) { return(false); }
bool Client::mod_can_increase_skill(EQEmu::skills::SkillType 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); }
@@ -114,7 +114,7 @@ int Client::mod_drink_value(const EQEmu::Item_Struct *item, int change) { return
int Mob::mod_effect_value(int effect_value, uint16 spell_id, int effect_type, Mob* caster, uint16 caster_id) { return(effect_value); }
//chancetohit - 0 to 100 percent - set over 1000 for a guaranteed hit
float Mob::mod_hit_chance(float chancetohit, SkillUseTypes skillinuse, Mob* attacker) { return(chancetohit); }
float Mob::mod_hit_chance(float chancetohit, EQEmu::skills::SkillType skillinuse, Mob* attacker) { return(chancetohit); }
//Final riposte chance
float Mob::mod_riposte_chance(float ripostechance, Mob* attacker) { return(ripostechance); }
@@ -146,7 +146,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, SkillUseTypes skill_type) { return(ndamage); }
int32 Mob::mod_monk_special_damage(int32 ndamage, EQEmu::skills::SkillType skill_type) { return(ndamage); }
//ndamage - Backstab damage as calculated by default formulas
int32 Mob::mod_backstab_damage(int32 ndamage) { return(ndamage); }
zone/npc.cpp
+10 -9
View File
@@ -30,6 +30,7 @@
#include "../common/item_struct.h"
#include "../common/linked_list.h"
#include "../common/servertalk.h"
#include "../common/say_link.h"
#include "client.h"
#include "entity.h"
@@ -276,20 +277,20 @@ NPC::NPC(const NPCType* d, Spawn2* in_respawn, const glm::vec4& position, int if
//give NPCs skill values...
int r;
for(r = 0; r <= HIGHEST_SKILL; r++) {
skills[r] = database.GetSkillCap(GetClass(),(SkillUseTypes)r,moblevel);
for (r = 0; r <= EQEmu::skills::HIGHEST_SKILL; r++) {
skills[r] = database.GetSkillCap(GetClass(), (EQEmu::skills::SkillType)r, moblevel);
}
// some overrides -- really we need to be able to set skills for mobs in the DB
// There are some known low level SHM/BST pets that do not follow this, which supports
// the theory of needing to be able to set skills for each mob separately
if (moblevel > 50) {
skills[SkillDoubleAttack] = 250;
skills[SkillDualWield] = 250;
skills[EQEmu::skills::SkillDoubleAttack] = 250;
skills[EQEmu::skills::SkillDualWield] = 250;
} else if (moblevel > 3) {
skills[SkillDoubleAttack] = moblevel * 5;
skills[SkillDualWield] = skills[SkillDoubleAttack];
skills[EQEmu::skills::SkillDoubleAttack] = moblevel * 5;
skills[EQEmu::skills::SkillDualWield] = skills[EQEmu::skills::SkillDoubleAttack];
} else {
skills[SkillDoubleAttack] = moblevel * 5;
skills[EQEmu::skills::SkillDoubleAttack] = moblevel * 5;
}
if(d->trap_template > 0)
@@ -1427,7 +1428,7 @@ uint32 NPC::GetMaxDamage(uint8 tlevel)
void NPC::PickPocket(Client* thief)
{
thief->CheckIncreaseSkill(SkillPickPockets, nullptr, 5);
thief->CheckIncreaseSkill(EQEmu::skills::SkillPickPockets, nullptr, 5);
//make sure were allowed to target them:
int over_level = GetLevel();
@@ -1446,7 +1447,7 @@ void NPC::PickPocket(Client* thief)
return;
}
int steal_skill = thief->GetSkill(SkillPickPockets);
int steal_skill = thief->GetSkill(EQEmu::skills::SkillPickPockets);
int steal_chance = steal_skill * 100 / (5 * over_level + 5);
// Determine whether to steal money or an item.
zone/npc.h
+6 -6
View File
@@ -108,8 +108,8 @@ public:
virtual ~NPC();
//abstract virtual function implementations requird by base abstract class
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, int special = 0);
virtual bool Death(Mob* killerMob, int32 damage, uint16 spell_id, EQEmu::skills::SkillType attack_skill);
virtual void Damage(Mob* from, int32 damage, uint16 spell_id, EQEmu::skills::SkillType attack_skill, bool avoidable = true, int8 buffslot = -1, bool iBuffTic = false, int special = 0);
virtual bool Attack(Mob* other, int Hand = EQEmu::legacy::SlotPrimary, bool FromRiposte = false, bool IsStrikethrough = false,
bool IsFromSpell = false, ExtraAttackOptions *opts = nullptr, int special = 0);
virtual bool HasRaid() { return false; }
@@ -142,7 +142,7 @@ public:
void CalcNPCDamage();
virtual void SetTarget(Mob* mob);
virtual uint16 GetSkill(SkillUseTypes skill_num) const { if (skill_num <= HIGHEST_SKILL) { return skills[skill_num]; } return 0; }
virtual uint16 GetSkill(EQEmu::skills::SkillType skill_num) const { if (skill_num <= EQEmu::skills::HIGHEST_SKILL) { return skills[skill_num]; } return 0; }
void CalcItemBonuses(StatBonuses *newbon);
virtual void CalcBonuses();
@@ -161,7 +161,7 @@ public:
virtual void RangedAttack(Mob* other);
virtual void ThrowingAttack(Mob* other) { }
int32 GetNumberOfAttacks() const { return attack_count; }
void DoRangedAttackDmg(Mob* other, bool Launch=true, int16 damage_mod=0, int16 chance_mod=0, SkillUseTypes skill=SkillArchery, float speed=4.0f, const char *IDFile = nullptr);
void DoRangedAttackDmg(Mob* other, bool Launch = true, int16 damage_mod = 0, int16 chance_mod = 0, EQEmu::skills::SkillType skill = EQEmu::skills::SkillArchery, float speed = 4.0f, const char *IDFile = nullptr);
bool DatabaseCastAccepted(int spell_id);
bool IsFactionListAlly(uint32 other_faction);
@@ -403,7 +403,7 @@ public:
void SetMerchantProbability(uint8 amt) { probability = amt; }
uint8 GetMerchantProbability() { return probability; }
void mod_prespawn(Spawn2 *sp);
int mod_npc_damage(int damage, SkillUseTypes skillinuse, int hand, const EQEmu::Item_Struct* weapon, Mob* other);
int mod_npc_damage(int damage, EQEmu::skills::SkillType skillinuse, int hand, const EQEmu::Item_Struct* weapon, Mob* other);
void mod_npc_killed_merit(Mob* c);
void mod_npc_killed(Mob* oos);
void AISpellsList(Client *c);
@@ -497,7 +497,7 @@ protected:
uint32 roambox_delay;
uint32 roambox_min_delay;
uint16 skills[HIGHEST_SKILL+1];
uint16 skills[EQEmu::skills::HIGHEST_SKILL + 1];
uint32 equipment[EQEmu::legacy::EQUIPMENT_SIZE]; //this is an array of item IDs
zone/object.h
+1 -1
View File
@@ -108,7 +108,7 @@ public:
static void HandleAugmentation(Client* user, const AugmentItem_Struct* in_augment, Object *worldo);
static void HandleAutoCombine(Client* user, const RecipeAutoCombine_Struct* rac);
static SkillUseTypes TypeToSkill(uint32 type);
static EQEmu::skills::SkillType TypeToSkill(uint32 type);
// Packet functions
void CreateSpawnPacket(EQApplicationPacket* app);
zone/perl_client.cpp
+8 -8
View File
@@ -1940,7 +1940,7 @@ XS(XS_Client_GetSkill)
Client * THIS;
uint16 RETVAL;
dXSTARG;
SkillUseTypes skill_id = (SkillUseTypes)SvUV(ST(1));
EQEmu::skills::SkillType skill_id = (EQEmu::skills::SkillType)SvUV(ST(1));
if (sv_derived_from(ST(0), "Client")) {
IV tmp = SvIV((SV*)SvRV(ST(0)));
@@ -1967,7 +1967,7 @@ XS(XS_Client_GetRawSkill)
Client * THIS;
uint32 RETVAL;
dXSTARG;
SkillUseTypes skill_id = (SkillUseTypes)SvUV(ST(1));
EQEmu::skills::SkillType skill_id = (EQEmu::skills::SkillType)SvUV(ST(1));
if (sv_derived_from(ST(0), "Client")) {
IV tmp = SvIV((SV*)SvRV(ST(0)));
@@ -1993,7 +1993,7 @@ XS(XS_Client_HasSkill)
{
Client * THIS;
bool RETVAL;
SkillUseTypes skill_id = (SkillUseTypes)SvUV(ST(1));
EQEmu::skills::SkillType skill_id = (EQEmu::skills::SkillType)SvUV(ST(1));
if (sv_derived_from(ST(0), "Client")) {
IV tmp = SvIV((SV*)SvRV(ST(0)));
@@ -2020,7 +2020,7 @@ XS(XS_Client_CanHaveSkill)
{
Client * THIS;
bool RETVAL;
SkillUseTypes skill_id = (SkillUseTypes)SvUV(ST(1));
EQEmu::skills::SkillType skill_id = (EQEmu::skills::SkillType)SvUV(ST(1));
if (sv_derived_from(ST(0), "Client")) {
IV tmp = SvIV((SV*)SvRV(ST(0)));
@@ -2046,7 +2046,7 @@ XS(XS_Client_SetSkill)
Perl_croak(aTHX_ "Usage: Client::SetSkill(THIS, skill_num, value)");
{
Client * THIS;
SkillUseTypes skill_num = (SkillUseTypes)SvUV(ST(1));
EQEmu::skills::SkillType skill_num = (EQEmu::skills::SkillType)SvUV(ST(1));
uint16 value = (uint16)SvUV(ST(2));
if (sv_derived_from(ST(0), "Client")) {
@@ -2071,7 +2071,7 @@ XS(XS_Client_AddSkill)
Perl_croak(aTHX_ "Usage: Client::AddSkill(THIS, skillid, value)");
{
Client * THIS;
SkillUseTypes skillid = (SkillUseTypes)SvUV(ST(1));
EQEmu::skills::SkillType skillid = (EQEmu::skills::SkillType)SvUV(ST(1));
uint16 value = (uint16)SvUV(ST(2));
if (sv_derived_from(ST(0), "Client")) {
@@ -2121,7 +2121,7 @@ XS(XS_Client_CheckIncreaseSkill)
{
Client * THIS;
bool RETVAL;
SkillUseTypes skillid = (SkillUseTypes)SvUV(ST(1));
EQEmu::skills::SkillType skillid = (EQEmu::skills::SkillType)SvUV(ST(1));
int chancemodi;
if (sv_derived_from(ST(0), "Client")) {
@@ -2180,7 +2180,7 @@ XS(XS_Client_MaxSkill)
{
Client * THIS;
uint16 RETVAL;
SkillUseTypes skillid = (SkillUseTypes)SvUV(ST(1));
EQEmu::skills::SkillType skillid = (EQEmu::skills::SkillType)SvUV(ST(1));
uint16 class_ = 0;
uint16 level = 0;
dXSTARG;
zone/perl_mob.cpp
+7 -7
View File
@@ -619,7 +619,7 @@ XS(XS_Mob_GetSkill)
Mob * THIS;
uint32 RETVAL;
dXSTARG;
SkillUseTypes skill_num = (SkillUseTypes)SvUV(ST(1));
EQEmu::skills::SkillType skill_num = (EQEmu::skills::SkillType)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));
SkillUseTypes attack_skill = (SkillUseTypes)SvUV(ST(4));
EQEmu::skills::SkillType attack_skill = (EQEmu::skills::SkillType)SvUV(ST(4));
bool avoidable;
int8 buffslot;
bool iBuffTic;
@@ -6836,7 +6836,7 @@ XS(XS_Mob_DoSpecialAttackDamage)
{
Mob * THIS;
Mob* target;
SkillUseTypes attack_skill = (SkillUseTypes)SvUV(ST(2));
EQEmu::skills::SkillType attack_skill = (EQEmu::skills::SkillType)SvUV(ST(2));
int32 max_damage = (int32)SvIV(ST(3));
int32 min_damage = 1;
int32 hate_override = -11;
@@ -7835,7 +7835,7 @@ XS(XS_Mob_ModSkillDmgTaken)
Perl_croak(aTHX_ "Usage: Mob::ModSkillDmgTaken(THIS, skill, value)");
{
Mob * THIS;
SkillUseTypes skill_num = (SkillUseTypes)SvUV(ST(1));
EQEmu::skills::SkillType skill_num = (EQEmu::skills::SkillType)SvUV(ST(1));
int16 value = (int16)SvIV(ST(2));
if (sv_derived_from(ST(0), "Mob")) {
@@ -7862,7 +7862,7 @@ XS(XS_Mob_GetModSkillDmgTaken)
Mob * THIS;
int16 RETVAL;
dXSTARG;
SkillUseTypes skill_num = (SkillUseTypes)SvUV(ST(1));
EQEmu::skills::SkillType skill_num = (EQEmu::skills::SkillType)SvUV(ST(1));
if (sv_derived_from(ST(0), "Mob")) {
IV tmp = SvIV((SV*)SvRV(ST(0)));
@@ -7889,7 +7889,7 @@ XS(XS_Mob_GetSkillDmgTaken)
Mob * THIS;
int32 RETVAL;
dXSTARG;
SkillUseTypes skill_num = (SkillUseTypes)SvUV(ST(1));
EQEmu::skills::SkillType skill_num = (EQEmu::skills::SkillType)SvUV(ST(1));
if (sv_derived_from(ST(0), "Mob")) {
IV tmp = SvIV((SV*)SvRV(ST(0)));
@@ -8055,7 +8055,7 @@ XS(XS_Mob_DoMeleeSkillAttackDmg)
Mob * THIS;
Mob* target;
uint16 weapon_damage = (uint16)SvIV(ST(2));
SkillUseTypes skill = (SkillUseTypes)SvUV(ST(3));
EQEmu::skills::SkillType skill = (EQEmu::skills::SkillType)SvUV(ST(3));
int16 chance_mod = (int16)SvIV(ST(4));
int16 focus = (int16)SvIV(ST(5));
uint8 CanRiposte = (uint8)SvIV(ST(6));
zone/questmgr.cpp
+8 -7
View File
@@ -22,6 +22,7 @@
#include "../common/skills.h"
#include "../common/spdat.h"
#include "../common/string_util.h"
#include "../common/say_link.h"
#include "entity.h"
#include "event_codes.h"
@@ -1152,10 +1153,10 @@ void QuestManager::doanim(int anim_id) {
void QuestManager::addskill(int skill_id, int value) {
QuestManagerCurrentQuestVars();
if(skill_id < 0 || skill_id > HIGHEST_SKILL)
if (skill_id < 0 || skill_id > EQEmu::skills::HIGHEST_SKILL)
return;
if (initiator && initiator->IsClient())
initiator->AddSkill((SkillUseTypes) skill_id, value);
initiator->AddSkill((EQEmu::skills::SkillType) skill_id, value);
}
void QuestManager::setlanguage(int skill_id, int value) {
@@ -1166,10 +1167,10 @@ void QuestManager::setlanguage(int skill_id, int value) {
void QuestManager::setskill(int skill_id, int value) {
QuestManagerCurrentQuestVars();
if(skill_id < 0 || skill_id > HIGHEST_SKILL)
if (skill_id < 0 || skill_id > EQEmu::skills::HIGHEST_SKILL)
return;
if (initiator && initiator->IsClient())
initiator->SetSkill((SkillUseTypes) skill_id, value);
initiator->SetSkill((EQEmu::skills::SkillType) skill_id, value);
}
void QuestManager::setallskill(int value) {
@@ -1177,8 +1178,8 @@ void QuestManager::setallskill(int value) {
if (!initiator)
return;
if (initiator && initiator->IsClient()) {
SkillUseTypes sk;
for (sk = Skill1HBlunt; sk <= HIGHEST_SKILL; sk = (SkillUseTypes)(sk+1)) {
EQEmu::skills::SkillType sk;
for (sk = EQEmu::skills::Skill1HBlunt; sk <= EQEmu::skills::HIGHEST_SKILL; sk = (EQEmu::skills::SkillType)(sk + 1)) {
initiator->SetSkill(sk, value);
}
}
@@ -1772,7 +1773,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, SkillHandtoHand, false, 0, false);
owner->Damage(owner, newhp, SPELL_UNKNOWN, EQEmu::skills::SkillHandtoHand, false, 0, false);
}
bool QuestManager::summonburiedplayercorpse(uint32 char_id, const glm::vec4& position) {
zone/special_attacks.cpp
+200 -214
View File
File diff suppressed because it is too large Load Diff
zone/spell_effects.cpp
+12 -15
View File
@@ -2271,18 +2271,15 @@ bool Mob::SpellEffect(Mob* caster, uint16 spell_id, float partial, int level_ove
focus = caster->GetFocusEffect(focusFcBaseEffects, spell_id);
switch(spells[spell_id].skill)
{
case SkillThrowing:
caster->DoThrowingAttackDmg(this, nullptr, nullptr, spells[spell_id].base[i],spells[spell_id].base2[i], focus, ReuseTime);
switch(spells[spell_id].skill) {
case EQEmu::skills::SkillThrowing:
caster->DoThrowingAttackDmg(this, nullptr, nullptr, spells[spell_id].base[i],spells[spell_id].base2[i], focus, ReuseTime);
break;
case SkillArchery:
caster->DoArcheryAttackDmg(this, nullptr, nullptr, spells[spell_id].base[i],spells[spell_id].base2[i],focus, ReuseTime);
case EQEmu::skills::SkillArchery:
caster->DoArcheryAttackDmg(this, nullptr, nullptr, spells[spell_id].base[i],spells[spell_id].base2[i],focus, ReuseTime);
break;
default:
caster->DoMeleeSkillAttackDmg(this, spells[spell_id].base[i], spells[spell_id].skill, spells[spell_id].base2[i], focus, false, ReuseTime);
default:
caster->DoMeleeSkillAttackDmg(this, spells[spell_id].base[i], spells[spell_id].skill, spells[spell_id].base2[i], focus, false, ReuseTime);
break;
}
break;
@@ -3046,7 +3043,7 @@ int Mob::CalcSpellEffectValue(uint16 spell_id, int effect_id, int caster_level,
effect_value = CalcSpellEffectValue_formula(formula, base, max, caster_level, spell_id, ticsremaining);
// this doesn't actually need to be a song to get mods, just the right skill
if (EQEmu::IsBardInstrumentSkill(spells[spell_id].skill) &&
if (EQEmu::skills::IsBardInstrumentSkill(spells[spell_id].skill) &&
spells[spell_id].effectid[effect_id] != SE_AttackSpeed &&
spells[spell_id].effectid[effect_id] != SE_AttackSpeed2 &&
spells[spell_id].effectid[effect_id] != SE_AttackSpeed3 &&
@@ -3613,13 +3610,13 @@ void Mob::DoBuffTic(const Buffs_Struct &buff, int slot, Mob *caster)
if (!IsBardSong(buff.spellid)) {
double break_chance = 2.0;
if (caster) {
break_chance -= (2 * (((double)caster->GetSkill(SkillDivination) +
break_chance -= (2 * (((double)caster->GetSkill(EQEmu::skills::SkillDivination) +
((double)caster->GetLevel() * 3.0)) /
650.0));
} else {
break_chance -=
(2 *
(((double)GetSkill(SkillDivination) + ((double)GetLevel() * 3.0)) /
(((double)GetSkill(EQEmu::skills::SkillDivination) + ((double)GetLevel() * 3.0)) /
650.0));
}
@@ -6564,7 +6561,7 @@ bool Mob::TrySpellProjectile(Mob* spell_target, uint16 spell_id, float speed){
ProjectileAtk[slot].origin_x = GetX();
ProjectileAtk[slot].origin_y = GetY();
ProjectileAtk[slot].origin_z = GetZ();
ProjectileAtk[slot].skill = SkillConjuration;
ProjectileAtk[slot].skill = EQEmu::skills::SkillConjuration;
ProjectileAtk[slot].speed_mod = speed_mod;
SetProjectileAttack(true);
@@ -6619,7 +6616,7 @@ void Mob::ResourceTap(int32 damage, uint16 spellid)
if (damage > 0)
HealDamage(damage);
else
Damage(this, -damage, 0, SkillEvocation, false);
Damage(this, -damage, 0, EQEmu::skills::SkillEvocation, false);
}
if (spells[spellid].base2[i] == 1) // Mana Tap
zone/spells.cpp
+42 -42
View File
@@ -556,16 +556,16 @@ bool Mob::DoCastingChecks()
uint16 Mob::GetSpecializeSkillValue(uint16 spell_id) const {
switch(spells[spell_id].skill) {
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));
case EQEmu::skills::SkillAbjuration:
return(GetSkill(EQEmu::skills::SkillSpecializeAbjure));
case EQEmu::skills::SkillAlteration:
return(GetSkill(EQEmu::skills::SkillSpecializeAlteration));
case EQEmu::skills::SkillConjuration:
return(GetSkill(EQEmu::skills::SkillSpecializeConjuration));
case EQEmu::skills::SkillDivination:
return(GetSkill(EQEmu::skills::SkillSpecializeDivination));
case EQEmu::skills::SkillEvocation:
return(GetSkill(EQEmu::skills::SkillSpecializeEvocation));
default:
//wtf...
break;
@@ -584,20 +584,20 @@ void Client::CheckSpecializeIncrease(uint16 spell_id) {
*/
switch(spells[spell_id].skill) {
case SkillAbjuration:
CheckIncreaseSkill(SkillSpecializeAbjure, nullptr);
case EQEmu::skills::SkillAbjuration:
CheckIncreaseSkill(EQEmu::skills::SkillSpecializeAbjure, nullptr);
break;
case SkillAlteration:
CheckIncreaseSkill(SkillSpecializeAlteration, nullptr);
case EQEmu::skills::SkillAlteration:
CheckIncreaseSkill(EQEmu::skills::SkillSpecializeAlteration, nullptr);
break;
case SkillConjuration:
CheckIncreaseSkill(SkillSpecializeConjuration, nullptr);
case EQEmu::skills::SkillConjuration:
CheckIncreaseSkill(EQEmu::skills::SkillSpecializeConjuration, nullptr);
break;
case SkillDivination:
CheckIncreaseSkill(SkillSpecializeDivination, nullptr);
case EQEmu::skills::SkillDivination:
CheckIncreaseSkill(EQEmu::skills::SkillSpecializeDivination, nullptr);
break;
case SkillEvocation:
CheckIncreaseSkill(SkillSpecializeEvocation, nullptr);
case EQEmu::skills::SkillEvocation:
CheckIncreaseSkill(EQEmu::skills::SkillSpecializeEvocation, nullptr);
break;
default:
//wtf...
@@ -617,48 +617,48 @@ void Client::CheckSongSkillIncrease(uint16 spell_id){
switch(spells[spell_id].skill)
{
case SkillSinging:
CheckIncreaseSkill(SkillSinging, nullptr, -15);
case EQEmu::skills::SkillSinging:
CheckIncreaseSkill(EQEmu::skills::SkillSinging, nullptr, -15);
break;
case SkillPercussionInstruments:
case EQEmu::skills::SkillPercussionInstruments:
if(this->itembonuses.percussionMod > 0) {
if(GetRawSkill(SkillPercussionInstruments) > 0) // no skill increases if not trained in the instrument
CheckIncreaseSkill(SkillPercussionInstruments, nullptr, -15);
if (GetRawSkill(EQEmu::skills::SkillPercussionInstruments) > 0) // no skill increases if not trained in the instrument
CheckIncreaseSkill(EQEmu::skills::SkillPercussionInstruments, nullptr, -15);
else
Message_StringID(13,NO_INSTRUMENT_SKILL); // tell the client that they need instrument training
}
else
CheckIncreaseSkill(SkillSinging, nullptr, -15);
CheckIncreaseSkill(EQEmu::skills::SkillSinging, nullptr, -15);
break;
case SkillStringedInstruments:
case EQEmu::skills::SkillStringedInstruments:
if(this->itembonuses.stringedMod > 0) {
if(GetRawSkill(SkillStringedInstruments) > 0)
CheckIncreaseSkill(SkillStringedInstruments, nullptr, -15);
if (GetRawSkill(EQEmu::skills::SkillStringedInstruments) > 0)
CheckIncreaseSkill(EQEmu::skills::SkillStringedInstruments, nullptr, -15);
else
Message_StringID(13,NO_INSTRUMENT_SKILL);
}
else
CheckIncreaseSkill(SkillSinging, nullptr, -15);
CheckIncreaseSkill(EQEmu::skills::SkillSinging, nullptr, -15);
break;
case SkillWindInstruments:
case EQEmu::skills::SkillWindInstruments:
if(this->itembonuses.windMod > 0) {
if(GetRawSkill(SkillWindInstruments) > 0)
CheckIncreaseSkill(SkillWindInstruments, nullptr, -15);
if (GetRawSkill(EQEmu::skills::SkillWindInstruments) > 0)
CheckIncreaseSkill(EQEmu::skills::SkillWindInstruments, nullptr, -15);
else
Message_StringID(13,NO_INSTRUMENT_SKILL);
}
else
CheckIncreaseSkill(SkillSinging, nullptr, -15);
CheckIncreaseSkill(EQEmu::skills::SkillSinging, nullptr, -15);
break;
case SkillBrassInstruments:
case EQEmu::skills::SkillBrassInstruments:
if(this->itembonuses.brassMod > 0) {
if(GetRawSkill(SkillBrassInstruments) > 0)
CheckIncreaseSkill(SkillBrassInstruments, nullptr, -15);
if (GetRawSkill(EQEmu::skills::SkillBrassInstruments) > 0)
CheckIncreaseSkill(EQEmu::skills::SkillBrassInstruments, nullptr, -15);
else
Message_StringID(13,NO_INSTRUMENT_SKILL);
}
else
CheckIncreaseSkill(SkillSinging, nullptr, -15);
CheckIncreaseSkill(EQEmu::skills::SkillSinging, nullptr, -15);
break;
default:
break;
@@ -991,7 +991,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(SkillChanneling) / 400.0f * 100;
channelchance = 30 + GetSkill(EQEmu::skills::SkillChanneling) / 400.0f * 100;
channelchance -= attacked_count * 2;
channelchance += channelchance * channelbonuses / 100.0f;
}
@@ -1005,7 +1005,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(SkillChanneling) / 400.0f * 100;
channelchance = 30 + GetSkill(EQEmu::skills::SkillChanneling) / 400.0f * 100;
channelchance -= attacked_count * 2;
channelchance += channelchance * channelbonuses / 100.0f;
}
@@ -1037,7 +1037,7 @@ void Mob::CastedSpellFinished(uint16 spell_id, uint32 target_id, uint16 slot,
}
}
Log.Out(Logs::Detail, Logs::Spells, "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));
Log.Out(Logs::Detail, Logs::Spells, "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(EQEmu::skills::SkillChanneling));
if(!spells[spell_id].uninterruptable && zone->random.Real(0, 100) > channelchance) {
Log.Out(Logs::Detail, Logs::Spells, "Casting of %d canceled: interrupted.", spell_id);
@@ -1330,7 +1330,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(SkillChanneling, nullptr, regain_conc ? 5 : 0);
c->CheckIncreaseSkill(EQEmu::skills::SkillChanneling, nullptr, regain_conc ? 5 : 0);
c->CheckSpecializeIncrease(spell_id);
}
zone/tasks.cpp
+1
View File
@@ -29,6 +29,7 @@ Copyright (C) 2001-2008 EQEMu Development Team (http://eqemulator.net)
#include "../common/misc_functions.h"
#include "../common/rulesys.h"
#include "../common/string_util.h"
#include "../common/say_link.h"
#include "client.h"
#include "entity.h"
zone/titles.cpp
+3 -3
View File
@@ -46,7 +46,7 @@ bool TitleManager::LoadTitles()
for (auto row = results.begin(); row != results.end(); ++row) {
TitleEntry Title;
Title.TitleID = atoi(row[0]);
Title.SkillID = (SkillUseTypes) atoi(row[1]);
Title.SkillID = (EQEmu::skills::SkillType) atoi(row[1]);
Title.MinSkillValue = atoi(row[2]);
Title.MaxSkillValue = atoi(row[3]);
Title.MinAAPoints = atoi(row[4]);
@@ -187,10 +187,10 @@ bool TitleManager::IsClientEligibleForTitle(Client *c, std::vector<TitleEntry>::
if(Title->SkillID >= 0)
{
if((Title->MinSkillValue >= 0) && (c->GetRawSkill(static_cast<SkillUseTypes>(Title->SkillID)) < static_cast<uint32>(Title->MinSkillValue)))
if ((Title->MinSkillValue >= 0) && (c->GetRawSkill(static_cast<EQEmu::skills::SkillType>(Title->SkillID)) < static_cast<uint32>(Title->MinSkillValue)))
return false;
if((Title->MaxSkillValue >= 0) && (c->GetRawSkill(static_cast<SkillUseTypes>(Title->SkillID)) > static_cast<uint32>(Title->MaxSkillValue)))
if ((Title->MaxSkillValue >= 0) && (c->GetRawSkill(static_cast<EQEmu::skills::SkillType>(Title->SkillID)) > static_cast<uint32>(Title->MaxSkillValue)))
return false;
}
zone/tradeskills.cpp
+83 -82
View File
@@ -36,7 +36,7 @@
extern QueryServ* QServ;
static const SkillUseTypes TradeskillUnknown = Skill1HBlunt; /* an arbitrary non-tradeskill */
static const EQEmu::skills::SkillType TradeskillUnknown = EQEmu::skills::Skill1HBlunt; /* an arbitrary non-tradeskill */
void Object::HandleAugmentation(Client* user, const AugmentItem_Struct* in_augment, Object *worldo)
{
@@ -363,7 +363,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 == SkillAlchemy) {
if (spec.tradeskill == EQEmu::skills::SkillAlchemy) {
if (user_pp.class_ != SHAMAN) {
user->Message(13, "This tradeskill can only be performed by a shaman.");
return;
@@ -373,13 +373,13 @@ void Object::HandleCombine(Client* user, const NewCombine_Struct* in_combine, Ob
return;
}
}
else if (spec.tradeskill == SkillTinkering) {
else if (spec.tradeskill == EQEmu::skills::SkillTinkering) {
if (user_pp.race != GNOME) {
user->Message(13, "Only gnomes can tinker.");
return;
}
}
else if (spec.tradeskill == SkillMakePoison) {
else if (spec.tradeskill == EQEmu::skills::SkillMakePoison) {
if (user_pp.class_ != ROGUE) {
user->Message(13, "Only rogues can mix poisons.");
return;
@@ -604,17 +604,17 @@ void Object::HandleAutoCombine(Client* user, const RecipeAutoCombine_Struct* rac
parse->EventPlayer(EVENT_COMBINE_FAILURE, user, spec.name.c_str(), spec.recipe_id);
}
SkillUseTypes Object::TypeToSkill(uint32 type)
EQEmu::skills::SkillType Object::TypeToSkill(uint32 type)
{
switch(type) { // grouped and ordered by SkillUseTypes name - new types need to be verified for proper SkillUseTypes and use
/*SkillAlchemy*/
case EQEmu::item::BagTypeMedicineBag:
return SkillAlchemy;
return EQEmu::skills::SkillAlchemy;
/*SkillBaking*/
//case EQEmu::item::BagTypeMixingBowl: // No idea...
case EQEmu::item::BagTypeOven:
return SkillBaking;
return EQEmu::skills::SkillBaking;
/*SkillBlacksmithing*/
case EQEmu::item::BagTypeForge:
@@ -632,25 +632,25 @@ SkillUseTypes Object::TypeToSkill(uint32 type)
case EQEmu::item::BagTypeValeForge:
//case EQEmu::item::BagTypeErudForge:
//case EQEmu::item::BagTypeGuktaForge:
return SkillBlacksmithing;
return EQEmu::skills::SkillBlacksmithing;
/*SkillBrewing*/
//case EQEmu::item::BagTypeIceCreamChurn: // No idea...
case EQEmu::item::BagTypeBrewBarrel:
return SkillBrewing;
return EQEmu::skills::SkillBrewing;
/*SkillFishing*/
case EQEmu::item::BagTypeTackleBox:
return SkillFishing;
return EQEmu::skills::SkillFishing;
/*SkillFletching*/
case EQEmu::item::BagTypeFletchingKit:
//case EQEmu::item::BagTypeFierDalFletchingKit:
return SkillFletching;
return EQEmu::skills::SkillFletching;
/*SkillJewelryMaking*/
case EQEmu::item::BagTypeJewelersKit:
return SkillJewelryMaking;
return EQEmu::skills::SkillJewelryMaking;
/*SkillMakePoison*/
// This is a guess and needs to be verified... (Could be SkillAlchemy)
@@ -661,7 +661,7 @@ SkillUseTypes Object::TypeToSkill(uint32 type)
case EQEmu::item::BagTypePotteryWheel:
case EQEmu::item::BagTypeKiln:
//case EQEmu::item::BagTypeIksarPotteryWheel:
return SkillPottery;
return EQEmu::skills::SkillPottery;
/*SkillResearch*/
//case EQEmu::item::BagTypeLexicon:
@@ -670,18 +670,18 @@ SkillUseTypes Object::TypeToSkill(uint32 type)
case EQEmu::item::BagTypeNecromancersLexicon:
case EQEmu::item::BagTypeEnchantersLexicon:
//case EQEmu::item::BagTypeConcordanceofResearch:
return SkillResearch;
return EQEmu::skills::SkillResearch;
/*SkillTailoring*/
case EQEmu::item::BagTypeSewingKit:
//case EQEmu::item::BagTypeHalflingTailoringKit:
//case EQEmu::item::BagTypeErudTailoringKit:
//case EQEmu::item::BagTypeFierDalTailoringKit:
return SkillTailoring;
return EQEmu::skills::SkillTailoring;
/*SkillTinkering*/
case EQEmu::item::BagTypeToolBox:
return SkillTinkering;
return EQEmu::skills::SkillTinkering;
/*Undefined*/
default:
@@ -718,7 +718,7 @@ void Client::TradeskillSearchResults(const std::string &query, unsigned long obj
// Recipes that have either been made before or were
// explicitly learned are excempt from that limit
if (RuleB(Skills, UseLimitTradeskillSearchSkillDiff)
&& ((int32)trivial - (int32)GetSkill((SkillUseTypes)tradeskill)) > RuleI(Skills, MaxTradeskillSearchSkillDiff)
&& ((int32)trivial - (int32)GetSkill((EQEmu::skills::SkillType)tradeskill)) > RuleI(Skills, MaxTradeskillSearchSkillDiff)
&& row[4] == nullptr)
continue;
@@ -866,49 +866,50 @@ bool Client::TradeskillExecute(DBTradeskillRecipe_Struct *spec) {
// Some tradeskills are more eqal then others. ;-)
// If you want to customize the stage1 success rate do it here.
// Remember: skillup_modifier is (float). Lower is better
switch(spec->tradeskill) {
case SkillFletching:
skillup_modifier = RuleI(Character, TradeskillUpFletching);
break;
case SkillAlchemy:
skillup_modifier = RuleI(Character, TradeskillUpAlchemy);
break;
case SkillJewelryMaking:
skillup_modifier = RuleI(Character, TradeskillUpJewelcrafting);
break;
case SkillPottery:
skillup_modifier = RuleI(Character, TradeskillUpPottery);
break;
case SkillBaking:
skillup_modifier = RuleI(Character, TradeskillUpBaking);
break;
case SkillBrewing:
skillup_modifier = RuleI(Character, TradeskillUpBrewing);
break;
case SkillBlacksmithing:
skillup_modifier = RuleI(Character, TradeskillUpBlacksmithing);
break;
case SkillResearch:
skillup_modifier = RuleI(Character, TradeskillUpResearch);
break;
case SkillMakePoison:
skillup_modifier = RuleI(Character, TradeskillUpMakePoison);
break;
case SkillTinkering:
skillup_modifier = RuleI(Character, TradeskillUpTinkering);
break;
default:
skillup_modifier = 2;
break;
}
switch(spec->tradeskill) {
case EQEmu::skills::SkillFletching:
skillup_modifier = RuleI(Character, TradeskillUpFletching);
break;
case EQEmu::skills::SkillAlchemy:
skillup_modifier = RuleI(Character, TradeskillUpAlchemy);
break;
case EQEmu::skills::SkillJewelryMaking:
skillup_modifier = RuleI(Character, TradeskillUpJewelcrafting);
break;
case EQEmu::skills::SkillPottery:
skillup_modifier = RuleI(Character, TradeskillUpPottery);
break;
case EQEmu::skills::SkillBaking:
skillup_modifier = RuleI(Character, TradeskillUpBaking);
break;
case EQEmu::skills::SkillBrewing:
skillup_modifier = RuleI(Character, TradeskillUpBrewing);
break;
case EQEmu::skills::SkillBlacksmithing:
skillup_modifier = RuleI(Character, TradeskillUpBlacksmithing);
break;
case EQEmu::skills::SkillResearch:
skillup_modifier = RuleI(Character, TradeskillUpResearch);
break;
case EQEmu::skills::SkillMakePoison:
skillup_modifier = RuleI(Character, TradeskillUpMakePoison);
break;
case EQEmu::skills::SkillTinkering:
skillup_modifier = RuleI(Character, TradeskillUpTinkering);
break;
default:
skillup_modifier = 2;
break;
}
// 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 == SkillFletching || spec->tradeskill == SkillMakePoison) {
if (spec->tradeskill == EQEmu::skills::SkillFletching || spec->tradeskill == EQEmu::skills::SkillMakePoison) {
thirdstat = GetDEX();
stat_modifier = 0;
} else if (spec->tradeskill == SkillBlacksmithing) {
}
else if (spec->tradeskill == EQEmu::skills::SkillBlacksmithing) {
thirdstat = GetSTR();
stat_modifier = 0;
}
@@ -1045,7 +1046,7 @@ bool Client::TradeskillExecute(DBTradeskillRecipe_Struct *spec) {
return(false);
}
void Client::CheckIncreaseTradeskill(int16 bonusstat, int16 stat_modifier, float skillup_modifier, uint16 success_modifier, SkillUseTypes tradeskill)
void Client::CheckIncreaseTradeskill(int16 bonusstat, int16 stat_modifier, float skillup_modifier, uint16 success_modifier, EQEmu::skills::SkillType tradeskill)
{
uint16 current_raw_skill = GetRawSkill(tradeskill);
@@ -1290,7 +1291,7 @@ bool ZoneDatabase::GetTradeRecipe(uint32 recipe_id, uint8 c_type, uint32 some_id
return false;//just not found i guess..
auto row = results.begin();
spec->tradeskill = (SkillUseTypes)atoi(row[1]);
spec->tradeskill = (EQEmu::skills::SkillType)atoi(row[1]);
spec->skill_needed = (int16)atoi(row[2]);
spec->trivial = (uint16)atoi(row[3]);
spec->nofail = atoi(row[4]) ? true : false;
@@ -1406,43 +1407,43 @@ void Client::LearnRecipe(uint32 recipeID)
results = database.QueryDatabase(query);
}
bool Client::CanIncreaseTradeskill(SkillUseTypes tradeskill) {
bool Client::CanIncreaseTradeskill(EQEmu::skills::SkillType tradeskill) {
uint32 rawskill = GetRawSkill(tradeskill);
uint16 maxskill = MaxSkill(tradeskill);
if (rawskill >= maxskill) //Max skill sanity check
return false;
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 Baking = (GetRawSkill(EQEmu::skills::SkillBaking) > 200) ? 1 : 0;
uint8 Smithing = (GetRawSkill(EQEmu::skills::SkillBlacksmithing) > 200) ? 1 : 0;
uint8 Brewing = (GetRawSkill(EQEmu::skills::SkillBrewing) > 200) ? 1 : 0;
uint8 Fletching = (GetRawSkill(EQEmu::skills::SkillFletching) > 200) ? 1 : 0;
uint8 Jewelry = (GetRawSkill(EQEmu::skills::SkillJewelryMaking) > 200) ? 1 : 0;
uint8 Pottery = (GetRawSkill(EQEmu::skills::SkillPottery) > 200) ? 1 : 0;
uint8 Tailoring = (GetRawSkill(EQEmu::skills::SkillTailoring) > 200) ? 1 : 0;
uint8 SkillTotal = Baking + Smithing + Brewing + Fletching + Jewelry + Pottery + Tailoring; //Tradeskills above 200
//New Tanaan AA: Each level allows an additional tradeskill above 200 (first one is free)
uint8 aaLevel = spellbonuses.TradeSkillMastery + itembonuses.TradeSkillMastery + aabonuses.TradeSkillMastery;
switch (tradeskill) {
case SkillBaking:
case SkillBlacksmithing:
case SkillBrewing:
case SkillFletching:
case SkillJewelryMaking:
case SkillPottery:
case SkillTailoring:
if (aaLevel == 6)
break; //Maxed AA
if (SkillTotal == 0)
break; //First tradeskill freebie
if ((SkillTotal == (aaLevel + 1)) && (rawskill > 200))
break; //One of the tradeskills already allowed to go over 200
if ((SkillTotal >= (aaLevel + 1)) && (rawskill >= 200))
return false; //One or more tradeskills already at or beyond limit
break;
default:
break; //Other skills unchecked and ability to increase assumed true
case EQEmu::skills::SkillBaking:
case EQEmu::skills::SkillBlacksmithing:
case EQEmu::skills::SkillBrewing:
case EQEmu::skills::SkillFletching:
case EQEmu::skills::SkillJewelryMaking:
case EQEmu::skills::SkillPottery:
case EQEmu::skills::SkillTailoring:
if (aaLevel == 6)
break; //Maxed AA
if (SkillTotal == 0)
break; //First tradeskill freebie
if ((SkillTotal == (aaLevel + 1)) && (rawskill > 200))
break; //One of the tradeskills already allowed to go over 200
if ((SkillTotal >= (aaLevel + 1)) && (rawskill >= 200))
return false; //One or more tradeskills already at or beyond limit
break;
default:
break; //Other skills unchecked and ability to increase assumed true
}
return true;
}
zone/tune.cpp
+37 -37
View File
@@ -255,7 +255,7 @@ int32 Mob::Tune_MeleeMitigation(Mob* GM, Mob *attacker, int32 damage, int32 minh
}
if (RuleB(Combat, UseIntervalAC)) {
float softcap = (GetSkill(SkillDefense) + GetLevel()) *
float softcap = (GetSkill(EQEmu::skills::SkillDefense) + GetLevel()) *
RuleR(Combat, SoftcapFactor) * (1.0 + aa_mit);
float mitigation_rating = 0.0;
float attack_rating = 0.0;
@@ -410,14 +410,14 @@ int32 Mob::Tune_MeleeMitigation(Mob* GM, Mob *attacker, int32 damage, int32 minh
int tmp_armor = armor;
if (GetClass() == WIZARD || GetClass() == MAGICIAN ||
GetClass() == NECROMANCER || GetClass() == ENCHANTER){
mitigation_rating = ((GetSkill(SkillDefense) + itembonuses.HeroicAGI/10) / 4.0) + armor + 1;
mitigation_rating = ((GetSkill(EQEmu::skills::SkillDefense) + itembonuses.HeroicAGI / 10) / 4.0) + armor + 1;
if (Msg >= 2)
GM->Message(0, "# + %.2f #### DEFENDER Armor Bonus [Defense Skill %i Heroic Agi %i]", mitigation_rating - tmp_armor, GetSkill(SkillDefense), itembonuses.HeroicAGI);
GM->Message(0, "# + %.2f #### DEFENDER Armor Bonus [Defense Skill %i Heroic Agi %i]", mitigation_rating - tmp_armor, GetSkill(EQEmu::skills::SkillDefense), itembonuses.HeroicAGI);
}
else{
mitigation_rating = ((GetSkill(SkillDefense) + itembonuses.HeroicAGI/10) / 3.0) + (armor * 1.333333) + 1;
mitigation_rating = ((GetSkill(EQEmu::skills::SkillDefense) + itembonuses.HeroicAGI / 10) / 3.0) + (armor * 1.333333) + 1;
if (Msg >= 2)
GM->Message(0, "# + %.2f #### DEFENDER Armor Bonus [Defense Skill %i Heroic Agi %i]", mitigation_rating - tmp_armor, GetSkill(SkillDefense), itembonuses.HeroicAGI);
GM->Message(0, "# + %.2f #### DEFENDER Armor Bonus [Defense Skill %i Heroic Agi %i]", mitigation_rating - tmp_armor, GetSkill(EQEmu::skills::SkillDefense), itembonuses.HeroicAGI);
}
mitigation_rating *= 0.847;
@@ -443,16 +443,16 @@ int32 Mob::Tune_MeleeMitigation(Mob* GM, Mob *attacker, int32 damage, int32 minh
if (attacker->IsClient()){
if (atk_override)
attack_rating = (atk_override + ((attacker->GetSTR()-66) * 0.9) + (attacker->GetSkill(SkillOffense)*1.345));
attack_rating = (atk_override + ((attacker->GetSTR() - 66) * 0.9) + (attacker->GetSkill(EQEmu::skills::SkillOffense)*1.345));
else
attack_rating = ((attacker->CastToClient()->CalcATK() + add_atk) + ((attacker->GetSTR()-66) * 0.9) + (attacker->GetSkill(SkillOffense)*1.345));
attack_rating = ((attacker->CastToClient()->CalcATK() + add_atk) + ((attacker->GetSTR() - 66) * 0.9) + (attacker->GetSkill(EQEmu::skills::SkillOffense)*1.345));
}
else{
if (atk_override)
attack_rating = (atk_override + (attacker->GetSkill(SkillOffense)*1.345) + ((attacker->GetSTR()-66) * 0.9));
attack_rating = (atk_override + (attacker->GetSkill(EQEmu::skills::SkillOffense)*1.345) + ((attacker->GetSTR() - 66) * 0.9));
else
attack_rating = ((attacker->GetATK() + add_atk) + (attacker->GetSkill(SkillOffense)*1.345) + ((attacker->GetSTR()-66) * 0.9));
attack_rating = ((attacker->GetATK() + add_atk) + (attacker->GetSkill(EQEmu::skills::SkillOffense)*1.345) + ((attacker->GetSTR() - 66) * 0.9));
}
attack_rating = attacker->mod_attack_rating(attack_rating, this);
@@ -468,7 +468,7 @@ int32 Mob::Tune_MeleeMitigation(Mob* GM, Mob *attacker, int32 damage, int32 minh
GM->Message(0, "# %i #### ATTACKER Worn/Equip ATK Bonus", attacker->itembonuses.ATK);
GM->Message(0, "# %i #### ATTACKER Worn/Equip ATK Bonus", attacker->itembonuses.ATK);
GM->Message(0, "# %.2f #### ATTACKER Strength Stat ATK Bonus [Stat Amt: %i]", ((attacker->GetSTR()-66) * 0.9),attacker->GetSTR());
GM->Message(0, "# %.2f #### ATTACKER Offensive Skill ATK Bonus [Stat Amt: %i]", (attacker->GetSkill(SkillOffense)*1.345) ,attacker->GetSkill(SkillOffense));
GM->Message(0, "# %.2f #### ATTACKER Offensive Skill ATK Bonus [Stat Amt: %i]", (attacker->GetSkill(EQEmu::skills::SkillOffense)*1.345), attacker->GetSkill(EQEmu::skills::SkillOffense));
}
else{
@@ -476,7 +476,7 @@ int32 Mob::Tune_MeleeMitigation(Mob* GM, Mob *attacker, int32 damage, int32 minh
GM->Message(0, "# %i #### ATTACKER SE_ATK(2) spell Bonus", attacker->spellbonuses.ATK);
GM->Message(0, "# %i #### ATTACKER NPC ATK Stat", attacker->CastToNPC()->ATK);
GM->Message(0, "# %.2f #### ATTACKER Strength Stat ATK Bonus [Stat Amt: %i]", ((attacker->GetSTR()-66) * 0.9),attacker->GetSTR());
GM->Message(0, "# %.2f #### ATTACKER Offensive Skill ATK Bonus [Stat Amt: %i]", (attacker->GetSkill(SkillOffense)*1.345) ,attacker->GetSkill(SkillOffense));
GM->Message(0, "# %.2f #### ATTACKER Offensive Skill ATK Bonus [Stat Amt: %i]", (attacker->GetSkill(EQEmu::skills::SkillOffense)*1.345), attacker->GetSkill(EQEmu::skills::SkillOffense));
}
}
@@ -596,7 +596,7 @@ int32 Client::GetMeleeDamage(Mob* other, bool GetMinDamage)
}
}
SkillUseTypes skillinuse;
EQEmu::skills::SkillType skillinuse;
AttackAnimation(skillinuse, Hand, weapon);
int damage = 0;
@@ -621,7 +621,7 @@ int32 Client::GetMeleeDamage(Mob* other, bool GetMinDamage)
max_hit = (RuleI(Combat, HitCapPre20));
CheckIncreaseSkill(skillinuse, other, -15);
CheckIncreaseSkill(SkillOffense, other, -15);
CheckIncreaseSkill(EQEmu::skills::SkillOffense, other, -15);
#ifndef EQEMU_NO_WEAPON_DAMAGE_BONUS
@@ -658,7 +658,7 @@ void Mob::Tune_FindAccuaryByHitChance(Mob* defender, Mob *attacker, float hit_ch
float tmp_hit_chance = 0.0f;
bool end = false;
SkillUseTypes skillinuse = SkillHandtoHand;
EQEmu::skills::SkillType skillinuse = EQEmu::skills::SkillHandtoHand;
if (attacker->IsClient())
{//Will check first equiped weapon for skill. Ie. remove wepaons to assess bow.
ItemInst* weapon;
@@ -738,7 +738,7 @@ void Mob::Tune_FindAvoidanceByHitChance(Mob* defender, Mob *attacker, float hit_
float tmp_hit_chance = 0.0f;
bool end = false;
SkillUseTypes skillinuse = SkillHandtoHand;
EQEmu::skills::SkillType skillinuse = EQEmu::skills::SkillHandtoHand;
if (attacker->IsClient())
{//Will check first equiped weapon for skill. Ie. remove wepaons to assess bow.
ItemInst* weapon;
@@ -809,7 +809,7 @@ void Mob::Tune_FindAvoidanceByHitChance(Mob* defender, Mob *attacker, float hit_
}
float Mob::Tune_CheckHitChance(Mob* defender, Mob* attacker, SkillUseTypes skillinuse, int Hand, int16 chance_mod, int Msg,int acc_override, int avoid_override, int add_acc, int add_avoid)
float Mob::Tune_CheckHitChance(Mob* defender, Mob* attacker, EQEmu::skills::SkillType skillinuse, int Hand, int16 chance_mod, int Msg, int acc_override, int avoid_override, int add_acc, int add_avoid)
{
float chancetohit = RuleR(Combat, BaseHitChance);
@@ -897,9 +897,9 @@ float Mob::Tune_CheckHitChance(Mob* defender, Mob* attacker, SkillUseTypes skill
if(defender->IsClient())
{
chancetohit += (RuleR(Combat,WeaponSkillFalloff) * (defender->CastToClient()->MaxSkill(SkillDefense) - defender->GetSkill(SkillDefense)));
chancetohit += (RuleR(Combat, WeaponSkillFalloff) * (defender->CastToClient()->MaxSkill(EQEmu::skills::SkillDefense) - defender->GetSkill(EQEmu::skills::SkillDefense)));
if (Msg >= 2)
Message(0, "# + %.2f Total: %.2f #### DEFENDER Defense Skill Mod", (RuleR(Combat,WeaponSkillFalloff) * (defender->CastToClient()->MaxSkill(SkillDefense) - defender->GetSkill(SkillDefense))), chancetohit);
Message(0, "# + %.2f Total: %.2f #### DEFENDER Defense Skill Mod", (RuleR(Combat, WeaponSkillFalloff) * (defender->CastToClient()->MaxSkill(EQEmu::skills::SkillDefense) - defender->GetSkill(EQEmu::skills::SkillDefense))), chancetohit);
}
@@ -988,17 +988,17 @@ float Mob::Tune_CheckHitChance(Mob* defender, Mob* attacker, SkillUseTypes skill
hitBonus += attacker->itembonuses.HitChanceEffect[skillinuse] +
attacker->spellbonuses.HitChanceEffect[skillinuse]+
attacker->aabonuses.HitChanceEffect[skillinuse]+
attacker->itembonuses.HitChanceEffect[HIGHEST_SKILL+1] +
attacker->spellbonuses.HitChanceEffect[HIGHEST_SKILL+1] +
attacker->aabonuses.HitChanceEffect[HIGHEST_SKILL+1];
attacker->itembonuses.HitChanceEffect[EQEmu::skills::HIGHEST_SKILL + 1] +
attacker->spellbonuses.HitChanceEffect[EQEmu::skills::HIGHEST_SKILL + 1] +
attacker->aabonuses.HitChanceEffect[EQEmu::skills::HIGHEST_SKILL + 1];
if (Msg >= 2){
if (attacker->aabonuses.HitChanceEffect[HIGHEST_SKILL+1])
Message(0, "# %i #### ATTACKER SE_HitChance(184) AA Bonus [All Skills]", attacker->aabonuses.HitChanceEffect[HIGHEST_SKILL+1]);
if (attacker->spellbonuses.HitChanceEffect[HIGHEST_SKILL+1])
Message(0, "# %i #### ATTACKER SE_HitChance(184) Spell Bonus [All Skills]", attacker->spellbonuses.HitChanceEffect[HIGHEST_SKILL+1]);
if (attacker->itembonuses.HitChanceEffect[HIGHEST_SKILL+1])
Message(0, "# %i #### ATTACKER SE_HitChance(184) Worn Bonus [All Skills]", attacker->itembonuses.HitChanceEffect[HIGHEST_SKILL+1]);
if (attacker->aabonuses.HitChanceEffect[EQEmu::skills::HIGHEST_SKILL + 1])
Message(0, "# %i #### ATTACKER SE_HitChance(184) AA Bonus [All Skills]", attacker->aabonuses.HitChanceEffect[EQEmu::skills::HIGHEST_SKILL + 1]);
if (attacker->spellbonuses.HitChanceEffect[EQEmu::skills::HIGHEST_SKILL + 1])
Message(0, "# %i #### ATTACKER SE_HitChance(184) Spell Bonus [All Skills]", attacker->spellbonuses.HitChanceEffect[EQEmu::skills::HIGHEST_SKILL + 1]);
if (attacker->itembonuses.HitChanceEffect[EQEmu::skills::HIGHEST_SKILL + 1])
Message(0, "# %i #### ATTACKER SE_HitChance(184) Worn Bonus [All Skills]", attacker->itembonuses.HitChanceEffect[EQEmu::skills::HIGHEST_SKILL + 1]);
if (attacker->itembonuses.HitChanceEffect[skillinuse])
Message(0, "# %i #### ATTACKER SE_HitChance(184) AA Bonus [Skill]", attacker->aabonuses.HitChanceEffect[skillinuse]);
if (attacker->spellbonuses.HitChanceEffect[skillinuse])
@@ -1009,19 +1009,19 @@ float Mob::Tune_CheckHitChance(Mob* defender, Mob* attacker, SkillUseTypes skill
//Accuracy = Spell Effect , HitChance = 'Accuracy' from Item Effect
//Only AA derived accuracy can be skill limited. ie (Precision of the Pathfinder, Dead Aim)
hitBonus += (attacker->itembonuses.Accuracy[HIGHEST_SKILL+1] +
attacker->spellbonuses.Accuracy[HIGHEST_SKILL+1] +
attacker->aabonuses.Accuracy[HIGHEST_SKILL+1] +
hitBonus += (attacker->itembonuses.Accuracy[EQEmu::skills::HIGHEST_SKILL + 1] +
attacker->spellbonuses.Accuracy[EQEmu::skills::HIGHEST_SKILL + 1] +
attacker->aabonuses.Accuracy[EQEmu::skills::HIGHEST_SKILL + 1] +
attacker->aabonuses.Accuracy[skillinuse] +
attacker->itembonuses.HitChance) / 15.0f; //Item Mod 'Accuracy'
if (Msg >= 2) {
if (attacker->aabonuses.Accuracy[HIGHEST_SKILL+1])
Message(0, "# %.2f #### ATTACKER SE_Accuracy(216) AA Bonus [All Skills] [Stat Amt: %i]", static_cast<float>(attacker->aabonuses.Accuracy[HIGHEST_SKILL+1])/15.0f,attacker->aabonuses.Accuracy[HIGHEST_SKILL+1]);
if (attacker->spellbonuses.Accuracy[HIGHEST_SKILL+1])
Message(0, "# %.2f #### ATTACKER SE_Accuracy(216) Spell Bonus [All Skills] [Stat Amt: %i]", static_cast<float>(attacker->spellbonuses.Accuracy[HIGHEST_SKILL+1])/15.0f,attacker->spellbonuses.Accuracy[HIGHEST_SKILL+1]);
if (attacker->itembonuses.Accuracy[HIGHEST_SKILL+1])
Message(0, "# %.2f #### ATTACKER SE_Accuracy(216) Worn Bonus [All Skills] [Stat Amt: %i]", static_cast<float>(attacker->itembonuses.Accuracy[HIGHEST_SKILL+1])/15.0f,attacker->itembonuses.Accuracy[HIGHEST_SKILL+1]);
if (attacker->aabonuses.Accuracy[EQEmu::skills::HIGHEST_SKILL + 1])
Message(0, "# %.2f #### ATTACKER SE_Accuracy(216) AA Bonus [All Skills] [Stat Amt: %i]", static_cast<float>(attacker->aabonuses.Accuracy[EQEmu::skills::HIGHEST_SKILL + 1]) / 15.0f, attacker->aabonuses.Accuracy[EQEmu::skills::HIGHEST_SKILL + 1]);
if (attacker->spellbonuses.Accuracy[EQEmu::skills::HIGHEST_SKILL + 1])
Message(0, "# %.2f #### ATTACKER SE_Accuracy(216) Spell Bonus [All Skills] [Stat Amt: %i]", static_cast<float>(attacker->spellbonuses.Accuracy[EQEmu::skills::HIGHEST_SKILL + 1]) / 15.0f, attacker->spellbonuses.Accuracy[EQEmu::skills::HIGHEST_SKILL + 1]);
if (attacker->itembonuses.Accuracy[EQEmu::skills::HIGHEST_SKILL + 1])
Message(0, "# %.2f #### ATTACKER SE_Accuracy(216) Worn Bonus [All Skills] [Stat Amt: %i]", static_cast<float>(attacker->itembonuses.Accuracy[EQEmu::skills::HIGHEST_SKILL + 1]) / 15.0f, attacker->itembonuses.Accuracy[EQEmu::skills::HIGHEST_SKILL + 1]);
if (attacker->aabonuses.Accuracy[skillinuse])
Message(0, "# %.2f #### ATTACKER SE_Accuracy(216) AA Bonus [Skill] [Stat Amt: %i]", static_cast<float>(attacker->aabonuses.Accuracy[skillinuse])/15.0f,attacker->aabonuses.Accuracy[skillinuse]);
if (attacker->itembonuses.HitChance)
@@ -1053,7 +1053,7 @@ float Mob::Tune_CheckHitChance(Mob* defender, Mob* attacker, SkillUseTypes skill
hitBonus += (add_acc / 15.0f); //Modifier from database
}
if(skillinuse == SkillArchery){
if (skillinuse == EQEmu::skills::SkillArchery){
hitBonus -= hitBonus*RuleR(Combat, ArcheryHitPenalty);
if (Msg >= 2)
Message(0, "# %.2f pct #### RuleR(Combat, ArcheryHitPenalty) ", RuleR(Combat, ArcheryHitPenalty));
zone/zonedb.h
+1 -1
View File
@@ -92,7 +92,7 @@ struct DBnpcspellseffects_Struct {
};
struct DBTradeskillRecipe_Struct {
SkillUseTypes tradeskill;
EQEmu::skills::SkillType tradeskill;
int16 skill_needed;
uint16 trivial;
bool nofail;