pa/eqemu-server
2
0
Fork 0
mirror of https://github.com/EQEmu/Server.git synced 2026-05-16 22:58:34 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

Rename namespace EQEmu to namespace EQ (so we don't have two similar but different namespaces anymore)

Browse Source
This commit is contained in:
KimLS
2020-05-17 18:36:06 -07:00
parent 06104b624a
commit 2fbd5aaccc
198 changed files with 6111 additions and 6111 deletions
Download Patch File Download Diff File Expand all files Collapse all files
zone/aa.cpp
+6 -6
View File
@@ -441,12 +441,12 @@ void Mob::WakeTheDead(uint16 spell_id, Mob *target, uint32 duration)
//gear stuff, need to make sure there's
//no situation where this stuff can be duped
for (int x = EQEmu::invslot::EQUIPMENT_BEGIN; x <= EQEmu::invslot::EQUIPMENT_END; x++)
for (int x = EQ::invslot::EQUIPMENT_BEGIN; x <= EQ::invslot::EQUIPMENT_END; x++)
{
uint32 sitem = 0;
sitem = CorpseToUse->GetWornItem(x);
if(sitem){
const EQEmu::ItemData * itm = database.GetItem(sitem);
const EQ::ItemData * itm = database.GetItem(sitem);
npca->AddLootDrop(itm, &npca->itemlist, 1, 1, 255, true, true);
}
}
@@ -494,7 +494,7 @@ void Client::ResetAA() {
database.DeleteCharacterLeadershipAAs(CharacterID());
// undefined for these clients
if (ClientVersionBit() & EQEmu::versions::maskTitaniumAndEarlier)
if (ClientVersionBit() & EQ::versions::maskTitaniumAndEarlier)
Kick("AA Reset on client that doesn't support it");
}
@@ -1245,12 +1245,12 @@ void Client::ActivateAlternateAdvancementAbility(int rank_id, int target_id) {
// Bards can cast instant cast AAs while they are casting another song
if(spells[rank->spell].cast_time == 0 && GetClass() == BARD && IsBardSong(casting_spell_id)) {
if(!SpellFinished(rank->spell, entity_list.GetMob(target_id), EQEmu::spells::CastingSlot::AltAbility, spells[rank->spell].mana, -1, spells[rank->spell].ResistDiff, false)) {
if(!SpellFinished(rank->spell, entity_list.GetMob(target_id), EQ::spells::CastingSlot::AltAbility, spells[rank->spell].mana, -1, spells[rank->spell].ResistDiff, false)) {
return;
}
ExpendAlternateAdvancementCharge(ability->id);
} else {
if(!CastSpell(rank->spell, target_id, EQEmu::spells::CastingSlot::AltAbility, -1, -1, 0, -1, rank->spell_type + pTimerAAStart, cooldown, nullptr, rank->id)) {
if(!CastSpell(rank->spell, target_id, EQ::spells::CastingSlot::AltAbility, -1, -1, 0, -1, rank->spell_type + pTimerAAStart, cooldown, nullptr, rank->id)) {
return;
}
}
@@ -1479,7 +1479,7 @@ bool Mob::CanUseAlternateAdvancementRank(AA::Rank *rank) {
//the one titanium hack i will allow
//just to make sure we dont crash the client with newer aas
//we'll exclude any expendable ones
if(IsClient() && CastToClient()->ClientVersionBit() & EQEmu::versions::maskTitaniumAndEarlier) {
if(IsClient() && CastToClient()->ClientVersionBit() & EQ::versions::maskTitaniumAndEarlier) {
if(ability->charges > 0) {
return false;
}
zone/attack.cpp
+226 -226
View File
File diff suppressed because it is too large Load Diff
zone/beacon.cpp
+1 -1
View File
@@ -56,7 +56,7 @@ Beacon::Beacon(Mob *at_mob, int lifetime)
:Mob
(
nullptr, nullptr, 0, 0, 0, INVISIBLE_MAN, 0, BT_NoTarget, 0, 0, 0, 0, 0, at_mob->GetPosition(), 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, EQEmu::TintProfile(), 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, false
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, EQ::TintProfile(), 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, false
),
remove_timer(lifetime),
spell_timer(0)
zone/beacon.h
+3 -3
View File
@@ -34,9 +34,9 @@ public:
~Beacon();
//abstract virtual function implementations requird by base abstract class
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, eSpecialAttacks special = eSpecialAttacks::None) { return; }
virtual bool Attack(Mob* other, int Hand = EQEmu::invslot::slotPrimary, bool FromRiposte = false, bool IsStrikethrough = false, bool IsFromSpell = false,
virtual bool Death(Mob* killerMob, int32 damage, uint16 spell_id, EQ::skills::SkillType attack_skill) { return true; }
virtual void Damage(Mob* from, int32 damage, uint16 spell_id, EQ::skills::SkillType attack_skill, bool avoidable = true, int8 buffslot = -1, bool iBuffTic = false, eSpecialAttacks special = eSpecialAttacks::None) { return; }
virtual bool Attack(Mob* other, int Hand = EQ::invslot::slotPrimary, bool FromRiposte = false, bool IsStrikethrough = false, bool IsFromSpell = false,
ExtraAttackOptions *opts = nullptr) { return false; }
virtual bool HasRaid() { return false; }
virtual bool HasGroup() { return false; }
zone/bonuses.cpp
+140 -140
View File
@@ -157,36 +157,36 @@ void Client::CalcItemBonuses(StatBonuses* newbon) {
unsigned int i;
// Update: MainAmmo should only calc skill mods (TODO: Check for other cases)
for (i = EQEmu::invslot::BONUS_BEGIN; i <= EQEmu::invslot::BONUS_SKILL_END; i++) {
const EQEmu::ItemInstance* inst = m_inv[i];
for (i = EQ::invslot::BONUS_BEGIN; i <= EQ::invslot::BONUS_SKILL_END; i++) {
const EQ::ItemInstance* inst = m_inv[i];
if(inst == 0)
continue;
AddItemBonuses(inst, newbon, false, false, 0, (i == EQEmu::invslot::slotAmmo));
AddItemBonuses(inst, newbon, false, false, 0, (i == EQ::invslot::slotAmmo));
//These are given special flags due to how often they are checked for various spell effects.
const EQEmu::ItemData *item = inst->GetItem();
if (i == EQEmu::invslot::slotSecondary && (item && item->ItemType == EQEmu::item::ItemTypeShield))
const EQ::ItemData *item = inst->GetItem();
if (i == EQ::invslot::slotSecondary && (item && item->ItemType == EQ::item::ItemTypeShield))
SetShieldEquiped(true);
else if (i == EQEmu::invslot::slotPrimary && (item && item->ItemType == EQEmu::item::ItemType2HBlunt)) {
else if (i == EQ::invslot::slotPrimary && (item && item->ItemType == EQ::item::ItemType2HBlunt)) {
SetTwoHandBluntEquiped(true);
SetTwoHanderEquipped(true);
}
else if (i == EQEmu::invslot::slotPrimary && (item && (item->ItemType == EQEmu::item::ItemType2HSlash || item->ItemType == EQEmu::item::ItemType2HPiercing)))
else if (i == EQ::invslot::slotPrimary && (item && (item->ItemType == EQ::item::ItemType2HSlash || item->ItemType == EQ::item::ItemType2HPiercing)))
SetTwoHanderEquipped(true);
}
//tribute items
for (i = EQEmu::invslot::TRIBUTE_BEGIN; i <= EQEmu::invslot::TRIBUTE_END; i++) {
const EQEmu::ItemInstance* inst = m_inv[i];
for (i = EQ::invslot::TRIBUTE_BEGIN; i <= EQ::invslot::TRIBUTE_END; i++) {
const EQ::ItemInstance* inst = m_inv[i];
if(inst == 0)
continue;
AddItemBonuses(inst, newbon, false, true);
}
//Optional ability to have worn effects calculate as an addititive bonus instead of highest value
if (RuleI(Spells, AdditiveBonusWornType) && RuleI(Spells, AdditiveBonusWornType) != EQEmu::item::ItemEffectWorn){
for (i = EQEmu::invslot::BONUS_BEGIN; i <= EQEmu::invslot::BONUS_STAT_END; i++) {
const EQEmu::ItemInstance* inst = m_inv[i];
if (RuleI(Spells, AdditiveBonusWornType) && RuleI(Spells, AdditiveBonusWornType) != EQ::item::ItemEffectWorn){
for (i = EQ::invslot::BONUS_BEGIN; i <= EQ::invslot::BONUS_STAT_END; i++) {
const EQ::ItemInstance* inst = m_inv[i];
if(inst == 0)
continue;
AdditiveWornBonuses(inst, newbon);
@@ -212,7 +212,7 @@ void Client::ProcessItemCaps()
itembonuses.ATK = std::min(itembonuses.ATK, CalcItemATKCap());
}
void Client::AddItemBonuses(const EQEmu::ItemInstance *inst, StatBonuses *newbon, bool isAug, bool isTribute, int rec_override, bool ammo_slot_item)
void Client::AddItemBonuses(const EQ::ItemInstance *inst, StatBonuses *newbon, bool isAug, bool isTribute, int rec_override, bool ammo_slot_item)
{
if (!inst || !inst->IsClassCommon()) {
return;
@@ -222,10 +222,10 @@ void Client::AddItemBonuses(const EQEmu::ItemInstance *inst, StatBonuses *newbon
return;
}
const EQEmu::ItemData *item = inst->GetItem();
const EQ::ItemData *item = inst->GetItem();
if (!isTribute && !inst->IsEquipable(GetBaseRace(), GetClass())) {
if (item->ItemType != EQEmu::item::ItemTypeFood && item->ItemType != EQEmu::item::ItemTypeDrink)
if (item->ItemType != EQ::item::ItemTypeFood && item->ItemType != EQ::item::ItemTypeDrink)
return;
}
@@ -434,11 +434,11 @@ void Client::AddItemBonuses(const EQEmu::ItemInstance *inst, StatBonuses *newbon
else
newbon->DSMitigation += item->DSMitigation;
}
if (item->Worn.Effect > 0 && item->Worn.Type == EQEmu::item::ItemEffectWorn) { // latent effects
if (item->Worn.Effect > 0 && item->Worn.Type == EQ::item::ItemEffectWorn) { // latent effects
ApplySpellsBonuses(item->Worn.Effect, item->Worn.Level, newbon, 0, item->Worn.Type);
}
if (item->Focus.Effect > 0 && (item->Focus.Type == EQEmu::item::ItemEffectFocus)) { // focus effects
if (item->Focus.Effect > 0 && (item->Focus.Type == EQ::item::ItemEffectFocus)) { // focus effects
ApplySpellsBonuses(item->Focus.Effect, item->Focus.Level, newbon, 0);
}
@@ -511,7 +511,7 @@ void Client::AddItemBonuses(const EQEmu::ItemInstance *inst, StatBonuses *newbon
}
}
if (item->ExtraDmgSkill != 0 && item->ExtraDmgSkill <= EQEmu::skills::HIGHEST_SKILL) {
if (item->ExtraDmgSkill != 0 && item->ExtraDmgSkill <= EQ::skills::HIGHEST_SKILL) {
if ((newbon->SkillDamageAmount[item->ExtraDmgSkill] + item->ExtraDmgAmt) >
RuleI(Character, ItemExtraDmgCap))
newbon->SkillDamageAmount[item->ExtraDmgSkill] = RuleI(Character, ItemExtraDmgCap);
@@ -521,7 +521,7 @@ void Client::AddItemBonuses(const EQEmu::ItemInstance *inst, StatBonuses *newbon
}
// Process when ammo_slot_item = true or false
if (item->SkillModValue != 0 && item->SkillModType <= EQEmu::skills::HIGHEST_SKILL) {
if (item->SkillModValue != 0 && item->SkillModType <= EQ::skills::HIGHEST_SKILL) {
if ((item->SkillModValue > 0 && newbon->skillmod[item->SkillModType] < item->SkillModValue) ||
(item->SkillModValue < 0 && newbon->skillmod[item->SkillModType] > item->SkillModValue)) {
@@ -531,12 +531,12 @@ void Client::AddItemBonuses(const EQEmu::ItemInstance *inst, StatBonuses *newbon
}
if (!isAug) {
for (int i = EQEmu::invaug::SOCKET_BEGIN; i <= EQEmu::invaug::SOCKET_END; i++)
for (int i = EQ::invaug::SOCKET_BEGIN; i <= EQ::invaug::SOCKET_END; i++)
AddItemBonuses(inst->GetAugment(i), newbon, true, false, rec_level, ammo_slot_item);
}
}
void Client::AdditiveWornBonuses(const EQEmu::ItemInstance *inst, StatBonuses* newbon, bool isAug) {
void Client::AdditiveWornBonuses(const EQ::ItemInstance *inst, StatBonuses* newbon, bool isAug) {
/*
Powerful Non-live like option allows developers to add worn effects on items that
@@ -554,7 +554,7 @@ void Client::AdditiveWornBonuses(const EQEmu::ItemInstance *inst, StatBonuses* n
if(inst->GetAugmentType()==0 && isAug == true)
return;
const EQEmu::ItemData *item = inst->GetItem();
const EQ::ItemData *item = inst->GetItem();
if(!inst->IsEquipable(GetBaseRace(),GetClass()))
return;
@@ -569,7 +569,7 @@ void Client::AdditiveWornBonuses(const EQEmu::ItemInstance *inst, StatBonuses* n
if (!isAug)
{
int i;
for (i = EQEmu::invaug::SOCKET_BEGIN; i <= EQEmu::invaug::SOCKET_END; i++) {
for (i = EQ::invaug::SOCKET_BEGIN; i <= EQ::invaug::SOCKET_END; i++) {
AdditiveWornBonuses(inst->GetAugment(i),newbon,true);
}
}
@@ -580,32 +580,32 @@ void Client::CalcEdibleBonuses(StatBonuses* newbon) {
bool food = false;
bool drink = false;
for (i = EQEmu::invslot::GENERAL_BEGIN; i <= EQEmu::invslot::GENERAL_END; i++)
for (i = EQ::invslot::GENERAL_BEGIN; i <= EQ::invslot::GENERAL_END; i++)
{
if (food && drink)
break;
const EQEmu::ItemInstance* inst = GetInv().GetItem(i);
const EQ::ItemInstance* inst = GetInv().GetItem(i);
if (inst && inst->GetItem() && inst->IsClassCommon()) {
const EQEmu::ItemData *item = inst->GetItem();
if (!food && item->ItemType == EQEmu::item::ItemTypeFood)
const EQ::ItemData *item = inst->GetItem();
if (!food && item->ItemType == EQ::item::ItemTypeFood)
food = true;
else if (!drink && item->ItemType == EQEmu::item::ItemTypeDrink)
else if (!drink && item->ItemType == EQ::item::ItemTypeDrink)
drink = true;
else
continue;
AddItemBonuses(inst, newbon);
}
}
for (i = EQEmu::invbag::GENERAL_BAGS_BEGIN; i <= EQEmu::invbag::GENERAL_BAGS_END; i++)
for (i = EQ::invbag::GENERAL_BAGS_BEGIN; i <= EQ::invbag::GENERAL_BAGS_END; i++)
{
if (food && drink)
break;
const EQEmu::ItemInstance* inst = GetInv().GetItem(i);
const EQ::ItemInstance* inst = GetInv().GetItem(i);
if (inst && inst->GetItem() && inst->IsClassCommon()) {
const EQEmu::ItemData *item = inst->GetItem();
if (!food && item->ItemType == EQEmu::item::ItemTypeFood)
const EQ::ItemData *item = inst->GetItem();
if (!food && item->ItemType == EQ::item::ItemTypeFood)
food = true;
else if (!drink && item->ItemType == EQEmu::item::ItemTypeDrink)
else if (!drink && item->ItemType == EQ::item::ItemTypeDrink)
drink = true;
else
continue;
@@ -680,10 +680,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 > EQEmu::skills::HIGHEST_SKILL)
if (base2 > EQ::skills::HIGHEST_SKILL)
break;
if ((base2 == ALL_SKILLS) && (newbon->Accuracy[EQEmu::skills::HIGHEST_SKILL + 1] < base1))
newbon->Accuracy[EQEmu::skills::HIGHEST_SKILL + 1] = base1;
if ((base2 == ALL_SKILLS) && (newbon->Accuracy[EQ::skills::HIGHEST_SKILL + 1] < base1))
newbon->Accuracy[EQ::skills::HIGHEST_SKILL + 1] = base1;
else if (newbon->Accuracy[base2] < base1)
newbon->Accuracy[base2] += base1;
break;
@@ -919,19 +919,19 @@ void Mob::ApplyAABonuses(const AA::Rank &rank, StatBonuses *newbon)
break;
case SE_AddSingingMod:
switch (base2) {
case EQEmu::item::ItemTypeWindInstrument:
case EQ::item::ItemTypeWindInstrument:
newbon->windMod += base1;
break;
case EQEmu::item::ItemTypeStringedInstrument:
case EQ::item::ItemTypeStringedInstrument:
newbon->stringedMod += base1;
break;
case EQEmu::item::ItemTypeBrassInstrument:
case EQ::item::ItemTypeBrassInstrument:
newbon->brassMod += base1;
break;
case EQEmu::item::ItemTypePercussionInstrument:
case EQ::item::ItemTypePercussionInstrument:
newbon->percussionMod += base1;
break;
case EQEmu::item::ItemTypeSinging:
case EQ::item::ItemTypeSinging:
newbon->singingMod += base1;
break;
}
@@ -1028,10 +1028,10 @@ void Mob::ApplyAABonuses(const AA::Rank &rank, StatBonuses *newbon)
case SE_HitChance: {
// Bad data or unsupported new skill
if (base2 > EQEmu::skills::HIGHEST_SKILL)
if (base2 > EQ::skills::HIGHEST_SKILL)
break;
if (base2 == ALL_SKILLS)
newbon->HitChanceEffect[EQEmu::skills::HIGHEST_SKILL + 1] += base1;
newbon->HitChanceEffect[EQ::skills::HIGHEST_SKILL + 1] += base1;
else
newbon->HitChanceEffect[base2] += base1;
}
@@ -1082,21 +1082,21 @@ void Mob::ApplyAABonuses(const AA::Rank &rank, StatBonuses *newbon)
case SE_CriticalHitChance: {
// Bad data or unsupported new skill
if (base2 > EQEmu::skills::HIGHEST_SKILL)
if (base2 > EQ::skills::HIGHEST_SKILL)
break;
if (base2 == ALL_SKILLS)
newbon->CriticalHitChance[EQEmu::skills::HIGHEST_SKILL + 1] += base1;
newbon->CriticalHitChance[EQ::skills::HIGHEST_SKILL + 1] += base1;
else
newbon->CriticalHitChance[base2] += base1;
} break;
case SE_CriticalDamageMob: {
// Bad data or unsupported new skill
if (base2 > EQEmu::skills::HIGHEST_SKILL)
if (base2 > EQ::skills::HIGHEST_SKILL)
break;
// base1 = effect value, base2 = skill restrictions(-1 for all)
if (base2 == ALL_SKILLS)
newbon->CritDmgMod[EQEmu::skills::HIGHEST_SKILL + 1] += base1;
newbon->CritDmgMod[EQ::skills::HIGHEST_SKILL + 1] += base1;
else
newbon->CritDmgMod[base2] += base1;
break;
@@ -1122,10 +1122,10 @@ void Mob::ApplyAABonuses(const AA::Rank &rank, StatBonuses *newbon)
case SE_SkillDamageAmount: {
// Bad data or unsupported new skill
if (base2 > EQEmu::skills::HIGHEST_SKILL)
if (base2 > EQ::skills::HIGHEST_SKILL)
break;
if (base2 == ALL_SKILLS)
newbon->SkillDamageAmount[EQEmu::skills::HIGHEST_SKILL + 1] += base1;
newbon->SkillDamageAmount[EQ::skills::HIGHEST_SKILL + 1] += base1;
else
newbon->SkillDamageAmount[base2] += base1;
break;
@@ -1141,10 +1141,10 @@ void Mob::ApplyAABonuses(const AA::Rank &rank, StatBonuses *newbon)
case SE_DamageModifier: {
// Bad data or unsupported new skill
if (base2 > EQEmu::skills::HIGHEST_SKILL)
if (base2 > EQ::skills::HIGHEST_SKILL)
break;
if (base2 == ALL_SKILLS)
newbon->DamageModifier[EQEmu::skills::HIGHEST_SKILL + 1] += base1;
newbon->DamageModifier[EQ::skills::HIGHEST_SKILL + 1] += base1;
else
newbon->DamageModifier[base2] += base1;
break;
@@ -1152,10 +1152,10 @@ void Mob::ApplyAABonuses(const AA::Rank &rank, StatBonuses *newbon)
case SE_DamageModifier2: {
// Bad data or unsupported new skill
if (base2 > EQEmu::skills::HIGHEST_SKILL)
if (base2 > EQ::skills::HIGHEST_SKILL)
break;
if (base2 == ALL_SKILLS)
newbon->DamageModifier2[EQEmu::skills::HIGHEST_SKILL + 1] += base1;
newbon->DamageModifier2[EQ::skills::HIGHEST_SKILL + 1] += base1;
else
newbon->DamageModifier2[base2] += base1;
break;
@@ -1191,7 +1191,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 > EQEmu::skills::HIGHEST_SKILL)
if (base2 > EQ::skills::HIGHEST_SKILL)
break;
if (newbon->RaiseSkillCap[base2] < base1)
@@ -1370,9 +1370,9 @@ void Mob::ApplyAABonuses(const AA::Rank &rank, StatBonuses *newbon)
case SE_LimitToSkill: {
// Bad data or unsupported new skill
if (base2 > EQEmu::skills::HIGHEST_SKILL)
if (base2 > EQ::skills::HIGHEST_SKILL)
break;
if (base1 <= EQEmu::skills::HIGHEST_SKILL)
if (base1 <= EQ::skills::HIGHEST_SKILL)
newbon->LimitToSkill[base1] = true;
break;
}
@@ -1436,7 +1436,7 @@ void Mob::ApplyAABonuses(const AA::Rank &rank, StatBonuses *newbon)
case SE_ReduceTradeskillFail:{
if (base2 > EQEmu::skills::HIGHEST_SKILL)
if (base2 > EQ::skills::HIGHEST_SKILL)
break;
newbon->ReduceTradeskillFail[base2] += base1;
@@ -1482,8 +1482,8 @@ void Mob::ApplyAABonuses(const AA::Rank &rank, StatBonuses *newbon)
// I'd rather not do this here, but whatever, probably fine
if (IsClient()) {
auto client = CastToClient();
if (client->GetRawSkill(EQEmu::skills::SkillType::SkillForage) == 0)
client->SetSkill(EQEmu::skills::SkillType::SkillForage, 1);
if (client->GetRawSkill(EQ::skills::SkillType::SkillForage) == 0)
client->SetSkill(EQ::skills::SkillType::SkillForage, 1);
}
break;
@@ -1983,26 +1983,26 @@ void Mob::ApplySpellsBonuses(uint16 spell_id, uint8 casterlevel, StatBonuses *ne
case SE_CriticalHitChance:
{
// Bad data or unsupported new skill
if (base2 > EQEmu::skills::HIGHEST_SKILL)
if (base2 > EQ::skills::HIGHEST_SKILL)
break;
if (AdditiveWornBonus) {
if(base2 == ALL_SKILLS)
new_bonus->CriticalHitChance[EQEmu::skills::HIGHEST_SKILL + 1] += effect_value;
new_bonus->CriticalHitChance[EQ::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[EQEmu::skills::HIGHEST_SKILL + 1] > effect_value)
new_bonus->CriticalHitChance[EQEmu::skills::HIGHEST_SKILL + 1] = effect_value;
if (base2 == ALL_SKILLS && new_bonus->CriticalHitChance[EQ::skills::HIGHEST_SKILL + 1] > effect_value)
new_bonus->CriticalHitChance[EQ::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[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[EQ::skills::HIGHEST_SKILL + 1] < effect_value)
new_bonus->CriticalHitChance[EQ::skills::HIGHEST_SKILL + 1] = effect_value;
else if(base2 != ALL_SKILLS && new_bonus->CriticalHitChance[base2] < effect_value)
new_bonus->CriticalHitChance[base2] = effect_value;
@@ -2189,24 +2189,24 @@ void Mob::ApplySpellsBonuses(uint16 spell_id, uint8 casterlevel, StatBonuses *ne
case SE_HitChance:
{
// Bad data or unsupported new skill
if (base2 > EQEmu::skills::HIGHEST_SKILL)
if (base2 > EQ::skills::HIGHEST_SKILL)
break;
if (AdditiveWornBonus){
if(base2 == ALL_SKILLS)
new_bonus->HitChanceEffect[EQEmu::skills::HIGHEST_SKILL + 1] += effect_value;
new_bonus->HitChanceEffect[EQ::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[EQEmu::skills::HIGHEST_SKILL + 1] > effect_value))
new_bonus->HitChanceEffect[EQEmu::skills::HIGHEST_SKILL + 1] = effect_value;
if ((effect_value < 0) && (new_bonus->HitChanceEffect[EQ::skills::HIGHEST_SKILL + 1] > effect_value))
new_bonus->HitChanceEffect[EQ::skills::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 if (!new_bonus->HitChanceEffect[EQ::skills::HIGHEST_SKILL + 1] ||
((new_bonus->HitChanceEffect[EQ::skills::HIGHEST_SKILL + 1] > 0) && (new_bonus->HitChanceEffect[EQ::skills::HIGHEST_SKILL + 1] < effect_value)))
new_bonus->HitChanceEffect[EQ::skills::HIGHEST_SKILL + 1] = effect_value;
}
else {
@@ -2226,9 +2226,9 @@ void Mob::ApplySpellsBonuses(uint16 spell_id, uint8 casterlevel, StatBonuses *ne
case SE_DamageModifier:
{
// Bad data or unsupported new skill
if (base2 > EQEmu::skills::HIGHEST_SKILL)
if (base2 > EQ::skills::HIGHEST_SKILL)
break;
int skill = base2 == ALL_SKILLS ? EQEmu::skills::HIGHEST_SKILL + 1 : base2;
int skill = base2 == ALL_SKILLS ? EQ::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)
@@ -2239,9 +2239,9 @@ void Mob::ApplySpellsBonuses(uint16 spell_id, uint8 casterlevel, StatBonuses *ne
case SE_DamageModifier2:
{
// Bad data or unsupported new skill
if (base2 > EQEmu::skills::HIGHEST_SKILL)
if (base2 > EQ::skills::HIGHEST_SKILL)
break;
int skill = base2 == ALL_SKILLS ? EQEmu::skills::HIGHEST_SKILL + 1 : base2;
int skill = base2 == ALL_SKILLS ? EQ::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)
@@ -2252,9 +2252,9 @@ void Mob::ApplySpellsBonuses(uint16 spell_id, uint8 casterlevel, StatBonuses *ne
case SE_MinDamageModifier:
{
// Bad data or unsupported new skill
if (base2 > EQEmu::skills::HIGHEST_SKILL)
if (base2 > EQ::skills::HIGHEST_SKILL)
break;
int skill = base2 == ALL_SKILLS ? EQEmu::skills::HIGHEST_SKILL + 1 : base2;
int skill = base2 == ALL_SKILLS ? EQ::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)
@@ -2329,14 +2329,14 @@ void Mob::ApplySpellsBonuses(uint16 spell_id, uint8 casterlevel, StatBonuses *ne
case SE_Accuracy:
{
// Bad data or unsupported new skill
if (base2 > EQEmu::skills::HIGHEST_SKILL)
if (base2 > EQ::skills::HIGHEST_SKILL)
break;
if ((effect_value < 0) && (new_bonus->Accuracy[EQEmu::skills::HIGHEST_SKILL + 1] > effect_value))
new_bonus->Accuracy[EQEmu::skills::HIGHEST_SKILL + 1] = effect_value;
if ((effect_value < 0) && (new_bonus->Accuracy[EQ::skills::HIGHEST_SKILL + 1] > effect_value))
new_bonus->Accuracy[EQ::skills::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;
else if (!new_bonus->Accuracy[EQ::skills::HIGHEST_SKILL + 1] ||
((new_bonus->Accuracy[EQ::skills::HIGHEST_SKILL + 1] > 0) && (new_bonus->Accuracy[EQ::skills::HIGHEST_SKILL + 1] < effect_value)))
new_bonus->Accuracy[EQ::skills::HIGHEST_SKILL + 1] = effect_value;
break;
}
@@ -2355,19 +2355,19 @@ void Mob::ApplySpellsBonuses(uint16 spell_id, uint8 casterlevel, StatBonuses *ne
case SE_SkillDamageTaken:
{
// Bad data or unsupported new skill
if (base2 > EQEmu::skills::HIGHEST_SKILL)
if (base2 > EQ::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[EQEmu::skills::HIGHEST_SKILL + 1] = effect_value;
SkillDmgTaken_Mod[EQ::skills::HIGHEST_SKILL + 1] = effect_value;
else
SkillDmgTaken_Mod[base2] = effect_value;
}
else {
if(base2 == ALL_SKILLS)
new_bonus->SkillDmgTaken[EQEmu::skills::HIGHEST_SKILL + 1] += effect_value;
new_bonus->SkillDmgTaken[EQ::skills::HIGHEST_SKILL + 1] += effect_value;
else
new_bonus->SkillDmgTaken[base2] += effect_value;
@@ -2476,10 +2476,10 @@ void Mob::ApplySpellsBonuses(uint16 spell_id, uint8 casterlevel, StatBonuses *ne
case SE_CriticalDamageMob:
{
// Bad data or unsupported new skill
if (base2 > EQEmu::skills::HIGHEST_SKILL)
if (base2 > EQ::skills::HIGHEST_SKILL)
break;
if(base2 == ALL_SKILLS)
new_bonus->CritDmgMod[EQEmu::skills::HIGHEST_SKILL + 1] += effect_value;
new_bonus->CritDmgMod[EQ::skills::HIGHEST_SKILL + 1] += effect_value;
else
new_bonus->CritDmgMod[base2] += effect_value;
break;
@@ -2495,10 +2495,10 @@ void Mob::ApplySpellsBonuses(uint16 spell_id, uint8 casterlevel, StatBonuses *ne
case SE_SkillDamageAmount:
{
// Bad data or unsupported new skill
if (base2 > EQEmu::skills::HIGHEST_SKILL)
if (base2 > EQ::skills::HIGHEST_SKILL)
break;
if(base2 == ALL_SKILLS)
new_bonus->SkillDamageAmount[EQEmu::skills::HIGHEST_SKILL + 1] += effect_value;
new_bonus->SkillDamageAmount[EQ::skills::HIGHEST_SKILL + 1] += effect_value;
else
new_bonus->SkillDamageAmount[base2] += effect_value;
break;
@@ -2614,10 +2614,10 @@ void Mob::ApplySpellsBonuses(uint16 spell_id, uint8 casterlevel, StatBonuses *ne
case SE_SkillDamageAmount2:
{
// Bad data or unsupported new skill
if (base2 > EQEmu::skills::HIGHEST_SKILL)
if (base2 > EQ::skills::HIGHEST_SKILL)
break;
if(base2 == ALL_SKILLS)
new_bonus->SkillDamageAmount2[EQEmu::skills::HIGHEST_SKILL + 1] += effect_value;
new_bonus->SkillDamageAmount2[EQ::skills::HIGHEST_SKILL + 1] += effect_value;
else
new_bonus->SkillDamageAmount2[base2] += effect_value;
break;
@@ -2805,19 +2805,19 @@ void Mob::ApplySpellsBonuses(uint16 spell_id, uint8 casterlevel, StatBonuses *ne
case SE_AddSingingMod:
switch (base2) {
case EQEmu::item::ItemTypeWindInstrument:
case EQ::item::ItemTypeWindInstrument:
new_bonus->windMod += effect_value;
break;
case EQEmu::item::ItemTypeStringedInstrument:
case EQ::item::ItemTypeStringedInstrument:
new_bonus->stringedMod += effect_value;
break;
case EQEmu::item::ItemTypeBrassInstrument:
case EQ::item::ItemTypeBrassInstrument:
new_bonus->brassMod += effect_value;
break;
case EQEmu::item::ItemTypePercussionInstrument:
case EQ::item::ItemTypePercussionInstrument:
new_bonus->percussionMod += effect_value;
break;
case EQEmu::item::ItemTypeSinging:
case EQ::item::ItemTypeSinging:
new_bonus->singingMod += effect_value;
break;
default:
@@ -3151,9 +3151,9 @@ void Mob::ApplySpellsBonuses(uint16 spell_id, uint8 casterlevel, StatBonuses *ne
case SE_LimitToSkill:{
// Bad data or unsupported new skill
if (base2 > EQEmu::skills::HIGHEST_SKILL)
if (base2 > EQ::skills::HIGHEST_SKILL)
break;
if (effect_value <= EQEmu::skills::HIGHEST_SKILL){
if (effect_value <= EQ::skills::HIGHEST_SKILL){
new_bonus->LimitToSkill[effect_value] = true;
}
break;
@@ -3210,7 +3210,7 @@ void Mob::ApplySpellsBonuses(uint16 spell_id, uint8 casterlevel, StatBonuses *ne
case SE_ReduceTradeskillFail:{
if (base2 > EQEmu::skills::HIGHEST_SKILL)
if (base2 > EQ::skills::HIGHEST_SKILL)
break;
new_bonus->ReduceTradeskillFail[base2] += effect_value;
@@ -3223,7 +3223,7 @@ void Mob::ApplySpellsBonuses(uint16 spell_id, uint8 casterlevel, StatBonuses *ne
break;
case SE_RaiseSkillCap: {
if (base2 > EQEmu::skills::HIGHEST_SKILL)
if (base2 > EQ::skills::HIGHEST_SKILL)
break;
if (new_bonus->RaiseSkillCap[base2] < effect_value)
@@ -3267,8 +3267,8 @@ void NPC::CalcItemBonuses(StatBonuses *newbon)
{
if(newbon){
for (int i = EQEmu::invslot::BONUS_BEGIN; i <= EQEmu::invslot::BONUS_STAT_END; i++){
const EQEmu::ItemData *cur = database.GetItem(equipment[i]);
for (int i = EQ::invslot::BONUS_BEGIN; i <= EQ::invslot::BONUS_STAT_END; i++){
const EQ::ItemData *cur = database.GetItem(equipment[i]);
if(cur){
//basic stats
newbon->AC += cur->AC;
@@ -3323,12 +3323,12 @@ void NPC::CalcItemBonuses(StatBonuses *newbon)
if(cur->CombatEffects > 0) {
newbon->ProcChance += cur->CombatEffects;
}
if (cur->Worn.Effect>0 && (cur->Worn.Type == EQEmu::item::ItemEffectWorn)) { // latent effects
if (cur->Worn.Effect>0 && (cur->Worn.Type == EQ::item::ItemEffectWorn)) { // latent effects
ApplySpellsBonuses(cur->Worn.Effect, cur->Worn.Level, newbon, 0, cur->Worn.Type);
}
if (RuleB(Spells, NPC_UseFocusFromItems)){
if (cur->Focus.Effect>0 && (cur->Focus.Type == EQEmu::item::ItemEffectFocus)){ // focus effects
if (cur->Focus.Effect>0 && (cur->Focus.Type == EQ::item::ItemEffectFocus)){ // focus effects
ApplySpellsBonuses(cur->Focus.Effect, cur->Focus.Level, newbon);
}
}
@@ -3345,18 +3345,18 @@ void Client::CalcItemScale() {
bool changed = false;
// MainAmmo excluded in helper function below
if (CalcItemScale(EQEmu::invslot::EQUIPMENT_BEGIN, EQEmu::invslot::EQUIPMENT_END)) // original coding excluded MainAmmo (< 21)
if (CalcItemScale(EQ::invslot::EQUIPMENT_BEGIN, EQ::invslot::EQUIPMENT_END)) // original coding excluded MainAmmo (< 21)
changed = true;
if (CalcItemScale(EQEmu::invslot::GENERAL_BEGIN, EQEmu::invslot::GENERAL_END)) // original coding excluded MainCursor (< 30)
if (CalcItemScale(EQ::invslot::GENERAL_BEGIN, EQ::invslot::GENERAL_END)) // original coding excluded MainCursor (< 30)
changed = true;
// I excluded cursor bag slots here because cursor was excluded above..if this is incorrect, change 'slot_y' here to CURSOR_BAG_END
// and 'slot_y' above to CURSOR from GENERAL_END above - or however it is supposed to be...
if (CalcItemScale(EQEmu::invbag::GENERAL_BAGS_BEGIN, EQEmu::invbag::GENERAL_BAGS_END)) // (< 341)
if (CalcItemScale(EQ::invbag::GENERAL_BAGS_BEGIN, EQ::invbag::GENERAL_BAGS_END)) // (< 341)
changed = true;
if (CalcItemScale(EQEmu::invslot::TRIBUTE_BEGIN, EQEmu::invslot::TRIBUTE_END)) // (< 405)
if (CalcItemScale(EQ::invslot::TRIBUTE_BEGIN, EQ::invslot::TRIBUTE_END)) // (< 405)
changed = true;
if(changed)
@@ -3370,18 +3370,18 @@ bool Client::CalcItemScale(uint32 slot_x, uint32 slot_y) {
bool changed = false;
uint32 i;
for (i = slot_x; i <= slot_y; i++) {
if (i == EQEmu::invslot::slotAmmo) // moved here from calling procedure to facilitate future range changes where MainAmmo may not be the last slot
if (i == EQ::invslot::slotAmmo) // moved here from calling procedure to facilitate future range changes where MainAmmo may not be the last slot
continue;
EQEmu::ItemInstance* inst = m_inv.GetItem(i);
EQ::ItemInstance* inst = m_inv.GetItem(i);
if(inst == nullptr)
continue;
// TEST CODE: test for bazaar trader crashing with charm items
if (Trader)
if (i >= EQEmu::invbag::GENERAL_BAGS_BEGIN && i <= EQEmu::invbag::GENERAL_BAGS_END) {
EQEmu::ItemInstance* parent_item = m_inv.GetItem(EQEmu::InventoryProfile::CalcSlotId(i));
if (i >= EQ::invbag::GENERAL_BAGS_BEGIN && i <= EQ::invbag::GENERAL_BAGS_END) {
EQ::ItemInstance* parent_item = m_inv.GetItem(EQ::InventoryProfile::CalcSlotId(i));
if (parent_item && parent_item->GetItem()->ID == 17899) // trader satchel
continue;
}
@@ -3400,9 +3400,9 @@ bool Client::CalcItemScale(uint32 slot_x, uint32 slot_y) {
}
//iterate all augments
for (int x = EQEmu::invaug::SOCKET_BEGIN; x <= EQEmu::invaug::SOCKET_END; ++x)
for (int x = EQ::invaug::SOCKET_BEGIN; x <= EQ::invaug::SOCKET_END; ++x)
{
EQEmu::ItemInstance * a_inst = inst->GetAugment(x);
EQ::ItemInstance * a_inst = inst->GetAugment(x);
if(!a_inst)
continue;
@@ -3432,18 +3432,18 @@ void Client::DoItemEnterZone() {
bool changed = false;
// MainAmmo excluded in helper function below
if (DoItemEnterZone(EQEmu::invslot::EQUIPMENT_BEGIN, EQEmu::invslot::EQUIPMENT_END)) // original coding excluded MainAmmo (< 21)
if (DoItemEnterZone(EQ::invslot::EQUIPMENT_BEGIN, EQ::invslot::EQUIPMENT_END)) // original coding excluded MainAmmo (< 21)
changed = true;
if (DoItemEnterZone(EQEmu::invslot::GENERAL_BEGIN, EQEmu::invslot::GENERAL_END)) // original coding excluded MainCursor (< 30)
if (DoItemEnterZone(EQ::invslot::GENERAL_BEGIN, EQ::invslot::GENERAL_END)) // original coding excluded MainCursor (< 30)
changed = true;
// I excluded cursor bag slots here because cursor was excluded above..if this is incorrect, change 'slot_y' here to CURSOR_BAG_END
// and 'slot_y' above to CURSOR from GENERAL_END above - or however it is supposed to be...
if (DoItemEnterZone(EQEmu::invbag::GENERAL_BAGS_BEGIN, EQEmu::invbag::GENERAL_BAGS_END)) // (< 341)
if (DoItemEnterZone(EQ::invbag::GENERAL_BAGS_BEGIN, EQ::invbag::GENERAL_BAGS_END)) // (< 341)
changed = true;
if (DoItemEnterZone(EQEmu::invslot::TRIBUTE_BEGIN, EQEmu::invslot::TRIBUTE_END)) // (< 405)
if (DoItemEnterZone(EQ::invslot::TRIBUTE_BEGIN, EQ::invslot::TRIBUTE_END)) // (< 405)
changed = true;
if(changed)
@@ -3456,18 +3456,18 @@ bool Client::DoItemEnterZone(uint32 slot_x, uint32 slot_y) {
// behavior change: 'slot_y' is now [RANGE]_END and not [RANGE]_END + 1
bool changed = false;
for(uint32 i = slot_x; i <= slot_y; i++) {
if (i == EQEmu::invslot::slotAmmo) // moved here from calling procedure to facilitate future range changes where MainAmmo may not be the last slot
if (i == EQ::invslot::slotAmmo) // moved here from calling procedure to facilitate future range changes where MainAmmo may not be the last slot
continue;
EQEmu::ItemInstance* inst = m_inv.GetItem(i);
EQ::ItemInstance* inst = m_inv.GetItem(i);
if(!inst)
continue;
// TEST CODE: test for bazaar trader crashing with charm items
if (Trader)
if (i >= EQEmu::invbag::GENERAL_BAGS_BEGIN && i <= EQEmu::invbag::GENERAL_BAGS_END) {
EQEmu::ItemInstance* parent_item = m_inv.GetItem(EQEmu::InventoryProfile::CalcSlotId(i));
if (i >= EQ::invbag::GENERAL_BAGS_BEGIN && i <= EQ::invbag::GENERAL_BAGS_END) {
EQ::ItemInstance* parent_item = m_inv.GetItem(EQ::InventoryProfile::CalcSlotId(i));
if (parent_item && parent_item->GetItem()->ID == 17899) // trader satchel
continue;
}
@@ -3478,7 +3478,7 @@ bool Client::DoItemEnterZone(uint32 slot_x, uint32 slot_y) {
uint16 oldexp = inst->GetExp();
parse->EventItem(EVENT_ITEM_ENTER_ZONE, this, inst, nullptr, "", 0);
if (i <= EQEmu::invslot::EQUIPMENT_END) {
if (i <= EQ::invslot::EQUIPMENT_END) {
parse->EventItem(EVENT_EQUIP_ITEM, this, inst, nullptr, "", i);
}
@@ -3488,7 +3488,7 @@ bool Client::DoItemEnterZone(uint32 slot_x, uint32 slot_y) {
update_slot = true;
}
} else {
if (i <= EQEmu::invslot::EQUIPMENT_END) {
if (i <= EQ::invslot::EQUIPMENT_END) {
parse->EventItem(EVENT_EQUIP_ITEM, this, inst, nullptr, "", i);
}
@@ -3496,9 +3496,9 @@ bool Client::DoItemEnterZone(uint32 slot_x, uint32 slot_y) {
}
//iterate all augments
for (int x = EQEmu::invaug::SOCKET_BEGIN; x <= EQEmu::invaug::SOCKET_END; ++x)
for (int x = EQ::invaug::SOCKET_BEGIN; x <= EQ::invaug::SOCKET_END; ++x)
{
EQEmu::ItemInstance *a_inst = inst->GetAugment(x);
EQ::ItemInstance *a_inst = inst->GetAugment(x);
if(!a_inst)
continue;
@@ -3922,7 +3922,7 @@ void Mob::NegateSpellsBonuses(uint16 spell_id)
case SE_CriticalHitChance:
{
for (int e = 0; e < EQEmu::skills::HIGHEST_SKILL + 1; e++)
for (int e = 0; e < EQ::skills::HIGHEST_SKILL + 1; e++)
{
spellbonuses.CriticalHitChance[e] = effect_value;
aabonuses.CriticalHitChance[e] = effect_value;
@@ -4040,7 +4040,7 @@ void Mob::NegateSpellsBonuses(uint16 spell_id)
case SE_HitChance:
{
for (int e = 0; e < EQEmu::skills::HIGHEST_SKILL + 1; e++)
for (int e = 0; e < EQ::skills::HIGHEST_SKILL + 1; e++)
{
spellbonuses.HitChanceEffect[e] = effect_value;
aabonuses.HitChanceEffect[e] = effect_value;
@@ -4051,7 +4051,7 @@ void Mob::NegateSpellsBonuses(uint16 spell_id)
case SE_DamageModifier:
{
for (int e = 0; e < EQEmu::skills::HIGHEST_SKILL + 1; e++)
for (int e = 0; e < EQ::skills::HIGHEST_SKILL + 1; e++)
{
spellbonuses.DamageModifier[e] = effect_value;
aabonuses.DamageModifier[e] = effect_value;
@@ -4062,7 +4062,7 @@ void Mob::NegateSpellsBonuses(uint16 spell_id)
case SE_DamageModifier2:
{
for (int e = 0; e < EQEmu::skills::HIGHEST_SKILL + 1; e++)
for (int e = 0; e < EQ::skills::HIGHEST_SKILL + 1; e++)
{
spellbonuses.DamageModifier2[e] = effect_value;
aabonuses.DamageModifier2[e] = effect_value;
@@ -4073,7 +4073,7 @@ void Mob::NegateSpellsBonuses(uint16 spell_id)
case SE_MinDamageModifier:
{
for (int e = 0; e < EQEmu::skills::HIGHEST_SKILL + 1; e++)
for (int e = 0; e < EQ::skills::HIGHEST_SKILL + 1; e++)
{
spellbonuses.MinDamageModifier[e] = effect_value;
aabonuses.MinDamageModifier[e] = effect_value;
@@ -4114,10 +4114,10 @@ void Mob::NegateSpellsBonuses(uint16 spell_id)
case SE_Accuracy:
{
spellbonuses.Accuracy[EQEmu::skills::HIGHEST_SKILL + 1] = effect_value;
itembonuses.Accuracy[EQEmu::skills::HIGHEST_SKILL + 1] = effect_value;
spellbonuses.Accuracy[EQ::skills::HIGHEST_SKILL + 1] = effect_value;
itembonuses.Accuracy[EQ::skills::HIGHEST_SKILL + 1] = effect_value;
for (int e = 0; e < EQEmu::skills::HIGHEST_SKILL + 1; e++)
for (int e = 0; e < EQ::skills::HIGHEST_SKILL + 1; e++)
{
aabonuses.Accuracy[e] = effect_value;
}
@@ -4144,7 +4144,7 @@ void Mob::NegateSpellsBonuses(uint16 spell_id)
case SE_SkillDamageTaken:
{
for (int e = 0; e < EQEmu::skills::HIGHEST_SKILL + 1; e++)
for (int e = 0; e < EQ::skills::HIGHEST_SKILL + 1; e++)
{
spellbonuses.SkillDmgTaken[e] = effect_value;
aabonuses.SkillDmgTaken[e] = effect_value;
@@ -4249,7 +4249,7 @@ void Mob::NegateSpellsBonuses(uint16 spell_id)
case SE_CriticalDamageMob:
{
for (int e = 0; e < EQEmu::skills::HIGHEST_SKILL + 1; e++)
for (int e = 0; e < EQ::skills::HIGHEST_SKILL + 1; e++)
{
spellbonuses.CritDmgMod[e] = effect_value;
aabonuses.CritDmgMod[e] = effect_value;
@@ -4260,7 +4260,7 @@ void Mob::NegateSpellsBonuses(uint16 spell_id)
case SE_SkillDamageAmount:
{
for (int e = 0; e < EQEmu::skills::HIGHEST_SKILL + 1; e++)
for (int e = 0; e < EQ::skills::HIGHEST_SKILL + 1; e++)
{
spellbonuses.SkillDamageAmount[e] = effect_value;
aabonuses.SkillDamageAmount[e] = effect_value;
@@ -4311,7 +4311,7 @@ void Mob::NegateSpellsBonuses(uint16 spell_id)
case SE_SkillDamageAmount2:
{
for (int e = 0; e < EQEmu::skills::HIGHEST_SKILL + 1; e++)
for (int e = 0; e < EQ::skills::HIGHEST_SKILL + 1; e++)
{
spellbonuses.SkillDamageAmount2[e] = effect_value;
aabonuses.SkillDamageAmount2[e] = effect_value;
zone/bot.cpp
+302 -302
View File
File diff suppressed because it is too large Load Diff
zone/bot.h
+31 -31
View File
@@ -144,9 +144,9 @@ 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, 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, eSpecialAttacks special = eSpecialAttacks::None);
virtual bool Attack(Mob* other, int Hand = EQEmu::invslot::slotPrimary, bool FromRiposte = false, bool IsStrikethrough = false, bool IsFromSpell = false,
virtual bool Death(Mob* killerMob, int32 damage, uint16 spell_id, EQ::skills::SkillType attack_skill);
virtual void Damage(Mob* from, int32 damage, uint16 spell_id, EQ::skills::SkillType attack_skill, bool avoidable = true, int8 buffslot = -1, bool iBuffTic = false, eSpecialAttacks special = eSpecialAttacks::None);
virtual bool Attack(Mob* other, int Hand = EQ::invslot::slotPrimary, bool FromRiposte = false, bool IsStrikethrough = false, bool IsFromSpell = false,
ExtraAttackOptions *opts = nullptr);
virtual bool HasRaid() { return (GetRaid() ? true : false); }
virtual bool HasGroup() { return (GetGroup() ? true : false); }
@@ -180,25 +180,25 @@ public:
virtual int GetHandToHandDamage(void);
virtual bool TryFinishingBlow(Mob *defender, int &damage);
virtual void DoRiposte(Mob* defender);
inline virtual int32 GetATK() const { return ATK + itembonuses.ATK + spellbonuses.ATK + ((GetSTR() + GetSkill(EQEmu::skills::SkillOffense)) * 9 / 10); }
inline virtual int32 GetATK() const { return ATK + itembonuses.ATK + spellbonuses.ATK + ((GetSTR() + GetSkill(EQ::skills::SkillOffense)) * 9 / 10); }
inline virtual int32 GetATKBonus() const { return itembonuses.ATK + spellbonuses.ATK; }
uint32 GetTotalATK();
uint32 GetATKRating();
uint16 GetPrimarySkillValue();
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 int GetBaseSkillDamage(EQEmu::skills::SkillType skill, Mob *target = nullptr);
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);
uint16 MaxSkill(EQ::skills::SkillType skillid, uint16 class_, uint16 level) const;
inline uint16 MaxSkill(EQ::skills::SkillType skillid) const { return MaxSkill(skillid, GetClass(), GetLevel()); }
virtual int GetBaseSkillDamage(EQ::skills::SkillType skill, Mob *target = nullptr);
virtual void DoSpecialAttackDamage(Mob *who, EQ::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 void ApplySpecialAttackMod(EQEmu::skills::SkillType skill, int32 &dmg, int32 &mindmg);
virtual void ApplySpecialAttackMod(EQ::skills::SkillType skill, int32 &dmg, int32 &mindmg);
bool CanDoSpecialAttack(Mob *other);
virtual int32 CheckAggroAmount(uint16 spellid);
virtual void CalcBonuses();
void CalcItemBonuses(StatBonuses* newbon);
void AddItemBonuses(const EQEmu::ItemInstance *inst, StatBonuses* newbon, bool isAug = false, bool isTribute = false, int rec_override = 0);
void AddItemBonuses(const EQ::ItemInstance *inst, StatBonuses* newbon, bool isAug = false, bool isTribute = false, int rec_override = 0);
int CalcRecommendedLevelBonus(uint8 level, uint8 reclevel, int basestat);
virtual void MakePet(uint16 spell_id, const char* pettype, const char *petname = nullptr);
virtual FACTION_VALUE GetReverseFactionCon(Mob* iOther);
@@ -212,9 +212,9 @@ public:
virtual void SetAttackTimer();
uint32 GetClassHPFactor();
virtual int32 CalcMaxHP();
bool DoFinishedSpellAETarget(uint16 spell_id, Mob* spellTarget, EQEmu::spells::CastingSlot slot, bool &stopLogic);
bool DoFinishedSpellSingleTarget(uint16 spell_id, Mob* spellTarget, EQEmu::spells::CastingSlot slot, bool &stopLogic);
bool DoFinishedSpellGroupTarget(uint16 spell_id, Mob* spellTarget, EQEmu::spells::CastingSlot slot, bool &stopLogic);
bool DoFinishedSpellAETarget(uint16 spell_id, Mob* spellTarget, EQ::spells::CastingSlot slot, bool &stopLogic);
bool DoFinishedSpellSingleTarget(uint16 spell_id, Mob* spellTarget, EQ::spells::CastingSlot slot, bool &stopLogic);
bool DoFinishedSpellGroupTarget(uint16 spell_id, Mob* spellTarget, EQ::spells::CastingSlot slot, bool &stopLogic);
void SendBotArcheryWearChange(uint8 material_slot, uint32 material, uint32 color);
void Camp(bool databaseSave = true);
virtual void AddToHateList(Mob* other, uint32 hate = 0, int32 damage = 0, bool iYellForHelp = true, bool bFrenzy = false, bool iBuffTic = false, bool pet_command = false);
@@ -336,20 +336,20 @@ public:
virtual float GetAOERange(uint16 spell_id);
virtual bool SpellEffect(Mob* caster, uint16 spell_id, float partial = 100);
virtual void DoBuffTic(const Buffs_Struct &buff, int slot, Mob* caster = nullptr);
virtual bool CastSpell(uint16 spell_id, uint16 target_id, EQEmu::spells::CastingSlot slot = EQEmu::spells::CastingSlot::Item, int32 casttime = -1, int32 mana_cost = -1, uint32* oSpellWillFinish = 0,
virtual bool CastSpell(uint16 spell_id, uint16 target_id, EQ::spells::CastingSlot slot = EQ::spells::CastingSlot::Item, int32 casttime = -1, int32 mana_cost = -1, uint32* oSpellWillFinish = 0,
uint32 item_slot = 0xFFFFFFFF, int16 *resist_adjust = nullptr, uint32 aa_id = 0);
virtual bool SpellOnTarget(uint16 spell_id, Mob* spelltar);
virtual bool IsImmuneToSpell(uint16 spell_id, Mob *caster);
virtual bool DetermineSpellTargets(uint16 spell_id, Mob *&spell_target, Mob *&ae_center, CastAction_type &CastAction, EQEmu::spells::CastingSlot slot);
virtual bool DoCastSpell(uint16 spell_id, uint16 target_id, EQEmu::spells::CastingSlot slot = EQEmu::spells::CastingSlot::Item, int32 casttime = -1, int32 mana_cost = -1, uint32* oSpellWillFinish = 0, uint32 item_slot = 0xFFFFFFFF, uint32 aa_id = 0);
virtual bool DetermineSpellTargets(uint16 spell_id, Mob *&spell_target, Mob *&ae_center, CastAction_type &CastAction, EQ::spells::CastingSlot slot);
virtual bool DoCastSpell(uint16 spell_id, uint16 target_id, EQ::spells::CastingSlot slot = EQ::spells::CastingSlot::Item, int32 casttime = -1, int32 mana_cost = -1, uint32* oSpellWillFinish = 0, uint32 item_slot = 0xFFFFFFFF, uint32 aa_id = 0);
// Bot Equipment & Inventory Class Methods
void BotTradeSwapItem(Client* client, int16 lootSlot, const EQEmu::ItemInstance* inst, const EQEmu::ItemInstance* inst_swap, uint32 equipableSlots, std::string* errorMessage, bool swap = true);
void BotTradeAddItem(uint32 id, const EQEmu::ItemInstance* inst, int16 charges, uint32 equipableSlots, uint16 lootSlot, std::string* errorMessage, bool addToDb = true);
void BotTradeSwapItem(Client* client, int16 lootSlot, const EQ::ItemInstance* inst, const EQ::ItemInstance* inst_swap, uint32 equipableSlots, std::string* errorMessage, bool swap = true);
void BotTradeAddItem(uint32 id, const EQ::ItemInstance* inst, int16 charges, uint32 equipableSlots, uint16 lootSlot, std::string* errorMessage, bool addToDb = true);
void EquipBot(std::string* errorMessage);
bool CheckLoreConflict(const EQEmu::ItemData* item);
virtual void UpdateEquipmentLight() { m_Light.Type[EQEmu::lightsource::LightEquipment] = m_inv.FindBrightestLightType(); m_Light.Level[EQEmu::lightsource::LightEquipment] = EQEmu::lightsource::TypeToLevel(m_Light.Type[EQEmu::lightsource::LightEquipment]); }
const EQEmu::InventoryProfile& GetBotInv() const { return m_inv; }
bool CheckLoreConflict(const EQ::ItemData* item);
virtual void UpdateEquipmentLight() { m_Light.Type[EQ::lightsource::LightEquipment] = m_inv.FindBrightestLightType(); m_Light.Level[EQ::lightsource::LightEquipment] = EQ::lightsource::TypeToLevel(m_Light.Type[EQ::lightsource::LightEquipment]); }
const EQ::InventoryProfile& GetBotInv() const { return m_inv; }
// Static Class Methods
//static void DestroyBotRaidObjects(Client* client); // Can be removed after bot raids are dumped
@@ -419,7 +419,7 @@ public:
uint32 GetBotSpellID() { return npc_spells_id; }
Mob* GetBotOwner() { return this->_botOwner; }
uint32 GetBotArcheryRange();
EQEmu::ItemInstance* GetBotItem(uint32 slotID);
EQ::ItemInstance* GetBotItem(uint32 slotID);
virtual bool GetSpawnStatus() { return _spawnStatus; }
uint8 GetPetChooserID() { return _petChooserID; }
bool IsPetChooser() { return _petChooser; }
@@ -428,7 +428,7 @@ public:
virtual bool IsBot() const { return true; }
bool GetRangerAutoWeaponSelect() { return _rangerAutoWeaponSelect; }
BotRoleType GetBotRole() { return _botRole; }
EQEmu::constants::StanceType GetBotStance() { return _botStance; }
EQ::constants::StanceType GetBotStance() { return _botStance; }
uint8 GetChanceToCastBySpellType(uint32 spellType);
bool IsGroupHealer() { return m_CastingRoles.GroupHealer; }
@@ -542,11 +542,11 @@ public:
// void SetBotOwnerCharacterID(uint32 botOwnerCharacterID) { _botOwnerCharacterID = botOwnerCharacterID; }
void SetRangerAutoWeaponSelect(bool enable) { GetClass() == RANGER ? _rangerAutoWeaponSelect = enable : _rangerAutoWeaponSelect = false; }
void SetBotRole(BotRoleType botRole) { _botRole = botRole; }
void SetBotStance(EQEmu::constants::StanceType botStance) {
if (botStance >= EQEmu::constants::stancePassive && botStance <= EQEmu::constants::stanceBurnAE)
void SetBotStance(EQ::constants::StanceType botStance) {
if (botStance >= EQ::constants::stancePassive && botStance <= EQ::constants::stanceBurnAE)
_botStance = botStance;
else
_botStance = EQEmu::constants::stancePassive;
_botStance = EQ::constants::stancePassive;
}
void SetSpellRecastTimer(int timer_index, int32 recast_delay);
void SetDisciplineRecastTimer(int timer_index, int32 recast_delay);
@@ -631,7 +631,7 @@ private:
bool _petChooser;
uint8 _petChooserID;
bool berserk;
EQEmu::InventoryProfile m_inv;
EQ::InventoryProfile m_inv;
double _lastTotalPlayTime;
time_t _startTotalPlayTime;
Mob* _previousTarget;
@@ -644,8 +644,8 @@ private:
uint32 _lastZoneId;
bool _rangerAutoWeaponSelect;
BotRoleType _botRole;
EQEmu::constants::StanceType _botStance;
EQEmu::constants::StanceType _baseBotStance;
EQ::constants::StanceType _botStance;
EQ::constants::StanceType _baseBotStance;
unsigned int RestRegenHP;
unsigned int RestRegenMana;
unsigned int RestRegenEndurance;
@@ -717,7 +717,7 @@ private:
void SetReturningFlag(bool flag = true) { m_returning_flag = flag; }
// Private "Inventory" Methods
void GetBotItems(EQEmu::InventoryProfile &inv, std::string* errorMessage);
void GetBotItems(EQ::InventoryProfile &inv, std::string* errorMessage);
void BotAddEquipItem(int slot, uint32 id);
uint32 GetBotItemBySlot(uint32 slotID);
@@ -727,7 +727,7 @@ private:
bool DeletePet();
public:
static uint8 spell_casting_chances[SPELL_TYPE_COUNT][PLAYER_CLASS_COUNT][EQEmu::constants::STANCE_TYPE_COUNT][cntHSND];
static uint8 spell_casting_chances[SPELL_TYPE_COUNT][PLAYER_CLASS_COUNT][EQ::constants::STANCE_TYPE_COUNT][cntHSND];
};
#endif // BOTS
zone/bot_command.cpp
+93 -93
View File
@@ -338,11 +338,11 @@ public:
while (spells[spell_id].typedescnum == 27) {
if (!spells[spell_id].goodEffect)
break;
if (spells[spell_id].skill != EQEmu::skills::SkillOffense && spells[spell_id].skill != EQEmu::skills::SkillDefense)
if (spells[spell_id].skill != EQ::skills::SkillOffense && spells[spell_id].skill != EQ::skills::SkillDefense)
break;
entry_prototype = new STStanceEntry();
if (spells[spell_id].skill == EQEmu::skills::SkillOffense)
if (spells[spell_id].skill == EQ::skills::SkillOffense)
entry_prototype->SafeCastToStance()->stance_type = BCEnum::StT_Aggressive;
else
entry_prototype->SafeCastToStance()->stance_type = BCEnum::StT_Defensive;
@@ -2462,7 +2462,7 @@ namespace ActionableBots
sbl.remove_if([bot_owner](Bot* l) { return (!l->IsBotArcher()); });
}
static void Filter_ByHighestSkill(Client* bot_owner, std::list<Bot*>& sbl, EQEmu::skills::SkillType skill_type, float& skill_value) {
static void Filter_ByHighestSkill(Client* bot_owner, std::list<Bot*>& sbl, EQ::skills::SkillType skill_type, float& skill_value) {
sbl.remove_if([bot_owner](Bot* l) { return (!MyBots::IsMyBot(bot_owner, l)); });
skill_value = 0.0f;
@@ -2474,8 +2474,8 @@ namespace ActionableBots
continue;
mod_skill_value = base_skill_value;
for (int16 index = EQEmu::invslot::EQUIPMENT_BEGIN; index <= EQEmu::invslot::EQUIPMENT_END; ++index) {
const EQEmu::ItemInstance* indexed_item = bot_iter->GetBotItem(index);
for (int16 index = EQ::invslot::EQUIPMENT_BEGIN; index <= EQ::invslot::EQUIPMENT_END; ++index) {
const EQ::ItemInstance* indexed_item = bot_iter->GetBotItem(index);
if (indexed_item && indexed_item->GetItem()->SkillModType == skill_type)
mod_skill_value += (base_skill_value * (((float)indexed_item->GetItem()->SkillModValue) / 100.0f));
}
@@ -2499,7 +2499,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, EQEmu::skills::SkillPickLock, pick_lock_value);
ActionableBots::Filter_ByHighestSkill(bot_owner, sbl, EQ::skills::SkillPickLock, pick_lock_value);
}
};
@@ -2611,7 +2611,7 @@ void bot_command_apply_poison(Client *c, const Seperator *sep)
return;
}
const auto poison_instance = c->GetInv().GetItem(EQEmu::invslot::slotCursor);
const auto poison_instance = c->GetInv().GetItem(EQ::invslot::slotCursor);
if (!poison_instance) {
c->Message(m_fail, "No item found on cursor!");
@@ -2625,7 +2625,7 @@ void bot_command_apply_poison(Client *c, const Seperator *sep)
return;
}
if (poison_data->ItemType == EQEmu::item::ItemTypePoison) {
if (poison_data->ItemType == EQ::item::ItemTypePoison) {
if ((~poison_data->Races) & GetPlayerRaceBit(my_rogue_bot->GetRace())) {
@@ -2654,7 +2654,7 @@ void bot_command_apply_poison(Client *c, const Seperator *sep)
c->Message(m_fail, "Failed to apply %s to %s's weapon.", poison_data->Name, my_rogue_bot->GetCleanName());
}
c->DeleteItemInInventory(EQEmu::invslot::slotCursor, 1, true);
c->DeleteItemInInventory(EQ::invslot::slotCursor, 1, true);
}
else {
@@ -2687,7 +2687,7 @@ void bot_command_apply_potion(Client* c, const Seperator* sep)
return;
}
const auto potion_instance = c->GetInv().GetItem(EQEmu::invslot::slotCursor);
const auto potion_instance = c->GetInv().GetItem(EQ::invslot::slotCursor);
if (!potion_instance) {
c->Message(m_fail, "No item found on cursor!");
@@ -2701,7 +2701,7 @@ void bot_command_apply_potion(Client* c, const Seperator* sep)
return;
}
if (potion_data->ItemType == EQEmu::item::ItemTypePotion && potion_data->Click.Effect > 0) {
if (potion_data->ItemType == EQ::item::ItemTypePotion && potion_data->Click.Effect > 0) {
if (RuleB(Bots, RestrictApplyPotionToRogue) && potion_data->Classes != PLAYER_CLASS_ROGUE_BIT) {
@@ -2726,14 +2726,14 @@ void bot_command_apply_potion(Client* c, const Seperator* sep)
}
// TODO: figure out best way to handle casting time/animation
if (my_bot->SpellFinished(potion_data->Click.Effect, my_bot, EQEmu::spells::CastingSlot::Item, 0)) {
if (my_bot->SpellFinished(potion_data->Click.Effect, my_bot, EQ::spells::CastingSlot::Item, 0)) {
c->Message(m_action, "Successfully applied %s to %s's buff effects.", potion_data->Name, my_bot->GetCleanName());
}
else {
c->Message(m_fail, "Failed to apply %s to %s's buff effects.", potion_data->Name, my_bot->GetCleanName());
}
c->DeleteItemInInventory(EQEmu::invslot::slotCursor, 1, true);
c->DeleteItemInInventory(EQ::invslot::slotCursor, 1, true);
}
else {
@@ -2776,7 +2776,7 @@ void bot_command_attack(Client *c, const Seperator *sep)
sbl.remove(nullptr);
for (auto bot_iter : sbl) {
if (bot_iter->GetAppearance() != eaDead && bot_iter->GetBotStance() != EQEmu::constants::stancePassive) {
if (bot_iter->GetAppearance() != eaDead && bot_iter->GetBotStance() != EQ::constants::stancePassive) {
if (!first_attacker) {
first_attacker = bot_iter;
@@ -3599,7 +3599,7 @@ void bot_command_item_use(Client* c, const Seperator* sep)
empty_only = true;
}
const auto item_instance = c->GetInv().GetItem(EQEmu::invslot::slotCursor);
const auto item_instance = c->GetInv().GetItem(EQ::invslot::slotCursor);
if (!item_instance) {
c->Message(m_fail, "No item found on cursor!");
@@ -3613,14 +3613,14 @@ void bot_command_item_use(Client* c, const Seperator* sep)
return;
}
if (item_data->ItemClass != EQEmu::item::ItemClassCommon || item_data->Slots == 0) {
if (item_data->ItemClass != EQ::item::ItemClassCommon || item_data->Slots == 0) {
c->Message(m_fail, "'%s' is not an equipable item!", item_data->Name);
return;
}
std::list<int16> equipable_slot_list;
for (int16 equipable_slot = EQEmu::invslot::EQUIPMENT_BEGIN; equipable_slot <= EQEmu::invslot::EQUIPMENT_END; ++equipable_slot) {
for (int16 equipable_slot = EQ::invslot::EQUIPMENT_BEGIN; equipable_slot <= EQ::invslot::EQUIPMENT_END; ++equipable_slot) {
if (item_data->Slots & (1 << equipable_slot)) {
equipable_slot_list.push_back(equipable_slot);
}
@@ -3629,8 +3629,8 @@ void bot_command_item_use(Client* c, const Seperator* sep)
std::string msg;
std::string text_link;
EQEmu::SayLinkEngine linker;
linker.SetLinkType(EQEmu::saylink::SayLinkItemInst);
EQ::SayLinkEngine linker;
linker.SetLinkType(EQ::saylink::SayLinkItemInst);
std::list<Bot*> sbl;
MyBots::PopulateSBL_BySpawnedBots(c, sbl);
@@ -3651,7 +3651,7 @@ void bot_command_item_use(Client* c, const Seperator* sep)
for (auto slot_iter : equipable_slot_list) {
// needs more failure criteria - this should cover the bulk for now
if (slot_iter == EQEmu::invslot::slotSecondary && item_data->Damage && !bot_iter->CanThisClassDualWield()) {
if (slot_iter == EQ::invslot::slotSecondary && item_data->Damage && !bot_iter->CanThisClassDualWield()) {
continue;
}
@@ -3665,7 +3665,7 @@ void bot_command_item_use(Client* c, const Seperator* sep)
Chat::Say,
"[%s] says, 'I can use that for my %s! (replaces: [%s])'",
text_link.c_str(),
EQEmu::invslot::GetInvPossessionsSlotName(slot_iter),
EQ::invslot::GetInvPossessionsSlotName(slot_iter),
linker.GenerateLink().c_str()
);
bot_iter->DoAnim(29);
@@ -3676,7 +3676,7 @@ void bot_command_item_use(Client* c, const Seperator* sep)
Chat::Say,
"[%s] says, 'I can use that for my %s!'",
text_link.c_str(),
EQEmu::invslot::GetInvPossessionsSlotName(slot_iter)
EQ::invslot::GetInvPossessionsSlotName(slot_iter)
);
bot_iter->DoAnim(29);
}
@@ -4307,7 +4307,7 @@ void bot_command_pull(Client *c, const Seperator *sep)
Bot* bot_puller = nullptr;
for (auto bot_iter : sbl) {
if (bot_iter->GetAppearance() == eaDead || bot_iter->GetBotStance() == EQEmu::constants::stancePassive) {
if (bot_iter->GetAppearance() == eaDead || bot_iter->GetBotStance() == EQ::constants::stancePassive) {
continue;
}
@@ -4774,7 +4774,7 @@ void bot_command_taunt(Client *c, const Seperator *sep)
int taunting_count = 0;
for (auto bot_iter : sbl) {
if (!bot_iter->GetSkill(EQEmu::skills::SkillTaunt))
if (!bot_iter->GetSkill(EQ::skills::SkillTaunt))
continue;
if (toggle_taunt)
@@ -5094,7 +5094,7 @@ void bot_subcommand_bot_clone(Client *c, const Seperator *sep)
return;
}
int clone_stance = EQEmu::constants::stancePassive;
int clone_stance = EQ::constants::stancePassive;
if (!database.botdb.LoadStance(my_bot->GetBotID(), clone_stance))
c->Message(m_fail, "%s for bot '%s'", BotDatabase::fail::LoadStance(), my_bot->GetCleanName());
if (!database.botdb.SaveStance(clone_id, clone_stance))
@@ -5298,7 +5298,7 @@ void bot_subcommand_bot_dye_armor(Client *c, const Seperator *sep)
// TODO: Trouble-shoot model update issue
const std::string msg_matslot = StringFormat("mat_slot: %c(All), %i(Head), %i(Chest), %i(Arms), %i(Wrists), %i(Hands), %i(Legs), %i(Feet)",
'*', EQEmu::textures::armorHead, EQEmu::textures::armorChest, EQEmu::textures::armorArms, EQEmu::textures::armorWrist, EQEmu::textures::armorHands, EQEmu::textures::armorLegs, EQEmu::textures::armorFeet);
'*', EQ::textures::armorHead, EQ::textures::armorChest, EQ::textures::armorArms, EQ::textures::armorWrist, EQ::textures::armorHands, EQ::textures::armorLegs, EQ::textures::armorFeet);
if (helper_command_alias_fail(c, "bot_subcommand_bot_dye_armor", sep->arg[0], "botdyearmor"))
return;
@@ -5309,15 +5309,15 @@ void bot_subcommand_bot_dye_armor(Client *c, const Seperator *sep)
}
const int ab_mask = ActionableBots::ABM_NoFilter;
uint8 material_slot = EQEmu::textures::materialInvalid;
uint8 material_slot = EQ::textures::materialInvalid;
int16 slot_id = INVALID_INDEX;
bool dye_all = (sep->arg[1][0] == '*');
if (!dye_all) {
material_slot = atoi(sep->arg[1]);
slot_id = EQEmu::InventoryProfile::CalcSlotFromMaterial(material_slot);
slot_id = EQ::InventoryProfile::CalcSlotFromMaterial(material_slot);
if (!sep->IsNumber(1) || slot_id == INVALID_INDEX || material_slot > EQEmu::textures::LastTintableTexture) {
if (!sep->IsNumber(1) || slot_id == INVALID_INDEX || material_slot > EQ::textures::LastTintableTexture) {
c->Message(m_fail, "Valid [mat_slot]s for this command are:");
c->Message(m_fail, msg_matslot.c_str());
return;
@@ -5654,7 +5654,7 @@ void bot_subcommand_bot_inspect_message(Client *c, const Seperator *sep)
if (helper_is_help_or_usage(sep->arg[1])) {
c->Message(m_usage, "usage: %s [set | clear] ([actionable: target | byname | ownergroup | botgroup | targetgroup | namesgroup | healrotation | spawned] ([actionable_name]))", sep->arg[0]);
c->Message(m_note, "Notes:");
if (c->ClientVersion() >= EQEmu::versions::ClientVersion::SoF) {
if (c->ClientVersion() >= EQ::versions::ClientVersion::SoF) {
c->Message(m_message, "- Self-inspect and type your bot's inspect message");
c->Message(m_message, "- Close the self-inspect window to update the server");
c->Message(m_message, "- Type '%s set' to set the bot's inspect message", sep->arg[0]);
@@ -5799,7 +5799,7 @@ void bot_subcommand_bot_list(Client *c, const Seperator *sep)
Bot * botCheckNotOnline = entity_list.GetBotByBotName(bots_iter.Name);
std::string botspawn_saylink = StringFormat("^botspawn %s", bots_iter.Name);
c->Message(Chat::White, "[%s] is a level %u %s %s %s who is owned by %s",
((c->CharacterID() == bots_iter.Owner_ID) && (!botCheckNotOnline) ? (EQEmu::SayLinkEngine::GenerateQuestSaylink(botspawn_saylink, false, bots_iter.Name).c_str()) : (bots_iter.Name)),
((c->CharacterID() == bots_iter.Owner_ID) && (!botCheckNotOnline) ? (EQ::SayLinkEngine::GenerateQuestSaylink(botspawn_saylink, false, bots_iter.Name).c_str()) : (bots_iter.Name)),
bots_iter.Level,
Bot::RaceIdToString(bots_iter.Race).c_str(),
((bots_iter.Gender == FEMALE) ? ("Female") : ((bots_iter.Gender == MALE) ? ("Male") : ("Neuter"))),
@@ -6127,32 +6127,32 @@ void bot_subcommand_bot_stance(Client *c, const Seperator *sep)
if (helper_is_help_or_usage(sep->arg[1])) {
c->Message(m_usage, "usage: %s [current | value: 1-9] ([actionable: target | byname] ([actionable_name]))", sep->arg[0]);
c->Message(m_note, "value: %u(%s), %u(%s), %u(%s), %u(%s), %u(%s), %u(%s), %u(%s)",
EQEmu::constants::stancePassive, EQEmu::constants::GetStanceName(EQEmu::constants::stancePassive),
EQEmu::constants::stanceBalanced, EQEmu::constants::GetStanceName(EQEmu::constants::stanceBalanced),
EQEmu::constants::stanceEfficient, EQEmu::constants::GetStanceName(EQEmu::constants::stanceEfficient),
EQEmu::constants::stanceReactive, EQEmu::constants::GetStanceName(EQEmu::constants::stanceReactive),
EQEmu::constants::stanceAggressive, EQEmu::constants::GetStanceName(EQEmu::constants::stanceAggressive),
EQEmu::constants::stanceAssist, EQEmu::constants::GetStanceName(EQEmu::constants::stanceAssist),
EQEmu::constants::stanceBurn, EQEmu::constants::GetStanceName(EQEmu::constants::stanceBurn),
EQEmu::constants::stanceEfficient2, EQEmu::constants::GetStanceName(EQEmu::constants::stanceEfficient2),
EQEmu::constants::stanceBurnAE, EQEmu::constants::GetStanceName(EQEmu::constants::stanceBurnAE)
EQ::constants::stancePassive, EQ::constants::GetStanceName(EQ::constants::stancePassive),
EQ::constants::stanceBalanced, EQ::constants::GetStanceName(EQ::constants::stanceBalanced),
EQ::constants::stanceEfficient, EQ::constants::GetStanceName(EQ::constants::stanceEfficient),
EQ::constants::stanceReactive, EQ::constants::GetStanceName(EQ::constants::stanceReactive),
EQ::constants::stanceAggressive, EQ::constants::GetStanceName(EQ::constants::stanceAggressive),
EQ::constants::stanceAssist, EQ::constants::GetStanceName(EQ::constants::stanceAssist),
EQ::constants::stanceBurn, EQ::constants::GetStanceName(EQ::constants::stanceBurn),
EQ::constants::stanceEfficient2, EQ::constants::GetStanceName(EQ::constants::stanceEfficient2),
EQ::constants::stanceBurnAE, EQ::constants::GetStanceName(EQ::constants::stanceBurnAE)
);
return;
}
int ab_mask = (ActionableBots::ABM_Target | ActionableBots::ABM_ByName);
bool current_flag = false;
auto bst = EQEmu::constants::stanceUnknown;
auto bst = EQ::constants::stanceUnknown;
if (!strcasecmp(sep->arg[1], "current"))
current_flag = true;
else if (sep->IsNumber(1)) {
bst = (EQEmu::constants::StanceType)atoi(sep->arg[1]);
if (bst < EQEmu::constants::stanceUnknown || bst > EQEmu::constants::stanceBurnAE)
bst = EQEmu::constants::stanceUnknown;
bst = (EQ::constants::StanceType)atoi(sep->arg[1]);
if (bst < EQ::constants::stanceUnknown || bst > EQ::constants::stanceBurnAE)
bst = EQ::constants::stanceUnknown;
}
if (!current_flag && bst == EQEmu::constants::stanceUnknown) {
if (!current_flag && bst == EQ::constants::stanceUnknown) {
c->Message(m_fail, "A [current] argument or valid numeric [value] is required to use this command");
return;
}
@@ -6173,7 +6173,7 @@ void bot_subcommand_bot_stance(Client *c, const Seperator *sep)
Bot::BotGroupSay(
bot_iter,
"My current stance is '%s' (%i)",
EQEmu::constants::GetStanceName(bot_iter->GetBotStance()),
EQ::constants::GetStanceName(bot_iter->GetBotStance()),
bot_iter->GetBotStance()
);
}
@@ -8181,31 +8181,31 @@ void bot_subcommand_inventory_list(Client *c, const Seperator *sep)
return;
}
const EQEmu::ItemInstance* inst = nullptr;
const EQEmu::ItemData* item = nullptr;
const EQ::ItemInstance* inst = nullptr;
const EQ::ItemData* item = nullptr;
bool is2Hweapon = false;
EQEmu::SayLinkEngine linker;
linker.SetLinkType(EQEmu::saylink::SayLinkItemInst);
EQ::SayLinkEngine linker;
linker.SetLinkType(EQ::saylink::SayLinkItemInst);
uint32 inventory_count = 0;
for (int i = EQEmu::invslot::EQUIPMENT_BEGIN; i <= EQEmu::invslot::EQUIPMENT_END; ++i) {
if ((i == EQEmu::invslot::slotSecondary) && is2Hweapon)
for (int i = EQ::invslot::EQUIPMENT_BEGIN; i <= EQ::invslot::EQUIPMENT_END; ++i) {
if ((i == EQ::invslot::slotSecondary) && is2Hweapon)
continue;
inst = my_bot->CastToBot()->GetBotItem(i);
if (!inst || !inst->GetItem()) {
c->Message(m_message, "I need something for my %s (slot %i)", EQEmu::invslot::GetInvPossessionsSlotName(i), i);
c->Message(m_message, "I need something for my %s (slot %i)", EQ::invslot::GetInvPossessionsSlotName(i), i);
continue;
}
item = inst->GetItem();
if ((i == EQEmu::invslot::slotPrimary) && item->IsType2HWeapon()) {
if ((i == EQ::invslot::slotPrimary) && item->IsType2HWeapon()) {
is2Hweapon = true;
}
linker.SetItemInst(inst);
c->Message(m_message, "Using %s in my %s (slot %i)", linker.GenerateLink().c_str(), EQEmu::invslot::GetInvPossessionsSlotName(i), i);
c->Message(m_message, "Using %s in my %s (slot %i)", linker.GenerateLink().c_str(), EQ::invslot::GetInvPossessionsSlotName(i), i);
++inventory_count;
}
@@ -8244,13 +8244,13 @@ void bot_subcommand_inventory_remove(Client *c, const Seperator *sep)
}
int slotId = atoi(sep->arg[1]);
if (!sep->IsNumber(1) || (slotId > EQEmu::invslot::EQUIPMENT_END || slotId < EQEmu::invslot::EQUIPMENT_BEGIN)) {
if (!sep->IsNumber(1) || (slotId > EQ::invslot::EQUIPMENT_END || slotId < EQ::invslot::EQUIPMENT_BEGIN)) {
c->Message(m_fail, "Valid slots are 0-22");
return;
}
const EQEmu::ItemData* itm = nullptr;
const EQEmu::ItemInstance* itminst = my_bot->GetBotItem(slotId);
const EQ::ItemData* itm = nullptr;
const EQ::ItemInstance* itminst = my_bot->GetBotItem(slotId);
if (itminst)
itm = itminst->GetItem();
@@ -8259,11 +8259,11 @@ void bot_subcommand_inventory_remove(Client *c, const Seperator *sep)
return;
}
for (int m = EQEmu::invaug::SOCKET_BEGIN; m <= EQEmu::invaug::SOCKET_END; ++m) {
for (int m = EQ::invaug::SOCKET_BEGIN; m <= EQ::invaug::SOCKET_END; ++m) {
if (!itminst)
break;
EQEmu::ItemInstance *itma = itminst->GetAugment(m);
EQ::ItemInstance *itma = itminst->GetAugment(m);
if (!itma)
continue;
if (!c->CheckLoreConflict(itma->GetItem()))
@@ -8276,7 +8276,7 @@ void bot_subcommand_inventory_remove(Client *c, const Seperator *sep)
std::string error_message;
if (itm) {
c->PushItemOnCursor(*itminst, true);
if ((slotId == EQEmu::invslot::slotRange) || (slotId == EQEmu::invslot::slotAmmo) || (slotId == EQEmu::invslot::slotPrimary) || (slotId == EQEmu::invslot::slotSecondary))
if ((slotId == EQ::invslot::slotRange) || (slotId == EQ::invslot::slotAmmo) || (slotId == EQ::invslot::slotPrimary) || (slotId == EQ::invslot::slotSecondary))
my_bot->SetBotArcher(false);
my_bot->RemoveBotItemBySlot(slotId, &error_message);
@@ -8290,32 +8290,32 @@ void bot_subcommand_inventory_remove(Client *c, const Seperator *sep)
}
switch (slotId) {
case EQEmu::invslot::slotCharm:
case EQEmu::invslot::slotEar1:
case EQEmu::invslot::slotHead:
case EQEmu::invslot::slotFace:
case EQEmu::invslot::slotEar2:
case EQEmu::invslot::slotNeck:
case EQEmu::invslot::slotBack:
case EQEmu::invslot::slotWrist1:
case EQEmu::invslot::slotWrist2:
case EQEmu::invslot::slotRange:
case EQEmu::invslot::slotPrimary:
case EQEmu::invslot::slotSecondary:
case EQEmu::invslot::slotFinger1:
case EQEmu::invslot::slotFinger2:
case EQEmu::invslot::slotChest:
case EQEmu::invslot::slotWaist:
case EQEmu::invslot::slotPowerSource:
case EQEmu::invslot::slotAmmo:
c->Message(m_message, "My %s is %s unequipped", EQEmu::invslot::GetInvPossessionsSlotName(slotId), ((itm) ? ("now") : ("already")));
case EQ::invslot::slotCharm:
case EQ::invslot::slotEar1:
case EQ::invslot::slotHead:
case EQ::invslot::slotFace:
case EQ::invslot::slotEar2:
case EQ::invslot::slotNeck:
case EQ::invslot::slotBack:
case EQ::invslot::slotWrist1:
case EQ::invslot::slotWrist2:
case EQ::invslot::slotRange:
case EQ::invslot::slotPrimary:
case EQ::invslot::slotSecondary:
case EQ::invslot::slotFinger1:
case EQ::invslot::slotFinger2:
case EQ::invslot::slotChest:
case EQ::invslot::slotWaist:
case EQ::invslot::slotPowerSource:
case EQ::invslot::slotAmmo:
c->Message(m_message, "My %s is %s unequipped", EQ::invslot::GetInvPossessionsSlotName(slotId), ((itm) ? ("now") : ("already")));
break;
case EQEmu::invslot::slotShoulders:
case EQEmu::invslot::slotArms:
case EQEmu::invslot::slotHands:
case EQEmu::invslot::slotLegs:
case EQEmu::invslot::slotFeet:
c->Message(m_message, "My %s are %s unequipped", EQEmu::invslot::GetInvPossessionsSlotName(slotId), ((itm) ? ("now") : ("already")));
case EQ::invslot::slotShoulders:
case EQ::invslot::slotArms:
case EQ::invslot::slotHands:
case EQ::invslot::slotLegs:
case EQ::invslot::slotFeet:
c->Message(m_message, "My %s are %s unequipped", EQ::invslot::GetInvPossessionsSlotName(slotId), ((itm) ? ("now") : ("already")));
break;
default:
c->Message(m_fail, "I'm soo confused...");
@@ -8348,17 +8348,17 @@ void bot_subcommand_inventory_window(Client *c, const Seperator *sep)
std::string window_text;
//std::string item_link;
//EQEmu::SayLinkEngine linker;
//linker.SetLinkType(EQEmu::saylink::SayLinkItemInst);
//EQ::SayLinkEngine linker;
//linker.SetLinkType(EQ::saylink::SayLinkItemInst);
for (int i = EQEmu::invslot::EQUIPMENT_BEGIN; i <= EQEmu::invslot::EQUIPMENT_END; ++i) {
const EQEmu::ItemData* item = nullptr;
const EQEmu::ItemInstance* inst = my_bot->CastToBot()->GetBotItem(i);
for (int i = EQ::invslot::EQUIPMENT_BEGIN; i <= EQ::invslot::EQUIPMENT_END; ++i) {
const EQ::ItemData* item = nullptr;
const EQ::ItemInstance* inst = my_bot->CastToBot()->GetBotItem(i);
if (inst)
item = inst->GetItem();
window_text.append("<c \"#FFFFFF\">");
window_text.append(EQEmu::invslot::GetInvPossessionsSlotName(i));
window_text.append(EQ::invslot::GetInvPossessionsSlotName(i));
window_text.append(": ");
if (item) {
//window_text.append("</c>");
@@ -8840,7 +8840,7 @@ bool helper_cast_standard_spell(Bot* casting_bot, Mob* target_mob, int spell_id,
if (annouce_cast)
Bot::BotGroupSay(casting_bot, "Attempting to cast '%s' on %s", spells[spell_id].name, target_mob->GetCleanName());
return casting_bot->CastSpell(spell_id, target_mob->GetID(), EQEmu::spells::CastingSlot::Gem2, -1, -1, dont_root_before);
return casting_bot->CastSpell(spell_id, target_mob->GetID(), EQ::spells::CastingSlot::Gem2, -1, -1, dont_root_before);
}
bool helper_command_disabled(Client* bot_owner, bool rule_value, const char* command)
zone/bot_database.cpp
+21 -21
View File
@@ -145,7 +145,7 @@ bool BotDatabase::LoadBotSpellCastingChances()
continue;
--class_index;
uint8 stance_index = atoi(row[2]);
if (stance_index >= EQEmu::constants::STANCE_TYPE_COUNT)
if (stance_index >= EQ::constants::STANCE_TYPE_COUNT)
continue;
for (uint8 conditional_index = nHSND; conditional_index < cntHSND; ++conditional_index) {
@@ -914,7 +914,7 @@ bool BotDatabase::LoadStance(Bot* bot_inst, bool& stance_flag)
return true;
auto row = results.begin();
bot_inst->SetBotStance((EQEmu::constants::StanceType)atoi(row[0]));
bot_inst->SetBotStance((EQ::constants::StanceType)atoi(row[0]));
stance_flag = true;
return true;
@@ -1141,7 +1141,7 @@ bool BotDatabase::QueryInventoryCount(const uint32 bot_id, uint32& item_count)
return true;
}
bool BotDatabase::LoadItems(const uint32 bot_id, EQEmu::InventoryProfile& inventory_inst)
bool BotDatabase::LoadItems(const uint32 bot_id, EQ::InventoryProfile& inventory_inst)
{
if (!bot_id)
return false;
@@ -1176,13 +1176,13 @@ bool BotDatabase::LoadItems(const uint32 bot_id, EQEmu::InventoryProfile& invent
for (auto row = results.begin(); row != results.end(); ++row) {
int16 slot_id = atoi(row[0]);
if (slot_id < EQEmu::invslot::EQUIPMENT_BEGIN || slot_id > EQEmu::invslot::EQUIPMENT_END)
if (slot_id < EQ::invslot::EQUIPMENT_BEGIN || slot_id > EQ::invslot::EQUIPMENT_END)
continue;
uint32 item_id = atoi(row[1]);
uint16 item_charges = (uint16)atoi(row[2]);
EQEmu::ItemInstance* item_inst = database.CreateItem(
EQ::ItemInstance* item_inst = database.CreateItem(
item_id,
item_charges,
(uint32)atoul(row[9]),
@@ -1211,7 +1211,7 @@ bool BotDatabase::LoadItems(const uint32 bot_id, EQEmu::InventoryProfile& invent
if (item_inst->GetItem()->Attuneable) {
if (atoi(row[4]))
item_inst->SetAttuned(true);
else if (slot_id >= EQEmu::invslot::EQUIPMENT_BEGIN && slot_id <= EQEmu::invslot::EQUIPMENT_END)
else if (slot_id >= EQ::invslot::EQUIPMENT_BEGIN && slot_id <= EQ::invslot::EQUIPMENT_END)
item_inst->SetAttuned(true);
}
@@ -1279,7 +1279,7 @@ bool BotDatabase::LoadItemBySlot(Bot* bot_inst)
bool BotDatabase::LoadItemBySlot(const uint32 bot_id, const uint32 slot_id, uint32& item_id)
{
if (!bot_id || slot_id > EQEmu::invslot::EQUIPMENT_END)
if (!bot_id || slot_id > EQ::invslot::EQUIPMENT_END)
return false;
query = StringFormat("SELECT `item_id` FROM `bot_inventories` WHERE `bot_id` = '%i' AND `slot_id` = '%i' LIMIT 1", bot_id, slot_id);
@@ -1295,9 +1295,9 @@ bool BotDatabase::LoadItemBySlot(const uint32 bot_id, const uint32 slot_id, uint
return true;
}
bool BotDatabase::SaveItemBySlot(Bot* bot_inst, const uint32 slot_id, const EQEmu::ItemInstance* item_inst)
bool BotDatabase::SaveItemBySlot(Bot* bot_inst, const uint32 slot_id, const EQ::ItemInstance* item_inst)
{
if (!bot_inst || !bot_inst->GetBotID() || slot_id > EQEmu::invslot::EQUIPMENT_END)
if (!bot_inst || !bot_inst->GetBotID() || slot_id > EQ::invslot::EQUIPMENT_END)
return false;
if (!DeleteItemBySlot(bot_inst->GetBotID(), slot_id))
@@ -1306,8 +1306,8 @@ bool BotDatabase::SaveItemBySlot(Bot* bot_inst, const uint32 slot_id, const EQEm
if (!item_inst || !item_inst->GetID())
return true;
uint32 augment_id[EQEmu::invaug::SOCKET_COUNT] = { 0, 0, 0, 0, 0, 0 };
for (int augment_iter = EQEmu::invaug::SOCKET_BEGIN; augment_iter <= EQEmu::invaug::SOCKET_END; ++augment_iter)
uint32 augment_id[EQ::invaug::SOCKET_COUNT] = { 0, 0, 0, 0, 0, 0 };
for (int augment_iter = EQ::invaug::SOCKET_BEGIN; augment_iter <= EQ::invaug::SOCKET_END; ++augment_iter)
augment_id[augment_iter] = item_inst->GetAugmentItemID(augment_iter);
uint16 item_charges = 0;
@@ -1381,7 +1381,7 @@ bool BotDatabase::SaveItemBySlot(Bot* bot_inst, const uint32 slot_id, const EQEm
bool BotDatabase::DeleteItemBySlot(const uint32 bot_id, const uint32 slot_id)
{
if (!bot_id || slot_id > EQEmu::invslot::EQUIPMENT_END)
if (!bot_id || slot_id > EQ::invslot::EQUIPMENT_END)
return false;
query = StringFormat("DELETE FROM `bot_inventories` WHERE `bot_id` = '%u' AND `slot_id` = '%u'", bot_id, slot_id);
@@ -1397,7 +1397,7 @@ bool BotDatabase::LoadEquipmentColor(const uint32 bot_id, const uint8 material_s
if (!bot_id)
return false;
int16 slot_id = EQEmu::InventoryProfile::CalcSlotFromMaterial(material_slot_id);
int16 slot_id = EQ::InventoryProfile::CalcSlotFromMaterial(material_slot_id);
if (slot_id == INVALID_INDEX)
return false;
@@ -1420,12 +1420,12 @@ bool BotDatabase::SaveEquipmentColor(const uint32 bot_id, const int16 slot_id, c
return false;
bool all_flag = (slot_id == -2);
if ((slot_id < EQEmu::invslot::EQUIPMENT_BEGIN || slot_id > EQEmu::invslot::EQUIPMENT_END) && !all_flag)
if ((slot_id < EQ::invslot::EQUIPMENT_BEGIN || slot_id > EQ::invslot::EQUIPMENT_END) && !all_flag)
return false;
std::string where_clause;
if (all_flag)
where_clause = StringFormat(" AND `slot_id` IN ('%u', '%u', '%u', '%u', '%u', '%u', '%u')", EQEmu::invslot::slotHead, EQEmu::invslot::slotArms, EQEmu::invslot::slotWrist1, EQEmu::invslot::slotHands, EQEmu::invslot::slotChest, EQEmu::invslot::slotLegs, EQEmu::invslot::slotFeet);
where_clause = StringFormat(" AND `slot_id` IN ('%u', '%u', '%u', '%u', '%u', '%u', '%u')", EQ::invslot::slotHead, EQ::invslot::slotArms, EQ::invslot::slotWrist1, EQ::invslot::slotHands, EQ::invslot::slotChest, EQ::invslot::slotLegs, EQ::invslot::slotFeet);
else
where_clause = StringFormat(" AND `slot_id` = '%u'", slot_id);
@@ -1696,8 +1696,8 @@ bool BotDatabase::LoadPetItems(const uint32 bot_id, uint32* pet_items)
if (!results.RowCount())
return true;
int item_index = EQEmu::invslot::EQUIPMENT_BEGIN;
for (auto row = results.begin(); row != results.end() && (item_index >= EQEmu::invslot::EQUIPMENT_BEGIN && item_index <= EQEmu::invslot::EQUIPMENT_END); ++row) {
int item_index = EQ::invslot::EQUIPMENT_BEGIN;
for (auto row = results.begin(); row != results.end() && (item_index >= EQ::invslot::EQUIPMENT_BEGIN && item_index <= EQ::invslot::EQUIPMENT_END); ++row) {
pet_items[item_index] = atoi(row[0]);
++item_index;
}
@@ -1721,7 +1721,7 @@ bool BotDatabase::SavePetItems(const uint32 bot_id, const uint32* pet_items, boo
if (!saved_pet_index)
return true;
for (int item_index = EQEmu::invslot::EQUIPMENT_BEGIN; item_index <= EQEmu::invslot::EQUIPMENT_END; ++item_index) {
for (int item_index = EQ::invslot::EQUIPMENT_BEGIN; item_index <= EQ::invslot::EQUIPMENT_END; ++item_index) {
if (!pet_items[item_index])
continue;
@@ -1870,7 +1870,7 @@ bool BotDatabase::SaveAllArmorColorBySlot(const uint32 owner_id, const int16 slo
" AND bi.`slot_id` = '%i'",
owner_id,
rgb_value,
EQEmu::invslot::slotHead, EQEmu::invslot::slotChest, EQEmu::invslot::slotArms, EQEmu::invslot::slotWrist1, EQEmu::invslot::slotWrist2, EQEmu::invslot::slotHands, EQEmu::invslot::slotLegs, EQEmu::invslot::slotFeet,
EQ::invslot::slotHead, EQ::invslot::slotChest, EQ::invslot::slotArms, EQ::invslot::slotWrist1, EQ::invslot::slotWrist2, EQ::invslot::slotHands, EQ::invslot::slotLegs, EQ::invslot::slotFeet,
slot_id
);
auto results = database.QueryDatabase(query);
@@ -1894,7 +1894,7 @@ bool BotDatabase::SaveAllArmorColors(const uint32 owner_id, const uint32 rgb_val
" AND bi.`slot_id` IN ('%u', '%u', '%u', '%u', '%u', '%u', '%u', '%u')",
owner_id,
rgb_value,
EQEmu::invslot::slotHead, EQEmu::invslot::slotChest, EQEmu::invslot::slotArms, EQEmu::invslot::slotWrist1, EQEmu::invslot::slotWrist2, EQEmu::invslot::slotHands, EQEmu::invslot::slotLegs, EQEmu::invslot::slotFeet
EQ::invslot::slotHead, EQ::invslot::slotChest, EQ::invslot::slotArms, EQ::invslot::slotWrist1, EQ::invslot::slotWrist2, EQ::invslot::slotHands, EQ::invslot::slotLegs, EQ::invslot::slotFeet
);
auto results = database.QueryDatabase(query);
if (!results.Success())
@@ -2944,7 +2944,7 @@ uint8 BotDatabase::GetSpellCastingChance(uint8 spell_type_index, uint8 class_ind
return 0;
if (class_index >= PLAYER_CLASS_COUNT)
return 0;
if (stance_index >= EQEmu::constants::STANCE_TYPE_COUNT)
if (stance_index >= EQ::constants::STANCE_TYPE_COUNT)
return 0;
if (conditional_index >= cntHSND)
return 0;
zone/bot_database.h
+3 -3
View File
@@ -32,7 +32,7 @@ class Client;
struct BotsAvailableList;
struct InspectMessage_Struct;
namespace EQEmu
namespace EQ
{
class ItemInstance;
class InventoryProfile;
@@ -85,13 +85,13 @@ public:
/* Bot inventory functions */
bool QueryInventoryCount(const uint32 bot_id, uint32& item_count);
bool LoadItems(const uint32 bot_id, EQEmu::InventoryProfile &inventory_inst);
bool LoadItems(const uint32 bot_id, EQ::InventoryProfile &inventory_inst);
bool SaveItems(Bot* bot_inst);
bool DeleteItems(const uint32 bot_id);
bool LoadItemBySlot(Bot* bot_inst);
bool LoadItemBySlot(const uint32 bot_id, const uint32 slot_id, uint32& item_id);
bool SaveItemBySlot(Bot* bot_inst, const uint32 slot_id, const EQEmu::ItemInstance* item_inst);
bool SaveItemBySlot(Bot* bot_inst, const uint32 slot_id, const EQ::ItemInstance* item_inst);
bool DeleteItemBySlot(const uint32 bot_id, const uint32 slot_id);
bool LoadEquipmentColor(const uint32 bot_id, const uint8 material_slot_id, uint32& rgb);
zone/botspellsai.cpp
+22 -22
View File
@@ -193,18 +193,18 @@ bool Bot::AICastSpell(Mob* tar, uint8 iChance, uint32 iSpellTypes) {
float hpRatioToCast = 0.0f;
switch(this->GetBotStance()) {
case EQEmu::constants::stanceEfficient:
case EQEmu::constants::stanceAggressive:
case EQ::constants::stanceEfficient:
case EQ::constants::stanceAggressive:
hpRatioToCast = isPrimaryHealer?90.0f:50.0f;
break;
case EQEmu::constants::stanceBalanced:
case EQ::constants::stanceBalanced:
hpRatioToCast = isPrimaryHealer?95.0f:75.0f;
break;
case EQEmu::constants::stanceReactive:
case EQ::constants::stanceReactive:
hpRatioToCast = isPrimaryHealer?100.0f:90.0f;
break;
case EQEmu::constants::stanceBurn:
case EQEmu::constants::stanceBurnAE:
case EQ::constants::stanceBurn:
case EQ::constants::stanceBurnAE:
hpRatioToCast = isPrimaryHealer?75.0f:25.0f;
break;
default:
@@ -381,16 +381,16 @@ bool Bot::AICastSpell(Mob* tar, uint8 iChance, uint32 iSpellTypes) {
float manaRatioToCast = 75.0f;
switch(this->GetBotStance()) {
case EQEmu::constants::stanceEfficient:
case EQ::constants::stanceEfficient:
manaRatioToCast = 90.0f;
break;
case EQEmu::constants::stanceBalanced:
case EQEmu::constants::stanceAggressive:
case EQ::constants::stanceBalanced:
case EQ::constants::stanceAggressive:
manaRatioToCast = 75.0f;
break;
case EQEmu::constants::stanceReactive:
case EQEmu::constants::stanceBurn:
case EQEmu::constants::stanceBurnAE:
case EQ::constants::stanceReactive:
case EQ::constants::stanceBurn:
case EQ::constants::stanceBurnAE:
manaRatioToCast = 50.0f;
break;
default:
@@ -460,18 +460,18 @@ bool Bot::AICastSpell(Mob* tar, uint8 iChance, uint32 iSpellTypes) {
float manaRatioToCast = 75.0f;
switch(this->GetBotStance()) {
case EQEmu::constants::stanceEfficient:
case EQ::constants::stanceEfficient:
manaRatioToCast = 90.0f;
break;
case EQEmu::constants::stanceBalanced:
case EQ::constants::stanceBalanced:
manaRatioToCast = 75.0f;
break;
case EQEmu::constants::stanceReactive:
case EQEmu::constants::stanceAggressive:
case EQ::constants::stanceReactive:
case EQ::constants::stanceAggressive:
manaRatioToCast = 50.0f;
break;
case EQEmu::constants::stanceBurn:
case EQEmu::constants::stanceBurnAE:
case EQ::constants::stanceBurn:
case EQ::constants::stanceBurnAE:
manaRatioToCast = 25.0f;
break;
default:
@@ -1310,7 +1310,7 @@ bool Bot::AI_EngagedCastCheck() {
AIautocastspell_timer->Disable(); //prevent the timer from going off AGAIN while we are casting.
uint8 botClass = GetClass();
EQEmu::constants::StanceType botStance = GetBotStance();
EQ::constants::StanceType botStance = GetBotStance();
bool mayGetAggro = HasOrMayGetAggro();
LogAI("Engaged autocast check triggered (BOTS). Trying to cast healing spells then maybe offensive spells");
@@ -2653,11 +2653,11 @@ uint8 Bot::GetChanceToCastBySpellType(uint32 spellType)
return 0;
--class_index;
EQEmu::constants::StanceType stance_type = GetBotStance();
if (stance_type < EQEmu::constants::stancePassive || stance_type > EQEmu::constants::stanceBurnAE)
EQ::constants::StanceType stance_type = GetBotStance();
if (stance_type < EQ::constants::stancePassive || stance_type > EQ::constants::stanceBurnAE)
return 0;
uint8 stance_index = EQEmu::constants::ConvertStanceTypeToIndex(stance_type);
uint8 stance_index = EQ::constants::ConvertStanceTypeToIndex(stance_type);
uint8 type_index = nHSND;
if (HasGroup()) {
zone/client.cpp
+218 -218
View File
File diff suppressed because it is too large Load Diff
zone/client.h
+66 -66
View File
@@ -29,7 +29,7 @@ class Seperator;
class ServerPacket;
enum WaterRegionType : int;
namespace EQEmu
namespace EQ
{
struct ItemData;
}
@@ -240,9 +240,9 @@ public:
bool GotoPlayer(std::string player_name);
//abstract virtual function implementations required by base abstract class
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, eSpecialAttacks special = eSpecialAttacks::None);
virtual bool Attack(Mob* other, int Hand = EQEmu::invslot::slotPrimary, bool FromRiposte = false, bool IsStrikethrough = false, bool IsFromSpell = false,
virtual bool Death(Mob* killerMob, int32 damage, uint16 spell_id, EQ::skills::SkillType attack_skill);
virtual void Damage(Mob* from, int32 damage, uint16 spell_id, EQ::skills::SkillType attack_skill, bool avoidable = true, int8 buffslot = -1, bool iBuffTic = false, eSpecialAttacks special = eSpecialAttacks::None);
virtual bool Attack(Mob* other, int Hand = EQ::invslot::slotPrimary, bool FromRiposte = false, bool IsStrikethrough = false, bool IsFromSpell = false,
ExtraAttackOptions *opts = nullptr);
virtual bool HasRaid() { return (GetRaid() ? true : false); }
virtual bool HasGroup() { return (GetGroup() ? true : false); }
@@ -270,12 +270,12 @@ public:
void KeyRingList();
virtual bool IsClient() const { return true; }
void CompleteConnect();
bool TryStacking(EQEmu::ItemInstance* item, uint8 type = ItemPacketTrade, bool try_worn = true, bool try_cursor = true);
bool TryStacking(EQ::ItemInstance* item, uint8 type = ItemPacketTrade, bool try_worn = true, bool try_cursor = true);
void SendTraderPacket(Client* trader, uint32 Unknown72 = 51);
void SendBuyerPacket(Client* Buyer);
GetItems_Struct* GetTraderItems();
void SendBazaarWelcome();
void DyeArmor(EQEmu::TintProfile* dye);
void DyeArmor(EQ::TintProfile* dye);
uint8 SlotConvert(uint8 slot,bool bracer=false);
void MessageString(uint32 type, uint32 string_id, uint32 distance = 0);
void MessageString(uint32 type, uint32 string_id, const char* message,const char* message2=0,const char* message3=0,const char* message4=0,const char* message5=0,const char* message6=0,const char* message7=0,const char* message8=0,const char* message9=0, uint32 distance = 0);
@@ -293,7 +293,7 @@ public:
void SendTraderItem(uint32 item_id,uint16 quantity);
uint16 FindTraderItem(int32 SerialNumber,uint16 Quantity);
uint32 FindTraderItemSerialNumber(int32 ItemID);
EQEmu::ItemInstance* FindTraderItemBySerialNumber(int32 SerialNumber);
EQ::ItemInstance* FindTraderItemBySerialNumber(int32 SerialNumber);
void FindAndNukeTraderItem(int32 item_id,uint16 quantity,Client* customer,uint16 traderslot);
void NukeTraderItem(uint16 slot, int16 charges, uint16 quantity, Client* customer, uint16 traderslot, int32 uniqueid, int32 itemid = 0);
void ReturnTraderReq(const EQApplicationPacket* app,int16 traderitemcharges, uint32 itemid = 0);
@@ -316,7 +316,7 @@ public:
bool ShouldISpawnFor(Client *c) { return !GMHideMe(c) && !IsHoveringForRespawn(); }
virtual bool Process();
void ProcessPackets();
void LogMerchant(Client* player, Mob* merchant, uint32 quantity, uint32 price, const EQEmu::ItemData* item, bool buying);
void LogMerchant(Client* player, Mob* merchant, uint32 quantity, uint32 price, const EQ::ItemData* item, bool buying);
void QueuePacket(const EQApplicationPacket* app, bool ack_req = true, CLIENT_CONN_STATUS = CLIENT_CONNECTINGALL, eqFilterType filter=FilterNone);
void FastQueuePacket(EQApplicationPacket** app, bool ack_req = true, CLIENT_CONN_STATUS = CLIENT_CONNECTINGALL);
void ChannelMessageReceived(uint8 chan_num, uint8 language, uint8 lang_skill, const char* orig_message, const char* targetname=nullptr);
@@ -326,9 +326,9 @@ public:
void VoiceMacroReceived(uint32 Type, char *Target, uint32 MacroNumber);
void SendSound();
void LearnRecipe(uint32 recipeID);
bool CanIncreaseTradeskill(EQEmu::skills::SkillType tradeskill);
bool CanIncreaseTradeskill(EQ::skills::SkillType tradeskill);
EQApplicationPacket* ReturnItemPacket(int16 slot_id, const EQEmu::ItemInstance* inst, ItemPacketType packet_type);
EQApplicationPacket* ReturnItemPacket(int16 slot_id, const EQ::ItemInstance* inst, ItemPacketType packet_type);
bool GetRevoked() const { return revoked; }
void SetRevoked(bool rev) { revoked = rev; }
@@ -360,8 +360,8 @@ public:
inline uint8 GetAnon() const { return m_pp.anon; }
inline PlayerProfile_Struct& GetPP() { return m_pp; }
inline ExtendedProfile_Struct& GetEPP() { return m_epp; }
inline EQEmu::InventoryProfile& GetInv() { return m_inv; }
inline const EQEmu::InventoryProfile& GetInv() const { return m_inv; }
inline EQ::InventoryProfile& GetInv() { return m_inv; }
inline const EQ::InventoryProfile& GetInv() const { return m_inv; }
inline PetInfo* GetPetInfo(uint16 pet) { return (pet==1)?&m_suspendedminion:&m_petinfo; }
inline InspectMessage_Struct& GetInspectMessage() { return m_inspect_message; }
inline const InspectMessage_Struct& GetInspectMessage() const { return m_inspect_message; }
@@ -435,7 +435,7 @@ public:
inline uint8 GetLanguageSkill(uint16 n) const { return m_pp.languages[n]; }
void SendPickPocketResponse(Mob *from, uint32 amt, int type, const EQEmu::ItemData* item = nullptr);
void SendPickPocketResponse(Mob *from, uint32 amt, int type, const EQ::ItemData* item = nullptr);
inline const char* GetLastName() const { return lastname; }
@@ -539,10 +539,10 @@ public:
virtual int GetCurrentBuffSlots() const;
virtual int GetCurrentSongSlots() const;
virtual int GetCurrentDiscSlots() const { return 1; }
virtual int GetMaxBuffSlots() const { return EQEmu::spells::LONG_BUFFS; }
virtual int GetMaxSongSlots() const { return EQEmu::spells::SHORT_BUFFS; }
virtual int GetMaxDiscSlots() const { return EQEmu::spells::DISC_BUFFS; }
virtual int GetMaxTotalSlots() const { return EQEmu::spells::TOTAL_BUFFS; }
virtual int GetMaxBuffSlots() const { return EQ::spells::LONG_BUFFS; }
virtual int GetMaxSongSlots() const { return EQ::spells::SHORT_BUFFS; }
virtual int GetMaxDiscSlots() const { return EQ::spells::DISC_BUFFS; }
virtual int GetMaxTotalSlots() const { return EQ::spells::TOTAL_BUFFS; }
virtual uint32 GetFirstBuffSlot(bool disc, bool song);
virtual uint32 GetLastBuffSlot(bool disc, bool song);
virtual void InitializeBuffSlots();
@@ -637,7 +637,7 @@ public:
void AssignToInstance(uint16 instance_id);
void RemoveFromInstance(uint16 instance_id);
void WhoAll();
bool CheckLoreConflict(const EQEmu::ItemData* item);
bool CheckLoreConflict(const EQ::ItemData* item);
void ChangeLastName(const char* in_lastname);
void GetGroupAAs(GroupLeadershipAA_Struct *into) const;
void GetRaidAAs(RaidLeadershipAA_Struct *into) const;
@@ -725,31 +725,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 <= EQEmu::skills::HIGHEST_SKILL) { m_pp.skills[skill_id] += value; } }
void IncreaseSkill(int skill_id, int value = 1) { if (skill_id <= EQ::skills::HIGHEST_SKILL) { m_pp.skills[skill_id] += value; } }
void IncreaseLanguageSkill(int skill_id, int value = 1);
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);
virtual uint16 GetSkill(EQ::skills::SkillType skill_id) const { if (skill_id <= EQ::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(EQ::skills::SkillType skill_id) const { if (skill_id <= EQ::skills::HIGHEST_SKILL) { return(m_pp.skills[skill_id]); } return 0; }
bool HasSkill(EQ::skills::SkillType skill_id) const;
bool CanHaveSkill(EQ::skills::SkillType skill_id) const;
void SetSkill(EQ::skills::SkillType skill_num, uint16 value);
void AddSkill(EQ::skills::SkillType skillid, uint16 value);
void CheckSpecializeIncrease(uint16 spell_id);
void CheckSongSkillIncrease(uint16 spell_id);
bool CheckIncreaseSkill(EQEmu::skills::SkillType skillid, Mob *against_who, int chancemodi = 0);
bool CheckIncreaseSkill(EQ::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(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_);
uint16 MaxSkill(EQ::skills::SkillType skillid, uint16 class_, uint16 level) const;
inline uint16 MaxSkill(EQ::skills::SkillType skillid) const { return MaxSkill(skillid, GetClass(), GetLevel()); }
uint8 SkillTrainLevel(EQ::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, EQEmu::skills::SkillType tradeskill);
void CheckIncreaseTradeskill(int16 bonusstat, int16 stat_modifier, float skillup_modifier, uint16 success_modifier, EQ::skills::SkillType tradeskill);
void InitInnates();
void GMKill();
@@ -791,7 +791,7 @@ public:
#endif
uint32 GetEquippedItemFromTextureSlot(uint8 material_slot) const; // returns item id
uint32 GetEquipmentColor(uint8 material_slot) const;
virtual void UpdateEquipmentLight() { m_Light.Type[EQEmu::lightsource::LightEquipment] = m_inv.FindBrightestLightType(); m_Light.Level[EQEmu::lightsource::LightEquipment] = EQEmu::lightsource::TypeToLevel(m_Light.Type[EQEmu::lightsource::LightEquipment]); }
virtual void UpdateEquipmentLight() { m_Light.Type[EQ::lightsource::LightEquipment] = m_inv.FindBrightestLightType(); m_Light.Level[EQ::lightsource::LightEquipment] = EQ::lightsource::TypeToLevel(m_Light.Type[EQ::lightsource::LightEquipment]); }
inline bool AutoSplitEnabled() { return m_pp.autosplit != 0; }
inline bool AutoConsentGroupEnabled() const { return m_pp.groupAutoconsent != 0; }
@@ -863,31 +863,31 @@ public:
uint32 NukeItem(uint32 itemnum, uint8 where_to_check =
(invWhereWorn | invWherePersonal | invWhereBank | invWhereSharedBank | invWhereTrading | invWhereCursor));
void SetTint(int16 slot_id, uint32 color);
void SetTint(int16 slot_id, EQEmu::textures::Tint_Struct& color);
void SetTint(int16 slot_id, EQ::textures::Tint_Struct& color);
void SetMaterial(int16 slot_id, uint32 item_id);
void Undye();
int32 GetItemIDAt(int16 slot_id);
int32 GetAugmentIDAt(int16 slot_id, uint8 augslot);
bool PutItemInInventory(int16 slot_id, const EQEmu::ItemInstance& inst, bool client_update = false);
bool PushItemOnCursor(const EQEmu::ItemInstance& inst, bool client_update = false);
bool PutItemInInventory(int16 slot_id, const EQ::ItemInstance& inst, bool client_update = false);
bool PushItemOnCursor(const EQ::ItemInstance& inst, bool client_update = false);
void SendCursorBuffer();
void DeleteItemInInventory(int16 slot_id, int8 quantity = 0, bool client_update = false, bool update_db = true);
bool SwapItem(MoveItem_Struct* move_in);
void SwapItemResync(MoveItem_Struct* move_slots);
void QSSwapItemAuditor(MoveItem_Struct* move_in, bool postaction_call = false);
void PutLootInInventory(int16 slot_id, const EQEmu::ItemInstance &inst, ServerLootItem_Struct** bag_item_data = 0);
bool AutoPutLootInInventory(EQEmu::ItemInstance& inst, bool try_worn = false, bool try_cursor = true, ServerLootItem_Struct** bag_item_data = 0);
bool SummonItem(uint32 item_id, int16 charges = -1, uint32 aug1 = 0, uint32 aug2 = 0, uint32 aug3 = 0, uint32 aug4 = 0, uint32 aug5 = 0, uint32 aug6 = 0, bool attuned = false, uint16 to_slot = EQEmu::invslot::slotCursor, uint32 ornament_icon = 0, uint32 ornament_idfile = 0, uint32 ornament_hero_model = 0);
void PutLootInInventory(int16 slot_id, const EQ::ItemInstance &inst, ServerLootItem_Struct** bag_item_data = 0);
bool AutoPutLootInInventory(EQ::ItemInstance& inst, bool try_worn = false, bool try_cursor = true, ServerLootItem_Struct** bag_item_data = 0);
bool SummonItem(uint32 item_id, int16 charges = -1, uint32 aug1 = 0, uint32 aug2 = 0, uint32 aug3 = 0, uint32 aug4 = 0, uint32 aug5 = 0, uint32 aug6 = 0, bool attuned = false, uint16 to_slot = EQ::invslot::slotCursor, uint32 ornament_icon = 0, uint32 ornament_idfile = 0, uint32 ornament_hero_model = 0);
void SetStats(uint8 type,int16 set_val);
void IncStats(uint8 type,int16 increase_val);
void DropItem(int16 slot_id, bool recurse = true);
void DropItemQS(EQEmu::ItemInstance* inst, bool pickup);
void DropItemQS(EQ::ItemInstance* inst, bool pickup);
int GetItemLinkHash(const EQEmu::ItemInstance* inst); // move to ItemData..or make use of the pre-calculated database field
int GetItemLinkHash(const EQ::ItemInstance* inst); // move to ItemData..or make use of the pre-calculated database field
void SendItemLink(const EQEmu::ItemInstance* inst, bool sendtoall=false);
void SendLootItemInPacket(const EQEmu::ItemInstance* inst, int16 slot_id);
void SendItemPacket(int16 slot_id, const EQEmu::ItemInstance* inst, ItemPacketType packet_type);
void SendItemLink(const EQ::ItemInstance* inst, bool sendtoall=false);
void SendLootItemInPacket(const EQ::ItemInstance* inst, int16 slot_id);
void SendItemPacket(int16 slot_id, const EQ::ItemInstance* inst, ItemPacketType packet_type);
bool IsValidSlot(uint32 slot);
bool IsBankSlot(uint32 slot);
@@ -945,7 +945,7 @@ public:
//Calculate vendor price modifier based on CHA: (reverse==selling)
float CalcPriceMod(Mob* other = 0, bool reverse = false);
void ResetTrade();
void DropInst(const EQEmu::ItemInstance* inst);
void DropInst(const EQ::ItemInstance* inst);
bool TrainDiscipline(uint32 itemid);
void TrainDiscBySpellID(int32 spell_id);
int GetDiscSlotBySpellID(int32 spellid);
@@ -977,7 +977,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(EQEmu::skills::SkillType skillid, uint16 maxSkill);
uint16 GetMaxSkillAfterSpecializationRules(EQ::skills::SkillType skillid, uint16 maxSkill);
void SendPopupToClient(const char *Title, const char *Text, uint32 PopupID = 0, uint32 Buttons = 0, uint32 Duration = 0);
void SendFullPopup(const char *Title, const char *Text, uint32 PopupID = 0, uint32 NegativeID = 0, uint32 Buttons = 0, uint32 Duration = 0, const char *ButtonName0 = 0, const char *ButtonName1 = 0, uint32 SoundControls = 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, ...);
@@ -1008,7 +1008,7 @@ public:
inline void UpdateTasksForItem(ActivityType Type, int ItemID, int Count=1) { if(taskstate) taskstate->UpdateTasksForItem(this, Type, ItemID, Count); }
inline void UpdateTasksOnExplore(int ExploreID) { if(taskstate) taskstate->UpdateTasksOnExplore(this, ExploreID); }
inline bool UpdateTasksOnSpeakWith(int NPCTypeID) { if(taskstate) return taskstate->UpdateTasksOnSpeakWith(this, NPCTypeID); else return false; }
inline bool UpdateTasksOnDeliver(std::list<EQEmu::ItemInstance*>& Items, int Cash, int NPCTypeID) { if (taskstate) return taskstate->UpdateTasksOnDeliver(this, Items, Cash, NPCTypeID); else return false; }
inline bool UpdateTasksOnDeliver(std::list<EQ::ItemInstance*>& Items, int Cash, int NPCTypeID) { if (taskstate) return taskstate->UpdateTasksOnDeliver(this, Items, Cash, NPCTypeID); else return false; }
inline void TaskSetSelector(Mob *mob, int TaskSetID) { if(taskmanager) taskmanager->TaskSetSelector(this, taskstate, mob, TaskSetID); }
inline void TaskQuestSetSelector(Mob *mob, int count, int *tasks) { if(taskmanager) taskmanager->TaskQuestSetSelector(this, taskstate, mob, count, tasks); }
inline void EnableTask(int TaskCount, int *TaskList) { if(taskstate) taskstate->EnableTask(CharacterID(), TaskCount, TaskList); }
@@ -1033,9 +1033,9 @@ public:
inline int ActiveTasksInSet(int TaskSet) { return (taskstate ? taskstate->ActiveTasksInSet(TaskSet) :0); }
inline int CompletedTasksInSet(int TaskSet) { return (taskstate ? taskstate->CompletedTasksInSet(TaskSet) :0); }
inline const EQEmu::versions::ClientVersion ClientVersion() const { return m_ClientVersion; }
inline const EQ::versions::ClientVersion ClientVersion() const { return m_ClientVersion; }
inline const uint32 ClientVersionBit() const { return m_ClientVersionBit; }
inline void SetClientVersion(EQEmu::versions::ClientVersion client_version) { m_ClientVersion = client_version; }
inline void SetClientVersion(EQ::versions::ClientVersion client_version) { m_ClientVersion = client_version; }
/** Adventure Stuff **/
void SendAdventureError(const char *error);
@@ -1124,7 +1124,7 @@ public:
inline bool GetPendingGuildInvitation() { return PendingGuildInvitation; }
void LocateCorpse();
void SendTargetCommand(uint32 EntityID);
bool MoveItemToInventory(EQEmu::ItemInstance *BInst, bool UpdateClient = false);
bool MoveItemToInventory(EQ::ItemInstance *BInst, bool UpdateClient = false);
void HandleRespawnFromHover(uint32 Option);
bool IsHoveringForRespawn() { return RespawnFromHoverTimer.Enabled(); }
std::list<RespawnOption> respawn_options;
@@ -1153,7 +1153,7 @@ public:
void HandleLFGuildResponse(ServerPacket *pack);
void SendLFGuildStatus();
void SendGuildLFGuildStatus();
inline bool XTargettingAvailable() const { return ((m_ClientVersionBit & EQEmu::versions::maskUFAndLater) && RuleB(Character, EnableXTargetting)); }
inline bool XTargettingAvailable() const { return ((m_ClientVersionBit & EQ::versions::maskUFAndLater) && RuleB(Character, EnableXTargetting)); }
inline uint8 GetMaxXTargets() const { return MaxXTargets; }
void SetMaxXTargets(uint8 NewMax);
bool IsXTarget(const Mob *m) const;
@@ -1177,7 +1177,7 @@ public:
bool GroupFollow(Client* inviter);
inline bool GetRunMode() const { return runmode; }
inline bool AggroMeterAvailable() const { return ((m_ClientVersionBit & EQEmu::versions::maskRoF2AndLater)) && RuleB(Character, EnableAggroMeter); } // RoF untested
inline bool AggroMeterAvailable() const { return ((m_ClientVersionBit & EQ::versions::maskRoF2AndLater)) && RuleB(Character, EnableAggroMeter); } // RoF untested
inline void SetAggroMeterLock(int in) { m_aggrometer.set_lock_id(in); }
void ProcessAggroMeter(); // builds packet and sends
@@ -1229,7 +1229,7 @@ public:
void TryItemTick(int slot);
void ItemTimerCheck();
void TryItemTimer(int slot);
void SendItemScale(EQEmu::ItemInstance *inst);
void SendItemScale(EQ::ItemInstance *inst);
int32 GetActSTR() { return( std::min(GetMaxSTR(), GetSTR()) ); }
int32 GetActSTA() { return( std::min(GetMaxSTA(), GetSTA()) ); }
@@ -1241,13 +1241,13 @@ public:
void LoadAccountFlags();
void SetAccountFlag(std::string flag, std::string val);
std::string GetAccountFlag(std::string flag);
float GetDamageMultiplier(EQEmu::skills::SkillType how_long_has_this_been_missing);
void Consume(const EQEmu::ItemData *item, uint8 type, int16 slot, bool auto_consume);
float GetDamageMultiplier(EQ::skills::SkillType how_long_has_this_been_missing);
void Consume(const EQ::ItemData *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, EQEmu::skills::SkillType skillinuse, int hand, const EQEmu::ItemInstance* weapon, Mob* other);
int mod_client_damage(int damage, EQ::skills::SkillType skillinuse, int hand, const EQ::ItemInstance* weapon, Mob* other);
bool mod_client_message(char* message, uint8 chan_num);
bool mod_can_increase_skill(EQEmu::skills::SkillType skillid, Mob* against_who);
bool mod_can_increase_skill(EQ::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);
@@ -1257,16 +1257,16 @@ public:
int16 mod_pet_power(int16 act_power, uint16 spell_id);
float mod_tradeskill_chance(float chance, DBTradeskillRecipe_Struct *spec);
float mod_tradeskill_skillup(float chance_stage2);
int32 mod_tribute_item_value(int32 pts, const EQEmu::ItemInstance* item);
int32 mod_tribute_item_value(int32 pts, const EQ::ItemInstance* item);
void mod_client_death_npc(Mob* killerMob);
void mod_client_death_duel(Mob* killerMob);
void mod_client_death_env();
int32 mod_client_xp(int32 in_exp, NPC *npc);
uint32 mod_client_xp_for_level(uint32 xp, uint16 check_level);
int mod_client_haste_cap(int cap);
int mod_consume(EQEmu::ItemData *item, EQEmu::item::ItemType type, int change);
int mod_food_value(const EQEmu::ItemData *item, int change);
int mod_drink_value(const EQEmu::ItemData *item, int change);
int mod_consume(EQ::ItemData *item, EQ::item::ItemType type, int change);
int mod_food_value(const EQ::ItemData *item, int change);
int mod_drink_value(const EQ::ItemData *item, int change);
void ShowNumHits(); // work around function for numhits not showing on buffs
@@ -1309,8 +1309,8 @@ public:
protected:
friend class Mob;
void CalcItemBonuses(StatBonuses* newbon);
void AddItemBonuses(const EQEmu::ItemInstance *inst, StatBonuses* newbon, bool isAug = false, bool isTribute = false, int rec_override = 0, bool ammo_slot_item = false);
void AdditiveWornBonuses(const EQEmu::ItemInstance *inst, StatBonuses* newbon, bool isAug = false);
void AddItemBonuses(const EQ::ItemInstance *inst, StatBonuses* newbon, bool isAug = false, bool isTribute = false, int rec_override = 0, bool ammo_slot_item = false);
void AdditiveWornBonuses(const EQ::ItemInstance *inst, StatBonuses* newbon, bool isAug = false);
int CalcRecommendedLevelBonus(uint8 level, uint8 reclevel, int basestat);
void CalcEdibleBonuses(StatBonuses* newbon);
void ProcessItemCaps();
@@ -1352,7 +1352,7 @@ private:
void OPRezzAnswer(uint32 Action, uint32 SpellID, uint16 ZoneID, uint16 InstanceID, float x, float y, float z);
void OPMemorizeSpell(const EQApplicationPacket *app);
void OPMoveCoin(const EQApplicationPacket* app);
void MoveItemCharges(EQEmu::ItemInstance &from, int16 to_slot, uint8 type);
void MoveItemCharges(EQ::ItemInstance &from, int16 to_slot, uint8 type);
void OPGMTraining(const EQApplicationPacket *app);
void OPGMEndTraining(const EQApplicationPacket *app);
void OPGMTrainSkill(const EQApplicationPacket *app);
@@ -1466,7 +1466,7 @@ private:
PlayerProfile_Struct m_pp;
ExtendedProfile_Struct m_epp;
EQEmu::InventoryProfile m_inv;
EQ::InventoryProfile m_inv;
Object* m_tradeskill_object;
PetInfo m_petinfo; // current pet data, used while loading from and saving to DB
PetInfo m_suspendedminion; // pet data for our suspended minion.
@@ -1580,7 +1580,7 @@ private:
Timer *GlobalChatLimiterTimer; //60 seconds
uint32 AttemptedMessages;
EQEmu::versions::ClientVersion m_ClientVersion;
EQ::versions::ClientVersion m_ClientVersion;
uint32 m_ClientVersionBit;
int XPRate;
@@ -1635,8 +1635,8 @@ private:
bool interrogateinv_flag; // used to minimize log spamming by players
void InterrogateInventory_(bool errorcheck, Client* requester, int16 head, int16 index, const EQEmu::ItemInstance* inst, const EQEmu::ItemInstance* parent, bool log, bool silent, bool &error, int depth);
bool InterrogateInventory_error(int16 head, int16 index, const EQEmu::ItemInstance* inst, const EQEmu::ItemInstance* parent, int depth);
void InterrogateInventory_(bool errorcheck, Client* requester, int16 head, int16 index, const EQ::ItemInstance* inst, const EQ::ItemInstance* parent, bool log, bool silent, bool &error, int depth);
bool InterrogateInventory_error(int16 head, int16 index, const EQ::ItemInstance* inst, const EQ::ItemInstance* parent, int depth);
int client_max_level;
zone/client_mods.cpp
+30 -30
View File
@@ -44,7 +44,7 @@ int32 Client::GetMaxStat() const
if (level < 61) {
base = 255;
}
else if (ClientVersion() >= EQEmu::versions::ClientVersion::SoF) {
else if (ClientVersion() >= EQ::versions::ClientVersion::SoF) {
base = 255 + 5 * (level - 60);
}
else if (level < 71) {
@@ -482,7 +482,7 @@ uint32 Mob::GetClassLevelFactor()
int32 Client::CalcBaseHP()
{
if (ClientVersion() >= EQEmu::versions::ClientVersion::SoF && RuleB(Character, SoDClientUseSoDHPManaEnd)) {
if (ClientVersion() >= EQ::versions::ClientVersion::SoF && RuleB(Character, SoDClientUseSoDHPManaEnd)) {
int stats = GetSTA();
if (stats > 255) {
stats = (stats - 255) / 2;
@@ -558,8 +558,8 @@ int32 Client::GetRawItemAC()
{
int32 Total = 0;
// this skips MainAmmo..add an '=' conditional if that slot is required (original behavior)
for (int16 slot_id = EQEmu::invslot::BONUS_BEGIN; slot_id <= EQEmu::invslot::BONUS_STAT_END; slot_id++) {
const EQEmu::ItemInstance* inst = m_inv[slot_id];
for (int16 slot_id = EQ::invslot::BONUS_BEGIN; slot_id <= EQ::invslot::BONUS_STAT_END; slot_id++) {
const EQ::ItemInstance* inst = m_inv[slot_id];
if (inst && inst->IsClassCommon()) {
Total += inst->GetItem()->AC;
}
@@ -613,7 +613,7 @@ int32 Client::CalcBaseMana()
switch (GetCasterClass()) {
case 'I':
WisInt = GetINT();
if (ClientVersion() >= EQEmu::versions::ClientVersion::SoF && RuleB(Character, SoDClientUseSoDHPManaEnd)) {
if (ClientVersion() >= EQ::versions::ClientVersion::SoF && RuleB(Character, SoDClientUseSoDHPManaEnd)) {
ConvertedWisInt = WisInt;
int over200 = WisInt;
if (WisInt > 100) {
@@ -645,7 +645,7 @@ int32 Client::CalcBaseMana()
break;
case 'W':
WisInt = GetWIS();
if (ClientVersion() >= EQEmu::versions::ClientVersion::SoF && RuleB(Character, SoDClientUseSoDHPManaEnd)) {
if (ClientVersion() >= EQ::versions::ClientVersion::SoF && RuleB(Character, SoDClientUseSoDHPManaEnd)) {
ConvertedWisInt = WisInt;
int over200 = WisInt;
if (WisInt > 100) {
@@ -696,8 +696,8 @@ int32 Client::CalcBaseManaRegen()
uint8 clevel = GetLevel();
int32 regen = 0;
if (IsSitting() || (GetHorseId() != 0)) {
if (HasSkill(EQEmu::skills::SkillMeditate)) {
regen = (((GetSkill(EQEmu::skills::SkillMeditate) / 10) + (clevel - (clevel / 4))) / 4) + 4;
if (HasSkill(EQ::skills::SkillMeditate)) {
regen = (((GetSkill(EQ::skills::SkillMeditate) / 10) + (clevel - (clevel / 4))) / 4) + 4;
}
else {
regen = 2;
@@ -723,7 +723,7 @@ int32 Client::CalcManaRegen(bool bCombat)
// kind of weird to do it here w/e
// client does some base medding regen for shrouds here
if (GetClass() != BARD) {
auto skill = GetSkill(EQEmu::skills::SkillMeditate);
auto skill = GetSkill(EQ::skills::SkillMeditate);
if (skill > 0) {
regen++;
if (skill > 1)
@@ -787,11 +787,11 @@ int32 Client::CalcManaRegenCap()
uint32 Client::CalcCurrentWeight()
{
const EQEmu::ItemData* TempItem = nullptr;
EQEmu::ItemInstance* ins = nullptr;
const EQ::ItemData* TempItem = nullptr;
EQ::ItemInstance* ins = nullptr;
uint32 Total = 0;
int x;
for (x = EQEmu::invslot::POSSESSIONS_BEGIN; x <= EQEmu::invslot::POSSESSIONS_END; x++) {
for (x = EQ::invslot::POSSESSIONS_BEGIN; x <= EQ::invslot::POSSESSIONS_END; x++) {
TempItem = 0;
ins = GetInv().GetItem(x);
if (ins) {
@@ -801,7 +801,7 @@ uint32 Client::CalcCurrentWeight()
Total += TempItem->Weight;
}
}
for (x = EQEmu::invbag::GENERAL_BAGS_BEGIN; x <= EQEmu::invbag::CURSOR_BAG_END; x++) {
for (x = EQ::invbag::GENERAL_BAGS_BEGIN; x <= EQ::invbag::CURSOR_BAG_END; x++) {
int TmpWeight = 0;
TempItem = 0;
ins = GetInv().GetItem(x);
@@ -814,14 +814,14 @@ uint32 Client::CalcCurrentWeight()
if (TmpWeight > 0) {
// this code indicates that weight redux bags can only be in the first general inventory slot to be effective...
// is this correct? or can we scan for the highest weight redux and use that? (need client verifications)
int bagslot = EQEmu::invslot::slotGeneral1;
int bagslot = EQ::invslot::slotGeneral1;
int reduction = 0;
for (int m = EQEmu::invbag::GENERAL_BAGS_BEGIN + EQEmu::invbag::SLOT_COUNT; m <= EQEmu::invbag::CURSOR_BAG_END; m += EQEmu::invbag::SLOT_COUNT) {
for (int m = EQ::invbag::GENERAL_BAGS_BEGIN + EQ::invbag::SLOT_COUNT; m <= EQ::invbag::CURSOR_BAG_END; m += EQ::invbag::SLOT_COUNT) {
if (x >= m) {
bagslot += 1;
}
}
EQEmu::ItemInstance* baginst = GetInv().GetItem(bagslot);
EQ::ItemInstance* baginst = GetInv().GetItem(bagslot);
if (baginst && baginst->GetItem() && baginst->IsClassBag()) {
reduction = baginst->GetItem()->BagWR;
}
@@ -840,7 +840,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::behavior::StaticLookup(EQEmu::versions::ConvertClientVersionToMobVersion(ClientVersion()))->CoinHasWeight) {
if (EQ::behavior::StaticLookup(EQ::versions::ConvertClientVersionToMobVersion(ClientVersion()))->CoinHasWeight) {
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;
@@ -1531,10 +1531,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 EQEmu::skills::SkillPercussionInstruments:
case EQ::skills::SkillPercussionInstruments:
if (itembonuses.percussionMod == 0 && spellbonuses.percussionMod == 0)
effectmod = 10;
else if (GetSkill(EQEmu::skills::SkillPercussionInstruments) == 0)
else if (GetSkill(EQ::skills::SkillPercussionInstruments) == 0)
effectmod = 10;
else if (itembonuses.percussionMod > spellbonuses.percussionMod)
effectmod = itembonuses.percussionMod;
@@ -1543,10 +1543,10 @@ uint32 Mob::GetInstrumentMod(uint16 spell_id) const
if (IsBardSong(spell_id))
effectmod += aabonuses.percussionMod;
break;
case EQEmu::skills::SkillStringedInstruments:
case EQ::skills::SkillStringedInstruments:
if (itembonuses.stringedMod == 0 && spellbonuses.stringedMod == 0)
effectmod = 10;
else if (GetSkill(EQEmu::skills::SkillStringedInstruments) == 0)
else if (GetSkill(EQ::skills::SkillStringedInstruments) == 0)
effectmod = 10;
else if (itembonuses.stringedMod > spellbonuses.stringedMod)
effectmod = itembonuses.stringedMod;
@@ -1555,10 +1555,10 @@ uint32 Mob::GetInstrumentMod(uint16 spell_id) const
if (IsBardSong(spell_id))
effectmod += aabonuses.stringedMod;
break;
case EQEmu::skills::SkillWindInstruments:
case EQ::skills::SkillWindInstruments:
if (itembonuses.windMod == 0 && spellbonuses.windMod == 0)
effectmod = 10;
else if (GetSkill(EQEmu::skills::SkillWindInstruments) == 0)
else if (GetSkill(EQ::skills::SkillWindInstruments) == 0)
effectmod = 10;
else if (itembonuses.windMod > spellbonuses.windMod)
effectmod = itembonuses.windMod;
@@ -1567,10 +1567,10 @@ uint32 Mob::GetInstrumentMod(uint16 spell_id) const
if (IsBardSong(spell_id))
effectmod += aabonuses.windMod;
break;
case EQEmu::skills::SkillBrassInstruments:
case EQ::skills::SkillBrassInstruments:
if (itembonuses.brassMod == 0 && spellbonuses.brassMod == 0)
effectmod = 10;
else if (GetSkill(EQEmu::skills::SkillBrassInstruments) == 0)
else if (GetSkill(EQ::skills::SkillBrassInstruments) == 0)
effectmod = 10;
else if (itembonuses.brassMod > spellbonuses.brassMod)
effectmod = itembonuses.brassMod;
@@ -1579,7 +1579,7 @@ uint32 Mob::GetInstrumentMod(uint16 spell_id) const
if (IsBardSong(spell_id))
effectmod += aabonuses.brassMod;
break;
case EQEmu::skills::SkillSinging:
case EQ::skills::SkillSinging:
if (itembonuses.singingMod == 0 && spellbonuses.singingMod == 0)
effectmod = 10;
else if (itembonuses.singingMod > spellbonuses.singingMod)
@@ -1626,7 +1626,7 @@ void Client::CalcMaxEndurance()
int32 Client::CalcBaseEndurance()
{
int32 base_end = 0;
if (ClientVersion() >= EQEmu::versions::ClientVersion::SoF && RuleB(Character, SoDClientUseSoDHPManaEnd)) {
if (ClientVersion() >= EQ::versions::ClientVersion::SoF && RuleB(Character, SoDClientUseSoDHPManaEnd)) {
double heroic_stats = (GetHeroicSTR() + GetHeroicSTA() + GetHeroicDEX() + GetHeroicAGI()) / 4.0f;
double stats = (GetSTR() + GetSTA() + GetDEX() + GetAGI()) / 4.0f;
if (stats > 201.0f) {
@@ -1765,12 +1765,12 @@ int Client::GetRawACNoShield(int &shield_ac) const
{
int ac = itembonuses.AC + spellbonuses.AC + aabonuses.AC;
shield_ac = 0;
const EQEmu::ItemInstance *inst = m_inv.GetItem(EQEmu::invslot::slotSecondary);
const EQ::ItemInstance *inst = m_inv.GetItem(EQ::invslot::slotSecondary);
if (inst) {
if (inst->GetItem()->ItemType == EQEmu::item::ItemTypeShield) {
if (inst->GetItem()->ItemType == EQ::item::ItemTypeShield) {
ac -= inst->GetItem()->AC;
shield_ac = inst->GetItem()->AC;
for (uint8 i = EQEmu::invaug::SOCKET_BEGIN; i <= EQEmu::invaug::SOCKET_END; i++) {
for (uint8 i = EQ::invaug::SOCKET_BEGIN; i <= EQ::invaug::SOCKET_END; i++) {
if (inst->GetAugment(i)) {
ac -= inst->GetAugment(i)->GetItem()->AC;
shield_ac += inst->GetAugment(i)->GetItem()->AC;
zone/client_packet.cpp
+267 -267
View File
File diff suppressed because it is too large Load Diff
zone/client_process.cpp
+66 -66
View File
@@ -112,7 +112,7 @@ bool Client::Process() {
HandleRespawnFromHover(0);
}
if (IsTracking() && (ClientVersion() >= EQEmu::versions::ClientVersion::SoD) && TrackingTimer.Check())
if (IsTracking() && (ClientVersion() >= EQ::versions::ClientVersion::SoD) && TrackingTimer.Check())
DoTracking();
// SendHPUpdate calls hpupdate_timer.Start so it can delay this timer, so lets not reset with the check
@@ -286,10 +286,10 @@ bool Client::Process() {
}
if (AutoFireEnabled()) {
EQEmu::ItemInstance *ranged = GetInv().GetItem(EQEmu::invslot::slotRange);
EQ::ItemInstance *ranged = GetInv().GetItem(EQ::invslot::slotRange);
if (ranged)
{
if (ranged->GetItem() && ranged->GetItem()->ItemType == EQEmu::item::ItemTypeBow) {
if (ranged->GetItem() && ranged->GetItem()->ItemType == EQ::item::ItemTypeBow) {
if (ranged_timer.Check(false)) {
if (GetTarget() && (GetTarget()->IsNPC() || GetTarget()->IsClient())) {
if (GetTarget()->InFrontMob(this, GetTarget()->GetX(), GetTarget()->GetY())) {
@@ -309,7 +309,7 @@ bool Client::Process() {
ranged_timer.Start();
}
}
else if (ranged->GetItem() && (ranged->GetItem()->ItemType == EQEmu::item::ItemTypeLargeThrowing || ranged->GetItem()->ItemType == EQEmu::item::ItemTypeSmallThrowing)) {
else if (ranged->GetItem() && (ranged->GetItem()->ItemType == EQ::item::ItemTypeLargeThrowing || ranged->GetItem()->ItemType == EQ::item::ItemTypeSmallThrowing)) {
if (ranged_timer.Check(false)) {
if (GetTarget() && (GetTarget()->IsNPC() || GetTarget()->IsClient())) {
if (GetTarget()->InFrontMob(this, GetTarget()->GetX(), GetTarget()->GetY())) {
@@ -374,11 +374,11 @@ bool Client::Process() {
}
else if (auto_attack_target->GetHP() > -10) // -10 so we can watch people bleed in PvP
{
EQEmu::ItemInstance *wpn = GetInv().GetItem(EQEmu::invslot::slotPrimary);
TryWeaponProc(wpn, auto_attack_target, EQEmu::invslot::slotPrimary);
TriggerDefensiveProcs(auto_attack_target, EQEmu::invslot::slotPrimary, false);
EQ::ItemInstance *wpn = GetInv().GetItem(EQ::invslot::slotPrimary);
TryWeaponProc(wpn, auto_attack_target, EQ::invslot::slotPrimary);
TriggerDefensiveProcs(auto_attack_target, EQ::invslot::slotPrimary, false);
DoAttackRounds(auto_attack_target, EQEmu::invslot::slotPrimary);
DoAttackRounds(auto_attack_target, EQ::invslot::slotPrimary);
if (CheckAATimer(aaTimerRampage)) {
entity_list.AEAttack(this, 30);
}
@@ -413,12 +413,12 @@ bool Client::Process() {
//you can't see your target
}
else if (auto_attack_target->GetHP() > -10) {
CheckIncreaseSkill(EQEmu::skills::SkillDualWield, auto_attack_target, -10);
CheckIncreaseSkill(EQ::skills::SkillDualWield, auto_attack_target, -10);
if (CheckDualWield()) {
EQEmu::ItemInstance *wpn = GetInv().GetItem(EQEmu::invslot::slotSecondary);
TryWeaponProc(wpn, auto_attack_target, EQEmu::invslot::slotSecondary);
EQ::ItemInstance *wpn = GetInv().GetItem(EQ::invslot::slotSecondary);
TryWeaponProc(wpn, auto_attack_target, EQ::invslot::slotSecondary);
DoAttackRounds(auto_attack_target, EQEmu::invslot::slotSecondary);
DoAttackRounds(auto_attack_target, EQ::invslot::slotSecondary);
}
}
}
@@ -722,10 +722,10 @@ void Client::BulkSendInventoryItems()
{
// LINKDEAD TRADE ITEMS
// Move trade slot items back into normal inventory..need them there now for the proceeding validity checks
for (int16 slot_id = EQEmu::invslot::TRADE_BEGIN; slot_id <= EQEmu::invslot::TRADE_END; slot_id++) {
EQEmu::ItemInstance* inst = m_inv.PopItem(slot_id);
for (int16 slot_id = EQ::invslot::TRADE_BEGIN; slot_id <= EQ::invslot::TRADE_END; slot_id++) {
EQ::ItemInstance* inst = m_inv.PopItem(slot_id);
if(inst) {
bool is_arrow = (inst->GetItem()->ItemType == EQEmu::item::ItemTypeArrow) ? true : false;
bool is_arrow = (inst->GetItem()->ItemType == EQ::item::ItemTypeArrow) ? true : false;
int16 free_slot_id = m_inv.FindFreeSlot(inst->IsClassBag(), true, inst->GetItem()->Size, is_arrow);
LogInventory("Incomplete Trade Transaction: Moving [{}] from slot [{}] to [{}]", inst->GetItem()->Name, slot_id, free_slot_id);
PutItemInInventory(free_slot_id, *inst, false);
@@ -744,12 +744,12 @@ void Client::BulkSendInventoryItems()
RemoveDuplicateLore(false);
MoveSlotNotAllowed(false);
EQEmu::OutBuffer ob;
EQEmu::OutBuffer::pos_type last_pos = ob.tellp();
EQ::OutBuffer ob;
EQ::OutBuffer::pos_type last_pos = ob.tellp();
// Possessions items
for (int16 slot_id = EQEmu::invslot::POSSESSIONS_BEGIN; slot_id <= EQEmu::invslot::POSSESSIONS_END; slot_id++) {
const EQEmu::ItemInstance* inst = m_inv[slot_id];
for (int16 slot_id = EQ::invslot::POSSESSIONS_BEGIN; slot_id <= EQ::invslot::POSSESSIONS_END; slot_id++) {
const EQ::ItemInstance* inst = m_inv[slot_id];
if (!inst)
continue;
@@ -762,8 +762,8 @@ void Client::BulkSendInventoryItems()
}
// Bank items
for (int16 slot_id = EQEmu::invslot::BANK_BEGIN; slot_id <= EQEmu::invslot::BANK_END; slot_id++) {
const EQEmu::ItemInstance* inst = m_inv[slot_id];
for (int16 slot_id = EQ::invslot::BANK_BEGIN; slot_id <= EQ::invslot::BANK_END; slot_id++) {
const EQ::ItemInstance* inst = m_inv[slot_id];
if (!inst)
continue;
@@ -776,8 +776,8 @@ void Client::BulkSendInventoryItems()
}
// SharedBank items
for (int16 slot_id = EQEmu::invslot::SHARED_BANK_BEGIN; slot_id <= EQEmu::invslot::SHARED_BANK_END; slot_id++) {
const EQEmu::ItemInstance* inst = m_inv[slot_id];
for (int16 slot_id = EQ::invslot::SHARED_BANK_BEGIN; slot_id <= EQ::invslot::SHARED_BANK_END; slot_id++) {
const EQ::ItemInstance* inst = m_inv[slot_id];
if (!inst)
continue;
@@ -797,12 +797,12 @@ void Client::BulkSendInventoryItems()
}
void Client::BulkSendMerchantInventory(int merchant_id, int npcid) {
const EQEmu::ItemData* handyitem = nullptr;
const EQ::ItemData* handyitem = nullptr;
uint32 numItemSlots = 80; //The max number of items passed in the transaction.
if (m_ClientVersionBit & EQEmu::versions::maskRoFAndLater) { // RoF+ can send 200 items
if (m_ClientVersionBit & EQ::versions::maskRoFAndLater) { // RoF+ can send 200 items
numItemSlots = 200;
}
const EQEmu::ItemData *item = nullptr;
const EQ::ItemData *item = nullptr;
std::list<MerchantList> merlist = zone->merchanttable[merchant_id];
std::list<MerchantList>::const_iterator itr;
Mob* merch = entity_list.GetMobByNpcTypeID(npcid);
@@ -851,7 +851,7 @@ void Client::BulkSendMerchantInventory(int merchant_id, int npcid) {
int charges = 1;
if (item->IsClassCommon())
charges = item->MaxCharges;
EQEmu::ItemInstance* inst = database.CreateItem(item, charges);
EQ::ItemInstance* inst = database.CreateItem(item, charges);
if (inst) {
if (RuleB(Merchant, UsePriceMod)) {
inst->SetPrice((item->Price * (RuleR(Merchant, SellCostMod)) * item->SellRate * Client::CalcPriceMod(merch, false)));
@@ -892,7 +892,7 @@ void Client::BulkSendMerchantInventory(int merchant_id, int npcid) {
// charges=ml.charges;
//else
charges = item->MaxCharges;
EQEmu::ItemInstance* inst = database.CreateItem(item, charges);
EQ::ItemInstance* inst = database.CreateItem(item, charges);
if (inst) {
if (RuleB(Merchant, UsePriceMod)) {
inst->SetPrice((item->Price * (RuleR(Merchant, SellCostMod)) * item->SellRate * Client::CalcPriceMod(merch, false)));
@@ -1066,11 +1066,11 @@ void Client::OPMemorizeSpell(const EQApplicationPacket* app)
switch(memspell->scribing)
{
case memSpellScribing: { // scribing spell to book
const EQEmu::ItemInstance* inst = m_inv[EQEmu::invslot::slotCursor];
const EQ::ItemInstance* inst = m_inv[EQ::invslot::slotCursor];
if (inst && inst->IsClassCommon())
{
const EQEmu::ItemData* item = inst->GetItem();
const EQ::ItemData* item = inst->GetItem();
if (RuleB(Character, RestrictSpellScribing) && !item->IsEquipable(GetRace(), GetClass())) {
MessageString(Chat::Red, CANNOT_USE_ITEM);
@@ -1080,7 +1080,7 @@ void Client::OPMemorizeSpell(const EQApplicationPacket* app)
if(item && item->Scroll.Effect == (int32)(memspell->spell_id))
{
ScribeSpell(memspell->spell_id, memspell->slot);
DeleteItemInInventory(EQEmu::invslot::slotCursor, 1, true);
DeleteItemInInventory(EQ::invslot::slotCursor, 1, true);
}
else
Message(0,"Scribing spell: inst exists but item does not or spell ids do not match.");
@@ -1119,7 +1119,7 @@ void Client::CancelSneakHide()
// The later clients send back a OP_Hide (this has a size but data is 0)
// as well as OP_SpawnAppearance with AT_Invis and one with AT_Sneak
// So we don't have to handle any of those flags
if (ClientVersionBit() & EQEmu::versions::maskSoFAndEarlier)
if (ClientVersionBit() & EQ::versions::maskSoFAndEarlier)
sneaking = false;
}
}
@@ -1486,19 +1486,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 = EQEmu::skills::Skill1HBlunt; sk <= EQEmu::skills::HIGHEST_SKILL; ++sk) {
if (sk == EQEmu::skills::SkillTinkering && GetRace() != GNOME) {
for (int sk = EQ::skills::Skill1HBlunt; sk <= EQ::skills::HIGHEST_SKILL; ++sk) {
if (sk == EQ::skills::SkillTinkering && GetRace() != GNOME) {
gmtrain->skills[sk] = 0; //Non gnomes can't tinker!
} else {
gmtrain->skills[sk] = GetMaxSkillAfterSpecializationRules((EQEmu::skills::SkillType)sk, MaxSkill((EQEmu::skills::SkillType)sk, GetClass(), RuleI(Character, MaxLevel)));
gmtrain->skills[sk] = GetMaxSkillAfterSpecializationRules((EQ::skills::SkillType)sk, MaxSkill((EQ::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[EQEmu::skills::Skill1HPiercing] = gmtrain->skills[EQEmu::skills::Skill2HPiercing];
gmtrain->skills[EQEmu::skills::Skill2HPiercing] = 0;
if (ClientVersion() < EQ::versions::ClientVersion::RoF2 && GetClass() == BERSERKER) {
gmtrain->skills[EQ::skills::Skill1HPiercing] = gmtrain->skills[EQ::skills::Skill2HPiercing];
gmtrain->skills[EQ::skills::Skill2HPiercing] = 0;
}
//#pragma GCC pop_options
@@ -1587,14 +1587,14 @@ void Client::OPGMTrainSkill(const EQApplicationPacket *app)
else if (gmskill->skillbank == 0x00)
{
// normal skills go here
if (gmskill->skill_id > EQEmu::skills::HIGHEST_SKILL)
if (gmskill->skill_id > EQ::skills::HIGHEST_SKILL)
{
std::cout << "Wrong Training Skill (abilities)" << std::endl;
DumpPacket(app);
return;
}
EQEmu::skills::SkillType skill = (EQEmu::skills::SkillType)gmskill->skill_id;
EQ::skills::SkillType skill = (EQ::skills::SkillType)gmskill->skill_id;
if(!CanHaveSkill(skill)) {
LogSkills("Tried to train skill [{}], which is not allowed", skill);
@@ -1619,27 +1619,27 @@ void Client::OPGMTrainSkill(const EQApplicationPacket *app)
SetSkill(skill, t_level);
} else {
switch(skill) {
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:
case EQ::skills::SkillBrewing:
case EQ::skills::SkillMakePoison:
case EQ::skills::SkillTinkering:
case EQ::skills::SkillResearch:
case EQ::skills::SkillAlchemy:
case EQ::skills::SkillBaking:
case EQ::skills::SkillTailoring:
case EQ::skills::SkillBlacksmithing:
case EQ::skills::SkillFletching:
case EQ::skills::SkillJewelryMaking:
case EQ::skills::SkillPottery:
if(skilllevel >= RuleI(Skills, MaxTrainTradeskills)) {
MessageString(Chat::Red, MORE_SKILLED_THAN_I, pTrainer->GetCleanName());
return;
}
break;
case EQEmu::skills::SkillSpecializeAbjure:
case EQEmu::skills::SkillSpecializeAlteration:
case EQEmu::skills::SkillSpecializeConjuration:
case EQEmu::skills::SkillSpecializeDivination:
case EQEmu::skills::SkillSpecializeEvocation:
case EQ::skills::SkillSpecializeAbjure:
case EQ::skills::SkillSpecializeAlteration:
case EQ::skills::SkillSpecializeConjuration:
case EQ::skills::SkillSpecializeDivination:
case EQ::skills::SkillSpecializeEvocation:
if(skilllevel >= RuleI(Skills, MaxTrainSpecializations)) {
MessageString(Chat::Red, MORE_SKILLED_THAN_I, pTrainer->GetCleanName());
return;
@@ -1656,7 +1656,7 @@ void Client::OPGMTrainSkill(const EQApplicationPacket *app)
return;
}
if (gmskill->skill_id >= EQEmu::skills::SkillSpecializeAbjure && gmskill->skill_id <= EQEmu::skills::SkillSpecializeEvocation)
if (gmskill->skill_id >= EQ::skills::SkillSpecializeAbjure && gmskill->skill_id <= EQ::skills::SkillSpecializeEvocation)
{
int MaxSpecSkill = GetMaxSkillAfterSpecializationRules(skill, MaxSkillValue);
if (skilllevel >= MaxSpecSkill)
@@ -1680,7 +1680,7 @@ void Client::OPGMTrainSkill(const EQApplicationPacket *app)
}
}
if (ClientVersion() >= EQEmu::versions::ClientVersion::SoF) {
if (ClientVersion() >= EQ::versions::ClientVersion::SoF) {
// The following packet decreases the skill points left in the Training Window and
// produces the 'You have increased your skill / learned the basics of' message.
//
@@ -1694,7 +1694,7 @@ void Client::OPGMTrainSkill(const EQApplicationPacket *app)
gmtsc->SkillID += 100;
}
else
gmtsc->NewSkill = (GetRawSkill((EQEmu::skills::SkillType)gmtsc->SkillID) == 1);
gmtsc->NewSkill = (GetRawSkill((EQ::skills::SkillType)gmtsc->SkillID) == 1);
gmtsc->Cost = Cost;
@@ -1775,8 +1775,8 @@ void Client::DoManaRegen() {
if (GetMana() >= max_mana && spellbonuses.ManaRegen >= 0)
return;
if (GetMana() < max_mana && (IsSitting() || CanMedOnHorse()) && HasSkill(EQEmu::skills::SkillMeditate))
CheckIncreaseSkill(EQEmu::skills::SkillMeditate, nullptr, -5);
if (GetMana() < max_mana && (IsSitting() || CanMedOnHorse()) && HasSkill(EQ::skills::SkillMeditate))
CheckIncreaseSkill(EQ::skills::SkillMeditate, nullptr, -5);
SetMana(GetMana() + CalcManaRegen());
CheckManaEndUpdate();
@@ -1794,11 +1794,11 @@ void Client::DoStaminaHungerUpdate()
if (GetHorseId() != 0)
loss *= 3;
m_pp.hunger_level = EQEmu::Clamp(m_pp.hunger_level - loss, 0, 6000);
m_pp.thirst_level = EQEmu::Clamp(m_pp.thirst_level - loss, 0, 6000);
m_pp.hunger_level = EQ::Clamp(m_pp.hunger_level - loss, 0, 6000);
m_pp.thirst_level = EQ::Clamp(m_pp.thirst_level - loss, 0, 6000);
if (spellbonuses.hunger) {
m_pp.hunger_level = EQEmu::ClampLower(m_pp.hunger_level, 3500);
m_pp.thirst_level = EQEmu::ClampLower(m_pp.thirst_level, 3500);
m_pp.hunger_level = EQ::ClampLower(m_pp.hunger_level, 3500);
m_pp.thirst_level = EQ::ClampLower(m_pp.thirst_level, 3500);
}
sta->food = m_pp.hunger_level;
sta->water = m_pp.thirst_level;
@@ -2113,7 +2113,7 @@ void Client::ClearHover()
entity_list.QueueClients(this, outapp, false);
safe_delete(outapp);
if (IsClient() && CastToClient()->ClientVersionBit() & EQEmu::versions::maskUFAndLater)
if (IsClient() && CastToClient()->ClientVersionBit() & EQ::versions::maskUFAndLater)
{
EQApplicationPacket *outapp = MakeBuffsPacket(false);
CastToClient()->FastQueuePacket(&outapp);
zone/command.cpp
+126 -126
View File
@@ -1569,7 +1569,7 @@ void command_list(Client *c, const Seperator *sep)
c->Message(
0,
"| %s | ID %5d | %s | x %.0f | y %0.f | z %.0f",
EQEmu::SayLinkEngine::GenerateQuestSaylink(saylink, false, "Goto").c_str(),
EQ::SayLinkEngine::GenerateQuestSaylink(saylink, false, "Goto").c_str(),
entity->GetID(),
entity->GetName(),
entity->GetX(),
@@ -1610,7 +1610,7 @@ void command_list(Client *c, const Seperator *sep)
c->Message(
0,
"| %s | ID %5d | %s | x %.0f | y %0.f | z %.0f",
EQEmu::SayLinkEngine::GenerateQuestSaylink(saylink, false, "Goto").c_str(),
EQ::SayLinkEngine::GenerateQuestSaylink(saylink, false, "Goto").c_str(),
entity->GetID(),
entity->GetName(),
entity->GetX(),
@@ -1651,7 +1651,7 @@ void command_list(Client *c, const Seperator *sep)
c->Message(
0,
"| %s | ID %5d | %s | x %.0f | y %0.f | z %.0f",
EQEmu::SayLinkEngine::GenerateQuestSaylink(saylink, false, "Goto").c_str(),
EQ::SayLinkEngine::GenerateQuestSaylink(saylink, false, "Goto").c_str(),
entity->GetID(),
entity->GetName(),
entity->GetX(),
@@ -1692,7 +1692,7 @@ void command_list(Client *c, const Seperator *sep)
c->Message(
0,
"| %s | Entity ID %5d | Door ID %i | %s | x %.0f | y %0.f | z %.0f",
EQEmu::SayLinkEngine::GenerateQuestSaylink(saylink, false, "Goto").c_str(),
EQ::SayLinkEngine::GenerateQuestSaylink(saylink, false, "Goto").c_str(),
entity->GetID(),
entity->GetDoorID(),
entity->GetDoorName(),
@@ -1734,7 +1734,7 @@ void command_list(Client *c, const Seperator *sep)
c->Message(
0,
"| %s | Entity ID %5d | Object DBID %i | %s | x %.0f | y %0.f | z %.0f",
EQEmu::SayLinkEngine::GenerateQuestSaylink(saylink, false, "Goto").c_str(),
EQ::SayLinkEngine::GenerateQuestSaylink(saylink, false, "Goto").c_str(),
entity->GetID(),
entity->GetDBID(),
entity->GetModelName(),
@@ -2624,7 +2624,7 @@ void command_showskills(Client *c, const Seperator *sep)
t=c->GetTarget()->CastToClient();
c->Message(Chat::White, "Skills for %s", t->GetName());
for (EQEmu::skills::SkillType i = EQEmu::skills::Skill1HBlunt; i <= EQEmu::skills::HIGHEST_SKILL; i = (EQEmu::skills::SkillType)(i + 1))
for (EQ::skills::SkillType i = EQ::skills::Skill1HBlunt; i <= EQ::skills::HIGHEST_SKILL; i = (EQ::skills::SkillType)(i + 1))
c->Message(Chat::White, "Skill [%d] is at [%d] - %u", i, t->GetSkill(i), t->GetRawSkill(i));
}
@@ -2693,14 +2693,14 @@ void command_castspell(Client *c, const Seperator *sep)
else
if (c->GetTarget() == 0)
if(c->Admin() >= commandInstacast)
c->SpellFinished(spellid, 0, EQEmu::spells::CastingSlot::Item, 0, -1, spells[spellid].ResistDiff);
c->SpellFinished(spellid, 0, EQ::spells::CastingSlot::Item, 0, -1, spells[spellid].ResistDiff);
else
c->CastSpell(spellid, 0, EQEmu::spells::CastingSlot::Item, 0);
c->CastSpell(spellid, 0, EQ::spells::CastingSlot::Item, 0);
else
if(c->Admin() >= commandInstacast)
c->SpellFinished(spellid, c->GetTarget(), EQEmu::spells::CastingSlot::Item, 0, -1, spells[spellid].ResistDiff);
c->SpellFinished(spellid, c->GetTarget(), EQ::spells::CastingSlot::Item, 0, -1, spells[spellid].ResistDiff);
else
c->CastSpell(spellid, c->GetTarget()->GetID(), EQEmu::spells::CastingSlot::Item, 0);
c->CastSpell(spellid, c->GetTarget()->GetID(), EQ::spells::CastingSlot::Item, 0);
}
}
@@ -2772,20 +2772,20 @@ void command_setskill(Client *c, const Seperator *sep)
c->Message(Chat::White, "Error: #setskill: Target must be a client.");
}
else if (
!sep->IsNumber(1) || atoi(sep->arg[1]) < 0 || atoi(sep->arg[1]) > EQEmu::skills::HIGHEST_SKILL ||
!sep->IsNumber(1) || atoi(sep->arg[1]) < 0 || atoi(sep->arg[1]) > EQ::skills::HIGHEST_SKILL ||
!sep->IsNumber(2) || atoi(sep->arg[2]) < 0 || atoi(sep->arg[2]) > HIGHEST_CAN_SET_SKILL
)
{
c->Message(Chat::White, "Usage: #setskill skill x ");
c->Message(Chat::White, " skill = 0 to %d", EQEmu::skills::HIGHEST_SKILL);
c->Message(Chat::White, " skill = 0 to %d", EQ::skills::HIGHEST_SKILL);
c->Message(Chat::White, " x = 0 to %d", HIGHEST_CAN_SET_SKILL);
}
else {
LogInfo("Set skill request from [{}], target:[{}] skill_id:[{}] value:[{}]", 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 <= EQEmu::skills::HIGHEST_SKILL)
c->GetTarget()->CastToClient()->SetSkill((EQEmu::skills::SkillType)skill_num, skill_value);
if (skill_num <= EQ::skills::HIGHEST_SKILL)
c->GetTarget()->CastToClient()->SetSkill((EQ::skills::SkillType)skill_num, skill_value);
}
}
@@ -2803,7 +2803,7 @@ void command_setskillall(Client *c, const Seperator *sep)
if (c->Admin() >= commandSetSkillsOther || c->GetTarget()==c || c->GetTarget()==0) {
LogInfo("Set ALL skill request from [{}], target:[{}]", c->GetName(), c->GetTarget()->GetName());
uint16 level = atoi(sep->arg[1]);
for (EQEmu::skills::SkillType skill_num = EQEmu::skills::Skill1HBlunt; skill_num <= EQEmu::skills::HIGHEST_SKILL; skill_num = (EQEmu::skills::SkillType)(skill_num + 1)) {
for (EQ::skills::SkillType skill_num = EQ::skills::Skill1HBlunt; skill_num <= EQ::skills::HIGHEST_SKILL; skill_num = (EQ::skills::SkillType)(skill_num + 1)) {
c->GetTarget()->CastToClient()->SetSkill(skill_num, level);
}
}
@@ -2992,7 +2992,7 @@ void command_spawneditmass(Client *c, const Seperator *sep)
if (found_count > 0) {
c->Message(
Chat::Yellow, "To apply these changes, click <%s> or type [%s]",
EQEmu::SayLinkEngine::GenerateQuestSaylink(saylink, false, "Apply").c_str(),
EQ::SayLinkEngine::GenerateQuestSaylink(saylink, false, "Apply").c_str(),
saylink.c_str()
);
}
@@ -3060,14 +3060,14 @@ void command_texture(Client *c, const Seperator *sep)
// Player Races Wear Armor, so Wearchange is sent instead
int i;
if (!c->GetTarget())
for (i = EQEmu::textures::textureBegin; i <= EQEmu::textures::LastTintableTexture; i++)
for (i = EQ::textures::textureBegin; i <= EQ::textures::LastTintableTexture; i++)
{
c->SendTextureWC(i, texture);
}
else if ((c->GetTarget()->GetModel() > 0 && c->GetTarget()->GetModel() <= 12) ||
c->GetTarget()->GetModel() == 128 || c->GetTarget()->GetModel() == 130 ||
c->GetTarget()->GetModel() == 330 || c->GetTarget()->GetModel() == 522) {
for (i = EQEmu::textures::textureBegin; i <= EQEmu::textures::LastTintableTexture; i++)
for (i = EQ::textures::textureBegin; i <= EQ::textures::LastTintableTexture; i++)
{
c->GetTarget()->SendTextureWC(i, texture);
}
@@ -3249,15 +3249,15 @@ void command_peekinv(Client *c, const Seperator *sep)
static const char* scope_prefix[] = { "equip", "gen", "cursor", "limbo", "trib", "bank", "shbank", "trade", "world" };
static const int16 scope_range[][2] = {
{ EQEmu::invslot::EQUIPMENT_BEGIN, EQEmu::invslot::EQUIPMENT_END },
{ EQEmu::invslot::GENERAL_BEGIN, EQEmu::invslot::GENERAL_END },
{ EQEmu::invslot::slotCursor, EQEmu::invslot::slotCursor },
{ EQEmu::invslot::SLOT_INVALID, EQEmu::invslot::SLOT_INVALID },
{ EQEmu::invslot::TRIBUTE_BEGIN, EQEmu::invslot::TRIBUTE_END },
{ EQEmu::invslot::BANK_BEGIN, EQEmu::invslot::BANK_END },
{ EQEmu::invslot::SHARED_BANK_BEGIN, EQEmu::invslot::SHARED_BANK_END },
{ EQEmu::invslot::TRADE_BEGIN, EQEmu::invslot::TRADE_END },
{ EQEmu::invslot::SLOT_BEGIN, (EQEmu::invtype::WORLD_SIZE - 1) }
{ EQ::invslot::EQUIPMENT_BEGIN, EQ::invslot::EQUIPMENT_END },
{ EQ::invslot::GENERAL_BEGIN, EQ::invslot::GENERAL_END },
{ EQ::invslot::slotCursor, EQ::invslot::slotCursor },
{ EQ::invslot::SLOT_INVALID, EQ::invslot::SLOT_INVALID },
{ EQ::invslot::TRIBUTE_BEGIN, EQ::invslot::TRIBUTE_END },
{ EQ::invslot::BANK_BEGIN, EQ::invslot::BANK_END },
{ EQ::invslot::SHARED_BANK_BEGIN, EQ::invslot::SHARED_BANK_END },
{ EQ::invslot::TRADE_BEGIN, EQ::invslot::TRADE_END },
{ EQ::invslot::SLOT_BEGIN, (EQ::invtype::WORLD_SIZE - 1) }
};
static const bool scope_bag[] = { false, true, true, true, false, true, true, true, true };
@@ -3297,13 +3297,13 @@ void command_peekinv(Client *c, const Seperator *sep)
if (c->GetTarget())
targetClient = c->GetTarget()->CastToClient();
const EQEmu::ItemInstance* inst_main = nullptr;
const EQEmu::ItemInstance* inst_sub = nullptr;
const EQEmu::ItemInstance* inst_aug = nullptr;
const EQEmu::ItemData* item_data = nullptr;
const EQ::ItemInstance* inst_main = nullptr;
const EQ::ItemInstance* inst_sub = nullptr;
const EQ::ItemInstance* inst_aug = nullptr;
const EQ::ItemData* item_data = nullptr;
EQEmu::SayLinkEngine linker;
linker.SetLinkType(EQEmu::saylink::SayLinkItemInst);
EQ::SayLinkEngine linker;
linker.SetLinkType(EQ::saylink::SayLinkItemInst);
c->Message(Chat::White, "Displaying inventory for %s...", targetClient->GetName());
@@ -3326,7 +3326,7 @@ void command_peekinv(Client *c, const Seperator *sep)
}
for (int16 indexMain = scope_range[scopeIndex][0]; indexMain <= scope_range[scopeIndex][1]; ++indexMain) {
if (indexMain == EQEmu::invslot::SLOT_INVALID)
if (indexMain == EQ::invslot::SLOT_INVALID)
continue;
inst_main = ((scopeBit & peekWorld) ? objectTradeskill->GetItem(indexMain) : targetClient->GetInv().GetItem(indexMain));
@@ -3344,14 +3344,14 @@ void command_peekinv(Client *c, const Seperator *sep)
(item_data == nullptr),
"%sSlot: %i, Item: %i (%s), Charges: %i",
scope_prefix[scopeIndex],
((scopeBit & peekWorld) ? (EQEmu::invslot::WORLD_BEGIN + indexMain) : indexMain),
((scopeBit & peekWorld) ? (EQ::invslot::WORLD_BEGIN + indexMain) : indexMain),
((item_data == nullptr) ? 0 : item_data->ID),
linker.GenerateLink().c_str(),
((inst_main == nullptr) ? 0 : inst_main->GetCharges())
);
if (inst_main && inst_main->IsClassCommon()) {
for (uint8 indexAug = EQEmu::invaug::SOCKET_BEGIN; indexAug <= EQEmu::invaug::SOCKET_END; ++indexAug) {
for (uint8 indexAug = EQ::invaug::SOCKET_BEGIN; indexAug <= EQ::invaug::SOCKET_END; ++indexAug) {
inst_aug = inst_main->GetItem(indexAug);
if (!inst_aug) // extant only
continue;
@@ -3364,7 +3364,7 @@ void command_peekinv(Client *c, const Seperator *sep)
".%sAugSlot: %i (Slot #%i, Aug idx #%i), Item: %i (%s), Charges: %i",
scope_prefix[scopeIndex],
INVALID_INDEX,
((scopeBit & peekWorld) ? (EQEmu::invslot::WORLD_BEGIN + indexMain) : indexMain),
((scopeBit & peekWorld) ? (EQ::invslot::WORLD_BEGIN + indexMain) : indexMain),
indexAug,
((item_data == nullptr) ? 0 : item_data->ID),
linker.GenerateLink().c_str(),
@@ -3376,7 +3376,7 @@ void command_peekinv(Client *c, const Seperator *sep)
if (!scope_bag[scopeIndex] || !(inst_main && inst_main->IsClassBag()))
continue;
for (uint8 indexSub = EQEmu::invbag::SLOT_BEGIN; indexSub <= EQEmu::invbag::SLOT_END; ++indexSub) {
for (uint8 indexSub = EQ::invbag::SLOT_BEGIN; indexSub <= EQ::invbag::SLOT_END; ++indexSub) {
inst_sub = inst_main->GetItem(indexSub);
if (!inst_sub) // extant only
continue;
@@ -3388,8 +3388,8 @@ void command_peekinv(Client *c, const Seperator *sep)
(item_data == nullptr),
"..%sBagSlot: %i (Slot #%i, Bag idx #%i), Item: %i (%s), Charges: %i",
scope_prefix[scopeIndex],
((scopeBit & peekWorld) ? INVALID_INDEX : EQEmu::InventoryProfile::CalcSlotId(indexMain, indexSub)),
((scopeBit & peekWorld) ? (EQEmu::invslot::WORLD_BEGIN + indexMain) : indexMain),
((scopeBit & peekWorld) ? INVALID_INDEX : EQ::InventoryProfile::CalcSlotId(indexMain, indexSub)),
((scopeBit & peekWorld) ? (EQ::invslot::WORLD_BEGIN + indexMain) : indexMain),
indexSub,
((item_data == nullptr) ? 0 : item_data->ID),
linker.GenerateLink().c_str(),
@@ -3397,7 +3397,7 @@ void command_peekinv(Client *c, const Seperator *sep)
);
if (inst_sub->IsClassCommon()) {
for (uint8 indexAug = EQEmu::invaug::SOCKET_BEGIN; indexAug <= EQEmu::invaug::SOCKET_END; ++indexAug) {
for (uint8 indexAug = EQ::invaug::SOCKET_BEGIN; indexAug <= EQ::invaug::SOCKET_END; ++indexAug) {
inst_aug = inst_sub->GetItem(indexAug);
if (!inst_aug) // extant only
continue;
@@ -3410,7 +3410,7 @@ void command_peekinv(Client *c, const Seperator *sep)
"...%sAugSlot: %i (Slot #%i, Sub idx #%i, Aug idx #%i), Item: %i (%s), Charges: %i",
scope_prefix[scopeIndex],
INVALID_INDEX,
((scopeBit & peekWorld) ? INVALID_INDEX : EQEmu::InventoryProfile::CalcSlotId(indexMain, indexSub)),
((scopeBit & peekWorld) ? INVALID_INDEX : EQ::InventoryProfile::CalcSlotId(indexMain, indexSub)),
indexSub,
indexAug,
((item_data == nullptr) ? 0 : item_data->ID),
@@ -3450,7 +3450,7 @@ void command_peekinv(Client *c, const Seperator *sep)
);
if (inst_main && inst_main->IsClassCommon()) {
for (uint8 indexAug = EQEmu::invaug::SOCKET_BEGIN; indexAug <= EQEmu::invaug::SOCKET_END; ++indexAug) {
for (uint8 indexAug = EQ::invaug::SOCKET_BEGIN; indexAug <= EQ::invaug::SOCKET_END; ++indexAug) {
inst_aug = inst_main->GetItem(indexAug);
if (!inst_aug) // extant only
continue;
@@ -3475,7 +3475,7 @@ void command_peekinv(Client *c, const Seperator *sep)
if (!scope_bag[scopeIndex] || !(inst_main && inst_main->IsClassBag()))
continue;
for (uint8 indexSub = EQEmu::invbag::SLOT_BEGIN; indexSub <= EQEmu::invbag::SLOT_END; ++indexSub) {
for (uint8 indexSub = EQ::invbag::SLOT_BEGIN; indexSub <= EQ::invbag::SLOT_END; ++indexSub) {
inst_sub = inst_main->GetItem(indexSub);
if (!inst_sub)
continue;
@@ -3497,7 +3497,7 @@ void command_peekinv(Client *c, const Seperator *sep)
);
if (inst_sub->IsClassCommon()) {
for (uint8 indexAug = EQEmu::invaug::SOCKET_BEGIN; indexAug <= EQEmu::invaug::SOCKET_END; ++indexAug) {
for (uint8 indexAug = EQ::invaug::SOCKET_BEGIN; indexAug <= EQ::invaug::SOCKET_END; ++indexAug) {
inst_aug = inst_sub->GetItem(indexAug);
if (!inst_aug) // extant only
continue;
@@ -3557,7 +3557,7 @@ void command_interrogateinv(Client *c, const Seperator *sep)
}
Client* target = nullptr;
std::map<int16, const EQEmu::ItemInstance*> instmap;
std::map<int16, const EQ::ItemInstance*> instmap;
bool log = false;
bool silent = false;
bool error = false;
@@ -4063,7 +4063,7 @@ void command_faction(Client *c, const Seperator *sep)
std::string fvalue = rrow[2];
_ctr2++;
std::string resetlink = fmt::format("#faction reset {}", f_id);
c->Message(Chat::Yellow, "Reset: %s id: %s (%s)", EQEmu::SayLinkEngine::GenerateQuestSaylink(resetlink, false, cname.c_str()).c_str(), std::to_string(f_id).c_str(), fvalue.c_str());
c->Message(Chat::Yellow, "Reset: %s id: %s (%s)", EQ::SayLinkEngine::GenerateQuestSaylink(resetlink, false, cname.c_str()).c_str(), std::to_string(f_id).c_str(), fvalue.c_str());
}
std::string response = _ctr2 > 0 ? fmt::format("Found {} matching factions", _ctr2).c_str() : "No faction hits found.";
c->Message(Chat::Yellow, response.c_str());
@@ -4159,8 +4159,8 @@ void command_findzone(Client *c, const Seperator *sep)
break;
}
std::string command_zone = EQEmu::SayLinkEngine::GenerateQuestSaylink("#zone " + short_name, false, "zone");
std::string command_gmzone = EQEmu::SayLinkEngine::GenerateQuestSaylink(
std::string command_zone = EQ::SayLinkEngine::GenerateQuestSaylink("#zone " + short_name, false, "zone");
std::string command_gmzone = EQ::SayLinkEngine::GenerateQuestSaylink(
fmt::format("#gmzone {} {}", short_name, version),
false,
"gmzone"
@@ -4410,16 +4410,16 @@ void command_listpetition(Client *c, const Seperator *sep)
void command_equipitem(Client *c, const Seperator *sep)
{
uint32 slot_id = atoi(sep->arg[1]);
if (sep->IsNumber(1) && (slot_id >= EQEmu::invslot::EQUIPMENT_BEGIN && slot_id <= EQEmu::invslot::EQUIPMENT_END)) {
const EQEmu::ItemInstance* from_inst = c->GetInv().GetItem(EQEmu::invslot::slotCursor);
const EQEmu::ItemInstance* to_inst = c->GetInv().GetItem(slot_id); // added (desync issue when forcing stack to stack)
if (sep->IsNumber(1) && (slot_id >= EQ::invslot::EQUIPMENT_BEGIN && slot_id <= EQ::invslot::EQUIPMENT_END)) {
const EQ::ItemInstance* from_inst = c->GetInv().GetItem(EQ::invslot::slotCursor);
const EQ::ItemInstance* to_inst = c->GetInv().GetItem(slot_id); // added (desync issue when forcing stack to stack)
bool partialmove = false;
int16 movecount;
if (from_inst && from_inst->IsClassCommon()) {
auto outapp = new EQApplicationPacket(OP_MoveItem, sizeof(MoveItem_Struct));
MoveItem_Struct* mi = (MoveItem_Struct*)outapp->pBuffer;
mi->from_slot = EQEmu::invslot::slotCursor;
mi->from_slot = EQ::invslot::slotCursor;
mi->to_slot = slot_id;
// mi->number_in_stack = from_inst->GetCharges(); // replaced with con check for stacking
@@ -5151,7 +5151,7 @@ void command_memspell(Client *c, const Seperator *sep)
{
slot = atoi(sep->arg[1]) - 1;
spell_id = atoi(sep->arg[2]);
if (slot > EQEmu::spells::SPELL_GEM_COUNT || spell_id >= SPDAT_RECORDS)
if (slot > EQ::spells::SPELL_GEM_COUNT || spell_id >= SPDAT_RECORDS)
{
c->Message(Chat::White, "Error: #MemSpell: Arguement out of range");
}
@@ -5249,11 +5249,11 @@ void command_devtools(Client *c, const Seperator *sep)
/**
* Search entity commands
*/
menu_commands_search += "[" + EQEmu::SayLinkEngine::GenerateQuestSaylink("#list npcs", false, "NPC") + "] ";
menu_commands_search += "[" + EQEmu::SayLinkEngine::GenerateQuestSaylink("#list players", false, "Players") + "] ";
menu_commands_search += "[" + EQEmu::SayLinkEngine::GenerateQuestSaylink("#list corpses", false, "Corpses") + "] ";
menu_commands_search += "[" + EQEmu::SayLinkEngine::GenerateQuestSaylink("#list doors", false, "Doors") + "] ";
menu_commands_search += "[" + EQEmu::SayLinkEngine::GenerateQuestSaylink("#list objects", false, "Objects") + "] ";
menu_commands_search += "[" + EQ::SayLinkEngine::GenerateQuestSaylink("#list npcs", false, "NPC") + "] ";
menu_commands_search += "[" + EQ::SayLinkEngine::GenerateQuestSaylink("#list players", false, "Players") + "] ";
menu_commands_search += "[" + EQ::SayLinkEngine::GenerateQuestSaylink("#list corpses", false, "Corpses") + "] ";
menu_commands_search += "[" + EQ::SayLinkEngine::GenerateQuestSaylink("#list doors", false, "Doors") + "] ";
menu_commands_search += "[" + EQ::SayLinkEngine::GenerateQuestSaylink("#list objects", false, "Objects") + "] ";
std::string dev_tools_window_key = StringFormat("%i-dev-tools-window-disabled", c->AccountID());
@@ -5272,9 +5272,9 @@ void command_devtools(Client *c, const Seperator *sep)
/**
* Show window status
*/
window_toggle_command = "Disabled [" + EQEmu::SayLinkEngine::GenerateQuestSaylink("#devtools enable_window", false, "Enable") + "] ";
window_toggle_command = "Disabled [" + EQ::SayLinkEngine::GenerateQuestSaylink("#devtools enable_window", false, "Enable") + "] ";
if (c->IsDevToolsWindowEnabled()) {
window_toggle_command = "Enabled [" + EQEmu::SayLinkEngine::GenerateQuestSaylink("#devtools disable_window", false, "Disable") + "] ";
window_toggle_command = "Enabled [" + EQ::SayLinkEngine::GenerateQuestSaylink("#devtools disable_window", false, "Disable") + "] ";
}
/**
@@ -5546,7 +5546,7 @@ void command_proximity(Client *c, const Seperator *sep)
points.push_back(p);
}
if (c->ClientVersion() >= EQEmu::versions::ClientVersion::RoF) {
if (c->ClientVersion() >= EQ::versions::ClientVersion::RoF) {
c->SendPathPacket(points);
}
}
@@ -5723,7 +5723,7 @@ void command_killallnpcs(Client *c, const Seperator *sep)
continue;
}
entity->Damage(c, 1000000000, 0, EQEmu::skills::SkillDragonPunch);
entity->Damage(c, 1000000000, 0, EQ::skills::SkillDragonPunch);
count++;
}
@@ -5759,7 +5759,7 @@ void command_damage(Client *c, const Seperator *sep)
if (nkdmg > 2100000000)
c->Message(Chat::White, "Enter a value less then 2,100,000,000.");
else
c->GetTarget()->Damage(c, nkdmg, SPELL_UNKNOWN, EQEmu::skills::SkillHandtoHand, false);
c->GetTarget()->Damage(c, nkdmg, SPELL_UNKNOWN, EQ::skills::SkillHandtoHand, false);
}
}
@@ -5949,7 +5949,7 @@ void command_goto(Client *c, const Seperator *sep)
void command_iteminfo(Client *c, const Seperator *sep)
{
auto inst = c->GetInv()[EQEmu::invslot::slotCursor];
auto inst = c->GetInv()[EQ::invslot::slotCursor];
if (!inst) {
c->Message(Chat::Red, "Error: You need an item on your cursor for this command");
return;
@@ -5961,8 +5961,8 @@ void command_iteminfo(Client *c, const Seperator *sep)
return;
}
EQEmu::SayLinkEngine linker;
linker.SetLinkType(EQEmu::saylink::SayLinkItemInst);
EQ::SayLinkEngine linker;
linker.SetLinkType(EQ::saylink::SayLinkItemInst);
linker.SetItemInst(inst);
c->Message(Chat::White, "*** Item Info for [%s] ***", linker.GenerateLink().c_str());
@@ -6653,7 +6653,7 @@ void command_editmassrespawn(Client* c, const Seperator* sep)
c->Message(
Chat::Yellow, "To apply these changes, click <%s> or type [%s]",
EQEmu::SayLinkEngine::GenerateQuestSaylink(saylink, false, "Apply").c_str(),
EQ::SayLinkEngine::GenerateQuestSaylink(saylink, false, "Apply").c_str(),
saylink.c_str()
);
}
@@ -7027,7 +7027,7 @@ void command_scribespells(Client *c, const Seperator *sep)
int spell_id = 0;
int count = 0;
for ( ; spell_id < SPDAT_RECORDS && book_slot < EQEmu::spells::SPELLBOOK_SIZE; ++spell_id) {
for ( ; spell_id < SPDAT_RECORDS && book_slot < EQ::spells::SPELLBOOK_SIZE; ++spell_id) {
if (book_slot == -1) {
t->Message(
13,
@@ -7050,8 +7050,8 @@ void command_scribespells(Client *c, const Seperator *sep)
c->Message(Chat::Red, "FATAL ERROR: Spell id out-of-range (id: %i, min: 0, max: %i)", spell_id, SPDAT_RECORDS);
return;
}
if (book_slot < 0 || book_slot >= EQEmu::spells::SPELLBOOK_SIZE) {
c->Message(Chat::Red, "FATAL ERROR: Book slot out-of-range (slot: %i, min: 0, max: %i)", book_slot, EQEmu::spells::SPELLBOOK_SIZE);
if (book_slot < 0 || book_slot >= EQ::spells::SPELLBOOK_SIZE) {
c->Message(Chat::Red, "FATAL ERROR: Book slot out-of-range (slot: %i, min: 0, max: %i)", book_slot, EQ::spells::SPELLBOOK_SIZE);
return;
}
@@ -7286,9 +7286,9 @@ void command_summonitem(Client *c, const Seperator *sep)
std::string cmd_msg = sep->msg;
size_t link_open = cmd_msg.find('\x12');
size_t link_close = cmd_msg.find_last_of('\x12');
if (link_open != link_close && (cmd_msg.length() - link_open) > EQEmu::constants::SAY_LINK_BODY_SIZE) {
EQEmu::SayLinkBody_Struct link_body;
EQEmu::saylink::DegenerateLinkBody(link_body, cmd_msg.substr(link_open + 1, EQEmu::constants::SAY_LINK_BODY_SIZE));
if (link_open != link_close && (cmd_msg.length() - link_open) > EQ::constants::SAY_LINK_BODY_SIZE) {
EQ::SayLinkBody_Struct link_body;
EQ::saylink::DegenerateLinkBody(link_body, cmd_msg.substr(link_open + 1, EQ::constants::SAY_LINK_BODY_SIZE));
itemid = link_body.item_id;
}
else if (!sep->IsNumber(1)) {
@@ -7304,7 +7304,7 @@ void command_summonitem(Client *c, const Seperator *sep)
}
int16 item_status = 0;
const EQEmu::ItemData* item = database.GetItem(itemid);
const EQ::ItemData* item = database.GetItem(itemid);
if (item) {
item_status = static_cast<int16>(item->MinStatus);
}
@@ -7343,7 +7343,7 @@ void command_giveitem(Client *c, const Seperator *sep)
Client *t = c->GetTarget()->CastToClient();
uint32 itemid = atoi(sep->arg[1]);
int16 item_status = 0;
const EQEmu::ItemData* item = database.GetItem(itemid);
const EQ::ItemData* item = database.GetItem(itemid);
if(item) {
item_status = static_cast<int16>(item->MinStatus);
}
@@ -7396,9 +7396,9 @@ void command_itemsearch(Client *c, const Seperator *sep)
{
const char *search_criteria=sep->argplus[1];
const EQEmu::ItemData* item = nullptr;
EQEmu::SayLinkEngine linker;
linker.SetLinkType(EQEmu::saylink::SayLinkItemData);
const EQ::ItemData* item = nullptr;
EQ::SayLinkEngine linker;
linker.SetLinkType(EQ::saylink::SayLinkItemData);
if (Seperator::IsNumber(search_criteria)) {
item = database.GetItem(atoi(search_criteria));
@@ -8101,7 +8101,7 @@ void command_npceditmass(Client *c, const Seperator *sep)
if (found_count > 0) {
c->Message(
Chat::Yellow, "To apply these changes, click <%s> or type [%s]",
EQEmu::SayLinkEngine::GenerateQuestSaylink(saylink, false, "Apply").c_str(),
EQ::SayLinkEngine::GenerateQuestSaylink(saylink, false, "Apply").c_str(),
saylink.c_str()
);
}
@@ -8889,9 +8889,9 @@ void command_path(Client *c, const Seperator *sep)
}
void Client::Undye() {
for (int cur_slot = EQEmu::textures::textureBegin; cur_slot <= EQEmu::textures::LastTexture; cur_slot++) {
for (int cur_slot = EQ::textures::textureBegin; cur_slot <= EQ::textures::LastTexture; cur_slot++) {
uint8 slot2=SlotConvert(cur_slot);
EQEmu::ItemInstance* inst = m_inv.GetItem(slot2);
EQ::ItemInstance* inst = m_inv.GetItem(slot2);
if(inst != nullptr) {
inst->SetColor(inst->GetItem()->Color);
@@ -8930,30 +8930,30 @@ void command_ucs(Client *c, const Seperator *sep)
std::string buffer;
std::string MailKey = database.GetMailKey(c->CharacterID(), true);
EQEmu::versions::UCSVersion ConnectionType = EQEmu::versions::ucsUnknown;
EQ::versions::UCSVersion ConnectionType = EQ::versions::ucsUnknown;
// chat server packet
switch (c->ClientVersion()) {
case EQEmu::versions::ClientVersion::Titanium:
ConnectionType = EQEmu::versions::ucsTitaniumChat;
case EQ::versions::ClientVersion::Titanium:
ConnectionType = EQ::versions::ucsTitaniumChat;
break;
case EQEmu::versions::ClientVersion::SoF:
ConnectionType = EQEmu::versions::ucsSoFCombined;
case EQ::versions::ClientVersion::SoF:
ConnectionType = EQ::versions::ucsSoFCombined;
break;
case EQEmu::versions::ClientVersion::SoD:
ConnectionType = EQEmu::versions::ucsSoDCombined;
case EQ::versions::ClientVersion::SoD:
ConnectionType = EQ::versions::ucsSoDCombined;
break;
case EQEmu::versions::ClientVersion::UF:
ConnectionType = EQEmu::versions::ucsUFCombined;
case EQ::versions::ClientVersion::UF:
ConnectionType = EQ::versions::ucsUFCombined;
break;
case EQEmu::versions::ClientVersion::RoF:
ConnectionType = EQEmu::versions::ucsRoFCombined;
case EQ::versions::ClientVersion::RoF:
ConnectionType = EQ::versions::ucsRoFCombined;
break;
case EQEmu::versions::ClientVersion::RoF2:
ConnectionType = EQEmu::versions::ucsRoF2Combined;
case EQ::versions::ClientVersion::RoF2:
ConnectionType = EQ::versions::ucsRoF2Combined;
break;
default:
ConnectionType = EQEmu::versions::ucsUnknown;
ConnectionType = EQ::versions::ucsUnknown;
break;
}
@@ -8975,8 +8975,8 @@ void command_ucs(Client *c, const Seperator *sep)
// mail server packet
switch (c->ClientVersion()) {
case EQEmu::versions::ClientVersion::Titanium:
ConnectionType = EQEmu::versions::ucsTitaniumMail;
case EQ::versions::ClientVersion::Titanium:
ConnectionType = EQ::versions::ucsTitaniumMail;
break;
default:
// retain value from previous switch
@@ -11864,16 +11864,16 @@ void command_max_all_skills(Client *c, const Seperator *sep)
{
if(c)
{
for (int i = 0; i <= EQEmu::skills::HIGHEST_SKILL; ++i)
for (int i = 0; i <= EQ::skills::HIGHEST_SKILL; ++i)
{
if (i >= EQEmu::skills::SkillSpecializeAbjure && i <= EQEmu::skills::SkillSpecializeEvocation)
if (i >= EQ::skills::SkillSpecializeAbjure && i <= EQ::skills::SkillSpecializeEvocation)
{
c->SetSkill((EQEmu::skills::SkillType)i, 50);
c->SetSkill((EQ::skills::SkillType)i, 50);
}
else
{
int max_skill_level = database.GetSkillCap(c->GetClass(), (EQEmu::skills::SkillType)i, c->GetLevel());
c->SetSkill((EQEmu::skills::SkillType)i, max_skill_level);
int max_skill_level = database.GetSkillCap(c->GetClass(), (EQ::skills::SkillType)i, c->GetLevel());
c->SetSkill((EQ::skills::SkillType)i, max_skill_level);
}
}
}
@@ -11959,14 +11959,14 @@ void command_disarmtrap(Client *c, const Seperator *sep)
if(target->IsNPC())
{
if (c->HasSkill(EQEmu::skills::SkillDisarmTraps))
if (c->HasSkill(EQ::skills::SkillDisarmTraps))
{
if(DistanceSquaredNoZ(c->GetPosition(), target->GetPosition()) > RuleI(Adventure, LDoNTrapDistanceUse))
{
c->Message(Chat::Red, "%s is too far away.", target->GetCleanName());
return;
}
c->HandleLDoNDisarm(target->CastToNPC(), c->GetSkill(EQEmu::skills::SkillDisarmTraps), LDoNTypeMechanical);
c->HandleLDoNDisarm(target->CastToNPC(), c->GetSkill(EQ::skills::SkillDisarmTraps), LDoNTypeMechanical);
}
else
c->Message(Chat::Red, "You do not have the disarm trap skill.");
@@ -11984,14 +11984,14 @@ void command_sensetrap(Client *c, const Seperator *sep)
if(target->IsNPC())
{
if (c->HasSkill(EQEmu::skills::SkillSenseTraps))
if (c->HasSkill(EQ::skills::SkillSenseTraps))
{
if(DistanceSquaredNoZ(c->GetPosition(), target->GetPosition()) > RuleI(Adventure, LDoNTrapDistanceUse))
{
c->Message(Chat::Red, "%s is too far away.", target->GetCleanName());
return;
}
c->HandleLDoNSenseTraps(target->CastToNPC(), c->GetSkill(EQEmu::skills::SkillSenseTraps), LDoNTypeMechanical);
c->HandleLDoNSenseTraps(target->CastToNPC(), c->GetSkill(EQ::skills::SkillSenseTraps), LDoNTypeMechanical);
}
else
c->Message(Chat::Red, "You do not have the sense traps skill.");
@@ -12009,14 +12009,14 @@ void command_picklock(Client *c, const Seperator *sep)
if(target->IsNPC())
{
if (c->HasSkill(EQEmu::skills::SkillPickLock))
if (c->HasSkill(EQ::skills::SkillPickLock))
{
if(DistanceSquaredNoZ(c->GetPosition(), target->GetPosition()) > RuleI(Adventure, LDoNTrapDistanceUse))
{
c->Message(Chat::Red, "%s is too far away.", target->GetCleanName());
return;
}
c->HandleLDoNPickLock(target->CastToNPC(), c->GetSkill(EQEmu::skills::SkillPickLock), LDoNTypeMechanical);
c->HandleLDoNPickLock(target->CastToNPC(), c->GetSkill(EQ::skills::SkillPickLock), LDoNTypeMechanical);
}
else
c->Message(Chat::Red, "You do not have the pick locks skill.");
@@ -12032,27 +12032,27 @@ void command_profanity(Client *c, const Seperator *sep)
// do nothing
}
else if (arg1.compare("clear") == 0) {
EQEmu::ProfanityManager::DeleteProfanityList(&database);
EQ::ProfanityManager::DeleteProfanityList(&database);
auto pack = new ServerPacket(ServerOP_RefreshCensorship);
worldserver.SendPacket(pack);
safe_delete(pack);
}
else if (arg1.compare("add") == 0) {
if (!EQEmu::ProfanityManager::AddProfanity(&database, sep->arg[2]))
if (!EQ::ProfanityManager::AddProfanity(&database, sep->arg[2]))
c->Message(Chat::Red, "Could not add '%s' to the profanity list.", sep->arg[2]);
auto pack = new ServerPacket(ServerOP_RefreshCensorship);
worldserver.SendPacket(pack);
safe_delete(pack);
}
else if (arg1.compare("del") == 0) {
if (!EQEmu::ProfanityManager::RemoveProfanity(&database, sep->arg[2]))
if (!EQ::ProfanityManager::RemoveProfanity(&database, sep->arg[2]))
c->Message(Chat::Red, "Could not delete '%s' from the profanity list.", sep->arg[2]);
auto pack = new ServerPacket(ServerOP_RefreshCensorship);
worldserver.SendPacket(pack);
safe_delete(pack);
}
else if (arg1.compare("reload") == 0) {
if (!EQEmu::ProfanityManager::UpdateProfanityList(&database))
if (!EQ::ProfanityManager::UpdateProfanityList(&database))
c->Message(Chat::Red, "Could not reload the profanity list.");
auto pack = new ServerPacket(ServerOP_RefreshCensorship);
worldserver.SendPacket(pack);
@@ -12063,7 +12063,7 @@ void command_profanity(Client *c, const Seperator *sep)
}
std::string popup;
const auto &list = EQEmu::ProfanityManager::GetProfanityList();
const auto &list = EQ::ProfanityManager::GetProfanityList();
for (const auto &iter : list) {
popup.append(iter);
popup.append("<br>");
@@ -12213,7 +12213,7 @@ void command_zopp(Client *c, const Seperator *sep)
uint32 itemid = atoi(sep->arg[3]);
int16 charges = sep->argnum == 4 ? atoi(sep->arg[4]) : 1; // defaults to 1 charge if not specified
const EQEmu::ItemData* FakeItem = database.GetItem(itemid);
const EQ::ItemData* FakeItem = database.GetItem(itemid);
if (!FakeItem) {
c->Message(Chat::Red, "Error: Item [%u] is not a valid item id.", itemid);
@@ -12221,7 +12221,7 @@ void command_zopp(Client *c, const Seperator *sep)
}
int16 item_status = 0;
const EQEmu::ItemData* item = database.GetItem(itemid);
const EQ::ItemData* item = database.GetItem(itemid);
if(item) {
item_status = static_cast<int16>(item->MinStatus);
}
@@ -12235,7 +12235,7 @@ void command_zopp(Client *c, const Seperator *sep)
c->Message(Chat::White, "Processing request..results may cause unpredictable behavior.");
}
EQEmu::ItemInstance* FakeItemInst = database.CreateItem(FakeItem, charges);
EQ::ItemInstance* FakeItemInst = database.CreateItem(FakeItem, charges);
c->SendItemPacket(slotid, FakeItemInst, packettype);
c->Message(Chat::White, "Sending zephyr op packet to client - [%s] %s (%u) with %i %s to slot %i.",
packettype == ItemPacketTrade ? "Trade" : "Summon", FakeItem->Name, itemid, charges,
@@ -12993,7 +12993,7 @@ void command_scale(Client *c, const Seperator *sep)
c->Message(Chat::Yellow, "Found (%i) NPC's that match this search...", found_count);
c->Message(
Chat::Yellow, "To apply these changes, click <%s> or type %s",
EQEmu::SayLinkEngine::GenerateQuestSaylink(saylink, false, "Apply").c_str(),
EQ::SayLinkEngine::GenerateQuestSaylink(saylink, false, "Apply").c_str(),
saylink.c_str()
);
}
@@ -13062,7 +13062,7 @@ void command_databuckets(Client *c, const Seperator *sep)
_ctr++;
std::string del_saylink = StringFormat("#databuckets delete %s", key.c_str());
c->Message(Chat::White, "%s : %s",
EQEmu::SayLinkEngine::GenerateQuestSaylink(del_saylink, false, "Delete").c_str(), key.c_str(), " Value: ", value.c_str());
EQ::SayLinkEngine::GenerateQuestSaylink(del_saylink, false, "Delete").c_str(), key.c_str(), " Value: ", value.c_str());
}
window_text.append("</table>");
c->SendPopupToClient(window_title.c_str(), window_text.c_str());
@@ -13157,7 +13157,7 @@ void command_who(Client *c, const Seperator *sep)
std::string displayed_guild_name;
if (guild_name.length() > 0) {
displayed_guild_name = EQEmu::SayLinkEngine::GenerateQuestSaylink(
displayed_guild_name = EQ::SayLinkEngine::GenerateQuestSaylink(
StringFormat(
"#who \"%s\"",
guild_name.c_str()),
@@ -13166,7 +13166,7 @@ void command_who(Client *c, const Seperator *sep)
);
}
std::string goto_saylink = EQEmu::SayLinkEngine::GenerateQuestSaylink(
std::string goto_saylink = EQ::SayLinkEngine::GenerateQuestSaylink(
StringFormat("#goto %s", player_name.c_str()), false, "Goto"
);
@@ -13176,15 +13176,15 @@ void command_who(Client *c, const Seperator *sep)
5, "%s[%u %s] %s (%s) %s ZONE: %s (%u) (%s) (%s) (%s)",
(account_status > 0 ? "* GM * " : ""),
player_level,
EQEmu::SayLinkEngine::GenerateQuestSaylink(StringFormat("#who %s", base_class_name.c_str()), false, display_class_name).c_str(),
EQ::SayLinkEngine::GenerateQuestSaylink(StringFormat("#who %s", base_class_name.c_str()), false, display_class_name).c_str(),
player_name.c_str(),
EQEmu::SayLinkEngine::GenerateQuestSaylink(StringFormat("#who %s", displayed_race_name.c_str()), false, displayed_race_name).c_str(),
EQ::SayLinkEngine::GenerateQuestSaylink(StringFormat("#who %s", displayed_race_name.c_str()), false, displayed_race_name).c_str(),
displayed_guild_name.c_str(),
EQEmu::SayLinkEngine::GenerateQuestSaylink(StringFormat("#who %s", zone_short_name.c_str()), false, zone_short_name).c_str(),
EQ::SayLinkEngine::GenerateQuestSaylink(StringFormat("#who %s", zone_short_name.c_str()), false, zone_short_name).c_str(),
zone_instance,
goto_saylink.c_str(),
EQEmu::SayLinkEngine::GenerateQuestSaylink(StringFormat("#who %s", account_name.c_str()), false, account_name).c_str(),
EQEmu::SayLinkEngine::GenerateQuestSaylink(StringFormat("#who %s", account_ip.c_str()), false, account_ip).c_str()
EQ::SayLinkEngine::GenerateQuestSaylink(StringFormat("#who %s", account_name.c_str()), false, account_name).c_str(),
EQ::SayLinkEngine::GenerateQuestSaylink(StringFormat("#who %s", account_ip.c_str()), false, account_ip).c_str()
);
found_count++;
zone/common.h
+20 -20
View File
@@ -268,7 +268,7 @@ enum class LootRequestType : uint8 {
Self,
AllowedPVE,
AllowedPVPAll,
AllowedPVPSingle, // can make this 'AllowedPVPVariable' and allow values between 1 and EQEmu::invtype::POSSESSIONS_SIZE
AllowedPVPSingle, // can make this 'AllowedPVPVariable' and allow values between 1 and EQ::invtype::POSSESSIONS_SIZE
AllowedPVPDefined,
};
@@ -385,8 +385,8 @@ struct StatBonuses {
int32 inhibitmelee;
float AggroRange; // when calculate just replace original value with this
float AssistRange;
int32 skillmod[EQEmu::skills::HIGHEST_SKILL + 1];
int32 skillmodmax[EQEmu::skills::HIGHEST_SKILL + 1];
int32 skillmod[EQ::skills::HIGHEST_SKILL + 1];
int32 skillmodmax[EQ::skills::HIGHEST_SKILL + 1];
int effective_casting_level;
int adjusted_casting_skill; // SPA 112 for fizzles
int reflect_chance; // chance to reflect incoming spell
@@ -403,7 +403,7 @@ struct StatBonuses {
int32 StrikeThrough; // PoP: Strike Through %
int32 MeleeMitigation; //i = Shielding
int32 MeleeMitigationEffect; //i = Spell Effect Melee Mitigation
int32 CriticalHitChance[EQEmu::skills::HIGHEST_SKILL + 2]; //i
int32 CriticalHitChance[EQ::skills::HIGHEST_SKILL + 2]; //i
int32 CriticalSpellChance; //i
int32 SpellCritDmgIncrease; //i
int32 SpellCritDmgIncNoStack; // increase
@@ -430,10 +430,10 @@ struct StatBonuses {
int32 MeleeSkillCheck; //i
uint8 MeleeSkillCheckSkill;
int32 HitChance; //HitChance/15 == % increase i = Accuracy (Item: Accuracy)
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 HitChanceEffect[EQ::skills::HIGHEST_SKILL + 2]; //Spell effect Chance to Hit, straight percent increase
int32 DamageModifier[EQ::skills::HIGHEST_SKILL + 2]; //i
int32 DamageModifier2[EQ::skills::HIGHEST_SKILL + 2]; //i
int32 MinDamageModifier[EQ::skills::HIGHEST_SKILL + 2]; //i
int32 ProcChance; // ProcChance/10 == % increase i = CombatEffects
int32 ProcChanceSPA; // ProcChance from spell effects
int32 ExtraAttackChance;
@@ -441,13 +441,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[EQEmu::skills::HIGHEST_SKILL + 2]; //Accuracy/15 == % increase [Spell Effect: Accuracy)
int32 Accuracy[EQ::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[EQEmu::skills::HIGHEST_SKILL + 2]; // All Skills + -1
int16 SkillDmgTaken[EQ::skills::HIGHEST_SKILL + 2]; // All Skills + -1
int32 HealAmt; // Item Effect
int32 SpellDmg; // Item Effect
int32 Clairvoyance; // Item Effect
@@ -456,9 +456,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 CritDmgMod[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 CritDmgMod[EQ::skills::HIGHEST_SKILL + 2]; // All Skills + -1
int32 SkillReuseTime[EQ::skills::HIGHEST_SKILL + 1]; // Reduces skill timers
int32 SkillDamageAmount[EQ::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
@@ -481,7 +481,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[EQEmu::skills::HIGHEST_SKILL + 2]; // Adds skill specific damage
int32 SkillDamageAmount2[EQ::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.
@@ -514,7 +514,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[EQEmu::skills::HIGHEST_SKILL + 2]; // Determines if we need to search for a skill proc.
bool LimitToSkill[EQ::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
@@ -549,7 +549,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[EQEmu::skills::HIGHEST_SKILL + 1]; // Raise a specific skill cap (base1= value, base2=skill)
uint32 RaiseSkillCap[EQ::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.
@@ -578,7 +578,7 @@ struct StatBonuses {
uint16 extra_xtargets; // extra xtarget entries
bool ShroudofStealth; // rogue improved invisiblity
uint16 ReduceFallDamage; // reduce fall damage by percent
int32 ReduceTradeskillFail[EQEmu::skills::HIGHEST_SKILL + 1]; // Reduces chance for trade skills to fail by percent.
int32 ReduceTradeskillFail[EQ::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
@@ -697,7 +697,7 @@ struct MercData {
uint32 NPCID;
};
namespace EQEmu
namespace EQ
{
class ItemInstance;
}
@@ -739,7 +739,7 @@ public:
private:
// Send item data for trade item to other person involved in trade
void SendItemData(const EQEmu::ItemInstance* inst, int16 dest_slot_id);
void SendItemData(const EQ::ItemInstance* inst, int16 dest_slot_id);
uint32 with_id;
Mob* owner;
@@ -783,7 +783,7 @@ struct DamageHitInfo {
int offense;
int tohit;
int hand;
EQEmu::skills::SkillType skill;
EQ::skills::SkillType skill;
};
#endif
zone/corpse.cpp
+51 -51
View File
@@ -153,7 +153,7 @@ Corpse::Corpse(NPC* in_npc, ItemList* in_itemlist, uint32 in_npctypeid, const NP
in_npc->GetDeity(),in_npc->GetLevel(),in_npc->GetNPCTypeID(),in_npc->GetSize(),0,
in_npc->GetPosition(), in_npc->GetInnateLightType(), in_npc->GetTexture(),in_npc->GetHelmTexture(),
0,0,0,0,0,0,0,0,0,
0,0,0,0,0,0,0,0,0,0,EQEmu::TintProfile(),0xff,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
0,0,0,0,0,0,0,0,0,0,EQ::TintProfile(),0xff,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
(*in_npctypedata)->use_model, false),
corpse_decay_timer(in_decaytime),
corpse_rez_timer(0),
@@ -245,7 +245,7 @@ Corpse::Corpse(Client* client, int32 in_rezexp) : Mob (
client->GetPP().drakkin_heritage, // uint32 in_drakkin_heritage,
client->GetPP().drakkin_tattoo, // uint32 in_drakkin_tattoo,
client->GetPP().drakkin_details, // uint32 in_drakkin_details,
EQEmu::TintProfile(), // uint32 in_armor_tint[_MaterialCount],
EQ::TintProfile(), // uint32 in_armor_tint[_MaterialCount],
0xff, // uint8 in_aa_title,
0, // uint8 in_see_invis, // see through invis
0, // uint8 in_see_invis_undead, // see through invis vs. undead
@@ -273,7 +273,7 @@ Corpse::Corpse(Client* client, int32 in_rezexp) : Mob (
int i;
PlayerProfile_Struct *pp = &client->GetPP();
EQEmu::ItemInstance *item = nullptr;
EQ::ItemInstance *item = nullptr;
/* Check if Zone has Graveyard First */
if(!zone->HasGraveyard()) {
@@ -325,7 +325,7 @@ Corpse::Corpse(Client* client, int32 in_rezexp) : Mob (
// cash
// Let's not move the cash when 'RespawnFromHover = true' && 'client->GetClientVersion() < EQClientSoF' since the client doesn't.
// (change to first client that supports 'death hover' mode, if not SoF.)
if (!RuleB(Character, RespawnFromHover) || client->ClientVersion() < EQEmu::versions::ClientVersion::SoF) {
if (!RuleB(Character, RespawnFromHover) || client->ClientVersion() < EQ::versions::ClientVersion::SoF) {
SetCash(pp->copper, pp->silver, pp->gold, pp->platinum);
pp->copper = 0;
pp->silver = 0;
@@ -344,7 +344,7 @@ Corpse::Corpse(Client* client, int32 in_rezexp) : Mob (
// ..then regress and process invslot::EQUIPMENT_BEGIN through invslot::EQUIPMENT_END...
// without additional work to database loading of player corpses, this order is not
// currently preserved and a re-work of this processing loop is not warranted.
for (i = EQEmu::invslot::POSSESSIONS_BEGIN; i <= EQEmu::invslot::POSSESSIONS_END; ++i) {
for (i = EQ::invslot::POSSESSIONS_BEGIN; i <= EQ::invslot::POSSESSIONS_END; ++i) {
item = client->GetInv().GetItem(i);
if (item == nullptr) { continue; }
@@ -402,7 +402,7 @@ Corpse::Corpse(Client* client, int32 in_rezexp) : Mob (
Save();
}
void Corpse::MoveItemToCorpse(Client *client, EQEmu::ItemInstance *inst, int16 equipSlot, std::list<uint32> &removedList)
void Corpse::MoveItemToCorpse(Client *client, EQ::ItemInstance *inst, int16 equipSlot, std::list<uint32> &removedList)
{
AddItem(
inst->GetItem()->ID,
@@ -420,10 +420,10 @@ void Corpse::MoveItemToCorpse(Client *client, EQEmu::ItemInstance *inst, int16 e
while (true) {
if (!inst->IsClassBag()) { break; }
if (equipSlot < EQEmu::invslot::GENERAL_BEGIN || equipSlot > EQEmu::invslot::slotCursor) { break; }
if (equipSlot < EQ::invslot::GENERAL_BEGIN || equipSlot > EQ::invslot::slotCursor) { break; }
for (int16 sub_index = EQEmu::invbag::SLOT_BEGIN; sub_index <= EQEmu::invbag::SLOT_END; ++sub_index) {
int16 real_bag_slot = EQEmu::InventoryProfile::CalcSlotId(equipSlot, sub_index);
for (int16 sub_index = EQ::invbag::SLOT_BEGIN; sub_index <= EQ::invbag::SLOT_END; ++sub_index) {
int16 real_bag_slot = EQ::InventoryProfile::CalcSlotId(equipSlot, sub_index);
auto bag_inst = client->GetInv().GetItem(real_bag_slot);
if (bag_inst == nullptr) { continue; }
@@ -485,7 +485,7 @@ in_helmtexture,
0,
0,
0,
EQEmu::TintProfile(),
EQ::TintProfile(),
0xff,
0,
0,
@@ -722,8 +722,8 @@ ServerLootItem_Struct* Corpse::GetItem(uint16 lootslot, ServerLootItem_Struct**
}
}
if (sitem && bag_item_data && EQEmu::InventoryProfile::SupportsContainers(sitem->equip_slot)) {
int16 bagstart = EQEmu::InventoryProfile::CalcSlotId(sitem->equip_slot, EQEmu::invbag::SLOT_BEGIN);
if (sitem && bag_item_data && EQ::InventoryProfile::SupportsContainers(sitem->equip_slot)) {
int16 bagstart = EQ::InventoryProfile::CalcSlotId(sitem->equip_slot, EQ::invbag::SLOT_BEGIN);
cur = itemlist.begin();
end = itemlist.end();
@@ -777,8 +777,8 @@ void Corpse::RemoveItem(ServerLootItem_Struct* item_data)
is_corpse_changed = true;
itemlist.erase(iter);
uint8 material = EQEmu::InventoryProfile::CalcMaterialFromSlot(sitem->equip_slot); // autos to unsigned char
if (material != EQEmu::textures::materialInvalid)
uint8 material = EQ::InventoryProfile::CalcMaterialFromSlot(sitem->equip_slot); // autos to unsigned char
if (material != EQ::textures::materialInvalid)
SendWearChange(material);
UpdateEquipmentLight();
@@ -1061,9 +1061,9 @@ void Corpse::MakeLootRequestPackets(Client* client, const EQApplicationPacket* a
if (pkitem->RecastDelay)
pkinst->SetRecastTimestamp(timestamps.count(pkitem->RecastType) ? timestamps.at(pkitem->RecastType) : 0);
LogInventory("MakeLootRequestPackets() Slot [{}], Item [{}]", EQEmu::invslot::CORPSE_BEGIN, pkitem->Name);
LogInventory("MakeLootRequestPackets() Slot [{}], Item [{}]", EQ::invslot::CORPSE_BEGIN, pkitem->Name);
client->SendItemPacket(EQEmu::invslot::CORPSE_BEGIN, pkinst, ItemPacketLoot);
client->SendItemPacket(EQ::invslot::CORPSE_BEGIN, pkinst, ItemPacketLoot);
safe_delete(pkinst);
}
else {
@@ -1076,7 +1076,7 @@ void Corpse::MakeLootRequestPackets(Client* client, const EQApplicationPacket* a
return;
}
auto loot_slot = EQEmu::invslot::CORPSE_BEGIN;
auto loot_slot = EQ::invslot::CORPSE_BEGIN;
auto corpse_mask = client->GetInv().GetLookup()->CorpseBitmask;
for (auto item_data : itemlist) {
@@ -1085,17 +1085,17 @@ void Corpse::MakeLootRequestPackets(Client* client, const EQApplicationPacket* a
item_data->lootslot = 0xFFFF;
// align server and client corpse slot mappings so translators can function properly
while (loot_slot <= EQEmu::invslot::CORPSE_END && (((uint64)1 << loot_slot) & corpse_mask) == 0)
while (loot_slot <= EQ::invslot::CORPSE_END && (((uint64)1 << loot_slot) & corpse_mask) == 0)
++loot_slot;
if (loot_slot > EQEmu::invslot::CORPSE_END)
if (loot_slot > EQ::invslot::CORPSE_END)
continue;
if (IsPlayerCorpse()) {
if (loot_request_type == LootRequestType::AllowedPVPSingle && loot_slot != EQEmu::invslot::CORPSE_BEGIN)
if (loot_request_type == LootRequestType::AllowedPVPSingle && loot_slot != EQ::invslot::CORPSE_BEGIN)
continue;
if (item_data->equip_slot < EQEmu::invslot::POSSESSIONS_BEGIN || item_data->equip_slot > EQEmu::invslot::POSSESSIONS_END)
if (item_data->equip_slot < EQ::invslot::POSSESSIONS_BEGIN || item_data->equip_slot > EQ::invslot::POSSESSIONS_END)
continue;
}
@@ -1130,7 +1130,7 @@ void Corpse::MakeLootRequestPackets(Client* client, const EQApplicationPacket* a
// This is required for the 'Loot All' feature to work for SoD clients. I expect it is to tell the client that the
// server has now sent all the items on the corpse.
if (client->ClientVersion() >= EQEmu::versions::ClientVersion::SoD)
if (client->ClientVersion() >= EQ::versions::ClientVersion::SoD)
SendLootReqErrorPacket(client, LootResponse::LootAll);
}
@@ -1202,8 +1202,8 @@ void Corpse::LootItem(Client *client, const EQApplicationPacket *app)
return;
}
const EQEmu::ItemData *item = nullptr;
EQEmu::ItemInstance *inst = nullptr;
const EQ::ItemData *item = nullptr;
EQ::ItemInstance *inst = nullptr;
ServerLootItem_Struct *item_data = nullptr, *bag_item_data[10] = {};
memset(bag_item_data, 0, sizeof(bag_item_data));
@@ -1244,8 +1244,8 @@ void Corpse::LootItem(Client *client, const EQApplicationPacket *app)
}
if (inst->IsAugmented()) {
for (int i = EQEmu::invaug::SOCKET_BEGIN; i <= EQEmu::invaug::SOCKET_END; i++) {
EQEmu::ItemInstance *itm = inst->GetAugment(i);
for (int i = EQ::invaug::SOCKET_BEGIN; i <= EQ::invaug::SOCKET_END; i++) {
EQ::ItemInstance *itm = inst->GetAugment(i);
if (itm) {
if (client->CheckLoreConflict(itm->GetItem())) {
client->MessageString(Chat::White, LOOT_LORE_ERROR);
@@ -1265,7 +1265,7 @@ void Corpse::LootItem(Client *client, const EQApplicationPacket *app)
snprintf(buf, 87, "%d %d %s", inst->GetItem()->ID, inst->GetCharges(),
EntityList::RemoveNumbers(q_corpse_name));
buf[87] = '\0';
std::vector<EQEmu::Any> args;
std::vector<EQ::Any> args;
args.push_back(inst);
args.push_back(this);
if (parse->EventPlayer(EVENT_LOOT, client, buf, 0, &args) != 0) {
@@ -1300,10 +1300,10 @@ void Corpse::LootItem(Client *client, const EQApplicationPacket *app)
/* First add it to the looter - this will do the bag contents too */
if (lootitem->auto_loot > 0) {
if (!client->AutoPutLootInInventory(*inst, true, true, bag_item_data))
client->PutLootInInventory(EQEmu::invslot::slotCursor, *inst, bag_item_data);
client->PutLootInInventory(EQ::invslot::slotCursor, *inst, bag_item_data);
}
else {
client->PutLootInInventory(EQEmu::invslot::slotCursor, *inst, bag_item_data);
client->PutLootInInventory(EQ::invslot::slotCursor, *inst, bag_item_data);
}
/* Update any tasks that have an activity to loot this item */
@@ -1322,7 +1322,7 @@ void Corpse::LootItem(Client *client, const EQApplicationPacket *app)
/* Remove Bag Contents */
if (item->IsClassBag() && (GetPlayerKillItem() != -1 || GetPlayerKillItem() != 1)) {
for (int i = EQEmu::invbag::SLOT_BEGIN; i <= EQEmu::invbag::SLOT_END; i++) {
for (int i = EQ::invbag::SLOT_BEGIN; i <= EQ::invbag::SLOT_END; i++) {
if (bag_item_data[i]) {
/* Delete needs to be before RemoveItem because its deletes the pointer for
* item_data/bag_item_data */
@@ -1340,8 +1340,8 @@ void Corpse::LootItem(Client *client, const EQApplicationPacket *app)
}
/* Send message with item link to groups and such */
EQEmu::SayLinkEngine linker;
linker.SetLinkType(EQEmu::saylink::SayLinkItemInst);
EQ::SayLinkEngine linker;
linker.SetLinkType(EQ::saylink::SayLinkItemInst);
linker.SetItemInst(inst);
linker.GenerateLink();
@@ -1400,7 +1400,7 @@ void Corpse::FillSpawnStruct(NewSpawn_Struct* ns, Mob* ForWho) {
ns->spawn.NPC = 2;
UpdateActiveLight();
ns->spawn.light = m_Light.Type[EQEmu::lightsource::LightActive];
ns->spawn.light = m_Light.Type[EQ::lightsource::LightActive];
}
void Corpse::QueryLoot(Client* to) {
@@ -1417,12 +1417,12 @@ void Corpse::QueryLoot(Client* to) {
ServerLootItem_Struct* sitem = *cur;
if (IsPlayerCorpse()) {
if (sitem->equip_slot >= EQEmu::invbag::GENERAL_BAGS_BEGIN && sitem->equip_slot <= EQEmu::invbag::CURSOR_BAG_END)
if (sitem->equip_slot >= EQ::invbag::GENERAL_BAGS_BEGIN && sitem->equip_slot <= EQ::invbag::CURSOR_BAG_END)
sitem->lootslot = 0xFFFF;
else
x < corpselootlimit ? sitem->lootslot = x : sitem->lootslot = 0xFFFF;
const EQEmu::ItemData* item = database.GetItem(sitem->item_id);
const EQ::ItemData* item = database.GetItem(sitem->item_id);
if (item)
to->Message((sitem->lootslot == 0xFFFF), "LootSlot: %i (EquipSlot: %i) Item: %s (%d), Count: %i", static_cast<int16>(sitem->lootslot), sitem->equip_slot, item->Name, item->ID, sitem->charges);
@@ -1436,7 +1436,7 @@ void Corpse::QueryLoot(Client* to) {
}
else {
sitem->lootslot=y;
const EQEmu::ItemData* item = database.GetItem(sitem->item_id);
const EQ::ItemData* item = database.GetItem(sitem->item_id);
if (item)
to->Message(Chat::White, "LootSlot: %i Item: %s (%d), Count: %i", sitem->lootslot, item->Name, item->ID, sitem->charges);
@@ -1540,11 +1540,11 @@ void Corpse::Spawn() {
uint32 Corpse::GetEquippedItemFromTextureSlot(uint8 material_slot) const {
int16 invslot;
if (material_slot > EQEmu::textures::LastTexture) {
if (material_slot > EQ::textures::LastTexture) {
return 0;
}
invslot = EQEmu::InventoryProfile::CalcSlotFromMaterial(material_slot);
invslot = EQ::InventoryProfile::CalcSlotFromMaterial(material_slot);
if(invslot == INVALID_INDEX) // GetWornItem() should be returning a 0 for any invalid index...
return 0;
@@ -1552,9 +1552,9 @@ uint32 Corpse::GetEquippedItemFromTextureSlot(uint8 material_slot) const {
}
uint32 Corpse::GetEquipmentColor(uint8 material_slot) const {
const EQEmu::ItemData *item = nullptr;
const EQ::ItemData *item = nullptr;
if (material_slot > EQEmu::textures::LastTexture) {
if (material_slot > EQ::textures::LastTexture) {
return 0;
}
@@ -1568,23 +1568,23 @@ uint32 Corpse::GetEquipmentColor(uint8 material_slot) const {
void Corpse::UpdateEquipmentLight()
{
m_Light.Type[EQEmu::lightsource::LightEquipment] = 0;
m_Light.Level[EQEmu::lightsource::LightEquipment] = 0;
m_Light.Type[EQ::lightsource::LightEquipment] = 0;
m_Light.Level[EQ::lightsource::LightEquipment] = 0;
for (auto iter = itemlist.begin(); iter != itemlist.end(); ++iter) {
if ((*iter)->equip_slot < EQEmu::invslot::EQUIPMENT_BEGIN || (*iter)->equip_slot > EQEmu::invslot::EQUIPMENT_END) { continue; }
if ((*iter)->equip_slot == EQEmu::invslot::slotAmmo) { continue; }
if ((*iter)->equip_slot < EQ::invslot::EQUIPMENT_BEGIN || (*iter)->equip_slot > EQ::invslot::EQUIPMENT_END) { continue; }
if ((*iter)->equip_slot == EQ::invslot::slotAmmo) { continue; }
auto item = database.GetItem((*iter)->item_id);
if (item == nullptr) { continue; }
if (EQEmu::lightsource::IsLevelGreater(item->Light, m_Light.Type[EQEmu::lightsource::LightEquipment]))
m_Light.Type[EQEmu::lightsource::LightEquipment] = item->Light;
if (EQ::lightsource::IsLevelGreater(item->Light, m_Light.Type[EQ::lightsource::LightEquipment]))
m_Light.Type[EQ::lightsource::LightEquipment] = item->Light;
}
uint8 general_light_type = 0;
for (auto iter = itemlist.begin(); iter != itemlist.end(); ++iter) {
if ((*iter)->equip_slot < EQEmu::invslot::GENERAL_BEGIN || (*iter)->equip_slot > EQEmu::invslot::GENERAL_END) { continue; }
if ((*iter)->equip_slot < EQ::invslot::GENERAL_BEGIN || (*iter)->equip_slot > EQ::invslot::GENERAL_END) { continue; }
auto item = database.GetItem((*iter)->item_id);
if (item == nullptr) { continue; }
@@ -1592,14 +1592,14 @@ void Corpse::UpdateEquipmentLight()
if (!item->IsClassCommon()) { continue; }
if (item->Light < 9 || item->Light > 13) { continue; }
if (EQEmu::lightsource::TypeToLevel(item->Light))
if (EQ::lightsource::TypeToLevel(item->Light))
general_light_type = item->Light;
}
if (EQEmu::lightsource::IsLevelGreater(general_light_type, m_Light.Type[EQEmu::lightsource::LightEquipment]))
m_Light.Type[EQEmu::lightsource::LightEquipment] = general_light_type;
if (EQ::lightsource::IsLevelGreater(general_light_type, m_Light.Type[EQ::lightsource::LightEquipment]))
m_Light.Type[EQ::lightsource::LightEquipment] = general_light_type;
m_Light.Level[EQEmu::lightsource::LightEquipment] = EQEmu::lightsource::TypeToLevel(m_Light.Type[EQEmu::lightsource::LightEquipment]);
m_Light.Level[EQ::lightsource::LightEquipment] = EQ::lightsource::TypeToLevel(m_Light.Type[EQ::lightsource::LightEquipment]);
}
void Corpse::AddLooter(Mob* who) {
zone/corpse.h
+6 -6
View File
@@ -30,7 +30,7 @@ class Raid;
struct ExtraAttackOptions;
struct NPCType;
namespace EQEmu
namespace EQ
{
class ItemInstance;
}
@@ -51,9 +51,9 @@ 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, uint32 guild_consent_id);
/* Corpse: General */
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, eSpecialAttacks special = eSpecialAttacks::None) { return; }
virtual bool Attack(Mob* other, int Hand = EQEmu::invslot::slotPrimary, bool FromRiposte = false, bool IsStrikethrough = true, bool IsFromSpell = false, ExtraAttackOptions *opts = nullptr) { return false; }
virtual bool Death(Mob* killerMob, int32 damage, uint16 spell_id, EQ::skills::SkillType attack_skill) { return true; }
virtual void Damage(Mob* from, int32 damage, uint16 spell_id, EQ::skills::SkillType attack_skill, bool avoidable = true, int8 buffslot = -1, bool iBuffTic = false, eSpecialAttacks special = eSpecialAttacks::None) { return; }
virtual bool Attack(Mob* other, int Hand = EQ::invslot::slotPrimary, bool FromRiposte = false, bool IsStrikethrough = true, bool IsFromSpell = false, ExtraAttackOptions *opts = nullptr) { return false; }
virtual bool HasRaid() { return false; }
virtual bool HasGroup() { return false; }
virtual Raid* GetRaid() { return 0; }
@@ -138,7 +138,7 @@ class Corpse : public Mob {
virtual void UpdateEquipmentLight();
protected:
void MoveItemToCorpse(Client *client, EQEmu::ItemInstance *inst, int16 equipSlot, std::list<uint32> &removedList);
void MoveItemToCorpse(Client *client, EQ::ItemInstance *inst, int16 equipSlot, std::list<uint32> &removedList);
private:
bool is_player_corpse; /* Determines if Player Corpse or not */
@@ -167,7 +167,7 @@ private:
Timer corpse_delay_timer;
Timer corpse_graveyard_timer;
Timer loot_cooldown_timer; /* Delay between loot actions on the corpse entity */
EQEmu::TintProfile item_tint;
EQ::TintProfile item_tint;
std::vector<std::string> consented_player_names;
LootRequestType loot_request_type;
zone/doors.cpp
+5 -5
View File
@@ -210,7 +210,7 @@ void Doors::HandleClick(Client* sender, uint8 trigger) {
uint32 player_has_key = 0;
uint32 player_key = 0;
const EQEmu::ItemInstance *lock_pick_item = sender->GetInv().GetItem(EQEmu::invslot::slotCursor);
const EQ::ItemInstance *lock_pick_item = sender->GetInv().GetItem(EQ::invslot::slotCursor);
player_has_key = static_cast<uint32>(sender->GetInv().HasItem(required_key_item, 1));
if (player_has_key != INVALID_INDEX) {
@@ -320,10 +320,10 @@ void Doors::HandleClick(Client* sender, uint8 trigger) {
* Try Lock pick
*/
else if (lock_pick_item != nullptr) {
if (sender->GetSkill(EQEmu::skills::SkillPickLock)) {
if (lock_pick_item->GetItem()->ItemType == EQEmu::item::ItemTypeLockPick) {
float player_pick_lock_skill = sender->GetSkill(EQEmu::skills::SkillPickLock);
sender->CheckIncreaseSkill(EQEmu::skills::SkillPickLock, nullptr, 1);
if (sender->GetSkill(EQ::skills::SkillPickLock)) {
if (lock_pick_item->GetItem()->ItemType == EQ::item::ItemTypeLockPick) {
float player_pick_lock_skill = sender->GetSkill(EQ::skills::SkillPickLock);
sender->CheckIncreaseSkill(EQ::skills::SkillPickLock, nullptr, 1);
LogSkills("Client has lockpicks: skill=[{}]", player_pick_lock_skill);
zone/effects.cpp
+5 -5
View File
@@ -432,14 +432,14 @@ int32 Client::GetActSpellCasttime(uint16 spell_id, int32 casttime)
bool Client::TrainDiscipline(uint32 itemid) {
//get the item info
const EQEmu::ItemData *item = database.GetItem(itemid);
const EQ::ItemData *item = database.GetItem(itemid);
if(item == nullptr) {
Message(Chat::Red, "Unable to find the tome you turned in!");
LogError("Unable to find turned in tome id [{}]\n", (unsigned long)itemid);
return(false);
}
if (!item->IsClassCommon() || item->ItemType != EQEmu::item::ItemTypeSpell) {
if (!item->IsClassCommon() || item->ItemType != EQ::item::ItemTypeSpell) {
Message(Chat::Red, "Invalid item type, you cannot learn from this item.");
//summon them the item back...
SummonItem(itemid);
@@ -645,9 +645,9 @@ bool Client::UseDiscipline(uint32 spell_id, uint32 target) {
}
if (reduced_recast > 0)
CastSpell(spell_id, target, EQEmu::spells::CastingSlot::Discipline, -1, -1, 0, -1, (uint32)DiscTimer, reduced_recast);
CastSpell(spell_id, target, EQ::spells::CastingSlot::Discipline, -1, -1, 0, -1, (uint32)DiscTimer, reduced_recast);
else{
CastSpell(spell_id, target, EQEmu::spells::CastingSlot::Discipline);
CastSpell(spell_id, target, EQ::spells::CastingSlot::Discipline);
return true;
}
@@ -655,7 +655,7 @@ bool Client::UseDiscipline(uint32 spell_id, uint32 target) {
}
else
{
CastSpell(spell_id, target, EQEmu::spells::CastingSlot::Discipline);
CastSpell(spell_id, target, EQ::spells::CastingSlot::Discipline);
}
return(true);
}
zone/embparser.cpp
+24 -24
View File
@@ -165,8 +165,8 @@ void PerlembParser::ReloadQuests()
}
int PerlembParser::EventCommon(
QuestEventID event, uint32 objid, const char *data, NPC *npcmob, EQEmu::ItemInstance *item_inst, Mob *mob,
uint32 extradata, bool global, std::vector<EQEmu::Any> *extra_pointers
QuestEventID event, uint32 objid, const char *data, NPC *npcmob, EQ::ItemInstance *item_inst, Mob *mob,
uint32 extradata, bool global, std::vector<EQ::Any> *extra_pointers
)
{
if (!perl) {
@@ -266,7 +266,7 @@ int PerlembParser::EventCommon(
int PerlembParser::EventNPC(
QuestEventID evt, NPC *npc, Mob *init, std::string data, uint32 extra_data,
std::vector<EQEmu::Any> *extra_pointers
std::vector<EQ::Any> *extra_pointers
)
{
return EventCommon(evt, npc->GetNPCTypeID(), data.c_str(), npc, nullptr, init, extra_data, false, extra_pointers);
@@ -274,7 +274,7 @@ int PerlembParser::EventNPC(
int PerlembParser::EventGlobalNPC(
QuestEventID evt, NPC *npc, Mob *init, std::string data, uint32 extra_data,
std::vector<EQEmu::Any> *extra_pointers
std::vector<EQ::Any> *extra_pointers
)
{
return EventCommon(evt, npc->GetNPCTypeID(), data.c_str(), npc, nullptr, init, extra_data, true, extra_pointers);
@@ -282,7 +282,7 @@ int PerlembParser::EventGlobalNPC(
int PerlembParser::EventPlayer(
QuestEventID evt, Client *client, std::string data, uint32 extra_data,
std::vector<EQEmu::Any> *extra_pointers
std::vector<EQ::Any> *extra_pointers
)
{
return EventCommon(evt, 0, data.c_str(), nullptr, nullptr, client, extra_data, false, extra_pointers);
@@ -290,15 +290,15 @@ int PerlembParser::EventPlayer(
int PerlembParser::EventGlobalPlayer(
QuestEventID evt, Client *client, std::string data, uint32 extra_data,
std::vector<EQEmu::Any> *extra_pointers
std::vector<EQ::Any> *extra_pointers
)
{
return EventCommon(evt, 0, data.c_str(), nullptr, nullptr, client, extra_data, true, extra_pointers);
}
int PerlembParser::EventItem(
QuestEventID evt, Client *client, EQEmu::ItemInstance *item, Mob *mob, std::string data, uint32 extra_data,
std::vector<EQEmu::Any> *extra_pointers
QuestEventID evt, Client *client, EQ::ItemInstance *item, Mob *mob, std::string data, uint32 extra_data,
std::vector<EQ::Any> *extra_pointers
)
{
// needs pointer validation on 'item' argument
@@ -307,7 +307,7 @@ int PerlembParser::EventItem(
int PerlembParser::EventSpell(
QuestEventID evt, NPC *npc, Client *client, uint32 spell_id, uint32 extra_data,
std::vector<EQEmu::Any> *extra_pointers
std::vector<EQ::Any> *extra_pointers
)
{
return EventCommon(evt, 0, itoa(spell_id), npc, nullptr, client, extra_data, false, extra_pointers);
@@ -416,7 +416,7 @@ bool PerlembParser::SpellHasQuestSub(uint32 spell_id, QuestEventID evt)
return (perl->SubExists(package_name.str().c_str(), subname));
}
bool PerlembParser::ItemHasQuestSub(EQEmu::ItemInstance *itm, QuestEventID evt)
bool PerlembParser::ItemHasQuestSub(EQ::ItemInstance *itm, QuestEventID evt)
{
std::stringstream package_name;
package_name << "qst_item_" << itm->GetID();
@@ -564,7 +564,7 @@ void PerlembParser::LoadGlobalPlayerScript(std::string filename)
global_player_quest_status_ = questLoaded;
}
void PerlembParser::LoadItemScript(std::string filename, EQEmu::ItemInstance *item)
void PerlembParser::LoadItemScript(std::string filename, EQ::ItemInstance *item)
{
if (item == nullptr) {
return;
@@ -776,7 +776,7 @@ int PerlembParser::SendCommands(
uint32 npcid,
Mob *other,
Mob *mob,
EQEmu::ItemInstance *item_inst
EQ::ItemInstance *item_inst
)
{
if (!perl) {
@@ -852,7 +852,7 @@ int PerlembParser::SendCommands(
//only export QuestItem if it's an item quest
if (item_inst) {
EQEmu::ItemInstance *curi = quest_manager.GetQuestItem();
EQ::ItemInstance *curi = quest_manager.GetQuestItem();
snprintf(namebuf, 64, "%s::questitem", pkgprefix);
SV *questitem = get_sv(namebuf, true);
sv_setref_pv(questitem, "QuestItem", curi);
@@ -979,7 +979,7 @@ void PerlembParser::MapFunctions()
void PerlembParser::GetQuestTypes(
bool &isPlayerQuest, bool &isGlobalPlayerQuest, bool &isGlobalNPC, bool &isItemQuest,
bool &isSpellQuest, QuestEventID event, NPC *npcmob, EQEmu::ItemInstance *item_inst, Mob *mob, bool global
bool &isSpellQuest, QuestEventID event, NPC *npcmob, EQ::ItemInstance *item_inst, Mob *mob, bool global
)
{
if (event == EVENT_SPELL_EFFECT_CLIENT ||
@@ -1018,7 +1018,7 @@ void PerlembParser::GetQuestPackageName(
uint32 objid,
const char *data,
NPC *npcmob,
EQEmu::ItemInstance *item_inst,
EQ::ItemInstance *item_inst,
bool global
)
{
@@ -1033,8 +1033,8 @@ void PerlembParser::GetQuestPackageName(
}
}
else if (isItemQuest) {
// need a valid EQEmu::ItemInstance pointer check here..unsure how to cancel this process
const EQEmu::ItemData *item = item_inst->GetItem();
// need a valid EQ::ItemInstance pointer check here..unsure how to cancel this process
const EQ::ItemData *item = item_inst->GetItem();
package_name = "qst_item_";
package_name += itoa(item->ID);
}
@@ -1263,7 +1263,7 @@ void PerlembParser::ExportItemVariables(std::string &package_name, Mob *mob)
//start with an empty hash
perl->eval(std::string("%").append(hashname).append(" = ();").c_str());
for (int slot = EQEmu::invslot::EQUIPMENT_BEGIN; slot <= EQEmu::invslot::GENERAL_END; slot++) {
for (int slot = EQ::invslot::EQUIPMENT_BEGIN; slot <= EQ::invslot::GENERAL_END; slot++) {
char *hi_decl = nullptr;
int itemid = mob->CastToClient()->GetItemIDAt(slot);
if (itemid != -1 && itemid != 0) {
@@ -1278,9 +1278,9 @@ void PerlembParser::ExportItemVariables(std::string &package_name, Mob *mob)
std::string hashname = package_name + std::string("::oncursor");
perl->eval(std::string("%").append(hashname).append(" = ();").c_str());
char *hi_decl = nullptr;
int itemid = mob->CastToClient()->GetItemIDAt(EQEmu::invslot::slotCursor);
int itemid = mob->CastToClient()->GetItemIDAt(EQ::invslot::slotCursor);
if (itemid != -1 && itemid != 0) {
MakeAnyLenString(&hi_decl, "push (@{$%s{%d}},%d);", hashname.c_str(), itemid, EQEmu::invslot::slotCursor);
MakeAnyLenString(&hi_decl, "push (@{$%s{%d}},%d);", hashname.c_str(), itemid, EQ::invslot::slotCursor);
perl->eval(hi_decl);
safe_delete_array(hi_decl);
}
@@ -1289,7 +1289,7 @@ void PerlembParser::ExportItemVariables(std::string &package_name, Mob *mob)
void PerlembParser::ExportEventVariables(
std::string &package_name, QuestEventID event, uint32 objid, const char *data,
NPC *npcmob, EQEmu::ItemInstance *item_inst, Mob *mob, uint32 extradata, std::vector<EQEmu::Any> *extra_pointers
NPC *npcmob, EQ::ItemInstance *item_inst, Mob *mob, uint32 extradata, std::vector<EQ::Any> *extra_pointers
)
{
switch (event) {
@@ -1308,7 +1308,7 @@ void PerlembParser::ExportEventVariables(
if (extra_pointers) {
size_t sz = extra_pointers->size();
for (size_t i = 0; i < sz; ++i) {
EQEmu::ItemInstance *inst = EQEmu::any_cast<EQEmu::ItemInstance *>(extra_pointers->at(i));
EQ::ItemInstance *inst = EQ::any_cast<EQ::ItemInstance *>(extra_pointers->at(i));
std::string var_name = "item";
var_name += std::to_string(i + 1);
@@ -1476,7 +1476,7 @@ void PerlembParser::ExportEventVariables(
case EVENT_SCALE_CALC:
case EVENT_ITEM_ENTER_ZONE: {
// need a valid EQEmu::ItemInstance pointer check here..unsure how to cancel this process
// need a valid EQ::ItemInstance pointer check here..unsure how to cancel this process
ExportVar(package_name.c_str(), "itemid", objid);
ExportVar(package_name.c_str(), "itemname", item_inst->GetItem()->Name);
break;
@@ -1484,7 +1484,7 @@ void PerlembParser::ExportEventVariables(
case EVENT_ITEM_CLICK_CAST:
case EVENT_ITEM_CLICK: {
// need a valid EQEmu::ItemInstance pointer check here..unsure how to cancel this process
// need a valid EQ::ItemInstance pointer check here..unsure how to cancel this process
ExportVar(package_name.c_str(), "itemid", objid);
ExportVar(package_name.c_str(), "itemname", item_inst->GetItem()->Name);
ExportVar(package_name.c_str(), "slotid", extradata);
zone/embparser.h
+16 -16
View File
@@ -31,7 +31,7 @@ class Mob;
class Client;
class NPC;
namespace EQEmu
namespace EQ
{
class ItemInstance;
}
@@ -49,30 +49,30 @@ public:
~PerlembParser();
virtual int EventNPC(QuestEventID evt, NPC* npc, Mob *init, std::string data, uint32 extra_data,
std::vector<EQEmu::Any> *extra_pointers);
std::vector<EQ::Any> *extra_pointers);
virtual int EventGlobalNPC(QuestEventID evt, NPC* npc, Mob *init, std::string data, uint32 extra_data,
std::vector<EQEmu::Any> *extra_pointers);
std::vector<EQ::Any> *extra_pointers);
virtual int EventPlayer(QuestEventID evt, Client *client, std::string data, uint32 extra_data,
std::vector<EQEmu::Any> *extra_pointers);
std::vector<EQ::Any> *extra_pointers);
virtual int EventGlobalPlayer(QuestEventID evt, Client *client, std::string data, uint32 extra_data,
std::vector<EQEmu::Any> *extra_pointers);
virtual int EventItem(QuestEventID evt, Client *client, EQEmu::ItemInstance *item, Mob *mob, std::string data, uint32 extra_data,
std::vector<EQEmu::Any> *extra_pointers);
std::vector<EQ::Any> *extra_pointers);
virtual int EventItem(QuestEventID evt, Client *client, EQ::ItemInstance *item, Mob *mob, std::string data, uint32 extra_data,
std::vector<EQ::Any> *extra_pointers);
virtual int EventSpell(QuestEventID evt, NPC* npc, Client *client, uint32 spell_id, uint32 extra_data,
std::vector<EQEmu::Any> *extra_pointers);
std::vector<EQ::Any> *extra_pointers);
virtual bool HasQuestSub(uint32 npcid, QuestEventID evt);
virtual bool HasGlobalQuestSub(QuestEventID evt);
virtual bool PlayerHasQuestSub(QuestEventID evt);
virtual bool GlobalPlayerHasQuestSub(QuestEventID evt);
virtual bool SpellHasQuestSub(uint32 spell_id, QuestEventID evt);
virtual bool ItemHasQuestSub(EQEmu::ItemInstance *itm, QuestEventID evt);
virtual bool ItemHasQuestSub(EQ::ItemInstance *itm, QuestEventID evt);
virtual void LoadNPCScript(std::string filename, int npc_id);
virtual void LoadGlobalNPCScript(std::string filename);
virtual void LoadPlayerScript(std::string filename);
virtual void LoadGlobalPlayerScript(std::string filename);
virtual void LoadItemScript(std::string filename, EQEmu::ItemInstance *item);
virtual void LoadItemScript(std::string filename, EQ::ItemInstance *item);
virtual void LoadSpellScript(std::string filename, uint32 spell_id);
virtual void AddVar(std::string name, std::string val);
@@ -90,16 +90,16 @@ private:
void ExportVar(const char *pkgprefix, const char *varname, float value);
void ExportVarComplex(const char *pkgprefix, const char *varname, const char *value);
int EventCommon(QuestEventID event, uint32 objid, const char * data, NPC* npcmob, EQEmu::ItemInstance* item_inst, Mob* mob,
uint32 extradata, bool global, std::vector<EQEmu::Any> *extra_pointers);
int SendCommands(const char *pkgprefix, const char *event, uint32 npcid, Mob* other, Mob* mob, EQEmu::ItemInstance *item_inst);
int EventCommon(QuestEventID event, uint32 objid, const char * data, NPC* npcmob, EQ::ItemInstance* item_inst, Mob* mob,
uint32 extradata, bool global, std::vector<EQ::Any> *extra_pointers);
int SendCommands(const char *pkgprefix, const char *event, uint32 npcid, Mob* other, Mob* mob, EQ::ItemInstance *item_inst);
void MapFunctions();
void GetQuestTypes(bool &isPlayerQuest, bool &isGlobalPlayerQuest, bool &isGlobalNPC, bool &isItemQuest,
bool &isSpellQuest, QuestEventID event, NPC* npcmob, EQEmu::ItemInstance* item_inst, Mob* mob, bool global);
bool &isSpellQuest, QuestEventID event, NPC* npcmob, EQ::ItemInstance* item_inst, Mob* mob, bool global);
void GetQuestPackageName(bool &isPlayerQuest, bool &isGlobalPlayerQuest, bool &isGlobalNPC, bool &isItemQuest,
bool &isSpellQuest, std::string &package_name, QuestEventID event, uint32 objid, const char * data,
NPC* npcmob, EQEmu::ItemInstance* item_inst, bool global);
NPC* npcmob, EQ::ItemInstance* item_inst, bool global);
void ExportCharID(const std::string &package_name, int &char_id, NPC *npcmob, Mob *mob);
void ExportQGlobals(bool isPlayerQuest, bool isGlobalPlayerQuest, bool isGlobalNPC, bool isItemQuest,
bool isSpellQuest, std::string &package_name, NPC *npcmob, Mob *mob, int char_id);
@@ -108,7 +108,7 @@ private:
void ExportZoneVariables(std::string &package_name);
void ExportItemVariables(std::string &package_name, Mob *mob);
void ExportEventVariables(std::string &package_name, QuestEventID event, uint32 objid, const char * data,
NPC* npcmob, EQEmu::ItemInstance* item_inst, Mob* mob, uint32 extradata, std::vector<EQEmu::Any> *extra_pointers);
NPC* npcmob, EQ::ItemInstance* item_inst, Mob* mob, uint32 extradata, std::vector<EQ::Any> *extra_pointers);
std::map<uint32, PerlQuestStatus> npc_quest_status_;
PerlQuestStatus global_npc_quest_status_;
zone/embparser_api.cpp
+83 -83
View File
@@ -109,7 +109,7 @@ XS(XS_QuestItem_new) {
if (items != 1)
Perl_croak(aTHX_ "Usage: quest::QuestItem::new()");
EQEmu::ItemInstance *RETVAL;
EQ::ItemInstance *RETVAL;
RETVAL = quest_manager.GetQuestItem();
ST(0) = sv_newmortal();
@@ -372,7 +372,7 @@ XS(XS__getinventoryslotid) {
if (items != 1)
Perl_croak(aTHX_ "Usage: quest::getinventoryslotid(string identifier)");
int16 RETVAL = EQEmu::invslot::SLOT_INVALID;
int16 RETVAL = EQ::invslot::SLOT_INVALID;
dXSTARG;
std::string identifier = (Const_char *)SvPV_nolen(ST(0));
@@ -380,89 +380,89 @@ XS(XS__getinventoryslotid) {
identifier[i] = std::tolower(identifier[i]);
if (identifier.find('.') == std::string::npos) {
if (identifier == "invalid") RETVAL = EQEmu::invslot::SLOT_INVALID;
else if (identifier == "charm") RETVAL = EQEmu::invslot::slotCharm;
else if (identifier == "ear1") RETVAL = EQEmu::invslot::slotEar1;
else if (identifier == "head") RETVAL = EQEmu::invslot::slotHead;
else if (identifier == "face") RETVAL = EQEmu::invslot::slotFace;
else if (identifier == "ear2") RETVAL = EQEmu::invslot::slotEar2;
else if (identifier == "neck") RETVAL = EQEmu::invslot::slotNeck;
else if (identifier == "shoulders") RETVAL = EQEmu::invslot::slotShoulders;
else if (identifier == "arms") RETVAL = EQEmu::invslot::slotArms;
else if (identifier == "back") RETVAL = EQEmu::invslot::slotBack;
else if (identifier == "wrist1") RETVAL = EQEmu::invslot::slotWrist1;
else if (identifier == "wrist2") RETVAL = EQEmu::invslot::slotWrist2;
else if (identifier == "range") RETVAL = EQEmu::invslot::slotRange;
else if (identifier == "hands") RETVAL = EQEmu::invslot::slotHands;
else if (identifier == "primary") RETVAL = EQEmu::invslot::slotPrimary;
else if (identifier == "secondary") RETVAL = EQEmu::invslot::slotSecondary;
else if (identifier == "finger1") RETVAL = EQEmu::invslot::slotFinger1;
else if (identifier == "finger2") RETVAL = EQEmu::invslot::slotFinger2;
else if (identifier == "chest") RETVAL = EQEmu::invslot::slotChest;
else if (identifier == "legs") RETVAL = EQEmu::invslot::slotLegs;
else if (identifier == "feet") RETVAL = EQEmu::invslot::slotFeet;
else if (identifier == "waist") RETVAL = EQEmu::invslot::slotWaist;
else if (identifier == "powersource") RETVAL = EQEmu::invslot::slotPowerSource;
else if (identifier == "ammo") RETVAL = EQEmu::invslot::slotAmmo;
else if (identifier == "general1") RETVAL = EQEmu::invslot::slotGeneral1;
else if (identifier == "general2") RETVAL = EQEmu::invslot::slotGeneral2;
else if (identifier == "general3") RETVAL = EQEmu::invslot::slotGeneral3;
else if (identifier == "general4") RETVAL = EQEmu::invslot::slotGeneral4;
else if (identifier == "general5") RETVAL = EQEmu::invslot::slotGeneral5;
else if (identifier == "general6") RETVAL = EQEmu::invslot::slotGeneral6;
else if (identifier == "general7") RETVAL = EQEmu::invslot::slotGeneral7;
else if (identifier == "general8") RETVAL = EQEmu::invslot::slotGeneral8;
else if (identifier == "general9") RETVAL = EQEmu::invslot::slotGeneral9;
else if (identifier == "general10") RETVAL = EQEmu::invslot::slotGeneral10;
else if (identifier == "cursor") RETVAL = EQEmu::invslot::slotCursor;
else if (identifier == "tradeskill") RETVAL = EQEmu::invslot::SLOT_TRADESKILL_EXPERIMENT_COMBINE;
else if (identifier == "augment") RETVAL = EQEmu::invslot::SLOT_AUGMENT_GENERIC_RETURN;
if (identifier == "invalid") RETVAL = EQ::invslot::SLOT_INVALID;
else if (identifier == "charm") RETVAL = EQ::invslot::slotCharm;
else if (identifier == "ear1") RETVAL = EQ::invslot::slotEar1;
else if (identifier == "head") RETVAL = EQ::invslot::slotHead;
else if (identifier == "face") RETVAL = EQ::invslot::slotFace;
else if (identifier == "ear2") RETVAL = EQ::invslot::slotEar2;
else if (identifier == "neck") RETVAL = EQ::invslot::slotNeck;
else if (identifier == "shoulders") RETVAL = EQ::invslot::slotShoulders;
else if (identifier == "arms") RETVAL = EQ::invslot::slotArms;
else if (identifier == "back") RETVAL = EQ::invslot::slotBack;
else if (identifier == "wrist1") RETVAL = EQ::invslot::slotWrist1;
else if (identifier == "wrist2") RETVAL = EQ::invslot::slotWrist2;
else if (identifier == "range") RETVAL = EQ::invslot::slotRange;
else if (identifier == "hands") RETVAL = EQ::invslot::slotHands;
else if (identifier == "primary") RETVAL = EQ::invslot::slotPrimary;
else if (identifier == "secondary") RETVAL = EQ::invslot::slotSecondary;
else if (identifier == "finger1") RETVAL = EQ::invslot::slotFinger1;
else if (identifier == "finger2") RETVAL = EQ::invslot::slotFinger2;
else if (identifier == "chest") RETVAL = EQ::invslot::slotChest;
else if (identifier == "legs") RETVAL = EQ::invslot::slotLegs;
else if (identifier == "feet") RETVAL = EQ::invslot::slotFeet;
else if (identifier == "waist") RETVAL = EQ::invslot::slotWaist;
else if (identifier == "powersource") RETVAL = EQ::invslot::slotPowerSource;
else if (identifier == "ammo") RETVAL = EQ::invslot::slotAmmo;
else if (identifier == "general1") RETVAL = EQ::invslot::slotGeneral1;
else if (identifier == "general2") RETVAL = EQ::invslot::slotGeneral2;
else if (identifier == "general3") RETVAL = EQ::invslot::slotGeneral3;
else if (identifier == "general4") RETVAL = EQ::invslot::slotGeneral4;
else if (identifier == "general5") RETVAL = EQ::invslot::slotGeneral5;
else if (identifier == "general6") RETVAL = EQ::invslot::slotGeneral6;
else if (identifier == "general7") RETVAL = EQ::invslot::slotGeneral7;
else if (identifier == "general8") RETVAL = EQ::invslot::slotGeneral8;
else if (identifier == "general9") RETVAL = EQ::invslot::slotGeneral9;
else if (identifier == "general10") RETVAL = EQ::invslot::slotGeneral10;
else if (identifier == "cursor") RETVAL = EQ::invslot::slotCursor;
else if (identifier == "tradeskill") RETVAL = EQ::invslot::SLOT_TRADESKILL_EXPERIMENT_COMBINE;
else if (identifier == "augment") RETVAL = EQ::invslot::SLOT_AUGMENT_GENERIC_RETURN;
}
else {
if (identifier == "possessions.begin") RETVAL = EQEmu::invslot::POSSESSIONS_BEGIN;
else if (identifier == "possessions.end") RETVAL = EQEmu::invslot::POSSESSIONS_END;
else if (identifier == "equipment.begin") RETVAL = EQEmu::invslot::EQUIPMENT_BEGIN;
else if (identifier == "equipment.end") RETVAL = EQEmu::invslot::EQUIPMENT_END;
else if (identifier == "general.begin") RETVAL = EQEmu::invslot::GENERAL_BEGIN;
else if (identifier == "general.end") RETVAL = EQEmu::invslot::GENERAL_END;
else if (identifier == "possessionsbags.begin") RETVAL = EQEmu::invbag::GENERAL_BAGS_BEGIN;
else if (identifier == "possessionsbags.end") RETVAL = EQEmu::invbag::CURSOR_BAG_END;
else if (identifier == "generalbags.begin") RETVAL = EQEmu::invbag::GENERAL_BAGS_BEGIN;
else if (identifier == "generalbags.end") RETVAL = EQEmu::invbag::GENERAL_BAGS_END;
else if (identifier == "general1bag.begin") RETVAL = EQEmu::invbag::GENERAL_BAGS_BEGIN;
else if (identifier == "general1bag.end") RETVAL = EQEmu::invbag::GENERAL_BAGS_BEGIN + 9;
else if (identifier == "general2bag.begin") RETVAL = EQEmu::invbag::GENERAL_BAGS_BEGIN + 10;
else if (identifier == "general2bag.end") RETVAL = EQEmu::invbag::GENERAL_BAGS_BEGIN + 19;
else if (identifier == "general3bag.begin") RETVAL = EQEmu::invbag::GENERAL_BAGS_BEGIN + 20;
else if (identifier == "general3bag.end") RETVAL = EQEmu::invbag::GENERAL_BAGS_BEGIN + 29;
else if (identifier == "general4bag.begin") RETVAL = EQEmu::invbag::GENERAL_BAGS_BEGIN + 30;
else if (identifier == "general4bag.end") RETVAL = EQEmu::invbag::GENERAL_BAGS_BEGIN + 39;
else if (identifier == "general5bag.begin") RETVAL = EQEmu::invbag::GENERAL_BAGS_BEGIN + 40;
else if (identifier == "general5bag.end") RETVAL = EQEmu::invbag::GENERAL_BAGS_BEGIN + 49;
else if (identifier == "general6bag.begin") RETVAL = EQEmu::invbag::GENERAL_BAGS_BEGIN + 50;
else if (identifier == "general6bag.end") RETVAL = EQEmu::invbag::GENERAL_BAGS_BEGIN + 59;
else if (identifier == "general7bag.begin") RETVAL = EQEmu::invbag::GENERAL_BAGS_BEGIN + 60;
else if (identifier == "general7bag.end") RETVAL = EQEmu::invbag::GENERAL_BAGS_BEGIN + 69;
else if (identifier == "general8bag.begin") RETVAL = EQEmu::invbag::GENERAL_BAGS_BEGIN + 70;
else if (identifier == "general8bag.end") RETVAL = EQEmu::invbag::GENERAL_BAGS_BEGIN + 79;
else if (identifier == "general9bag.begin") RETVAL = EQEmu::invbag::GENERAL_BAGS_BEGIN + 80;
else if (identifier == "general9bag.end") RETVAL = EQEmu::invbag::GENERAL_BAGS_BEGIN + 89;
else if (identifier == "general10bag.begin") RETVAL = EQEmu::invbag::GENERAL_BAGS_BEGIN + 90;
else if (identifier == "general10bag.end") RETVAL = EQEmu::invbag::GENERAL_BAGS_BEGIN + 99;
else if (identifier == "cursorbag.begin") RETVAL = EQEmu::invbag::CURSOR_BAG_BEGIN;
else if (identifier == "cursorbag.end") RETVAL = EQEmu::invbag::CURSOR_BAG_END;
else if (identifier == "bank.begin") RETVAL = EQEmu::invslot::BANK_BEGIN;
else if (identifier == "bank.end") RETVAL = EQEmu::invslot::BANK_END;
else if (identifier == "bankbags.begin") RETVAL = EQEmu::invbag::BANK_BAGS_BEGIN;
else if (identifier == "bankbags.end") RETVAL = EQEmu::invbag::BANK_BAGS_END;
else if (identifier == "sharedbank.begin") RETVAL = EQEmu::invslot::SHARED_BANK_BEGIN;
else if (identifier == "sharedbank.end") RETVAL = EQEmu::invslot::SHARED_BANK_END;
else if (identifier == "sharedbankbags.begin") RETVAL = EQEmu::invbag::SHARED_BANK_BAGS_BEGIN;
else if (identifier == "sharedbankbags.end") RETVAL = EQEmu::invbag::SHARED_BANK_BAGS_END;
else if (identifier == "bagslot.begin") RETVAL = EQEmu::invbag::SLOT_BEGIN;
else if (identifier == "bagslot.end") RETVAL = EQEmu::invbag::SLOT_END;
else if (identifier == "augsocket.begin") RETVAL = EQEmu::invaug::SOCKET_BEGIN;
else if (identifier == "augsocket.end") RETVAL = EQEmu::invaug::SOCKET_END;
if (identifier == "possessions.begin") RETVAL = EQ::invslot::POSSESSIONS_BEGIN;
else if (identifier == "possessions.end") RETVAL = EQ::invslot::POSSESSIONS_END;
else if (identifier == "equipment.begin") RETVAL = EQ::invslot::EQUIPMENT_BEGIN;
else if (identifier == "equipment.end") RETVAL = EQ::invslot::EQUIPMENT_END;
else if (identifier == "general.begin") RETVAL = EQ::invslot::GENERAL_BEGIN;
else if (identifier == "general.end") RETVAL = EQ::invslot::GENERAL_END;
else if (identifier == "possessionsbags.begin") RETVAL = EQ::invbag::GENERAL_BAGS_BEGIN;
else if (identifier == "possessionsbags.end") RETVAL = EQ::invbag::CURSOR_BAG_END;
else if (identifier == "generalbags.begin") RETVAL = EQ::invbag::GENERAL_BAGS_BEGIN;
else if (identifier == "generalbags.end") RETVAL = EQ::invbag::GENERAL_BAGS_END;
else if (identifier == "general1bag.begin") RETVAL = EQ::invbag::GENERAL_BAGS_BEGIN;
else if (identifier == "general1bag.end") RETVAL = EQ::invbag::GENERAL_BAGS_BEGIN + 9;
else if (identifier == "general2bag.begin") RETVAL = EQ::invbag::GENERAL_BAGS_BEGIN + 10;
else if (identifier == "general2bag.end") RETVAL = EQ::invbag::GENERAL_BAGS_BEGIN + 19;
else if (identifier == "general3bag.begin") RETVAL = EQ::invbag::GENERAL_BAGS_BEGIN + 20;
else if (identifier == "general3bag.end") RETVAL = EQ::invbag::GENERAL_BAGS_BEGIN + 29;
else if (identifier == "general4bag.begin") RETVAL = EQ::invbag::GENERAL_BAGS_BEGIN + 30;
else if (identifier == "general4bag.end") RETVAL = EQ::invbag::GENERAL_BAGS_BEGIN + 39;
else if (identifier == "general5bag.begin") RETVAL = EQ::invbag::GENERAL_BAGS_BEGIN + 40;
else if (identifier == "general5bag.end") RETVAL = EQ::invbag::GENERAL_BAGS_BEGIN + 49;
else if (identifier == "general6bag.begin") RETVAL = EQ::invbag::GENERAL_BAGS_BEGIN + 50;
else if (identifier == "general6bag.end") RETVAL = EQ::invbag::GENERAL_BAGS_BEGIN + 59;
else if (identifier == "general7bag.begin") RETVAL = EQ::invbag::GENERAL_BAGS_BEGIN + 60;
else if (identifier == "general7bag.end") RETVAL = EQ::invbag::GENERAL_BAGS_BEGIN + 69;
else if (identifier == "general8bag.begin") RETVAL = EQ::invbag::GENERAL_BAGS_BEGIN + 70;
else if (identifier == "general8bag.end") RETVAL = EQ::invbag::GENERAL_BAGS_BEGIN + 79;
else if (identifier == "general9bag.begin") RETVAL = EQ::invbag::GENERAL_BAGS_BEGIN + 80;
else if (identifier == "general9bag.end") RETVAL = EQ::invbag::GENERAL_BAGS_BEGIN + 89;
else if (identifier == "general10bag.begin") RETVAL = EQ::invbag::GENERAL_BAGS_BEGIN + 90;
else if (identifier == "general10bag.end") RETVAL = EQ::invbag::GENERAL_BAGS_BEGIN + 99;
else if (identifier == "cursorbag.begin") RETVAL = EQ::invbag::CURSOR_BAG_BEGIN;
else if (identifier == "cursorbag.end") RETVAL = EQ::invbag::CURSOR_BAG_END;
else if (identifier == "bank.begin") RETVAL = EQ::invslot::BANK_BEGIN;
else if (identifier == "bank.end") RETVAL = EQ::invslot::BANK_END;
else if (identifier == "bankbags.begin") RETVAL = EQ::invbag::BANK_BAGS_BEGIN;
else if (identifier == "bankbags.end") RETVAL = EQ::invbag::BANK_BAGS_END;
else if (identifier == "sharedbank.begin") RETVAL = EQ::invslot::SHARED_BANK_BEGIN;
else if (identifier == "sharedbank.end") RETVAL = EQ::invslot::SHARED_BANK_END;
else if (identifier == "sharedbankbags.begin") RETVAL = EQ::invbag::SHARED_BANK_BAGS_BEGIN;
else if (identifier == "sharedbankbags.end") RETVAL = EQ::invbag::SHARED_BANK_BAGS_END;
else if (identifier == "bagslot.begin") RETVAL = EQ::invbag::SLOT_BEGIN;
else if (identifier == "bagslot.end") RETVAL = EQ::invbag::SLOT_END;
else if (identifier == "augsocket.begin") RETVAL = EQ::invaug::SOCKET_BEGIN;
else if (identifier == "augsocket.end") RETVAL = EQ::invaug::SOCKET_END;
}
XSprePUSH; PUSHu((IV)RETVAL);
zone/embxs.cpp
+1 -1
View File
@@ -33,7 +33,7 @@
const char *getItemName(unsigned itemid)
{
const EQEmu::ItemData* item = nullptr;
const EQ::ItemData* item = nullptr;
item = database.GetItem(itemid);
if (item)
zone/encounter.cpp
+1 -1
View File
@@ -36,7 +36,7 @@ Encounter::Encounter(const char* enc_name)
:Mob
(
nullptr, nullptr, 0, 0, 0, INVISIBLE_MAN, 0, BT_NoTarget, 0, 0, 0, 0, 0, glm::vec4(0,0,0,0), 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, EQEmu::TintProfile(), 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, false
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, EQ::TintProfile(), 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, false
)
{
encounter_name[0] = 0;
zone/encounter.h
+3 -3
View File
@@ -34,9 +34,9 @@ public:
~Encounter();
//abstract virtual function implementations required by base abstract class
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, eSpecialAttacks special = eSpecialAttacks::None) { return; }
virtual bool Attack(Mob* other, int Hand = EQEmu::invslot::slotPrimary, bool FromRiposte = false, bool IsStrikethrough = false, bool IsFromSpell = false,
virtual bool Death(Mob* killerMob, int32 damage, uint16 spell_id, EQ::skills::SkillType attack_skill) { return true; }
virtual void Damage(Mob* from, int32 damage, uint16 spell_id, EQ::skills::SkillType attack_skill, bool avoidable = true, int8 buffslot = -1, bool iBuffTic = false, eSpecialAttacks special = eSpecialAttacks::None) { return; }
virtual bool Attack(Mob* other, int Hand = EQ::invslot::slotPrimary, bool FromRiposte = false, bool IsStrikethrough = false, bool IsFromSpell = false,
ExtraAttackOptions *opts = nullptr) {
return false;
}
zone/entity.cpp
+13 -13
View File
@@ -1598,7 +1598,7 @@ void EntityList::QueueClientsByTarget(Mob *sender, const EQApplicationPacket *ap
}
}
void EntityList::QueueClientsByXTarget(Mob *sender, const EQApplicationPacket *app, bool iSendToSender, EQEmu::versions::ClientVersionBitmask client_version_bits)
void EntityList::QueueClientsByXTarget(Mob *sender, const EQApplicationPacket *app, bool iSendToSender, EQ::versions::ClientVersionBitmask client_version_bits)
{
auto it = client_list.begin();
while (it != client_list.end()) {
@@ -1728,7 +1728,7 @@ void EntityList::QueueClientsStatus(Mob *sender, const EQApplicationPacket *app,
void EntityList::DuelMessage(Mob *winner, Mob *loser, bool flee)
{
if (winner->GetLevelCon(winner->GetLevel(), loser->GetLevel()) > 2) {
std::vector<EQEmu::Any> args;
std::vector<EQ::Any> args;
args.push_back(winner);
args.push_back(loser);
@@ -2130,7 +2130,7 @@ void EntityList::QueueClientsGuildBankItemUpdate(const GuildBankItemUpdate_Struc
memcpy(outgbius, gbius, sizeof(GuildBankItemUpdate_Struct));
const EQEmu::ItemData *Item = database.GetItem(gbius->ItemID);
const EQ::ItemData *Item = database.GetItem(gbius->ItemID);
auto it = client_list.begin();
while (it != client_list.end()) {
@@ -3378,7 +3378,7 @@ void EntityList::ClearFeignAggro(Mob *targ)
}
if (targ->IsClient()) {
std::vector<EQEmu::Any> args;
std::vector<EQ::Any> args;
args.push_back(it->second);
int i = parse->EventPlayer(EVENT_FEIGN_DEATH, targ->CastToClient(), "", 0, &args);
if (i != 0) {
@@ -3445,11 +3445,11 @@ bool EntityList::MakeTrackPacket(Client *client)
float MobDistance;
if (client->GetClass() == DRUID)
distance = (client->GetSkill(EQEmu::skills::SkillTracking) * 10);
distance = (client->GetSkill(EQ::skills::SkillTracking) * 10);
else if (client->GetClass() == RANGER)
distance = (client->GetSkill(EQEmu::skills::SkillTracking) * 12);
distance = (client->GetSkill(EQ::skills::SkillTracking) * 12);
else if (client->GetClass() == BARD)
distance = (client->GetSkill(EQEmu::skills::SkillTracking) * 7);
distance = (client->GetSkill(EQ::skills::SkillTracking) * 7);
if (distance <= 0)
return false;
if (distance < 300)
@@ -3710,10 +3710,10 @@ void EntityList::ProcessMove(Client *c, const glm::vec3& location)
for (auto iter = events.begin(); iter != events.end(); ++iter) {
quest_proximity_event& evt = (*iter);
if (evt.npc) {
std::vector<EQEmu::Any> args;
std::vector<EQ::Any> args;
parse->EventNPC(evt.event_id, evt.npc, evt.client, "", 0, &args);
} else {
std::vector<EQEmu::Any> args;
std::vector<EQ::Any> args;
args.push_back(&evt.area_id);
args.push_back(&evt.area_type);
parse->EventPlayer(evt.event_id, evt.client, "", 0, &args);
@@ -3769,7 +3769,7 @@ void EntityList::ProcessMove(NPC *n, float x, float y, float z) {
for (auto iter = events.begin(); iter != events.end(); ++iter) {
quest_proximity_event &evt = (*iter);
std::vector<EQEmu::Any> args;
std::vector<EQ::Any> args;
args.push_back(&evt.area_id);
args.push_back(&evt.area_type);
parse->EventNPC(evt.event_id, evt.npc, evt.client, "", 0, &args);
@@ -4262,11 +4262,11 @@ void EntityList::GroupMessage(uint32 gid, const char *from, const char *message)
uint16 EntityList::CreateGroundObject(uint32 itemid, const glm::vec4& position, uint32 decay_time)
{
const EQEmu::ItemData *is = database.GetItem(itemid);
const EQ::ItemData *is = database.GetItem(itemid);
if (!is)
return 0;
auto i = new EQEmu::ItemInstance(is, is->MaxCharges);
auto i = new EQ::ItemInstance(is, is->MaxCharges);
if (!i)
return 0;
@@ -4848,7 +4848,7 @@ void EntityList::UpdateFindableNPCState(NPC *n, bool Remove)
auto it = client_list.begin();
while (it != client_list.end()) {
Client *c = it->second;
if (c && (c->ClientVersion() >= EQEmu::versions::ClientVersion::SoD))
if (c && (c->ClientVersion() >= EQ::versions::ClientVersion::SoD))
c->QueuePacket(outapp);
++it;
zone/entity.h
+2 -2
View File
@@ -394,14 +394,14 @@ public:
void QueueClientsByTarget(Mob* sender, const EQApplicationPacket* app, bool iSendToSender = true, Mob* SkipThisMob = 0, bool ackreq = true,
bool HoTT = true, uint32 ClientVersionBits = 0xFFFFFFFF, bool inspect_buffs = false);
void QueueClientsByXTarget(Mob* sender, const EQApplicationPacket* app, bool iSendToSender = true, EQEmu::versions::ClientVersionBitmask client_version_bits = EQEmu::versions::ClientVersionBitmask::maskAllClients);
void QueueClientsByXTarget(Mob* sender, const EQApplicationPacket* app, bool iSendToSender = true, EQ::versions::ClientVersionBitmask client_version_bits = EQ::versions::ClientVersionBitmask::maskAllClients);
void QueueToGroupsForNPCHealthAA(Mob* sender, const EQApplicationPacket* app);
void QueueManaged(Mob* sender, const EQApplicationPacket* app, bool ignore_sender=false, bool ackreq = true);
void AEAttack(
Mob *attacker,
float distance,
int Hand = EQEmu::invslot::slotPrimary,
int Hand = EQ::invslot::slotPrimary,
int count = 0,
bool is_from_spell = false
);
zone/forage.cpp
+30 -30
View File
@@ -153,21 +153,21 @@ uint32 ZoneDatabase::GetZoneFishing(uint32 ZoneID, uint8 skill, uint32 &npc_id,
//we need this function to immediately determine, after we receive OP_Fishing, if we can even try to fish, otherwise we have to wait a while to get the failure
bool Client::CanFish() {
//make sure we still have a fishing pole on:
const EQEmu::ItemInstance* Pole = m_inv[EQEmu::invslot::slotPrimary];
int32 bslot = m_inv.HasItemByUse(EQEmu::item::ItemTypeFishingBait, 1, invWhereWorn | invWherePersonal);
const EQEmu::ItemInstance* Bait = nullptr;
const EQ::ItemInstance* Pole = m_inv[EQ::invslot::slotPrimary];
int32 bslot = m_inv.HasItemByUse(EQ::item::ItemTypeFishingBait, 1, invWhereWorn | invWherePersonal);
const EQ::ItemInstance* Bait = nullptr;
if (bslot != INVALID_INDEX)
Bait = m_inv.GetItem(bslot);
if (!Pole || !Pole->IsClassCommon() || Pole->GetItem()->ItemType != EQEmu::item::ItemTypeFishingPole) {
if (m_inv.HasItemByUse(EQEmu::item::ItemTypeFishingPole, 1, invWhereWorn | invWherePersonal | invWhereBank | invWhereSharedBank | invWhereTrading | invWhereCursor)) //We have a fishing pole somewhere, just not equipped
if (!Pole || !Pole->IsClassCommon() || Pole->GetItem()->ItemType != EQ::item::ItemTypeFishingPole) {
if (m_inv.HasItemByUse(EQ::item::ItemTypeFishingPole, 1, invWhereWorn | invWherePersonal | invWhereBank | invWhereSharedBank | invWhereTrading | invWhereCursor)) //We have a fishing pole somewhere, just not equipped
MessageString(Chat::Skills, FISHING_EQUIP_POLE); //You need to put your fishing pole in your primary hand.
else //We don't have a fishing pole anywhere
MessageString(Chat::Skills, FISHING_NO_POLE); //You can't fish without a fishing pole, go buy one.
return false;
}
if (!Bait || !Bait->IsClassCommon() || Bait->GetItem()->ItemType != EQEmu::item::ItemTypeFishingBait) {
if (!Bait || !Bait->IsClassCommon() || Bait->GetItem()->ItemType != EQ::item::ItemTypeFishingBait) {
MessageString(Chat::Skills, FISHING_NO_BAIT); //You can't fish without fishing bait, go buy some.
return false;
}
@@ -249,16 +249,16 @@ void Client::GoFish()
//success formula is not researched at all
int fishing_skill = GetSkill(EQEmu::skills::SkillFishing); //will take into account skill bonuses on pole & bait
int fishing_skill = GetSkill(EQ::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);
const EQEmu::ItemInstance* Bait = nullptr;
int32 bslot = m_inv.HasItemByUse(EQ::item::ItemTypeFishingBait, 1, invWhereWorn | invWherePersonal);
const EQ::ItemInstance* Bait = nullptr;
if (bslot != INVALID_INDEX)
Bait = m_inv.GetItem(bslot);
//if the bait isnt equipped, need to add its skill bonus
if (bslot >= EQEmu::invslot::GENERAL_BEGIN && Bait != nullptr && Bait->GetItem()->SkillModType == EQEmu::skills::SkillFishing) {
if (bslot >= EQ::invslot::GENERAL_BEGIN && Bait != nullptr && Bait->GetItem()->SkillModType == EQ::skills::SkillFishing) {
fishing_skill += Bait->GetItem()->SkillModValue;
}
@@ -312,17 +312,17 @@ void Client::GoFish()
food_id = (RuleB(Character, UseNoJunkFishing) ? 13019 : common_fish_ids[index]);
}
const EQEmu::ItemData* food_item = database.GetItem(food_id);
const EQ::ItemData* food_item = database.GetItem(food_id);
if (food_item) {
if (food_item->ItemType != EQEmu::item::ItemTypeFood) {
if (food_item->ItemType != EQ::item::ItemTypeFood) {
MessageString(Chat::Skills, FISHING_SUCCESS);
}
else {
MessageString(Chat::Skills, FISHING_SUCCESS_FISH_NAME, food_item->Name);
}
EQEmu::ItemInstance* inst = database.CreateItem(food_item, 1);
EQ::ItemInstance* inst = database.CreateItem(food_item, 1);
if (inst != nullptr) {
if (CheckLoreConflict(inst->GetItem()))
{
@@ -332,16 +332,16 @@ void Client::GoFish()
else
{
PushItemOnCursor(*inst);
SendItemPacket(EQEmu::invslot::slotCursor, inst, ItemPacketLimbo);
SendItemPacket(EQ::invslot::slotCursor, inst, ItemPacketLimbo);
if (RuleB(TaskSystem, EnableTaskSystem))
UpdateTasksForItem(ActivityFish, food_id);
safe_delete(inst);
inst = m_inv.GetItem(EQEmu::invslot::slotCursor);
inst = m_inv.GetItem(EQ::invslot::slotCursor);
}
if (inst) {
std::vector<EQEmu::Any> args;
std::vector<EQ::Any> args;
args.push_back(inst);
parse->EventPlayer(EVENT_FISH_SUCCESS, this, "", inst->GetID(), &args);
}
@@ -368,26 +368,26 @@ void Client::GoFish()
//chance to break fishing pole...
//this is potentially exploitable in that they can fish
//and then swap out items in primary slot... too lazy to fix right now
const EQEmu::ItemInstance* Pole = m_inv[EQEmu::invslot::slotPrimary];
const EQ::ItemInstance* Pole = m_inv[EQ::invslot::slotPrimary];
if (Pole) {
const EQEmu::ItemData* fishing_item = Pole->GetItem();
const EQ::ItemData* fishing_item = Pole->GetItem();
if (fishing_item && fishing_item->SubType == 0 && zone->random.Int(0, 49) == 1) {
MessageString(Chat::Skills, FISHING_POLE_BROKE); //Your fishing pole broke!
DeleteItemInInventory(EQEmu::invslot::slotPrimary, 0, true);
DeleteItemInInventory(EQ::invslot::slotPrimary, 0, true);
}
}
if (CheckIncreaseSkill(EQEmu::skills::SkillFishing, nullptr, 5))
if (CheckIncreaseSkill(EQ::skills::SkillFishing, nullptr, 5))
{
if (title_manager.IsNewTradeSkillTitleAvailable(EQEmu::skills::SkillFishing, GetRawSkill(EQEmu::skills::SkillFishing)))
if (title_manager.IsNewTradeSkillTitleAvailable(EQ::skills::SkillFishing, GetRawSkill(EQ::skills::SkillFishing)))
NotifyNewTitlesAvailable();
}
}
void Client::ForageItem(bool guarantee) {
int skill_level = GetSkill(EQEmu::skills::SkillForage);
int skill_level = GetSkill(EQ::skills::SkillForage);
//be wary of the string ids in switch below when changing this.
uint32 common_food_ids[MAX_COMMON_FOOD_IDS] = {
@@ -417,7 +417,7 @@ void Client::ForageItem(bool guarantee) {
foragedfood = common_food_ids[index];
}
const EQEmu::ItemData* food_item = database.GetItem(foragedfood);
const EQ::ItemData* food_item = database.GetItem(foragedfood);
if(!food_item) {
LogError("nullptr returned from database.GetItem in ClientForageItem");
@@ -428,10 +428,10 @@ void Client::ForageItem(bool guarantee) {
stringid = FORAGE_GRUBS;
else
switch(food_item->ItemType) {
case EQEmu::item::ItemTypeFood:
case EQ::item::ItemTypeFood:
stringid = FORAGE_FOOD;
break;
case EQEmu::item::ItemTypeDrink:
case EQ::item::ItemTypeDrink:
if(strstr(food_item->Name, "ater"))
stringid = FORAGE_WATER;
else
@@ -442,7 +442,7 @@ void Client::ForageItem(bool guarantee) {
}
MessageString(Chat::Skills, stringid);
EQEmu::ItemInstance* inst = database.CreateItem(food_item, 1);
EQ::ItemInstance* inst = database.CreateItem(food_item, 1);
if(inst != nullptr) {
// check to make sure it isn't a foraged lore item
if(CheckLoreConflict(inst->GetItem()))
@@ -452,16 +452,16 @@ void Client::ForageItem(bool guarantee) {
}
else {
PushItemOnCursor(*inst);
SendItemPacket(EQEmu::invslot::slotCursor, inst, ItemPacketLimbo);
SendItemPacket(EQ::invslot::slotCursor, inst, ItemPacketLimbo);
if(RuleB(TaskSystem, EnableTaskSystem))
UpdateTasksForItem(ActivityForage, foragedfood);
safe_delete(inst);
inst = m_inv.GetItem(EQEmu::invslot::slotCursor);
inst = m_inv.GetItem(EQ::invslot::slotCursor);
}
if(inst) {
std::vector<EQEmu::Any> args;
std::vector<EQ::Any> args;
args.push_back(inst);
parse->EventPlayer(EVENT_FORAGE_SUCCESS, this, "", inst->GetID(), &args);
}
@@ -478,7 +478,7 @@ void Client::ForageItem(bool guarantee) {
parse->EventPlayer(EVENT_FORAGE_FAILURE, this, "", 0);
}
CheckIncreaseSkill(EQEmu::skills::SkillForage, nullptr, 5);
CheckIncreaseSkill(EQ::skills::SkillForage, nullptr, 5);
}
zone/groups.cpp
+10 -10
View File
@@ -407,7 +407,7 @@ void Group::SendHPManaEndPacketsTo(Mob *member)
safe_delete_array(hpapp.pBuffer);
hpapp.size = 0;
if (member->CastToClient()->ClientVersion() >= EQEmu::versions::ClientVersion::SoD) {
if (member->CastToClient()->ClientVersion() >= EQ::versions::ClientVersion::SoD) {
outapp.SetOpcode(OP_MobManaUpdate);
MobManaUpdate_Struct *mana_update = (MobManaUpdate_Struct *)outapp.pBuffer;
@@ -438,7 +438,7 @@ void Group::SendHPPacketsFrom(Mob *member)
for(i = 0; i < MAX_GROUP_MEMBERS; i++) {
if(members[i] && members[i] != member && members[i]->IsClient()) {
members[i]->CastToClient()->QueuePacket(&hp_app);
if (members[i]->CastToClient()->ClientVersion() >= EQEmu::versions::ClientVersion::SoD) {
if (members[i]->CastToClient()->ClientVersion() >= EQ::versions::ClientVersion::SoD) {
outapp.SetOpcode(OP_MobManaUpdate);
MobManaUpdate_Struct *mana_update = (MobManaUpdate_Struct *)outapp.pBuffer;
mana_update->spawn_id = member->GetID();
@@ -463,7 +463,7 @@ void Group::SendManaPacketFrom(Mob *member)
uint32 i;
for (i = 0; i < MAX_GROUP_MEMBERS; i++) {
if (members[i] && members[i] != member && members[i]->IsClient()) {
if (members[i]->CastToClient()->ClientVersion() >= EQEmu::versions::ClientVersion::SoD) {
if (members[i]->CastToClient()->ClientVersion() >= EQ::versions::ClientVersion::SoD) {
outapp.SetOpcode(OP_MobManaUpdate);
MobManaUpdate_Struct *mana_update = (MobManaUpdate_Struct *)outapp.pBuffer;
mana_update->spawn_id = member->GetID();
@@ -484,7 +484,7 @@ void Group::SendEndurancePacketFrom(Mob* member)
uint32 i;
for (i = 0; i < MAX_GROUP_MEMBERS; i++) {
if (members[i] && members[i] != member && members[i]->IsClient()) {
if (members[i]->CastToClient()->ClientVersion() >= EQEmu::versions::ClientVersion::SoD) {
if (members[i]->CastToClient()->ClientVersion() >= EQ::versions::ClientVersion::SoD) {
MobEnduranceUpdate_Struct *endurance_update = (MobEnduranceUpdate_Struct *)outapp.pBuffer;
endurance_update->spawn_id = member->GetID();
endurance_update->endurance = member->GetEndurancePercent();
@@ -621,7 +621,7 @@ bool Group::DelMemberOOZ(const char *Name) {
if(GroupCount() < 3)
{
UnDelegateMarkNPC(NPCMarkerName.c_str());
if (GetLeader() && GetLeader()->IsClient() && GetLeader()->CastToClient()->ClientVersion() < EQEmu::versions::ClientVersion::SoD) {
if (GetLeader() && GetLeader()->IsClient() && GetLeader()->CastToClient()->ClientVersion() < EQ::versions::ClientVersion::SoD) {
UnDelegateMainAssist(MainAssistName.c_str());
}
ClearAllNPCMarks();
@@ -786,7 +786,7 @@ bool Group::DelMember(Mob* oldmember, bool ignoresender)
if(GroupCount() < 3)
{
UnDelegateMarkNPC(NPCMarkerName.c_str());
if (GetLeader() && GetLeader()->IsClient() && GetLeader()->CastToClient()->ClientVersion() < EQEmu::versions::ClientVersion::SoD) {
if (GetLeader() && GetLeader()->IsClient() && GetLeader()->CastToClient()->ClientVersion() < EQ::versions::ClientVersion::SoD) {
UnDelegateMainAssist(MainAssistName.c_str());
}
ClearAllNPCMarks();
@@ -1682,7 +1682,7 @@ void Group::NotifyMainTank(Client *c, uint8 toggle)
if(!MainTankName.size())
return;
if (c->ClientVersion() < EQEmu::versions::ClientVersion::SoD)
if (c->ClientVersion() < EQ::versions::ClientVersion::SoD)
{
if(toggle)
c->Message(Chat::White, "%s is now Main Tank.", MainTankName.c_str());
@@ -1722,7 +1722,7 @@ void Group::NotifyMainAssist(Client *c, uint8 toggle)
if(!MainAssistName.size())
return;
if (c->ClientVersion() < EQEmu::versions::ClientVersion::SoD)
if (c->ClientVersion() < EQ::versions::ClientVersion::SoD)
{
auto outapp = new EQApplicationPacket(OP_DelegateAbility, sizeof(DelegateAbility_Struct));
@@ -1777,7 +1777,7 @@ void Group::NotifyPuller(Client *c, uint8 toggle)
if(!PullerName.size())
return;
if (c->ClientVersion() < EQEmu::versions::ClientVersion::SoD)
if (c->ClientVersion() < EQ::versions::ClientVersion::SoD)
{
if(toggle)
c->Message(Chat::White, "%s is now Puller.", PullerName.c_str());
@@ -2343,7 +2343,7 @@ void Group::ChangeLeader(Mob* newleader)
for (uint32 i = 0; i < MAX_GROUP_MEMBERS; i++) {
if (members[i] && members[i]->IsClient())
{
if (members[i]->CastToClient()->ClientVersion() >= EQEmu::versions::ClientVersion::SoD)
if (members[i]->CastToClient()->ClientVersion() >= EQ::versions::ClientVersion::SoD)
members[i]->CastToClient()->SendGroupLeaderChangePacket(newleader->GetName());
members[i]->CastToClient()->QueuePacket(outapp);
zone/guild.cpp
+5 -5
View File
@@ -63,7 +63,7 @@ void Client::SendGuildMOTD(bool GetGuildMOTDReply) {
void Client::SendGuildURL()
{
if (ClientVersion() < EQEmu::versions::ClientVersion::SoF)
if (ClientVersion() < EQ::versions::ClientVersion::SoF)
return;
if(IsInAGuild())
@@ -85,7 +85,7 @@ void Client::SendGuildURL()
void Client::SendGuildChannel()
{
if (ClientVersion() < EQEmu::versions::ClientVersion::SoF)
if (ClientVersion() < EQ::versions::ClientVersion::SoF)
return;
if(IsInAGuild())
@@ -108,7 +108,7 @@ void Client::SendGuildChannel()
void Client::SendGuildRanks()
{
if (ClientVersion() < EQEmu::versions::ClientVersion::RoF)
if (ClientVersion() < EQ::versions::ClientVersion::RoF)
return;
int permissions = 30 + 1; //Static number of permissions in all EQ clients as of May 2014
@@ -152,7 +152,7 @@ void Client::SendGuildSpawnAppearance() {
uint8 rank = guild_mgr.GetDisplayedRank(GuildID(), GuildRank(), CharacterID());
LogGuilds("Sending spawn appearance for guild [{}] at rank [{}]", GuildID(), rank);
SendAppearancePacket(AT_GuildID, GuildID());
if (ClientVersion() >= EQEmu::versions::ClientVersion::RoF)
if (ClientVersion() >= EQ::versions::ClientVersion::RoF)
{
switch (rank) {
case 0: { rank = 5; break; } // GUILD_MEMBER 0
@@ -253,7 +253,7 @@ void Client::RefreshGuildInfo()
if((guild_id != OldGuildID) && GuildBanks)
{
// Unsure about this for RoF+ ... But they don't have that action anymore so fuck it
if (ClientVersion() < EQEmu::versions::ClientVersion::RoF)
if (ClientVersion() < EQ::versions::ClientVersion::RoF)
ClearGuildBank();
if(guild_id != GUILD_NONE)
zone/guild_mgr.cpp
+14 -14
View File
@@ -322,7 +322,7 @@ void ZoneGuildManager::ProcessWorldPacket(ServerPacket *pack) {
else if(c != nullptr && s->guild_id != GUILD_NONE) {
//char is in zone, and has changed into a new guild, send MOTD.
c->SendGuildMOTD();
if (c->ClientVersion() >= EQEmu::versions::ClientVersion::RoF)
if (c->ClientVersion() >= EQ::versions::ClientVersion::RoF)
{
c->SendGuildRanks();
}
@@ -690,10 +690,10 @@ void GuildBankManager::SendGuildBank(Client *c)
auto &guild_bank = *Iterator;
// RoF+ uses a bulk list packet -- This is also how the Action 0 of older clients basically works
if (c->ClientVersionBit() & EQEmu::versions::maskRoFAndLater) {
if (c->ClientVersionBit() & EQ::versions::maskRoFAndLater) {
auto outapp = new EQApplicationPacket(OP_GuildBankItemList, sizeof(GuildBankItemListEntry_Struct) * 240);
for (int i = 0; i < GUILD_BANK_DEPOSIT_AREA_SIZE; ++i) {
const EQEmu::ItemData *Item = database.GetItem(guild_bank->Items.DepositArea[i].ItemID);
const EQ::ItemData *Item = database.GetItem(guild_bank->Items.DepositArea[i].ItemID);
if (Item) {
outapp->WriteUInt8(1);
outapp->WriteUInt32(guild_bank->Items.DepositArea[i].Permissions);
@@ -717,7 +717,7 @@ void GuildBankManager::SendGuildBank(Client *c)
outapp->SetWritePosition(outapp->GetWritePosition() + 20); // newer clients have 40 deposit slots, keep them 0 for now
for (int i = 0; i < GUILD_BANK_MAIN_AREA_SIZE; ++i) {
const EQEmu::ItemData *Item = database.GetItem(guild_bank->Items.MainArea[i].ItemID);
const EQ::ItemData *Item = database.GetItem(guild_bank->Items.MainArea[i].ItemID);
if (Item) {
outapp->WriteUInt8(1);
outapp->WriteUInt32(guild_bank->Items.MainArea[i].Permissions);
@@ -748,7 +748,7 @@ void GuildBankManager::SendGuildBank(Client *c)
{
if(guild_bank->Items.DepositArea[i].ItemID > 0)
{
const EQEmu::ItemData *Item = database.GetItem(guild_bank->Items.DepositArea[i].ItemID);
const EQ::ItemData *Item = database.GetItem(guild_bank->Items.DepositArea[i].ItemID);
if(!Item)
continue;
@@ -784,7 +784,7 @@ void GuildBankManager::SendGuildBank(Client *c)
{
if(guild_bank->Items.MainArea[i].ItemID > 0)
{
const EQEmu::ItemData *Item = database.GetItem(guild_bank->Items.MainArea[i].ItemID);
const EQ::ItemData *Item = database.GetItem(guild_bank->Items.MainArea[i].ItemID);
if(!Item)
continue;
@@ -915,7 +915,7 @@ bool GuildBankManager::AddItem(uint32 GuildID, uint8 Area, uint32 ItemID, int32
return false;
}
const EQEmu::ItemData *Item = database.GetItem(ItemID);
const EQ::ItemData *Item = database.GetItem(ItemID);
GuildBankItemUpdate_Struct gbius;
@@ -981,7 +981,7 @@ int GuildBankManager::Promote(uint32 guildID, int slotID)
(*iter)->Items.DepositArea[slotID].ItemID = 0;
const EQEmu::ItemData *Item = database.GetItem((*iter)->Items.MainArea[mainSlot].ItemID);
const EQ::ItemData *Item = database.GetItem((*iter)->Items.MainArea[mainSlot].ItemID);
GuildBankItemUpdate_Struct gbius;
@@ -1037,7 +1037,7 @@ void GuildBankManager::SetPermissions(uint32 guildID, uint16 slotID, uint32 perm
else
(*iter)->Items.MainArea[slotID].WhoFor[0] = '\0';
const EQEmu::ItemData *Item = database.GetItem((*iter)->Items.MainArea[slotID].ItemID);
const EQ::ItemData *Item = database.GetItem((*iter)->Items.MainArea[slotID].ItemID);
GuildBankItemUpdate_Struct gbius;
@@ -1061,7 +1061,7 @@ void GuildBankManager::SetPermissions(uint32 guildID, uint16 slotID, uint32 perm
entity_list.QueueClientsGuildBankItemUpdate(&gbius, guildID);
}
EQEmu::ItemInstance* GuildBankManager::GetItem(uint32 GuildID, uint16 Area, uint16 SlotID, uint32 Quantity)
EQ::ItemInstance* GuildBankManager::GetItem(uint32 GuildID, uint16 Area, uint16 SlotID, uint32 Quantity)
{
auto Iterator = GetGuildBank(GuildID);
@@ -1070,7 +1070,7 @@ EQEmu::ItemInstance* GuildBankManager::GetItem(uint32 GuildID, uint16 Area, uint
GuildBankItem* BankArea = nullptr;
EQEmu::ItemInstance* inst = nullptr;
EQ::ItemInstance* inst = nullptr;
if(Area == GuildBankDepositArea)
{
@@ -1168,7 +1168,7 @@ bool GuildBankManager::DeleteItem(uint32 guildID, uint16 area, uint16 slotID, ui
bool deleted = true;
const EQEmu::ItemData *Item = database.GetItem(BankArea[slotID].ItemID);
const EQ::ItemData *Item = database.GetItem(BankArea[slotID].ItemID);
if(!Item->Stackable || (quantity >= BankArea[slotID].Quantity)) {
std::string query = StringFormat("DELETE FROM `guild_bank` WHERE `guildid` = %i "
@@ -1229,7 +1229,7 @@ bool GuildBankManager::MergeStacks(uint32 GuildID, uint16 SlotID)
if(BankArea[SlotID].ItemID == 0)
return false;
const EQEmu::ItemData *Item = database.GetItem(BankArea[SlotID].ItemID);
const EQ::ItemData *Item = database.GetItem(BankArea[SlotID].ItemID);
if(!Item->Stackable)
return false;
@@ -1327,7 +1327,7 @@ bool GuildBankManager::SplitStack(uint32 GuildID, uint16 SlotID, uint32 Quantity
if(BankArea[SlotID].Quantity <= Quantity || Quantity == 0)
return false;
const EQEmu::ItemData *Item = database.GetItem(BankArea[SlotID].ItemID);
const EQ::ItemData *Item = database.GetItem(BankArea[SlotID].ItemID);
if(!Item->Stackable)
return false;
zone/guild_mgr.h
+1 -1
View File
@@ -117,7 +117,7 @@ public:
bool AddItem(uint32 GuildID, uint8 Area, uint32 ItemID, int32 QtyOrCharges, const char *Donator, uint8 Permissions, const char *WhoFor);
int Promote(uint32 GuildID, int SlotID);
void SetPermissions(uint32 GuildID, uint16 SlotID, uint32 Permissions, const char *MemberName);
EQEmu::ItemInstance* GetItem(uint32 GuildID, uint16 Area, uint16 SlotID, uint32 Quantity);
EQ::ItemInstance* GetItem(uint32 GuildID, uint16 Area, uint16 SlotID, uint32 Quantity);
bool DeleteItem(uint32 GuildID, uint16 Area, uint16 SlotID, uint32 Quantity);
bool HasItem(uint32 GuildID, uint32 ItemID);
bool IsAreaFull(uint32 GuildID, uint16 Area);
zone/hate_list.cpp
+1 -1
View File
@@ -297,7 +297,7 @@ int HateList::GetHateRatio(Mob *top, Mob *other)
if (!top_entry || top_entry->stored_hate_amount < 1)
return 999; // shouldn't happen if you call it right :P
return EQEmu::Clamp(static_cast<int>((other_entry->stored_hate_amount * 100) / top_entry->stored_hate_amount), 1, 999);
return EQ::Clamp(static_cast<int>((other_entry->stored_hate_amount * 100) / top_entry->stored_hate_amount), 1, 999);
}
// skip is used to ignore a certain mob on the list
zone/inventory.cpp
+380 -380
View File
File diff suppressed because it is too large Load Diff
zone/loottables.cpp
+34 -34
View File
@@ -61,7 +61,7 @@ void ZoneDatabase::AddLootTableToNPC(NPC* npc,uint32 loottable_id, ItemList* ite
uint32 cash = 0;
if (!bGlobal) {
if(max_cash > 0 && lts->avgcoin > 0 && EQEmu::ValueWithin(lts->avgcoin, min_cash, max_cash)) {
if(max_cash > 0 && lts->avgcoin > 0 && EQ::ValueWithin(lts->avgcoin, min_cash, max_cash)) {
float upper_chance = (float)(lts->avgcoin - min_cash) / (float)(max_cash - min_cash);
float avg_cash_roll = (float)zone->random.Real(0.0, 1.0);
@@ -128,7 +128,7 @@ void ZoneDatabase::AddLootDropToNPC(NPC* npc,uint32 lootdrop_id, ItemList* iteml
int charges = lds->Entries[i].multiplier;
for(int j = 0; j < charges; ++j) {
if(zone->random.Real(0.0, 100.0) <= lds->Entries[i].chance) {
const EQEmu::ItemData* dbitem = GetItem(lds->Entries[i].item_id);
const EQ::ItemData* dbitem = GetItem(lds->Entries[i].item_id);
npc->AddLootDrop(dbitem, itemlist, lds->Entries[i].item_charges, lds->Entries[i].minlevel,
lds->Entries[i].maxlevel, lds->Entries[i].equip_item > 0 ? true : false, false);
}
@@ -149,7 +149,7 @@ void ZoneDatabase::AddLootDropToNPC(NPC* npc,uint32 lootdrop_id, ItemList* iteml
float roll_t_min = 0.0f;
bool active_item_list = false;
for(uint32 i = 0; i < lds->NumEntries; ++i) {
const EQEmu::ItemData* db_item = GetItem(lds->Entries[i].item_id);
const EQ::ItemData* db_item = GetItem(lds->Entries[i].item_id);
if(db_item) {
roll_t += lds->Entries[i].chance;
active_item_list = true;
@@ -157,7 +157,7 @@ void ZoneDatabase::AddLootDropToNPC(NPC* npc,uint32 lootdrop_id, ItemList* iteml
}
roll_t_min = roll_t;
roll_t = EQEmu::ClampLower(roll_t, 100.0f);
roll_t = EQ::ClampLower(roll_t, 100.0f);
if(!active_item_list) {
return;
@@ -166,14 +166,14 @@ void ZoneDatabase::AddLootDropToNPC(NPC* npc,uint32 lootdrop_id, ItemList* iteml
for(int i = 0; i < mindrop; ++i) {
float roll = (float)zone->random.Real(0.0, roll_t_min);
for(uint32 j = 0; j < lds->NumEntries; ++j) {
const EQEmu::ItemData* db_item = GetItem(lds->Entries[j].item_id);
const EQ::ItemData* db_item = GetItem(lds->Entries[j].item_id);
if(db_item) {
if(roll < lds->Entries[j].chance) {
npc->AddLootDrop(db_item, itemlist, lds->Entries[j].item_charges, lds->Entries[j].minlevel,
lds->Entries[j].maxlevel, lds->Entries[j].equip_item > 0 ? true : false, false);
int charges = (int)lds->Entries[i].multiplier;
charges = EQEmu::ClampLower(charges, 1);
charges = EQ::ClampLower(charges, 1);
for(int k = 1; k < charges; ++k) {
float c_roll = (float)zone->random.Real(0.0, 100.0);
@@ -196,14 +196,14 @@ void ZoneDatabase::AddLootDropToNPC(NPC* npc,uint32 lootdrop_id, ItemList* iteml
for(int i = mindrop; i < droplimit; ++i) {
float roll = (float)zone->random.Real(0.0, roll_t);
for(uint32 j = 0; j < lds->NumEntries; ++j) {
const EQEmu::ItemData* db_item = GetItem(lds->Entries[j].item_id);
const EQ::ItemData* db_item = GetItem(lds->Entries[j].item_id);
if(db_item) {
if(roll < lds->Entries[j].chance) {
npc->AddLootDrop(db_item, itemlist, lds->Entries[j].item_charges, lds->Entries[j].minlevel,
lds->Entries[j].maxlevel, lds->Entries[j].equip_item > 0 ? true : false, false);
int charges = (int)lds->Entries[i].multiplier;
charges = EQEmu::ClampLower(charges, 1);
charges = EQ::ClampLower(charges, 1);
for(int k = 1; k < charges; ++k) {
float c_roll = (float)zone->random.Real(0.0, 100.0);
@@ -230,7 +230,7 @@ void ZoneDatabase::AddLootDropToNPC(NPC* npc,uint32 lootdrop_id, ItemList* iteml
}
//if itemlist is null, just send wear changes
void NPC::AddLootDrop(const EQEmu::ItemData *item2, ItemList* itemlist, int16 charges, uint8 minlevel, uint8 maxlevel, bool equipit, bool wearchange, uint32 aug1, uint32 aug2, uint32 aug3, uint32 aug4, uint32 aug5, uint32 aug6) {
void NPC::AddLootDrop(const EQ::ItemData *item2, ItemList* itemlist, int16 charges, uint8 minlevel, uint8 maxlevel, bool equipit, bool wearchange, uint32 aug1, uint32 aug2, uint32 aug3, uint32 aug4, uint32 aug5, uint32 aug6) {
if(item2 == nullptr)
return;
@@ -263,12 +263,12 @@ void NPC::AddLootDrop(const EQEmu::ItemData *item2, ItemList* itemlist, int16 ch
item->attuned = 0;
item->min_level = minlevel;
item->max_level = maxlevel;
item->equip_slot = EQEmu::invslot::SLOT_INVALID;
item->equip_slot = EQ::invslot::SLOT_INVALID;
if (equipit) {
uint8 eslot = 0xFF;
char newid[20];
const EQEmu::ItemData* compitem = nullptr;
const EQ::ItemData* compitem = nullptr;
bool found = false; // track if we found an empty slot we fit into
int32 foundslot = -1; // for multi-slot items
@@ -282,7 +282,7 @@ void NPC::AddLootDrop(const EQEmu::ItemData *item2, ItemList* itemlist, int16 ch
// it is an improvement.
if (!item2->NoPet) {
for (int i = EQEmu::invslot::EQUIPMENT_BEGIN; !found && i <= EQEmu::invslot::EQUIPMENT_END; i++) {
for (int i = EQ::invslot::EQUIPMENT_BEGIN; !found && i <= EQ::invslot::EQUIPMENT_END; i++) {
uint32 slots = (1 << i);
if (item2->Slots & slots) {
if(equipment[i])
@@ -323,7 +323,7 @@ void NPC::AddLootDrop(const EQEmu::ItemData *item2, ItemList* itemlist, int16 ch
// @merth: IDFile size has been increased, this needs to change
uint16 emat;
if(item2->Material <= 0
|| (item2->Slots & ((1 << EQEmu::invslot::slotPrimary) | (1 << EQEmu::invslot::slotSecondary)))) {
|| (item2->Slots & ((1 << EQ::invslot::slotPrimary) | (1 << EQ::invslot::slotSecondary)))) {
memset(newid, 0, sizeof(newid));
for(int i=0;i<7;i++){
if (!isalpha(item2->IDFile[i])){
@@ -337,11 +337,11 @@ void NPC::AddLootDrop(const EQEmu::ItemData *item2, ItemList* itemlist, int16 ch
emat = item2->Material;
}
if (foundslot == EQEmu::invslot::slotPrimary) {
if (foundslot == EQ::invslot::slotPrimary) {
if (item2->Proc.Effect != 0)
CastToMob()->AddProcToWeapon(item2->Proc.Effect, true);
eslot = EQEmu::textures::weaponPrimary;
eslot = EQ::textures::weaponPrimary;
if (item2->Damage > 0) {
SendAddPlayerState(PlayerState::PrimaryWeaponEquipped);
if (!RuleB(Combat, ClassicNPCBackstab))
@@ -350,37 +350,37 @@ void NPC::AddLootDrop(const EQEmu::ItemData *item2, ItemList* itemlist, int16 ch
if (item2->IsType2HWeapon())
SetTwoHanderEquipped(true);
}
else if (foundslot == EQEmu::invslot::slotSecondary
else if (foundslot == EQ::invslot::slotSecondary
&& (GetOwner() != nullptr || (CanThisClassDualWield() && zone->random.Roll(NPC_DW_CHANCE)) || (item2->Damage==0)) &&
(item2->IsType1HWeapon() || item2->ItemType == EQEmu::item::ItemTypeShield || item2->ItemType == EQEmu::item::ItemTypeLight))
(item2->IsType1HWeapon() || item2->ItemType == EQ::item::ItemTypeShield || item2->ItemType == EQ::item::ItemTypeLight))
{
if (item2->Proc.Effect!=0)
CastToMob()->AddProcToWeapon(item2->Proc.Effect, true);
eslot = EQEmu::textures::weaponSecondary;
eslot = EQ::textures::weaponSecondary;
if (item2->Damage > 0)
SendAddPlayerState(PlayerState::SecondaryWeaponEquipped);
}
else if (foundslot == EQEmu::invslot::slotHead) {
eslot = EQEmu::textures::armorHead;
else if (foundslot == EQ::invslot::slotHead) {
eslot = EQ::textures::armorHead;
}
else if (foundslot == EQEmu::invslot::slotChest) {
eslot = EQEmu::textures::armorChest;
else if (foundslot == EQ::invslot::slotChest) {
eslot = EQ::textures::armorChest;
}
else if (foundslot == EQEmu::invslot::slotArms) {
eslot = EQEmu::textures::armorArms;
else if (foundslot == EQ::invslot::slotArms) {
eslot = EQ::textures::armorArms;
}
else if (foundslot == EQEmu::invslot::slotWrist1 || foundslot == EQEmu::invslot::slotWrist2) {
eslot = EQEmu::textures::armorWrist;
else if (foundslot == EQ::invslot::slotWrist1 || foundslot == EQ::invslot::slotWrist2) {
eslot = EQ::textures::armorWrist;
}
else if (foundslot == EQEmu::invslot::slotHands) {
eslot = EQEmu::textures::armorHands;
else if (foundslot == EQ::invslot::slotHands) {
eslot = EQ::textures::armorHands;
}
else if (foundslot == EQEmu::invslot::slotLegs) {
eslot = EQEmu::textures::armorLegs;
else if (foundslot == EQ::invslot::slotLegs) {
eslot = EQ::textures::armorLegs;
}
else if (foundslot == EQEmu::invslot::slotFeet) {
eslot = EQEmu::textures::armorFeet;
else if (foundslot == EQ::invslot::slotFeet) {
eslot = EQ::textures::armorFeet;
}
/*
@@ -428,14 +428,14 @@ void NPC::AddLootDrop(const EQEmu::ItemData *item2, ItemList* itemlist, int16 ch
SendAppearancePacket(AT_Light, GetActiveLightType());
}
void NPC::AddItem(const EQEmu::ItemData* item, uint16 charges, bool equipitem) {
void NPC::AddItem(const EQ::ItemData* item, uint16 charges, bool equipitem) {
//slot isnt needed, its determined from the item.
AddLootDrop(item, &itemlist, charges, 1, 255, equipitem, equipitem);
}
void NPC::AddItem(uint32 itemid, uint16 charges, bool equipitem, uint32 aug1, uint32 aug2, uint32 aug3, uint32 aug4, uint32 aug5, uint32 aug6) {
//slot isnt needed, its determined from the item.
const EQEmu::ItemData * i = database.GetItem(itemid);
const EQ::ItemData * i = database.GetItem(itemid);
if(i == nullptr)
return;
AddLootDrop(i, &itemlist, charges, 1, 255, equipitem, equipitem, aug1, aug2, aug3, aug4, aug5, aug6);
zone/lua_client.cpp
+10 -10
View File
@@ -442,27 +442,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<EQEmu::skills::SkillType>(skill_id));
return self->GetRawSkill(static_cast<EQ::skills::SkillType>(skill_id));
}
bool Lua_Client::HasSkill(int skill_id) {
Lua_Safe_Call_Bool();
return self->HasSkill(static_cast<EQEmu::skills::SkillType>(skill_id));
return self->HasSkill(static_cast<EQ::skills::SkillType>(skill_id));
}
bool Lua_Client::CanHaveSkill(int skill_id) {
Lua_Safe_Call_Bool();
return self->CanHaveSkill(static_cast<EQEmu::skills::SkillType>(skill_id));
return self->CanHaveSkill(static_cast<EQ::skills::SkillType>(skill_id));
}
void Lua_Client::SetSkill(int skill_id, int value) {
Lua_Safe_Call_Void();
self->SetSkill(static_cast<EQEmu::skills::SkillType>(skill_id), value);
self->SetSkill(static_cast<EQ::skills::SkillType>(skill_id), value);
}
void Lua_Client::AddSkill(int skill_id, int value) {
Lua_Safe_Call_Void();
self->AddSkill(static_cast<EQEmu::skills::SkillType>(skill_id), value);
self->AddSkill(static_cast<EQ::skills::SkillType>(skill_id), value);
}
void Lua_Client::CheckSpecializeIncrease(int spell_id) {
@@ -472,12 +472,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<EQEmu::skills::SkillType>(skill_id), target);
self->CheckIncreaseSkill(static_cast<EQ::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<EQEmu::skills::SkillType>(skill_id), target, chance_mod);
self->CheckIncreaseSkill(static_cast<EQ::skills::SkillType>(skill_id), target, chance_mod);
}
void Lua_Client::SetLanguageSkill(int language, int value) {
@@ -487,7 +487,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<EQEmu::skills::SkillType>(skill_id));
return self->MaxSkill(static_cast<EQ::skills::SkillType>(skill_id));
}
bool Lua_Client::IsMedding() {
@@ -1267,13 +1267,13 @@ Lua_Raid Lua_Client::GetRaid() {
bool Lua_Client::PutItemInInventory(int slot_id, Lua_ItemInst inst) {
Lua_Safe_Call_Bool();
EQEmu::ItemInstance *rinst = inst;
EQ::ItemInstance *rinst = inst;
return self->PutItemInInventory(slot_id, *rinst, true);
}
bool Lua_Client::PushItemOnCursor(Lua_ItemInst inst) {
Lua_Safe_Call_Bool();
EQEmu::ItemInstance *rinst = inst;
EQ::ItemInstance *rinst = inst;
return self->PushItemOnCursor(*rinst, true);
}
zone/lua_general.cpp
+191 -191
View File
@@ -71,7 +71,7 @@ void load_encounter_with_data(std::string name, std::string info_str) {
entity_list.AddEncounter(enc);
lua_encounters[name] = enc;
lua_encounters_loaded[name] = true;
std::vector<EQEmu::Any> info_ptrs;
std::vector<EQ::Any> info_ptrs;
info_ptrs.push_back(&info_str);
parse->EventEncounter(EVENT_ENCOUNTER_LOAD, name, "", 0, &info_ptrs);
}
@@ -133,7 +133,7 @@ void unload_encounter_with_data(std::string name, std::string info_str) {
lua_encounters[name]->Depop();
lua_encounters.erase(name);
lua_encounters_loaded.erase(name);
std::vector<EQEmu::Any> info_ptrs;
std::vector<EQ::Any> info_ptrs;
info_ptrs.push_back(&info_str);
parse->EventEncounter(EVENT_ENCOUNTER_UNLOAD, name, "", 0, &info_ptrs);
}
@@ -2047,95 +2047,95 @@ luabind::scope lua_register_slot() {
return luabind::class_<Slots>("Slot")
.enum_("constants")
[
luabind::value("Charm", static_cast<int>(EQEmu::invslot::slotCharm)),
luabind::value("Ear1", static_cast<int>(EQEmu::invslot::slotEar1)),
luabind::value("Head", static_cast<int>(EQEmu::invslot::slotHead)),
luabind::value("Face", static_cast<int>(EQEmu::invslot::slotFace)),
luabind::value("Ear2", static_cast<int>(EQEmu::invslot::slotEar2)),
luabind::value("Neck", static_cast<int>(EQEmu::invslot::slotNeck)),
luabind::value("Shoulders", static_cast<int>(EQEmu::invslot::slotShoulders)),
luabind::value("Arms", static_cast<int>(EQEmu::invslot::slotArms)),
luabind::value("Back", static_cast<int>(EQEmu::invslot::slotBack)),
luabind::value("Wrist1", static_cast<int>(EQEmu::invslot::slotWrist1)),
luabind::value("Wrist2", static_cast<int>(EQEmu::invslot::slotWrist2)),
luabind::value("Range", static_cast<int>(EQEmu::invslot::slotRange)),
luabind::value("Hands", static_cast<int>(EQEmu::invslot::slotHands)),
luabind::value("Primary", static_cast<int>(EQEmu::invslot::slotPrimary)),
luabind::value("Secondary", static_cast<int>(EQEmu::invslot::slotSecondary)),
luabind::value("Finger1", static_cast<int>(EQEmu::invslot::slotFinger1)),
luabind::value("Finger2", static_cast<int>(EQEmu::invslot::slotFinger2)),
luabind::value("Chest", static_cast<int>(EQEmu::invslot::slotChest)),
luabind::value("Legs", static_cast<int>(EQEmu::invslot::slotLegs)),
luabind::value("Feet", static_cast<int>(EQEmu::invslot::slotFeet)),
luabind::value("Waist", static_cast<int>(EQEmu::invslot::slotWaist)),
luabind::value("PowerSource", static_cast<int>(EQEmu::invslot::slotPowerSource)),
luabind::value("Ammo", static_cast<int>(EQEmu::invslot::slotAmmo)),
luabind::value("General1", static_cast<int>(EQEmu::invslot::slotGeneral1)),
luabind::value("General2", static_cast<int>(EQEmu::invslot::slotGeneral2)),
luabind::value("General3", static_cast<int>(EQEmu::invslot::slotGeneral3)),
luabind::value("General4", static_cast<int>(EQEmu::invslot::slotGeneral4)),
luabind::value("General5", static_cast<int>(EQEmu::invslot::slotGeneral5)),
luabind::value("General6", static_cast<int>(EQEmu::invslot::slotGeneral6)),
luabind::value("General7", static_cast<int>(EQEmu::invslot::slotGeneral7)),
luabind::value("General8", static_cast<int>(EQEmu::invslot::slotGeneral8)),
luabind::value("General9", static_cast<int>(EQEmu::invslot::slotGeneral9)),
luabind::value("General10", static_cast<int>(EQEmu::invslot::slotGeneral10)),
luabind::value("Cursor", static_cast<int>(EQEmu::invslot::slotCursor)),
luabind::value("PossessionsBegin", static_cast<int>(EQEmu::invslot::POSSESSIONS_BEGIN)),
luabind::value("PossessionsEnd", static_cast<int>(EQEmu::invslot::POSSESSIONS_END)),
luabind::value("EquipmentBegin", static_cast<int>(EQEmu::invslot::EQUIPMENT_BEGIN)),
luabind::value("EquipmentEnd", static_cast<int>(EQEmu::invslot::EQUIPMENT_END)),
luabind::value("GeneralBegin", static_cast<int>(EQEmu::invslot::GENERAL_BEGIN)),
luabind::value("GeneralEnd", static_cast<int>(EQEmu::invslot::GENERAL_END)),
luabind::value("PossessionsBagsBegin", static_cast<int>(EQEmu::invbag::GENERAL_BAGS_BEGIN)),
luabind::value("PossessionsBagsEnd", static_cast<int>(EQEmu::invbag::CURSOR_BAG_END)),
luabind::value("GeneralBagsBegin", static_cast<int>(EQEmu::invbag::GENERAL_BAGS_BEGIN)),
luabind::value("GeneralBagsEnd", static_cast<int>(EQEmu::invbag::GENERAL_BAGS_END)),
luabind::value("General1BagBegin", static_cast<int>(EQEmu::invbag::GENERAL_BAGS_BEGIN)),
luabind::value("General1BagEnd", static_cast<int>(EQEmu::invbag::GENERAL_BAGS_BEGIN) + 9),
luabind::value("General2BagBegin", static_cast<int>(EQEmu::invbag::GENERAL_BAGS_BEGIN) + 10),
luabind::value("General2BagEnd", static_cast<int>(EQEmu::invbag::GENERAL_BAGS_BEGIN) + 19),
luabind::value("General3BagBegin", static_cast<int>(EQEmu::invbag::GENERAL_BAGS_BEGIN) + 20),
luabind::value("General3BagEnd", static_cast<int>(EQEmu::invbag::GENERAL_BAGS_BEGIN) + 29),
luabind::value("General4BagBegin", static_cast<int>(EQEmu::invbag::GENERAL_BAGS_BEGIN) + 30),
luabind::value("General4BagEnd", static_cast<int>(EQEmu::invbag::GENERAL_BAGS_BEGIN) + 39),
luabind::value("General5BagBegin", static_cast<int>(EQEmu::invbag::GENERAL_BAGS_BEGIN) + 40),
luabind::value("General5BagEnd", static_cast<int>(EQEmu::invbag::GENERAL_BAGS_BEGIN) + 49),
luabind::value("General6BagBegin", static_cast<int>(EQEmu::invbag::GENERAL_BAGS_BEGIN) + 50),
luabind::value("General6BagEnd", static_cast<int>(EQEmu::invbag::GENERAL_BAGS_BEGIN) + 59),
luabind::value("General7BagBegin", static_cast<int>(EQEmu::invbag::GENERAL_BAGS_BEGIN) + 60),
luabind::value("General7BagEnd", static_cast<int>(EQEmu::invbag::GENERAL_BAGS_BEGIN) + 69),
luabind::value("General8BagBegin", static_cast<int>(EQEmu::invbag::GENERAL_BAGS_BEGIN) + 70),
luabind::value("General8BagEnd", static_cast<int>(EQEmu::invbag::GENERAL_BAGS_BEGIN) + 79),
luabind::value("General9BagBegin", static_cast<int>(EQEmu::invbag::GENERAL_BAGS_BEGIN) + 80),
luabind::value("General9BagEnd", static_cast<int>(EQEmu::invbag::GENERAL_BAGS_BEGIN) + 89),
luabind::value("General10BagBegin", static_cast<int>(EQEmu::invbag::GENERAL_BAGS_BEGIN) + 90),
luabind::value("General10BagEnd", static_cast<int>(EQEmu::invbag::GENERAL_BAGS_BEGIN) + 99),
luabind::value("CursorBagBegin", static_cast<int>(EQEmu::invbag::CURSOR_BAG_BEGIN)),
luabind::value("CursorBagEnd", static_cast<int>(EQEmu::invbag::CURSOR_BAG_END)),
luabind::value("Tradeskill", static_cast<int>(EQEmu::invslot::SLOT_TRADESKILL_EXPERIMENT_COMBINE)),
luabind::value("Augment", static_cast<int>(EQEmu::invslot::SLOT_AUGMENT_GENERIC_RETURN)),
luabind::value("BankBegin", static_cast<int>(EQEmu::invslot::BANK_BEGIN)),
luabind::value("BankEnd", static_cast<int>(EQEmu::invslot::BANK_END)),
luabind::value("BankBagsBegin", static_cast<int>(EQEmu::invbag::BANK_BAGS_BEGIN)),
luabind::value("BankBagsEnd", static_cast<int>(EQEmu::invbag::BANK_BAGS_END)),
luabind::value("SharedBankBegin", static_cast<int>(EQEmu::invslot::SHARED_BANK_BEGIN)),
luabind::value("SharedBankEnd", static_cast<int>(EQEmu::invslot::SHARED_BANK_END)),
luabind::value("SharedBankBagsBegin", static_cast<int>(EQEmu::invbag::SHARED_BANK_BAGS_BEGIN)),
luabind::value("SharedBankBagsEnd", static_cast<int>(EQEmu::invbag::SHARED_BANK_BAGS_END)),
luabind::value("BagSlotBegin", static_cast<int>(EQEmu::invbag::SLOT_BEGIN)),
luabind::value("BagSlotEnd", static_cast<int>(EQEmu::invbag::SLOT_END)),
luabind::value("AugSocketBegin", static_cast<int>(EQEmu::invaug::SOCKET_BEGIN)),
luabind::value("AugSocketEnd", static_cast<int>(EQEmu::invaug::SOCKET_END)),
luabind::value("Invalid", static_cast<int>(EQEmu::invslot::SLOT_INVALID)),
luabind::value("Charm", static_cast<int>(EQ::invslot::slotCharm)),
luabind::value("Ear1", static_cast<int>(EQ::invslot::slotEar1)),
luabind::value("Head", static_cast<int>(EQ::invslot::slotHead)),
luabind::value("Face", static_cast<int>(EQ::invslot::slotFace)),
luabind::value("Ear2", static_cast<int>(EQ::invslot::slotEar2)),
luabind::value("Neck", static_cast<int>(EQ::invslot::slotNeck)),
luabind::value("Shoulders", static_cast<int>(EQ::invslot::slotShoulders)),
luabind::value("Arms", static_cast<int>(EQ::invslot::slotArms)),
luabind::value("Back", static_cast<int>(EQ::invslot::slotBack)),
luabind::value("Wrist1", static_cast<int>(EQ::invslot::slotWrist1)),
luabind::value("Wrist2", static_cast<int>(EQ::invslot::slotWrist2)),
luabind::value("Range", static_cast<int>(EQ::invslot::slotRange)),
luabind::value("Hands", static_cast<int>(EQ::invslot::slotHands)),
luabind::value("Primary", static_cast<int>(EQ::invslot::slotPrimary)),
luabind::value("Secondary", static_cast<int>(EQ::invslot::slotSecondary)),
luabind::value("Finger1", static_cast<int>(EQ::invslot::slotFinger1)),
luabind::value("Finger2", static_cast<int>(EQ::invslot::slotFinger2)),
luabind::value("Chest", static_cast<int>(EQ::invslot::slotChest)),
luabind::value("Legs", static_cast<int>(EQ::invslot::slotLegs)),
luabind::value("Feet", static_cast<int>(EQ::invslot::slotFeet)),
luabind::value("Waist", static_cast<int>(EQ::invslot::slotWaist)),
luabind::value("PowerSource", static_cast<int>(EQ::invslot::slotPowerSource)),
luabind::value("Ammo", static_cast<int>(EQ::invslot::slotAmmo)),
luabind::value("General1", static_cast<int>(EQ::invslot::slotGeneral1)),
luabind::value("General2", static_cast<int>(EQ::invslot::slotGeneral2)),
luabind::value("General3", static_cast<int>(EQ::invslot::slotGeneral3)),
luabind::value("General4", static_cast<int>(EQ::invslot::slotGeneral4)),
luabind::value("General5", static_cast<int>(EQ::invslot::slotGeneral5)),
luabind::value("General6", static_cast<int>(EQ::invslot::slotGeneral6)),
luabind::value("General7", static_cast<int>(EQ::invslot::slotGeneral7)),
luabind::value("General8", static_cast<int>(EQ::invslot::slotGeneral8)),
luabind::value("General9", static_cast<int>(EQ::invslot::slotGeneral9)),
luabind::value("General10", static_cast<int>(EQ::invslot::slotGeneral10)),
luabind::value("Cursor", static_cast<int>(EQ::invslot::slotCursor)),
luabind::value("PossessionsBegin", static_cast<int>(EQ::invslot::POSSESSIONS_BEGIN)),
luabind::value("PossessionsEnd", static_cast<int>(EQ::invslot::POSSESSIONS_END)),
luabind::value("EquipmentBegin", static_cast<int>(EQ::invslot::EQUIPMENT_BEGIN)),
luabind::value("EquipmentEnd", static_cast<int>(EQ::invslot::EQUIPMENT_END)),
luabind::value("GeneralBegin", static_cast<int>(EQ::invslot::GENERAL_BEGIN)),
luabind::value("GeneralEnd", static_cast<int>(EQ::invslot::GENERAL_END)),
luabind::value("PossessionsBagsBegin", static_cast<int>(EQ::invbag::GENERAL_BAGS_BEGIN)),
luabind::value("PossessionsBagsEnd", static_cast<int>(EQ::invbag::CURSOR_BAG_END)),
luabind::value("GeneralBagsBegin", static_cast<int>(EQ::invbag::GENERAL_BAGS_BEGIN)),
luabind::value("GeneralBagsEnd", static_cast<int>(EQ::invbag::GENERAL_BAGS_END)),
luabind::value("General1BagBegin", static_cast<int>(EQ::invbag::GENERAL_BAGS_BEGIN)),
luabind::value("General1BagEnd", static_cast<int>(EQ::invbag::GENERAL_BAGS_BEGIN) + 9),
luabind::value("General2BagBegin", static_cast<int>(EQ::invbag::GENERAL_BAGS_BEGIN) + 10),
luabind::value("General2BagEnd", static_cast<int>(EQ::invbag::GENERAL_BAGS_BEGIN) + 19),
luabind::value("General3BagBegin", static_cast<int>(EQ::invbag::GENERAL_BAGS_BEGIN) + 20),
luabind::value("General3BagEnd", static_cast<int>(EQ::invbag::GENERAL_BAGS_BEGIN) + 29),
luabind::value("General4BagBegin", static_cast<int>(EQ::invbag::GENERAL_BAGS_BEGIN) + 30),
luabind::value("General4BagEnd", static_cast<int>(EQ::invbag::GENERAL_BAGS_BEGIN) + 39),
luabind::value("General5BagBegin", static_cast<int>(EQ::invbag::GENERAL_BAGS_BEGIN) + 40),
luabind::value("General5BagEnd", static_cast<int>(EQ::invbag::GENERAL_BAGS_BEGIN) + 49),
luabind::value("General6BagBegin", static_cast<int>(EQ::invbag::GENERAL_BAGS_BEGIN) + 50),
luabind::value("General6BagEnd", static_cast<int>(EQ::invbag::GENERAL_BAGS_BEGIN) + 59),
luabind::value("General7BagBegin", static_cast<int>(EQ::invbag::GENERAL_BAGS_BEGIN) + 60),
luabind::value("General7BagEnd", static_cast<int>(EQ::invbag::GENERAL_BAGS_BEGIN) + 69),
luabind::value("General8BagBegin", static_cast<int>(EQ::invbag::GENERAL_BAGS_BEGIN) + 70),
luabind::value("General8BagEnd", static_cast<int>(EQ::invbag::GENERAL_BAGS_BEGIN) + 79),
luabind::value("General9BagBegin", static_cast<int>(EQ::invbag::GENERAL_BAGS_BEGIN) + 80),
luabind::value("General9BagEnd", static_cast<int>(EQ::invbag::GENERAL_BAGS_BEGIN) + 89),
luabind::value("General10BagBegin", static_cast<int>(EQ::invbag::GENERAL_BAGS_BEGIN) + 90),
luabind::value("General10BagEnd", static_cast<int>(EQ::invbag::GENERAL_BAGS_BEGIN) + 99),
luabind::value("CursorBagBegin", static_cast<int>(EQ::invbag::CURSOR_BAG_BEGIN)),
luabind::value("CursorBagEnd", static_cast<int>(EQ::invbag::CURSOR_BAG_END)),
luabind::value("Tradeskill", static_cast<int>(EQ::invslot::SLOT_TRADESKILL_EXPERIMENT_COMBINE)),
luabind::value("Augment", static_cast<int>(EQ::invslot::SLOT_AUGMENT_GENERIC_RETURN)),
luabind::value("BankBegin", static_cast<int>(EQ::invslot::BANK_BEGIN)),
luabind::value("BankEnd", static_cast<int>(EQ::invslot::BANK_END)),
luabind::value("BankBagsBegin", static_cast<int>(EQ::invbag::BANK_BAGS_BEGIN)),
luabind::value("BankBagsEnd", static_cast<int>(EQ::invbag::BANK_BAGS_END)),
luabind::value("SharedBankBegin", static_cast<int>(EQ::invslot::SHARED_BANK_BEGIN)),
luabind::value("SharedBankEnd", static_cast<int>(EQ::invslot::SHARED_BANK_END)),
luabind::value("SharedBankBagsBegin", static_cast<int>(EQ::invbag::SHARED_BANK_BAGS_BEGIN)),
luabind::value("SharedBankBagsEnd", static_cast<int>(EQ::invbag::SHARED_BANK_BAGS_END)),
luabind::value("BagSlotBegin", static_cast<int>(EQ::invbag::SLOT_BEGIN)),
luabind::value("BagSlotEnd", static_cast<int>(EQ::invbag::SLOT_END)),
luabind::value("AugSocketBegin", static_cast<int>(EQ::invaug::SOCKET_BEGIN)),
luabind::value("AugSocketEnd", static_cast<int>(EQ::invaug::SOCKET_END)),
luabind::value("Invalid", static_cast<int>(EQ::invslot::SLOT_INVALID)),
luabind::value("Shoulder", static_cast<int>(EQEmu::invslot::slotShoulders)), // deprecated
luabind::value("Bracer1", static_cast<int>(EQEmu::invslot::slotWrist1)), // deprecated
luabind::value("Bracer2", static_cast<int>(EQEmu::invslot::slotWrist2)), // deprecated
luabind::value("Ring1", static_cast<int>(EQEmu::invslot::slotFinger1)), // deprecated
luabind::value("Ring2", static_cast<int>(EQEmu::invslot::slotFinger2)), // deprecated
luabind::value("PersonalBegin", static_cast<int>(EQEmu::invslot::GENERAL_BEGIN)), // deprecated
luabind::value("PersonalEnd", static_cast<int>(EQEmu::invslot::GENERAL_END)), // deprecated
luabind::value("Shoulder", static_cast<int>(EQ::invslot::slotShoulders)), // deprecated
luabind::value("Bracer1", static_cast<int>(EQ::invslot::slotWrist1)), // deprecated
luabind::value("Bracer2", static_cast<int>(EQ::invslot::slotWrist2)), // deprecated
luabind::value("Ring1", static_cast<int>(EQ::invslot::slotFinger1)), // deprecated
luabind::value("Ring2", static_cast<int>(EQ::invslot::slotFinger2)), // deprecated
luabind::value("PersonalBegin", static_cast<int>(EQ::invslot::GENERAL_BEGIN)), // deprecated
luabind::value("PersonalEnd", static_cast<int>(EQ::invslot::GENERAL_END)), // deprecated
luabind::value("CursorEnd", 0xFFFE) // deprecated (not in use..and never valid vis-a-vis client behavior)
];
}
@@ -2144,20 +2144,20 @@ luabind::scope lua_register_material() {
return luabind::class_<Materials>("Material")
.enum_("constants")
[
luabind::value("Head", static_cast<int>(EQEmu::textures::armorHead)),
luabind::value("Chest", static_cast<int>(EQEmu::textures::armorChest)),
luabind::value("Arms", static_cast<int>(EQEmu::textures::armorArms)),
luabind::value("Wrist", static_cast<int>(EQEmu::textures::armorWrist)),
luabind::value("Hands", static_cast<int>(EQEmu::textures::armorHands)),
luabind::value("Legs", static_cast<int>(EQEmu::textures::armorLegs)),
luabind::value("Feet", static_cast<int>(EQEmu::textures::armorFeet)),
luabind::value("Primary", static_cast<int>(EQEmu::textures::weaponPrimary)),
luabind::value("Secondary", static_cast<int>(EQEmu::textures::weaponSecondary)),
luabind::value("Count", static_cast<int>(EQEmu::textures::materialCount)),
luabind::value("Invalid", static_cast<int>(EQEmu::textures::materialInvalid)),
luabind::value("Head", static_cast<int>(EQ::textures::armorHead)),
luabind::value("Chest", static_cast<int>(EQ::textures::armorChest)),
luabind::value("Arms", static_cast<int>(EQ::textures::armorArms)),
luabind::value("Wrist", static_cast<int>(EQ::textures::armorWrist)),
luabind::value("Hands", static_cast<int>(EQ::textures::armorHands)),
luabind::value("Legs", static_cast<int>(EQ::textures::armorLegs)),
luabind::value("Feet", static_cast<int>(EQ::textures::armorFeet)),
luabind::value("Primary", static_cast<int>(EQ::textures::weaponPrimary)),
luabind::value("Secondary", static_cast<int>(EQ::textures::weaponSecondary)),
luabind::value("Count", static_cast<int>(EQ::textures::materialCount)),
luabind::value("Invalid", static_cast<int>(EQ::textures::materialInvalid)),
luabind::value("Bracer", static_cast<int>(EQEmu::textures::armorWrist)), // deprecated
luabind::value("Max", static_cast<int>(EQEmu::textures::materialCount)) // deprecated
luabind::value("Bracer", static_cast<int>(EQ::textures::armorWrist)), // deprecated
luabind::value("Max", static_cast<int>(EQ::textures::materialCount)) // deprecated
];
}
@@ -2165,14 +2165,14 @@ luabind::scope lua_register_client_version() {
return luabind::class_<ClientVersions>("ClientVersion")
.enum_("constants")
[
luabind::value("Unknown", static_cast<int>(EQEmu::versions::ClientVersion::Unknown)),
luabind::value("Titanium", static_cast<int>(EQEmu::versions::ClientVersion::Titanium)),
luabind::value("SoF", static_cast<int>(EQEmu::versions::ClientVersion::SoF)),
luabind::value("SoD", static_cast<int>(EQEmu::versions::ClientVersion::SoD)),
luabind::value("Underfoot", static_cast<int>(EQEmu::versions::ClientVersion::UF)), // deprecated
luabind::value("UF", static_cast<int>(EQEmu::versions::ClientVersion::UF)),
luabind::value("RoF", static_cast<int>(EQEmu::versions::ClientVersion::RoF)),
luabind::value("RoF2", static_cast<int>(EQEmu::versions::ClientVersion::RoF2))
luabind::value("Unknown", static_cast<int>(EQ::versions::ClientVersion::Unknown)),
luabind::value("Titanium", static_cast<int>(EQ::versions::ClientVersion::Titanium)),
luabind::value("SoF", static_cast<int>(EQ::versions::ClientVersion::SoF)),
luabind::value("SoD", static_cast<int>(EQ::versions::ClientVersion::SoD)),
luabind::value("Underfoot", static_cast<int>(EQ::versions::ClientVersion::UF)), // deprecated
luabind::value("UF", static_cast<int>(EQ::versions::ClientVersion::UF)),
luabind::value("RoF", static_cast<int>(EQ::versions::ClientVersion::RoF)),
luabind::value("RoF2", static_cast<int>(EQ::versions::ClientVersion::RoF2))
];
}
@@ -2245,86 +2245,86 @@ luabind::scope lua_register_skills() {
return luabind::class_<Skills>("Skill")
.enum_("constants")
[
luabind::value("1HBlunt", EQEmu::skills::Skill1HBlunt),
luabind::value("1HSlashing", EQEmu::skills::Skill1HSlashing),
luabind::value("2HBlunt", EQEmu::skills::Skill2HBlunt),
luabind::value("2HSlashing", EQEmu::skills::Skill2HSlashing),
luabind::value("Abjuration", EQEmu::skills::SkillAbjuration),
luabind::value("Alteration", EQEmu::skills::SkillAlteration),
luabind::value("ApplyPoison", EQEmu::skills::SkillApplyPoison),
luabind::value("Archery", EQEmu::skills::SkillArchery),
luabind::value("Backstab", EQEmu::skills::SkillBackstab),
luabind::value("BindWound", EQEmu::skills::SkillBindWound),
luabind::value("Bash", EQEmu::skills::SkillBash),
luabind::value("Block", EQEmu::skills::SkillBlock),
luabind::value("BrassInstruments", EQEmu::skills::SkillBrassInstruments),
luabind::value("Channeling", EQEmu::skills::SkillChanneling),
luabind::value("Conjuration", EQEmu::skills::SkillConjuration),
luabind::value("Defense", EQEmu::skills::SkillDefense),
luabind::value("Disarm", EQEmu::skills::SkillDisarm),
luabind::value("DisarmTraps", EQEmu::skills::SkillDisarmTraps),
luabind::value("Divination", EQEmu::skills::SkillDivination),
luabind::value("Dodge", EQEmu::skills::SkillDodge),
luabind::value("DoubleAttack", EQEmu::skills::SkillDoubleAttack),
luabind::value("DragonPunch", EQEmu::skills::SkillDragonPunch),
luabind::value("TailRake", EQEmu::skills::SkillTailRake),
luabind::value("DualWield", EQEmu::skills::SkillDualWield),
luabind::value("EagleStrike", EQEmu::skills::SkillEagleStrike),
luabind::value("Evocation", EQEmu::skills::SkillEvocation),
luabind::value("FeignDeath", EQEmu::skills::SkillFeignDeath),
luabind::value("FlyingKick", EQEmu::skills::SkillFlyingKick),
luabind::value("Forage", EQEmu::skills::SkillForage),
luabind::value("HandtoHand", EQEmu::skills::SkillHandtoHand),
luabind::value("Hide", EQEmu::skills::SkillHide),
luabind::value("Kick", EQEmu::skills::SkillKick),
luabind::value("Meditate", EQEmu::skills::SkillMeditate),
luabind::value("Mend", EQEmu::skills::SkillMend),
luabind::value("Offense", EQEmu::skills::SkillOffense),
luabind::value("Parry", EQEmu::skills::SkillParry),
luabind::value("PickLock", EQEmu::skills::SkillPickLock),
luabind::value("1HPiercing", EQEmu::skills::Skill1HPiercing),
luabind::value("Riposte", EQEmu::skills::SkillRiposte),
luabind::value("RoundKick", EQEmu::skills::SkillRoundKick),
luabind::value("SafeFall", EQEmu::skills::SkillSafeFall),
luabind::value("SenseHeading", EQEmu::skills::SkillSenseHeading),
luabind::value("Singing", EQEmu::skills::SkillSinging),
luabind::value("Sneak", EQEmu::skills::SkillSneak),
luabind::value("SpecializeAbjure", EQEmu::skills::SkillSpecializeAbjure),
luabind::value("SpecializeAlteration", EQEmu::skills::SkillSpecializeAlteration),
luabind::value("SpecializeConjuration", EQEmu::skills::SkillSpecializeConjuration),
luabind::value("SpecializeDivination", EQEmu::skills::SkillSpecializeDivination),
luabind::value("SpecializeEvocation", EQEmu::skills::SkillSpecializeEvocation),
luabind::value("PickPockets", EQEmu::skills::SkillPickPockets),
luabind::value("StringedInstruments", EQEmu::skills::SkillStringedInstruments),
luabind::value("Swimming", EQEmu::skills::SkillSwimming),
luabind::value("Throwing", EQEmu::skills::SkillThrowing),
luabind::value("TigerClaw", EQEmu::skills::SkillTigerClaw),
luabind::value("Tracking", EQEmu::skills::SkillTracking),
luabind::value("WindInstruments", EQEmu::skills::SkillWindInstruments),
luabind::value("Fishing", EQEmu::skills::SkillFishing),
luabind::value("MakePoison", EQEmu::skills::SkillMakePoison),
luabind::value("Tinkering", EQEmu::skills::SkillTinkering),
luabind::value("Research", EQEmu::skills::SkillResearch),
luabind::value("Alchemy", EQEmu::skills::SkillAlchemy),
luabind::value("Baking", EQEmu::skills::SkillBaking),
luabind::value("Tailoring", EQEmu::skills::SkillTailoring),
luabind::value("SenseTraps", EQEmu::skills::SkillSenseTraps),
luabind::value("Blacksmithing", EQEmu::skills::SkillBlacksmithing),
luabind::value("Fletching", EQEmu::skills::SkillFletching),
luabind::value("Brewing", EQEmu::skills::SkillBrewing),
luabind::value("AlcoholTolerance", EQEmu::skills::SkillAlcoholTolerance),
luabind::value("Begging", EQEmu::skills::SkillBegging),
luabind::value("JewelryMaking", EQEmu::skills::SkillJewelryMaking),
luabind::value("Pottery", EQEmu::skills::SkillPottery),
luabind::value("PercussionInstruments", EQEmu::skills::SkillPercussionInstruments),
luabind::value("Intimidation", EQEmu::skills::SkillIntimidation),
luabind::value("Berserking", EQEmu::skills::SkillBerserking),
luabind::value("Taunt", EQEmu::skills::SkillTaunt),
luabind::value("Frenzy", EQEmu::skills::SkillFrenzy),
luabind::value("RemoveTraps", EQEmu::skills::SkillRemoveTraps),
luabind::value("TripleAttack", EQEmu::skills::SkillTripleAttack),
luabind::value("2HPiercing", EQEmu::skills::Skill2HPiercing),
luabind::value("HIGHEST_SKILL", EQEmu::skills::HIGHEST_SKILL)
luabind::value("1HBlunt", EQ::skills::Skill1HBlunt),
luabind::value("1HSlashing", EQ::skills::Skill1HSlashing),
luabind::value("2HBlunt", EQ::skills::Skill2HBlunt),
luabind::value("2HSlashing", EQ::skills::Skill2HSlashing),
luabind::value("Abjuration", EQ::skills::SkillAbjuration),
luabind::value("Alteration", EQ::skills::SkillAlteration),
luabind::value("ApplyPoison", EQ::skills::SkillApplyPoison),
luabind::value("Archery", EQ::skills::SkillArchery),
luabind::value("Backstab", EQ::skills::SkillBackstab),
luabind::value("BindWound", EQ::skills::SkillBindWound),
luabind::value("Bash", EQ::skills::SkillBash),
luabind::value("Block", EQ::skills::SkillBlock),
luabind::value("BrassInstruments", EQ::skills::SkillBrassInstruments),
luabind::value("Channeling", EQ::skills::SkillChanneling),
luabind::value("Conjuration", EQ::skills::SkillConjuration),
luabind::value("Defense", EQ::skills::SkillDefense),
luabind::value("Disarm", EQ::skills::SkillDisarm),
luabind::value("DisarmTraps", EQ::skills::SkillDisarmTraps),
luabind::value("Divination", EQ::skills::SkillDivination),
luabind::value("Dodge", EQ::skills::SkillDodge),
luabind::value("DoubleAttack", EQ::skills::SkillDoubleAttack),
luabind::value("DragonPunch", EQ::skills::SkillDragonPunch),
luabind::value("TailRake", EQ::skills::SkillTailRake),
luabind::value("DualWield", EQ::skills::SkillDualWield),
luabind::value("EagleStrike", EQ::skills::SkillEagleStrike),
luabind::value("Evocation", EQ::skills::SkillEvocation),
luabind::value("FeignDeath", EQ::skills::SkillFeignDeath),
luabind::value("FlyingKick", EQ::skills::SkillFlyingKick),
luabind::value("Forage", EQ::skills::SkillForage),
luabind::value("HandtoHand", EQ::skills::SkillHandtoHand),
luabind::value("Hide", EQ::skills::SkillHide),
luabind::value("Kick", EQ::skills::SkillKick),
luabind::value("Meditate", EQ::skills::SkillMeditate),
luabind::value("Mend", EQ::skills::SkillMend),
luabind::value("Offense", EQ::skills::SkillOffense),
luabind::value("Parry", EQ::skills::SkillParry),
luabind::value("PickLock", EQ::skills::SkillPickLock),
luabind::value("1HPiercing", EQ::skills::Skill1HPiercing),
luabind::value("Riposte", EQ::skills::SkillRiposte),
luabind::value("RoundKick", EQ::skills::SkillRoundKick),
luabind::value("SafeFall", EQ::skills::SkillSafeFall),
luabind::value("SenseHeading", EQ::skills::SkillSenseHeading),
luabind::value("Singing", EQ::skills::SkillSinging),
luabind::value("Sneak", EQ::skills::SkillSneak),
luabind::value("SpecializeAbjure", EQ::skills::SkillSpecializeAbjure),
luabind::value("SpecializeAlteration", EQ::skills::SkillSpecializeAlteration),
luabind::value("SpecializeConjuration", EQ::skills::SkillSpecializeConjuration),
luabind::value("SpecializeDivination", EQ::skills::SkillSpecializeDivination),
luabind::value("SpecializeEvocation", EQ::skills::SkillSpecializeEvocation),
luabind::value("PickPockets", EQ::skills::SkillPickPockets),
luabind::value("StringedInstruments", EQ::skills::SkillStringedInstruments),
luabind::value("Swimming", EQ::skills::SkillSwimming),
luabind::value("Throwing", EQ::skills::SkillThrowing),
luabind::value("TigerClaw", EQ::skills::SkillTigerClaw),
luabind::value("Tracking", EQ::skills::SkillTracking),
luabind::value("WindInstruments", EQ::skills::SkillWindInstruments),
luabind::value("Fishing", EQ::skills::SkillFishing),
luabind::value("MakePoison", EQ::skills::SkillMakePoison),
luabind::value("Tinkering", EQ::skills::SkillTinkering),
luabind::value("Research", EQ::skills::SkillResearch),
luabind::value("Alchemy", EQ::skills::SkillAlchemy),
luabind::value("Baking", EQ::skills::SkillBaking),
luabind::value("Tailoring", EQ::skills::SkillTailoring),
luabind::value("SenseTraps", EQ::skills::SkillSenseTraps),
luabind::value("Blacksmithing", EQ::skills::SkillBlacksmithing),
luabind::value("Fletching", EQ::skills::SkillFletching),
luabind::value("Brewing", EQ::skills::SkillBrewing),
luabind::value("AlcoholTolerance", EQ::skills::SkillAlcoholTolerance),
luabind::value("Begging", EQ::skills::SkillBegging),
luabind::value("JewelryMaking", EQ::skills::SkillJewelryMaking),
luabind::value("Pottery", EQ::skills::SkillPottery),
luabind::value("PercussionInstruments", EQ::skills::SkillPercussionInstruments),
luabind::value("Intimidation", EQ::skills::SkillIntimidation),
luabind::value("Berserking", EQ::skills::SkillBerserking),
luabind::value("Taunt", EQ::skills::SkillTaunt),
luabind::value("Frenzy", EQ::skills::SkillFrenzy),
luabind::value("RemoveTraps", EQ::skills::SkillRemoveTraps),
luabind::value("TripleAttack", EQ::skills::SkillTripleAttack),
luabind::value("2HPiercing", EQ::skills::Skill2HPiercing),
luabind::value("HIGHEST_SKILL", EQ::skills::HIGHEST_SKILL)
];
}
zone/lua_inventory.cpp
+3 -3
View File
@@ -20,7 +20,7 @@ Lua_ItemInst Lua_Inventory::GetItem(int slot_id, int bag_slot) {
int Lua_Inventory::PutItem(int slot_id, Lua_ItemInst item) {
Lua_Safe_Call_Int();
EQEmu::ItemInstance *inst = item;
EQ::ItemInstance *inst = item;
if(!inst) {
return 0;
}
@@ -30,7 +30,7 @@ int Lua_Inventory::PutItem(int slot_id, Lua_ItemInst item) {
int Lua_Inventory::PushCursor(Lua_ItemInst item) {
Lua_Safe_Call_Int();
EQEmu::ItemInstance *inst = item;
EQ::ItemInstance *inst = item;
if(!inst) {
return 0;
}
@@ -40,7 +40,7 @@ int Lua_Inventory::PushCursor(Lua_ItemInst item) {
bool Lua_Inventory::SwapItem(int source_slot, int destination_slot) {
Lua_Safe_Call_Bool();
EQEmu::InventoryProfile::SwapItemFailState fail_state = EQEmu::InventoryProfile::swapInvalid;
EQ::InventoryProfile::SwapItemFailState fail_state = EQ::InventoryProfile::swapInvalid;
return self->SwapItem(source_slot, destination_slot, fail_state);
}
zone/lua_inventory.h
+6 -6
View File
@@ -7,7 +7,7 @@
class Lua_ItemInst;
class Lua_Item;
namespace EQEmu
namespace EQ
{
class InventoryProfile;
}
@@ -23,16 +23,16 @@ luabind::scope lua_register_inventory();
// of database calls and can lead to lost items, duplicated items and/or
// desync'd inventories, if not handled correctly.
class Lua_Inventory : public Lua_Ptr<EQEmu::InventoryProfile>
class Lua_Inventory : public Lua_Ptr<EQ::InventoryProfile>
{
typedef EQEmu::InventoryProfile NativeType;
typedef EQ::InventoryProfile NativeType;
public:
Lua_Inventory() : Lua_Ptr(nullptr) { }
Lua_Inventory(EQEmu::InventoryProfile *d) : Lua_Ptr(d) { }
Lua_Inventory(EQ::InventoryProfile *d) : Lua_Ptr(d) { }
virtual ~Lua_Inventory() { }
operator EQEmu::InventoryProfile*() {
return reinterpret_cast<EQEmu::InventoryProfile*>(GetLuaPtrData());
operator EQ::InventoryProfile*() {
return reinterpret_cast<EQ::InventoryProfile*>(GetLuaPtrData());
}
Lua_ItemInst GetItem(int slot_id);
zone/lua_item.cpp
+1 -1
View File
@@ -7,7 +7,7 @@
#include "lua_item.h"
Lua_Item::Lua_Item(uint32 item_id) {
const EQEmu::ItemData *t = database.GetItem(item_id);
const EQ::ItemData *t = database.GetItem(item_id);
SetLuaPtrData(t);
}
zone/lua_item.h
+6 -6
View File
@@ -4,7 +4,7 @@
#include "lua_ptr.h"
namespace EQEmu
namespace EQ
{
struct ItemData;
}
@@ -15,17 +15,17 @@ namespace luabind {
luabind::scope lua_register_item();
class Lua_Item : public Lua_Ptr<const EQEmu::ItemData>
class Lua_Item : public Lua_Ptr<const EQ::ItemData>
{
typedef const EQEmu::ItemData NativeType;
typedef const EQ::ItemData NativeType;
public:
Lua_Item(uint32 item_id);
Lua_Item() : Lua_Ptr(nullptr) { }
Lua_Item(const EQEmu::ItemData *d) : Lua_Ptr(d) { }
Lua_Item(const EQ::ItemData *d) : Lua_Ptr(d) { }
virtual ~Lua_Item() { }
operator const EQEmu::ItemData*() {
return reinterpret_cast<const EQEmu::ItemData*>(GetLuaPtrData());
operator const EQ::ItemData*() {
return reinterpret_cast<const EQ::ItemData*>(GetLuaPtrData());
}
int GetMinStatus();
zone/lua_iteminst.cpp
+3 -3
View File
@@ -21,7 +21,7 @@ Lua_ItemInst::Lua_ItemInst(int item_id, int charges) {
Lua_ItemInst& Lua_ItemInst::operator=(const Lua_ItemInst& o) {
if(o.cloned_) {
cloned_ = true;
d_ = new EQEmu::ItemInstance(*o.d_);
d_ = new EQ::ItemInstance(*o.d_);
} else {
cloned_ = false;
d_ = o.d_;
@@ -32,7 +32,7 @@ Lua_ItemInst& Lua_ItemInst::operator=(const Lua_ItemInst& o) {
Lua_ItemInst::Lua_ItemInst(const Lua_ItemInst& o) {
if(o.cloned_) {
cloned_ = true;
d_ = new EQEmu::ItemInstance(*o.d_);
d_ = new EQ::ItemInstance(*o.d_);
} else {
cloned_ = false;
d_ = o.d_;
@@ -41,7 +41,7 @@ Lua_ItemInst::Lua_ItemInst(const Lua_ItemInst& o) {
bool Lua_ItemInst::IsType(int item_class) {
Lua_Safe_Call_Bool();
return self->IsType(static_cast<EQEmu::item::ItemClass>(item_class));
return self->IsType(static_cast<EQ::item::ItemClass>(item_class));
}
bool Lua_ItemInst::IsStackable() {
zone/lua_iteminst.h
+8 -8
View File
@@ -6,7 +6,7 @@
class Lua_Item;
namespace EQEmu
namespace EQ
{
class ItemInstance;
}
@@ -17,21 +17,21 @@ namespace luabind {
luabind::scope lua_register_iteminst();
class Lua_ItemInst : public Lua_Ptr<EQEmu::ItemInstance>
class Lua_ItemInst : public Lua_Ptr<EQ::ItemInstance>
{
typedef EQEmu::ItemInstance NativeType;
typedef EQ::ItemInstance NativeType;
public:
Lua_ItemInst(int item_id);
Lua_ItemInst(int item_id, int charges);
Lua_ItemInst() : Lua_Ptr(nullptr), cloned_(false) { }
Lua_ItemInst(EQEmu::ItemInstance *d) : Lua_Ptr(d), cloned_(false) { }
Lua_ItemInst(EQEmu::ItemInstance *d, bool cloned) : Lua_Ptr(d), cloned_(cloned) { }
Lua_ItemInst(EQ::ItemInstance *d) : Lua_Ptr(d), cloned_(false) { }
Lua_ItemInst(EQ::ItemInstance *d, bool cloned) : Lua_Ptr(d), cloned_(cloned) { }
Lua_ItemInst& operator=(const Lua_ItemInst& o);
Lua_ItemInst(const Lua_ItemInst& o);
virtual ~Lua_ItemInst() { if(cloned_) { EQEmu::ItemInstance *ptr = GetLuaPtrData(); if(ptr) { delete ptr; } } }
virtual ~Lua_ItemInst() { if(cloned_) { EQ::ItemInstance *ptr = GetLuaPtrData(); if(ptr) { delete ptr; } } }
operator EQEmu::ItemInstance*() {
return reinterpret_cast<EQEmu::ItemInstance*>(GetLuaPtrData());
operator EQ::ItemInstance*() {
return reinterpret_cast<EQ::ItemInstance*>(GetLuaPtrData());
}
bool IsType(int item_class);
zone/lua_mob.cpp
+27 -27
View File
@@ -179,22 +179,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<EQEmu::skills::SkillType>(attack_skill));
return self->Damage(from, damage, spell_id, static_cast<EQ::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<EQEmu::skills::SkillType>(attack_skill), avoidable);
return self->Damage(from, damage, spell_id, static_cast<EQ::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<EQEmu::skills::SkillType>(attack_skill), avoidable, buffslot);
return self->Damage(from, damage, spell_id, static_cast<EQ::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<EQEmu::skills::SkillType>(attack_skill), avoidable, buffslot, buff_tic);
return self->Damage(from, damage, spell_id, static_cast<EQ::skills::SkillType>(attack_skill), avoidable, buffslot, buff_tic);
}
void Lua_Mob::RangedAttack(Lua_Mob other) {
@@ -853,28 +853,28 @@ bool Lua_Mob::CastSpell(int spell_id, int target_id) {
bool Lua_Mob::CastSpell(int spell_id, int target_id, int slot) {
Lua_Safe_Call_Bool();
return self->CastSpell(spell_id, target_id, static_cast<EQEmu::spells::CastingSlot>(slot));
return self->CastSpell(spell_id, target_id, static_cast<EQ::spells::CastingSlot>(slot));
}
bool Lua_Mob::CastSpell(int spell_id, int target_id, int slot, int cast_time) {
Lua_Safe_Call_Bool();
return self->CastSpell(spell_id, target_id, static_cast<EQEmu::spells::CastingSlot>(slot), cast_time);
return self->CastSpell(spell_id, target_id, static_cast<EQ::spells::CastingSlot>(slot), cast_time);
}
bool Lua_Mob::CastSpell(int spell_id, int target_id, int slot, int cast_time, int mana_cost) {
Lua_Safe_Call_Bool();
return self->CastSpell(spell_id, target_id, static_cast<EQEmu::spells::CastingSlot>(slot), cast_time, mana_cost);
return self->CastSpell(spell_id, target_id, static_cast<EQ::spells::CastingSlot>(slot), cast_time, mana_cost);
}
bool Lua_Mob::CastSpell(int spell_id, int target_id, int slot, int cast_time, int mana_cost, int item_slot) {
Lua_Safe_Call_Bool();
return self->CastSpell(spell_id, target_id, static_cast<EQEmu::spells::CastingSlot>(slot), cast_time, mana_cost, nullptr, static_cast<uint32>(item_slot));
return self->CastSpell(spell_id, target_id, static_cast<EQ::spells::CastingSlot>(slot), cast_time, mana_cost, nullptr, static_cast<uint32>(item_slot));
}
bool Lua_Mob::CastSpell(int spell_id, int target_id, int slot, int cast_time, int mana_cost, int item_slot, int timer,
int timer_duration) {
Lua_Safe_Call_Bool();
return self->CastSpell(spell_id, target_id, static_cast<EQEmu::spells::CastingSlot>(slot), cast_time, mana_cost, nullptr, static_cast<uint32>(item_slot),
return self->CastSpell(spell_id, target_id, static_cast<EQ::spells::CastingSlot>(slot), cast_time, mana_cost, nullptr, static_cast<uint32>(item_slot),
static_cast<uint32>(timer), static_cast<uint32>(timer_duration));
}
@@ -883,7 +883,7 @@ bool Lua_Mob::CastSpell(int spell_id, int target_id, int slot, int cast_time, in
Lua_Safe_Call_Bool();
int16 res = resist_adjust;
return self->CastSpell(spell_id, target_id, static_cast<EQEmu::spells::CastingSlot>(slot), cast_time, mana_cost, nullptr, static_cast<uint32>(item_slot),
return self->CastSpell(spell_id, target_id, static_cast<EQ::spells::CastingSlot>(slot), cast_time, mana_cost, nullptr, static_cast<uint32>(item_slot),
static_cast<uint32>(timer), static_cast<uint32>(timer_duration), &res);
}
@@ -894,27 +894,27 @@ bool Lua_Mob::SpellFinished(int spell_id, Lua_Mob target) {
bool Lua_Mob::SpellFinished(int spell_id, Lua_Mob target, int slot) {
Lua_Safe_Call_Bool();
return self->SpellFinished(spell_id, target, static_cast<EQEmu::spells::CastingSlot>(slot));
return self->SpellFinished(spell_id, target, static_cast<EQ::spells::CastingSlot>(slot));
}
bool Lua_Mob::SpellFinished(int spell_id, Lua_Mob target, int slot, int mana_used) {
Lua_Safe_Call_Bool();
return self->SpellFinished(spell_id, target, static_cast<EQEmu::spells::CastingSlot>(slot), mana_used);
return self->SpellFinished(spell_id, target, static_cast<EQ::spells::CastingSlot>(slot), mana_used);
}
bool Lua_Mob::SpellFinished(int spell_id, Lua_Mob target, int slot, int mana_used, uint32 inventory_slot) {
Lua_Safe_Call_Bool();
return self->SpellFinished(spell_id, target, static_cast<EQEmu::spells::CastingSlot>(slot), mana_used, inventory_slot);
return self->SpellFinished(spell_id, target, static_cast<EQ::spells::CastingSlot>(slot), mana_used, inventory_slot);
}
bool Lua_Mob::SpellFinished(int spell_id, Lua_Mob target, int slot, int mana_used, uint32 inventory_slot, int resist_adjust) {
Lua_Safe_Call_Bool();
return self->SpellFinished(spell_id, target, static_cast<EQEmu::spells::CastingSlot>(slot), mana_used, inventory_slot, resist_adjust);
return self->SpellFinished(spell_id, target, static_cast<EQ::spells::CastingSlot>(slot), mana_used, inventory_slot, resist_adjust);
}
bool Lua_Mob::SpellFinished(int spell_id, Lua_Mob target, int slot, int mana_used, uint32 inventory_slot, int resist_adjust, bool proc) {
Lua_Safe_Call_Bool();
return self->SpellFinished(spell_id, target, static_cast<EQEmu::spells::CastingSlot>(slot), mana_used, inventory_slot, resist_adjust, proc);
return self->SpellFinished(spell_id, target, static_cast<EQ::spells::CastingSlot>(slot), mana_used, inventory_slot, resist_adjust, proc);
}
void Lua_Mob::SendBeginCast(int spell_id, int cast_time) {
@@ -1349,22 +1349,22 @@ 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<EQEmu::skills::SkillType>(skill), max_damage);
self->DoSpecialAttackDamage(other, static_cast<EQ::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<EQEmu::skills::SkillType>(skill), max_damage, min_damage);
self->DoSpecialAttackDamage(other, static_cast<EQ::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<EQEmu::skills::SkillType>(skill), max_damage, min_damage, hate_override);
self->DoSpecialAttackDamage(other, static_cast<EQ::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<EQEmu::skills::SkillType>(skill), max_damage, min_damage, hate_override, reuse_time);
self->DoSpecialAttackDamage(other, static_cast<EQ::skills::SkillType>(skill), max_damage, min_damage, hate_override, reuse_time);
}
void Lua_Mob::DoThrowingAttackDmg(Lua_Mob other) {
@@ -1400,22 +1400,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<EQEmu::skills::SkillType>(skill));
self->DoMeleeSkillAttackDmg(other, weapon_damage, static_cast<EQ::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<EQEmu::skills::SkillType>(skill), chance_mod);
self->DoMeleeSkillAttackDmg(other, weapon_damage, static_cast<EQ::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<EQEmu::skills::SkillType>(skill), chance_mod, focus);
self->DoMeleeSkillAttackDmg(other, weapon_damage, static_cast<EQ::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<EQEmu::skills::SkillType>(skill), chance_mod, focus, can_riposte);
self->DoMeleeSkillAttackDmg(other, weapon_damage, static_cast<EQ::skills::SkillType>(skill), chance_mod, focus, can_riposte);
}
void Lua_Mob::DoArcheryAttackDmg(Lua_Mob other) {
@@ -1879,17 +1879,17 @@ void Lua_Mob::SetTargetable(bool on) {
void Lua_Mob::ModSkillDmgTaken(int skill, int value) {
Lua_Safe_Call_Void();
self->ModSkillDmgTaken(static_cast<EQEmu::skills::SkillType>(skill), value);
self->ModSkillDmgTaken(static_cast<EQ::skills::SkillType>(skill), value);
}
int Lua_Mob::GetModSkillDmgTaken(int skill) {
Lua_Safe_Call_Int();
return self->GetModSkillDmgTaken(static_cast<EQEmu::skills::SkillType>(skill));
return self->GetModSkillDmgTaken(static_cast<EQ::skills::SkillType>(skill));
}
int Lua_Mob::GetSkillDmgTaken(int skill) {
Lua_Safe_Call_Int();
return self->GetSkillDmgTaken(static_cast<EQEmu::skills::SkillType>(skill));
return self->GetSkillDmgTaken(static_cast<EQ::skills::SkillType>(skill));
}
int Lua_Mob::GetFcDamageAmtIncoming(Lua_Mob caster, uint32 spell_id, bool use_skill, uint16 skill)
@@ -1951,7 +1951,7 @@ int Lua_Mob::GetFlurryChance() {
int Lua_Mob::GetSkill(int skill) {
Lua_Safe_Call_Int();
return self->GetSkill(static_cast<EQEmu::skills::SkillType>(skill));
return self->GetSkill(static_cast<EQ::skills::SkillType>(skill));
}
int Lua_Mob::GetSpecialAbility(int ability) {
zone/lua_mod.cpp
+1 -1
View File
@@ -95,7 +95,7 @@ void GetDamageHitInfo(luabind::adl::object &ret, DamageHitInfo &hit) {
}
if (luabind::type(skill) == LUA_TNUMBER) {
hit.skill = (EQEmu::skills::SkillType)luabind::object_cast<int>(skill);
hit.skill = (EQ::skills::SkillType)luabind::object_cast<int>(skill);
}
}
}
zone/lua_parser.cpp
+21 -21
View File
@@ -246,7 +246,7 @@ LuaParser::~LuaParser() {
}
int LuaParser::EventNPC(QuestEventID evt, NPC* npc, Mob *init, std::string data, uint32 extra_data,
std::vector<EQEmu::Any> *extra_pointers) {
std::vector<EQ::Any> *extra_pointers) {
evt = ConvertLuaEvent(evt);
if(evt >= _LargestEventID) {
return 0;
@@ -265,7 +265,7 @@ int LuaParser::EventNPC(QuestEventID evt, NPC* npc, Mob *init, std::string data,
}
int LuaParser::EventGlobalNPC(QuestEventID evt, NPC* npc, Mob *init, std::string data, uint32 extra_data,
std::vector<EQEmu::Any> *extra_pointers) {
std::vector<EQ::Any> *extra_pointers) {
evt = ConvertLuaEvent(evt);
if(evt >= _LargestEventID) {
return 0;
@@ -283,7 +283,7 @@ int LuaParser::EventGlobalNPC(QuestEventID evt, NPC* npc, Mob *init, std::string
}
int LuaParser::_EventNPC(std::string package_name, QuestEventID evt, NPC* npc, Mob *init, std::string data, uint32 extra_data,
std::vector<EQEmu::Any> *extra_pointers, luabind::adl::object *l_func) {
std::vector<EQ::Any> *extra_pointers, luabind::adl::object *l_func) {
const char *sub_name = LuaEvents[evt];
int start = lua_gettop(L);
@@ -342,7 +342,7 @@ int LuaParser::_EventNPC(std::string package_name, QuestEventID evt, NPC* npc, M
}
int LuaParser::EventPlayer(QuestEventID evt, Client *client, std::string data, uint32 extra_data,
std::vector<EQEmu::Any> *extra_pointers) {
std::vector<EQ::Any> *extra_pointers) {
evt = ConvertLuaEvent(evt);
if(evt >= _LargestEventID) {
return 0;
@@ -360,7 +360,7 @@ int LuaParser::EventPlayer(QuestEventID evt, Client *client, std::string data, u
}
int LuaParser::EventGlobalPlayer(QuestEventID evt, Client *client, std::string data, uint32 extra_data,
std::vector<EQEmu::Any> *extra_pointers) {
std::vector<EQ::Any> *extra_pointers) {
evt = ConvertLuaEvent(evt);
if(evt >= _LargestEventID) {
return 0;
@@ -378,7 +378,7 @@ int LuaParser::EventGlobalPlayer(QuestEventID evt, Client *client, std::string d
}
int LuaParser::_EventPlayer(std::string package_name, QuestEventID evt, Client *client, std::string data, uint32 extra_data,
std::vector<EQEmu::Any> *extra_pointers, luabind::adl::object *l_func) {
std::vector<EQ::Any> *extra_pointers, luabind::adl::object *l_func) {
const char *sub_name = LuaEvents[evt];
int start = lua_gettop(L);
@@ -434,8 +434,8 @@ int LuaParser::_EventPlayer(std::string package_name, QuestEventID evt, Client *
return 0;
}
int LuaParser::EventItem(QuestEventID evt, Client *client, EQEmu::ItemInstance *item, Mob *mob, std::string data, uint32 extra_data,
std::vector<EQEmu::Any> *extra_pointers) {
int LuaParser::EventItem(QuestEventID evt, Client *client, EQ::ItemInstance *item, Mob *mob, std::string data, uint32 extra_data,
std::vector<EQ::Any> *extra_pointers) {
evt = ConvertLuaEvent(evt);
if(evt >= _LargestEventID) {
return 0;
@@ -454,8 +454,8 @@ int LuaParser::EventItem(QuestEventID evt, Client *client, EQEmu::ItemInstance *
return _EventItem(package_name, evt, client, item, mob, data, extra_data, extra_pointers);
}
int LuaParser::_EventItem(std::string package_name, QuestEventID evt, Client *client, EQEmu::ItemInstance *item, Mob *mob,
std::string data, uint32 extra_data, std::vector<EQEmu::Any> *extra_pointers, luabind::adl::object *l_func) {
int LuaParser::_EventItem(std::string package_name, QuestEventID evt, Client *client, EQ::ItemInstance *item, Mob *mob,
std::string data, uint32 extra_data, std::vector<EQ::Any> *extra_pointers, luabind::adl::object *l_func) {
const char *sub_name = LuaEvents[evt];
int start = lua_gettop(L);
@@ -518,7 +518,7 @@ int LuaParser::_EventItem(std::string package_name, QuestEventID evt, Client *cl
}
int LuaParser::EventSpell(QuestEventID evt, NPC* npc, Client *client, uint32 spell_id, uint32 extra_data,
std::vector<EQEmu::Any> *extra_pointers) {
std::vector<EQ::Any> *extra_pointers) {
evt = ConvertLuaEvent(evt);
if(evt >= _LargestEventID) {
return 0;
@@ -534,7 +534,7 @@ int LuaParser::EventSpell(QuestEventID evt, NPC* npc, Client *client, uint32 spe
}
int LuaParser::_EventSpell(std::string package_name, QuestEventID evt, NPC* npc, Client *client, uint32 spell_id, uint32 extra_data,
std::vector<EQEmu::Any> *extra_pointers, luabind::adl::object *l_func) {
std::vector<EQ::Any> *extra_pointers, luabind::adl::object *l_func) {
const char *sub_name = LuaEvents[evt];
int start = lua_gettop(L);
@@ -598,7 +598,7 @@ int LuaParser::_EventSpell(std::string package_name, QuestEventID evt, NPC* npc,
return 0;
}
int LuaParser::EventEncounter(QuestEventID evt, std::string encounter_name, std::string data, uint32 extra_data, std::vector<EQEmu::Any> *extra_pointers) {
int LuaParser::EventEncounter(QuestEventID evt, std::string encounter_name, std::string data, uint32 extra_data, std::vector<EQ::Any> *extra_pointers) {
evt = ConvertLuaEvent(evt);
if(evt >= _LargestEventID) {
return 0;
@@ -614,7 +614,7 @@ int LuaParser::EventEncounter(QuestEventID evt, std::string encounter_name, std:
}
int LuaParser::_EventEncounter(std::string package_name, QuestEventID evt, std::string encounter_name, std::string data, uint32 extra_data,
std::vector<EQEmu::Any> *extra_pointers) {
std::vector<EQ::Any> *extra_pointers) {
const char *sub_name = LuaEvents[evt];
int start = lua_gettop(L);
@@ -718,7 +718,7 @@ bool LuaParser::SpellHasQuestSub(uint32 spell_id, QuestEventID evt) {
return HasFunction(subname, package_name);
}
bool LuaParser::ItemHasQuestSub(EQEmu::ItemInstance *itm, QuestEventID evt) {
bool LuaParser::ItemHasQuestSub(EQ::ItemInstance *itm, QuestEventID evt) {
if (itm == nullptr) {
return false;
}
@@ -764,7 +764,7 @@ void LuaParser::LoadGlobalPlayerScript(std::string filename) {
LoadScript(filename, "global_player");
}
void LuaParser::LoadItemScript(std::string filename, EQEmu::ItemInstance *item) {
void LuaParser::LoadItemScript(std::string filename, EQ::ItemInstance *item) {
if (item == nullptr)
return;
std::string package_name = "item_";
@@ -1118,7 +1118,7 @@ void LuaParser::MapFunctions(lua_State *L) {
}
int LuaParser::DispatchEventNPC(QuestEventID evt, NPC* npc, Mob *init, std::string data, uint32 extra_data,
std::vector<EQEmu::Any> *extra_pointers) {
std::vector<EQ::Any> *extra_pointers) {
evt = ConvertLuaEvent(evt);
if(evt >= _LargestEventID) {
return 0;
@@ -1164,7 +1164,7 @@ int LuaParser::DispatchEventNPC(QuestEventID evt, NPC* npc, Mob *init, std::stri
}
int LuaParser::DispatchEventPlayer(QuestEventID evt, Client *client, std::string data, uint32 extra_data,
std::vector<EQEmu::Any> *extra_pointers) {
std::vector<EQ::Any> *extra_pointers) {
evt = ConvertLuaEvent(evt);
if(evt >= _LargestEventID) {
return 0;
@@ -1192,8 +1192,8 @@ int LuaParser::DispatchEventPlayer(QuestEventID evt, Client *client, std::string
return ret;
}
int LuaParser::DispatchEventItem(QuestEventID evt, Client *client, EQEmu::ItemInstance *item, Mob *mob, std::string data, uint32 extra_data,
std::vector<EQEmu::Any> *extra_pointers) {
int LuaParser::DispatchEventItem(QuestEventID evt, Client *client, EQ::ItemInstance *item, Mob *mob, std::string data, uint32 extra_data,
std::vector<EQ::Any> *extra_pointers) {
evt = ConvertLuaEvent(evt);
if(evt >= _LargestEventID) {
return 0;
@@ -1239,7 +1239,7 @@ int LuaParser::DispatchEventItem(QuestEventID evt, Client *client, EQEmu::ItemIn
}
int LuaParser::DispatchEventSpell(QuestEventID evt, NPC* npc, Client *client, uint32 spell_id, uint32 extra_data,
std::vector<EQEmu::Any> *extra_pointers) {
std::vector<EQ::Any> *extra_pointers) {
evt = ConvertLuaEvent(evt);
if(evt >= _LargestEventID) {
return 0;
zone/lua_parser.h
+22 -22
View File
@@ -18,7 +18,7 @@ struct lua_State;
class Client;
class NPC;
namespace EQEmu
namespace EQ
{
class ItemInstance;
}
@@ -37,33 +37,33 @@ public:
~LuaParser();
virtual int EventNPC(QuestEventID evt, NPC* npc, Mob *init, std::string data, uint32 extra_data,
std::vector<EQEmu::Any> *extra_pointers);
std::vector<EQ::Any> *extra_pointers);
virtual int EventGlobalNPC(QuestEventID evt, NPC* npc, Mob *init, std::string data, uint32 extra_data,
std::vector<EQEmu::Any> *extra_pointers);
std::vector<EQ::Any> *extra_pointers);
virtual int EventPlayer(QuestEventID evt, Client *client, std::string data, uint32 extra_data,
std::vector<EQEmu::Any> *extra_pointers);
std::vector<EQ::Any> *extra_pointers);
virtual int EventGlobalPlayer(QuestEventID evt, Client *client, std::string data, uint32 extra_data,
std::vector<EQEmu::Any> *extra_pointers);
virtual int EventItem(QuestEventID evt, Client *client, EQEmu::ItemInstance *item, Mob *mob, std::string data, uint32 extra_data,
std::vector<EQEmu::Any> *extra_pointers);
std::vector<EQ::Any> *extra_pointers);
virtual int EventItem(QuestEventID evt, Client *client, EQ::ItemInstance *item, Mob *mob, std::string data, uint32 extra_data,
std::vector<EQ::Any> *extra_pointers);
virtual int EventSpell(QuestEventID evt, NPC* npc, Client *client, uint32 spell_id, uint32 extra_data,
std::vector<EQEmu::Any> *extra_pointers);
std::vector<EQ::Any> *extra_pointers);
virtual int EventEncounter(QuestEventID evt, std::string encounter_name, std::string data, uint32 extra_data,
std::vector<EQEmu::Any> *extra_pointers);
std::vector<EQ::Any> *extra_pointers);
virtual bool HasQuestSub(uint32 npc_id, QuestEventID evt);
virtual bool HasGlobalQuestSub(QuestEventID evt);
virtual bool PlayerHasQuestSub(QuestEventID evt);
virtual bool GlobalPlayerHasQuestSub(QuestEventID evt);
virtual bool SpellHasQuestSub(uint32 spell_id, QuestEventID evt);
virtual bool ItemHasQuestSub(EQEmu::ItemInstance *itm, QuestEventID evt);
virtual bool ItemHasQuestSub(EQ::ItemInstance *itm, QuestEventID evt);
virtual bool EncounterHasQuestSub(std::string encounter_name, QuestEventID evt);
virtual void LoadNPCScript(std::string filename, int npc_id);
virtual void LoadGlobalNPCScript(std::string filename);
virtual void LoadPlayerScript(std::string filename);
virtual void LoadGlobalPlayerScript(std::string filename);
virtual void LoadItemScript(std::string filename, EQEmu::ItemInstance *item);
virtual void LoadItemScript(std::string filename, EQ::ItemInstance *item);
virtual void LoadSpellScript(std::string filename, uint32 spell_id);
virtual void LoadEncounterScript(std::string filename, std::string encounter_name);
@@ -74,13 +74,13 @@ public:
virtual uint32 GetIdentifier() { return 0xb0712acc; }
virtual int DispatchEventNPC(QuestEventID evt, NPC* npc, Mob *init, std::string data, uint32 extra_data,
std::vector<EQEmu::Any> *extra_pointers);
std::vector<EQ::Any> *extra_pointers);
virtual int DispatchEventPlayer(QuestEventID evt, Client *client, std::string data, uint32 extra_data,
std::vector<EQEmu::Any> *extra_pointers);
virtual int DispatchEventItem(QuestEventID evt, Client *client, EQEmu::ItemInstance *item, Mob *mob, std::string data, uint32 extra_data,
std::vector<EQEmu::Any> *extra_pointers);
std::vector<EQ::Any> *extra_pointers);
virtual int DispatchEventItem(QuestEventID evt, Client *client, EQ::ItemInstance *item, Mob *mob, std::string data, uint32 extra_data,
std::vector<EQ::Any> *extra_pointers);
virtual int DispatchEventSpell(QuestEventID evt, NPC* npc, Client *client, uint32 spell_id, uint32 extra_data,
std::vector<EQEmu::Any> *extra_pointers);
std::vector<EQ::Any> *extra_pointers);
static LuaParser* Instance() {
static LuaParser inst;
@@ -106,15 +106,15 @@ private:
LuaParser& operator=(const LuaParser&);
int _EventNPC(std::string package_name, QuestEventID evt, NPC* npc, Mob *init, std::string data, uint32 extra_data,
std::vector<EQEmu::Any> *extra_pointers, luabind::adl::object *l_func = nullptr);
std::vector<EQ::Any> *extra_pointers, luabind::adl::object *l_func = nullptr);
int _EventPlayer(std::string package_name, QuestEventID evt, Client *client, std::string data, uint32 extra_data,
std::vector<EQEmu::Any> *extra_pointers, luabind::adl::object *l_func = nullptr);
int _EventItem(std::string package_name, QuestEventID evt, Client *client, EQEmu::ItemInstance *item, Mob *mob, std::string data,
uint32 extra_data, std::vector<EQEmu::Any> *extra_pointers, luabind::adl::object *l_func = nullptr);
std::vector<EQ::Any> *extra_pointers, luabind::adl::object *l_func = nullptr);
int _EventItem(std::string package_name, QuestEventID evt, Client *client, EQ::ItemInstance *item, Mob *mob, std::string data,
uint32 extra_data, std::vector<EQ::Any> *extra_pointers, luabind::adl::object *l_func = nullptr);
int _EventSpell(std::string package_name, QuestEventID evt, NPC* npc, Client *client, uint32 spell_id, uint32 extra_data,
std::vector<EQEmu::Any> *extra_pointers, luabind::adl::object *l_func = nullptr);
std::vector<EQ::Any> *extra_pointers, luabind::adl::object *l_func = nullptr);
int _EventEncounter(std::string package_name, QuestEventID evt, std::string encounter_name, std::string data, uint32 extra_data,
std::vector<EQEmu::Any> *extra_pointers);
std::vector<EQ::Any> *extra_pointers);
void LoadScript(std::string filename, std::string package_name);
void MapFunctions(lua_State *L);
zone/lua_parser_events.cpp
+99 -99
View File
@@ -28,7 +28,7 @@
//NPC
void handle_npc_event_say(QuestInterface *parse, lua_State* L, NPC* npc, Mob *init, std::string data, uint32 extra_data,
std::vector<EQEmu::Any> *extra_pointers) {
std::vector<EQ::Any> *extra_pointers) {
npc->DoQuestPause(init);
Lua_Client l_client(reinterpret_cast<Client*>(init));
@@ -44,7 +44,7 @@ void handle_npc_event_say(QuestInterface *parse, lua_State* L, NPC* npc, Mob *in
}
void handle_npc_event_trade(QuestInterface *parse, lua_State* L, NPC* npc, Mob *init, std::string data, uint32 extra_data,
std::vector<EQEmu::Any> *extra_pointers) {
std::vector<EQ::Any> *extra_pointers) {
Lua_Client l_client(reinterpret_cast<Client*>(init));
luabind::adl::object l_client_o = luabind::adl::object(L, l_client);
l_client_o.push(L);
@@ -58,7 +58,7 @@ void handle_npc_event_trade(QuestInterface *parse, lua_State* L, NPC* npc, Mob *
size_t sz = extra_pointers->size();
for(size_t i = 0; i < sz; ++i) {
std::string prefix = "item" + std::to_string(i + 1);
EQEmu::ItemInstance *inst = EQEmu::any_cast<EQEmu::ItemInstance*>(extra_pointers->at(i));
EQ::ItemInstance *inst = EQ::any_cast<EQ::ItemInstance*>(extra_pointers->at(i));
Lua_ItemInst l_inst = inst;
luabind::adl::object l_inst_o = luabind::adl::object(L, l_inst);
@@ -83,7 +83,7 @@ void handle_npc_event_trade(QuestInterface *parse, lua_State* L, NPC* npc, Mob *
}
void handle_npc_event_hp(QuestInterface *parse, lua_State* L, NPC* npc, Mob *init, std::string data, uint32 extra_data,
std::vector<EQEmu::Any> *extra_pointers) {
std::vector<EQ::Any> *extra_pointers) {
if(extra_data == 1) {
lua_pushinteger(L, -1);
lua_setfield(L, -2, "hp_event");
@@ -100,7 +100,7 @@ void handle_npc_event_hp(QuestInterface *parse, lua_State* L, NPC* npc, Mob *ini
}
void handle_npc_single_mob(QuestInterface *parse, lua_State* L, NPC* npc, Mob *init, std::string data, uint32 extra_data,
std::vector<EQEmu::Any> *extra_pointers) {
std::vector<EQ::Any> *extra_pointers) {
Lua_Mob l_mob(init);
luabind::adl::object l_mob_o = luabind::adl::object(L, l_mob);
l_mob_o.push(L);
@@ -108,7 +108,7 @@ void handle_npc_single_mob(QuestInterface *parse, lua_State* L, NPC* npc, Mob *i
}
void handle_npc_single_client(QuestInterface *parse, lua_State* L, NPC* npc, Mob *init, std::string data, uint32 extra_data,
std::vector<EQEmu::Any> *extra_pointers) {
std::vector<EQ::Any> *extra_pointers) {
Lua_Client l_client(reinterpret_cast<Client*>(init));
luabind::adl::object l_client_o = luabind::adl::object(L, l_client);
l_client_o.push(L);
@@ -116,7 +116,7 @@ void handle_npc_single_client(QuestInterface *parse, lua_State* L, NPC* npc, Mob
}
void handle_npc_single_npc(QuestInterface *parse, lua_State* L, NPC* npc, Mob *init, std::string data, uint32 extra_data,
std::vector<EQEmu::Any> *extra_pointers) {
std::vector<EQ::Any> *extra_pointers) {
Lua_NPC l_npc(reinterpret_cast<NPC*>(init));
luabind::adl::object l_npc_o = luabind::adl::object(L, l_npc);
l_npc_o.push(L);
@@ -124,7 +124,7 @@ void handle_npc_single_npc(QuestInterface *parse, lua_State* L, NPC* npc, Mob *i
}
void handle_npc_task_accepted(QuestInterface *parse, lua_State* L, NPC* npc, Mob *init, std::string data, uint32 extra_data,
std::vector<EQEmu::Any> *extra_pointers) {
std::vector<EQ::Any> *extra_pointers) {
Lua_Client l_client(reinterpret_cast<Client*>(init));
luabind::adl::object l_client_o = luabind::adl::object(L, l_client);
l_client_o.push(L);
@@ -135,7 +135,7 @@ void handle_npc_task_accepted(QuestInterface *parse, lua_State* L, NPC* npc, Mob
}
void handle_npc_popup(QuestInterface *parse, lua_State* L, NPC* npc, Mob *init, std::string data, uint32 extra_data,
std::vector<EQEmu::Any> *extra_pointers) {
std::vector<EQ::Any> *extra_pointers) {
Lua_Mob l_mob(init);
luabind::adl::object l_mob_o = luabind::adl::object(L, l_mob);
l_mob_o.push(L);
@@ -146,7 +146,7 @@ void handle_npc_popup(QuestInterface *parse, lua_State* L, NPC* npc, Mob *init,
}
void handle_npc_waypoint(QuestInterface *parse, lua_State* L, NPC* npc, Mob *init, std::string data, uint32 extra_data,
std::vector<EQEmu::Any> *extra_pointers) {
std::vector<EQ::Any> *extra_pointers) {
Lua_Mob l_mob(init);
luabind::adl::object l_mob_o = luabind::adl::object(L, l_mob);
l_mob_o.push(L);
@@ -157,7 +157,7 @@ void handle_npc_waypoint(QuestInterface *parse, lua_State* L, NPC* npc, Mob *ini
}
void handle_npc_hate(QuestInterface *parse, lua_State* L, NPC* npc, Mob *init, std::string data, uint32 extra_data,
std::vector<EQEmu::Any> *extra_pointers) {
std::vector<EQ::Any> *extra_pointers) {
Lua_Mob l_mob(init);
luabind::adl::object l_mob_o = luabind::adl::object(L, l_mob);
l_mob_o.push(L);
@@ -169,19 +169,19 @@ void handle_npc_hate(QuestInterface *parse, lua_State* L, NPC* npc, Mob *init, s
void handle_npc_signal(QuestInterface *parse, lua_State* L, NPC* npc, Mob *init, std::string data, uint32 extra_data,
std::vector<EQEmu::Any> *extra_pointers) {
std::vector<EQ::Any> *extra_pointers) {
lua_pushinteger(L, std::stoi(data));
lua_setfield(L, -2, "signal");
}
void handle_npc_timer(QuestInterface *parse, lua_State* L, NPC* npc, Mob *init, std::string data, uint32 extra_data,
std::vector<EQEmu::Any> *extra_pointers) {
std::vector<EQ::Any> *extra_pointers) {
lua_pushstring(L, data.c_str());
lua_setfield(L, -2, "timer");
}
void handle_npc_death(QuestInterface *parse, lua_State* L, NPC* npc, Mob *init, std::string data, uint32 extra_data,
std::vector<EQEmu::Any> *extra_pointers) {
std::vector<EQ::Any> *extra_pointers) {
Lua_Mob l_mob(init);
luabind::adl::object l_mob_o = luabind::adl::object(L, l_mob);
l_mob_o.push(L);
@@ -209,7 +209,7 @@ void handle_npc_death(QuestInterface *parse, lua_State* L, NPC* npc, Mob *init,
}
void handle_npc_cast(QuestInterface *parse, lua_State* L, NPC* npc, Mob *init, std::string data, uint32 extra_data,
std::vector<EQEmu::Any> *extra_pointers) {
std::vector<EQ::Any> *extra_pointers) {
int spell_id = std::stoi(data);
if(IsValidSpell(spell_id)) {
Lua_Spell l_spell(&spells[spell_id]);
@@ -225,21 +225,21 @@ void handle_npc_cast(QuestInterface *parse, lua_State* L, NPC* npc, Mob *init, s
}
void handle_npc_area(QuestInterface *parse, lua_State* L, NPC* npc, Mob *init, std::string data, uint32 extra_data,
std::vector<EQEmu::Any> *extra_pointers) {
lua_pushinteger(L, *EQEmu::any_cast<int*>(extra_pointers->at(0)));
std::vector<EQ::Any> *extra_pointers) {
lua_pushinteger(L, *EQ::any_cast<int*>(extra_pointers->at(0)));
lua_setfield(L, -2, "area_id");
lua_pushinteger(L, *EQEmu::any_cast<int*>(extra_pointers->at(1)));
lua_pushinteger(L, *EQ::any_cast<int*>(extra_pointers->at(1)));
lua_setfield(L, -2, "area_type");
}
void handle_npc_null(QuestInterface *parse, lua_State* L, NPC* npc, Mob *init, std::string data, uint32 extra_data,
std::vector<EQEmu::Any> *extra_pointers) {
std::vector<EQ::Any> *extra_pointers) {
}
//Player
void handle_player_say(QuestInterface *parse, lua_State* L, Client* client, std::string data, uint32 extra_data,
std::vector<EQEmu::Any> *extra_pointers) {
std::vector<EQ::Any> *extra_pointers) {
lua_pushstring(L, data.c_str());
lua_setfield(L, -2, "message");
@@ -248,7 +248,7 @@ void handle_player_say(QuestInterface *parse, lua_State* L, Client* client, std:
}
void handle_player_environmental_damage(QuestInterface *parse, lua_State* L, Client* client, std::string data, uint32 extra_data,
std::vector<EQEmu::Any> *extra_pointers){
std::vector<EQ::Any> *extra_pointers){
Seperator sep(data.c_str());
lua_pushinteger(L, std::stoi(sep.arg[0]));
lua_setfield(L, -2, "env_damage");
@@ -261,7 +261,7 @@ void handle_player_environmental_damage(QuestInterface *parse, lua_State* L, Cli
}
void handle_player_death(QuestInterface *parse, lua_State* L, Client* client, std::string data, uint32 extra_data,
std::vector<EQEmu::Any> *extra_pointers) {
std::vector<EQ::Any> *extra_pointers) {
Seperator sep(data.c_str());
Mob *o = entity_list.GetMobID(std::stoi(sep.arg[0]));
@@ -291,14 +291,14 @@ void handle_player_death(QuestInterface *parse, lua_State* L, Client* client, st
}
void handle_player_timer(QuestInterface *parse, lua_State* L, Client* client, std::string data, uint32 extra_data,
std::vector<EQEmu::Any> *extra_pointers) {
std::vector<EQ::Any> *extra_pointers) {
lua_pushstring(L, data.c_str());
lua_setfield(L, -2, "timer");
}
void handle_player_discover_item(QuestInterface *parse, lua_State* L, Client* client, std::string data, uint32 extra_data,
std::vector<EQEmu::Any> *extra_pointers) {
const EQEmu::ItemData *item = database.GetItem(extra_data);
std::vector<EQ::Any> *extra_pointers) {
const EQ::ItemData *item = database.GetItem(extra_data);
if(item) {
Lua_Item l_item(item);
luabind::adl::object l_item_o = luabind::adl::object(L, l_item);
@@ -313,51 +313,51 @@ void handle_player_discover_item(QuestInterface *parse, lua_State* L, Client* cl
}
void handle_player_fish_forage_success(QuestInterface *parse, lua_State* L, Client* client, std::string data, uint32 extra_data,
std::vector<EQEmu::Any> *extra_pointers) {
Lua_ItemInst l_item(EQEmu::any_cast<EQEmu::ItemInstance*>(extra_pointers->at(0)));
std::vector<EQ::Any> *extra_pointers) {
Lua_ItemInst l_item(EQ::any_cast<EQ::ItemInstance*>(extra_pointers->at(0)));
luabind::adl::object l_item_o = luabind::adl::object(L, l_item);
l_item_o.push(L);
lua_setfield(L, -2, "item");
}
void handle_player_click_object(QuestInterface *parse, lua_State* L, Client* client, std::string data, uint32 extra_data,
std::vector<EQEmu::Any> *extra_pointers) {
Lua_Object l_object(EQEmu::any_cast<Object*>(extra_pointers->at(0)));
std::vector<EQ::Any> *extra_pointers) {
Lua_Object l_object(EQ::any_cast<Object*>(extra_pointers->at(0)));
luabind::adl::object l_object_o = luabind::adl::object(L, l_object);
l_object_o.push(L);
lua_setfield(L, -2, "object");
}
void handle_player_click_door(QuestInterface *parse, lua_State* L, Client* client, std::string data, uint32 extra_data,
std::vector<EQEmu::Any> *extra_pointers) {
Lua_Door l_door(EQEmu::any_cast<Doors*>(extra_pointers->at(0)));
std::vector<EQ::Any> *extra_pointers) {
Lua_Door l_door(EQ::any_cast<Doors*>(extra_pointers->at(0)));
luabind::adl::object l_door_o = luabind::adl::object(L, l_door);
l_door_o.push(L);
lua_setfield(L, -2, "door");
}
void handle_player_signal(QuestInterface *parse, lua_State* L, Client* client, std::string data, uint32 extra_data,
std::vector<EQEmu::Any> *extra_pointers) {
std::vector<EQ::Any> *extra_pointers) {
lua_pushinteger(L, std::stoi(data));
lua_setfield(L, -2, "signal");
}
void handle_player_popup_response(QuestInterface *parse, lua_State* L, Client* client, std::string data, uint32 extra_data,
std::vector<EQEmu::Any> *extra_pointers) {
std::vector<EQ::Any> *extra_pointers) {
lua_pushinteger(L, std::stoi(data));
lua_setfield(L, -2, "popup_id");
}
void handle_player_pick_up(QuestInterface *parse, lua_State* L, Client* client, std::string data, uint32 extra_data,
std::vector<EQEmu::Any> *extra_pointers) {
Lua_ItemInst l_item(EQEmu::any_cast<EQEmu::ItemInstance*>(extra_pointers->at(0)));
std::vector<EQ::Any> *extra_pointers) {
Lua_ItemInst l_item(EQ::any_cast<EQ::ItemInstance*>(extra_pointers->at(0)));
luabind::adl::object l_item_o = luabind::adl::object(L, l_item);
l_item_o.push(L);
lua_setfield(L, -2, "item");
}
void handle_player_cast(QuestInterface *parse, lua_State* L, Client* client, std::string data, uint32 extra_data,
std::vector<EQEmu::Any> *extra_pointers) {
std::vector<EQ::Any> *extra_pointers) {
int spell_id = std::stoi(data);
if(IsValidSpell(spell_id)) {
Lua_Spell l_spell(&spells[spell_id]);
@@ -373,48 +373,48 @@ void handle_player_cast(QuestInterface *parse, lua_State* L, Client* client, std
}
void handle_player_task_fail(QuestInterface *parse, lua_State* L, Client* client, std::string data, uint32 extra_data,
std::vector<EQEmu::Any> *extra_pointers) {
std::vector<EQ::Any> *extra_pointers) {
lua_pushinteger(L, std::stoi(data));
lua_setfield(L, -2, "task_id");
}
void handle_player_zone(QuestInterface *parse, lua_State* L, Client* client, std::string data, uint32 extra_data,
std::vector<EQEmu::Any> *extra_pointers) {
std::vector<EQ::Any> *extra_pointers) {
lua_pushinteger(L, std::stoi(data));
lua_setfield(L, -2, "zone_id");
}
void handle_player_duel_win(QuestInterface *parse, lua_State* L, Client* client, std::string data, uint32 extra_data,
std::vector<EQEmu::Any> *extra_pointers) {
Lua_Client l_client(EQEmu::any_cast<Client*>(extra_pointers->at(1)));
std::vector<EQ::Any> *extra_pointers) {
Lua_Client l_client(EQ::any_cast<Client*>(extra_pointers->at(1)));
luabind::adl::object l_client_o = luabind::adl::object(L, l_client);
l_client_o.push(L);
lua_setfield(L, -2, "other");
}
void handle_player_duel_loss(QuestInterface *parse, lua_State* L, Client* client, std::string data, uint32 extra_data,
std::vector<EQEmu::Any> *extra_pointers) {
Lua_Client l_client(EQEmu::any_cast<Client*>(extra_pointers->at(0)));
std::vector<EQ::Any> *extra_pointers) {
Lua_Client l_client(EQ::any_cast<Client*>(extra_pointers->at(0)));
luabind::adl::object l_client_o = luabind::adl::object(L, l_client);
l_client_o.push(L);
lua_setfield(L, -2, "other");
}
void handle_player_loot(QuestInterface *parse, lua_State* L, Client* client, std::string data, uint32 extra_data,
std::vector<EQEmu::Any> *extra_pointers) {
Lua_ItemInst l_item(EQEmu::any_cast<EQEmu::ItemInstance*>(extra_pointers->at(0)));
std::vector<EQ::Any> *extra_pointers) {
Lua_ItemInst l_item(EQ::any_cast<EQ::ItemInstance*>(extra_pointers->at(0)));
luabind::adl::object l_item_o = luabind::adl::object(L, l_item);
l_item_o.push(L);
lua_setfield(L, -2, "item");
Lua_Corpse l_corpse(EQEmu::any_cast<Corpse*>(extra_pointers->at(1)));
Lua_Corpse l_corpse(EQ::any_cast<Corpse*>(extra_pointers->at(1)));
luabind::adl::object l_corpse_o = luabind::adl::object(L, l_corpse);
l_corpse_o.push(L);
lua_setfield(L, -2, "corpse");
}
void handle_player_task_stage_complete(QuestInterface *parse, lua_State* L, Client* client, std::string data, uint32 extra_data,
std::vector<EQEmu::Any> *extra_pointers) {
std::vector<EQ::Any> *extra_pointers) {
Seperator sep(data.c_str());
lua_pushinteger(L, std::stoi(sep.arg[0]));
lua_setfield(L, -2, "task_id");
@@ -424,7 +424,7 @@ void handle_player_task_stage_complete(QuestInterface *parse, lua_State* L, Clie
}
void handle_player_task_update(QuestInterface *parse, lua_State* L, Client* client, std::string data, uint32 extra_data,
std::vector<EQEmu::Any> *extra_pointers) {
std::vector<EQ::Any> *extra_pointers) {
Seperator sep(data.c_str());
lua_pushinteger(L, std::stoi(sep.arg[0]));
lua_setfield(L, -2, "count");
@@ -437,7 +437,7 @@ void handle_player_task_update(QuestInterface *parse, lua_State* L, Client* clie
}
void handle_player_command(QuestInterface *parse, lua_State* L, Client* client, std::string data, uint32 extra_data,
std::vector<EQEmu::Any> *extra_pointers) {
std::vector<EQ::Any> *extra_pointers) {
Seperator sep(data.c_str(), ' ', 10, 100, true);
std::string command(sep.arg[0] + 1);
lua_pushstring(L, command.c_str());
@@ -456,7 +456,7 @@ void handle_player_command(QuestInterface *parse, lua_State* L, Client* client,
}
void handle_player_combine(QuestInterface *parse, lua_State* L, Client* client, std::string data, uint32 extra_data,
std::vector<EQEmu::Any> *extra_pointers) {
std::vector<EQ::Any> *extra_pointers) {
lua_pushinteger(L, extra_data);
lua_setfield(L, -2, "recipe_id");
@@ -465,24 +465,24 @@ void handle_player_combine(QuestInterface *parse, lua_State* L, Client* client,
}
void handle_player_feign(QuestInterface *parse, lua_State* L, Client* client, std::string data, uint32 extra_data,
std::vector<EQEmu::Any> *extra_pointers) {
Lua_NPC l_npc(EQEmu::any_cast<NPC*>(extra_pointers->at(0)));
std::vector<EQ::Any> *extra_pointers) {
Lua_NPC l_npc(EQ::any_cast<NPC*>(extra_pointers->at(0)));
luabind::adl::object l_npc_o = luabind::adl::object(L, l_npc);
l_npc_o.push(L);
lua_setfield(L, -2, "other");
}
void handle_player_area(QuestInterface *parse, lua_State* L, Client* client, std::string data, uint32 extra_data,
std::vector<EQEmu::Any> *extra_pointers) {
lua_pushinteger(L, *EQEmu::any_cast<int*>(extra_pointers->at(0)));
std::vector<EQ::Any> *extra_pointers) {
lua_pushinteger(L, *EQ::any_cast<int*>(extra_pointers->at(0)));
lua_setfield(L, -2, "area_id");
lua_pushinteger(L, *EQEmu::any_cast<int*>(extra_pointers->at(1)));
lua_pushinteger(L, *EQ::any_cast<int*>(extra_pointers->at(1)));
lua_setfield(L, -2, "area_type");
}
void handle_player_respawn(QuestInterface *parse, lua_State* L, Client* client, std::string data, uint32 extra_data,
std::vector<EQEmu::Any> *extra_pointers) {
std::vector<EQ::Any> *extra_pointers) {
lua_pushinteger(L, std::stoi(data));
lua_setfield(L, -2, "option");
@@ -491,8 +491,8 @@ void handle_player_respawn(QuestInterface *parse, lua_State* L, Client* client,
}
void handle_player_packet(QuestInterface *parse, lua_State* L, Client* client, std::string data, uint32 extra_data,
std::vector<EQEmu::Any> *extra_pointers) {
Lua_Packet l_packet(EQEmu::any_cast<EQApplicationPacket*>(extra_pointers->at(0)));
std::vector<EQ::Any> *extra_pointers) {
Lua_Packet l_packet(EQ::any_cast<EQApplicationPacket*>(extra_pointers->at(0)));
luabind::adl::object l_packet_o = luabind::adl::object(L, l_packet);
l_packet_o.push(L);
lua_setfield(L, -2, "packet");
@@ -502,10 +502,10 @@ void handle_player_packet(QuestInterface *parse, lua_State* L, Client* client, s
}
void handle_player_null(QuestInterface *parse, lua_State* L, Client* client, std::string data, uint32 extra_data,
std::vector<EQEmu::Any> *extra_pointers) {
std::vector<EQ::Any> *extra_pointers) {
}
void handle_player_use_skill(QuestInterface *parse, lua_State* L, Client* client, std::string data, uint32 extra_data, std::vector<EQEmu::Any> *extra_pointers) {
void handle_player_use_skill(QuestInterface *parse, lua_State* L, Client* client, std::string data, uint32 extra_data, std::vector<EQ::Any> *extra_pointers) {
Seperator sep(data.c_str());
lua_pushinteger(L, std::stoi(sep.arg[0]));
lua_setfield(L, -2, "skill_id");
@@ -515,7 +515,7 @@ void handle_player_use_skill(QuestInterface *parse, lua_State* L, Client* client
}
void handle_player_combine_validate(QuestInterface* parse, lua_State* L, Client* client, std::string data, uint32 extra_data,
std::vector<EQEmu::Any>* extra_pointers) {
std::vector<EQ::Any>* extra_pointers) {
Seperator sep(data.c_str());
lua_pushinteger(L, extra_data);
lua_setfield(L, -2, "recipe_id");
@@ -540,7 +540,7 @@ void handle_player_combine_validate(QuestInterface* parse, lua_State* L, Client*
}
void handle_player_bot_command(QuestInterface* parse, lua_State* L, Client* client, std::string data, uint32 extra_data,
std::vector<EQEmu::Any>* extra_pointers) {
std::vector<EQ::Any>* extra_pointers) {
Seperator sep(data.c_str(), ' ', 10, 100, true);
std::string bot_command(sep.arg[0] + 1);
lua_pushstring(L, bot_command.c_str());
@@ -559,20 +559,20 @@ void handle_player_bot_command(QuestInterface* parse, lua_State* L, Client* clie
}
//Item
void handle_item_click(QuestInterface *parse, lua_State* L, Client* client, EQEmu::ItemInstance* item, Mob *mob, std::string data, uint32 extra_data,
std::vector<EQEmu::Any> *extra_pointers) {
void handle_item_click(QuestInterface *parse, lua_State* L, Client* client, EQ::ItemInstance* item, Mob *mob, std::string data, uint32 extra_data,
std::vector<EQ::Any> *extra_pointers) {
lua_pushinteger(L, extra_data);
lua_setfield(L, -2, "slot_id");
}
void handle_item_timer(QuestInterface *parse, lua_State* L, Client* client, EQEmu::ItemInstance* item, Mob *mob, std::string data, uint32 extra_data,
std::vector<EQEmu::Any> *extra_pointers) {
void handle_item_timer(QuestInterface *parse, lua_State* L, Client* client, EQ::ItemInstance* item, Mob *mob, std::string data, uint32 extra_data,
std::vector<EQ::Any> *extra_pointers) {
lua_pushstring(L, data.c_str());
lua_setfield(L, -2, "timer");
}
void handle_item_proc(QuestInterface *parse, lua_State* L, Client* client, EQEmu::ItemInstance* item, Mob *mob, std::string data, uint32 extra_data,
std::vector<EQEmu::Any> *extra_pointers) {
void handle_item_proc(QuestInterface *parse, lua_State* L, Client* client, EQ::ItemInstance* item, Mob *mob, std::string data, uint32 extra_data,
std::vector<EQ::Any> *extra_pointers) {
Lua_Mob l_mob(mob);
luabind::adl::object l_mob_o = luabind::adl::object(L, l_mob);
@@ -592,8 +592,8 @@ void handle_item_proc(QuestInterface *parse, lua_State* L, Client* client, EQEmu
}
}
void handle_item_loot(QuestInterface *parse, lua_State* L, Client* client, EQEmu::ItemInstance* item, Mob *mob, std::string data, uint32 extra_data,
std::vector<EQEmu::Any> *extra_pointers) {
void handle_item_loot(QuestInterface *parse, lua_State* L, Client* client, EQ::ItemInstance* item, Mob *mob, std::string data, uint32 extra_data,
std::vector<EQ::Any> *extra_pointers) {
if(mob && mob->IsCorpse()) {
Lua_Corpse l_corpse(mob->CastToCorpse());
luabind::adl::object l_corpse_o = luabind::adl::object(L, l_corpse);
@@ -607,15 +607,15 @@ void handle_item_loot(QuestInterface *parse, lua_State* L, Client* client, EQEmu
}
}
void handle_item_equip(QuestInterface *parse, lua_State* L, Client* client, EQEmu::ItemInstance* item, Mob *mob, std::string data, uint32 extra_data,
std::vector<EQEmu::Any> *extra_pointers) {
void handle_item_equip(QuestInterface *parse, lua_State* L, Client* client, EQ::ItemInstance* item, Mob *mob, std::string data, uint32 extra_data,
std::vector<EQ::Any> *extra_pointers) {
lua_pushinteger(L, extra_data);
lua_setfield(L, -2, "slot_id");
}
void handle_item_augment(QuestInterface *parse, lua_State* L, Client* client, EQEmu::ItemInstance* item, Mob *mob, std::string data, uint32 extra_data,
std::vector<EQEmu::Any> *extra_pointers) {
Lua_ItemInst l_item(EQEmu::any_cast<EQEmu::ItemInstance*>(extra_pointers->at(0)));
void handle_item_augment(QuestInterface *parse, lua_State* L, Client* client, EQ::ItemInstance* item, Mob *mob, std::string data, uint32 extra_data,
std::vector<EQ::Any> *extra_pointers) {
Lua_ItemInst l_item(EQ::any_cast<EQ::ItemInstance*>(extra_pointers->at(0)));
luabind::adl::object l_item_o = luabind::adl::object(L, l_item);
l_item_o.push(L);
lua_setfield(L, -2, "aug");
@@ -624,9 +624,9 @@ void handle_item_augment(QuestInterface *parse, lua_State* L, Client* client, EQ
lua_setfield(L, -2, "slot_id");
}
void handle_item_augment_insert(QuestInterface *parse, lua_State* L, Client* client, EQEmu::ItemInstance* item, Mob *mob, std::string data, uint32 extra_data,
std::vector<EQEmu::Any> *extra_pointers) {
Lua_ItemInst l_item(EQEmu::any_cast<EQEmu::ItemInstance*>(extra_pointers->at(0)));
void handle_item_augment_insert(QuestInterface *parse, lua_State* L, Client* client, EQ::ItemInstance* item, Mob *mob, std::string data, uint32 extra_data,
std::vector<EQ::Any> *extra_pointers) {
Lua_ItemInst l_item(EQ::any_cast<EQ::ItemInstance*>(extra_pointers->at(0)));
luabind::adl::object l_item_o = luabind::adl::object(L, l_item);
l_item_o.push(L);
lua_setfield(L, -2, "item");
@@ -635,9 +635,9 @@ void handle_item_augment_insert(QuestInterface *parse, lua_State* L, Client* cli
lua_setfield(L, -2, "slot_id");
}
void handle_item_augment_remove(QuestInterface *parse, lua_State* L, Client* client, EQEmu::ItemInstance* item, Mob *mob, std::string data, uint32 extra_data,
std::vector<EQEmu::Any> *extra_pointers) {
Lua_ItemInst l_item(EQEmu::any_cast<EQEmu::ItemInstance*>(extra_pointers->at(0)));
void handle_item_augment_remove(QuestInterface *parse, lua_State* L, Client* client, EQ::ItemInstance* item, Mob *mob, std::string data, uint32 extra_data,
std::vector<EQ::Any> *extra_pointers) {
Lua_ItemInst l_item(EQ::any_cast<EQ::ItemInstance*>(extra_pointers->at(0)));
luabind::adl::object l_item_o = luabind::adl::object(L, l_item);
l_item_o.push(L);
lua_setfield(L, -2, "item");
@@ -645,17 +645,17 @@ void handle_item_augment_remove(QuestInterface *parse, lua_State* L, Client* cli
lua_pushinteger(L, extra_data);
lua_setfield(L, -2, "slot_id");
lua_pushboolean(L, *EQEmu::any_cast<bool*>(extra_pointers->at(1)));
lua_pushboolean(L, *EQ::any_cast<bool*>(extra_pointers->at(1)));
lua_setfield(L, -2, "destroyed");
}
void handle_item_null(QuestInterface *parse, lua_State* L, Client* client, EQEmu::ItemInstance* item, Mob *mob, std::string data, uint32 extra_data,
std::vector<EQEmu::Any> *extra_pointers) {
void handle_item_null(QuestInterface *parse, lua_State* L, Client* client, EQ::ItemInstance* item, Mob *mob, std::string data, uint32 extra_data,
std::vector<EQ::Any> *extra_pointers) {
}
//Spell
void handle_spell_effect(QuestInterface *parse, lua_State* L, NPC* npc, Client* client, uint32 spell_id, uint32 extra_data,
std::vector<EQEmu::Any> *extra_pointers) {
std::vector<EQ::Any> *extra_pointers) {
if(npc) {
Lua_Mob l_npc(npc);
luabind::adl::object l_npc_o = luabind::adl::object(L, l_npc);
@@ -672,7 +672,7 @@ void handle_spell_effect(QuestInterface *parse, lua_State* L, NPC* npc, Client*
lua_setfield(L, -2, "target");
lua_pushinteger(L, *EQEmu::any_cast<int*>(extra_pointers->at(0)));
lua_pushinteger(L, *EQ::any_cast<int*>(extra_pointers->at(0)));
lua_setfield(L, -2, "buff_slot");
lua_pushinteger(L, extra_data);
@@ -680,7 +680,7 @@ void handle_spell_effect(QuestInterface *parse, lua_State* L, NPC* npc, Client*
}
void handle_spell_tic(QuestInterface *parse, lua_State* L, NPC* npc, Client* client, uint32 spell_id, uint32 extra_data,
std::vector<EQEmu::Any> *extra_pointers) {
std::vector<EQ::Any> *extra_pointers) {
if(npc) {
Lua_Mob l_npc(npc);
luabind::adl::object l_npc_o = luabind::adl::object(L, l_npc);
@@ -697,13 +697,13 @@ void handle_spell_tic(QuestInterface *parse, lua_State* L, NPC* npc, Client* cli
lua_setfield(L, -2, "target");
lua_pushinteger(L, *EQEmu::any_cast<int*>(extra_pointers->at(0)));
lua_pushinteger(L, *EQ::any_cast<int*>(extra_pointers->at(0)));
lua_setfield(L, -2, "tics_remaining");
lua_pushinteger(L, *EQEmu::any_cast<uint8*>(extra_pointers->at(1)));
lua_pushinteger(L, *EQ::any_cast<uint8*>(extra_pointers->at(1)));
lua_setfield(L, -2, "caster_level");
lua_pushinteger(L, *EQEmu::any_cast<int*>(extra_pointers->at(2)));
lua_pushinteger(L, *EQ::any_cast<int*>(extra_pointers->at(2)));
lua_setfield(L, -2, "buff_slot");
lua_pushinteger(L, extra_data);
@@ -711,7 +711,7 @@ void handle_spell_tic(QuestInterface *parse, lua_State* L, NPC* npc, Client* cli
}
void handle_spell_fade(QuestInterface *parse, lua_State* L, NPC* npc, Client* client, uint32 spell_id, uint32 extra_data,
std::vector<EQEmu::Any> *extra_pointers) {
std::vector<EQ::Any> *extra_pointers) {
if(npc) {
Lua_Mob l_npc(npc);
luabind::adl::object l_npc_o = luabind::adl::object(L, l_npc);
@@ -731,12 +731,12 @@ void handle_spell_fade(QuestInterface *parse, lua_State* L, NPC* npc, Client* cl
lua_pushinteger(L, extra_data);
lua_setfield(L, -2, "buff_slot");
lua_pushinteger(L, *EQEmu::any_cast<uint16*>(extra_pointers->at(0)));
lua_pushinteger(L, *EQ::any_cast<uint16*>(extra_pointers->at(0)));
lua_setfield(L, -2, "caster_id");
}
void handle_translocate_finish(QuestInterface *parse, lua_State* L, NPC* npc, Client* client, uint32 spell_id, uint32 extra_data,
std::vector<EQEmu::Any> *extra_pointers) {
std::vector<EQ::Any> *extra_pointers) {
if(npc) {
Lua_Mob l_npc(npc);
luabind::adl::object l_npc_o = luabind::adl::object(L, l_npc);
@@ -755,17 +755,17 @@ void handle_translocate_finish(QuestInterface *parse, lua_State* L, NPC* npc, Cl
}
void handle_spell_null(QuestInterface *parse, lua_State* L, NPC* npc, Client* client, uint32 spell_id, uint32 extra_data,
std::vector<EQEmu::Any> *extra_pointers) {
std::vector<EQ::Any> *extra_pointers) {
}
void handle_encounter_timer(QuestInterface *parse, lua_State* L, Encounter* encounter, std::string data, uint32 extra_data,
std::vector<EQEmu::Any> *extra_pointers) {
std::vector<EQ::Any> *extra_pointers) {
lua_pushstring(L, data.c_str());
lua_setfield(L, -2, "timer");
}
void handle_encounter_load(QuestInterface *parse, lua_State* L, Encounter* encounter, std::string data, uint32 extra_data,
std::vector<EQEmu::Any> *extra_pointers) {
std::vector<EQ::Any> *extra_pointers) {
if (encounter) {
Lua_Encounter l_enc(encounter);
luabind::adl::object l_enc_o = luabind::adl::object(L, l_enc);
@@ -773,23 +773,23 @@ void handle_encounter_load(QuestInterface *parse, lua_State* L, Encounter* encou
lua_setfield(L, -2, "encounter");
}
if (extra_pointers) {
std::string *str = EQEmu::any_cast<std::string*>(extra_pointers->at(0));
std::string *str = EQ::any_cast<std::string*>(extra_pointers->at(0));
lua_pushstring(L, str->c_str());
lua_setfield(L, -2, "data");
}
}
void handle_encounter_unload(QuestInterface *parse, lua_State* L, Encounter* encounter, std::string data, uint32 extra_data,
std::vector<EQEmu::Any> *extra_pointers) {
std::vector<EQ::Any> *extra_pointers) {
if (extra_pointers) {
std::string *str = EQEmu::any_cast<std::string*>(extra_pointers->at(0));
std::string *str = EQ::any_cast<std::string*>(extra_pointers->at(0));
lua_pushstring(L, str->c_str());
lua_setfield(L, -2, "data");
}
}
void handle_encounter_null(QuestInterface *parse, lua_State* L, Encounter* encounter, std::string data, uint32 extra_data,
std::vector<EQEmu::Any> *extra_pointers) {
std::vector<EQ::Any> *extra_pointers) {
}
zone/lua_parser_events.h
+77 -77
View File
@@ -2,148 +2,148 @@
#define _EQE_LUA_PARSER_EVENTS_H
#ifdef LUA_EQEMU
typedef void(*NPCArgumentHandler)(QuestInterface*, lua_State*, NPC*, Mob*, std::string, uint32, std::vector<EQEmu::Any>*);
typedef void(*PlayerArgumentHandler)(QuestInterface*, lua_State*, Client*, std::string, uint32, std::vector<EQEmu::Any>*);
typedef void(*ItemArgumentHandler)(QuestInterface*, lua_State*, Client*, EQEmu::ItemInstance*, Mob*, std::string, uint32, std::vector<EQEmu::Any>*);
typedef void(*SpellArgumentHandler)(QuestInterface*, lua_State*, NPC*, Client*, uint32, uint32, std::vector<EQEmu::Any>*);
typedef void(*EncounterArgumentHandler)(QuestInterface*, lua_State*, Encounter* encounter, std::string, uint32, std::vector<EQEmu::Any>*);
typedef void(*NPCArgumentHandler)(QuestInterface*, lua_State*, NPC*, Mob*, std::string, uint32, std::vector<EQ::Any>*);
typedef void(*PlayerArgumentHandler)(QuestInterface*, lua_State*, Client*, std::string, uint32, std::vector<EQ::Any>*);
typedef void(*ItemArgumentHandler)(QuestInterface*, lua_State*, Client*, EQ::ItemInstance*, Mob*, std::string, uint32, std::vector<EQ::Any>*);
typedef void(*SpellArgumentHandler)(QuestInterface*, lua_State*, NPC*, Client*, uint32, uint32, std::vector<EQ::Any>*);
typedef void(*EncounterArgumentHandler)(QuestInterface*, lua_State*, Encounter* encounter, std::string, uint32, std::vector<EQ::Any>*);
//NPC
void handle_npc_event_say(QuestInterface *parse, lua_State* L, NPC* npc, Mob *init, std::string data, uint32 extra_data,
std::vector<EQEmu::Any> *extra_pointers);
std::vector<EQ::Any> *extra_pointers);
void handle_npc_event_trade(QuestInterface *parse, lua_State* L, NPC* npc, Mob *init, std::string data, uint32 extra_data,
std::vector<EQEmu::Any> *extra_pointers);
std::vector<EQ::Any> *extra_pointers);
void handle_npc_event_hp(QuestInterface *parse, lua_State* L, NPC* npc, Mob *init, std::string data, uint32 extra_data,
std::vector<EQEmu::Any> *extra_pointers);
std::vector<EQ::Any> *extra_pointers);
void handle_npc_single_mob(QuestInterface *parse, lua_State* L, NPC* npc, Mob *init, std::string data, uint32 extra_data,
std::vector<EQEmu::Any> *extra_pointers);
std::vector<EQ::Any> *extra_pointers);
void handle_npc_single_client(QuestInterface *parse, lua_State* L, NPC* npc, Mob *init, std::string data, uint32 extra_data,
std::vector<EQEmu::Any> *extra_pointers);
std::vector<EQ::Any> *extra_pointers);
void handle_npc_single_npc(QuestInterface *parse, lua_State* L, NPC* npc, Mob *init, std::string data, uint32 extra_data,
std::vector<EQEmu::Any> *extra_pointers);
std::vector<EQ::Any> *extra_pointers);
void handle_npc_task_accepted(QuestInterface *parse, lua_State* L, NPC* npc, Mob *init, std::string data, uint32 extra_data,
std::vector<EQEmu::Any> *extra_pointers);
std::vector<EQ::Any> *extra_pointers);
void handle_npc_popup(QuestInterface *parse, lua_State* L, NPC* npc, Mob *init, std::string data, uint32 extra_data,
std::vector<EQEmu::Any> *extra_pointers);
std::vector<EQ::Any> *extra_pointers);
void handle_npc_waypoint(QuestInterface *parse, lua_State* L, NPC* npc, Mob *init, std::string data, uint32 extra_data,
std::vector<EQEmu::Any> *extra_pointers);
std::vector<EQ::Any> *extra_pointers);
void handle_npc_hate(QuestInterface *parse, lua_State* L, NPC* npc, Mob *init, std::string data, uint32 extra_data,
std::vector<EQEmu::Any> *extra_pointers);
std::vector<EQ::Any> *extra_pointers);
void handle_npc_signal(QuestInterface *parse, lua_State* L, NPC* npc, Mob *init, std::string data, uint32 extra_data,
std::vector<EQEmu::Any> *extra_pointers);
std::vector<EQ::Any> *extra_pointers);
void handle_npc_timer(QuestInterface *parse, lua_State* L, NPC* npc, Mob *init, std::string data, uint32 extra_data,
std::vector<EQEmu::Any> *extra_pointers);
std::vector<EQ::Any> *extra_pointers);
void handle_npc_death(QuestInterface *parse, lua_State* L, NPC* npc, Mob *init, std::string data, uint32 extra_data,
std::vector<EQEmu::Any> *extra_pointers);
std::vector<EQ::Any> *extra_pointers);
void handle_npc_cast(QuestInterface *parse, lua_State* L, NPC* npc, Mob *init, std::string data, uint32 extra_data,
std::vector<EQEmu::Any> *extra_pointers);
std::vector<EQ::Any> *extra_pointers);
void handle_npc_area(QuestInterface *parse, lua_State* L, NPC* npc, Mob *init, std::string data, uint32 extra_data,
std::vector<EQEmu::Any> *extra_pointers);
std::vector<EQ::Any> *extra_pointers);
void handle_npc_null(QuestInterface *parse, lua_State* L, NPC* npc, Mob *init, std::string data, uint32 extra_data,
std::vector<EQEmu::Any> *extra_pointers);
std::vector<EQ::Any> *extra_pointers);
//Player
void handle_player_say(QuestInterface *parse, lua_State* L, Client* client, std::string data, uint32 extra_data,
std::vector<EQEmu::Any> *extra_pointers);
std::vector<EQ::Any> *extra_pointers);
void handle_player_environmental_damage(QuestInterface *parse, lua_State* L, Client* client, std::string data, uint32 extra_data,
std::vector<EQEmu::Any> *extra_pointers);
std::vector<EQ::Any> *extra_pointers);
void handle_player_death(QuestInterface *parse, lua_State* L, Client* client, std::string data, uint32 extra_data,
std::vector<EQEmu::Any> *extra_pointers);
std::vector<EQ::Any> *extra_pointers);
void handle_player_timer(QuestInterface *parse, lua_State* L, Client* client, std::string data, uint32 extra_data,
std::vector<EQEmu::Any> *extra_pointers);
std::vector<EQ::Any> *extra_pointers);
void handle_player_discover_item(QuestInterface *parse, lua_State* L, Client* client, std::string data, uint32 extra_data,
std::vector<EQEmu::Any> *extra_pointers);
std::vector<EQ::Any> *extra_pointers);
void handle_player_fish_forage_success(QuestInterface *parse, lua_State* L, Client* client, std::string data, uint32 extra_data,
std::vector<EQEmu::Any> *extra_pointers);
std::vector<EQ::Any> *extra_pointers);
void handle_player_click_object(QuestInterface *parse, lua_State* L, Client* client, std::string data, uint32 extra_data,
std::vector<EQEmu::Any> *extra_pointers);
std::vector<EQ::Any> *extra_pointers);
void handle_player_click_door(QuestInterface *parse, lua_State* L, Client* client, std::string data, uint32 extra_data,
std::vector<EQEmu::Any> *extra_pointers);
std::vector<EQ::Any> *extra_pointers);
void handle_player_signal(QuestInterface *parse, lua_State* L, Client* client, std::string data, uint32 extra_data,
std::vector<EQEmu::Any> *extra_pointers);
std::vector<EQ::Any> *extra_pointers);
void handle_player_popup_response(QuestInterface *parse, lua_State* L, Client* client, std::string data, uint32 extra_data,
std::vector<EQEmu::Any> *extra_pointers);
std::vector<EQ::Any> *extra_pointers);
void handle_player_pick_up(QuestInterface *parse, lua_State* L, Client* client, std::string data, uint32 extra_data,
std::vector<EQEmu::Any> *extra_pointers);
std::vector<EQ::Any> *extra_pointers);
void handle_player_cast(QuestInterface *parse, lua_State* L, Client* client, std::string data, uint32 extra_data,
std::vector<EQEmu::Any> *extra_pointers);
std::vector<EQ::Any> *extra_pointers);
void handle_player_task_fail(QuestInterface *parse, lua_State* L, Client* client, std::string data, uint32 extra_data,
std::vector<EQEmu::Any> *extra_pointers);
std::vector<EQ::Any> *extra_pointers);
void handle_player_zone(QuestInterface *parse, lua_State* L, Client* client, std::string data, uint32 extra_data,
std::vector<EQEmu::Any> *extra_pointers);
std::vector<EQ::Any> *extra_pointers);
void handle_player_duel_win(QuestInterface *parse, lua_State* L, Client* client, std::string data, uint32 extra_data,
std::vector<EQEmu::Any> *extra_pointers);
std::vector<EQ::Any> *extra_pointers);
void handle_player_duel_loss(QuestInterface *parse, lua_State* L, Client* client, std::string data, uint32 extra_data,
std::vector<EQEmu::Any> *extra_pointers);
std::vector<EQ::Any> *extra_pointers);
void handle_player_loot(QuestInterface *parse, lua_State* L, Client* client, std::string data, uint32 extra_data,
std::vector<EQEmu::Any> *extra_pointers);
std::vector<EQ::Any> *extra_pointers);
void handle_player_task_stage_complete(QuestInterface *parse, lua_State* L, Client* client, std::string data, uint32 extra_data,
std::vector<EQEmu::Any> *extra_pointers);
std::vector<EQ::Any> *extra_pointers);
void handle_player_task_update(QuestInterface *parse, lua_State* L, Client* client, std::string data, uint32 extra_data,
std::vector<EQEmu::Any> *extra_pointers);
std::vector<EQ::Any> *extra_pointers);
void handle_player_command(QuestInterface *parse, lua_State* L, Client* client, std::string data, uint32 extra_data,
std::vector<EQEmu::Any> *extra_pointers);
std::vector<EQ::Any> *extra_pointers);
void handle_player_combine(QuestInterface *parse, lua_State* L, Client* client, std::string data, uint32 extra_data,
std::vector<EQEmu::Any> *extra_pointers);
std::vector<EQ::Any> *extra_pointers);
void handle_player_feign(QuestInterface *parse, lua_State* L, Client* client, std::string data, uint32 extra_data,
std::vector<EQEmu::Any> *extra_pointers);
std::vector<EQ::Any> *extra_pointers);
void handle_player_area(QuestInterface *parse, lua_State* L, Client* client, std::string data, uint32 extra_data,
std::vector<EQEmu::Any> *extra_pointers);
std::vector<EQ::Any> *extra_pointers);
void handle_player_respawn(QuestInterface *parse, lua_State* L, Client* client, std::string data, uint32 extra_data,
std::vector<EQEmu::Any> *extra_pointers);
std::vector<EQ::Any> *extra_pointers);
void handle_player_packet(QuestInterface *parse, lua_State* L, Client* client, std::string data, uint32 extra_data,
std::vector<EQEmu::Any> *extra_pointers);
std::vector<EQ::Any> *extra_pointers);
void handle_player_null(QuestInterface *parse, lua_State* L, Client* client, std::string data, uint32 extra_data,
std::vector<EQEmu::Any> *extra_pointers);
std::vector<EQ::Any> *extra_pointers);
void handle_player_use_skill(QuestInterface *parse, lua_State* L, Client* client, std::string data, uint32 extra_data,
std::vector<EQEmu::Any> *extra_pointers);
std::vector<EQ::Any> *extra_pointers);
void handle_player_combine_validate(QuestInterface* parse, lua_State* L, Client* client, std::string data, uint32 extra_data,
std::vector<EQEmu::Any>* extra_pointers);
std::vector<EQ::Any>* extra_pointers);
void handle_player_bot_command(QuestInterface *parse, lua_State* L, Client* client, std::string data, uint32 extra_data,
std::vector<EQEmu::Any> *extra_pointers);
std::vector<EQ::Any> *extra_pointers);
//Item
void handle_item_click(QuestInterface *parse, lua_State* L, Client* client, EQEmu::ItemInstance* item, Mob *mob, std::string data, uint32 extra_data,
std::vector<EQEmu::Any> *extra_pointers);
void handle_item_timer(QuestInterface *parse, lua_State* L, Client* client, EQEmu::ItemInstance* item, Mob *mob, std::string data, uint32 extra_data,
std::vector<EQEmu::Any> *extra_pointers);
void handle_item_proc(QuestInterface *parse, lua_State* L, Client* client, EQEmu::ItemInstance* item, Mob *mob, std::string data, uint32 extra_data,
std::vector<EQEmu::Any> *extra_pointers);
void handle_item_loot(QuestInterface *parse, lua_State* L, Client* client, EQEmu::ItemInstance* item, Mob *mob, std::string data, uint32 extra_data,
std::vector<EQEmu::Any> *extra_pointers);
void handle_item_equip(QuestInterface *parse, lua_State* L, Client* client, EQEmu::ItemInstance* item, Mob *mob, std::string data, uint32 extra_data,
std::vector<EQEmu::Any> *extra_pointers);
void handle_item_augment(QuestInterface *parse, lua_State* L, Client* client, EQEmu::ItemInstance* item, Mob *mob, std::string data, uint32 extra_data,
std::vector<EQEmu::Any> *extra_pointers);
void handle_item_augment_insert(QuestInterface *parse, lua_State* L, Client* client, EQEmu::ItemInstance* item, Mob *mob, std::string data, uint32 extra_data,
std::vector<EQEmu::Any> *extra_pointers);
void handle_item_augment_remove(QuestInterface *parse, lua_State* L, Client* client, EQEmu::ItemInstance* item, Mob *mob, std::string data, uint32 extra_data,
std::vector<EQEmu::Any> *extra_pointers);
void handle_item_null(QuestInterface *parse, lua_State* L, Client* client, EQEmu::ItemInstance* item, Mob *mob, std::string data, uint32 extra_data,
std::vector<EQEmu::Any> *extra_pointers);
void handle_item_click(QuestInterface *parse, lua_State* L, Client* client, EQ::ItemInstance* item, Mob *mob, std::string data, uint32 extra_data,
std::vector<EQ::Any> *extra_pointers);
void handle_item_timer(QuestInterface *parse, lua_State* L, Client* client, EQ::ItemInstance* item, Mob *mob, std::string data, uint32 extra_data,
std::vector<EQ::Any> *extra_pointers);
void handle_item_proc(QuestInterface *parse, lua_State* L, Client* client, EQ::ItemInstance* item, Mob *mob, std::string data, uint32 extra_data,
std::vector<EQ::Any> *extra_pointers);
void handle_item_loot(QuestInterface *parse, lua_State* L, Client* client, EQ::ItemInstance* item, Mob *mob, std::string data, uint32 extra_data,
std::vector<EQ::Any> *extra_pointers);
void handle_item_equip(QuestInterface *parse, lua_State* L, Client* client, EQ::ItemInstance* item, Mob *mob, std::string data, uint32 extra_data,
std::vector<EQ::Any> *extra_pointers);
void handle_item_augment(QuestInterface *parse, lua_State* L, Client* client, EQ::ItemInstance* item, Mob *mob, std::string data, uint32 extra_data,
std::vector<EQ::Any> *extra_pointers);
void handle_item_augment_insert(QuestInterface *parse, lua_State* L, Client* client, EQ::ItemInstance* item, Mob *mob, std::string data, uint32 extra_data,
std::vector<EQ::Any> *extra_pointers);
void handle_item_augment_remove(QuestInterface *parse, lua_State* L, Client* client, EQ::ItemInstance* item, Mob *mob, std::string data, uint32 extra_data,
std::vector<EQ::Any> *extra_pointers);
void handle_item_null(QuestInterface *parse, lua_State* L, Client* client, EQ::ItemInstance* item, Mob *mob, std::string data, uint32 extra_data,
std::vector<EQ::Any> *extra_pointers);
//Spell
void handle_spell_effect(QuestInterface *parse, lua_State* L, NPC* npc, Client* client, uint32 spell_id, uint32 extra_data,
std::vector<EQEmu::Any> *extra_pointers);
std::vector<EQ::Any> *extra_pointers);
void handle_spell_tic(QuestInterface *parse, lua_State* L, NPC* npc, Client* client, uint32 spell_id, uint32 extra_data,
std::vector<EQEmu::Any> *extra_pointers);
std::vector<EQ::Any> *extra_pointers);
void handle_spell_fade(QuestInterface *parse, lua_State* L, NPC* npc, Client* client, uint32 spell_id, uint32 extra_data,
std::vector<EQEmu::Any> *extra_pointers);
std::vector<EQ::Any> *extra_pointers);
void handle_translocate_finish(QuestInterface *parse, lua_State* L, NPC* npc, Client* client, uint32 spell_id, uint32 extra_data,
std::vector<EQEmu::Any> *extra_pointers);
std::vector<EQ::Any> *extra_pointers);
void handle_spell_null(QuestInterface *parse, lua_State* L, NPC* npc, Client* client, uint32 spell_id, uint32 extra_data,
std::vector<EQEmu::Any> *extra_pointers);
std::vector<EQ::Any> *extra_pointers);
//Encounter
void handle_encounter_timer(QuestInterface *parse, lua_State* L, Encounter* encounter, std::string data, uint32 extra_data,
std::vector<EQEmu::Any> *extra_pointers);
std::vector<EQ::Any> *extra_pointers);
void handle_encounter_load(QuestInterface *parse, lua_State* L, Encounter* encounter, std::string data, uint32 extra_data,
std::vector<EQEmu::Any> *extra_pointers);
std::vector<EQ::Any> *extra_pointers);
void handle_encounter_unload(QuestInterface *parse, lua_State* L, Encounter* encounter, std::string data, uint32 extra_data,
std::vector<EQEmu::Any> *extra_pointers);
std::vector<EQ::Any> *extra_pointers);
void handle_encounter_null(QuestInterface *parse, lua_State* L, Encounter* encounter, std::string data, uint32 extra_data,
std::vector<EQEmu::Any> *extra_pointers);
std::vector<EQ::Any> *extra_pointers);
#endif
#endif
zone/main.cpp
+2 -2
View File
@@ -345,7 +345,7 @@ int main(int argc, char** argv) {
database.GetDecayTimes(npcCorpseDecayTimes);
LogInfo("Loading profanity list");
if (!EQEmu::ProfanityManager::LoadProfanityList(&database))
if (!EQ::ProfanityManager::LoadProfanityList(&database))
LogError("Loading profanity list failed!");
LogInfo("Loading commands");
@@ -373,7 +373,7 @@ int main(int argc, char** argv) {
}
}
EQEmu::InitializeDynamicLookups();
EQ::InitializeDynamicLookups();
LogInfo("Initialized dynamic dictionary entries");
}
zone/map.cpp
+1 -1
View File
@@ -403,7 +403,7 @@ bool Map::LoadV2(FILE *f) {
std::vector<char> buffer;
buffer.resize(buffer_size);
uint32 v = EQEmu::InflateData(&data[0], data_size, &buffer[0], buffer_size);
uint32 v = EQ::InflateData(&data[0], data_size, &buffer[0], buffer_size);
char *buf = &buffer[0];
uint32 vert_count;
zone/merc.cpp
+94 -94
View File
@@ -50,7 +50,7 @@ Merc::Merc(const NPCType* d, float x, float y, float z, float heading)
_baseFR = d->FR;
_basePR = d->PR;
_baseCorrup = d->Corrup;
_OwnerClientVersion = static_cast<unsigned int>(EQEmu::versions::ClientVersion::Titanium);
_OwnerClientVersion = static_cast<unsigned int>(EQ::versions::ClientVersion::Titanium);
RestRegenHP = 0;
RestRegenMana = 0;
RestRegenEndurance = 0;
@@ -66,15 +66,15 @@ Merc::Merc(const NPCType* d, float x, float y, float z, float heading)
memset(equipment, 0, sizeof(equipment));
SetMercID(0);
SetStance(EQEmu::constants::stanceBalanced);
SetStance(EQ::constants::stanceBalanced);
rest_timer.Disable();
if (GetClass() == ROGUE)
evade_timer.Start();
int r;
for (r = 0; r <= EQEmu::skills::HIGHEST_SKILL; r++) {
skills[r] = database.GetSkillCap(GetClass(), (EQEmu::skills::SkillType)r, GetLevel());
for (r = 0; r <= EQ::skills::HIGHEST_SKILL; r++) {
skills[r] = database.GetSkillCap(GetClass(), (EQ::skills::SkillType)r, GetLevel());
}
size = d->size;
@@ -217,12 +217,12 @@ void Merc::CalcItemBonuses(StatBonuses* newbon) {
unsigned int i;
//should not include 21 (SLOT_AMMO)
for (i = EQEmu::invslot::BONUS_BEGIN; i <= EQEmu::invslot::BONUS_STAT_END; i++) {
if (i == EQEmu::invslot::slotAmmo)
for (i = EQ::invslot::BONUS_BEGIN; i <= EQ::invslot::BONUS_STAT_END; i++) {
if (i == EQ::invslot::slotAmmo)
continue;
if (equipment[i] == 0)
continue;
const EQEmu::ItemData * itm = database.GetItem(equipment[i]);
const EQ::ItemData * itm = database.GetItem(equipment[i]);
if (itm)
AddItemBonuses(itm, newbon);
}
@@ -240,7 +240,7 @@ void Merc::CalcItemBonuses(StatBonuses* newbon) {
SetAttackTimer();
}
void Merc::AddItemBonuses(const EQEmu::ItemData *item, StatBonuses* newbon) {
void Merc::AddItemBonuses(const EQ::ItemData *item, StatBonuses* newbon) {
if(GetLevel() < item->ReqLevel)
{
@@ -453,11 +453,11 @@ void Merc::AddItemBonuses(const EQEmu::ItemData *item, StatBonuses* newbon) {
else
newbon->DSMitigation += item->DSMitigation;
}
if (item->Worn.Effect>0 && (item->Worn.Type == EQEmu::item::ItemEffectWorn)) { // latent effects
if (item->Worn.Effect>0 && (item->Worn.Type == EQ::item::ItemEffectWorn)) { // latent effects
ApplySpellsBonuses(item->Worn.Effect, item->Worn.Level, newbon, 0, item->Worn.Type);
}
if (item->Focus.Effect>0 && (item->Focus.Type == EQEmu::item::ItemEffectFocus)) { // focus effects
if (item->Focus.Effect>0 && (item->Focus.Type == EQ::item::ItemEffectFocus)) { // focus effects
ApplySpellsBonuses(item->Focus.Effect, item->Focus.Level, newbon, 0);
}
@@ -509,7 +509,7 @@ void Merc::AddItemBonuses(const EQEmu::ItemData *item, StatBonuses* newbon) {
}
}
if (item->SkillModValue != 0 && item->SkillModType <= EQEmu::skills::HIGHEST_SKILL){
if (item->SkillModValue != 0 && item->SkillModType <= EQ::skills::HIGHEST_SKILL){
if ((item->SkillModValue > 0 && newbon->skillmod[item->SkillModType] < item->SkillModValue) ||
(item->SkillModValue < 0 && newbon->skillmod[item->SkillModType] > item->SkillModValue))
{
@@ -563,7 +563,7 @@ void Merc::AddItemBonuses(const EQEmu::ItemData *item, StatBonuses* newbon) {
}
}
if (item->ExtraDmgSkill != 0 && item->ExtraDmgSkill <= EQEmu::skills::HIGHEST_SKILL) {
if (item->ExtraDmgSkill != 0 && item->ExtraDmgSkill <= EQ::skills::HIGHEST_SKILL) {
if((newbon->SkillDamageAmount[item->ExtraDmgSkill] + item->ExtraDmgAmt) > RuleI(Character, ItemExtraDmgCap))
newbon->SkillDamageAmount[item->ExtraDmgSkill] = RuleI(Character, ItemExtraDmgCap);
else
@@ -928,8 +928,8 @@ int32 Merc::CalcBaseManaRegen()
int32 regen = 0;
if (IsSitting())
{
if (HasSkill(EQEmu::skills::SkillMeditate))
regen = (((GetSkill(EQEmu::skills::SkillMeditate) / 10) + (clevel - (clevel / 4))) / 4) + 4;
if (HasSkill(EQ::skills::SkillMeditate))
regen = (((GetSkill(EQ::skills::SkillMeditate) / 10) + (clevel - (clevel / 4))) / 4) + 4;
else
regen = 2;
}
@@ -945,9 +945,9 @@ int32 Merc::CalcManaRegen()
if (IsSitting())
{
BuffFadeBySitModifier();
if (HasSkill(EQEmu::skills::SkillMeditate)) {
if (HasSkill(EQ::skills::SkillMeditate)) {
this->_medding = true;
regen = ((GetSkill(EQEmu::skills::SkillMeditate) / 10) + mana_regen);
regen = ((GetSkill(EQ::skills::SkillMeditate) / 10) + mana_regen);
regen += spellbonuses.ManaRegen + itembonuses.ManaRegen;
}
else
@@ -1015,7 +1015,7 @@ int32 Merc::CalcBaseEndurance()
int32 sta_end = 0;
int Stats = 0;
if (GetClientVersion() >= static_cast<unsigned int>(EQEmu::versions::ClientVersion::SoD) && RuleB(Character, SoDClientUseSoDHPManaEnd)) {
if (GetClientVersion() >= static_cast<unsigned int>(EQ::versions::ClientVersion::SoD) && RuleB(Character, SoDClientUseSoDHPManaEnd)) {
int HeroicStats = 0;
Stats = ((GetSTR() + GetSTA() + GetDEX() + GetAGI()) / 4);
@@ -1175,16 +1175,16 @@ void Merc::CalcRestState() {
RestRegenEndurance = 6 * (GetMaxEndurance() / zone->newzone_data.FastRegenEndurance);
}
bool Merc::HasSkill(EQEmu::skills::SkillType skill_id) const {
bool Merc::HasSkill(EQ::skills::SkillType skill_id) const {
return((GetSkill(skill_id) > 0) && CanHaveSkill(skill_id));
}
bool Merc::CanHaveSkill(EQEmu::skills::SkillType skill_id) const {
bool Merc::CanHaveSkill(EQ::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(EQEmu::skills::SkillType skillid, uint16 class_, uint16 level) const {
uint16 Merc::MaxSkill(EQ::skills::SkillType skillid, uint16 class_, uint16 level) const {
return(database.GetSkillCap(class_, skillid, level));
}
@@ -1207,7 +1207,7 @@ void Merc::FillSpawnStruct(NewSpawn_Struct* ns, Mob* ForWho) {
ns->spawn.show_name = true;
UpdateActiveLight();
ns->spawn.light = m_Light.Type[EQEmu::lightsource::LightActive];
ns->spawn.light = m_Light.Type[EQ::lightsource::LightActive];
/*
// Wear Slots are not setup for Mercs yet
@@ -1518,12 +1518,12 @@ void Merc::AI_Process() {
// Hate redux actions
if (evade_timer.Check(false)) {
// Attempt to evade
int timer_duration = (HideReuseTime - GetSkillReuseTime(EQEmu::skills::SkillHide)) * 1000;
int timer_duration = (HideReuseTime - GetSkillReuseTime(EQ::skills::SkillHide)) * 1000;
if (timer_duration < 0)
timer_duration = 0;
evade_timer.Start(timer_duration);
if (zone->random.Int(0, 260) < (int)GetSkill(EQEmu::skills::SkillHide))
if (zone->random.Int(0, 260) < (int)GetSkill(EQ::skills::SkillHide))
RogueEvade(GetTarget());
return;
@@ -1590,24 +1590,24 @@ void Merc::AI_Process() {
//try main hand first
if(attack_timer.Check())
{
Attack(GetTarget(), EQEmu::invslot::slotPrimary);
Attack(GetTarget(), EQ::invslot::slotPrimary);
bool tripleSuccess = false;
if(GetOwner() && GetTarget() && CanThisClassDoubleAttack())
{
if(GetOwner()) {
Attack(GetTarget(), EQEmu::invslot::slotPrimary, true);
Attack(GetTarget(), EQ::invslot::slotPrimary, true);
}
if(GetOwner() && GetTarget() && GetSpecialAbility(SPECATK_TRIPLE)) {
tripleSuccess = true;
Attack(GetTarget(), EQEmu::invslot::slotPrimary, true);
Attack(GetTarget(), EQ::invslot::slotPrimary, true);
}
//quad attack, does this belong here??
if(GetOwner() && GetTarget() && GetSpecialAbility(SPECATK_QUAD)) {
Attack(GetTarget(), EQEmu::invslot::slotPrimary, true);
Attack(GetTarget(), EQ::invslot::slotPrimary, true);
}
}
@@ -1619,8 +1619,8 @@ void Merc::AI_Process() {
if(zone->random.Roll(flurrychance))
{
MessageString(Chat::NPCFlurry, YOU_FLURRY);
Attack(GetTarget(), EQEmu::invslot::slotPrimary, false);
Attack(GetTarget(), EQEmu::invslot::slotPrimary, false);
Attack(GetTarget(), EQ::invslot::slotPrimary, false);
Attack(GetTarget(), EQ::invslot::slotPrimary, false);
}
}
@@ -1629,7 +1629,7 @@ void Merc::AI_Process() {
if (GetTarget() && ExtraAttackChanceBonus) {
if(zone->random.Roll(ExtraAttackChanceBonus))
{
Attack(GetTarget(), EQEmu::invslot::slotPrimary, false);
Attack(GetTarget(), EQ::invslot::slotPrimary, false);
}
}
}
@@ -1653,23 +1653,23 @@ void Merc::AI_Process() {
bool bIsFist = true;
// why are we checking 'weapontype' when we know it's set to '0' above?
if (bIsFist || ((weapontype != EQEmu::item::ItemType2HSlash) && (weapontype != EQEmu::item::ItemType2HPiercing) && (weapontype != EQEmu::item::ItemType2HBlunt)))
if (bIsFist || ((weapontype != EQ::item::ItemType2HSlash) && (weapontype != EQ::item::ItemType2HPiercing) && (weapontype != EQ::item::ItemType2HBlunt)))
{
float DualWieldProbability = 0.0f;
int16 Ambidexterity = aabonuses.Ambidexterity + spellbonuses.Ambidexterity + itembonuses.Ambidexterity;
DualWieldProbability = (GetSkill(EQEmu::skills::SkillDualWield) + GetLevel() + Ambidexterity) / 400.0f; // 78.0 max
DualWieldProbability = (GetSkill(EQ::skills::SkillDualWield) + GetLevel() + Ambidexterity) / 400.0f; // 78.0 max
int16 DWBonus = spellbonuses.DualWieldChance + itembonuses.DualWieldChance;
DualWieldProbability += DualWieldProbability*float(DWBonus)/ 100.0f;
// Max 78% of DW
if (zone->random.Roll(DualWieldProbability))
{
Attack(GetTarget(), EQEmu::invslot::slotSecondary); // Single attack with offhand
Attack(GetTarget(), EQ::invslot::slotSecondary); // Single attack with offhand
if(CanThisClassDoubleAttack()) {
if(GetTarget() && GetTarget()->GetHP() > -10)
Attack(GetTarget(), EQEmu::invslot::slotSecondary); // Single attack with offhand
Attack(GetTarget(), EQ::invslot::slotSecondary); // Single attack with offhand
}
}
}
@@ -1993,7 +1993,7 @@ bool Merc::AIDoSpellCast(uint16 spellid, Mob* tar, int32 mana_cost, uint32* oDon
SentPositionPacket(0.0f, 0.0f, 0.0f, 0.0f, 0);
SetMoving(false);
result = CastSpell(spellid, tar->GetID(), EQEmu::spells::CastingSlot::Gem2, -1, mana_cost, oDontDoAgainBefore, -1, -1, 0, 0);
result = CastSpell(spellid, tar->GetID(), EQ::spells::CastingSlot::Gem2, -1, mana_cost, oDontDoAgainBefore, -1, -1, 0, 0);
if(IsCasting() && IsSitting())
Stand();
@@ -2348,7 +2348,7 @@ bool Merc::AICastSpell(int8 iChance, uint32 iSpellTypes) {
continue;
}
if (spells[selectedMercSpell.spellid].skill == EQEmu::skills::SkillBackstab && spells[selectedMercSpell.spellid].targettype == ST_Self) {
if (spells[selectedMercSpell.spellid].skill == EQ::skills::SkillBackstab && spells[selectedMercSpell.spellid].targettype == ST_Self) {
if(!hidden) {
continue;
}
@@ -2577,15 +2577,15 @@ int16 Merc::GetFocusEffect(focusType type, uint16 spell_id) {
//Check if item focus effect exists for the client.
if (itembonuses.FocusEffects[type]){
const EQEmu::ItemData* TempItem = nullptr;
const EQEmu::ItemData* UsedItem = nullptr;
const EQ::ItemData* TempItem = nullptr;
const EQ::ItemData* UsedItem = nullptr;
uint16 UsedFocusID = 0;
int16 Total = 0;
int16 focus_max = 0;
int16 focus_max_real = 0;
//item focus
for (int x = EQEmu::invslot::EQUIPMENT_BEGIN; x <= EQEmu::invslot::EQUIPMENT_END; ++x)
for (int x = EQ::invslot::EQUIPMENT_BEGIN; x <= EQ::invslot::EQUIPMENT_END; ++x)
{
TempItem = nullptr;
if (equipment[x] == 0)
@@ -3669,13 +3669,13 @@ MercSpell Merc::GetBestMercSpellForAENuke(Merc* caster, Mob* tar) {
switch(caster->GetStance())
{
case EQEmu::constants::stanceBurnAE:
case EQ::constants::stanceBurnAE:
initialCastChance = 50;
break;
case EQEmu::constants::stanceBalanced:
case EQ::constants::stanceBalanced:
initialCastChance = 25;
break;
case EQEmu::constants::stanceBurn:
case EQ::constants::stanceBurn:
initialCastChance = 0;
break;
}
@@ -3717,11 +3717,11 @@ MercSpell Merc::GetBestMercSpellForTargetedAENuke(Merc* caster, Mob* tar) {
switch(caster->GetStance())
{
case EQEmu::constants::stanceBurnAE:
case EQ::constants::stanceBurnAE:
numTargetsCheck = 1;
break;
case EQEmu::constants::stanceBalanced:
case EQEmu::constants::stanceBurn:
case EQ::constants::stanceBalanced:
case EQ::constants::stanceBurn:
numTargetsCheck = 2;
break;
}
@@ -3769,11 +3769,11 @@ MercSpell Merc::GetBestMercSpellForPBAENuke(Merc* caster, Mob* tar) {
switch(caster->GetStance())
{
case EQEmu::constants::stanceBurnAE:
case EQ::constants::stanceBurnAE:
numTargetsCheck = 2;
break;
case EQEmu::constants::stanceBalanced:
case EQEmu::constants::stanceBurn:
case EQ::constants::stanceBalanced:
case EQ::constants::stanceBurn:
numTargetsCheck = 3;
break;
}
@@ -3820,11 +3820,11 @@ MercSpell Merc::GetBestMercSpellForAERainNuke(Merc* caster, Mob* tar) {
switch(caster->GetStance())
{
case EQEmu::constants::stanceBurnAE:
case EQ::constants::stanceBurnAE:
numTargetsCheck = 1;
break;
case EQEmu::constants::stanceBalanced:
case EQEmu::constants::stanceBurn:
case EQ::constants::stanceBalanced:
case EQ::constants::stanceBurn:
numTargetsCheck = 2;
break;
}
@@ -4045,7 +4045,7 @@ bool Merc::UseDiscipline(int32 spell_id, int32 target) {
if(IsCasting())
InterruptSpell();
CastSpell(spell_id, target, EQEmu::spells::CastingSlot::Discipline);
CastSpell(spell_id, target, EQ::spells::CastingSlot::Discipline);
return(true);
}
@@ -4461,25 +4461,25 @@ void Merc::DoClassAttacks(Mob *target) {
if(zone->random.Int(0, 100) > 25) //tested on live, warrior mobs both kick and bash, kick about 75% of the time, casting doesn't seem to make a difference.
{
DoAnim(animKick, 0, false);
int32 dmg = GetBaseSkillDamage(EQEmu::skills::SkillKick);
int32 dmg = GetBaseSkillDamage(EQ::skills::SkillKick);
if (GetWeaponDamage(target, (const EQEmu::ItemData*)nullptr) <= 0)
if (GetWeaponDamage(target, (const EQ::ItemData*)nullptr) <= 0)
dmg = DMG_INVULNERABLE;
reuse = KickReuseTime * 1000;
DoSpecialAttackDamage(target, EQEmu::skills::SkillKick, dmg, 1, -1, reuse);
DoSpecialAttackDamage(target, EQ::skills::SkillKick, dmg, 1, -1, reuse);
did_attack = true;
}
else
{
DoAnim(animTailRake, 0, false);
int32 dmg = GetBaseSkillDamage(EQEmu::skills::SkillBash);
int32 dmg = GetBaseSkillDamage(EQ::skills::SkillBash);
if (GetWeaponDamage(target, (const EQEmu::ItemData*)nullptr) <= 0)
if (GetWeaponDamage(target, (const EQ::ItemData*)nullptr) <= 0)
dmg = DMG_INVULNERABLE;
reuse = BashReuseTime * 1000;
DoSpecialAttackDamage(target, EQEmu::skills::SkillBash, dmg, 1, -1, reuse);
DoSpecialAttackDamage(target, EQ::skills::SkillBash, dmg, 1, -1, reuse);
did_attack = true;
}
}
@@ -4501,7 +4501,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, EQEmu::skills::SkillType attack_skill, bool avoidable, int8 buffslot, bool iBuffTic, eSpecialAttacks special)
void Merc::Damage(Mob* other, int32 damage, uint16 spell_id, EQ::skills::SkillType attack_skill, bool avoidable, int8 buffslot, bool iBuffTic, eSpecialAttacks special)
{
if(IsDead() || IsCorpse())
return;
@@ -4542,7 +4542,7 @@ Mob* Merc::GetOwnerOrSelf() {
return Result;
}
bool Merc::Death(Mob* killerMob, int32 damage, uint16 spell, EQEmu::skills::SkillType attack_skill)
bool Merc::Death(Mob* killerMob, int32 damage, uint16 spell, EQ::skills::SkillType attack_skill)
{
if(!NPC::Death(killerMob, damage, spell, attack_skill))
{
@@ -5062,12 +5062,12 @@ void Merc::ScaleStats(int scalepercent, bool setmax) {
void Merc::UpdateMercAppearance() {
// Copied from Bot Code:
uint32 itemID = 0;
uint8 materialFromSlot = EQEmu::textures::materialInvalid;
for (int i = EQEmu::invslot::EQUIPMENT_BEGIN; i <= EQEmu::invslot::EQUIPMENT_END; ++i) {
uint8 materialFromSlot = EQ::textures::materialInvalid;
for (int i = EQ::invslot::EQUIPMENT_BEGIN; i <= EQ::invslot::EQUIPMENT_END; ++i) {
itemID = equipment[i];
if(itemID != 0) {
materialFromSlot = EQEmu::InventoryProfile::CalcMaterialFromSlot(i);
if (materialFromSlot != EQEmu::textures::materialInvalid)
materialFromSlot = EQ::InventoryProfile::CalcMaterialFromSlot(i);
if (materialFromSlot != EQ::textures::materialInvalid)
this->SendWearChange(materialFromSlot);
}
}
@@ -5078,18 +5078,18 @@ void Merc::UpdateMercAppearance() {
void Merc::UpdateEquipmentLight()
{
m_Light.Type[EQEmu::lightsource::LightEquipment] = 0;
m_Light.Level[EQEmu::lightsource::LightEquipment] = 0;
m_Light.Type[EQ::lightsource::LightEquipment] = 0;
m_Light.Level[EQ::lightsource::LightEquipment] = 0;
for (int index = EQEmu::invslot::EQUIPMENT_BEGIN; index <= EQEmu::invslot::EQUIPMENT_END; ++index) {
if (index == EQEmu::invslot::slotAmmo) { continue; }
for (int index = EQ::invslot::EQUIPMENT_BEGIN; index <= EQ::invslot::EQUIPMENT_END; ++index) {
if (index == EQ::invslot::slotAmmo) { continue; }
auto item = database.GetItem(equipment[index]);
if (item == nullptr) { continue; }
if (EQEmu::lightsource::IsLevelGreater(item->Light, m_Light.Type[EQEmu::lightsource::LightEquipment])) {
m_Light.Type[EQEmu::lightsource::LightEquipment] = item->Light;
m_Light.Level[EQEmu::lightsource::LightEquipment] = EQEmu::lightsource::TypeToLevel(m_Light.Type[EQEmu::lightsource::LightEquipment]);
if (EQ::lightsource::IsLevelGreater(item->Light, m_Light.Type[EQ::lightsource::LightEquipment])) {
m_Light.Type[EQ::lightsource::LightEquipment] = item->Light;
m_Light.Level[EQ::lightsource::LightEquipment] = EQ::lightsource::TypeToLevel(m_Light.Type[EQ::lightsource::LightEquipment]);
}
}
@@ -5101,14 +5101,14 @@ void Merc::UpdateEquipmentLight()
if (!item->IsClassCommon()) { continue; }
if (item->Light < 9 || item->Light > 13) { continue; }
if (EQEmu::lightsource::TypeToLevel(item->Light))
if (EQ::lightsource::TypeToLevel(item->Light))
general_light_type = item->Light;
}
if (EQEmu::lightsource::IsLevelGreater(general_light_type, m_Light.Type[EQEmu::lightsource::LightEquipment]))
m_Light.Type[EQEmu::lightsource::LightEquipment] = general_light_type;
if (EQ::lightsource::IsLevelGreater(general_light_type, m_Light.Type[EQ::lightsource::LightEquipment]))
m_Light.Type[EQ::lightsource::LightEquipment] = general_light_type;
m_Light.Level[EQEmu::lightsource::LightEquipment] = EQEmu::lightsource::TypeToLevel(m_Light.Type[EQEmu::lightsource::LightEquipment]);
m_Light.Level[EQ::lightsource::LightEquipment] = EQ::lightsource::TypeToLevel(m_Light.Type[EQ::lightsource::LightEquipment]);
}
void Merc::AddItem(uint8 slot, uint32 item_id) {
@@ -5164,109 +5164,109 @@ void Client::SendMercResponsePackets(uint32 ResponseType)
SendMercMerchantResponsePacket(6);
break;
case 7: //You must dismiss your suspended mercenary before purchasing a new one!
if (ClientVersion() < EQEmu::versions::ClientVersion::RoF)
if (ClientVersion() < EQ::versions::ClientVersion::RoF)
SendMercMerchantResponsePacket(7);
else
//You have the maximum number of mercenaries. You must dismiss one before purchasing a new one!
SendMercMerchantResponsePacket(6);
break;
case 8: //You can not purchase a mercenary because your group is full!
if (ClientVersion() < EQEmu::versions::ClientVersion::RoF)
if (ClientVersion() < EQ::versions::ClientVersion::RoF)
SendMercMerchantResponsePacket(8);
else
SendMercMerchantResponsePacket(7);
break;
case 9: //You can not purchase a mercenary because you are in combat!
if (ClientVersion() < EQEmu::versions::ClientVersion::RoF)
if (ClientVersion() < EQ::versions::ClientVersion::RoF)
//Mercenary failed to spawn!
SendMercMerchantResponsePacket(3);
else
SendMercMerchantResponsePacket(8);
break;
case 10: //You have recently dismissed a mercenary and must wait a few more seconds before you can purchase a new one!
if (ClientVersion() < EQEmu::versions::ClientVersion::RoF)
if (ClientVersion() < EQ::versions::ClientVersion::RoF)
//Mercenary failed to spawn!
SendMercMerchantResponsePacket(3);
else
SendMercMerchantResponsePacket(9);
break;
case 11: //An error occurred created your mercenary!
if (ClientVersion() < EQEmu::versions::ClientVersion::RoF)
if (ClientVersion() < EQ::versions::ClientVersion::RoF)
SendMercMerchantResponsePacket(9);
else
SendMercMerchantResponsePacket(10);
break;
case 12: //Upkeep Charge Message
if (ClientVersion() < EQEmu::versions::ClientVersion::RoF)
if (ClientVersion() < EQ::versions::ClientVersion::RoF)
SendMercMerchantResponsePacket(10);
else
SendMercMerchantResponsePacket(11);
break;
case 13: // ???
if (ClientVersion() < EQEmu::versions::ClientVersion::RoF)
if (ClientVersion() < EQ::versions::ClientVersion::RoF)
SendMercMerchantResponsePacket(11);
else
SendMercMerchantResponsePacket(12);
break;
case 14: //You ran out of funds to pay for your mercenary!
if (ClientVersion() < EQEmu::versions::ClientVersion::RoF)
if (ClientVersion() < EQ::versions::ClientVersion::RoF)
SendMercMerchantResponsePacket(12);
else
SendMercMerchantResponsePacket(13);
break;
case 15: // ???
if (ClientVersion() < EQEmu::versions::ClientVersion::RoF)
if (ClientVersion() < EQ::versions::ClientVersion::RoF)
SendMercMerchantResponsePacket(13);
else
SendMercMerchantResponsePacket(14);
break;
case 16: //Your mercenary is about to be suspended due to insufficient funds!
if (ClientVersion() < EQEmu::versions::ClientVersion::RoF)
if (ClientVersion() < EQ::versions::ClientVersion::RoF)
SendMercMerchantResponsePacket(14);
else
SendMercMerchantResponsePacket(15);
break;
case 17: //There is no mercenary liaison nearby!
if (ClientVersion() < EQEmu::versions::ClientVersion::RoF)
if (ClientVersion() < EQ::versions::ClientVersion::RoF)
SendMercMerchantResponsePacket(15);
else
SendMercMerchantResponsePacket(16);
break;
case 18: //You are too far from the liaison!
if (ClientVersion() < EQEmu::versions::ClientVersion::RoF)
if (ClientVersion() < EQ::versions::ClientVersion::RoF)
SendMercMerchantResponsePacket(16);
else
SendMercMerchantResponsePacket(17);
break;
case 19: //You do not meet the requirements for that mercenary!
if (ClientVersion() < EQEmu::versions::ClientVersion::RoF)
if (ClientVersion() < EQ::versions::ClientVersion::RoF)
SendMercMerchantResponsePacket(17);
else
SendMercMerchantResponsePacket(18);
break;
case 20: //You are unable to interact with the liaison!
if (ClientVersion() < EQEmu::versions::ClientVersion::RoF)
if (ClientVersion() < EQ::versions::ClientVersion::RoF)
//You are too far from the liaison!
SendMercMerchantResponsePacket(16);
else
SendMercMerchantResponsePacket(19);
break;
case 21: //You do not have a high enough membership level to purchase this mercenary!
if (ClientVersion() < EQEmu::versions::ClientVersion::RoF)
if (ClientVersion() < EQ::versions::ClientVersion::RoF)
//You do not meet the requirements for that mercenary!
SendMercMerchantResponsePacket(17);
else
SendMercMerchantResponsePacket(20);
break;
case 22: //Your purchase has failed because this mercenary requires a Gold membership!
if (ClientVersion() < EQEmu::versions::ClientVersion::RoF)
if (ClientVersion() < EQ::versions::ClientVersion::RoF)
//You do not meet the requirements for that mercenary!
SendMercMerchantResponsePacket(17);
else
SendMercMerchantResponsePacket(21);
break;
case 23: //Your purchase has failed because this mercenary requires at least a Silver membership!
if (ClientVersion() < EQEmu::versions::ClientVersion::RoF)
if (ClientVersion() < EQ::versions::ClientVersion::RoF)
//You do not meet the requirements for that mercenary!
SendMercMerchantResponsePacket(17);
else
@@ -5649,7 +5649,7 @@ void Client::SpawnMerc(Merc* merc, bool setMaxStats) {
merc->SetSuspended(false);
SetMerc(merc);
merc->Unsuspend(setMaxStats);
merc->SetStance((EQEmu::constants::StanceType)GetMercInfo().Stance);
merc->SetStance((EQ::constants::StanceType)GetMercInfo().Stance);
Log(Logs::General, Logs::Mercenaries, "SpawnMerc Success for %s.", GetName());
@@ -6106,7 +6106,7 @@ void Client::UpdateMercLevel() {
void Client::SendMercMerchantResponsePacket(int32 response_type) {
// This response packet brings up the Mercenary Manager window
if (ClientVersion() >= EQEmu::versions::ClientVersion::SoD)
if (ClientVersion() >= EQ::versions::ClientVersion::SoD)
{
auto outapp = new EQApplicationPacket(OP_MercenaryHire, sizeof(MercenaryMerchantResponse_Struct));
MercenaryMerchantResponse_Struct* mmr = (MercenaryMerchantResponse_Struct*)outapp->pBuffer;
zone/merc.h
+15 -15
View File
@@ -12,7 +12,7 @@ struct MercTemplate;
struct NPCType;
struct NewSpawn_Struct;
namespace EQEmu
namespace EQ
{
struct ItemData;
}
@@ -52,9 +52,9 @@ public:
virtual ~Merc();
//abstract virtual function implementations requird by base abstract class
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, eSpecialAttacks special = eSpecialAttacks::None);
virtual bool Attack(Mob* other, int Hand = EQEmu::invslot::slotPrimary, bool FromRiposte = false, bool IsStrikethrough = false,
virtual bool Death(Mob* killerMob, int32 damage, uint16 spell_id, EQ::skills::SkillType attack_skill);
virtual void Damage(Mob* from, int32 damage, uint16 spell_id, EQ::skills::SkillType attack_skill, bool avoidable = true, int8 buffslot = -1, bool iBuffTic = false, eSpecialAttacks special = eSpecialAttacks::None);
virtual bool Attack(Mob* other, int Hand = EQ::invslot::slotPrimary, bool FromRiposte = false, bool IsStrikethrough = false,
bool IsFromSpell = false, ExtraAttackOptions *opts = nullptr);
virtual bool HasRaid() { return false; }
virtual bool HasGroup() { return (GetGroup() ? true : false); }
@@ -163,16 +163,16 @@ public:
uint8 GetTierID() { return _TierID; }
uint32 GetCostFormula() { return _CostFormula; }
uint32 GetMercNameType() { return _NameType; }
EQEmu::constants::StanceType GetStance() { return _currentStance; }
EQ::constants::StanceType GetStance() { return _currentStance; }
int GetHatedCount() { return _hatedCount; }
inline const uint8 GetClientVersion() const { return _OwnerClientVersion; }
virtual void SetTarget(Mob* mob);
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()); }
bool HasSkill(EQ::skills::SkillType skill_id) const;
bool CanHaveSkill(EQ::skills::SkillType skill_id) const;
uint16 MaxSkill(EQ::skills::SkillType skillid, uint16 class_, uint16 level) const;
inline uint16 MaxSkill(EQ::skills::SkillType skillid) const { return MaxSkill(skillid, GetClass(), GetLevel()); }
virtual void DoClassAttacks(Mob *target);
void CheckHateList();
bool CheckTaunt();
@@ -253,7 +253,7 @@ public:
void SetMercNameType( uint8 nametype ) { _NameType = nametype; }
void SetClientVersion(uint8 clientVersion) { _OwnerClientVersion = clientVersion; }
void SetSuspended(bool suspended) { _suspended = suspended; }
void SetStance( EQEmu::constants::StanceType stance ) { _currentStance = stance; }
void SetStance( EQ::constants::StanceType stance ) { _currentStance = stance; }
void SetHatedCount( int count ) { _hatedCount = count; }
void Sit();
@@ -270,7 +270,7 @@ public:
protected:
void CalcItemBonuses(StatBonuses* newbon);
void AddItemBonuses(const EQEmu::ItemData *item, StatBonuses* newbon);
void AddItemBonuses(const EQ::ItemData *item, StatBonuses* newbon);
int CalcRecommendedLevelBonus(uint8 level, uint8 reclevel, int basestat);
int16 GetFocusEffect(focusType type, uint16 spell_id);
@@ -280,8 +280,8 @@ protected:
Timer evade_timer; // can be moved to pTimers at some point
uint16 skills[EQEmu::skills::HIGHEST_SKILL + 1];
uint32 equipment[EQEmu::invslot::EQUIPMENT_COUNT]; //this is an array of item IDs
uint16 skills[EQ::skills::HIGHEST_SKILL + 1];
uint32 equipment[EQ::invslot::EQUIPMENT_COUNT]; //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)
uint8 prim_melee_type; //Sets the Primary Weapon attack message and animation
@@ -373,9 +373,9 @@ private:
uint8 _CostFormula;
uint8 _NameType;
uint8 _OwnerClientVersion;
EQEmu::constants::StanceType _currentStance;
EQ::constants::StanceType _currentStance;
EQEmu::InventoryProfile m_inv;
EQ::InventoryProfile m_inv;
int32 max_end;
int32 cur_end;
bool _medding;
zone/mob.cpp
+131 -131
View File
@@ -77,7 +77,7 @@ Mob::Mob(
uint32 in_drakkin_heritage,
uint32 in_drakkin_tattoo,
uint32 in_drakkin_details,
EQEmu::TintProfile in_armor_tint,
EQ::TintProfile in_armor_tint,
uint8 in_aa_title,
uint8 in_see_invis, // see through invis/ivu
uint8 in_see_invis_undead,
@@ -199,10 +199,10 @@ Mob::Mob(
runspeed = 1.25f;
}
m_Light.Type[EQEmu::lightsource::LightInnate] = in_light;
m_Light.Level[EQEmu::lightsource::LightInnate] = EQEmu::lightsource::TypeToLevel(m_Light.Type[EQEmu::lightsource::LightInnate]);
m_Light.Type[EQEmu::lightsource::LightActive] = m_Light.Type[EQEmu::lightsource::LightInnate];
m_Light.Level[EQEmu::lightsource::LightActive] = m_Light.Level[EQEmu::lightsource::LightInnate];
m_Light.Type[EQ::lightsource::LightInnate] = in_light;
m_Light.Level[EQ::lightsource::LightInnate] = EQ::lightsource::TypeToLevel(m_Light.Type[EQ::lightsource::LightInnate]);
m_Light.Type[EQ::lightsource::LightActive] = m_Light.Type[EQ::lightsource::LightInnate];
m_Light.Level[EQ::lightsource::LightActive] = m_Light.Level[EQ::lightsource::LightInnate];
texture = in_texture;
helmtexture = in_helmtexture;
@@ -300,7 +300,7 @@ Mob::Mob(
RangedProcs[j].level_override = -1;
}
for (int i = EQEmu::textures::textureBegin; i < EQEmu::textures::materialCount; i++) {
for (int i = EQ::textures::textureBegin; i < EQ::textures::materialCount; i++) {
armor_tint.Slot[i].Color = in_armor_tint.Slot[i].Color;
}
@@ -444,7 +444,7 @@ Mob::Mob(
m_AllowBeneficial = false;
m_DisableMelee = false;
for (int i = 0; i < EQEmu::skills::HIGHEST_SKILL + 2; i++) {
for (int i = 0; i < EQ::skills::HIGHEST_SKILL + 2; i++) {
SkillDmgTaken_Mod[i] = 0;
}
@@ -1147,7 +1147,7 @@ void Mob::FillSpawnStruct(NewSpawn_Struct* ns, Mob* ForWho)
ns->spawn.findable = findable?1:0;
UpdateActiveLight();
ns->spawn.light = m_Light.Type[EQEmu::lightsource::LightActive];
ns->spawn.light = m_Light.Type[EQ::lightsource::LightActive];
if (IsNPC() && race == ERUDITE)
ns->spawn.showhelm = 1;
@@ -1363,7 +1363,7 @@ void Mob::SendHPUpdate(bool skip_self /*= false*/, bool force_update_all /*= fal
(skip_self ? "true" : "false")
);
if (!skip_self || this->CastToClient()->ClientVersion() >= EQEmu::versions::ClientVersion::SoD) {
if (!skip_self || this->CastToClient()->ClientVersion() >= EQ::versions::ClientVersion::SoD) {
auto client_packet = new EQApplicationPacket(OP_HPUpdate, sizeof(SpawnHPUpdate_Struct));
auto *hp_packet_client = (SpawnHPUpdate_Struct *) client_packet->pBuffer;
@@ -1419,7 +1419,7 @@ void Mob::SendHPUpdate(bool skip_self /*= false*/, bool force_update_all /*= fal
/**
* Update those who have us targeted
*/
entity_list.QueueClientsByTarget(this, &hp_packet, false, 0, false, true, EQEmu::versions::maskAllClients);
entity_list.QueueClientsByTarget(this, &hp_packet, false, 0, false, true, EQ::versions::maskAllClients);
/**
* Update those who have us on x-target
@@ -1639,9 +1639,9 @@ void Mob::ShowStats(Client* client)
client->Message(Chat::White, " AggroRange: %1.0f AssistRange: %1.0f", GetAggroRange(), GetAssistRange());
}
client->Message(Chat::White, " compute_tohit: %i TotalToHit: %i", compute_tohit(EQEmu::skills::SkillHandtoHand), GetTotalToHit(EQEmu::skills::SkillHandtoHand, 0));
client->Message(Chat::White, " compute_tohit: %i TotalToHit: %i", compute_tohit(EQ::skills::SkillHandtoHand), GetTotalToHit(EQ::skills::SkillHandtoHand, 0));
client->Message(Chat::White, " compute_defense: %i TotalDefense: %i", compute_defense(), GetTotalDefense());
client->Message(Chat::White, " offense: %i mitigation ac: %i", offense(EQEmu::skills::SkillHandtoHand), GetMitigationAC());
client->Message(Chat::White, " offense: %i mitigation ac: %i", offense(EQ::skills::SkillHandtoHand), GetMitigationAC());
}
}
@@ -2368,18 +2368,18 @@ void Mob::SetAppearance(EmuAppearance app, bool iIgnoreSelf) {
bool Mob::UpdateActiveLight()
{
uint8 old_light_level = m_Light.Level[EQEmu::lightsource::LightActive];
uint8 old_light_level = m_Light.Level[EQ::lightsource::LightActive];
m_Light.Type[EQEmu::lightsource::LightActive] = 0;
m_Light.Level[EQEmu::lightsource::LightActive] = 0;
m_Light.Type[EQ::lightsource::LightActive] = 0;
m_Light.Level[EQ::lightsource::LightActive] = 0;
if (EQEmu::lightsource::IsLevelGreater((m_Light.Type[EQEmu::lightsource::LightInnate] & 0x0F), m_Light.Type[EQEmu::lightsource::LightActive])) { m_Light.Type[EQEmu::lightsource::LightActive] = m_Light.Type[EQEmu::lightsource::LightInnate]; }
if (m_Light.Level[EQEmu::lightsource::LightEquipment] > m_Light.Level[EQEmu::lightsource::LightActive]) { m_Light.Type[EQEmu::lightsource::LightActive] = m_Light.Type[EQEmu::lightsource::LightEquipment]; } // limiter in property handler
if (m_Light.Level[EQEmu::lightsource::LightSpell] > m_Light.Level[EQEmu::lightsource::LightActive]) { m_Light.Type[EQEmu::lightsource::LightActive] = m_Light.Type[EQEmu::lightsource::LightSpell]; } // limiter in property handler
if (EQ::lightsource::IsLevelGreater((m_Light.Type[EQ::lightsource::LightInnate] & 0x0F), m_Light.Type[EQ::lightsource::LightActive])) { m_Light.Type[EQ::lightsource::LightActive] = m_Light.Type[EQ::lightsource::LightInnate]; }
if (m_Light.Level[EQ::lightsource::LightEquipment] > m_Light.Level[EQ::lightsource::LightActive]) { m_Light.Type[EQ::lightsource::LightActive] = m_Light.Type[EQ::lightsource::LightEquipment]; } // limiter in property handler
if (m_Light.Level[EQ::lightsource::LightSpell] > m_Light.Level[EQ::lightsource::LightActive]) { m_Light.Type[EQ::lightsource::LightActive] = m_Light.Type[EQ::lightsource::LightSpell]; } // limiter in property handler
m_Light.Level[EQEmu::lightsource::LightActive] = EQEmu::lightsource::TypeToLevel(m_Light.Type[EQEmu::lightsource::LightActive]);
m_Light.Level[EQ::lightsource::LightActive] = EQ::lightsource::TypeToLevel(m_Light.Type[EQ::lightsource::LightActive]);
return (m_Light.Level[EQEmu::lightsource::LightActive] != old_light_level);
return (m_Light.Level[EQ::lightsource::LightActive] != old_light_level);
}
void Mob::ChangeSize(float in_size = 0, bool bNoRestriction) {
@@ -2511,20 +2511,20 @@ void Mob::SetZone(uint32 zone_id, uint32 instance_id)
}
void Mob::Kill() {
Death(this, 0, SPELL_UNKNOWN, EQEmu::skills::SkillHandtoHand);
Death(this, 0, SPELL_UNKNOWN, EQ::skills::SkillHandtoHand);
}
bool Mob::CanThisClassDualWield(void) const {
if(!IsClient()) {
return(GetSkill(EQEmu::skills::SkillDualWield) > 0);
return(GetSkill(EQ::skills::SkillDualWield) > 0);
}
else if (CastToClient()->HasSkill(EQEmu::skills::SkillDualWield)) {
const EQEmu::ItemInstance* pinst = CastToClient()->GetInv().GetItem(EQEmu::invslot::slotPrimary);
const EQEmu::ItemInstance* sinst = CastToClient()->GetInv().GetItem(EQEmu::invslot::slotSecondary);
else if (CastToClient()->HasSkill(EQ::skills::SkillDualWield)) {
const EQ::ItemInstance* pinst = CastToClient()->GetInv().GetItem(EQ::invslot::slotPrimary);
const EQ::ItemInstance* sinst = CastToClient()->GetInv().GetItem(EQ::invslot::slotSecondary);
// 2HS, 2HB, or 2HP
if(pinst && pinst->IsWeapon()) {
const EQEmu::ItemData* item = pinst->GetItem();
const EQ::ItemData* item = pinst->GetItem();
if (item->IsType2HWeapon())
return false;
@@ -2548,12 +2548,12 @@ bool Mob::CanThisClassDualWield(void) const {
bool Mob::CanThisClassDoubleAttack(void) const
{
if(!IsClient()) {
return(GetSkill(EQEmu::skills::SkillDoubleAttack) > 0);
return(GetSkill(EQ::skills::SkillDoubleAttack) > 0);
} else {
if(aabonuses.GiveDoubleAttack || itembonuses.GiveDoubleAttack || spellbonuses.GiveDoubleAttack) {
return true;
}
return(CastToClient()->HasSkill(EQEmu::skills::SkillDoubleAttack));
return(CastToClient()->HasSkill(EQ::skills::SkillDoubleAttack));
}
}
@@ -2562,7 +2562,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(EQEmu::skills::SkillTripleAttack);
return CastToClient()->HasSkill(EQ::skills::SkillTripleAttack);
}
bool Mob::IsWarriorClass(void) const
@@ -2601,36 +2601,36 @@ bool Mob::IsWarriorClass(void) const
bool Mob::CanThisClassParry(void) const
{
if(!IsClient()) {
return(GetSkill(EQEmu::skills::SkillParry) > 0);
return(GetSkill(EQ::skills::SkillParry) > 0);
} else {
return(CastToClient()->HasSkill(EQEmu::skills::SkillParry));
return(CastToClient()->HasSkill(EQ::skills::SkillParry));
}
}
bool Mob::CanThisClassDodge(void) const
{
if(!IsClient()) {
return(GetSkill(EQEmu::skills::SkillDodge) > 0);
return(GetSkill(EQ::skills::SkillDodge) > 0);
} else {
return(CastToClient()->HasSkill(EQEmu::skills::SkillDodge));
return(CastToClient()->HasSkill(EQ::skills::SkillDodge));
}
}
bool Mob::CanThisClassRiposte(void) const
{
if(!IsClient()) {
return(GetSkill(EQEmu::skills::SkillRiposte) > 0);
return(GetSkill(EQ::skills::SkillRiposte) > 0);
} else {
return(CastToClient()->HasSkill(EQEmu::skills::SkillRiposte));
return(CastToClient()->HasSkill(EQ::skills::SkillRiposte));
}
}
bool Mob::CanThisClassBlock(void) const
{
if(!IsClient()) {
return(GetSkill(EQEmu::skills::SkillBlock) > 0);
return(GetSkill(EQ::skills::SkillBlock) > 0);
} else {
return(CastToClient()->HasSkill(EQEmu::skills::SkillBlock));
return(CastToClient()->HasSkill(EQ::skills::SkillBlock));
}
}
/*
@@ -2881,7 +2881,7 @@ uint32 Mob::RandomTimer(int min, int max)
uint32 Mob::IsEliteMaterialItem(uint8 material_slot) const
{
const EQEmu::ItemData *item = nullptr;
const EQ::ItemData *item = nullptr;
item = database.GetItem(GetEquippedItemFromTextureSlot(material_slot));
if(item != 0)
@@ -3111,7 +3111,7 @@ int32 Mob::GetActSpellCasttime(uint16 spell_id, int32 casttime) {
return casttime;
}
void Mob::ExecWeaponProc(const EQEmu::ItemInstance *inst, uint16 spell_id, Mob *on, int level_override) {
void Mob::ExecWeaponProc(const EQ::ItemInstance *inst, uint16 spell_id, Mob *on, int level_override) {
// Changed proc targets to look up based on the spells goodEffect flag.
// This should work for the majority of weapons.
if(spell_id == SPELL_UNKNOWN || on->GetSpecialAbility(NO_HARM_FROM_CLIENT)) {
@@ -3132,9 +3132,9 @@ void Mob::ExecWeaponProc(const EQEmu::ItemInstance *inst, uint16 spell_id, Mob *
if(inst && IsClient()) {
//const cast is dirty but it would require redoing a ton of interfaces at this point
//It should be safe as we don't have any truly const EQEmu::ItemInstance floating around anywhere.
//It should be safe as we don't have any truly const EQ::ItemInstance floating around anywhere.
//So we'll live with it for now
int i = parse->EventItem(EVENT_WEAPON_PROC, CastToClient(), const_cast<EQEmu::ItemInstance*>(inst), on, "", spell_id);
int i = parse->EventItem(EVENT_WEAPON_PROC, CastToClient(), const_cast<EQ::ItemInstance*>(inst), on, "", spell_id);
if(i != 0) {
return;
}
@@ -3150,12 +3150,12 @@ void Mob::ExecWeaponProc(const EQEmu::ItemInstance *inst, uint16 spell_id, Mob *
twinproc = true;
if (IsBeneficialSpell(spell_id) && (!IsNPC() || (IsNPC() && CastToNPC()->GetInnateProcSpellID() != spell_id))) { // NPC innate procs don't take this path ever
SpellFinished(spell_id, this, EQEmu::spells::CastingSlot::Item, 0, -1, spells[spell_id].ResistDiff, true, level_override);
SpellFinished(spell_id, this, EQ::spells::CastingSlot::Item, 0, -1, spells[spell_id].ResistDiff, true, level_override);
if(twinproc)
SpellOnTarget(spell_id, this, false, false, 0, true, level_override);
}
else if(!(on->IsClient() && on->CastToClient()->dead)) { //dont proc on dead clients
SpellFinished(spell_id, on, EQEmu::spells::CastingSlot::Item, 0, -1, spells[spell_id].ResistDiff, true, level_override);
SpellFinished(spell_id, on, EQ::spells::CastingSlot::Item, 0, -1, spells[spell_id].ResistDiff, true, level_override);
if(twinproc)
SpellOnTarget(spell_id, on, false, false, 0, true, level_override);
}
@@ -3368,19 +3368,19 @@ void Mob::TriggerDefensiveProcs(Mob *on, uint16 hand, bool FromSkillProc, int da
uint16 skillinuse = 0;
switch (damage) {
case (-1):
skillinuse = EQEmu::skills::SkillBlock;
skillinuse = EQ::skills::SkillBlock;
break;
case (-2):
skillinuse = EQEmu::skills::SkillParry;
skillinuse = EQ::skills::SkillParry;
break;
case (-3):
skillinuse = EQEmu::skills::SkillRiposte;
skillinuse = EQ::skills::SkillRiposte;
break;
case (-4):
skillinuse = EQEmu::skills::SkillDodge;
skillinuse = EQ::skills::SkillDodge;
break;
}
@@ -3496,7 +3496,7 @@ void Mob::TriggerOnCast(uint32 focus_spell, uint32 spell_id, bool aa_trigger)
trigger_spell_id = CastToClient()->CalcAAFocus(focusTriggerOnCast, *rank, spell_id);
if (IsValidSpell(trigger_spell_id) && GetTarget())
SpellFinished(trigger_spell_id, GetTarget(), EQEmu::spells::CastingSlot::Item, 0, -1,
SpellFinished(trigger_spell_id, GetTarget(), EQ::spells::CastingSlot::Item, 0, -1,
spells[trigger_spell_id].ResistDiff);
}
@@ -3504,7 +3504,7 @@ void Mob::TriggerOnCast(uint32 focus_spell, uint32 spell_id, bool aa_trigger)
trigger_spell_id = CalcFocusEffect(focusTriggerOnCast, focus_spell, spell_id);
if (IsValidSpell(trigger_spell_id) && GetTarget()) {
SpellFinished(trigger_spell_id, GetTarget(), EQEmu::spells::CastingSlot::Item, 0, -1,
SpellFinished(trigger_spell_id, GetTarget(), EQ::spells::CastingSlot::Item, 0, -1,
spells[trigger_spell_id].ResistDiff);
CheckNumHitsRemaining(NumHit::MatchingSpells, -1, focus_spell);
}
@@ -3535,7 +3535,7 @@ bool Mob::TrySpellTrigger(Mob *target, uint32 spell_id, int effect)
{
// If we trigger an effect then its over.
if (IsValidSpell(spells[spell_id].base2[i])){
SpellFinished(spells[spell_id].base2[i], target, EQEmu::spells::CastingSlot::Item, 0, -1, spells[spells[spell_id].base2[i]].ResistDiff);
SpellFinished(spells[spell_id].base2[i], target, EQ::spells::CastingSlot::Item, 0, -1, spells[spells[spell_id].base2[i]].ResistDiff);
return true;
}
}
@@ -3554,7 +3554,7 @@ bool Mob::TrySpellTrigger(Mob *target, uint32 spell_id, int effect)
if(zone->random.Int(0, 100) <= spells[spell_id].base[effect])
{
if (IsValidSpell(spells[spell_id].base2[effect])){
SpellFinished(spells[spell_id].base2[effect], target, EQEmu::spells::CastingSlot::Item, 0, -1, spells[spells[spell_id].base2[effect]].ResistDiff);
SpellFinished(spells[spell_id].base2[effect], target, EQ::spells::CastingSlot::Item, 0, -1, spells[spells[spell_id].base2[effect]].ResistDiff);
return true; //Only trigger once of these per spell effect.
}
}
@@ -3631,7 +3631,7 @@ void Mob::TryTriggerOnValueAmount(bool IsHP, bool IsMana, bool IsEndur, bool IsP
}
if (use_spell){
SpellFinished(spells[spell_id].base[i], this, EQEmu::spells::CastingSlot::Item, 0, -1, spells[spell_id].ResistDiff);
SpellFinished(spells[spell_id].base[i], this, EQ::spells::CastingSlot::Item, 0, -1, spells[spell_id].ResistDiff);
if(!TryFadeEffect(e))
BuffFadeBySlot(e);
@@ -3659,7 +3659,7 @@ void Mob::TryTwincast(Mob *caster, Mob *target, uint32 spell_id)
if(zone->random.Roll(focus))
{
Message(Chat::Spells,"You twincast %s!", spells[spell_id].name);
SpellFinished(spell_id, target, EQEmu::spells::CastingSlot::Item, 0, -1, spells[spell_id].ResistDiff);
SpellFinished(spell_id, target, EQ::spells::CastingSlot::Item, 0, -1, spells[spell_id].ResistDiff);
}
}
}
@@ -3677,7 +3677,7 @@ void Mob::TryTwincast(Mob *caster, Mob *target, uint32 spell_id)
{
if(zone->random.Roll(focus))
{
SpellFinished(spell_id, target, EQEmu::spells::CastingSlot::Item, 0, -1, spells[spell_id].ResistDiff);
SpellFinished(spell_id, target, EQ::spells::CastingSlot::Item, 0, -1, spells[spell_id].ResistDiff);
}
}
}
@@ -3745,15 +3745,15 @@ int32 Mob::GetVulnerability(Mob* caster, uint32 spell_id, uint32 ticsremaining)
return value;
}
int16 Mob::GetSkillDmgTaken(const EQEmu::skills::SkillType skill_used, ExtraAttackOptions *opts)
int16 Mob::GetSkillDmgTaken(const EQ::skills::SkillType skill_used, ExtraAttackOptions *opts)
{
int skilldmg_mod = 0;
// All skill dmg mod + Skill specific
skilldmg_mod += itembonuses.SkillDmgTaken[EQEmu::skills::HIGHEST_SKILL + 1] + spellbonuses.SkillDmgTaken[EQEmu::skills::HIGHEST_SKILL + 1] +
skilldmg_mod += itembonuses.SkillDmgTaken[EQ::skills::HIGHEST_SKILL + 1] + spellbonuses.SkillDmgTaken[EQ::skills::HIGHEST_SKILL + 1] +
itembonuses.SkillDmgTaken[skill_used] + spellbonuses.SkillDmgTaken[skill_used];
skilldmg_mod += SkillDmgTaken_Mod[skill_used] + SkillDmgTaken_Mod[EQEmu::skills::HIGHEST_SKILL + 1];
skilldmg_mod += SkillDmgTaken_Mod[skill_used] + SkillDmgTaken_Mod[EQ::skills::HIGHEST_SKILL + 1];
if (opts)
skilldmg_mod += opts->skilldmgtaken_bonus_flat;
@@ -3805,10 +3805,10 @@ bool Mob::TryFadeEffect(int slot)
if(IsValidSpell(spell_id))
{
if (IsBeneficialSpell(spell_id)) {
SpellFinished(spell_id, this, EQEmu::spells::CastingSlot::Item, 0, -1, spells[spell_id].ResistDiff);
SpellFinished(spell_id, this, EQ::spells::CastingSlot::Item, 0, -1, spells[spell_id].ResistDiff);
}
else if(!(IsClient() && CastToClient()->dead)) {
SpellFinished(spell_id, this, EQEmu::spells::CastingSlot::Item, 0, -1, spells[spell_id].ResistDiff);
SpellFinished(spell_id, this, EQ::spells::CastingSlot::Item, 0, -1, spells[spell_id].ResistDiff);
}
return true;
}
@@ -3842,7 +3842,7 @@ void Mob::TrySympatheticProc(Mob *target, uint32 spell_id)
SpellFinished(focus_trigger, target);
else
SpellFinished(focus_trigger, this, EQEmu::spells::CastingSlot::Item, 0, -1, spells[focus_trigger].ResistDiff);
SpellFinished(focus_trigger, this, EQ::spells::CastingSlot::Item, 0, -1, spells[focus_trigger].ResistDiff);
}
// For detrimental spells, if the triggered spell is beneficial, then it will land on the caster
// if the triggered spell is also detrimental, then it will land on the target
@@ -3852,7 +3852,7 @@ void Mob::TrySympatheticProc(Mob *target, uint32 spell_id)
SpellFinished(focus_trigger, this);
else
SpellFinished(focus_trigger, target, EQEmu::spells::CastingSlot::Item, 0, -1, spells[focus_trigger].ResistDiff);
SpellFinished(focus_trigger, target, EQ::spells::CastingSlot::Item, 0, -1, spells[focus_trigger].ResistDiff);
}
CheckNumHitsRemaining(NumHit::MatchingSpells, -1, focus_spell);
@@ -3860,11 +3860,11 @@ void Mob::TrySympatheticProc(Mob *target, uint32 spell_id)
int32 Mob::GetItemStat(uint32 itemid, const char *identifier)
{
const EQEmu::ItemInstance* inst = database.CreateItem(itemid);
const EQ::ItemInstance* inst = database.CreateItem(itemid);
if (!inst)
return 0;
const EQEmu::ItemData* item = inst->GetItem();
const EQ::ItemData* item = inst->GetItem();
if (!item)
return 0;
@@ -4502,7 +4502,7 @@ void Mob::TrySpellOnKill(uint8 level, uint16 spell_id)
if (IsValidSpell(spells[spell_id].base2[i]) && spells[spell_id].max[i] <= level)
{
if(zone->random.Roll(spells[spell_id].base[i]))
SpellFinished(spells[spell_id].base2[i], this, EQEmu::spells::CastingSlot::Item, 0, -1, spells[spells[spell_id].base2[i]].ResistDiff);
SpellFinished(spells[spell_id].base2[i], this, EQ::spells::CastingSlot::Item, 0, -1, spells[spells[spell_id].base2[i]].ResistDiff);
}
}
}
@@ -4517,17 +4517,17 @@ void Mob::TrySpellOnKill(uint8 level, uint16 spell_id)
if(aabonuses.SpellOnKill[i] && IsValidSpell(aabonuses.SpellOnKill[i]) && (level >= aabonuses.SpellOnKill[i + 2])) {
if(zone->random.Roll(static_cast<int>(aabonuses.SpellOnKill[i + 1])))
SpellFinished(aabonuses.SpellOnKill[i], this, EQEmu::spells::CastingSlot::Item, 0, -1, spells[aabonuses.SpellOnKill[i]].ResistDiff);
SpellFinished(aabonuses.SpellOnKill[i], this, EQ::spells::CastingSlot::Item, 0, -1, spells[aabonuses.SpellOnKill[i]].ResistDiff);
}
if(itembonuses.SpellOnKill[i] && IsValidSpell(itembonuses.SpellOnKill[i]) && (level >= itembonuses.SpellOnKill[i + 2])){
if(zone->random.Roll(static_cast<int>(itembonuses.SpellOnKill[i + 1])))
SpellFinished(itembonuses.SpellOnKill[i], this, EQEmu::spells::CastingSlot::Item, 0, -1, spells[aabonuses.SpellOnKill[i]].ResistDiff);
SpellFinished(itembonuses.SpellOnKill[i], this, EQ::spells::CastingSlot::Item, 0, -1, spells[aabonuses.SpellOnKill[i]].ResistDiff);
}
if(spellbonuses.SpellOnKill[i] && IsValidSpell(spellbonuses.SpellOnKill[i]) && (level >= spellbonuses.SpellOnKill[i + 2])) {
if(zone->random.Roll(static_cast<int>(spellbonuses.SpellOnKill[i + 1])))
SpellFinished(spellbonuses.SpellOnKill[i], this, EQEmu::spells::CastingSlot::Item, 0, -1, spells[aabonuses.SpellOnKill[i]].ResistDiff);
SpellFinished(spellbonuses.SpellOnKill[i], this, EQ::spells::CastingSlot::Item, 0, -1, spells[aabonuses.SpellOnKill[i]].ResistDiff);
}
}
@@ -4544,19 +4544,19 @@ bool Mob::TrySpellOnDeath()
for(int i = 0; i < MAX_SPELL_TRIGGER*2; i+=2) {
if(IsClient() && aabonuses.SpellOnDeath[i] && IsValidSpell(aabonuses.SpellOnDeath[i])) {
if(zone->random.Roll(static_cast<int>(aabonuses.SpellOnDeath[i + 1]))) {
SpellFinished(aabonuses.SpellOnDeath[i], this, EQEmu::spells::CastingSlot::Item, 0, -1, spells[aabonuses.SpellOnDeath[i]].ResistDiff);
SpellFinished(aabonuses.SpellOnDeath[i], this, EQ::spells::CastingSlot::Item, 0, -1, spells[aabonuses.SpellOnDeath[i]].ResistDiff);
}
}
if(itembonuses.SpellOnDeath[i] && IsValidSpell(itembonuses.SpellOnDeath[i])) {
if(zone->random.Roll(static_cast<int>(itembonuses.SpellOnDeath[i + 1]))) {
SpellFinished(itembonuses.SpellOnDeath[i], this, EQEmu::spells::CastingSlot::Item, 0, -1, spells[itembonuses.SpellOnDeath[i]].ResistDiff);
SpellFinished(itembonuses.SpellOnDeath[i], this, EQ::spells::CastingSlot::Item, 0, -1, spells[itembonuses.SpellOnDeath[i]].ResistDiff);
}
}
if(spellbonuses.SpellOnDeath[i] && IsValidSpell(spellbonuses.SpellOnDeath[i])) {
if(zone->random.Roll(static_cast<int>(spellbonuses.SpellOnDeath[i + 1]))) {
SpellFinished(spellbonuses.SpellOnDeath[i], this, EQEmu::spells::CastingSlot::Item, 0, -1, spells[spellbonuses.SpellOnDeath[i]].ResistDiff);
SpellFinished(spellbonuses.SpellOnDeath[i], this, EQ::spells::CastingSlot::Item, 0, -1, spells[spellbonuses.SpellOnDeath[i]].ResistDiff);
}
}
}
@@ -4573,7 +4573,7 @@ int16 Mob::GetCritDmgMod(uint16 skill)
int critDmg_mod = 0;
// All skill dmg mod + Skill specific
critDmg_mod += itembonuses.CritDmgMod[EQEmu::skills::HIGHEST_SKILL + 1] + spellbonuses.CritDmgMod[EQEmu::skills::HIGHEST_SKILL + 1] + aabonuses.CritDmgMod[EQEmu::skills::HIGHEST_SKILL + 1] +
critDmg_mod += itembonuses.CritDmgMod[EQ::skills::HIGHEST_SKILL + 1] + spellbonuses.CritDmgMod[EQ::skills::HIGHEST_SKILL + 1] + aabonuses.CritDmgMod[EQ::skills::HIGHEST_SKILL + 1] +
itembonuses.CritDmgMod[skill] + spellbonuses.CritDmgMod[skill] + aabonuses.CritDmgMod[skill];
return critDmg_mod;
@@ -4615,7 +4615,7 @@ int Mob::GetCriticalChanceBonus(uint16 skill)
int critical_chance = 0;
// All skills + Skill specific
critical_chance += itembonuses.CriticalHitChance[EQEmu::skills::HIGHEST_SKILL + 1] + spellbonuses.CriticalHitChance[EQEmu::skills::HIGHEST_SKILL + 1] + aabonuses.CriticalHitChance[EQEmu::skills::HIGHEST_SKILL + 1] +
critical_chance += itembonuses.CriticalHitChance[EQ::skills::HIGHEST_SKILL + 1] + spellbonuses.CriticalHitChance[EQ::skills::HIGHEST_SKILL + 1] + aabonuses.CriticalHitChance[EQ::skills::HIGHEST_SKILL + 1] +
itembonuses.CriticalHitChance[skill] + spellbonuses.CriticalHitChance[skill] + aabonuses.CriticalHitChance[skill];
if(critical_chance < -100)
@@ -4629,10 +4629,10 @@ int16 Mob::GetMeleeDamageMod_SE(uint16 skill)
int dmg_mod = 0;
// All skill dmg mod + Skill specific
dmg_mod += itembonuses.DamageModifier[EQEmu::skills::HIGHEST_SKILL + 1] + spellbonuses.DamageModifier[EQEmu::skills::HIGHEST_SKILL + 1] + aabonuses.DamageModifier[EQEmu::skills::HIGHEST_SKILL + 1] +
dmg_mod += itembonuses.DamageModifier[EQ::skills::HIGHEST_SKILL + 1] + spellbonuses.DamageModifier[EQ::skills::HIGHEST_SKILL + 1] + aabonuses.DamageModifier[EQ::skills::HIGHEST_SKILL + 1] +
itembonuses.DamageModifier[skill] + spellbonuses.DamageModifier[skill] + aabonuses.DamageModifier[skill];
dmg_mod += itembonuses.DamageModifier2[EQEmu::skills::HIGHEST_SKILL + 1] + spellbonuses.DamageModifier2[EQEmu::skills::HIGHEST_SKILL + 1] + aabonuses.DamageModifier2[EQEmu::skills::HIGHEST_SKILL + 1] +
dmg_mod += itembonuses.DamageModifier2[EQ::skills::HIGHEST_SKILL + 1] + spellbonuses.DamageModifier2[EQ::skills::HIGHEST_SKILL + 1] + aabonuses.DamageModifier2[EQ::skills::HIGHEST_SKILL + 1] +
itembonuses.DamageModifier2[skill] + spellbonuses.DamageModifier2[skill] + aabonuses.DamageModifier2[skill];
if(dmg_mod < -100)
@@ -4646,7 +4646,7 @@ int16 Mob::GetMeleeMinDamageMod_SE(uint16 skill)
int dmg_mod = 0;
dmg_mod = itembonuses.MinDamageModifier[skill] + spellbonuses.MinDamageModifier[skill] +
itembonuses.MinDamageModifier[EQEmu::skills::HIGHEST_SKILL + 1] + spellbonuses.MinDamageModifier[EQEmu::skills::HIGHEST_SKILL + 1];
itembonuses.MinDamageModifier[EQ::skills::HIGHEST_SKILL + 1] + spellbonuses.MinDamageModifier[EQ::skills::HIGHEST_SKILL + 1];
if(dmg_mod < -100)
dmg_mod = -100;
@@ -4678,10 +4678,10 @@ int16 Mob::GetSkillDmgAmt(uint16 skill)
int skill_dmg = 0;
// All skill dmg(only spells do this) + Skill specific
skill_dmg += spellbonuses.SkillDamageAmount[EQEmu::skills::HIGHEST_SKILL + 1] + itembonuses.SkillDamageAmount[EQEmu::skills::HIGHEST_SKILL + 1] + aabonuses.SkillDamageAmount[EQEmu::skills::HIGHEST_SKILL + 1]
skill_dmg += spellbonuses.SkillDamageAmount[EQ::skills::HIGHEST_SKILL + 1] + itembonuses.SkillDamageAmount[EQ::skills::HIGHEST_SKILL + 1] + aabonuses.SkillDamageAmount[EQ::skills::HIGHEST_SKILL + 1]
+ itembonuses.SkillDamageAmount[skill] + spellbonuses.SkillDamageAmount[skill] + aabonuses.SkillDamageAmount[skill];
skill_dmg += spellbonuses.SkillDamageAmount2[EQEmu::skills::HIGHEST_SKILL + 1] + itembonuses.SkillDamageAmount2[EQEmu::skills::HIGHEST_SKILL + 1]
skill_dmg += spellbonuses.SkillDamageAmount2[EQ::skills::HIGHEST_SKILL + 1] + itembonuses.SkillDamageAmount2[EQ::skills::HIGHEST_SKILL + 1]
+ itembonuses.SkillDamageAmount2[skill] + spellbonuses.SkillDamageAmount2[skill];
return skill_dmg;
@@ -4701,7 +4701,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, EQEmu::skills::SkillEvocation, false); //Dmg self for modified damage amount.
Damage(this, -lifetap_amt, 0, EQ::skills::SkillEvocation, false); //Dmg self for modified damage amount.
}
}
@@ -4904,21 +4904,21 @@ void Mob::SetBodyType(bodyType new_body, bool overwrite_orig) {
}
void Mob::ModSkillDmgTaken(EQEmu::skills::SkillType skill_num, int value)
void Mob::ModSkillDmgTaken(EQ::skills::SkillType skill_num, int value)
{
if (skill_num == ALL_SKILLS)
SkillDmgTaken_Mod[EQEmu::skills::HIGHEST_SKILL + 1] = value;
SkillDmgTaken_Mod[EQ::skills::HIGHEST_SKILL + 1] = value;
else if (skill_num >= 0 && skill_num <= EQEmu::skills::HIGHEST_SKILL)
else if (skill_num >= 0 && skill_num <= EQ::skills::HIGHEST_SKILL)
SkillDmgTaken_Mod[skill_num] = value;
}
int16 Mob::GetModSkillDmgTaken(const EQEmu::skills::SkillType skill_num)
int16 Mob::GetModSkillDmgTaken(const EQ::skills::SkillType skill_num)
{
if (skill_num == ALL_SKILLS)
return SkillDmgTaken_Mod[EQEmu::skills::HIGHEST_SKILL + 1];
return SkillDmgTaken_Mod[EQ::skills::HIGHEST_SKILL + 1];
else if (skill_num >= 0 && skill_num <= EQEmu::skills::HIGHEST_SKILL)
else if (skill_num >= 0 && skill_num <= EQ::skills::HIGHEST_SKILL)
return SkillDmgTaken_Mod[skill_num];
return 0;
@@ -5010,56 +5010,56 @@ void Mob::SlowMitigation(Mob* caster)
uint16 Mob::GetSkillByItemType(int ItemType)
{
switch (ItemType) {
case EQEmu::item::ItemType1HSlash:
return EQEmu::skills::Skill1HSlashing;
case EQEmu::item::ItemType2HSlash:
return EQEmu::skills::Skill2HSlashing;
case EQEmu::item::ItemType1HPiercing:
return EQEmu::skills::Skill1HPiercing;
case EQEmu::item::ItemType1HBlunt:
return EQEmu::skills::Skill1HBlunt;
case EQEmu::item::ItemType2HBlunt:
return EQEmu::skills::Skill2HBlunt;
case EQEmu::item::ItemType2HPiercing:
if (IsClient() && CastToClient()->ClientVersion() < EQEmu::versions::ClientVersion::RoF2)
return EQEmu::skills::Skill1HPiercing;
case EQ::item::ItemType1HSlash:
return EQ::skills::Skill1HSlashing;
case EQ::item::ItemType2HSlash:
return EQ::skills::Skill2HSlashing;
case EQ::item::ItemType1HPiercing:
return EQ::skills::Skill1HPiercing;
case EQ::item::ItemType1HBlunt:
return EQ::skills::Skill1HBlunt;
case EQ::item::ItemType2HBlunt:
return EQ::skills::Skill2HBlunt;
case EQ::item::ItemType2HPiercing:
if (IsClient() && CastToClient()->ClientVersion() < EQ::versions::ClientVersion::RoF2)
return EQ::skills::Skill1HPiercing;
else
return EQEmu::skills::Skill2HPiercing;
case EQEmu::item::ItemTypeBow:
return EQEmu::skills::SkillArchery;
case EQEmu::item::ItemTypeLargeThrowing:
case EQEmu::item::ItemTypeSmallThrowing:
return EQEmu::skills::SkillThrowing;
case EQEmu::item::ItemTypeMartial:
return EQEmu::skills::SkillHandtoHand;
return EQ::skills::Skill2HPiercing;
case EQ::item::ItemTypeBow:
return EQ::skills::SkillArchery;
case EQ::item::ItemTypeLargeThrowing:
case EQ::item::ItemTypeSmallThrowing:
return EQ::skills::SkillThrowing;
case EQ::item::ItemTypeMartial:
return EQ::skills::SkillHandtoHand;
default:
return EQEmu::skills::SkillHandtoHand;
return EQ::skills::SkillHandtoHand;
}
}
uint8 Mob::GetItemTypeBySkill(EQEmu::skills::SkillType skill)
uint8 Mob::GetItemTypeBySkill(EQ::skills::SkillType skill)
{
switch (skill) {
case EQEmu::skills::SkillThrowing:
return EQEmu::item::ItemTypeSmallThrowing;
case EQEmu::skills::SkillArchery:
return EQEmu::item::ItemTypeArrow;
case EQEmu::skills::Skill1HSlashing:
return EQEmu::item::ItemType1HSlash;
case EQEmu::skills::Skill2HSlashing:
return EQEmu::item::ItemType2HSlash;
case EQEmu::skills::Skill1HPiercing:
return EQEmu::item::ItemType1HPiercing;
case EQEmu::skills::Skill2HPiercing: // watch for undesired client behavior
return EQEmu::item::ItemType2HPiercing;
case EQEmu::skills::Skill1HBlunt:
return EQEmu::item::ItemType1HBlunt;
case EQEmu::skills::Skill2HBlunt:
return EQEmu::item::ItemType2HBlunt;
case EQEmu::skills::SkillHandtoHand:
return EQEmu::item::ItemTypeMartial;
case EQ::skills::SkillThrowing:
return EQ::item::ItemTypeSmallThrowing;
case EQ::skills::SkillArchery:
return EQ::item::ItemTypeArrow;
case EQ::skills::Skill1HSlashing:
return EQ::item::ItemType1HSlash;
case EQ::skills::Skill2HSlashing:
return EQ::item::ItemType2HSlash;
case EQ::skills::Skill1HPiercing:
return EQ::item::ItemType1HPiercing;
case EQ::skills::Skill2HPiercing: // watch for undesired client behavior
return EQ::item::ItemType2HPiercing;
case EQ::skills::Skill1HBlunt:
return EQ::item::ItemType1HBlunt;
case EQ::skills::Skill2HBlunt:
return EQ::item::ItemType2HBlunt;
case EQ::skills::SkillHandtoHand:
return EQ::item::ItemTypeMartial;
default:
return EQEmu::item::ItemTypeMartial;
return EQ::item::ItemTypeMartial;
}
}
@@ -5623,7 +5623,7 @@ int32 Mob::GetSpellStat(uint32 spell_id, const char *identifier, uint8 slot)
bool Mob::CanClassEquipItem(uint32 item_id)
{
const EQEmu::ItemData* itm = nullptr;
const EQ::ItemData* itm = nullptr;
itm = database.GetItem(item_id);
if (!itm)
@@ -5679,9 +5679,9 @@ int32 Mob::GetMeleeMitigation() {
}
/* this is the mob being attacked.
* Pass in the weapon's EQEmu::ItemInstance
* Pass in the weapon's EQ::ItemInstance
*/
int Mob::ResistElementalWeaponDmg(const EQEmu::ItemInstance *item)
int Mob::ResistElementalWeaponDmg(const EQ::ItemInstance *item)
{
if (!item)
return 0;
@@ -5831,9 +5831,9 @@ int Mob::ResistElementalWeaponDmg(const EQEmu::ItemInstance *item)
}
/* this is the mob being attacked.
* Pass in the weapon's EQEmu::ItemInstance
* Pass in the weapon's EQ::ItemInstance
*/
int Mob::CheckBaneDamage(const EQEmu::ItemInstance *item)
int Mob::CheckBaneDamage(const EQ::ItemInstance *item)
{
if (!item)
return 0;
zone/mob.h
+66 -66
View File
@@ -54,7 +54,7 @@ class MobMovementManager;
const int COLLISION_BOX_SIZE = 8;
namespace EQEmu
namespace EQ
{
struct ItemData;
class ItemInstance;
@@ -145,7 +145,7 @@ public:
uint32 in_drakkin_heritage,
uint32 in_drakkin_tattoo,
uint32 in_drakkin_details,
EQEmu::TintProfile in_armor_tint,
EQ::TintProfile in_armor_tint,
uint8 in_aa_title,
uint8 in_see_invis, // see through invis
uint8 in_see_invis_undead, // see through invis vs. undead
@@ -193,26 +193,26 @@ public:
virtual void RangedAttack(Mob* other) { }
virtual void ThrowingAttack(Mob* other) { }
// 13 = Primary (default), 14 = secondary
virtual bool Attack(Mob* other, int Hand = EQEmu::invslot::slotPrimary, bool FromRiposte = false, bool IsStrikethrough = false,
virtual bool Attack(Mob* other, int Hand = EQ::invslot::slotPrimary, bool FromRiposte = false, bool IsStrikethrough = false,
bool IsFromSpell = false, ExtraAttackOptions *opts = nullptr) = 0;
void DoAttack(Mob *other, DamageHitInfo &hit, ExtraAttackOptions *opts = nullptr);
int MonkSpecialAttack(Mob* other, uint8 skill_used);
virtual void TryBackstab(Mob *other,int ReuseTime = 10);
bool AvoidDamage(Mob *attacker, DamageHitInfo &hit);
int compute_tohit(EQEmu::skills::SkillType skillinuse);
int GetTotalToHit(EQEmu::skills::SkillType skill, int chance_mod); // compute_tohit + spell bonuses
int compute_tohit(EQ::skills::SkillType skillinuse);
int GetTotalToHit(EQ::skills::SkillType skill, int chance_mod); // compute_tohit + spell bonuses
int compute_defense();
int GetTotalDefense(); // compute_defense + spell bonuses
bool CheckHitChance(Mob* attacker, DamageHitInfo &hit);
void TryCriticalHit(Mob *defender, DamageHitInfo &hit, ExtraAttackOptions *opts = nullptr);
void TryPetCriticalHit(Mob *defender, DamageHitInfo &hit);
virtual bool TryFinishingBlow(Mob *defender, int &damage);
int TryHeadShot(Mob* defender, EQEmu::skills::SkillType skillInUse);
int TryAssassinate(Mob* defender, EQEmu::skills::SkillType skillInUse);
int TryHeadShot(Mob* defender, EQ::skills::SkillType skillInUse);
int TryAssassinate(Mob* defender, EQ::skills::SkillType skillInUse);
virtual void DoRiposte(Mob* defender);
void ApplyMeleeDamageMods(uint16 skill, int &damage, Mob * defender = nullptr, ExtraAttackOptions *opts = nullptr);
int ACSum();
int offense(EQEmu::skills::SkillType skill);
int offense(EQ::skills::SkillType skill);
int GetBestMeleeSkill();
void CalcAC() { mitigation_ac = ACSum(); }
int GetACSoftcap();
@@ -251,11 +251,11 @@ public:
************************************************
*/
EQEmu::InternalTextureProfile mob_texture_profile = {};
EQ::InternalTextureProfile mob_texture_profile = {};
bool IsInvisible(Mob* other = 0) const;
EQEmu::skills::SkillType AttackAnimation(int Hand, const EQEmu::ItemInstance* weapon, EQEmu::skills::SkillType skillinuse = EQEmu::skills::Skill1HBlunt);
EQ::skills::SkillType AttackAnimation(int Hand, const EQ::ItemInstance* weapon, EQ::skills::SkillType skillinuse = EQ::skills::Skill1HBlunt);
inline bool GetSeeInvisible(uint8 see_invis);
inline bool SeeHide() const { return see_hide; }
@@ -275,7 +275,7 @@ public:
void ChangeSize(float in_size, bool bNoRestriction = false);
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, EQEmu::skills::SkillType skillInUse = EQEmu::skills::SkillArchery);
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, EQ::skills::SkillType skillInUse = EQ::skills::SkillArchery);
void SendAppearanceEffect(uint32 parm1, uint32 parm2, uint32 parm3, uint32 parm4, uint32 parm5, Client *specific_target=nullptr);
void SendLevelAppearance();
void SendStunAppearance();
@@ -285,7 +285,7 @@ public:
//Song
bool UseBardSpellLogic(uint16 spell_id = 0xffff, int slot = -1);
bool ApplyNextBardPulse(uint16 spell_id, Mob *spell_target, EQEmu::spells::CastingSlot slot);
bool ApplyNextBardPulse(uint16 spell_id, Mob *spell_target, EQ::spells::CastingSlot slot);
void BardPulse(uint16 spell_id, Mob *caster);
//Spell
@@ -309,31 +309,31 @@ public:
int level_override = -1);
int GetResist(uint8 resist_type);
int ResistPhysical(int level_diff, uint8 caster_level);
int ResistElementalWeaponDmg(const EQEmu::ItemInstance *item);
int CheckBaneDamage(const EQEmu::ItemInstance *item);
int ResistElementalWeaponDmg(const EQ::ItemInstance *item);
int CheckBaneDamage(const EQ::ItemInstance *item);
uint16 GetSpecializeSkillValue(uint16 spell_id) const;
void SendSpellBarDisable();
void SendSpellBarEnable(uint16 spellid);
void ZeroCastingVars();
virtual void SpellProcess();
virtual bool CastSpell(uint16 spell_id, uint16 target_id, EQEmu::spells::CastingSlot slot = EQEmu::spells::CastingSlot::Item, int32 casttime = -1,
virtual bool CastSpell(uint16 spell_id, uint16 target_id, EQ::spells::CastingSlot slot = EQ::spells::CastingSlot::Item, int32 casttime = -1,
int32 mana_cost = -1, uint32* oSpellWillFinish = 0, uint32 item_slot = 0xFFFFFFFF,
uint32 timer = 0xFFFFFFFF, uint32 timer_duration = 0, int16 *resist_adjust = nullptr,
uint32 aa_id = 0);
virtual bool DoCastSpell(uint16 spell_id, uint16 target_id, EQEmu::spells::CastingSlot slot = EQEmu::spells::CastingSlot::Item, int32 casttime = -1,
virtual bool DoCastSpell(uint16 spell_id, uint16 target_id, EQ::spells::CastingSlot slot = EQ::spells::CastingSlot::Item, int32 casttime = -1,
int32 mana_cost = -1, uint32* oSpellWillFinish = 0, uint32 item_slot = 0xFFFFFFFF,
uint32 timer = 0xFFFFFFFF, uint32 timer_duration = 0, int16 resist_adjust = 0,
uint32 aa_id = 0);
void CastedSpellFinished(uint16 spell_id, uint32 target_id, EQEmu::spells::CastingSlot slot, uint16 mana_used,
void CastedSpellFinished(uint16 spell_id, uint32 target_id, EQ::spells::CastingSlot slot, uint16 mana_used,
uint32 inventory_slot = 0xFFFFFFFF, int16 resist_adjust = 0);
bool SpellFinished(uint16 spell_id, Mob *target, EQEmu::spells::CastingSlot slot = EQEmu::spells::CastingSlot::Item, uint16 mana_used = 0,
bool SpellFinished(uint16 spell_id, Mob *target, EQ::spells::CastingSlot slot = EQ::spells::CastingSlot::Item, uint16 mana_used = 0,
uint32 inventory_slot = 0xFFFFFFFF, int16 resist_adjust = 0, bool isproc = false, int level_override = -1);
void SendBeginCast(uint16 spell_id, uint32 casttime);
virtual bool SpellOnTarget(uint16 spell_id, Mob* spelltar, bool reflect = false,
bool use_resist_adjust = false, int16 resist_adjust = 0, bool isproc = false, int level_override = -1);
virtual bool SpellEffect(Mob* caster, uint16 spell_id, float partial = 100, int level_override = -1);
virtual bool DetermineSpellTargets(uint16 spell_id, Mob *&spell_target, Mob *&ae_center,
CastAction_type &CastAction, EQEmu::spells::CastingSlot slot, bool isproc = false);
CastAction_type &CastAction, EQ::spells::CastingSlot slot, bool isproc = false);
virtual bool CheckFizzle(uint16 spell_id);
virtual bool CheckSpellLevelRestriction(uint16 spell_id);
virtual bool IsImmuneToSpell(uint16 spell_id, Mob *caster);
@@ -432,7 +432,7 @@ public:
void SetTwoHanderEquipped(bool val) { has_twohanderequipped = val; }
bool CanFacestab() { return can_facestab; }
void SetFacestab(bool val) { can_facestab = val; }
virtual uint16 GetSkill(EQEmu::skills::SkillType skill_num) const { return 0; }
virtual uint16 GetSkill(EQ::skills::SkillType skill_num) const { return 0; }
virtual uint32 GetEquippedItemFromTextureSlot(uint8 material_slot) const { return(0); }
virtual int32 GetEquipmentMaterial(uint8 material_slot) const;
virtual int32 GetHerosForgeModel(uint8 material_slot) const;
@@ -440,8 +440,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, EQEmu::skills::SkillType attack_skill) = 0;
virtual void Damage(Mob* from, int32 damage, uint16 spell_id, EQEmu::skills::SkillType attack_skill,
virtual bool Death(Mob* killerMob, int32 damage, uint16 spell_id, EQ::skills::SkillType attack_skill) = 0;
virtual void Damage(Mob* from, int32 damage, uint16 spell_id, EQ::skills::SkillType attack_skill,
bool avoidable = true, int8 buffslot = -1, bool iBuffTic = false, eSpecialAttacks special = eSpecialAttacks::None) = 0;
inline virtual void SetHP(int32 hp) { if (hp >= max_hp) current_hp = max_hp; else current_hp = hp;}
bool ChangeHP(Mob* other, int32 amount, uint16 spell_id = 0, int8 buffslot = -1, bool iBuffTic = false);
@@ -453,7 +453,7 @@ public:
virtual inline uint8 GetBaseGender() const { return base_gender; }
virtual uint16 GetFactionRace();
virtual inline uint16 GetDeity() const { return deity; }
virtual EQEmu::deity::DeityTypeBit GetDeityBit() { return EQEmu::deity::ConvertDeityTypeToDeityTypeBit((EQEmu::deity::DeityType)deity); }
virtual EQ::deity::DeityTypeBit GetDeityBit() { return EQ::deity::ConvertDeityTypeToDeityTypeBit((EQ::deity::DeityType)deity); }
inline uint16 GetRace() const { return race; }
inline uint16 GetModel() const { return (use_model == 0) ? race : use_model; }
inline uint8 GetGender() const { return gender; }
@@ -483,7 +483,7 @@ public:
inline void ChangeDrakkinHeritage(uint8 in) { drakkin_heritage = in; }
inline void ChangeDrakkinTattoo(uint8 in) { drakkin_tattoo = in; }
inline void ChangeDrakkinDetails(uint8 in) { drakkin_details = in; }
inline uint32 GetArmorTint(uint8 i) const { return armor_tint.Slot[(i < EQEmu::textures::materialCount) ? i : 0].Color; }
inline uint32 GetArmorTint(uint8 i) const { return armor_tint.Slot[(i < EQ::textures::materialCount) ? i : 0].Color; }
inline uint8 GetClass() const { return class_; }
inline uint8 GetLevel() const { return level; }
inline uint8 GetOrigLevel() const { return orig_level; }
@@ -680,7 +680,7 @@ public:
static uint8 GetDefaultGender(uint16 in_race, uint8 in_gender = 0xFF);
static bool IsPlayerRace(uint16 in_race);
uint16 GetSkillByItemType(int ItemType);
uint8 GetItemTypeBySkill(EQEmu::skills::SkillType skill);
uint8 GetItemTypeBySkill(EQ::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;
@@ -709,7 +709,7 @@ public:
inline AuraMgr &GetAuraMgr() { return aura_mgr; } // mainly used for zone db loading/saving
//Procs
void TriggerDefensiveProcs(Mob *on, uint16 hand = EQEmu::invslot::slotPrimary, bool FromSkillProc = false, int damage = 0);
void TriggerDefensiveProcs(Mob *on, uint16 hand = EQ::invslot::slotPrimary, bool FromSkillProc = false, int damage = 0);
bool AddRangedProc(uint16 spell_id, uint16 iChance = 3, uint16 base_spell_id = SPELL_UNKNOWN);
bool RemoveRangedProc(uint16 spell_id, bool bAll = false);
bool HasRangedProcs() const;
@@ -796,7 +796,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 EQEmu::skills::SkillType skill_used, ExtraAttackOptions *opts = nullptr);
int16 GetSkillDmgTaken(const EQ::skills::SkillType skill_used, ExtraAttackOptions *opts = nullptr);
void DoKnockback(Mob *caster, uint32 pushback, uint32 pushup);
int16 CalcResistChanceBonus();
int16 CalcFearResistChance();
@@ -829,8 +829,8 @@ public:
inline void SetSpellPowerDistanceMod(int16 value) { SpellPowerDistanceMod = value; };
int32 GetSpellStat(uint32 spell_id, const char *identifier, uint8 slot = 0);
void ModSkillDmgTaken(EQEmu::skills::SkillType skill_num, int value);
int16 GetModSkillDmgTaken(const EQEmu::skills::SkillType skill_num);
void ModSkillDmgTaken(EQ::skills::SkillType skill_num, int value);
int16 GetModSkillDmgTaken(const EQ::skills::SkillType skill_num);
void ModVulnerability(uint8 resist, int16 value);
int16 GetModVulnerability(const uint8 resist);
@@ -856,17 +856,17 @@ public:
bool IsDestructibleObject() { return destructibleobject; }
void SetDestructibleObject(bool in) { destructibleobject = in; }
inline uint8 GetInnateLightType() { return m_Light.Type[EQEmu::lightsource::LightInnate]; }
inline uint8 GetEquipmentLightType() { return m_Light.Type[EQEmu::lightsource::LightEquipment]; }
inline uint8 GetSpellLightType() { return m_Light.Type[EQEmu::lightsource::LightSpell]; }
inline uint8 GetInnateLightType() { return m_Light.Type[EQ::lightsource::LightInnate]; }
inline uint8 GetEquipmentLightType() { return m_Light.Type[EQ::lightsource::LightEquipment]; }
inline uint8 GetSpellLightType() { return m_Light.Type[EQ::lightsource::LightSpell]; }
virtual void UpdateEquipmentLight() { m_Light.Type[EQEmu::lightsource::LightEquipment] = 0; m_Light.Level[EQEmu::lightsource::LightEquipment] = 0; }
inline void SetSpellLightType(uint8 light_type) { m_Light.Type[EQEmu::lightsource::LightSpell] = (light_type & 0x0F); m_Light.Level[EQEmu::lightsource::LightSpell] = EQEmu::lightsource::TypeToLevel(m_Light.Type[EQEmu::lightsource::LightSpell]); }
virtual void UpdateEquipmentLight() { m_Light.Type[EQ::lightsource::LightEquipment] = 0; m_Light.Level[EQ::lightsource::LightEquipment] = 0; }
inline void SetSpellLightType(uint8 light_type) { m_Light.Type[EQ::lightsource::LightSpell] = (light_type & 0x0F); m_Light.Level[EQ::lightsource::LightSpell] = EQ::lightsource::TypeToLevel(m_Light.Type[EQ::lightsource::LightSpell]); }
inline uint8 GetActiveLightType() { return m_Light.Type[EQEmu::lightsource::LightActive]; }
inline uint8 GetActiveLightType() { return m_Light.Type[EQ::lightsource::LightActive]; }
bool UpdateActiveLight(); // returns true if change, false if no change
EQEmu::LightSourceProfile* GetLightProfile() { return &m_Light; }
EQ::LightSourceProfile* GetLightProfile() { return &m_Light; }
Mob* GetPet();
void SetPet(Mob* newpet);
@@ -917,7 +917,7 @@ public:
virtual int GetHaste();
int32 GetMeleeMitigation();
uint8 GetWeaponDamageBonus(const EQEmu::ItemData* weapon, bool offhand = false);
uint8 GetWeaponDamageBonus(const EQ::ItemData* weapon, bool offhand = false);
const DamageTable &GetDamageTable() const;
void ApplyDamageTable(DamageHitInfo &hit);
virtual int GetHandToHandDamage(void);
@@ -942,11 +942,11 @@ public:
int32 AffectMagicalDamage(int32 damage, uint16 spell_id, const bool iBuffTic, Mob* attacker);
int32 ReduceAllDamage(int32 damage);
void DoSpecialAttackDamage(Mob *who, EQEmu::skills::SkillType skill, int base_damage, int min_damage = 0, int32 hate_override = -1, int ReuseTime = 10);
virtual void DoThrowingAttackDmg(Mob* other, const EQEmu::ItemInstance* RangeWeapon = nullptr, const EQEmu::ItemData* 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);
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 EQEmu::ItemInstance* RangeWeapon = nullptr, const EQEmu::ItemInstance* 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::ItemData *AmmoItem = nullptr, int AmmoSlot = 0, float speed = 4.0f);
bool TryProjectileAttack(Mob* other, const EQEmu::ItemData *item, EQEmu::skills::SkillType skillInUse, uint16 weapon_dmg, const EQEmu::ItemInstance* RangeWeapon, const EQEmu::ItemInstance* Ammo, int AmmoSlot, float speed);
void DoSpecialAttackDamage(Mob *who, EQ::skills::SkillType skill, int base_damage, int min_damage = 0, int32 hate_override = -1, int ReuseTime = 10);
virtual void DoThrowingAttackDmg(Mob* other, const EQ::ItemInstance* RangeWeapon = nullptr, const EQ::ItemData* 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);
void DoMeleeSkillAttackDmg(Mob* other, uint16 weapon_damage, EQ::skills::SkillType skillinuse, int16 chance_mod = 0, int16 focus = 0, bool CanRiposte = false, int ReuseTime = 0);
virtual void DoArcheryAttackDmg(Mob* other, const EQ::ItemInstance* RangeWeapon = nullptr, const EQ::ItemInstance* 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 EQ::ItemData *AmmoItem = nullptr, int AmmoSlot = 0, float speed = 4.0f);
bool TryProjectileAttack(Mob* other, const EQ::ItemData *item, EQ::skills::SkillType skillInUse, uint16 weapon_dmg, const EQ::ItemInstance* RangeWeapon, const EQ::ItemInstance* Ammo, int AmmoSlot, float speed);
void ProjectileAttack();
inline bool HasProjectileAttack() const { return ActiveProjectileATK; }
inline void SetProjectileAttack(bool value) { ActiveProjectileATK = value; }
@@ -1083,7 +1083,7 @@ public:
// HP Event
inline int GetNextHPEvent() const { return nexthpevent; }
void SetNextHPEvent( int hpevent );
void SendItemAnimation(Mob *to, const EQEmu::ItemData *item, EQEmu::skills::SkillType skillInUse, float velocity = 4.0);
void SendItemAnimation(Mob *to, const EQ::ItemData *item, EQ::skills::SkillType skillInUse, float velocity = 4.0);
inline int& GetNextIncHPEvent() { return nextinchpevent; }
void SetNextIncHPEvent( int inchpevent );
@@ -1136,7 +1136,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, EQEmu::skills::SkillType skillinuse, Mob* attacker);
float mod_hit_chance(float chancetohit, EQ::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);
@@ -1147,11 +1147,11 @@ 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, EQEmu::skills::SkillType skill_type);
int32 mod_monk_special_damage(int32 ndamage, EQ::skills::SkillType skill_type);
int32 mod_backstab_damage(int32 ndamage);
int mod_archery_bonus_chance(int bonuschance, const EQEmu::ItemInstance* RangeWeapon);
uint32 mod_archery_bonus_damage(uint32 MaxDmg, const EQEmu::ItemInstance* RangeWeapon);
int32 mod_archery_damage(int32 TotalDmg, bool hasbonus, const EQEmu::ItemInstance* RangeWeapon);
int mod_archery_bonus_chance(int bonuschance, const EQ::ItemInstance* RangeWeapon);
uint32 mod_archery_bonus_damage(uint32 MaxDmg, const EQ::ItemInstance* RangeWeapon);
int32 mod_archery_damage(int32 TotalDmg, bool hasbonus, const EQ::ItemInstance* RangeWeapon);
uint16 mod_throwing_damage(uint16 MaxDmg);
int32 mod_cast_time(int32 cast_time);
int mod_buff_duration(int res, Mob* caster, Mob* target, uint16 spell_id);
@@ -1166,7 +1166,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, 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);
float Tune_CheckHitChance(Mob* defender, Mob* attacker, EQ::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);
@@ -1187,8 +1187,8 @@ public:
void AddAssistCap() { ++npc_assist_cap; }
void DelAssistCap() { --npc_assist_cap; }
void ResetAssistCap() { npc_assist_cap = 0; }
int GetWeaponDamage(Mob *against, const EQEmu::ItemData *weapon_item);
int GetWeaponDamage(Mob *against, const EQEmu::ItemInstance *weapon_item, uint32 *hate = nullptr);
int GetWeaponDamage(Mob *against, const EQ::ItemData *weapon_item);
int GetWeaponDamage(Mob *against, const EQ::ItemInstance *weapon_item, uint32 *hate = nullptr);
int32 GetHPRegen() const;
int32 GetManaRegen() const;
@@ -1214,7 +1214,7 @@ public:
#endif
protected:
void CommonDamage(Mob* other, int &damage, const uint16 spell_id, const EQEmu::skills::SkillType attack_skill, bool &avoidable, const int8 buffslot, const bool iBuffTic, eSpecialAttacks specal = eSpecialAttacks::None);
void CommonDamage(Mob* other, int &damage, const uint16 spell_id, const EQ::skills::SkillType attack_skill, bool &avoidable, const int8 buffslot, const bool iBuffTic, eSpecialAttacks specal = eSpecialAttacks::None);
static uint16 GetProcID(uint16 spell_id, uint8 effect_index);
float _GetMovementSpeed(int mod) const;
int _GetWalkSpeed() const;
@@ -1231,7 +1231,7 @@ protected:
std::vector<uint16> RampageArray;
std::map<std::string, std::string> m_EntityVariables;
int16 SkillDmgTaken_Mod[EQEmu::skills::HIGHEST_SKILL + 2];
int16 SkillDmgTaken_Mod[EQ::skills::HIGHEST_SKILL + 2];
int16 Vulnerability_Mod[HIGHEST_RESIST+2];
bool m_AllowBeneficial;
bool m_DisableMelee;
@@ -1341,19 +1341,19 @@ protected:
void TrySkillProc(Mob *on, uint16 skill, uint16 ReuseTime, bool Success = false, uint16 hand = 0, bool IsDefensive = false); // hand = SlotCharm?
bool PassLimitToSkill(uint16 spell_id, uint16 skill);
bool PassLimitClass(uint32 Classes_, uint16 Class_);
void TryDefensiveProc(Mob *on, uint16 hand = EQEmu::invslot::slotPrimary);
void TryWeaponProc(const EQEmu::ItemInstance* inst, const EQEmu::ItemData* weapon, Mob *on, uint16 hand = EQEmu::invslot::slotPrimary);
void TrySpellProc(const EQEmu::ItemInstance* inst, const EQEmu::ItemData* weapon, Mob *on, uint16 hand = EQEmu::invslot::slotPrimary);
void TryWeaponProc(const EQEmu::ItemInstance* weapon, Mob *on, uint16 hand = EQEmu::invslot::slotPrimary);
void ExecWeaponProc(const EQEmu::ItemInstance* weapon, uint16 spell_id, Mob *on, int level_override = -1);
virtual float GetProcChances(float ProcBonus, uint16 hand = EQEmu::invslot::slotPrimary);
virtual float GetDefensiveProcChances(float &ProcBonus, float &ProcChance, uint16 hand = EQEmu::invslot::slotPrimary, Mob *on = nullptr);
void TryDefensiveProc(Mob *on, uint16 hand = EQ::invslot::slotPrimary);
void TryWeaponProc(const EQ::ItemInstance* inst, const EQ::ItemData* weapon, Mob *on, uint16 hand = EQ::invslot::slotPrimary);
void TrySpellProc(const EQ::ItemInstance* inst, const EQ::ItemData* weapon, Mob *on, uint16 hand = EQ::invslot::slotPrimary);
void TryWeaponProc(const EQ::ItemInstance* weapon, Mob *on, uint16 hand = EQ::invslot::slotPrimary);
void ExecWeaponProc(const EQ::ItemInstance* weapon, uint16 spell_id, Mob *on, int level_override = -1);
virtual float GetProcChances(float ProcBonus, uint16 hand = EQ::invslot::slotPrimary);
virtual float GetDefensiveProcChances(float &ProcBonus, float &ProcChance, uint16 hand = EQ::invslot::slotPrimary, Mob *on = nullptr);
virtual float GetSkillProcChances(uint16 ReuseTime, uint16 hand = 0); // hand = MainCharm?
uint16 GetWeaponSpeedbyHand(uint16 hand);
#ifdef BOTS
virtual
#endif
int GetBaseSkillDamage(EQEmu::skills::SkillType skill, Mob *target = nullptr);
int GetBaseSkillDamage(EQ::skills::SkillType skill, Mob *target = nullptr);
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);
@@ -1379,7 +1379,7 @@ protected:
// ideally we should use real models, but this should be quick and work mostly
glm::vec4 m_CollisionBox[COLLISION_BOX_SIZE];
EQEmu::LightSourceProfile m_Light;
EQ::LightSourceProfile m_Light;
float fixedZ;
EmuAppearance _appearance;
@@ -1403,7 +1403,7 @@ protected:
int attacked_count;
bool delaytimer;
uint16 casting_spell_targetid;
EQEmu::spells::CastingSlot casting_spell_slot;
EQ::spells::CastingSlot casting_spell_slot;
uint16 casting_spell_mana;
uint32 casting_spell_inventory_slot;
uint32 casting_spell_timer;
@@ -1413,7 +1413,7 @@ protected:
uint32 casting_spell_aa_id;
bool casting_spell_checks;
uint16 bardsong;
EQEmu::spells::CastingSlot bardsong_slot;
EQ::spells::CastingSlot bardsong_slot;
uint32 bardsong_target_id;
bool ActiveProjectileATK;
@@ -1438,7 +1438,7 @@ protected:
uint32 drakkin_heritage;
uint32 drakkin_tattoo;
uint32 drakkin_details;
EQEmu::TintProfile armor_tint;
EQ::TintProfile armor_tint;
uint8 aa_title;
@@ -1567,7 +1567,7 @@ protected:
glm::vec3 m_TargetRing;
// we might want to do this differently, we gotta do max NPC buffs ... which is 97
uint32 m_spellHitsLeft[EQEmu::spells::TOTAL_BUFFS]; // Used to track which spells will have their numhits incremented when spell finishes casting
uint32 m_spellHitsLeft[EQ::spells::TOTAL_BUFFS]; // Used to track which spells will have their numhits incremented when spell finishes casting
GravityBehavior flymode;
bool m_targetable;
int QGVarDuration(const char *fmt);
zone/mob_ai.cpp
+17 -17
View File
@@ -144,7 +144,7 @@ bool NPC::AICastSpell(Mob* tar, uint8 iChance, uint32 iSpellTypes, bool bInnates
int min_hp = AIspells[i].min_hp; // well 0 is default, so no special case here
int max_hp = AIspells[i].max_hp ? AIspells[i].max_hp : RuleI(Spells, AI_HealHPPct);
if (EQEmu::ValueWithin(hp_ratio, min_hp, max_hp) || (tar->IsClient() && hp_ratio <= 99)) { // not sure about client bit, leaving it
if (EQ::ValueWithin(hp_ratio, min_hp, max_hp) || (tar->IsClient() && hp_ratio <= 99)) { // not sure about client bit, leaving it
uint32 tempTime = 0;
AIDoSpellCast(i, tar, mana_cost, &tempTime);
tar->SetDontHealMeBefore(tempTime);
@@ -375,7 +375,7 @@ bool NPC::AIDoSpellCast(uint8 i, Mob* tar, int32 mana_cost, uint32* oDontDoAgain
#endif
casting_spell_AIindex = i;
return CastSpell(AIspells[i].spellid, tar->GetID(), EQEmu::spells::CastingSlot::Gem2, AIspells[i].manacost == -2 ? 0 : -1, mana_cost, oDontDoAgainBefore, -1, -1, 0, &(AIspells[i].resist_adjust));
return CastSpell(AIspells[i].spellid, tar->GetID(), EQ::spells::CastingSlot::Gem2, AIspells[i].manacost == -2 ? 0 : -1, mana_cost, oDontDoAgainBefore, -1, -1, 0, &(AIspells[i].resist_adjust));
}
void Mob::AI_Init()
@@ -635,11 +635,11 @@ void Client::AI_SpellCast()
}
uint32 spell_to_cast = 0xFFFFFFFF;
EQEmu::spells::CastingSlot slot_to_use = EQEmu::spells::CastingSlot::Item;
EQ::spells::CastingSlot slot_to_use = EQ::spells::CastingSlot::Item;
if(valid_spells.size() == 1)
{
spell_to_cast = valid_spells[0];
slot_to_use = static_cast<EQEmu::spells::CastingSlot>(slots[0]);
slot_to_use = static_cast<EQ::spells::CastingSlot>(slots[0]);
}
else if(valid_spells.empty())
{
@@ -649,7 +649,7 @@ void Client::AI_SpellCast()
{
uint32 idx = zone->random.Int(0, (valid_spells.size()-1));
spell_to_cast = valid_spells[idx];
slot_to_use = static_cast<EQEmu::spells::CastingSlot>(slots[idx]);
slot_to_use = static_cast<EQ::spells::CastingSlot>(slots[idx]);
}
if(IsMezSpell(spell_to_cast) || IsFearSpell(spell_to_cast))
@@ -803,7 +803,7 @@ void Client::AI_Process()
if (GetTarget() && !IsStunned() && !IsMezzed() && !GetFeigned()) {
if (attack_timer.Check()) {
// Should charmed clients not be procing?
DoAttackRounds(GetTarget(), EQEmu::invslot::slotPrimary);
DoAttackRounds(GetTarget(), EQ::invslot::slotPrimary);
}
}
@@ -811,7 +811,7 @@ void Client::AI_Process()
if (attack_dw_timer.Check()) {
if (CheckDualWield()) {
// Should charmed clients not be procing?
DoAttackRounds(GetTarget(), EQEmu::invslot::slotSecondary);
DoAttackRounds(GetTarget(), EQ::invslot::slotSecondary);
}
}
}
@@ -1159,7 +1159,7 @@ void Mob::AI_Process() {
//try main hand first
if (attack_timer.Check()) {
DoMainHandAttackRounds(target);
TriggerDefensiveProcs(target, EQEmu::invslot::slotPrimary, false);
TriggerDefensiveProcs(target, EQ::invslot::slotPrimary, false);
bool specialed = false; // NPCs can only do one of these a round
if (GetSpecialAbility(SPECATK_FLURRY)) {
@@ -1549,10 +1549,10 @@ void NPC::AI_DoMovement() {
// Check if we're already moving to a WP
// If so, if we're not moving we have arrived and need to set delay
if (GetCWP() == EQEmu::WaypointStatus::RoamBoxPauseInProgress && !IsMoving()) {
if (GetCWP() == EQ::WaypointStatus::RoamBoxPauseInProgress && !IsMoving()) {
// We have arrived
int roambox_move_delay = EQEmu::ClampLower(GetRoamboxDelay(), GetRoamboxMinDelay());
int roambox_move_delay = EQ::ClampLower(GetRoamboxDelay(), GetRoamboxMinDelay());
int move_delay_max = (roambox_move_delay > 0 ? roambox_move_delay : (int) GetRoamboxMinDelay() * 4);
int random_timer = RandomTimer(
GetRoamboxMinDelay(),
@@ -1579,8 +1579,8 @@ void NPC::AI_DoMovement() {
auto move_x = static_cast<float>(zone->random.Real(-roambox_distance, roambox_distance));
auto move_y = static_cast<float>(zone->random.Real(-roambox_distance, roambox_distance));
roambox_destination_x = EQEmu::Clamp((GetX() + move_x), roambox_min_x, roambox_max_x);
roambox_destination_y = EQEmu::Clamp((GetY() + move_y), roambox_min_y, roambox_max_y);
roambox_destination_x = EQ::Clamp((GetX() + move_x), roambox_min_x, roambox_max_x);
roambox_destination_y = EQ::Clamp((GetY() + move_y), roambox_min_y, roambox_max_y);
/**
* If our roambox was configured with large distances, chances of hitting the min or max end of
@@ -1672,7 +1672,7 @@ void NPC::AI_DoMovement() {
roambox_destination_z
);
SetCurrentWP(EQEmu::WaypointStatus::RoamBoxPauseInProgress);
SetCurrentWP(EQ::WaypointStatus::RoamBoxPauseInProgress);
NavigateTo(roambox_destination_x, roambox_destination_y, roambox_destination_z);
}
@@ -1686,7 +1686,7 @@ void NPC::AI_DoMovement() {
int32 gridno = CastToNPC()->GetGrid();
if (gridno > 0 || cur_wp == EQEmu::WaypointStatus::QuestControlNoGrid) {
if (gridno > 0 || cur_wp == EQ::WaypointStatus::QuestControlNoGrid) {
if (pause_timer_complete == true) { // time to pause at wp is over
AI_SetupNextWaypoint();
} // endif (pause_timer_complete==true)
@@ -1736,7 +1736,7 @@ void NPC::AI_DoMovement() {
// as that is where roamer is unset and we don't want
// the next trip through to move again based on grid stuff.
doMove = false;
if (cur_wp == EQEmu::WaypointStatus::QuestControlNoGrid) {
if (cur_wp == EQ::WaypointStatus::QuestControlNoGrid) {
AI_SetupNextWaypoint();
}
@@ -1830,7 +1830,7 @@ void NPC::AI_SetupNextWaypoint() {
pause_timer_complete = false;
LogPathing("We are departing waypoint [{}]", cur_wp);
//if we were under quest control (with no grid), we are done now..
if (cur_wp == EQEmu::WaypointStatus::QuestControlNoGrid) {
if (cur_wp == EQ::WaypointStatus::QuestControlNoGrid) {
LogPathing("Non-grid quest mob has reached its quest ordered waypoint. Leaving pathing mode");
roamer = false;
cur_wp = 0;
@@ -2107,7 +2107,7 @@ bool Mob::Flurry(ExtraAttackOptions *opts)
int num_attacks = GetSpecialAbilityParam(SPECATK_FLURRY, 1);
num_attacks = num_attacks > 0 ? num_attacks : RuleI(Combat, MaxFlurryHits);
for (int i = 0; i < num_attacks; i++)
Attack(target, EQEmu::invslot::slotPrimary, false, false, false, opts);
Attack(target, EQ::invslot::slotPrimary, false, false, false, opts);
}
return true;
}
zone/mob_appearance.cpp
+50 -50
View File
@@ -52,47 +52,47 @@ void Mob::SetMobTextureProfile(uint8 material_slot, uint16 texture, uint32 color
);
switch (material_slot) {
case EQEmu::textures::armorHead:
case EQ::textures::armorHead:
mob_texture_profile.Head.Material = texture;
mob_texture_profile.Head.HerosForgeModel = hero_forge_model;
mob_texture_profile.Head.Color = color;
break;
case EQEmu::textures::armorChest:
case EQ::textures::armorChest:
mob_texture_profile.Chest.Material = texture;
mob_texture_profile.Chest.HerosForgeModel = hero_forge_model;
mob_texture_profile.Chest.Color = color;
break;
case EQEmu::textures::armorArms:
case EQ::textures::armorArms:
mob_texture_profile.Arms.Material = texture;
mob_texture_profile.Arms.HerosForgeModel = hero_forge_model;
mob_texture_profile.Arms.Color = color;
break;
case EQEmu::textures::armorWrist:
case EQ::textures::armorWrist:
mob_texture_profile.Wrist.Material = texture;
mob_texture_profile.Wrist.HerosForgeModel = hero_forge_model;
mob_texture_profile.Wrist.Color = color;
break;
case EQEmu::textures::armorHands:
case EQ::textures::armorHands:
mob_texture_profile.Hands.Material = texture;
mob_texture_profile.Hands.HerosForgeModel = hero_forge_model;
mob_texture_profile.Hands.Color = color;
break;
case EQEmu::textures::armorLegs:
case EQ::textures::armorLegs:
mob_texture_profile.Legs.Material = texture;
mob_texture_profile.Legs.HerosForgeModel = hero_forge_model;
mob_texture_profile.Legs.Color = color;
break;
case EQEmu::textures::armorFeet:
case EQ::textures::armorFeet:
mob_texture_profile.Feet.Material = texture;
mob_texture_profile.Feet.HerosForgeModel = hero_forge_model;
mob_texture_profile.Feet.Color = color;
break;
case EQEmu::textures::weaponPrimary:
case EQ::textures::weaponPrimary:
mob_texture_profile.Primary.Material = texture;
mob_texture_profile.Primary.HerosForgeModel = hero_forge_model;
mob_texture_profile.Primary.Color = color;
break;
case EQEmu::textures::weaponSecondary:
case EQ::textures::weaponSecondary:
mob_texture_profile.Secondary.Material = texture;
mob_texture_profile.Secondary.HerosForgeModel = hero_forge_model;
mob_texture_profile.Secondary.Color = color;
@@ -111,23 +111,23 @@ void Mob::SetMobTextureProfile(uint8 material_slot, uint16 texture, uint32 color
int32 Mob::GetTextureProfileMaterial(uint8 material_slot) const
{
switch (material_slot) {
case EQEmu::textures::armorHead:
case EQ::textures::armorHead:
return mob_texture_profile.Head.Material;
case EQEmu::textures::armorChest:
case EQ::textures::armorChest:
return mob_texture_profile.Chest.Material;
case EQEmu::textures::armorArms:
case EQ::textures::armorArms:
return mob_texture_profile.Arms.Material;
case EQEmu::textures::armorWrist:
case EQ::textures::armorWrist:
return mob_texture_profile.Wrist.Material;
case EQEmu::textures::armorHands:
case EQ::textures::armorHands:
return mob_texture_profile.Hands.Material;
case EQEmu::textures::armorLegs:
case EQ::textures::armorLegs:
return mob_texture_profile.Legs.Material;
case EQEmu::textures::armorFeet:
case EQ::textures::armorFeet:
return mob_texture_profile.Feet.Material;
case EQEmu::textures::weaponPrimary:
case EQ::textures::weaponPrimary:
return mob_texture_profile.Primary.Material;
case EQEmu::textures::weaponSecondary:
case EQ::textures::weaponSecondary:
return mob_texture_profile.Secondary.Material;
default:
return 0;
@@ -143,23 +143,23 @@ int32 Mob::GetTextureProfileMaterial(uint8 material_slot) const
int32 Mob::GetTextureProfileColor(uint8 material_slot) const
{
switch (material_slot) {
case EQEmu::textures::armorHead:
case EQ::textures::armorHead:
return mob_texture_profile.Head.Color;
case EQEmu::textures::armorChest:
case EQ::textures::armorChest:
return mob_texture_profile.Chest.Color;
case EQEmu::textures::armorArms:
case EQ::textures::armorArms:
return mob_texture_profile.Arms.Color;
case EQEmu::textures::armorWrist:
case EQ::textures::armorWrist:
return mob_texture_profile.Wrist.Color;
case EQEmu::textures::armorHands:
case EQ::textures::armorHands:
return mob_texture_profile.Hands.Color;
case EQEmu::textures::armorLegs:
case EQ::textures::armorLegs:
return mob_texture_profile.Legs.Color;
case EQEmu::textures::armorFeet:
case EQ::textures::armorFeet:
return mob_texture_profile.Feet.Color;
case EQEmu::textures::weaponPrimary:
case EQ::textures::weaponPrimary:
return mob_texture_profile.Primary.Color;
case EQEmu::textures::weaponSecondary:
case EQ::textures::weaponSecondary:
return mob_texture_profile.Secondary.Color;
default:
return 0;
@@ -175,23 +175,23 @@ int32 Mob::GetTextureProfileColor(uint8 material_slot) const
int32 Mob::GetTextureProfileHeroForgeModel(uint8 material_slot) const
{
switch (material_slot) {
case EQEmu::textures::armorHead:
case EQ::textures::armorHead:
return mob_texture_profile.Head.HerosForgeModel;
case EQEmu::textures::armorChest:
case EQ::textures::armorChest:
return mob_texture_profile.Chest.HerosForgeModel;
case EQEmu::textures::armorArms:
case EQ::textures::armorArms:
return mob_texture_profile.Arms.HerosForgeModel;
case EQEmu::textures::armorWrist:
case EQ::textures::armorWrist:
return mob_texture_profile.Wrist.HerosForgeModel;
case EQEmu::textures::armorHands:
case EQ::textures::armorHands:
return mob_texture_profile.Hands.HerosForgeModel;
case EQEmu::textures::armorLegs:
case EQ::textures::armorLegs:
return mob_texture_profile.Legs.HerosForgeModel;
case EQEmu::textures::armorFeet:
case EQ::textures::armorFeet:
return mob_texture_profile.Feet.HerosForgeModel;
case EQEmu::textures::weaponPrimary:
case EQ::textures::weaponPrimary:
return mob_texture_profile.Primary.HerosForgeModel;
case EQEmu::textures::weaponSecondary:
case EQ::textures::weaponSecondary:
return mob_texture_profile.Secondary.HerosForgeModel;
default:
return 0;
@@ -230,18 +230,18 @@ int32 Mob::GetEquipmentMaterial(uint8 material_slot) const
* Handle primary / secondary texture
*/
bool is_primary_or_secondary_weapon =
material_slot == EQEmu::textures::weaponPrimary ||
material_slot == EQEmu::textures::weaponSecondary;
material_slot == EQ::textures::weaponPrimary ||
material_slot == EQ::textures::weaponSecondary;
if (is_primary_or_secondary_weapon) {
if (this->IsClient()) {
int16 inventory_slot = EQEmu::InventoryProfile::CalcSlotFromMaterial(material_slot);
int16 inventory_slot = EQ::InventoryProfile::CalcSlotFromMaterial(material_slot);
if (inventory_slot == INVALID_INDEX) {
return 0;
}
const EQEmu::ItemInstance *item_instance = CastToClient()->m_inv[inventory_slot];
const EQ::ItemInstance *item_instance = CastToClient()->m_inv[inventory_slot];
if (item_instance) {
if (item_instance->GetOrnamentationAug(ornamentation_augment_type)) {
item = item_instance->GetOrnamentationAug(ornamentation_augment_type)->GetItem();
@@ -273,7 +273,7 @@ int32 Mob::GetEquipmentMaterial(uint8 material_slot) const
*/
uint32 Mob::GetEquipmentColor(uint8 material_slot) const
{
const EQEmu::ItemData *item = nullptr;
const EQ::ItemData *item = nullptr;
if (armor_tint.Slot[material_slot].Color) {
return armor_tint.Slot[material_slot].Color;
@@ -294,15 +294,15 @@ uint32 Mob::GetEquipmentColor(uint8 material_slot) const
int32 Mob::GetHerosForgeModel(uint8 material_slot) const
{
uint32 hero_model = 0;
if (material_slot >= 0 && material_slot < EQEmu::textures::weaponPrimary) {
if (material_slot >= 0 && material_slot < EQ::textures::weaponPrimary) {
uint32 ornamentation_aug_type = RuleI(Character, OrnamentationAugmentType);
const EQEmu::ItemData *item = database.GetItem(GetEquippedItemFromTextureSlot(material_slot));
int16 invslot = EQEmu::InventoryProfile::CalcSlotFromMaterial(material_slot);
const EQ::ItemData *item = database.GetItem(GetEquippedItemFromTextureSlot(material_slot));
int16 invslot = EQ::InventoryProfile::CalcSlotFromMaterial(material_slot);
if (item != nullptr && invslot != INVALID_INDEX) {
if (IsClient()) {
const EQEmu::ItemInstance *inst = CastToClient()->m_inv[invslot];
const EQ::ItemInstance *inst = CastToClient()->m_inv[invslot];
if (inst) {
if (inst->GetOrnamentationAug(ornamentation_aug_type)) {
item = inst->GetOrnamentationAug(ornamentation_aug_type)->GetItem();
@@ -352,7 +352,7 @@ uint32 NPC::GetEquippedItemFromTextureSlot(uint8 material_slot) const
return 0;
}
int16 inventory_slot = EQEmu::InventoryProfile::CalcSlotFromMaterial(material_slot);
int16 inventory_slot = EQ::InventoryProfile::CalcSlotFromMaterial(material_slot);
if (inventory_slot == INVALID_INDEX) {
return 0;
}
@@ -383,8 +383,8 @@ void Mob::SendArmorAppearance(Client *one_client)
if (IsPlayerRace(race)) {
if (!IsClient()) {
for (uint8 i = 0; i <= EQEmu::textures::materialCount; ++i) {
const EQEmu::ItemData *item = database.GetItem(GetEquippedItemFromTextureSlot(i));
for (uint8 i = 0; i <= EQ::textures::materialCount; ++i) {
const EQ::ItemData *item = database.GetItem(GetEquippedItemFromTextureSlot(i));
if (item != nullptr) {
SendWearChange(i, one_client);
}
@@ -392,7 +392,7 @@ void Mob::SendArmorAppearance(Client *one_client)
}
}
for (uint8 i = 0; i <= EQEmu::textures::materialCount; ++i) {
for (uint8 i = 0; i <= EQ::textures::materialCount; ++i) {
if (GetTextureProfileMaterial(i)) {
SendWearChange(i, one_client);
}
@@ -419,7 +419,7 @@ void Mob::SendWearChange(uint8 material_slot, Client *one_client)
#ifdef BOTS
if (IsBot()) {
auto item_inst = CastToBot()->GetBotItem(EQEmu::InventoryProfile::CalcSlotFromMaterial(material_slot));
auto item_inst = CastToBot()->GetBotItem(EQ::InventoryProfile::CalcSlotFromMaterial(material_slot));
if (item_inst)
wear_change->color.Color = item_inst->GetColor();
else
zone/mob_info.cpp
+9 -9
View File
@@ -230,11 +230,11 @@ inline std::string GetMobAttributeByString(Mob *mob, const std::string &attribut
}
if (attribute == "tohit") {
return std::to_string(mob->compute_tohit(EQEmu::skills::SkillHandtoHand));
return std::to_string(mob->compute_tohit(EQ::skills::SkillHandtoHand));
}
if (attribute == "total_to_hit") {
return std::to_string(mob->GetTotalToHit(EQEmu::skills::SkillHandtoHand, 0));
return std::to_string(mob->GetTotalToHit(EQ::skills::SkillHandtoHand, 0));
}
if (attribute == "defense") {
@@ -246,7 +246,7 @@ inline std::string GetMobAttributeByString(Mob *mob, const std::string &attribut
}
if (attribute == "offense") {
return std::to_string(mob->offense(EQEmu::skills::SkillHandtoHand));
return std::to_string(mob->offense(EQ::skills::SkillHandtoHand));
}
if (attribute == "mitigation_ac") {
@@ -606,24 +606,24 @@ inline void NPCCommandsMenu(Client* client, NPC* npc)
std::string menu_commands;
if (npc->GetGrid() > 0) {
menu_commands += "[" + EQEmu::SayLinkEngine::GenerateQuestSaylink("#grid show", false, "Grid Points") + "] ";
menu_commands += "[" + EQ::SayLinkEngine::GenerateQuestSaylink("#grid show", false, "Grid Points") + "] ";
}
if (npc->GetEmoteID() > 0) {
std::string saylink = StringFormat("#emotesearch %u", npc->GetEmoteID());
menu_commands += "[" + EQEmu::SayLinkEngine::GenerateQuestSaylink(saylink, false, "Emotes") + "] ";
menu_commands += "[" + EQ::SayLinkEngine::GenerateQuestSaylink(saylink, false, "Emotes") + "] ";
}
if (npc->GetLoottableID() > 0) {
menu_commands += "[" + EQEmu::SayLinkEngine::GenerateQuestSaylink("#npcloot show", false, "Loot") + "] ";
menu_commands += "[" + EQ::SayLinkEngine::GenerateQuestSaylink("#npcloot show", false, "Loot") + "] ";
}
if (npc->IsProximitySet()) {
menu_commands += "[" + EQEmu::SayLinkEngine::GenerateQuestSaylink("#proximity show", false, "Proximity") + "] ";
menu_commands += "[" + EQ::SayLinkEngine::GenerateQuestSaylink("#proximity show", false, "Proximity") + "] ";
}
if (menu_commands.length() > 0) {
std::string dev_menu = "[" + EQEmu::SayLinkEngine::GenerateQuestSaylink("#devtools", false, "DevTools") + "] ";;
std::string dev_menu = "[" + EQ::SayLinkEngine::GenerateQuestSaylink("#devtools", false, "DevTools") + "] ";;
client->Message(Chat::White, "| %s [Show Commands] %s", dev_menu.c_str(), menu_commands.c_str());
}
}
@@ -823,7 +823,7 @@ void Mob::DisplayInfo(Mob *mob)
client->SendFullPopup(
"GM: Entity Info",
window_text.c_str(),
EQEmu::popupresponse::MOB_INFO_DISMISS,
EQ::popupresponse::MOB_INFO_DISMISS,
0,
100,
0,
zone/mod_functions.cpp
+12 -12
View File
@@ -9,7 +9,7 @@ class Spawn2;
struct Consider_Struct;
struct DBTradeskillRecipe_Struct;
namespace EQEmu
namespace EQ
{
class ItemInstance;
}
@@ -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, EQEmu::skills::SkillType skillinuse, int hand, const EQEmu::ItemData* weapon, Mob* other) { return(damage); }
int NPC::mod_npc_damage(int damage, EQ::skills::SkillType skillinuse, int hand, const EQ::ItemData* 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, EQEmu::skills::SkillType skillinuse, int hand, const EQEmu::ItemInstance* weapon, Mob* other) { return(damage); }
int Client::mod_client_damage(int damage, EQ::skills::SkillType skillinuse, int hand, const EQ::ItemInstance* 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(EQEmu::skills::SkillType skillid, Mob* against_who) { return(false); }
bool Client::mod_can_increase_skill(EQ::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); }
@@ -91,7 +91,7 @@ float Client::mod_tradeskill_chance(float chance, DBTradeskillRecipe_Struct *spe
float Client::mod_tradeskill_skillup(float chance_stage2) { return(chance_stage2); }
//Tribute value override
int32 Client::mod_tribute_item_value(int32 pts, const EQEmu::ItemInstance* item) { return(pts); }
int32 Client::mod_tribute_item_value(int32 pts, const EQ::ItemInstance* item) { return(pts); }
//Death reporting
void Client::mod_client_death_npc(Mob* killerMob) { return; }
@@ -107,14 +107,14 @@ int32 Client::mod_client_xp(int32 in_xp, NPC *npc) { return(in_xp); }
uint32 Client::mod_client_xp_for_level(uint32 xp, uint16 check_level) { return(xp); }
//Food and drink values as computed by consume requests. Return < 0 to abort the request.
int Client::mod_food_value(const EQEmu::ItemData *item, int change) { return(change); }
int Client::mod_drink_value(const EQEmu::ItemData *item, int change) { return(change); }
int Client::mod_food_value(const EQ::ItemData *item, int change) { return(change); }
int Client::mod_drink_value(const EQ::ItemData *item, int change) { return(change); }
//effect_vallue - Spell effect value as calculated by default formulas. You will want to ignore effects that don't lend themselves to scaling - pet ID's, gate coords, etc.
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, EQEmu::skills::SkillType skillinuse, Mob* attacker) { return(chancetohit); }
float Mob::mod_hit_chance(float chancetohit, EQ::skills::SkillType skillinuse, Mob* attacker) { return(chancetohit); }
//Final riposte chance
float Mob::mod_riposte_chance(float ripostechance, Mob* attacker) { return(ripostechance); }
@@ -146,19 +146,19 @@ 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, EQEmu::skills::SkillType skill_type) { return(ndamage); }
int32 Mob::mod_monk_special_damage(int32 ndamage, EQ::skills::SkillType skill_type) { return(ndamage); }
//ndamage - Backstab damage as calculated by default formulas
int32 Mob::mod_backstab_damage(int32 ndamage) { return(ndamage); }
//Chance for 50+ archery bonus damage if Combat:UseArcheryBonusRoll is true. Base is Combat:ArcheryBonusChance
int Mob::mod_archery_bonus_chance(int bonuschance, const EQEmu::ItemInstance* RangeWeapon) { return(bonuschance); }
int Mob::mod_archery_bonus_chance(int bonuschance, const EQ::ItemInstance* RangeWeapon) { return(bonuschance); }
//Archery bonus damage
uint32 Mob::mod_archery_bonus_damage(uint32 MaxDmg, const EQEmu::ItemInstance* RangeWeapon) { return(MaxDmg); }
uint32 Mob::mod_archery_bonus_damage(uint32 MaxDmg, const EQ::ItemInstance* RangeWeapon) { return(MaxDmg); }
//Final archery damage including bonus if it was applied.
int32 Mob::mod_archery_damage(int32 TotalDmg, bool hasbonus, const EQEmu::ItemInstance* RangeWeapon) { return(TotalDmg); }
int32 Mob::mod_archery_damage(int32 TotalDmg, bool hasbonus, const EQ::ItemInstance* RangeWeapon) { return(TotalDmg); }
//Thrown weapon damage after all other calcs
uint16 Mob::mod_throwing_damage(uint16 MaxDmg) { return(MaxDmg); }
zone/npc.cpp
+56 -56
View File
@@ -303,8 +303,8 @@ NPC::NPC(const NPCType *npc_type_data, Spawn2 *in_respawn, const glm::vec4 &posi
//give NPCs skill values...
int r;
for (r = 0; r <= EQEmu::skills::HIGHEST_SKILL; r++) {
skills[r] = database.GetSkillCap(GetClass(), (EQEmu::skills::SkillType)r, moblevel);
for (r = 0; r <= EQ::skills::HIGHEST_SKILL; r++) {
skills[r] = database.GetSkillCap(GetClass(), (EQ::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
@@ -319,15 +319,15 @@ NPC::NPC(const NPCType *npc_type_data, Spawn2 *in_respawn, const glm::vec4 &posi
}
else {
if (moblevel > 50) {
skills[EQEmu::skills::SkillDoubleAttack] = 250;
skills[EQEmu::skills::SkillDualWield] = 250;
skills[EQ::skills::SkillDoubleAttack] = 250;
skills[EQ::skills::SkillDualWield] = 250;
}
else if (moblevel > 3) {
skills[EQEmu::skills::SkillDoubleAttack] = moblevel * 5;
skills[EQEmu::skills::SkillDualWield] = skills[EQEmu::skills::SkillDoubleAttack];
skills[EQ::skills::SkillDoubleAttack] = moblevel * 5;
skills[EQ::skills::SkillDualWield] = skills[EQ::skills::SkillDoubleAttack];
}
else {
skills[EQEmu::skills::SkillDoubleAttack] = moblevel * 5;
skills[EQ::skills::SkillDoubleAttack] = moblevel * 5;
}
}
@@ -527,7 +527,7 @@ void NPC::SetTarget(Mob* mob) {
if (owner) {
auto client = owner->CastToClient();
if (client->ClientVersionBit() & EQEmu::versions::maskUFAndLater) {
if (client->ClientVersionBit() & EQ::versions::maskUFAndLater) {
auto app = new EQApplicationPacket(OP_PetHoTT, sizeof(ClientTarget_Struct));
auto ct = (ClientTarget_Struct *)app->pBuffer;
ct->new_target = mob ? mob->GetID() : 0;
@@ -592,8 +592,8 @@ void NPC::CheckMinMaxLevel(Mob *them)
if(themlevel < (*cur)->min_level || themlevel > (*cur)->max_level)
{
material = EQEmu::InventoryProfile::CalcMaterialFromSlot((*cur)->equip_slot);
if (material != EQEmu::textures::materialInvalid)
material = EQ::InventoryProfile::CalcMaterialFromSlot((*cur)->equip_slot);
if (material != EQ::textures::materialInvalid)
SendWearChange(material);
cur = itemlist.erase(cur);
@@ -637,8 +637,8 @@ void NPC::QueryLoot(Client* to)
continue;
}
EQEmu::SayLinkEngine linker;
linker.SetLinkType(EQEmu::saylink::SayLinkLootItem);
EQ::SayLinkEngine linker;
linker.SetLinkType(EQ::saylink::SayLinkLootItem);
linker.SetLootData(*cur);
to->Message(
@@ -790,7 +790,7 @@ bool NPC::Process()
if (GetMana() < GetMaxMana()) {
if (RuleB(NPC, UseMeditateBasedManaRegen)) {
int32 npc_idle_mana_regen_bonus = 2;
uint16 meditate_skill = GetSkill(EQEmu::skills::SkillMeditate);
uint16 meditate_skill = GetSkill(EQ::skills::SkillMeditate);
if (!IsEngaged() && meditate_skill > 0) {
uint8 clevel = GetLevel();
npc_idle_mana_regen_bonus =
@@ -916,18 +916,18 @@ uint32 NPC::CountLoot() {
void NPC::UpdateEquipmentLight()
{
m_Light.Type[EQEmu::lightsource::LightEquipment] = 0;
m_Light.Level[EQEmu::lightsource::LightEquipment] = 0;
m_Light.Type[EQ::lightsource::LightEquipment] = 0;
m_Light.Level[EQ::lightsource::LightEquipment] = 0;
for (int index = EQEmu::invslot::EQUIPMENT_BEGIN; index <= EQEmu::invslot::EQUIPMENT_END; ++index) {
if (index == EQEmu::invslot::slotAmmo) { continue; }
for (int index = EQ::invslot::EQUIPMENT_BEGIN; index <= EQ::invslot::EQUIPMENT_END; ++index) {
if (index == EQ::invslot::slotAmmo) { continue; }
auto item = database.GetItem(equipment[index]);
if (item == nullptr) { continue; }
if (EQEmu::lightsource::IsLevelGreater(item->Light, m_Light.Type[EQEmu::lightsource::LightEquipment])) {
m_Light.Type[EQEmu::lightsource::LightEquipment] = item->Light;
m_Light.Level[EQEmu::lightsource::LightEquipment] = EQEmu::lightsource::TypeToLevel(m_Light.Type[EQEmu::lightsource::LightEquipment]);
if (EQ::lightsource::IsLevelGreater(item->Light, m_Light.Type[EQ::lightsource::LightEquipment])) {
m_Light.Type[EQ::lightsource::LightEquipment] = item->Light;
m_Light.Level[EQ::lightsource::LightEquipment] = EQ::lightsource::TypeToLevel(m_Light.Type[EQ::lightsource::LightEquipment]);
}
}
@@ -939,14 +939,14 @@ void NPC::UpdateEquipmentLight()
if (!item->IsClassCommon()) { continue; }
if (item->Light < 9 || item->Light > 13) { continue; }
if (EQEmu::lightsource::TypeToLevel(item->Light))
if (EQ::lightsource::TypeToLevel(item->Light))
general_light_type = item->Light;
}
if (EQEmu::lightsource::IsLevelGreater(general_light_type, m_Light.Type[EQEmu::lightsource::LightEquipment]))
m_Light.Type[EQEmu::lightsource::LightEquipment] = general_light_type;
if (EQ::lightsource::IsLevelGreater(general_light_type, m_Light.Type[EQ::lightsource::LightEquipment]))
m_Light.Type[EQ::lightsource::LightEquipment] = general_light_type;
m_Light.Level[EQEmu::lightsource::LightEquipment] = EQEmu::lightsource::TypeToLevel(m_Light.Type[EQEmu::lightsource::LightEquipment]);
m_Light.Level[EQ::lightsource::LightEquipment] = EQ::lightsource::TypeToLevel(m_Light.Type[EQ::lightsource::LightEquipment]);
}
void NPC::Depop(bool StartSpawnTimer) {
@@ -1586,34 +1586,34 @@ int32 NPC::GetEquipmentMaterial(uint8 material_slot) const
return texture_profile_material;
}
if (material_slot >= EQEmu::textures::materialCount) {
if (material_slot >= EQ::textures::materialCount) {
return 0;
}
int16 invslot = EQEmu::InventoryProfile::CalcSlotFromMaterial(material_slot);
int16 invslot = EQ::InventoryProfile::CalcSlotFromMaterial(material_slot);
if (invslot == INVALID_INDEX) {
return 0;
}
if (equipment[invslot] == 0) {
switch (material_slot) {
case EQEmu::textures::armorHead:
case EQ::textures::armorHead:
return helmtexture;
case EQEmu::textures::armorChest:
case EQ::textures::armorChest:
return texture;
case EQEmu::textures::armorArms:
case EQ::textures::armorArms:
return armtexture;
case EQEmu::textures::armorWrist:
case EQ::textures::armorWrist:
return bracertexture;
case EQEmu::textures::armorHands:
case EQ::textures::armorHands:
return handtexture;
case EQEmu::textures::armorLegs:
case EQ::textures::armorLegs:
return legtexture;
case EQEmu::textures::armorFeet:
case EQ::textures::armorFeet:
return feettexture;
case EQEmu::textures::weaponPrimary:
case EQ::textures::weaponPrimary:
return d_melee_texture1;
case EQEmu::textures::weaponSecondary:
case EQ::textures::weaponSecondary:
return d_melee_texture2;
default:
//they have nothing in the slot, and its not a special slot... they get nothing.
@@ -1641,7 +1641,7 @@ uint32 NPC::GetMaxDamage(uint8 tlevel)
void NPC::PickPocket(Client* thief)
{
thief->CheckIncreaseSkill(EQEmu::skills::SkillPickPockets, nullptr, 5);
thief->CheckIncreaseSkill(EQ::skills::SkillPickPockets, nullptr, 5);
//make sure were allowed to target them:
int over_level = GetLevel();
@@ -1661,7 +1661,7 @@ void NPC::PickPocket(Client* thief)
return;
}
int steal_skill = thief->GetSkill(EQEmu::skills::SkillPickPockets);
int steal_skill = thief->GetSkill(EQ::skills::SkillPickPockets);
int steal_chance = steal_skill * 100 / (5 * over_level + 5);
// Determine whether to steal money or an item.
@@ -1671,7 +1671,7 @@ void NPC::PickPocket(Client* thief)
// still needs to have FindFreeSlot vs PutItemInInventory issue worked out
while (steal_item) {
std::vector<std::pair<const EQEmu::ItemData*, uint16>> loot_selection; // <const ItemData*, charges>
std::vector<std::pair<const EQ::ItemData*, uint16>> loot_selection; // <const ItemData*, charges>
for (auto item_iter : itemlist) {
if (!item_iter || !item_iter->item_id)
continue;
@@ -1688,7 +1688,7 @@ void NPC::PickPocket(Client* thief)
}
int random = zone->random.Int(0, (loot_selection.size() - 1));
uint16 slot_id = thief->GetInv().FindFreeSlot(false, true, (loot_selection[random].first->Size), (loot_selection[random].first->ItemType == EQEmu::item::ItemTypeArrow));
uint16 slot_id = thief->GetInv().FindFreeSlot(false, true, (loot_selection[random].first->Size), (loot_selection[random].first->ItemType == EQ::item::ItemTypeArrow));
if (slot_id == INVALID_INDEX) {
steal_item = false;
break;
@@ -1769,12 +1769,12 @@ void NPC::PickPocket(Client* thief)
void NPC::Disarm(Client* client, int chance) {
// disarm primary if available, otherwise disarm secondary
const EQEmu::ItemData* weapon = NULL;
const EQ::ItemData* weapon = NULL;
uint8 eslot = 0xFF;
if (equipment[EQEmu::invslot::slotPrimary] != 0)
eslot = EQEmu::invslot::slotPrimary;
else if (equipment[EQEmu::invslot::slotSecondary] != 0)
eslot = EQEmu::invslot::slotSecondary;
if (equipment[EQ::invslot::slotPrimary] != 0)
eslot = EQ::invslot::slotPrimary;
else if (equipment[EQ::invslot::slotSecondary] != 0)
eslot = EQ::invslot::slotSecondary;
if (eslot != 0xFF) {
if (zone->random.Int(0, 1000) <= chance) {
weapon = database.GetItem(equipment[eslot]);
@@ -1792,7 +1792,7 @@ void NPC::Disarm(Client* client, int chance) {
break;
}
}
EQEmu::ItemInstance *inst = NULL;
EQ::ItemInstance *inst = NULL;
inst = database.CreateItem(weapon->ID, charges);
// Remove item from loot table
RemoveItem(weapon->ID);
@@ -1808,19 +1808,19 @@ void NPC::Disarm(Client* client, int chance) {
}
// Update Appearance
equipment[eslot] = 0;
int matslot = eslot == EQEmu::invslot::slotPrimary ? EQEmu::textures::weaponPrimary : EQEmu::textures::weaponSecondary;
int matslot = eslot == EQ::invslot::slotPrimary ? EQ::textures::weaponPrimary : EQ::textures::weaponSecondary;
if (matslot != -1)
SendWearChange(matslot);
if ((CastToMob()->GetBodyType() == BT_Humanoid || CastToMob()->GetBodyType() == BT_Summoned) && eslot == EQEmu::invslot::slotPrimary)
if ((CastToMob()->GetBodyType() == BT_Humanoid || CastToMob()->GetBodyType() == BT_Summoned) && eslot == EQ::invslot::slotPrimary)
Say("Ahh! My weapon!");
client->MessageString(Chat::Skills, DISARM_SUCCESS, this->GetCleanName());
if (chance != 1000)
client->CheckIncreaseSkill(EQEmu::skills::SkillDisarm, nullptr, 4);
client->CheckIncreaseSkill(EQ::skills::SkillDisarm, nullptr, 4);
return;
}
client->MessageString(Chat::Skills, DISARM_FAILED);
if (chance != 1000)
client->CheckIncreaseSkill(EQEmu::skills::SkillDisarm, nullptr, 2);
client->CheckIncreaseSkill(EQ::skills::SkillDisarm, nullptr, 2);
return;
}
client->MessageString(Chat::Skills, DISARM_FAILED);
@@ -3236,8 +3236,8 @@ void NPC::AIYellForHelp(Mob *sender, Mob *attacker)
void NPC::RecalculateSkills()
{
int r;
for (r = 0; r <= EQEmu::skills::HIGHEST_SKILL; r++) {
skills[r] = database.GetSkillCap(GetClass(), (EQEmu::skills::SkillType)r, level);
for (r = 0; r <= EQ::skills::HIGHEST_SKILL; r++) {
skills[r] = database.GetSkillCap(GetClass(), (EQ::skills::SkillType)r, level);
}
// some overrides -- really we need to be able to set skills for mobs in the DB
@@ -3245,15 +3245,15 @@ void NPC::RecalculateSkills()
// the theory of needing to be able to set skills for each mob separately
if (!IsBot()) {
if (level > 50) {
skills[EQEmu::skills::SkillDoubleAttack] = 250;
skills[EQEmu::skills::SkillDualWield] = 250;
skills[EQ::skills::SkillDoubleAttack] = 250;
skills[EQ::skills::SkillDualWield] = 250;
}
else if (level > 3) {
skills[EQEmu::skills::SkillDoubleAttack] = level * 5;
skills[EQEmu::skills::SkillDualWield] = skills[EQEmu::skills::SkillDoubleAttack];
skills[EQ::skills::SkillDoubleAttack] = level * 5;
skills[EQ::skills::SkillDualWield] = skills[EQ::skills::SkillDoubleAttack];
}
else {
skills[EQEmu::skills::SkillDoubleAttack] = level * 5;
skills[EQ::skills::SkillDoubleAttack] = level * 5;
}
}
}
zone/npc.h
+11 -11
View File
@@ -95,7 +95,7 @@ class Raid;
class Spawn2;
class Aura;
namespace EQEmu
namespace EQ
{
struct ItemData;
}
@@ -115,9 +115,9 @@ public:
static NPC *SpawnGridNodeNPC(std::string name, const glm::vec4 &position, uint32 grid_id, uint32 grid_number, uint32 pause);
//abstract virtual function implementations requird by base abstract class
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, eSpecialAttacks special = eSpecialAttacks::None);
virtual bool Attack(Mob* other, int Hand = EQEmu::invslot::slotPrimary, bool FromRiposte = false, bool IsStrikethrough = false,
virtual bool Death(Mob* killerMob, int32 damage, uint16 spell_id, EQ::skills::SkillType attack_skill);
virtual void Damage(Mob* from, int32 damage, uint16 spell_id, EQ::skills::SkillType attack_skill, bool avoidable = true, int8 buffslot = -1, bool iBuffTic = false, eSpecialAttacks special = eSpecialAttacks::None);
virtual bool Attack(Mob* other, int Hand = EQ::invslot::slotPrimary, bool FromRiposte = false, bool IsStrikethrough = false,
bool IsFromSpell = false, ExtraAttackOptions *opts = nullptr);
virtual bool HasRaid() { return false; }
virtual bool HasGroup() { return false; }
@@ -149,7 +149,7 @@ public:
void LevelScale();
virtual void SetTarget(Mob* mob);
virtual uint16 GetSkill(EQEmu::skills::SkillType skill_num) const { if (skill_num <= EQEmu::skills::HIGHEST_SKILL) { return skills[skill_num]; } return 0; }
virtual uint16 GetSkill(EQ::skills::SkillType skill_num) const { if (skill_num <= EQ::skills::HIGHEST_SKILL) { return skills[skill_num]; } return 0; }
void CalcItemBonuses(StatBonuses *newbon);
virtual void CalcBonuses();
@@ -168,7 +168,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, EQEmu::skills::SkillType skill = EQEmu::skills::SkillArchery, float speed = 4.0f, const char *IDFile = nullptr);
void DoRangedAttackDmg(Mob* other, bool Launch = true, int16 damage_mod = 0, int16 chance_mod = 0, EQ::skills::SkillType skill = EQ::skills::SkillArchery, float speed = 4.0f, const char *IDFile = nullptr);
bool DatabaseCastAccepted(int spell_id);
bool IsFactionListAlly(uint32 other_faction);
@@ -185,7 +185,7 @@ public:
virtual void SpellProcess();
virtual void FillSpawnStruct(NewSpawn_Struct* ns, Mob* ForWho);
void AddItem(const EQEmu::ItemData* item, uint16 charges, bool equipitem = true);
void AddItem(const EQ::ItemData* item, uint16 charges, bool equipitem = true);
void AddItem(uint32 itemid, uint16 charges, bool equipitem = true, uint32 aug1 = 0, uint32 aug2 = 0, uint32 aug3 = 0, uint32 aug4 = 0, uint32 aug5 = 0, uint32 aug6 = 0);
void AddLootTable();
void AddLootTable(uint32 ldid);
@@ -290,7 +290,7 @@ public:
void PickPocket(Client* thief);
void Disarm(Client* client, int chance);
void StartSwarmTimer(uint32 duration) { swarm_timer.Start(duration); }
void AddLootDrop(const EQEmu::ItemData*dbitem, ItemList* itemlistconst, int16 charges, uint8 minlevel, uint8 maxlevel, bool equipit, bool wearchange = false, uint32 aug1 = 0, uint32 aug2 = 0, uint32 aug3 = 0, uint32 aug4 = 0, uint32 aug5 = 0, uint32 aug6 = 0);
void AddLootDrop(const EQ::ItemData*dbitem, ItemList* itemlistconst, int16 charges, uint8 minlevel, uint8 maxlevel, bool equipit, bool wearchange = false, uint32 aug1 = 0, uint32 aug2 = 0, uint32 aug3 = 0, uint32 aug4 = 0, uint32 aug5 = 0, uint32 aug6 = 0);
virtual void DoClassAttacks(Mob *target);
void CheckSignal();
inline bool IsNotTargetableWithHotkey() const { return no_target_hotkey; }
@@ -443,7 +443,7 @@ public:
uint32 GetSpawnKillCount();
int GetScore();
void mod_prespawn(Spawn2 *sp);
int mod_npc_damage(int damage, EQEmu::skills::SkillType skillinuse, int hand, const EQEmu::ItemData* weapon, Mob* other);
int mod_npc_damage(int damage, EQ::skills::SkillType skillinuse, int hand, const EQ::ItemData* weapon, Mob* other);
void mod_npc_killed_merit(Mob* c);
void mod_npc_killed(Mob* oos);
void AISpellsList(Client *c);
@@ -587,9 +587,9 @@ protected:
uint32 roambox_delay;
uint32 roambox_min_delay;
uint16 skills[EQEmu::skills::HIGHEST_SKILL + 1];
uint16 skills[EQ::skills::HIGHEST_SKILL + 1];
uint32 equipment[EQEmu::invslot::EQUIPMENT_COUNT]; //this is an array of item IDs
uint32 equipment[EQ::invslot::EQUIPMENT_COUNT]; //this is an array of item IDs
uint32 herosforgemodel; //this is the Hero Forge Armor Model (i.e 63 or 84 or 203)
uint16 d_melee_texture1;
zone/object.cpp
+32 -32
View File
@@ -37,7 +37,7 @@ extern Zone* zone;
extern EntityList entity_list;
// Loading object from database
Object::Object(uint32 id, uint32 type, uint32 icon, const Object_Struct& object, const EQEmu::ItemInstance* inst)
Object::Object(uint32 id, uint32 type, uint32 icon, const Object_Struct& object, const EQ::ItemInstance* inst)
: respawn_timer(0), decay_timer(300000)
{
@@ -69,7 +69,7 @@ Object::Object(uint32 id, uint32 type, uint32 icon, const Object_Struct& object,
}
//creating a re-ocurring ground spawn.
Object::Object(const EQEmu::ItemInstance* inst, char* name,float max_x,float min_x,float max_y,float min_y,float z,float heading,uint32 respawntimer)
Object::Object(const EQ::ItemInstance* inst, char* name,float max_x,float min_x,float max_y,float min_y,float z,float heading,uint32 respawntimer)
: respawn_timer(respawntimer * 1000), decay_timer(300000)
{
@@ -102,7 +102,7 @@ Object::Object(const EQEmu::ItemInstance* inst, char* name,float max_x,float min
}
// Loading object from client dropping item on ground
Object::Object(Client* client, const EQEmu::ItemInstance* inst)
Object::Object(Client* client, const EQ::ItemInstance* inst)
: respawn_timer(0), decay_timer(300000)
{
user = nullptr;
@@ -120,7 +120,7 @@ Object::Object(Client* client, const EQEmu::ItemInstance* inst)
m_data.heading = client->GetHeading();
m_data.x = client->GetX();
m_data.y = client->GetY();
if (client->ClientVersion() >= EQEmu::versions::ClientVersion::RoF2)
if (client->ClientVersion() >= EQ::versions::ClientVersion::RoF2)
{
// RoF2 places items at player's Z, which is 0.625 of their height.
m_data.z = client->GetZ() - (client->GetSize() * 0.625f);
@@ -141,7 +141,7 @@ Object::Object(Client* client, const EQEmu::ItemInstance* inst)
// Set object name
if (inst) {
const EQEmu::ItemData* item = inst->GetItem();
const EQ::ItemData* item = inst->GetItem();
if (item && item->IDFile) {
if (strlen(item->IDFile) == 0) {
strcpy(m_data.object_name, DEFAULT_OBJECT_NAME);
@@ -164,7 +164,7 @@ Object::Object(Client* client, const EQEmu::ItemInstance* inst)
}
}
Object::Object(const EQEmu::ItemInstance *inst, float x, float y, float z, float heading, uint32 decay_time)
Object::Object(const EQ::ItemInstance *inst, float x, float y, float z, float heading, uint32 decay_time)
: respawn_timer(0), decay_timer(decay_time)
{
user = nullptr;
@@ -197,7 +197,7 @@ Object::Object(const EQEmu::ItemInstance *inst, float x, float y, float z, float
// Set object name
if (inst) {
const EQEmu::ItemData* item = inst->GetItem();
const EQ::ItemData* item = inst->GetItem();
if (item && item->IDFile) {
if (strlen(item->IDFile) == 0) {
strcpy(m_data.object_name, DEFAULT_OBJECT_NAME);
@@ -225,7 +225,7 @@ Object::Object(const char *model, float x, float y, float z, float heading, uint
{
user = nullptr;
last_user = nullptr;
EQEmu::ItemInstance* inst = new EQEmu::ItemInstance(ItemInstWorldContainer);
EQ::ItemInstance* inst = new EQ::ItemInstance(ItemInstWorldContainer);
// Initialize members
m_id = 0;
@@ -327,8 +327,8 @@ void Object::Delete(bool reset_state)
}
}
const EQEmu::ItemInstance* Object::GetItem(uint8 index) {
if (index < EQEmu::invtype::WORLD_SIZE) {
const EQ::ItemInstance* Object::GetItem(uint8 index) {
if (index < EQ::invtype::WORLD_SIZE) {
return m_inst->GetItem(index);
}
@@ -336,14 +336,14 @@ const EQEmu::ItemInstance* Object::GetItem(uint8 index) {
}
// Add item to object (only logical for world tradeskill containers
void Object::PutItem(uint8 index, const EQEmu::ItemInstance* inst)
void Object::PutItem(uint8 index, const EQ::ItemInstance* inst)
{
if (index > 9) {
LogError("Object::PutItem: Invalid index specified ([{}])", index);
return;
}
if (m_inst && m_inst->IsType(EQEmu::item::ItemClassBag)) {
if (m_inst && m_inst->IsType(EQ::item::ItemClassBag)) {
if (inst) {
m_inst->PutItem(index, *inst);
}
@@ -363,12 +363,12 @@ void Object::Close() {
last_user = user;
// put any remaining items from the world container back into the player's inventory to avoid item loss
// if they close the container without removing all items
EQEmu::ItemInstance* container = this->m_inst;
EQ::ItemInstance* container = this->m_inst;
if(container != nullptr)
{
for (uint8 i = EQEmu::invbag::SLOT_BEGIN; i <= EQEmu::invbag::SLOT_END; i++)
for (uint8 i = EQ::invbag::SLOT_BEGIN; i <= EQ::invbag::SLOT_END; i++)
{
EQEmu::ItemInstance* inst = container->PopItem(i);
EQ::ItemInstance* inst = container->PopItem(i);
if(inst != nullptr)
{
user->MoveItemToInventory(inst, true);
@@ -384,7 +384,7 @@ void Object::Close() {
// Remove item from container
void Object::DeleteItem(uint8 index)
{
if (m_inst && m_inst->IsType(EQEmu::item::ItemClassBag)) {
if (m_inst && m_inst->IsType(EQ::item::ItemClassBag)) {
m_inst->DeleteItem(index);
// This is _highly_ inefficient, but for now it will work: Save entire object to database
@@ -393,11 +393,11 @@ void Object::DeleteItem(uint8 index)
}
// Pop item out of container
EQEmu::ItemInstance* Object::PopItem(uint8 index)
EQ::ItemInstance* Object::PopItem(uint8 index)
{
EQEmu::ItemInstance* inst = nullptr;
EQ::ItemInstance* inst = nullptr;
if (m_inst && m_inst->IsType(EQEmu::item::ItemClassBag)) {
if (m_inst && m_inst->IsType(EQ::item::ItemClassBag)) {
inst = m_inst->PopItem(index);
// This is _highly_ inefficient, but for now it will work: Save entire object to database
@@ -510,7 +510,7 @@ bool Object::HandleClick(Client* sender, const ClickObject_Struct* click_object)
char buf[10];
snprintf(buf, 9, "%u", item->ID);
buf[9] = '\0';
std::vector<EQEmu::Any> args;
std::vector<EQ::Any> args;
args.push_back(m_inst);
if(parse->EventPlayer(EVENT_PLAYER_PICKUP, sender, buf, this->GetID(), &args))
{
@@ -530,11 +530,11 @@ bool Object::HandleClick(Client* sender, const ClickObject_Struct* click_object)
// Transfer item to client
sender->PutItemInInventory(EQEmu::invslot::slotCursor, *m_inst, false);
sender->SendItemPacket(EQEmu::invslot::slotCursor, m_inst, ItemPacketTrade);
sender->PutItemInInventory(EQ::invslot::slotCursor, *m_inst, false);
sender->SendItemPacket(EQ::invslot::slotCursor, m_inst, ItemPacketTrade);
if(cursordelete) // delete the item if it's a duplicate lore. We have to do this because the client expects the item packet
sender->DeleteItemInInventory(EQEmu::invslot::slotCursor);
sender->DeleteItemInInventory(EQ::invslot::slotCursor);
sender->DropItemQS(m_inst, true);
@@ -577,7 +577,7 @@ bool Object::HandleClick(Client* sender, const ClickObject_Struct* click_object)
else {
coa->open = 0x00;
if (sender->ClientVersion() >= EQEmu::versions::ClientVersion::RoF) {
if (sender->ClientVersion() >= EQ::versions::ClientVersion::RoF) {
coa->drop_id = 0xFFFFFFFF;
sender->Message(Chat::White, "Someone else is using that. Try again later.");
}
@@ -598,7 +598,7 @@ bool Object::HandleClick(Client* sender, const ClickObject_Struct* click_object)
// Send items inside of container
if (m_inst && m_inst->IsType(EQEmu::item::ItemClassBag)) {
if (m_inst && m_inst->IsType(EQ::item::ItemClassBag)) {
//Clear out no-drop and no-rent items first if different player opens it
if(user != last_user)
@@ -607,8 +607,8 @@ bool Object::HandleClick(Client* sender, const ClickObject_Struct* click_object)
auto outapp = new EQApplicationPacket(OP_ClientReady, 0);
sender->QueuePacket(outapp);
safe_delete(outapp);
for (uint8 i = EQEmu::invbag::SLOT_BEGIN; i <= EQEmu::invbag::SLOT_END; i++) {
const EQEmu::ItemInstance* inst = m_inst->GetItem(i);
for (uint8 i = EQ::invbag::SLOT_BEGIN; i <= EQ::invbag::SLOT_END; i++) {
const EQ::ItemInstance* inst = m_inst->GetItem(i);
if (inst) {
//sender->GetInv().PutItem(i+4000,inst);
sender->SendItemPacket(i, inst, ItemPacketWorldContainer);
@@ -621,7 +621,7 @@ bool Object::HandleClick(Client* sender, const ClickObject_Struct* click_object)
}
// Add new Zone Object (theoretically only called for items dropped to ground)
uint32 ZoneDatabase::AddObject(uint32 type, uint32 icon, const Object_Struct& object, const EQEmu::ItemInstance* inst)
uint32 ZoneDatabase::AddObject(uint32 type, uint32 icon, const Object_Struct& object, const EQ::ItemInstance* inst)
{
uint32 database_id = 0;
uint32 item_id = 0;
@@ -652,14 +652,14 @@ uint32 ZoneDatabase::AddObject(uint32 type, uint32 icon, const Object_Struct& ob
}
// Save container contents, if container
if (inst && inst->IsType(EQEmu::item::ItemClassBag))
if (inst && inst->IsType(EQ::item::ItemClassBag))
SaveWorldContainer(object.zone_id, database_id, inst);
return database_id;
}
// Update information about existing object in database
void ZoneDatabase::UpdateObject(uint32 id, uint32 type, uint32 icon, const Object_Struct& object, const EQEmu::ItemInstance* inst)
void ZoneDatabase::UpdateObject(uint32 id, uint32 type, uint32 icon, const Object_Struct& object, const EQ::ItemInstance* inst)
{
uint32 item_id = 0;
int16 charges = 0;
@@ -691,7 +691,7 @@ void ZoneDatabase::UpdateObject(uint32 id, uint32 type, uint32 icon, const Objec
}
// Save container contents, if container
if (inst && inst->IsType(EQEmu::item::ItemClassBag))
if (inst && inst->IsType(EQ::item::ItemClassBag))
SaveWorldContainer(object.zone_id, id, inst);
}
@@ -950,7 +950,7 @@ uint32 Object::GetItemID()
return 0;
}
const EQEmu::ItemData* item = this->m_inst->GetItem();
const EQ::ItemData* item = this->m_inst->GetItem();
if (item == 0)
{
zone/object.h
+11 -11
View File
@@ -30,7 +30,7 @@
class Client;
class EQApplicationPacket;
namespace EQEmu
namespace EQ
{
class ItemInstance;
}
@@ -73,7 +73,7 @@ IT10714_ACTORDEF=Augmentation Sealer
IT10725_ACTORDEF=Shuriken
*/
#define OT_DROPPEDITEM EQEmu::item::BagTypeLargeBag
#define OT_DROPPEDITEM EQ::item::BagTypeLargeBag
// Icon values:
//0x0453 a pie
@@ -93,11 +93,11 @@ class Object: public Entity
{
public:
// Loading object from database
Object(uint32 id, uint32 type, uint32 icon, const Object_Struct& data, const EQEmu::ItemInstance* inst);
Object(const EQEmu::ItemInstance* inst, char* name,float max_x,float min_x,float max_y,float min_y,float z,float heading,uint32 respawntimer);
Object(uint32 id, uint32 type, uint32 icon, const Object_Struct& data, const EQ::ItemInstance* inst);
Object(const EQ::ItemInstance* inst, char* name,float max_x,float min_x,float max_y,float min_y,float z,float heading,uint32 respawntimer);
// Loading object from client dropping item on ground
Object(Client* client, const EQEmu::ItemInstance* inst);
Object(const EQEmu::ItemInstance *inst, float x, float y, float z, float heading, uint32 decay_time = 300000);
Object(Client* client, const EQ::ItemInstance* inst);
Object(const EQ::ItemInstance *inst, float x, float y, float z, float heading, uint32 decay_time = 300000);
Object(const char *model, float x, float y, float z, float heading, uint8 type, uint32 decay_time = 0);
// Destructor
@@ -112,7 +112,7 @@ public:
static void HandleAugmentation(Client* user, const AugmentItem_Struct* in_augment, Object *worldo);
static void HandleAutoCombine(Client* user, const RecipeAutoCombine_Struct* rac);
static EQEmu::skills::SkillType TypeToSkill(uint32 type);
static EQ::skills::SkillType TypeToSkill(uint32 type);
// Packet functions
void CreateSpawnPacket(EQApplicationPacket* app);
@@ -124,10 +124,10 @@ public:
void StartDecay() {decay_timer.Start();}
// Container functions
const EQEmu::ItemInstance* GetItem(uint8 index);
void PutItem(uint8 index, const EQEmu::ItemInstance* inst);
const EQ::ItemInstance* GetItem(uint8 index);
void PutItem(uint8 index, const EQ::ItemInstance* inst);
void DeleteItem(uint8 index); // Item inside container
EQEmu::ItemInstance* PopItem(uint8 index); // Pop item out of container
EQ::ItemInstance* PopItem(uint8 index); // Pop item out of container
// Override base class implementations
virtual bool IsObject() const { return true; }
@@ -180,7 +180,7 @@ protected:
void RandomSpawn(bool send_packet = false); //spawn this ground spawn at a random place
Object_Struct m_data; // Packet data
EQEmu::ItemInstance *m_inst; // Item representing object
EQ::ItemInstance *m_inst; // Item representing object
bool m_inuse; // Currently in use by a client?
uint32 m_id; // Database key, different than drop_id
uint32 m_type; // Object Type, ie, forge, oven, dropped item, etc (ref: ContainerUseTypes)
zone/pathfinder_nav_mesh.cpp
+1 -1
View File
@@ -432,7 +432,7 @@ void PathfinderNavmesh::Load(const std::string &path)
std::vector<char> buffer;
buffer.resize(buffer_size);
uint32_t v = EQEmu::InflateData(&data[0], data_size, &buffer[0], buffer_size);
uint32_t v = EQ::InflateData(&data[0], data_size, &buffer[0], buffer_size);
fclose(f);
char *buf = &buffer[0];
zone/pathing.cpp
+4 -4
View File
@@ -40,14 +40,14 @@ void CullPoints(std::vector<FindPerson_Point> &points) {
}
void Client::SendPathPacket(const std::vector<FindPerson_Point> &points) {
EQEmu::Any data(points);
EQ::Any data(points);
EQ::Task([=](EQ::Task::ResolveFn resolve, EQ::Task::RejectFn reject) {
auto points = EQEmu::any_cast<std::vector<FindPerson_Point>>(data);
auto points = EQ::any_cast<std::vector<FindPerson_Point>>(data);
CullPoints(points);
resolve(points);
})
.Then([this](const EQEmu::Any &result) {
auto points = EQEmu::any_cast<std::vector<FindPerson_Point>>(result);
.Then([this](const EQ::Any &result) {
auto points = EQ::any_cast<std::vector<FindPerson_Point>>(result);
if (points.size() < 2) {
if (Admin() > 10) {
Message(Chat::System, "Too few points");
zone/perl_client.cpp
+13 -13
View File
@@ -1891,7 +1891,7 @@ XS(XS_Client_GetSkill) {
Client *THIS;
uint16 RETVAL;
dXSTARG;
EQEmu::skills::SkillType skill_id = (EQEmu::skills::SkillType) SvUV(ST(1));
EQ::skills::SkillType skill_id = (EQ::skills::SkillType) SvUV(ST(1));
if (sv_derived_from(ST(0), "Client")) {
IV tmp = SvIV((SV *) SvRV(ST(0)));
@@ -1917,7 +1917,7 @@ XS(XS_Client_GetRawSkill) {
Client *THIS;
uint32 RETVAL;
dXSTARG;
EQEmu::skills::SkillType skill_id = (EQEmu::skills::SkillType) SvUV(ST(1));
EQ::skills::SkillType skill_id = (EQ::skills::SkillType) SvUV(ST(1));
if (sv_derived_from(ST(0), "Client")) {
IV tmp = SvIV((SV *) SvRV(ST(0)));
@@ -1942,7 +1942,7 @@ XS(XS_Client_HasSkill) {
{
Client *THIS;
bool RETVAL;
EQEmu::skills::SkillType skill_id = (EQEmu::skills::SkillType) SvUV(ST(1));
EQ::skills::SkillType skill_id = (EQ::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_CanHaveSkill) {
{
Client *THIS;
bool RETVAL;
EQEmu::skills::SkillType skill_id = (EQEmu::skills::SkillType) SvUV(ST(1));
EQ::skills::SkillType skill_id = (EQ::skills::SkillType) SvUV(ST(1));
if (sv_derived_from(ST(0), "Client")) {
IV tmp = SvIV((SV *) SvRV(ST(0)));
@@ -1991,7 +1991,7 @@ XS(XS_Client_SetSkill) {
Perl_croak(aTHX_ "Usage: Client::SetSkill(THIS, int skill_id, uint16 value)");
{
Client *THIS;
EQEmu::skills::SkillType skill_num = (EQEmu::skills::SkillType) SvUV(ST(1));
EQ::skills::SkillType skill_num = (EQ::skills::SkillType) SvUV(ST(1));
uint16 value = (uint16) SvUV(ST(2));
if (sv_derived_from(ST(0), "Client")) {
@@ -2014,7 +2014,7 @@ XS(XS_Client_AddSkill) {
Perl_croak(aTHX_ "Usage: Client::AddSkill(THIS, int skill_id, uint16 value)");
{
Client *THIS;
EQEmu::skills::SkillType skillid = (EQEmu::skills::SkillType) SvUV(ST(1));
EQ::skills::SkillType skillid = (EQ::skills::SkillType) SvUV(ST(1));
uint16 value = (uint16) SvUV(ST(2));
if (sv_derived_from(ST(0), "Client")) {
@@ -2060,7 +2060,7 @@ XS(XS_Client_CheckIncreaseSkill) {
{
Client *THIS;
bool RETVAL;
EQEmu::skills::SkillType skillid = (EQEmu::skills::SkillType) SvUV(ST(1));
EQ::skills::SkillType skillid = (EQ::skills::SkillType) SvUV(ST(1));
int chancemodi;
if (sv_derived_from(ST(0), "Client")) {
@@ -2116,7 +2116,7 @@ XS(XS_Client_MaxSkill) {
{
Client *THIS;
uint16 RETVAL;
EQEmu::skills::SkillType skillid = (EQEmu::skills::SkillType) SvUV(ST(1));
EQ::skills::SkillType skillid = (EQ::skills::SkillType) SvUV(ST(1));
uint16 class_ = 0;
uint16 level = 0;
dXSTARG;
@@ -3148,7 +3148,7 @@ XS(XS_Client_SummonItem) {
uint32 aug3 = 0;
uint32 aug4 = 0;
uint32 aug5 = 0;
uint16 slot_id = EQEmu::invslot::slotCursor;
uint16 slot_id = EQ::invslot::slotCursor;
if (sv_derived_from(ST(0), "Client")) {
IV tmp = SvIV((SV *) SvRV(ST(0)));
@@ -4206,7 +4206,7 @@ XS(XS_Client_GetItemAt) {
Perl_croak(aTHX_ "Usage: Client::GetItemAt(THIS, uint32 slot)");
{
Client *THIS;
EQEmu::ItemInstance *RETVAL;
EQ::ItemInstance *RETVAL;
uint32 slot = (int32) SvIV(ST(1));
if (sv_derived_from(ST(0), "Client")) {
@@ -4231,7 +4231,7 @@ XS(XS_Client_GetAugmentAt) {
Perl_croak(aTHX_ "Usage: Client::GetAugmentAt(THIS, uint32 slot, uint32 aug_slot)");
{
Client *THIS;
EQEmu::ItemInstance *RETVAL;
EQ::ItemInstance *RETVAL;
uint32 slot = (int32) SvIV(ST(1));
uint32 aug_slot = (int32) SvIV(ST(1));
@@ -4243,7 +4243,7 @@ XS(XS_Client_GetAugmentAt) {
if (THIS == nullptr)
Perl_croak(aTHX_ "THIS is nullptr, avoiding crash.");
EQEmu::ItemInstance *inst = THIS->GetInv().GetItem(slot);
EQ::ItemInstance *inst = THIS->GetInv().GetItem(slot);
if (inst) {
RETVAL = inst->GetAugment(aug_slot);
} else {
@@ -5431,7 +5431,7 @@ XS(XS_Client_GetItemInInventory) {
{
Client *THIS;
int16 slot_id = (int16) SvIV(ST(1));
EQEmu::ItemInstance *RETVAL = nullptr;
EQ::ItemInstance *RETVAL = nullptr;
if (sv_derived_from(ST(0), "Client")) {
IV tmp = SvIV((SV *) SvRV(ST(0)));
zone/perl_mob.cpp
+15 -15
View File
@@ -606,7 +606,7 @@ XS(XS_Mob_GetSkill) {
Mob *THIS;
uint32 RETVAL;
dXSTARG;
EQEmu::skills::SkillType skill_num = (EQEmu::skills::SkillType) SvUV(ST(1));
EQ::skills::SkillType skill_num = (EQ::skills::SkillType) SvUV(ST(1));
if (sv_derived_from(ST(0), "Mob")) {
IV tmp = SvIV((SV *) SvRV(ST(0)));
@@ -872,7 +872,7 @@ XS(XS_Mob_Damage) {
Mob *from;
int32 damage = (int32) SvIV(ST(2));
uint16 spell_id = (uint16) SvUV(ST(3));
EQEmu::skills::SkillType attack_skill = (EQEmu::skills::SkillType) SvUV(ST(4));
EQ::skills::SkillType attack_skill = (EQ::skills::SkillType) SvUV(ST(4));
bool avoidable;
int8 buffslot;
bool iBuffTic;
@@ -3830,7 +3830,7 @@ XS(XS_Mob_CastSpell) {
Mob *THIS;
uint16 spell_id = (uint16) SvUV(ST(1));
uint16 target_id = (uint16) SvUV(ST(2));
EQEmu::spells::CastingSlot slot;
EQ::spells::CastingSlot slot;
int32 casttime;
int32 mana_cost;
int16 resist_adjust;
@@ -3844,9 +3844,9 @@ XS(XS_Mob_CastSpell) {
Perl_croak(aTHX_ "THIS is nullptr, avoiding crash.");
if (items < 4)
slot = EQEmu::spells::CastingSlot::Item;
slot = EQ::spells::CastingSlot::Item;
else {
slot = static_cast<EQEmu::spells::CastingSlot>(SvUV(ST(3)));
slot = static_cast<EQ::spells::CastingSlot>(SvUV(ST(3)));
}
if (items < 5)
@@ -3919,7 +3919,7 @@ XS(XS_Mob_SpellFinished) {
resist_diff = spells[spell_id].ResistDiff;
}
THIS->SpellFinished(spell_id, spell_target, EQEmu::spells::CastingSlot::Item, mana_cost, -1, resist_diff);
THIS->SpellFinished(spell_id, spell_target, EQ::spells::CastingSlot::Item, mana_cost, -1, resist_diff);
}
XSRETURN_EMPTY;
}
@@ -6494,7 +6494,7 @@ XS(XS_Mob_DoSpecialAttackDamage) {
{
Mob *THIS;
Mob *target;
EQEmu::skills::SkillType attack_skill = (EQEmu::skills::SkillType) SvUV(ST(2));
EQ::skills::SkillType attack_skill = (EQ::skills::SkillType) SvUV(ST(2));
int32 max_damage = (int32) SvIV(ST(3));
int32 min_damage = 1;
int32 hate_override = -11;
@@ -7401,7 +7401,7 @@ XS(XS_Mob_ModSkillDmgTaken) {
Perl_croak(aTHX_ "Usage: Mob::ModSkillDmgTaken(THIS, int skill, int16 value)");
{
Mob *THIS;
EQEmu::skills::SkillType skill_num = (EQEmu::skills::SkillType) SvUV(ST(1));
EQ::skills::SkillType skill_num = (EQ::skills::SkillType) SvUV(ST(1));
int16 value = (int16) SvIV(ST(2));
if (sv_derived_from(ST(0), "Mob")) {
@@ -7426,7 +7426,7 @@ XS(XS_Mob_GetModSkillDmgTaken) {
Mob *THIS;
int16 RETVAL;
dXSTARG;
EQEmu::skills::SkillType skill_num = (EQEmu::skills::SkillType) SvUV(ST(1));
EQ::skills::SkillType skill_num = (EQ::skills::SkillType) SvUV(ST(1));
if (sv_derived_from(ST(0), "Mob")) {
IV tmp = SvIV((SV *) SvRV(ST(0)));
@@ -7452,7 +7452,7 @@ XS(XS_Mob_GetSkillDmgTaken) {
Mob *THIS;
int32 RETVAL;
dXSTARG;
EQEmu::skills::SkillType skill_num = (EQEmu::skills::SkillType) SvUV(ST(1));
EQ::skills::SkillType skill_num = (EQ::skills::SkillType) SvUV(ST(1));
if (sv_derived_from(ST(0), "Mob")) {
IV tmp = SvIV((SV *) SvRV(ST(0)));
@@ -7607,7 +7607,7 @@ XS(XS_Mob_DoMeleeSkillAttackDmg) {
Mob *THIS;
Mob *target;
uint16 weapon_damage = (uint16) SvIV(ST(2));
EQEmu::skills::SkillType skill = (EQEmu::skills::SkillType) SvUV(ST(3));
EQ::skills::SkillType skill = (EQ::skills::SkillType) SvUV(ST(3));
int16 chance_mod = (int16) SvIV(ST(4));
int16 focus = (int16) SvIV(ST(5));
uint8 CanRiposte = (uint8) SvIV(ST(6));
@@ -7641,8 +7641,8 @@ XS(XS_Mob_DoArcheryAttackDmg) {
{
Mob *THIS;
Mob *target;
EQEmu::ItemInstance *RangeWeapon = nullptr;
EQEmu::ItemInstance *Ammo = nullptr;
EQ::ItemInstance *RangeWeapon = nullptr;
EQ::ItemInstance *Ammo = nullptr;
uint16 weapon_damage = (uint16) SvIV(ST(4));
int16 chance_mod = (int16) SvIV(ST(5));
int16 focus = (int16) SvIV(ST(6));
@@ -7676,8 +7676,8 @@ XS(XS_Mob_DoThrowingAttackDmg) {
{
Mob *THIS;
Mob *target;
EQEmu::ItemInstance *RangeWeapon = nullptr;
EQEmu::ItemData *item = nullptr;
EQ::ItemInstance *RangeWeapon = nullptr;
EQ::ItemData *item = nullptr;
uint16 weapon_damage = (uint16) SvIV(ST(4));
int16 chance_mod = (int16) SvIV(ST(5));
int16 focus = (int16) SvIV(ST(6));
zone/perl_questitem.cpp
+26 -26
View File
@@ -40,15 +40,15 @@ XS(XS_QuestItem_GetName) {
if (items != 1)
Perl_croak(aTHX_ "Usage: QuestItem::GetName(THIS)");
{
EQEmu::ItemInstance *THIS;
EQ::ItemInstance *THIS;
Const_char *RETVAL;
dXSTARG;
if (sv_derived_from(ST(0), "QuestItem")) {
IV tmp = SvIV((SV *) SvRV(ST(0)));
THIS = INT2PTR(EQEmu::ItemInstance *, tmp);
THIS = INT2PTR(EQ::ItemInstance *, tmp);
} else
Perl_croak(aTHX_ "THIS is not of type EQEmu::ItemInstance");
Perl_croak(aTHX_ "THIS is not of type EQ::ItemInstance");
if (THIS == nullptr)
Perl_croak(aTHX_ "THIS is nullptr, avoiding crash.");
@@ -66,14 +66,14 @@ XS(XS_QuestItem_SetScale) {
if (items != 2)
Perl_croak(aTHX_ "Usage: QuestItem::SetScale(THIS, float scale_multiplier)");
{
EQEmu::ItemInstance *THIS;
EQ::ItemInstance *THIS;
float Mult;
if (sv_derived_from(ST(0), "QuestItem")) {
IV tmp = SvIV((SV *) SvRV(ST(0)));
THIS = INT2PTR(EQEmu::ItemInstance *, tmp);
THIS = INT2PTR(EQ::ItemInstance *, tmp);
} else
Perl_croak(aTHX_ "THIS is not of type EQEmu::ItemInstance");
Perl_croak(aTHX_ "THIS is not of type EQ::ItemInstance");
if (THIS == nullptr)
Perl_croak(aTHX_ "THIS is nullptr, avoiding crash.");
@@ -92,15 +92,15 @@ XS(XS_QuestItem_ItemSay) {
if (items != 2 && items != 3)
Perl_croak(aTHX_ "Usage: QuestItem::ItemSay(THIS, string text [int language_id])");
{
EQEmu::ItemInstance *THIS;
EQ::ItemInstance *THIS;
Const_char *text;
int lang = 0;
if (sv_derived_from(ST(0), "QuestItem")) {
IV tmp = SvIV((SV *) SvRV(ST(0)));
THIS = INT2PTR(EQEmu::ItemInstance *, tmp);
THIS = INT2PTR(EQ::ItemInstance *, tmp);
} else
Perl_croak(aTHX_ "THIS is not of type EQEmu::ItemInstance");
Perl_croak(aTHX_ "THIS is not of type EQ::ItemInstance");
if (THIS == nullptr)
Perl_croak(aTHX_ "THIS is nullptr, avoiding crash.");
@@ -119,19 +119,19 @@ XS(XS_QuestItem_IsType) {
if (items != 2)
Perl_croak(aTHX_ "Usage: QuestItem::IsType(THIS, type)");
{
EQEmu::ItemInstance *THIS;
EQ::ItemInstance *THIS;
bool RETVAL;
uint32 type = (int32) SvIV(ST(1));
if (sv_derived_from(ST(0), "QuestItem")) {
IV tmp = SvIV((SV *) SvRV(ST(0)));
THIS = INT2PTR(EQEmu::ItemInstance *, tmp);
THIS = INT2PTR(EQ::ItemInstance *, tmp);
} else
Perl_croak(aTHX_ "THIS is not of type EQEmu::ItemInstance");
Perl_croak(aTHX_ "THIS is not of type EQ::ItemInstance");
if (THIS == nullptr)
Perl_croak(aTHX_ "THIS is nullptr, avoiding crash.");
RETVAL = THIS->IsType((EQEmu::item::ItemClass) type);
RETVAL = THIS->IsType((EQ::item::ItemClass) type);
ST(0) = boolSV(RETVAL);
sv_2mortal(ST(0));
}
@@ -144,14 +144,14 @@ XS(XS_QuestItem_IsAttuned) {
if (items != 1)
Perl_croak(aTHX_ "Usage: QuestItem::IsAttuned(THIS)");
{
EQEmu::ItemInstance *THIS;
EQ::ItemInstance *THIS;
bool RETVAL;
if (sv_derived_from(ST(0), "QuestItem")) {
IV tmp = SvIV((SV *) SvRV(ST(0)));
THIS = INT2PTR(EQEmu::ItemInstance *, tmp);
THIS = INT2PTR(EQ::ItemInstance *, tmp);
} else
Perl_croak(aTHX_ "THIS is not of type EQEmu::ItemInstance");
Perl_croak(aTHX_ "THIS is not of type EQ::ItemInstance");
if (THIS == nullptr)
Perl_croak(aTHX_ "THIS is nullptr, avoiding crash.");
@@ -168,15 +168,15 @@ XS(XS_QuestItem_GetCharges) {
if (items != 1)
Perl_croak(aTHX_ "Usage: QuestItem::GetCharges(THIS)");
{
EQEmu::ItemInstance *THIS;
EQ::ItemInstance *THIS;
int16 RETVAL;
dXSTARG;
if (sv_derived_from(ST(0), "QuestItem")) {
IV tmp = SvIV((SV *) SvRV(ST(0)));
THIS = INT2PTR(EQEmu::ItemInstance *, tmp);
THIS = INT2PTR(EQ::ItemInstance *, tmp);
} else
Perl_croak(aTHX_ "THIS is not of type EQEmu::ItemInstance");
Perl_croak(aTHX_ "THIS is not of type EQ::ItemInstance");
if (THIS == nullptr)
Perl_croak(aTHX_ "THIS is nullptr, avoiding crash.");
@@ -193,15 +193,15 @@ XS(XS_QuestItem_GetAugment) {
if (items != 2)
Perl_croak(aTHX_ "Usage: QuestItem::GetAugment(THIS, int16 slot_id)");
{
EQEmu::ItemInstance *THIS;
EQ::ItemInstance *THIS;
int16 slot_id = (int16) SvIV(ST(1));
EQEmu::ItemInstance *RETVAL;
EQ::ItemInstance *RETVAL;
if (sv_derived_from(ST(0), "QuestItem")) {
IV tmp = SvIV((SV *) SvRV(ST(0)));
THIS = INT2PTR(EQEmu::ItemInstance *, tmp);
THIS = INT2PTR(EQ::ItemInstance *, tmp);
} else
Perl_croak(aTHX_ "THIS is not of type EQEmu::ItemInstance");
Perl_croak(aTHX_ "THIS is not of type EQ::ItemInstance");
if (THIS == nullptr)
Perl_croak(aTHX_ "THIS is nullptr, avoiding crash.");
@@ -218,15 +218,15 @@ XS(XS_QuestItem_GetID) {
if (items != 1)
Perl_croak(aTHX_ "Usage: QuestItem::GetID(THIS)");
{
EQEmu::ItemInstance *THIS;
EQ::ItemInstance *THIS;
uint32 RETVAL;
dXSTARG;
if (sv_derived_from(ST(0), "QuestItem")) {
IV tmp = SvIV((SV *) SvRV(ST(0)));
THIS = INT2PTR(EQEmu::ItemInstance *, tmp);
THIS = INT2PTR(EQ::ItemInstance *, tmp);
} else
Perl_croak(aTHX_ "THIS is not of type EQEmu::ItemInstance");
Perl_croak(aTHX_ "THIS is not of type EQ::ItemInstance");
if (THIS == nullptr)
Perl_croak(aTHX_ "THIS is nullptr, avoiding crash.");
zone/pets.cpp
+8 -8
View File
@@ -385,12 +385,12 @@ void Mob::MakePoweredPet(uint16 spell_id, const char* pettype, int16 petpower,
// the base items for the pet. These are always loaded
// so that a rank 1 suspend minion does not kill things
// like the special back items some focused pets may receive.
uint32 petinv[EQEmu::invslot::EQUIPMENT_COUNT];
uint32 petinv[EQ::invslot::EQUIPMENT_COUNT];
memset(petinv, 0, sizeof(petinv));
const EQEmu::ItemData *item = nullptr;
const EQ::ItemData *item = nullptr;
if (database.GetBasePetItems(record.equipmentset, petinv)) {
for (int i = EQEmu::invslot::EQUIPMENT_BEGIN; i <= EQEmu::invslot::EQUIPMENT_END; i++)
for (int i = EQ::invslot::EQUIPMENT_BEGIN; i <= EQ::invslot::EQUIPMENT_END; i++)
if (petinv[i]) {
item = database.GetItem(petinv[i]);
npc->AddLootDrop(item, &npc->itemlist, 0, 1, 127, true, true);
@@ -524,10 +524,10 @@ void NPC::GetPetState(SpellBuff_Struct *pet_buffs, uint32 *items, char *name) {
strn0cpy(name, GetName(), 64);
//save their items, we only care about what they are actually wearing
memcpy(items, equipment, sizeof(uint32) * EQEmu::invslot::EQUIPMENT_COUNT);
memcpy(items, equipment, sizeof(uint32) * EQ::invslot::EQUIPMENT_COUNT);
//save their buffs.
for (int i=EQEmu::invslot::EQUIPMENT_BEGIN; i < GetPetMaxTotalSlots(); i++) {
for (int i=EQ::invslot::EQUIPMENT_BEGIN; i < GetPetMaxTotalSlots(); i++) {
if (buffs[i].spellid != SPELL_UNKNOWN) {
pet_buffs[i].spellid = buffs[i].spellid;
pet_buffs[i].effect_type = i+1;
@@ -612,11 +612,11 @@ void NPC::SetPetState(SpellBuff_Struct *pet_buffs, uint32 *items) {
}
//restore their equipment...
for (i = EQEmu::invslot::EQUIPMENT_BEGIN; i <= EQEmu::invslot::EQUIPMENT_END; i++) {
for (i = EQ::invslot::EQUIPMENT_BEGIN; i <= EQ::invslot::EQUIPMENT_END; i++) {
if(items[i] == 0)
continue;
const EQEmu::ItemData* item2 = database.GetItem(items[i]);
const EQ::ItemData* item2 = database.GetItem(items[i]);
if (item2) {
bool noDrop=(item2->NoDrop == 0); // Field is reverse logic
@@ -679,7 +679,7 @@ bool ZoneDatabase::GetBasePetItems(int32 equipmentset, uint32 *items) {
{
slot = atoi(row[0]);
if (slot > EQEmu::invslot::EQUIPMENT_END)
if (slot > EQ::invslot::EQUIPMENT_END)
continue;
if (items[slot] == 0)
zone/quest_interface.h
+16 -16
View File
@@ -26,7 +26,7 @@
class Client;
class NPC;
namespace EQEmu
namespace EQ
{
class ItemInstance;
}
@@ -34,44 +34,44 @@ namespace EQEmu
class QuestInterface {
public:
virtual int EventNPC(QuestEventID evt, NPC* npc, Mob *init, std::string data, uint32 extra_data,
std::vector<EQEmu::Any> *extra_pointers) { return 0; }
std::vector<EQ::Any> *extra_pointers) { return 0; }
virtual int EventGlobalNPC(QuestEventID evt, NPC* npc, Mob *init, std::string data, uint32 extra_data,
std::vector<EQEmu::Any> *extra_pointers) { return 0; }
std::vector<EQ::Any> *extra_pointers) { return 0; }
virtual int EventPlayer(QuestEventID evt, Client *client, std::string data, uint32 extra_data,
std::vector<EQEmu::Any> *extra_pointers) { return 0; }
std::vector<EQ::Any> *extra_pointers) { return 0; }
virtual int EventGlobalPlayer(QuestEventID evt, Client *client, std::string data, uint32 extra_data,
std::vector<EQEmu::Any> *extra_pointers) { return 0; }
virtual int EventItem(QuestEventID evt, Client *client, EQEmu::ItemInstance *item, Mob *mob, std::string data, uint32 extra_data,
std::vector<EQEmu::Any> *extra_pointers) { return 0; }
std::vector<EQ::Any> *extra_pointers) { return 0; }
virtual int EventItem(QuestEventID evt, Client *client, EQ::ItemInstance *item, Mob *mob, std::string data, uint32 extra_data,
std::vector<EQ::Any> *extra_pointers) { return 0; }
virtual int EventSpell(QuestEventID evt, NPC* npc, Client *client, uint32 spell_id, uint32 extra_data,
std::vector<EQEmu::Any> *extra_pointers) { return 0; }
std::vector<EQ::Any> *extra_pointers) { return 0; }
virtual int EventEncounter(QuestEventID evt, std::string encounter_name, std::string data, uint32 extra_data,
std::vector<EQEmu::Any> *extra_pointers) { return 0; }
std::vector<EQ::Any> *extra_pointers) { return 0; }
virtual bool HasQuestSub(uint32 npcid, QuestEventID evt) { return false; }
virtual bool HasGlobalQuestSub(QuestEventID evt) { return false; }
virtual bool PlayerHasQuestSub(QuestEventID evt) { return false; }
virtual bool GlobalPlayerHasQuestSub(QuestEventID evt) { return false; }
virtual bool SpellHasQuestSub(uint32 spell_id, QuestEventID evt) { return false; }
virtual bool ItemHasQuestSub(EQEmu::ItemInstance *itm, QuestEventID evt) { return false; }
virtual bool ItemHasQuestSub(EQ::ItemInstance *itm, QuestEventID evt) { return false; }
virtual bool EncounterHasQuestSub(std::string encounter_name, QuestEventID evt) { return false; }
virtual void LoadNPCScript(std::string filename, int npc_id) { }
virtual void LoadGlobalNPCScript(std::string filename) { }
virtual void LoadPlayerScript(std::string filename) { }
virtual void LoadGlobalPlayerScript(std::string filename) { }
virtual void LoadItemScript(std::string filename, EQEmu::ItemInstance *item) { }
virtual void LoadItemScript(std::string filename, EQ::ItemInstance *item) { }
virtual void LoadSpellScript(std::string filename, uint32 spell_id) { }
virtual void LoadEncounterScript(std::string filename, std::string encounter_name) { }
virtual int DispatchEventNPC(QuestEventID evt, NPC* npc, Mob *init, std::string data, uint32 extra_data,
std::vector<EQEmu::Any> *extra_pointers) { return 0; }
std::vector<EQ::Any> *extra_pointers) { return 0; }
virtual int DispatchEventPlayer(QuestEventID evt, Client *client, std::string data, uint32 extra_data,
std::vector<EQEmu::Any> *extra_pointers) { return 0; }
virtual int DispatchEventItem(QuestEventID evt, Client *client, EQEmu::ItemInstance *item, Mob *mob, std::string data, uint32 extra_data,
std::vector<EQEmu::Any> *extra_pointers) { return 0; }
std::vector<EQ::Any> *extra_pointers) { return 0; }
virtual int DispatchEventItem(QuestEventID evt, Client *client, EQ::ItemInstance *item, Mob *mob, std::string data, uint32 extra_data,
std::vector<EQ::Any> *extra_pointers) { return 0; }
virtual int DispatchEventSpell(QuestEventID evt, NPC* npc, Client *client, uint32 spell_id, uint32 extra_data,
std::vector<EQEmu::Any> *extra_pointers) { return 0; }
std::vector<EQ::Any> *extra_pointers) { return 0; }
virtual void AddVar(std::string name, std::string val) { }
virtual std::string GetVar(std::string name) { return std::string(); }
zone/quest_parser_collection.cpp
+16 -16
View File
@@ -201,7 +201,7 @@ bool QuestParserCollection::SpellHasQuestSub(uint32 spell_id, QuestEventID evt)
return false;
}
bool QuestParserCollection::ItemHasQuestSub(EQEmu::ItemInstance *itm, QuestEventID evt) {
bool QuestParserCollection::ItemHasQuestSub(EQ::ItemInstance *itm, QuestEventID evt) {
if (itm == nullptr)
return false;
@@ -238,7 +238,7 @@ bool QuestParserCollection::ItemHasQuestSub(EQEmu::ItemInstance *itm, QuestEvent
}
int QuestParserCollection::EventNPC(QuestEventID evt, NPC *npc, Mob *init, std::string data, uint32 extra_data,
std::vector<EQEmu::Any> *extra_pointers) {
std::vector<EQ::Any> *extra_pointers) {
int rd = DispatchEventNPC(evt, npc, init, data, extra_data, extra_pointers);
int rl = EventNPCLocal(evt, npc, init, data, extra_data, extra_pointers);
int rg = EventNPCGlobal(evt, npc, init, data, extra_data, extra_pointers);
@@ -256,7 +256,7 @@ int QuestParserCollection::EventNPC(QuestEventID evt, NPC *npc, Mob *init, std::
}
int QuestParserCollection::EventNPCLocal(QuestEventID evt, NPC* npc, Mob *init, std::string data, uint32 extra_data,
std::vector<EQEmu::Any> *extra_pointers) {
std::vector<EQ::Any> *extra_pointers) {
auto iter = _npc_quest_status.find(npc->GetNPCTypeID());
if(iter != _npc_quest_status.end()) {
//loaded or failed to load
@@ -279,7 +279,7 @@ int QuestParserCollection::EventNPCLocal(QuestEventID evt, NPC* npc, Mob *init,
}
int QuestParserCollection::EventNPCGlobal(QuestEventID evt, NPC* npc, Mob *init, std::string data, uint32 extra_data,
std::vector<EQEmu::Any> *extra_pointers) {
std::vector<EQ::Any> *extra_pointers) {
if(_global_npc_quest_status != QuestUnloaded && _global_npc_quest_status != QuestFailedToLoad) {
auto qiter = _interfaces.find(_global_npc_quest_status);
return qiter->second->EventGlobalNPC(evt, npc, init, data, extra_data, extra_pointers);
@@ -299,7 +299,7 @@ int QuestParserCollection::EventNPCGlobal(QuestEventID evt, NPC* npc, Mob *init,
}
int QuestParserCollection::EventPlayer(QuestEventID evt, Client *client, std::string data, uint32 extra_data,
std::vector<EQEmu::Any> *extra_pointers) {
std::vector<EQ::Any> *extra_pointers) {
int rd = DispatchEventPlayer(evt, client, data, extra_data, extra_pointers);
int rl = EventPlayerLocal(evt, client, data, extra_data, extra_pointers);
int rg = EventPlayerGlobal(evt, client, data, extra_data, extra_pointers);
@@ -317,7 +317,7 @@ int QuestParserCollection::EventPlayer(QuestEventID evt, Client *client, std::st
}
int QuestParserCollection::EventPlayerLocal(QuestEventID evt, Client *client, std::string data, uint32 extra_data,
std::vector<EQEmu::Any> *extra_pointers) {
std::vector<EQ::Any> *extra_pointers) {
if(_player_quest_status == QuestUnloaded) {
std::string filename;
QuestInterface *qi = GetQIByPlayerQuest(filename);
@@ -336,7 +336,7 @@ int QuestParserCollection::EventPlayerLocal(QuestEventID evt, Client *client, st
}
int QuestParserCollection::EventPlayerGlobal(QuestEventID evt, Client *client, std::string data, uint32 extra_data,
std::vector<EQEmu::Any> *extra_pointers) {
std::vector<EQ::Any> *extra_pointers) {
if(_global_player_quest_status == QuestUnloaded) {
std::string filename;
QuestInterface *qi = GetQIByGlobalPlayerQuest(filename);
@@ -354,8 +354,8 @@ int QuestParserCollection::EventPlayerGlobal(QuestEventID evt, Client *client, s
return 0;
}
int QuestParserCollection::EventItem(QuestEventID evt, Client *client, EQEmu::ItemInstance *item, Mob *mob, std::string data, uint32 extra_data,
std::vector<EQEmu::Any> *extra_pointers) {
int QuestParserCollection::EventItem(QuestEventID evt, Client *client, EQ::ItemInstance *item, Mob *mob, std::string data, uint32 extra_data,
std::vector<EQ::Any> *extra_pointers) {
// needs pointer validation check on 'item' argument
std::string item_script;
@@ -403,7 +403,7 @@ int QuestParserCollection::EventItem(QuestEventID evt, Client *client, EQEmu::It
}
int QuestParserCollection::EventSpell(QuestEventID evt, NPC* npc, Client *client, uint32 spell_id, uint32 extra_data,
std::vector<EQEmu::Any> *extra_pointers) {
std::vector<EQ::Any> *extra_pointers) {
auto iter = _spell_quest_status.find(spell_id);
if(iter != _spell_quest_status.end()) {
//loaded or failed to load
@@ -440,7 +440,7 @@ int QuestParserCollection::EventSpell(QuestEventID evt, NPC* npc, Client *client
}
int QuestParserCollection::EventEncounter(QuestEventID evt, std::string encounter_name, std::string data, uint32 extra_data,
std::vector<EQEmu::Any> *extra_pointers) {
std::vector<EQ::Any> *extra_pointers) {
auto iter = _encounter_quest_status.find(encounter_name);
if(iter != _encounter_quest_status.end()) {
//loaded or failed to load
@@ -993,7 +993,7 @@ void QuestParserCollection::GetErrors(std::list<std::string> &err) {
}
int QuestParserCollection::DispatchEventNPC(QuestEventID evt, NPC* npc, Mob *init, std::string data, uint32 extra_data,
std::vector<EQEmu::Any> *extra_pointers) {
std::vector<EQ::Any> *extra_pointers) {
int ret = 0;
auto iter = _load_precedence.begin();
while(iter != _load_precedence.end()) {
@@ -1007,7 +1007,7 @@ int QuestParserCollection::DispatchEventNPC(QuestEventID evt, NPC* npc, Mob *ini
}
int QuestParserCollection::DispatchEventPlayer(QuestEventID evt, Client *client, std::string data, uint32 extra_data,
std::vector<EQEmu::Any> *extra_pointers) {
std::vector<EQ::Any> *extra_pointers) {
int ret = 0;
auto iter = _load_precedence.begin();
while(iter != _load_precedence.end()) {
@@ -1020,8 +1020,8 @@ int QuestParserCollection::DispatchEventPlayer(QuestEventID evt, Client *client,
return ret;
}
int QuestParserCollection::DispatchEventItem(QuestEventID evt, Client *client, EQEmu::ItemInstance *item, Mob *mob, std::string data,
uint32 extra_data, std::vector<EQEmu::Any> *extra_pointers) {
int QuestParserCollection::DispatchEventItem(QuestEventID evt, Client *client, EQ::ItemInstance *item, Mob *mob, std::string data,
uint32 extra_data, std::vector<EQ::Any> *extra_pointers) {
int ret = 0;
auto iter = _load_precedence.begin();
while(iter != _load_precedence.end()) {
@@ -1035,7 +1035,7 @@ int QuestParserCollection::DispatchEventItem(QuestEventID evt, Client *client, E
}
int QuestParserCollection::DispatchEventSpell(QuestEventID evt, NPC* npc, Client *client, uint32 spell_id, uint32 extra_data,
std::vector<EQEmu::Any> *extra_pointers) {
std::vector<EQ::Any> *extra_pointers) {
int ret = 0;
auto iter = _load_precedence.begin();
while(iter != _load_precedence.end()) {
zone/quest_parser_collection.h
+17 -17
View File
@@ -48,7 +48,7 @@ class Mob;
class NPC;
class QuestInterface;
namespace EQEmu
namespace EQ
{
class Any;
class ItemInstance;
@@ -69,18 +69,18 @@ public:
bool HasQuestSub(uint32 npcid, QuestEventID evt);
bool PlayerHasQuestSub(QuestEventID evt);
bool SpellHasQuestSub(uint32 spell_id, QuestEventID evt);
bool ItemHasQuestSub(EQEmu::ItemInstance *itm, QuestEventID evt);
bool ItemHasQuestSub(EQ::ItemInstance *itm, QuestEventID evt);
int EventNPC(QuestEventID evt, NPC* npc, Mob *init, std::string data, uint32 extra_data,
std::vector<EQEmu::Any> *extra_pointers = nullptr);
std::vector<EQ::Any> *extra_pointers = nullptr);
int EventPlayer(QuestEventID evt, Client *client, std::string data, uint32 extra_data,
std::vector<EQEmu::Any> *extra_pointers = nullptr);
int EventItem(QuestEventID evt, Client *client, EQEmu::ItemInstance *item, Mob *mob, std::string data, uint32 extra_data,
std::vector<EQEmu::Any> *extra_pointers = nullptr);
std::vector<EQ::Any> *extra_pointers = nullptr);
int EventItem(QuestEventID evt, Client *client, EQ::ItemInstance *item, Mob *mob, std::string data, uint32 extra_data,
std::vector<EQ::Any> *extra_pointers = nullptr);
int EventSpell(QuestEventID evt, NPC* npc, Client *client, uint32 spell_id, uint32 extra_data,
std::vector<EQEmu::Any> *extra_pointers = nullptr);
std::vector<EQ::Any> *extra_pointers = nullptr);
int EventEncounter(QuestEventID evt, std::string encounter_name, std::string data, uint32 extra_data,
std::vector<EQEmu::Any> *extra_pointers = nullptr);
std::vector<EQ::Any> *extra_pointers = nullptr);
void GetErrors(std::list<std::string> &err);
@@ -111,10 +111,10 @@ private:
bool PlayerHasQuestSubLocal(QuestEventID evt);
bool PlayerHasQuestSubGlobal(QuestEventID evt);
int EventNPCLocal(QuestEventID evt, NPC* npc, Mob *init, std::string data, uint32 extra_data, std::vector<EQEmu::Any> *extra_pointers);
int EventNPCGlobal(QuestEventID evt, NPC* npc, Mob *init, std::string data, uint32 extra_data, std::vector<EQEmu::Any> *extra_pointers);
int EventPlayerLocal(QuestEventID evt, Client *client, std::string data, uint32 extra_data, std::vector<EQEmu::Any> *extra_pointers);
int EventPlayerGlobal(QuestEventID evt, Client *client, std::string data, uint32 extra_data, std::vector<EQEmu::Any> *extra_pointers);
int EventNPCLocal(QuestEventID evt, NPC* npc, Mob *init, std::string data, uint32 extra_data, std::vector<EQ::Any> *extra_pointers);
int EventNPCGlobal(QuestEventID evt, NPC* npc, Mob *init, std::string data, uint32 extra_data, std::vector<EQ::Any> *extra_pointers);
int EventPlayerLocal(QuestEventID evt, Client *client, std::string data, uint32 extra_data, std::vector<EQ::Any> *extra_pointers);
int EventPlayerGlobal(QuestEventID evt, Client *client, std::string data, uint32 extra_data, std::vector<EQ::Any> *extra_pointers);
QuestInterface *GetQIByNPCQuest(uint32 npcid, std::string &filename);
QuestInterface *GetQIByGlobalNPCQuest(std::string &filename);
@@ -125,13 +125,13 @@ private:
QuestInterface *GetQIByEncounterQuest(std::string encounter_name, std::string &filename);
int DispatchEventNPC(QuestEventID evt, NPC* npc, Mob *init, std::string data, uint32 extra_data,
std::vector<EQEmu::Any> *extra_pointers);
std::vector<EQ::Any> *extra_pointers);
int DispatchEventPlayer(QuestEventID evt, Client *client, std::string data, uint32 extra_data,
std::vector<EQEmu::Any> *extra_pointers);
int DispatchEventItem(QuestEventID evt, Client *client, EQEmu::ItemInstance *item, Mob *mob, std::string data, uint32 extra_data,
std::vector<EQEmu::Any> *extra_pointers);
std::vector<EQ::Any> *extra_pointers);
int DispatchEventItem(QuestEventID evt, Client *client, EQ::ItemInstance *item, Mob *mob, std::string data, uint32 extra_data,
std::vector<EQ::Any> *extra_pointers);
int DispatchEventSpell(QuestEventID evt, NPC* npc, Client *client, uint32 spell_id, uint32 extra_data,
std::vector<EQEmu::Any> *extra_pointers);
std::vector<EQ::Any> *extra_pointers);
std::map<uint32, QuestInterface*> _interfaces;
std::map<uint32, std::string> _extensions;
zone/questmgr.cpp
+43 -43
View File
@@ -54,7 +54,7 @@ QuestManager quest_manager;
#define QuestManagerCurrentQuestVars() \
Mob *owner = nullptr; \
Client *initiator = nullptr; \
EQEmu::ItemInstance* questitem = nullptr; \
EQ::ItemInstance* questitem = nullptr; \
bool depop_npc = false; \
std::string encounter; \
do { \
@@ -116,7 +116,7 @@ void QuestManager::Process() {
}
}
void QuestManager::StartQuest(Mob *_owner, Client *_initiator, EQEmu::ItemInstance* _questitem, std::string encounter) {
void QuestManager::StartQuest(Mob *_owner, Client *_initiator, EQ::ItemInstance* _questitem, std::string encounter) {
running_quest run;
run.owner = _owner;
run.initiator = _initiator;
@@ -370,14 +370,14 @@ void QuestManager::castspell(int spell_id, int target_id) {
if (owner) {
Mob *tgt = entity_list.GetMob(target_id);
if(tgt != nullptr)
owner->SpellFinished(spell_id, tgt, EQEmu::spells::CastingSlot::Item, 0, -1, spells[spell_id].ResistDiff);
owner->SpellFinished(spell_id, tgt, EQ::spells::CastingSlot::Item, 0, -1, spells[spell_id].ResistDiff);
}
}
void QuestManager::selfcast(int spell_id) {
QuestManagerCurrentQuestVars();
if (initiator)
initiator->SpellFinished(spell_id, initiator, EQEmu::spells::CastingSlot::Item, 0, -1, spells[spell_id].ResistDiff);
initiator->SpellFinished(spell_id, initiator, EQ::spells::CastingSlot::Item, 0, -1, spells[spell_id].ResistDiff);
}
void QuestManager::addloot(int item_id, int charges, bool equipitem, int aug1, int aug2, int aug3, int aug4, int aug5, int aug6) {
@@ -455,7 +455,7 @@ void QuestManager::settimerMS(const char *timer_name, int milliseconds) {
QTimerList.push_back(QuestTimer(milliseconds, owner, timer_name));
}
void QuestManager::settimerMS(const char *timer_name, int milliseconds, EQEmu::ItemInstance *inst) {
void QuestManager::settimerMS(const char *timer_name, int milliseconds, EQ::ItemInstance *inst) {
if (inst) {
inst->SetTimer(timer_name, milliseconds);
}
@@ -498,7 +498,7 @@ void QuestManager::stoptimer(const char *timer_name) {
}
}
void QuestManager::stoptimer(const char *timer_name, EQEmu::ItemInstance *inst) {
void QuestManager::stoptimer(const char *timer_name, EQ::ItemInstance *inst) {
if (inst) {
inst->StopTimer(timer_name);
}
@@ -536,7 +536,7 @@ void QuestManager::stopalltimers() {
}
}
void QuestManager::stopalltimers(EQEmu::ItemInstance *inst) {
void QuestManager::stopalltimers(EQ::ItemInstance *inst) {
if (inst) {
inst->ClearTimers();
}
@@ -847,12 +847,12 @@ void QuestManager::traindisc(int discipline_tome_item_id) {
}
bool QuestManager::isdisctome(int item_id) {
const EQEmu::ItemData *item = database.GetItem(item_id);
const EQ::ItemData *item = database.GetItem(item_id);
if(item == nullptr) {
return(false);
}
if (!item->IsClassCommon() || item->ItemType != EQEmu::item::ItemTypeSpell) {
if (!item->IsClassCommon() || item->ItemType != EQ::item::ItemTypeSpell) {
return(false);
}
@@ -920,8 +920,8 @@ std::string QuestManager::getspellname(uint32 spell_id) {
}
std::string QuestManager::getskillname(int skill_id) {
if (skill_id >= 0 && skill_id < EQEmu::skills::SkillCount) {
std::map<EQEmu::skills::SkillType, std::string> Skills = EQEmu::skills::GetSkillTypeMap();
if (skill_id >= 0 && skill_id < EQ::skills::SkillCount) {
std::map<EQ::skills::SkillType, std::string> Skills = EQ::skills::GetSkillTypeMap();
for (auto skills_iter : Skills) {
if (skill_id == skills_iter.first) {
return skills_iter.second;
@@ -1009,7 +1009,7 @@ uint16 QuestManager::scribespells(uint8 max_level, uint8 min_level) {
bool SpellGlobalCheckResult = false;
bool SpellBucketCheckResult = false;
for ( ; spell_id < SPDAT_RECORDS && book_slot < EQEmu::spells::SPELLBOOK_SIZE; ++spell_id) {
for ( ; spell_id < SPDAT_RECORDS && book_slot < EQ::spells::SPELLBOOK_SIZE; ++spell_id) {
if (book_slot == -1) {
initiator->Message(
13,
@@ -1024,8 +1024,8 @@ uint16 QuestManager::scribespells(uint8 max_level, uint8 min_level) {
initiator->Message(Chat::Red, "FATAL ERROR: Spell id out-of-range (id: %i, min: 0, max: %i)", spell_id, SPDAT_RECORDS);
return count;
}
if (book_slot < 0 || book_slot >= EQEmu::spells::SPELLBOOK_SIZE) {
initiator->Message(Chat::Red, "FATAL ERROR: Book slot out-of-range (slot: %i, min: 0, max: %i)", book_slot, EQEmu::spells::SPELLBOOK_SIZE);
if (book_slot < 0 || book_slot >= EQ::spells::SPELLBOOK_SIZE) {
initiator->Message(Chat::Red, "FATAL ERROR: Book slot out-of-range (slot: %i, min: 0, max: %i)", book_slot, EQ::spells::SPELLBOOK_SIZE);
return count;
}
@@ -1286,10 +1286,10 @@ void QuestManager::doanim(int anim_id) {
void QuestManager::addskill(int skill_id, int value) {
QuestManagerCurrentQuestVars();
if (skill_id < 0 || skill_id > EQEmu::skills::HIGHEST_SKILL)
if (skill_id < 0 || skill_id > EQ::skills::HIGHEST_SKILL)
return;
if (initiator && initiator->IsClient())
initiator->AddSkill((EQEmu::skills::SkillType) skill_id, value);
initiator->AddSkill((EQ::skills::SkillType) skill_id, value);
}
void QuestManager::setlanguage(int skill_id, int value) {
@@ -1300,10 +1300,10 @@ void QuestManager::setlanguage(int skill_id, int value) {
void QuestManager::setskill(int skill_id, int value) {
QuestManagerCurrentQuestVars();
if (skill_id < 0 || skill_id > EQEmu::skills::HIGHEST_SKILL)
if (skill_id < 0 || skill_id > EQ::skills::HIGHEST_SKILL)
return;
if (initiator && initiator->IsClient())
initiator->SetSkill((EQEmu::skills::SkillType) skill_id, value);
initiator->SetSkill((EQ::skills::SkillType) skill_id, value);
}
void QuestManager::setallskill(int value) {
@@ -1311,8 +1311,8 @@ void QuestManager::setallskill(int value) {
if (!initiator)
return;
if (initiator && initiator->IsClient()) {
EQEmu::skills::SkillType sk;
for (sk = EQEmu::skills::Skill1HBlunt; sk <= EQEmu::skills::HIGHEST_SKILL; sk = (EQEmu::skills::SkillType)(sk + 1)) {
EQ::skills::SkillType sk;
for (sk = EQ::skills::Skill1HBlunt; sk <= EQ::skills::HIGHEST_SKILL; sk = (EQ::skills::SkillType)(sk + 1)) {
initiator->SetSkill(sk, value);
}
}
@@ -1438,12 +1438,12 @@ void QuestManager::settime(uint8 new_hour, uint8 new_min, bool update_world /*=
void QuestManager::itemlink(int item_id) {
QuestManagerCurrentQuestVars();
if (initiator) {
const EQEmu::ItemData* item = database.GetItem(item_id);
const EQ::ItemData* item = database.GetItem(item_id);
if (item == nullptr)
return;
EQEmu::SayLinkEngine linker;
linker.SetLinkType(EQEmu::saylink::SayLinkItemData);
EQ::SayLinkEngine linker;
linker.SetLinkType(EQ::saylink::SayLinkItemData);
linker.SetItemData(item);
initiator->Message(Chat::White, "%s tells you, %s", owner->GetCleanName(), linker.GenerateLink().c_str());
@@ -1908,7 +1908,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, EQEmu::skills::SkillHandtoHand, false, 0, false);
owner->Damage(owner, newhp, SPELL_UNKNOWN, EQ::skills::SkillHandtoHand, false, 0, false);
}
bool QuestManager::summonburiedplayercorpse(uint32 char_id, const glm::vec4& position) {
@@ -2567,7 +2567,7 @@ int QuestManager::collectitems_processSlot(int16 slot_id, uint32 item_id,
bool remove)
{
QuestManagerCurrentQuestVars();
EQEmu::ItemInstance *item = nullptr;
EQ::ItemInstance *item = nullptr;
int quantity = 0;
item = initiator->GetInv().GetItem(slot_id);
@@ -2602,12 +2602,12 @@ int QuestManager::collectitems(uint32 item_id, bool remove)
int quantity = 0;
int slot_id;
for (slot_id = EQEmu::invslot::GENERAL_BEGIN; slot_id <= EQEmu::invslot::GENERAL_END; ++slot_id)
for (slot_id = EQ::invslot::GENERAL_BEGIN; slot_id <= EQ::invslot::GENERAL_END; ++slot_id)
{
quantity += collectitems_processSlot(slot_id, item_id, remove);
}
for (slot_id = EQEmu::invbag::GENERAL_BAGS_BEGIN; slot_id <= EQEmu::invbag::GENERAL_BAGS_END; ++slot_id)
for (slot_id = EQ::invbag::GENERAL_BAGS_BEGIN; slot_id <= EQ::invbag::GENERAL_BAGS_END; ++slot_id)
{
quantity += collectitems_processSlot(slot_id, item_id, remove);
}
@@ -2618,15 +2618,15 @@ int QuestManager::collectitems(uint32 item_id, bool remove)
int QuestManager::countitem(uint32 item_id) {
QuestManagerCurrentQuestVars();
int quantity = 0;
EQEmu::ItemInstance *item = nullptr;
EQ::ItemInstance *item = nullptr;
static const int16 slots[][2] = {
{ EQEmu::invslot::POSSESSIONS_BEGIN, EQEmu::invslot::POSSESSIONS_END },
{ EQEmu::invbag::GENERAL_BAGS_BEGIN, EQEmu::invbag::GENERAL_BAGS_END },
{ EQEmu::invbag::CURSOR_BAG_BEGIN, EQEmu::invbag::CURSOR_BAG_END},
{ EQEmu::invslot::BANK_BEGIN, EQEmu::invslot::BANK_END },
{ EQEmu::invbag::BANK_BAGS_BEGIN, EQEmu::invbag::BANK_BAGS_END },
{ EQEmu::invslot::SHARED_BANK_BEGIN, EQEmu::invslot::SHARED_BANK_END },
{ EQEmu::invbag::SHARED_BANK_BAGS_BEGIN, EQEmu::invbag::SHARED_BANK_BAGS_END },
{ EQ::invslot::POSSESSIONS_BEGIN, EQ::invslot::POSSESSIONS_END },
{ EQ::invbag::GENERAL_BAGS_BEGIN, EQ::invbag::GENERAL_BAGS_END },
{ EQ::invbag::CURSOR_BAG_BEGIN, EQ::invbag::CURSOR_BAG_END},
{ EQ::invslot::BANK_BEGIN, EQ::invslot::BANK_END },
{ EQ::invbag::BANK_BAGS_BEGIN, EQ::invbag::BANK_BAGS_END },
{ EQ::invslot::SHARED_BANK_BEGIN, EQ::invslot::SHARED_BANK_END },
{ EQ::invbag::SHARED_BANK_BAGS_BEGIN, EQ::invbag::SHARED_BANK_BAGS_END },
};
const size_t size = sizeof(slots) / sizeof(slots[0]);
for (int slot_index = 0; slot_index < size; ++slot_index) {
@@ -2682,7 +2682,7 @@ void QuestManager::MerchantSetItem(uint32 NPCid, uint32 itemid, uint32 quantity)
if (merchant == 0 || !merchant->IsNPC() || (merchant->GetClass() != MERCHANT))
return; // don't do anything if NPCid isn't a merchant
const EQEmu::ItemData* item = nullptr;
const EQ::ItemData* item = nullptr;
item = database.GetItem(itemid);
if (!item) return; // if the item id doesn't correspond to a real item, do nothing
@@ -2695,7 +2695,7 @@ uint32 QuestManager::MerchantCountItem(uint32 NPCid, uint32 itemid) {
if (merchant == 0 || !merchant->IsNPC() || (merchant->GetClass() != MERCHANT))
return 0; // if it isn't a merchant, it doesn't have any items
const EQEmu::ItemData* item = nullptr;
const EQ::ItemData* item = nullptr;
item = database.GetItem(itemid);
if (!item)
return 0; // if it isn't a valid item, the merchant doesn't have any
@@ -2718,12 +2718,12 @@ uint32 QuestManager::MerchantCountItem(uint32 NPCid, uint32 itemid) {
// Item Link for use in Variables - "my $example_link = quest::varlink(item_id);"
const char* QuestManager::varlink(char* perltext, int item_id) {
QuestManagerCurrentQuestVars();
const EQEmu::ItemData* item = database.GetItem(item_id);
const EQ::ItemData* item = database.GetItem(item_id);
if (!item)
return "INVALID ITEM ID IN VARLINK";
EQEmu::SayLinkEngine linker;
linker.SetLinkType(EQEmu::saylink::SayLinkItemData);
EQ::SayLinkEngine linker;
linker.SetLinkType(EQ::saylink::SayLinkItemData);
linker.SetItemData(item);
strcpy(perltext, linker.GenerateLink().c_str());
@@ -2732,7 +2732,7 @@ const char* QuestManager::varlink(char* perltext, int item_id) {
}
std::string QuestManager::getitemname(uint32 item_id) {
const EQEmu::ItemData* item_data = database.GetItem(item_id);
const EQ::ItemData* item_data = database.GetItem(item_id);
if (!item_data) {
return "INVALID ITEM ID IN GETITEMNAME";
}
@@ -2948,7 +2948,7 @@ std::string QuestManager::saylink(char *saylink_text, bool silent, const char *l
{
QuestManagerCurrentQuestVars();
return EQEmu::SayLinkEngine::GenerateQuestSaylink(saylink_text, silent, link_name);
return EQ::SayLinkEngine::GenerateQuestSaylink(saylink_text, silent, link_name);
}
const char* QuestManager::getcharnamebyid(uint32 char_id) {
@@ -3427,7 +3427,7 @@ Mob *QuestManager::GetOwner() const {
return nullptr;
}
EQEmu::ItemInstance *QuestManager::GetQuestItem() const {
EQ::ItemInstance *QuestManager::GetQuestItem() const {
if(!quests_running_.empty()) {
running_quest e = quests_running_.top();
return e.questitem;
zone/questmgr.h
+7 -7
View File
@@ -28,7 +28,7 @@ class Client;
class Mob;
class NPC;
namespace EQEmu
namespace EQ
{
class ItemInstance;
}
@@ -37,7 +37,7 @@ class QuestManager {
struct running_quest {
Mob *owner;
Client *initiator;
EQEmu::ItemInstance* questitem;
EQ::ItemInstance* questitem;
bool depop_npc;
std::string encounter;
};
@@ -51,7 +51,7 @@ public:
QuestManager();
virtual ~QuestManager();
void StartQuest(Mob *_owner, Client *_initiator = nullptr, EQEmu::ItemInstance* _questitem = nullptr, std::string encounter = "");
void StartQuest(Mob *_owner, Client *_initiator = nullptr, EQ::ItemInstance* _questitem = nullptr, std::string encounter = "");
void EndQuest();
bool QuestsRunning() { return !quests_running_.empty(); }
@@ -79,13 +79,13 @@ public:
void Zone(const char *zone_name);
void settimer(const char *timer_name, int seconds);
void settimerMS(const char *timer_name, int milliseconds);
void settimerMS(const char *timer_name, int milliseconds, EQEmu::ItemInstance *inst);
void settimerMS(const char *timer_name, int milliseconds, EQ::ItemInstance *inst);
void settimerMS(const char *timer_name, int milliseconds, Mob *mob);
void stoptimer(const char *timer_name);
void stoptimer(const char *timer_name, EQEmu::ItemInstance *inst);
void stoptimer(const char *timer_name, EQ::ItemInstance *inst);
void stoptimer(const char *timer_name, Mob *mob);
void stopalltimers();
void stopalltimers(EQEmu::ItemInstance *inst);
void stopalltimers(EQ::ItemInstance *inst);
void stopalltimers(Mob *mob);
void pausetimer(const char *timer_name);
void resumetimer(const char *timer_name);
@@ -302,7 +302,7 @@ public:
Client *GetInitiator() const;
NPC *GetNPC() const;
Mob *GetOwner() const;
EQEmu::ItemInstance *GetQuestItem() const;
EQ::ItemInstance *GetQuestItem() const;
std::string GetEncounter() const;
inline bool ProximitySayInUse() { return HaveProximitySays; }
zone/raids.cpp
+4 -4
View File
@@ -1592,7 +1592,7 @@ void Raid::SendHPManaEndPacketsTo(Client *client)
safe_delete_array(hp_packet.pBuffer);
hp_packet.size = 0;
if (client->ClientVersion() >= EQEmu::versions::ClientVersion::SoD) {
if (client->ClientVersion() >= EQ::versions::ClientVersion::SoD) {
outapp.SetOpcode(OP_MobManaUpdate);
MobManaUpdate_Struct *mana_update = (MobManaUpdate_Struct *)outapp.pBuffer;
@@ -1629,7 +1629,7 @@ void Raid::SendHPManaEndPacketsFrom(Mob *mob)
if(members[x].member) {
if(!mob->IsClient() || ((members[x].member != mob->CastToClient()) && (members[x].GroupNumber == group_id))) {
members[x].member->QueuePacket(&hpapp, false);
if (members[x].member->ClientVersion() >= EQEmu::versions::ClientVersion::SoD) {
if (members[x].member->ClientVersion() >= EQ::versions::ClientVersion::SoD) {
outapp.SetOpcode(OP_MobManaUpdate);
MobManaUpdate_Struct *mana_update = (MobManaUpdate_Struct *)outapp.pBuffer;
mana_update->spawn_id = mob->GetID();
@@ -1661,7 +1661,7 @@ void Raid::SendManaPacketFrom(Mob *mob)
for (int x = 0; x < MAX_RAID_MEMBERS; x++) {
if (members[x].member) {
if (!mob->IsClient() || ((members[x].member != mob->CastToClient()) && (members[x].GroupNumber == group_id))) {
if (members[x].member->ClientVersion() >= EQEmu::versions::ClientVersion::SoD) {
if (members[x].member->ClientVersion() >= EQ::versions::ClientVersion::SoD) {
outapp.SetOpcode(OP_MobManaUpdate);
MobManaUpdate_Struct *mana_update = (MobManaUpdate_Struct *)outapp.pBuffer;
mana_update->spawn_id = mob->GetID();
@@ -1688,7 +1688,7 @@ void Raid::SendEndurancePacketFrom(Mob *mob)
for (int x = 0; x < MAX_RAID_MEMBERS; x++) {
if (members[x].member) {
if (!mob->IsClient() || ((members[x].member != mob->CastToClient()) && (members[x].GroupNumber == group_id))) {
if (members[x].member->ClientVersion() >= EQEmu::versions::ClientVersion::SoD) {
if (members[x].member->ClientVersion() >= EQ::versions::ClientVersion::SoD) {
outapp.SetOpcode(OP_MobEnduranceUpdate);
MobEnduranceUpdate_Struct *endurance_update = (MobEnduranceUpdate_Struct *)outapp.pBuffer;
endurance_update->spawn_id = mob->GetID();
zone/special_attacks.cpp
+237 -237
View File
File diff suppressed because it is too large Load Diff
zone/spell_effects.cpp
+62 -62
View File
@@ -49,7 +49,7 @@ extern WorldServer worldserver;
bool Mob::SpellEffect(Mob* caster, uint16 spell_id, float partial, int level_override)
{
int caster_level, buffslot, effect, effect_value, i;
EQEmu::ItemInstance *SummonedItem=nullptr;
EQ::ItemInstance *SummonedItem=nullptr;
#ifdef SPELL_EFFECT_SPAM
#define _EDLEN 200
char effect_desc[_EDLEN];
@@ -65,7 +65,7 @@ bool Mob::SpellEffect(Mob* caster, uint16 spell_id, float partial, int level_ove
bool c_override = false;
if (caster && caster->IsClient() && GetCastedSpellInvSlot() > 0) {
const EQEmu::ItemInstance *inst = caster->CastToClient()->GetInv().GetItem(GetCastedSpellInvSlot());
const EQ::ItemInstance *inst = caster->CastToClient()->GetInv().GetItem(GetCastedSpellInvSlot());
if (inst) {
if (inst->GetItem()->Click.Level > 0) {
caster_level = inst->GetItem()->Click.Level;
@@ -149,7 +149,7 @@ bool Mob::SpellEffect(Mob* caster, uint16 spell_id, float partial, int level_ove
if (spells[spell_id].EndurUpkeep > 0)
SetEndurUpkeep(true);
if (IsClient() && CastToClient()->ClientVersionBit() & EQEmu::versions::maskUFAndLater)
if (IsClient() && CastToClient()->ClientVersionBit() & EQ::versions::maskUFAndLater)
{
EQApplicationPacket *outapp = MakeBuffsPacket(false);
CastToClient()->FastQueuePacket(&outapp);
@@ -158,7 +158,7 @@ bool Mob::SpellEffect(Mob* caster, uint16 spell_id, float partial, int level_ove
if(IsNPC())
{
std::vector<EQEmu::Any> args;
std::vector<EQ::Any> args;
args.push_back(&buffslot);
int i = parse->EventSpell(EVENT_SPELL_EFFECT_NPC, CastToNPC(), nullptr, spell_id, caster ? caster->GetID() : 0, &args);
if(i != 0){
@@ -168,7 +168,7 @@ bool Mob::SpellEffect(Mob* caster, uint16 spell_id, float partial, int level_ove
}
else if(IsClient())
{
std::vector<EQEmu::Any> args;
std::vector<EQ::Any> args;
args.push_back(&buffslot);
int i = parse->EventSpell(EVENT_SPELL_EFFECT_CLIENT, nullptr, CastToClient(), spell_id, caster ? caster->GetID() : 0, &args);
if(i != 0){
@@ -627,7 +627,7 @@ bool Mob::SpellEffect(Mob* caster, uint16 spell_id, float partial, int level_ove
snprintf(effect_desc, _EDLEN, "Flesh To Bone");
#endif
if(IsClient()){
EQEmu::ItemInstance* transI = CastToClient()->GetInv().GetItem(EQEmu::invslot::slotCursor);
EQ::ItemInstance* transI = CastToClient()->GetInv().GetItem(EQ::invslot::slotCursor);
if (transI && transI->IsClassCommon() && transI->IsStackable()){
uint32 fcharges = transI->GetCharges();
//Does it sound like meat... maybe should check if it looks like meat too...
@@ -637,7 +637,7 @@ bool Mob::SpellEffect(Mob* caster, uint16 spell_id, float partial, int level_ove
strstr(transI->GetItem()->Name, "Flesh") ||
strstr(transI->GetItem()->Name, "parts") ||
strstr(transI->GetItem()->Name, "Parts")){
CastToClient()->DeleteItemInInventory(EQEmu::invslot::slotCursor, fcharges, true);
CastToClient()->DeleteItemInInventory(EQ::invslot::slotCursor, fcharges, true);
CastToClient()->SummonItem(13073, fcharges);
}
else{
@@ -829,7 +829,7 @@ bool Mob::SpellEffect(Mob* caster, uint16 spell_id, float partial, int level_ove
#endif
if(IsClient())
{
if (CastToClient()->ClientVersionBit() & EQEmu::versions::maskSoDAndLater)
if (CastToClient()->ClientVersionBit() & EQ::versions::maskSoDAndLater)
{
bodyType bt = BT_Undead;
@@ -1152,7 +1152,7 @@ bool Mob::SpellEffect(Mob* caster, uint16 spell_id, float partial, int level_ove
case SE_SummonItem:
{
const EQEmu::ItemData *item = database.GetItem(spell.base[i]);
const EQ::ItemData *item = database.GetItem(spell.base[i]);
#ifdef SPELL_EFFECT_SPAM
const char *itemname = item ? item->Name : "*Unknown Item*";
snprintf(effect_desc, _EDLEN, "Summon Item: %s (id %d)", itemname, spell.base[i]);
@@ -1177,7 +1177,7 @@ bool Mob::SpellEffect(Mob* caster, uint16 spell_id, float partial, int level_ove
if (SummonedItem) {
c->PushItemOnCursor(*SummonedItem);
c->SendItemPacket(EQEmu::invslot::slotCursor, SummonedItem, ItemPacketLimbo);
c->SendItemPacket(EQ::invslot::slotCursor, SummonedItem, ItemPacketLimbo);
safe_delete(SummonedItem);
}
SummonedItem = database.CreateItem(spell.base[i], charges);
@@ -1188,7 +1188,7 @@ bool Mob::SpellEffect(Mob* caster, uint16 spell_id, float partial, int level_ove
}
case SE_SummonItemIntoBag:
{
const EQEmu::ItemData *item = database.GetItem(spell.base[i]);
const EQ::ItemData *item = database.GetItem(spell.base[i]);
#ifdef SPELL_EFFECT_SPAM
const char *itemname = item ? item->Name : "*Unknown Item*";
snprintf(effect_desc, _EDLEN, "Summon Item In Bag: %s (id %d)", itemname, spell.base[i]);
@@ -1217,7 +1217,7 @@ bool Mob::SpellEffect(Mob* caster, uint16 spell_id, float partial, int level_ove
if (charges < 1)
charges = 1;
EQEmu::ItemInstance *SubItem = database.CreateItem(spell.base[i], charges);
EQ::ItemInstance *SubItem = database.CreateItem(spell.base[i], charges);
if (SubItem != nullptr) {
SummonedItem->PutItem(slot, *SubItem);
safe_delete(SubItem);
@@ -1247,7 +1247,7 @@ bool Mob::SpellEffect(Mob* caster, uint16 spell_id, float partial, int level_ove
// Will fix buttons for now
if (IsClient()) {
auto c = CastToClient();
if (c->ClientVersionBit() & EQEmu::versions::maskUFAndLater) {
if (c->ClientVersionBit() & EQ::versions::maskUFAndLater) {
c->SetPetCommandState(PET_BUTTON_SIT, 0);
c->SetPetCommandState(PET_BUTTON_STOP, 0);
c->SetPetCommandState(PET_BUTTON_REGROUP, 0);
@@ -1466,7 +1466,7 @@ bool Mob::SpellEffect(Mob* caster, uint16 spell_id, float partial, int level_ove
}
}
for (int x = EQEmu::textures::textureBegin; x <= EQEmu::textures::LastTintableTexture; x++)
for (int x = EQ::textures::textureBegin; x <= EQ::textures::LastTintableTexture; x++)
SendWearChange(x);
if (caster == this && spell.id != 287 && spell.id != 601 &&
@@ -1492,7 +1492,7 @@ bool Mob::SpellEffect(Mob* caster, uint16 spell_id, float partial, int level_ove
);
caster->SendAppearancePacket(AT_Size, static_cast<uint32>(caster->GetTarget()->GetSize()));
for (int x = EQEmu::textures::textureBegin; x <= EQEmu::textures::LastTintableTexture; x++)
for (int x = EQ::textures::textureBegin; x <= EQ::textures::LastTintableTexture; x++)
caster->SendWearChange(x);
}
}
@@ -1670,7 +1670,7 @@ bool Mob::SpellEffect(Mob* caster, uint16 spell_id, float partial, int level_ove
#endif
// This is handled by the client prior to SoD.
//
if (IsClient() && (CastToClient()->ClientVersionBit() & EQEmu::versions::maskSoDAndLater))
if (IsClient() && (CastToClient()->ClientVersionBit() & EQ::versions::maskSoDAndLater))
CastToClient()->LocateCorpse();
break;
@@ -2278,7 +2278,7 @@ bool Mob::SpellEffect(Mob* caster, uint16 spell_id, float partial, int level_ove
snprintf(effect_desc, _EDLEN, "Rampage");
#endif
if(caster)
entity_list.AEAttack(caster, 30, EQEmu::invslot::slotPrimary, 0, true); // on live wars dont get a duration ramp, its a one shot deal
entity_list.AEAttack(caster, 30, EQ::invslot::slotPrimary, 0, true); // on live wars dont get a duration ramp, its a one shot deal
break;
}
@@ -2329,10 +2329,10 @@ 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 EQEmu::skills::SkillThrowing:
case EQ::skills::SkillThrowing:
caster->DoThrowingAttackDmg(this, nullptr, nullptr, spells[spell_id].base[i],spells[spell_id].base2[i], focus, ReuseTime);
break;
case EQEmu::skills::SkillArchery:
case EQ::skills::SkillArchery:
caster->DoArcheryAttackDmg(this, nullptr, nullptr, spells[spell_id].base[i],spells[spell_id].base2[i],focus, ReuseTime);
break;
default:
@@ -2532,7 +2532,7 @@ bool Mob::SpellEffect(Mob* caster, uint16 spell_id, float partial, int level_ove
case SE_FcTimerRefresh:
{
if(IsClient()) {
for (unsigned int i = 0; i < EQEmu::spells::SPELL_GEM_COUNT; ++i) {
for (unsigned int i = 0; i < EQ::spells::SPELL_GEM_COUNT; ++i) {
if(IsValidSpell(CastToClient()->m_pp.mem_spells[i])) {
if (CalcFocusEffect(focusFcTimerRefresh, spell_id, CastToClient()->m_pp.mem_spells[i])){
CastToClient()->m_pp.spellSlotRefresh[i] = 1;
@@ -2801,7 +2801,7 @@ bool Mob::SpellEffect(Mob* caster, uint16 spell_id, float partial, int level_ove
if (caster && IsValidSpell(spells[spell_id].base2[i])){
if(zone->random.Roll(spells[spell_id].base[i]))
caster->SpellFinished(spells[spell_id].base2[i], this, EQEmu::spells::CastingSlot::Item, 0, -1, spells[spells[spell_id].base2[i]].ResistDiff);
caster->SpellFinished(spells[spell_id].base2[i], this, EQ::spells::CastingSlot::Item, 0, -1, spells[spells[spell_id].base2[i]].ResistDiff);
}
break;
}
@@ -3080,7 +3080,7 @@ bool Mob::SpellEffect(Mob* caster, uint16 spell_id, float partial, int level_ove
if (SummonedItem) {
Client *c=CastToClient();
c->PushItemOnCursor(*SummonedItem);
c->SendItemPacket(EQEmu::invslot::slotCursor, SummonedItem, ItemPacketLimbo);
c->SendItemPacket(EQ::invslot::slotCursor, SummonedItem, ItemPacketLimbo);
safe_delete(SummonedItem);
}
@@ -3105,7 +3105,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::skills::IsBardInstrumentSkill(spells[spell_id].skill) &&
if (EQ::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 &&
@@ -3464,7 +3464,7 @@ void Mob::BuffProcess()
LogSpells("Buff [{}] in slot [{}] has [{}] tics remaining", buffs[buffs_i].spellid, buffs_i, buffs[buffs_i].ticsremaining);
}
}
else if (IsClient() && !(CastToClient()->ClientVersionBit() & EQEmu::versions::maskSoFAndLater))
else if (IsClient() && !(CastToClient()->ClientVersionBit() & EQ::versions::maskSoFAndLater))
{
buffs[buffs_i].UpdateClient = true;
}
@@ -3476,7 +3476,7 @@ void Mob::BuffProcess()
{
CastToClient()->SendBuffDurationPacket(buffs[buffs_i], buffs_i);
// Hack to get UF to play nicer, RoF seems fine without it
if (CastToClient()->ClientVersion() == EQEmu::versions::ClientVersion::UF && buffs[buffs_i].numhits > 0)
if (CastToClient()->ClientVersion() == EQ::versions::ClientVersion::UF && buffs[buffs_i].numhits > 0)
CastToClient()->SendBuffNumHitPacket(buffs[buffs_i], buffs_i);
buffs[buffs_i].UpdateClient = false;
}
@@ -3495,7 +3495,7 @@ void Mob::DoBuffTic(const Buffs_Struct &buff, int slot, Mob *caster)
const SPDat_Spell_Struct &spell = spells[buff.spellid];
if (IsNPC()) {
std::vector<EQEmu::Any> args;
std::vector<EQ::Any> args;
args.push_back(&buff.ticsremaining);
args.push_back(&buff.casterlevel);
args.push_back(&slot);
@@ -3505,7 +3505,7 @@ void Mob::DoBuffTic(const Buffs_Struct &buff, int slot, Mob *caster)
return;
}
} else {
std::vector<EQEmu::Any> args;
std::vector<EQ::Any> args;
args.push_back(&buff.ticsremaining);
args.push_back(&buff.casterlevel);
args.push_back(&slot);
@@ -3686,13 +3686,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(EQEmu::skills::SkillDivination) +
break_chance -= (2 * (((double)caster->GetSkill(EQ::skills::SkillDivination) +
((double)caster->GetLevel() * 3.0)) /
650.0));
} else {
break_chance -=
(2 *
(((double)GetSkill(EQEmu::skills::SkillDivination) + ((double)GetLevel() * 3.0)) /
(((double)GetSkill(EQ::skills::SkillDivination) + ((double)GetLevel() * 3.0)) /
650.0));
}
@@ -3724,14 +3724,14 @@ void Mob::DoBuffTic(const Buffs_Struct &buff, int slot, Mob *caster)
case SE_CastOnFadeEffectNPC:
case SE_CastOnFadeEffectAlways: {
if (buff.ticsremaining == 0) {
SpellFinished(spells[buff.spellid].base[i], this, EQEmu::spells::CastingSlot::Item, 0, -1, spells[spells[buff.spellid].base[i]].ResistDiff);
SpellFinished(spells[buff.spellid].base[i], this, EQ::spells::CastingSlot::Item, 0, -1, spells[spells[buff.spellid].base[i]].ResistDiff);
}
break;
}
case SE_LocateCorpse: {
// This is handled by the client prior to SoD.
if (IsClient() && (CastToClient()->ClientVersionBit() & EQEmu::versions::maskSoDAndLater))
if (IsClient() && (CastToClient()->ClientVersionBit() & EQ::versions::maskSoDAndLater))
CastToClient()->LocateCorpse();
}
@@ -3812,12 +3812,12 @@ void Mob::BuffFadeBySlot(int slot, bool iRecalcBonuses)
}
if(IsClient()) {
std::vector<EQEmu::Any> args;
std::vector<EQ::Any> args;
args.push_back(&buffs[slot].casterid);
parse->EventSpell(EVENT_SPELL_FADE, nullptr, CastToClient(), buffs[slot].spellid, slot, &args);
} else if(IsNPC()) {
std::vector<EQEmu::Any> args;
std::vector<EQ::Any> args;
args.push_back(&buffs[slot].casterid);
parse->EventSpell(EVENT_SPELL_FADE, CastToNPC(), nullptr, buffs[slot].spellid, slot, &args);
@@ -3889,7 +3889,7 @@ void Mob::BuffFadeBySlot(int slot, bool iRecalcBonuses)
else{
SendAppearancePacket(AT_Size, 6);
}
for (int x = EQEmu::textures::textureBegin; x <= EQEmu::textures::LastTintableTexture; x++){
for (int x = EQ::textures::textureBegin; x <= EQ::textures::LastTintableTexture; x++){
SendWearChange(x);
}
break;
@@ -4155,7 +4155,7 @@ void Mob::BuffFadeBySlot(int slot, bool iRecalcBonuses)
{
EQApplicationPacket *outapp = MakeBuffsPacket();
entity_list.QueueClientsByTarget(this, outapp, false, nullptr, true, false, EQEmu::versions::maskSoDAndLater);
entity_list.QueueClientsByTarget(this, outapp, false, nullptr, true, false, EQ::versions::maskSoDAndLater);
if(IsClient() && GetTarget() == this) {
CastToClient()->QueuePacket(outapp);
}
@@ -4165,11 +4165,11 @@ void Mob::BuffFadeBySlot(int slot, bool iRecalcBonuses)
if (IsNPC()) {
EQApplicationPacket *outapp = MakeBuffsPacket();
entity_list.QueueClientsByTarget(this, outapp, false, nullptr, true, false, EQEmu::versions::maskSoDAndLater, true);
entity_list.QueueClientsByTarget(this, outapp, false, nullptr, true, false, EQ::versions::maskSoDAndLater, true);
safe_delete(outapp);
}
if (IsClient() && CastToClient()->ClientVersionBit() & EQEmu::versions::maskUFAndLater)
if (IsClient() && CastToClient()->ClientVersionBit() & EQ::versions::maskUFAndLater)
{
EQApplicationPacket *outapp = MakeBuffsPacket(false);
CastToClient()->FastQueuePacket(&outapp);
@@ -5170,7 +5170,7 @@ int16 Mob::CalcFocusEffect(focusType type, uint16 focus_id, uint16 spell_id, boo
if (Caston_spell_id) {
if (IsValidSpell(Caston_spell_id) && (Caston_spell_id != spell_id))
SpellFinished(Caston_spell_id, this, EQEmu::spells::CastingSlot::Item, 0, -1, spells[Caston_spell_id].ResistDiff);
SpellFinished(Caston_spell_id, this, EQ::spells::CastingSlot::Item, 0, -1, spells[Caston_spell_id].ResistDiff);
}
return (value * lvlModifier / 100);
@@ -5189,15 +5189,15 @@ uint16 Client::GetSympatheticFocusEffect(focusType type, uint16 spell_id) {
//item focus
if (itembonuses.FocusEffects[type]){
const EQEmu::ItemData* TempItem = nullptr;
const EQ::ItemData* TempItem = nullptr;
for (int x = EQEmu::invslot::EQUIPMENT_BEGIN; x <= EQEmu::invslot::EQUIPMENT_END; x++)
for (int x = EQ::invslot::EQUIPMENT_BEGIN; x <= EQ::invslot::EQUIPMENT_END; x++)
{
if (SympatheticProcList.size() > MAX_SYMPATHETIC_PROCS)
continue;
TempItem = nullptr;
EQEmu::ItemInstance* ins = GetInv().GetItem(x);
EQ::ItemInstance* ins = GetInv().GetItem(x);
if (!ins)
continue;
TempItem = ins->GetItem();
@@ -5211,16 +5211,16 @@ uint16 Client::GetSympatheticFocusEffect(focusType type, uint16 spell_id) {
}
}
for (int y = EQEmu::invaug::SOCKET_BEGIN; y <= EQEmu::invaug::SOCKET_END; ++y)
for (int y = EQ::invaug::SOCKET_BEGIN; y <= EQ::invaug::SOCKET_END; ++y)
{
if (SympatheticProcList.size() > MAX_SYMPATHETIC_PROCS)
continue;
EQEmu::ItemInstance *aug = nullptr;
EQ::ItemInstance *aug = nullptr;
aug = ins->GetAugment(y);
if(aug)
{
const EQEmu::ItemData* TempItemAug = aug->GetItem();
const EQ::ItemData* TempItemAug = aug->GetItem();
if (TempItemAug && TempItemAug->Focus.Effect > 0 && IsValidSpell(TempItemAug->Focus.Effect)) {
proc_spellid = CalcFocusEffect(type, TempItemAug->Focus.Effect, spell_id);
if (IsValidSpell(proc_spellid)){
@@ -5318,18 +5318,18 @@ int16 Client::GetFocusEffect(focusType type, uint16 spell_id)
//Check if item focus effect exists for the client.
if (itembonuses.FocusEffects[type]){
const EQEmu::ItemData* TempItem = nullptr;
const EQEmu::ItemData* UsedItem = nullptr;
const EQ::ItemData* TempItem = nullptr;
const EQ::ItemData* UsedItem = nullptr;
uint16 UsedFocusID = 0;
int16 Total = 0;
int16 focus_max = 0;
int16 focus_max_real = 0;
//item focus
for (int x = EQEmu::invslot::EQUIPMENT_BEGIN; x <= EQEmu::invslot::EQUIPMENT_END; x++)
for (int x = EQ::invslot::EQUIPMENT_BEGIN; x <= EQ::invslot::EQUIPMENT_END; x++)
{
TempItem = nullptr;
EQEmu::ItemInstance* ins = GetInv().GetItem(x);
EQ::ItemInstance* ins = GetInv().GetItem(x);
if (!ins)
continue;
TempItem = ins->GetItem();
@@ -5360,13 +5360,13 @@ int16 Client::GetFocusEffect(focusType type, uint16 spell_id)
}
}
for (int y = EQEmu::invaug::SOCKET_BEGIN; y <= EQEmu::invaug::SOCKET_END; ++y)
for (int y = EQ::invaug::SOCKET_BEGIN; y <= EQ::invaug::SOCKET_END; ++y)
{
EQEmu::ItemInstance *aug = nullptr;
EQ::ItemInstance *aug = nullptr;
aug = ins->GetAugment(y);
if(aug)
{
const EQEmu::ItemData* TempItemAug = aug->GetItem();
const EQ::ItemData* TempItemAug = aug->GetItem();
if (TempItemAug && TempItemAug->Focus.Effect > 0 && TempItemAug->Focus.Effect != SPELL_UNKNOWN) {
if(rand_effectiveness) {
focus_max = CalcFocusEffect(type, TempItemAug->Focus.Effect, spell_id, true);
@@ -5398,10 +5398,10 @@ int16 Client::GetFocusEffect(focusType type, uint16 spell_id)
}
//Tribute Focus
for (int x = EQEmu::invslot::TRIBUTE_BEGIN; x <= EQEmu::invslot::TRIBUTE_END; ++x)
for (int x = EQ::invslot::TRIBUTE_BEGIN; x <= EQ::invslot::TRIBUTE_END; ++x)
{
TempItem = nullptr;
EQEmu::ItemInstance* ins = GetInv().GetItem(x);
EQ::ItemInstance* ins = GetInv().GetItem(x);
if (!ins)
continue;
TempItem = ins->GetItem();
@@ -5590,16 +5590,16 @@ int16 NPC::GetFocusEffect(focusType type, uint16 spell_id) {
if (RuleB(Spells, NPC_UseFocusFromItems) && itembonuses.FocusEffects[type]){
const EQEmu::ItemData* TempItem = nullptr;
const EQEmu::ItemData* UsedItem = nullptr;
const EQ::ItemData* TempItem = nullptr;
const EQ::ItemData* UsedItem = nullptr;
uint16 UsedFocusID = 0;
int16 Total = 0;
int16 focus_max = 0;
int16 focus_max_real = 0;
//item focus
for (int i = EQEmu::invslot::EQUIPMENT_BEGIN; i <= EQEmu::invslot::EQUIPMENT_END; i++){
const EQEmu::ItemData *cur = database.GetItem(equipment[i]);
for (int i = EQ::invslot::EQUIPMENT_BEGIN; i <= EQ::invslot::EQUIPMENT_END; i++){
const EQ::ItemData *cur = database.GetItem(equipment[i]);
if(!cur)
continue;
@@ -6702,7 +6702,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 = EQEmu::skills::SkillConjuration;
ProjectileAtk[slot].skill = EQ::skills::SkillConjuration;
ProjectileAtk[slot].speed_mod = speed_mod;
SetProjectileAttack(true);
@@ -6758,7 +6758,7 @@ void Mob::ResourceTap(int32 damage, uint16 spellid)
if (damage > 0)
HealDamage(damage);
else
Damage(this, -damage, 0, EQEmu::skills::SkillEvocation, false);
Damage(this, -damage, 0, EQ::skills::SkillEvocation, false);
}
if (spells[spellid].base2[i] == 1) // Mana Tap
@@ -6801,10 +6801,10 @@ void Mob::TryTriggerThreshHold(int32 damage, int effect_id, Mob* attacker){
if (IsValidSpell(spell_id)) {
if (IsBeneficialSpell(spell_id))
SpellFinished(spell_id, this, EQEmu::spells::CastingSlot::Item, 0, -1, spells[spell_id].ResistDiff);
SpellFinished(spell_id, this, EQ::spells::CastingSlot::Item, 0, -1, spells[spell_id].ResistDiff);
else if(attacker)
SpellFinished(spell_id, attacker, EQEmu::spells::CastingSlot::Item, 0, -1, spells[spell_id].ResistDiff);
SpellFinished(spell_id, attacker, EQ::spells::CastingSlot::Item, 0, -1, spells[spell_id].ResistDiff);
}
}
}
@@ -6875,7 +6875,7 @@ void Mob::CalcSpellPowerDistanceMod(uint16 spell_id, float range, Mob* caster)
else
distance = sqrt(range);
distance = EQEmu::Clamp(distance, spells[spell_id].min_dist, spells[spell_id].max_dist);
distance = EQ::Clamp(distance, spells[spell_id].min_dist, spells[spell_id].max_dist);
float dm_range = spells[spell_id].max_dist - spells[spell_id].min_dist;
float dm_mod_interval = spells[spell_id].max_dist_mod - spells[spell_id].min_dist_mod;
zone/spells.cpp
+78 -78
View File
@@ -108,7 +108,7 @@ extern volatile bool is_zone_loaded;
extern WorldServer worldserver;
extern FastMath g_Math;
using EQEmu::spells::CastingSlot;
using EQ::spells::CastingSlot;
// this is run constantly for every mob
void Mob::SpellProcess()
@@ -245,12 +245,12 @@ bool Mob::CastSpell(uint16 spell_id, uint16 target_id, CastingSlot slot,
//Added to prevent MQ2 exploitation of equipping normally-unequippable/clickable items with effects and clicking them for benefits.
if(item_slot && IsClient() && (slot == CastingSlot::Item || slot == CastingSlot::PotionBelt))
{
EQEmu::ItemInstance *itm = CastToClient()->GetInv().GetItem(item_slot);
EQ::ItemInstance *itm = CastToClient()->GetInv().GetItem(item_slot);
int bitmask = 1;
bitmask = bitmask << (CastToClient()->GetClass() - 1);
if( itm && itm->GetItem()->Classes != 65535 ) {
if ((itm->GetItem()->Click.Type == EQEmu::item::ItemEffectEquipClick) && !(itm->GetItem()->Classes & bitmask)) {
if (CastToClient()->ClientVersion() < EQEmu::versions::ClientVersion::SoF) {
if ((itm->GetItem()->Click.Type == EQ::item::ItemEffectEquipClick) && !(itm->GetItem()->Classes & bitmask)) {
if (CastToClient()->ClientVersion() < EQ::versions::ClientVersion::SoF) {
// They are casting a spell from an item that requires equipping but shouldn't let them equip it
LogError("HACKER: [{}] (account: [{}]) attempted to click an equip-only effect on item [{}] (id: [{}]) which they shouldn't be able to equip!",
CastToClient()->GetCleanName(), CastToClient()->AccountName(), itm->GetItem()->Name, itm->GetItem()->ID);
@@ -261,15 +261,15 @@ bool Mob::CastSpell(uint16 spell_id, uint16 target_id, CastingSlot slot,
}
return(false);
}
if ((itm->GetItem()->Click.Type == EQEmu::item::ItemEffectClick2) && !(itm->GetItem()->Classes & bitmask)) {
if (CastToClient()->ClientVersion() < EQEmu::versions::ClientVersion::SoF) {
if ((itm->GetItem()->Click.Type == EQ::item::ItemEffectClick2) && !(itm->GetItem()->Classes & bitmask)) {
if (CastToClient()->ClientVersion() < EQ::versions::ClientVersion::SoF) {
// They are casting a spell from an item that they don't meet the race/class requirements to cast
LogError("HACKER: [{}] (account: [{}]) attempted to click a race/class restricted effect on item [{}] (id: [{}]) which they shouldn't be able to click!",
CastToClient()->GetCleanName(), CastToClient()->AccountName(), itm->GetItem()->Name, itm->GetItem()->ID);
database.SetHackerFlag(CastToClient()->AccountName(), CastToClient()->GetCleanName(), "Clicking race/class restricted item with an invalid class");
}
else {
if (CastToClient()->ClientVersion() >= EQEmu::versions::ClientVersion::RoF)
if (CastToClient()->ClientVersion() >= EQ::versions::ClientVersion::RoF)
{
// Line 181 in eqstr_us.txt was changed in RoF+
Message(Chat::Yellow, "Your race, class, or deity cannot use this item.");
@@ -282,8 +282,8 @@ bool Mob::CastSpell(uint16 spell_id, uint16 target_id, CastingSlot slot,
return(false);
}
}
if (itm && (itm->GetItem()->Click.Type == EQEmu::item::ItemEffectEquipClick) && item_slot > EQEmu::invslot::EQUIPMENT_END){
if (CastToClient()->ClientVersion() < EQEmu::versions::ClientVersion::SoF) {
if (itm && (itm->GetItem()->Click.Type == EQ::item::ItemEffectEquipClick) && item_slot > EQ::invslot::EQUIPMENT_END){
if (CastToClient()->ClientVersion() < EQ::versions::ClientVersion::SoF) {
// They are attempting to cast a must equip clicky without having it equipped
LogError("HACKER: [{}] (account: [{}]) attempted to click an equip-only effect on item [{}] (id: [{}]) without equiping it!", CastToClient()->GetCleanName(), CastToClient()->AccountName(), itm->GetItem()->Name, itm->GetItem()->ID);
database.SetHackerFlag(CastToClient()->AccountName(), CastToClient()->GetCleanName(), "Clicking equip-only item without equiping it");
@@ -611,16 +611,16 @@ bool Mob::DoCastingChecks()
uint16 Mob::GetSpecializeSkillValue(uint16 spell_id) const {
switch(spells[spell_id].skill) {
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));
case EQ::skills::SkillAbjuration:
return(GetSkill(EQ::skills::SkillSpecializeAbjure));
case EQ::skills::SkillAlteration:
return(GetSkill(EQ::skills::SkillSpecializeAlteration));
case EQ::skills::SkillConjuration:
return(GetSkill(EQ::skills::SkillSpecializeConjuration));
case EQ::skills::SkillDivination:
return(GetSkill(EQ::skills::SkillSpecializeDivination));
case EQ::skills::SkillEvocation:
return(GetSkill(EQ::skills::SkillSpecializeEvocation));
default:
//wtf...
break;
@@ -639,20 +639,20 @@ void Client::CheckSpecializeIncrease(uint16 spell_id) {
*/
switch(spells[spell_id].skill) {
case EQEmu::skills::SkillAbjuration:
CheckIncreaseSkill(EQEmu::skills::SkillSpecializeAbjure, nullptr);
case EQ::skills::SkillAbjuration:
CheckIncreaseSkill(EQ::skills::SkillSpecializeAbjure, nullptr);
break;
case EQEmu::skills::SkillAlteration:
CheckIncreaseSkill(EQEmu::skills::SkillSpecializeAlteration, nullptr);
case EQ::skills::SkillAlteration:
CheckIncreaseSkill(EQ::skills::SkillSpecializeAlteration, nullptr);
break;
case EQEmu::skills::SkillConjuration:
CheckIncreaseSkill(EQEmu::skills::SkillSpecializeConjuration, nullptr);
case EQ::skills::SkillConjuration:
CheckIncreaseSkill(EQ::skills::SkillSpecializeConjuration, nullptr);
break;
case EQEmu::skills::SkillDivination:
CheckIncreaseSkill(EQEmu::skills::SkillSpecializeDivination, nullptr);
case EQ::skills::SkillDivination:
CheckIncreaseSkill(EQ::skills::SkillSpecializeDivination, nullptr);
break;
case EQEmu::skills::SkillEvocation:
CheckIncreaseSkill(EQEmu::skills::SkillSpecializeEvocation, nullptr);
case EQ::skills::SkillEvocation:
CheckIncreaseSkill(EQ::skills::SkillSpecializeEvocation, nullptr);
break;
default:
//wtf...
@@ -672,48 +672,48 @@ void Client::CheckSongSkillIncrease(uint16 spell_id){
switch(spells[spell_id].skill)
{
case EQEmu::skills::SkillSinging:
CheckIncreaseSkill(EQEmu::skills::SkillSinging, nullptr, -15);
case EQ::skills::SkillSinging:
CheckIncreaseSkill(EQ::skills::SkillSinging, nullptr, -15);
break;
case EQEmu::skills::SkillPercussionInstruments:
case EQ::skills::SkillPercussionInstruments:
if(this->itembonuses.percussionMod > 0) {
if (GetRawSkill(EQEmu::skills::SkillPercussionInstruments) > 0) // no skill increases if not trained in the instrument
CheckIncreaseSkill(EQEmu::skills::SkillPercussionInstruments, nullptr, -15);
if (GetRawSkill(EQ::skills::SkillPercussionInstruments) > 0) // no skill increases if not trained in the instrument
CheckIncreaseSkill(EQ::skills::SkillPercussionInstruments, nullptr, -15);
else
MessageString(Chat::Red,NO_INSTRUMENT_SKILL); // tell the client that they need instrument training
}
else
CheckIncreaseSkill(EQEmu::skills::SkillSinging, nullptr, -15);
CheckIncreaseSkill(EQ::skills::SkillSinging, nullptr, -15);
break;
case EQEmu::skills::SkillStringedInstruments:
case EQ::skills::SkillStringedInstruments:
if(this->itembonuses.stringedMod > 0) {
if (GetRawSkill(EQEmu::skills::SkillStringedInstruments) > 0)
CheckIncreaseSkill(EQEmu::skills::SkillStringedInstruments, nullptr, -15);
if (GetRawSkill(EQ::skills::SkillStringedInstruments) > 0)
CheckIncreaseSkill(EQ::skills::SkillStringedInstruments, nullptr, -15);
else
MessageString(Chat::Red,NO_INSTRUMENT_SKILL);
}
else
CheckIncreaseSkill(EQEmu::skills::SkillSinging, nullptr, -15);
CheckIncreaseSkill(EQ::skills::SkillSinging, nullptr, -15);
break;
case EQEmu::skills::SkillWindInstruments:
case EQ::skills::SkillWindInstruments:
if(this->itembonuses.windMod > 0) {
if (GetRawSkill(EQEmu::skills::SkillWindInstruments) > 0)
CheckIncreaseSkill(EQEmu::skills::SkillWindInstruments, nullptr, -15);
if (GetRawSkill(EQ::skills::SkillWindInstruments) > 0)
CheckIncreaseSkill(EQ::skills::SkillWindInstruments, nullptr, -15);
else
MessageString(Chat::Red,NO_INSTRUMENT_SKILL);
}
else
CheckIncreaseSkill(EQEmu::skills::SkillSinging, nullptr, -15);
CheckIncreaseSkill(EQ::skills::SkillSinging, nullptr, -15);
break;
case EQEmu::skills::SkillBrassInstruments:
case EQ::skills::SkillBrassInstruments:
if(this->itembonuses.brassMod > 0) {
if (GetRawSkill(EQEmu::skills::SkillBrassInstruments) > 0)
CheckIncreaseSkill(EQEmu::skills::SkillBrassInstruments, nullptr, -15);
if (GetRawSkill(EQ::skills::SkillBrassInstruments) > 0)
CheckIncreaseSkill(EQ::skills::SkillBrassInstruments, nullptr, -15);
else
MessageString(Chat::Red,NO_INSTRUMENT_SKILL);
}
else
CheckIncreaseSkill(EQEmu::skills::SkillSinging, nullptr, -15);
CheckIncreaseSkill(EQ::skills::SkillSinging, nullptr, -15);
break;
default:
break;
@@ -967,7 +967,7 @@ void Mob::CastedSpellFinished(uint16 spell_id, uint32 target_id, CastingSlot slo
uint16 mana_used, uint32 inventory_slot, int16 resist_adjust)
{
bool IsFromItem = false;
EQEmu::ItemInstance *item = nullptr;
EQ::ItemInstance *item = nullptr;
if(IsClient() && slot != CastingSlot::Item && slot != CastingSlot::PotionBelt && spells[spell_id].recast_time > 1000) { // 10 is item
if(!CastToClient()->GetPTimers().Expired(&database, pTimerSpellStart + spell_id, false)) {
@@ -1081,7 +1081,7 @@ void Mob::CastedSpellFinished(uint16 spell_id, uint32 target_id, CastingSlot slo
channelbonuses += spellbonuses.ChannelChanceSpells + itembonuses.ChannelChanceSpells + aabonuses.ChannelChanceSpells;
// max 93% chance at 252 skill
channelchance = 30 + GetSkill(EQEmu::skills::SkillChanneling) / 400.0f * 100;
channelchance = 30 + GetSkill(EQ::skills::SkillChanneling) / 400.0f * 100;
channelchance -= attacked_count * 2;
channelchance += channelchance * channelbonuses / 100.0f;
}
@@ -1095,7 +1095,7 @@ void Mob::CastedSpellFinished(uint16 spell_id, uint32 target_id, CastingSlot slo
channelbonuses += spellbonuses.ChannelChanceSpells + itembonuses.ChannelChanceSpells + aabonuses.ChannelChanceSpells;
// max 93% chance at 252 skill
channelchance = 30 + GetSkill(EQEmu::skills::SkillChanneling) / 400.0f * 100;
channelchance = 30 + GetSkill(EQ::skills::SkillChanneling) / 400.0f * 100;
channelchance -= attacked_count * 2;
channelchance += channelchance * channelbonuses / 100.0f;
}
@@ -1127,7 +1127,7 @@ void Mob::CastedSpellFinished(uint16 spell_id, uint32 target_id, CastingSlot slo
}
}
LogSpells("Checking Interruption: spell x: [{}] spell y: [{}] cur x: [{}] cur y: [{}] channelchance [{}] channeling skill [{}]\n", GetSpellX(), GetSpellY(), GetX(), GetY(), channelchance, GetSkill(EQEmu::skills::SkillChanneling));
LogSpells("Checking Interruption: spell x: [{}] spell y: [{}] cur x: [{}] cur y: [{}] channelchance [{}] channeling skill [{}]\n", GetSpellX(), GetSpellY(), GetX(), GetY(), channelchance, GetSkill(EQ::skills::SkillChanneling));
if(!spells[spell_id].uninterruptable && zone->random.Real(0, 100) > channelchance) {
LogSpells("Casting of [{}] canceled: interrupted", spell_id);
@@ -1241,7 +1241,7 @@ void Mob::CastedSpellFinished(uint16 spell_id, uint32 target_id, CastingSlot slo
missingreags=true;
}
const EQEmu::ItemData *item = database.GetItem(component);
const EQ::ItemData *item = database.GetItem(component);
if(item) {
c->MessageString(Chat::Red, MISSING_SPELL_COMP_ITEM, item->Name);
LogSpells("Spell [{}]: Canceled. Missing required reagent [{}] ([{}])", spell_id, item->Name, component);
@@ -1305,7 +1305,7 @@ void Mob::CastedSpellFinished(uint16 spell_id, uint32 target_id, CastingSlot slo
&& inventory_slot != 0xFFFFFFFF) // 10 is an item
{
bool fromaug = false;
EQEmu::ItemData* augitem = nullptr;
EQ::ItemData* augitem = nullptr;
uint32 recastdelay = 0;
uint32 recasttype = 0;
@@ -1313,12 +1313,12 @@ void Mob::CastedSpellFinished(uint16 spell_id, uint32 target_id, CastingSlot slo
if (item == nullptr)
break;
for (int r = EQEmu::invaug::SOCKET_BEGIN; r <= EQEmu::invaug::SOCKET_END; r++) {
const EQEmu::ItemInstance* aug_i = item->GetAugment(r);
for (int r = EQ::invaug::SOCKET_BEGIN; r <= EQ::invaug::SOCKET_END; r++) {
const EQ::ItemInstance* aug_i = item->GetAugment(r);
if (!aug_i)
continue;
const EQEmu::ItemData* aug = aug_i->GetItem();
const EQ::ItemData* aug = aug_i->GetItem();
if (!aug)
continue;
@@ -1439,11 +1439,11 @@ void Mob::CastedSpellFinished(uint16 spell_id, uint32 target_id, CastingSlot slo
SetMana(GetMana());
// skills
if (EQEmu::skills::IsCastingSkill(spells[spell_id].skill)) {
if (EQ::skills::IsCastingSkill(spells[spell_id].skill)) {
c->CheckIncreaseSkill(spells[spell_id].skill, nullptr);
// increased chance of gaining channel skill if you regained concentration
c->CheckIncreaseSkill(EQEmu::skills::SkillChanneling, nullptr, regain_conc ? 5 : 0);
c->CheckIncreaseSkill(EQ::skills::SkillChanneling, nullptr, regain_conc ? 5 : 0);
c->CheckSpecializeIncrease(spell_id);
}
@@ -2422,7 +2422,7 @@ bool Mob::SpellFinished(uint16 spell_id, Mob *spell_target, CastingSlot slot, ui
auto end_cost = spells[spell_id].EndurCost;
if (mgb)
end_cost *= 2;
SetEndurance(GetEndurance() - EQEmu::ClampUpper(end_cost, GetEndurance()));
SetEndurance(GetEndurance() - EQ::ClampUpper(end_cost, GetEndurance()));
TryTriggerOnValueAmount(false, false, true);
}
if (mgb)
@@ -2465,7 +2465,7 @@ bool Mob::SpellFinished(uint16 spell_id, Mob *spell_target, CastingSlot slot, ui
if(IsClient() && (slot == CastingSlot::Item || slot == CastingSlot::PotionBelt))
{
EQEmu::ItemInstance *itm = CastToClient()->GetInv().GetItem(inventory_slot);
EQ::ItemInstance *itm = CastToClient()->GetInv().GetItem(inventory_slot);
if(itm && itm->GetItem()->RecastDelay > 0){
auto recast_type = itm->GetItem()->RecastType;
CastToClient()->GetPTimers().Start((pTimerItemStart + recast_type), itm->GetItem()->RecastDelay);
@@ -3335,7 +3335,7 @@ int Mob::AddBuff(Mob *caster, uint16 spell_id, int duration, int32 level_overrid
{
EQApplicationPacket *outapp = MakeBuffsPacket();
entity_list.QueueClientsByTarget(this, outapp, false, nullptr, true, false, EQEmu::versions::maskSoDAndLater);
entity_list.QueueClientsByTarget(this, outapp, false, nullptr, true, false, EQ::versions::maskSoDAndLater);
if(IsClient() && GetTarget() == this)
CastToClient()->QueuePacket(outapp);
@@ -3345,7 +3345,7 @@ int Mob::AddBuff(Mob *caster, uint16 spell_id, int duration, int32 level_overrid
if (IsNPC()) {
EQApplicationPacket *outapp = MakeBuffsPacket();
entity_list.QueueClientsByTarget(this, outapp, false, nullptr, true, false, EQEmu::versions::maskSoDAndLater, true);
entity_list.QueueClientsByTarget(this, outapp, false, nullptr, true, false, EQ::versions::maskSoDAndLater, true);
safe_delete(outapp);
}
@@ -5034,7 +5034,7 @@ void Client::MakeBuffFadePacket(uint16 spell_id, int slot_id, bool send_message)
void Client::MemSpell(uint16 spell_id, int slot, bool update_client)
{
if(slot >= EQEmu::spells::SPELL_GEM_COUNT || slot < 0)
if(slot >= EQ::spells::SPELL_GEM_COUNT || slot < 0)
return;
if(update_client)
@@ -5056,7 +5056,7 @@ void Client::MemSpell(uint16 spell_id, int slot, bool update_client)
void Client::UnmemSpell(int slot, bool update_client)
{
if(slot > EQEmu::spells::SPELL_GEM_COUNT || slot < 0)
if(slot > EQ::spells::SPELL_GEM_COUNT || slot < 0)
return;
LogSpells("Spell [{}] forgotten from slot [{}]", m_pp.mem_spells[slot], slot);
@@ -5072,7 +5072,7 @@ void Client::UnmemSpell(int slot, bool update_client)
void Client::UnmemSpellBySpellID(int32 spell_id)
{
for(int i = 0; i < EQEmu::spells::SPELL_GEM_COUNT; i++) {
for(int i = 0; i < EQ::spells::SPELL_GEM_COUNT; i++) {
if(m_pp.mem_spells[i] == spell_id) {
UnmemSpell(i, true);
break;
@@ -5084,7 +5084,7 @@ void Client::UnmemSpellAll(bool update_client)
{
int i;
for(i = 0; i < EQEmu::spells::SPELL_GEM_COUNT; i++)
for(i = 0; i < EQ::spells::SPELL_GEM_COUNT; i++)
if(m_pp.mem_spells[i] != 0xFFFFFFFF)
UnmemSpell(i, update_client);
}
@@ -5098,7 +5098,7 @@ uint16 Client::FindMemmedSpellBySlot(int slot) {
int Client::MemmedCount() {
int memmed_count = 0;
for (int i = 0; i < EQEmu::spells::SPELL_GEM_COUNT; i++)
for (int i = 0; i < EQ::spells::SPELL_GEM_COUNT; i++)
if (m_pp.mem_spells[i] != 0xFFFFFFFF)
memmed_count++;
@@ -5108,7 +5108,7 @@ int Client::MemmedCount() {
void Client::ScribeSpell(uint16 spell_id, int slot, bool update_client)
{
if(slot >= EQEmu::spells::SPELLBOOK_SIZE || slot < 0)
if(slot >= EQ::spells::SPELLBOOK_SIZE || slot < 0)
return;
if(update_client)
@@ -5129,14 +5129,14 @@ void Client::ScribeSpell(uint16 spell_id, int slot, bool update_client)
void Client::UnscribeSpell(int slot, bool update_client)
{
if(slot >= EQEmu::spells::SPELLBOOK_SIZE || slot < 0)
if(slot >= EQ::spells::SPELLBOOK_SIZE || slot < 0)
return;
LogSpells("Spell [{}] erased from spell book slot [{}]", m_pp.spell_book[slot], slot);
m_pp.spell_book[slot] = 0xFFFFFFFF;
database.DeleteCharacterSpell(this->CharacterID(), m_pp.spell_book[slot], slot);
if(update_client && slot < EQEmu::spells::DynamicLookup(ClientVersion(), GetGM())->SpellbookSize)
if(update_client && slot < EQ::spells::DynamicLookup(ClientVersion(), GetGM())->SpellbookSize)
{
auto outapp = new EQApplicationPacket(OP_DeleteSpell, sizeof(DeleteSpell_Struct));
DeleteSpell_Struct* del = (DeleteSpell_Struct*)outapp->pBuffer;
@@ -5149,7 +5149,7 @@ void Client::UnscribeSpell(int slot, bool update_client)
void Client::UnscribeSpellAll(bool update_client)
{
for(int i = 0; i < EQEmu::spells::SPELLBOOK_SIZE; i++)
for(int i = 0; i < EQ::spells::SPELLBOOK_SIZE; i++)
{
if(m_pp.spell_book[i] != 0xFFFFFFFF)
UnscribeSpell(i, update_client);
@@ -5183,7 +5183,7 @@ void Client::UntrainDiscAll(bool update_client)
}
int Client::GetNextAvailableSpellBookSlot(int starting_slot) {
for (int i = starting_slot; i < EQEmu::spells::SPELLBOOK_SIZE; i++) { //using starting_slot should help speed this up when we're iterating through a bunch of spells
for (int i = starting_slot; i < EQ::spells::SPELLBOOK_SIZE; i++) { //using starting_slot should help speed this up when we're iterating through a bunch of spells
if (!IsValidSpell(GetSpellByBookSlot(i)))
return i;
}
@@ -5192,7 +5192,7 @@ int Client::GetNextAvailableSpellBookSlot(int starting_slot) {
}
int Client::FindSpellBookSlotBySpellID(uint16 spellid) {
for(int i = 0; i < EQEmu::spells::SPELLBOOK_SIZE; i++) {
for(int i = 0; i < EQ::spells::SPELLBOOK_SIZE; i++) {
if(m_pp.spell_book[i] == spellid)
return i;
}
@@ -5543,7 +5543,7 @@ bool Mob::UseBardSpellLogic(uint16 spell_id, int slot)
spell_id != SPELL_UNKNOWN &&
slot != -1 &&
GetClass() == BARD &&
slot <= EQEmu::spells::SPELL_GEM_COUNT &&
slot <= EQ::spells::SPELL_GEM_COUNT &&
IsBardSong(spell_id)
);
}
@@ -5607,7 +5607,7 @@ void Client::SendBuffDurationPacket(Buffs_Struct &buff, int slot)
void Client::SendBuffNumHitPacket(Buffs_Struct &buff, int slot)
{
// UF+ use this packet
if (ClientVersion() < EQEmu::versions::ClientVersion::UF)
if (ClientVersion() < EQ::versions::ClientVersion::UF)
return;
EQApplicationPacket *outapp = nullptr;
outapp = new EQApplicationPacket(OP_BuffCreate, sizeof(BuffIcon_Struct) + sizeof(BuffIconEntry_Struct));
@@ -5664,7 +5664,7 @@ void Mob::SendBuffsToClient(Client *c)
if(!c)
return;
if (c->ClientVersionBit() & EQEmu::versions::maskSoDAndLater)
if (c->ClientVersionBit() & EQ::versions::maskSoDAndLater)
{
EQApplicationPacket *outapp = MakeBuffsPacket();
c->FastQueuePacket(&outapp);
@@ -5752,12 +5752,12 @@ int Client::GetCurrentBuffSlots() const
numbuffs++;
if (GetLevel() > 74)
numbuffs++;
return EQEmu::ClampUpper(numbuffs, EQEmu::spells::StaticLookup(m_ClientVersion)->LongBuffs);
return EQ::ClampUpper(numbuffs, EQ::spells::StaticLookup(m_ClientVersion)->LongBuffs);
}
int Client::GetCurrentSongSlots() const
{
return EQEmu::spells::StaticLookup(m_ClientVersion)->ShortBuffs; // AAs dont affect this
return EQ::spells::StaticLookup(m_ClientVersion)->ShortBuffs; // AAs dont affect this
}
void Client::InitializeBuffSlots()
zone/tasks.cpp
+10 -10
View File
@@ -1071,7 +1071,7 @@ void TaskManager::TaskQuestSetSelector(Client *c, ClientTaskState *state, Mob *m
void TaskManager::SendTaskSelector(Client *c, Mob *mob, int TaskCount, int *TaskList) {
if (c->ClientVersion() >= EQEmu::versions::ClientVersion::RoF)
if (c->ClientVersion() >= EQ::versions::ClientVersion::RoF)
{
SendTaskSelectorNew(c, mob, TaskCount, TaskList);
return;
@@ -1118,7 +1118,7 @@ void TaskManager::SendTaskSelector(Client *c, Mob *mob, int TaskCount, int *Task
continue;
buf.WriteUInt32(TaskList[i]); // TaskID
if (c->ClientVersion() != EQEmu::versions::ClientVersion::Titanium)
if (c->ClientVersion() != EQ::versions::ClientVersion::Titanium)
buf.WriteFloat(1.0f); // affects color, difficulty?
buf.WriteUInt32(Tasks[TaskList[i]]->Duration);
buf.WriteUInt32(static_cast<int>(Tasks[TaskList[i]]->dur_code));
@@ -1126,7 +1126,7 @@ void TaskManager::SendTaskSelector(Client *c, Mob *mob, int TaskCount, int *Task
buf.WriteString(Tasks[TaskList[i]]->Title); // max 64 with null
buf.WriteString(Tasks[TaskList[i]]->Description); // max 4000 with null
if (c->ClientVersion() != EQEmu::versions::ClientVersion::Titanium)
if (c->ClientVersion() != EQ::versions::ClientVersion::Titanium)
buf.WriteUInt8(0); // Has reward set flag
buf.WriteUInt32(Tasks[TaskList[i]]->ActivityCount);
@@ -1771,7 +1771,7 @@ void ClientTaskState::UpdateTasksOnExplore(Client *c, int ExploreID)
return;
}
bool ClientTaskState::UpdateTasksOnDeliver(Client *c, std::list<EQEmu::ItemInstance *> &Items, int Cash, int NPCTypeID)
bool ClientTaskState::UpdateTasksOnDeliver(Client *c, std::list<EQ::ItemInstance *> &Items, int Cash, int NPCTypeID)
{
bool Ret = false;
@@ -1988,7 +1988,7 @@ void ClientTaskState::RewardTask(Client *c, TaskInformation *Task) {
if(!Task || !c) return;
const EQEmu::ItemData* Item;
const EQ::ItemData* Item;
std::vector<int> RewardList;
switch(Task->RewardMethod) {
@@ -2698,7 +2698,7 @@ void TaskManager::SendTaskActivityShort(Client *c, int TaskID, int ActivityID, i
TaskActivityShort_Struct* tass;
if (c->ClientVersionBit() & EQEmu::versions::maskRoFAndLater)
if (c->ClientVersionBit() & EQ::versions::maskRoFAndLater)
{
auto outapp = new EQApplicationPacket(OP_TaskActivity, 25);
outapp->WriteUInt32(ClientTaskIndex);
@@ -2734,7 +2734,7 @@ void TaskManager::SendTaskActivityShort(Client *c, int TaskID, int ActivityID, i
void TaskManager::SendTaskActivityLong(Client *c, int TaskID, int ActivityID, int ClientTaskIndex, bool Optional, bool TaskComplete) {
if (c->ClientVersion() >= EQEmu::versions::ClientVersion::RoF)
if (c->ClientVersion() >= EQ::versions::ClientVersion::RoF)
{
SendTaskActivityNew(c, TaskID, ActivityID, ClientTaskIndex, Optional, TaskComplete);
return;
@@ -2943,10 +2943,10 @@ void TaskManager::SendActiveTaskDescription(Client *c, int TaskID, ClientTaskInf
}
if(ItemID) {
const EQEmu::ItemData* reward_item = database.GetItem(ItemID);
const EQ::ItemData* reward_item = database.GetItem(ItemID);
EQEmu::SayLinkEngine linker;
linker.SetLinkType(EQEmu::saylink::SayLinkItemData);
EQ::SayLinkEngine linker;
linker.SetLinkType(EQ::saylink::SayLinkItemData);
linker.SetItemData(reward_item);
linker.SetTaskUse();
Tasks[TaskID]->item_link = linker.GenerateLink();
zone/tasks.h
+2 -2
View File
@@ -48,7 +48,7 @@ Copyright (C) 2001-2004 EQEMu Development Team (http://eqemulator.net)
class Client;
class Mob;
namespace EQEmu
namespace EQ
{
class ItemInstance;
}
@@ -222,7 +222,7 @@ public:
void UpdateTasksForItem(Client *c, ActivityType Type, int ItemID, int Count=1);
void UpdateTasksOnExplore(Client *c, int ExploreID);
bool UpdateTasksOnSpeakWith(Client *c, int NPCTypeID);
bool UpdateTasksOnDeliver(Client *c, std::list<EQEmu::ItemInstance*>& Items, int Cash, int NPCTypeID);
bool UpdateTasksOnDeliver(Client *c, std::list<EQ::ItemInstance*>& Items, int Cash, int NPCTypeID);
void UpdateTasksOnTouch(Client *c, int ZoneID);
void ProcessTaskProximities(Client *c, float X, float Y, float Z);
bool TaskOutOfTime(TaskType type, int Index);
zone/titles.cpp
+3 -3
View File
@@ -47,7 +47,7 @@ bool TitleManager::LoadTitles()
for (auto row = results.begin(); row != results.end(); ++row) {
TitleEntry Title;
Title.TitleID = atoi(row[0]);
Title.SkillID = (EQEmu::skills::SkillType) atoi(row[1]);
Title.SkillID = (EQ::skills::SkillType) atoi(row[1]);
Title.MinSkillValue = atoi(row[2]);
Title.MaxSkillValue = atoi(row[3]);
Title.MinAAPoints = atoi(row[4]);
@@ -188,10 +188,10 @@ bool TitleManager::IsClientEligibleForTitle(Client *c, std::vector<TitleEntry>::
if(Title->SkillID >= 0)
{
if ((Title->MinSkillValue >= 0) && (c->GetRawSkill(static_cast<EQEmu::skills::SkillType>(Title->SkillID)) < static_cast<uint32>(Title->MinSkillValue)))
if ((Title->MinSkillValue >= 0) && (c->GetRawSkill(static_cast<EQ::skills::SkillType>(Title->SkillID)) < static_cast<uint32>(Title->MinSkillValue)))
return false;
if ((Title->MaxSkillValue >= 0) && (c->GetRawSkill(static_cast<EQEmu::skills::SkillType>(Title->SkillID)) > static_cast<uint32>(Title->MaxSkillValue)))
if ((Title->MaxSkillValue >= 0) && (c->GetRawSkill(static_cast<EQ::skills::SkillType>(Title->SkillID)) > static_cast<uint32>(Title->MaxSkillValue)))
return false;
}
zone/tradeskills.cpp
+136 -136
View File
@@ -36,7 +36,7 @@
extern QueryServ* QServ;
static const EQEmu::skills::SkillType TradeskillUnknown = EQEmu::skills::Skill1HBlunt; /* an arbitrary non-tradeskill */
static const EQ::skills::SkillType TradeskillUnknown = EQ::skills::Skill1HBlunt; /* an arbitrary non-tradeskill */
void Object::HandleAugmentation(Client* user, const AugmentItem_Struct* in_augment, Object *worldo)
{
@@ -46,7 +46,7 @@ void Object::HandleAugmentation(Client* user, const AugmentItem_Struct* in_augme
return;
}
EQEmu::ItemInstance* container = nullptr;
EQ::ItemInstance* container = nullptr;
if (worldo)
{
@@ -55,23 +55,23 @@ void Object::HandleAugmentation(Client* user, const AugmentItem_Struct* in_augme
else
{
// Check to see if they have an inventory container type 53 that is used for this.
EQEmu::InventoryProfile& user_inv = user->GetInv();
EQEmu::ItemInstance* inst = nullptr;
EQ::InventoryProfile& user_inv = user->GetInv();
EQ::ItemInstance* inst = nullptr;
inst = user_inv.GetItem(in_augment->container_slot);
if (inst)
{
const EQEmu::ItemData* item = inst->GetItem();
if (item && inst->IsType(EQEmu::item::ItemClassBag) && item->BagType == 53)
const EQ::ItemData* item = inst->GetItem();
if (item && inst->IsType(EQ::item::ItemClassBag) && item->BagType == 53)
{
// We have found an appropriate inventory augmentation sealer
container = inst;
// Verify that no more than two items are in container to guarantee no inadvertant wipes.
uint8 itemsFound = 0;
for (uint8 i = EQEmu::invbag::SLOT_BEGIN; i < EQEmu::invtype::WORLD_SIZE; i++)
for (uint8 i = EQ::invbag::SLOT_BEGIN; i < EQ::invtype::WORLD_SIZE; i++)
{
const EQEmu::ItemInstance* inst = container->GetItem(i);
const EQ::ItemInstance* inst = container->GetItem(i);
if (inst)
{
itemsFound++;
@@ -94,7 +94,7 @@ void Object::HandleAugmentation(Client* user, const AugmentItem_Struct* in_augme
return;
}
EQEmu::ItemInstance *tobe_auged = nullptr, *auged_with = nullptr;
EQ::ItemInstance *tobe_auged = nullptr, *auged_with = nullptr;
int8 slot=-1;
// Verify 2 items in the augmentation device
@@ -135,7 +135,7 @@ void Object::HandleAugmentation(Client* user, const AugmentItem_Struct* in_augme
bool deleteItems = false;
EQEmu::ItemInstance *itemOneToPush = nullptr, *itemTwoToPush = nullptr;
EQ::ItemInstance *itemOneToPush = nullptr, *itemTwoToPush = nullptr;
// Adding augment
if (in_augment->augment_slot == -1)
@@ -145,9 +145,9 @@ void Object::HandleAugmentation(Client* user, const AugmentItem_Struct* in_augme
{
tobe_auged->PutAugment(slot, *auged_with);
EQEmu::ItemInstance *aug = tobe_auged->GetAugment(slot);
EQ::ItemInstance *aug = tobe_auged->GetAugment(slot);
if(aug) {
std::vector<EQEmu::Any> args;
std::vector<EQ::Any> args;
args.push_back(aug);
parse->EventItem(EVENT_AUGMENT_ITEM, user, tobe_auged, nullptr, "", slot, &args);
@@ -165,9 +165,9 @@ void Object::HandleAugmentation(Client* user, const AugmentItem_Struct* in_augme
}
else
{
EQEmu::ItemInstance *old_aug = nullptr;
bool isSolvent = auged_with->GetItem()->ItemType == EQEmu::item::ItemTypeAugmentationSolvent;
if (!isSolvent && auged_with->GetItem()->ItemType != EQEmu::item::ItemTypeAugmentationDistiller)
EQ::ItemInstance *old_aug = nullptr;
bool isSolvent = auged_with->GetItem()->ItemType == EQ::item::ItemTypeAugmentationSolvent;
if (!isSolvent && auged_with->GetItem()->ItemType != EQ::item::ItemTypeAugmentationDistiller)
{
LogError("Player tried to remove an augment without a solvent or distiller");
user->Message(Chat::Red, "Error: Missing an augmentation solvent or distiller for removing this augment.");
@@ -175,7 +175,7 @@ void Object::HandleAugmentation(Client* user, const AugmentItem_Struct* in_augme
return;
}
EQEmu::ItemInstance *aug = tobe_auged->GetAugment(in_augment->augment_slot);
EQ::ItemInstance *aug = tobe_auged->GetAugment(in_augment->augment_slot);
if (aug) {
if (!isSolvent && auged_with->GetItem()->ID != aug->GetItem()->AugDistiller)
{
@@ -183,7 +183,7 @@ void Object::HandleAugmentation(Client* user, const AugmentItem_Struct* in_augme
user->Message(Chat::Red, "Error: Wrong augmentation distiller for safely removing this augment.");
return;
}
std::vector<EQEmu::Any> args;
std::vector<EQ::Any> args;
args.push_back(aug);
parse->EventItem(EVENT_UNAUGMENT_ITEM, user, tobe_auged, nullptr, "", slot, &args);
@@ -222,12 +222,12 @@ void Object::HandleAugmentation(Client* user, const AugmentItem_Struct* in_augme
else
{
// Delete items in our inventory container...
for (uint8 i = EQEmu::invbag::SLOT_BEGIN; i < EQEmu::invtype::WORLD_SIZE; i++)
for (uint8 i = EQ::invbag::SLOT_BEGIN; i < EQ::invtype::WORLD_SIZE; i++)
{
const EQEmu::ItemInstance* inst = container->GetItem(i);
const EQ::ItemInstance* inst = container->GetItem(i);
if (inst)
{
user->DeleteItemInInventory(EQEmu::InventoryProfile::CalcSlotId(in_augment->container_slot, i), 0, true);
user->DeleteItemInInventory(EQ::InventoryProfile::CalcSlotId(in_augment->container_slot, i), 0, true);
}
}
// Explicitly mark container as cleared.
@@ -256,15 +256,15 @@ void Object::HandleCombine(Client* user, const NewCombine_Struct* in_combine, Ob
return;
}
EQEmu::InventoryProfile& user_inv = user->GetInv();
EQ::InventoryProfile& user_inv = user->GetInv();
PlayerProfile_Struct& user_pp = user->GetPP();
EQEmu::ItemInstance* container = nullptr;
EQEmu::ItemInstance* inst = nullptr;
EQ::ItemInstance* container = nullptr;
EQ::ItemInstance* inst = nullptr;
uint8 c_type = 0xE8;
uint32 some_id = 0;
bool worldcontainer=false;
if (in_combine->container_slot == EQEmu::invslot::SLOT_TRADESKILL_EXPERIMENT_COMBINE) {
if (in_combine->container_slot == EQ::invslot::SLOT_TRADESKILL_EXPERIMENT_COMBINE) {
if(!worldo) {
user->Message(Chat::Red, "Error: Server is not aware of the tradeskill container you are attempting to use");
return;
@@ -274,7 +274,7 @@ void Object::HandleCombine(Client* user, const NewCombine_Struct* in_combine, Ob
worldcontainer=true;
// if we're a world container with an item, use that too
if (inst) {
const EQEmu::ItemData* item = inst->GetItem();
const EQ::ItemData* item = inst->GetItem();
if (item)
some_id = item->ID;
}
@@ -282,28 +282,28 @@ void Object::HandleCombine(Client* user, const NewCombine_Struct* in_combine, Ob
else {
inst = user_inv.GetItem(in_combine->container_slot);
if (inst) {
const EQEmu::ItemData* item = inst->GetItem();
if (item && inst->IsType(EQEmu::item::ItemClassBag)) {
const EQ::ItemData* item = inst->GetItem();
if (item && inst->IsType(EQ::item::ItemClassBag)) {
c_type = item->BagType;
some_id = item->ID;
}
}
}
if (!inst || !inst->IsType(EQEmu::item::ItemClassBag)) {
if (!inst || !inst->IsType(EQ::item::ItemClassBag)) {
user->Message(Chat::Red, "Error: Server does not recognize specified tradeskill container");
return;
}
container = inst;
if (container->GetItem() && container->GetItem()->BagType == EQEmu::item::BagTypeTransformationmold) {
const EQEmu::ItemInstance* inst = container->GetItem(0);
if (container->GetItem() && container->GetItem()->BagType == EQ::item::BagTypeTransformationmold) {
const EQ::ItemInstance* inst = container->GetItem(0);
bool AllowAll = RuleB(Inventory, AllowAnyWeaponTransformation);
if (inst && EQEmu::ItemInstance::CanTransform(inst->GetItem(), container->GetItem(), AllowAll)) {
const EQEmu::ItemData* new_weapon = inst->GetItem();
user->DeleteItemInInventory(EQEmu::InventoryProfile::CalcSlotId(in_combine->container_slot, 0), 0, true);
if (inst && EQ::ItemInstance::CanTransform(inst->GetItem(), container->GetItem(), AllowAll)) {
const EQ::ItemData* new_weapon = inst->GetItem();
user->DeleteItemInInventory(EQ::InventoryProfile::CalcSlotId(in_combine->container_slot, 0), 0, true);
container->Clear();
user->SummonItem(new_weapon->ID, inst->GetCharges(), inst->GetAugmentItemID(0), inst->GetAugmentItemID(1), inst->GetAugmentItemID(2), inst->GetAugmentItemID(3), inst->GetAugmentItemID(4), inst->GetAugmentItemID(5), inst->IsAttuned(), EQEmu::invslot::slotCursor, container->GetItem()->Icon, atoi(container->GetItem()->IDFile + 2));
user->SummonItem(new_weapon->ID, inst->GetCharges(), inst->GetAugmentItemID(0), inst->GetAugmentItemID(1), inst->GetAugmentItemID(2), inst->GetAugmentItemID(3), inst->GetAugmentItemID(4), inst->GetAugmentItemID(5), inst->IsAttuned(), EQ::invslot::slotCursor, container->GetItem()->Icon, atoi(container->GetItem()->IDFile + 2));
user->MessageString(Chat::LightBlue, TRANSFORM_COMPLETE, inst->GetItem()->Name);
if (RuleB(Inventory, DeleteTransformationMold))
user->DeleteItemInInventory(in_combine->container_slot, 0, true);
@@ -317,13 +317,13 @@ void Object::HandleCombine(Client* user, const NewCombine_Struct* in_combine, Ob
return;
}
if (container->GetItem() && container->GetItem()->BagType == EQEmu::item::BagTypeDetransformationmold) {
const EQEmu::ItemInstance* inst = container->GetItem(0);
if (container->GetItem() && container->GetItem()->BagType == EQ::item::BagTypeDetransformationmold) {
const EQ::ItemInstance* inst = container->GetItem(0);
if (inst && inst->GetOrnamentationIcon() && inst->GetOrnamentationIcon()) {
const EQEmu::ItemData* new_weapon = inst->GetItem();
user->DeleteItemInInventory(EQEmu::InventoryProfile::CalcSlotId(in_combine->container_slot, 0), 0, true);
const EQ::ItemData* new_weapon = inst->GetItem();
user->DeleteItemInInventory(EQ::InventoryProfile::CalcSlotId(in_combine->container_slot, 0), 0, true);
container->Clear();
user->SummonItem(new_weapon->ID, inst->GetCharges(), inst->GetAugmentItemID(0), inst->GetAugmentItemID(1), inst->GetAugmentItemID(2), inst->GetAugmentItemID(3), inst->GetAugmentItemID(4), inst->GetAugmentItemID(5), inst->IsAttuned(), EQEmu::invslot::slotCursor, 0, 0);
user->SummonItem(new_weapon->ID, inst->GetCharges(), inst->GetAugmentItemID(0), inst->GetAugmentItemID(1), inst->GetAugmentItemID(2), inst->GetAugmentItemID(3), inst->GetAugmentItemID(4), inst->GetAugmentItemID(5), inst->IsAttuned(), EQ::invslot::slotCursor, 0, 0);
user->MessageString(Chat::LightBlue, TRANSFORM_COMPLETE, inst->GetItem()->Name);
}
else if (inst) {
@@ -369,7 +369,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 == EQEmu::skills::SkillAlchemy) {
if (spec.tradeskill == EQ::skills::SkillAlchemy) {
if (user_pp.class_ != SHAMAN) {
user->Message(Chat::Red, "This tradeskill can only be performed by a shaman.");
return;
@@ -379,13 +379,13 @@ void Object::HandleCombine(Client* user, const NewCombine_Struct* in_combine, Ob
return;
}
}
else if (spec.tradeskill == EQEmu::skills::SkillTinkering) {
else if (spec.tradeskill == EQ::skills::SkillTinkering) {
if (user_pp.race != GNOME) {
user->Message(Chat::Red, "Only gnomes can tinker.");
return;
}
}
else if (spec.tradeskill == EQEmu::skills::SkillMakePoison) {
else if (spec.tradeskill == EQ::skills::SkillMakePoison) {
if (user_pp.class_ != ROGUE) {
user->Message(Chat::Red, "Only rogues can mix poisons.");
return;
@@ -416,10 +416,10 @@ void Object::HandleCombine(Client* user, const NewCombine_Struct* in_combine, Ob
safe_delete(outapp);
database.DeleteWorldContainer(worldo->m_id, zone->GetZoneID());
} else{
for (uint8 i = EQEmu::invbag::SLOT_BEGIN; i < EQEmu::invtype::WORLD_SIZE; i++) {
const EQEmu::ItemInstance* inst = container->GetItem(i);
for (uint8 i = EQ::invbag::SLOT_BEGIN; i < EQ::invtype::WORLD_SIZE; i++) {
const EQ::ItemInstance* inst = container->GetItem(i);
if (inst) {
user->DeleteItemInInventory(EQEmu::InventoryProfile::CalcSlotId(in_combine->container_slot, i), 0, true);
user->DeleteItemInInventory(EQ::InventoryProfile::CalcSlotId(in_combine->container_slot, i), 0, true);
}
}
container->Clear();
@@ -516,7 +516,7 @@ void Object::HandleAutoCombine(Client* user, const RecipeAutoCombine_Struct* rac
memset(counts, 0, sizeof(counts));
//search for all the items in their inventory
EQEmu::InventoryProfile& user_inv = user->GetInv();
EQ::InventoryProfile& user_inv = user->GetInv();
uint8 count = 0;
uint8 needcount = 0;
@@ -552,7 +552,7 @@ void Object::HandleAutoCombine(Client* user, const RecipeAutoCombine_Struct* rac
user->MessageString(Chat::Skills, TRADESKILL_MISSING_COMPONENTS);
for (auto it = MissingItems.begin(); it != MissingItems.end(); ++it) {
const EQEmu::ItemData* item = database.GetItem(*it);
const EQ::ItemData* item = database.GetItem(*it);
if(item)
user->MessageString(Chat::Skills, TRADESKILL_MISSING_ITEM, item->Name);
@@ -581,7 +581,7 @@ void Object::HandleAutoCombine(Client* user, const RecipeAutoCombine_Struct* rac
return;
}
const EQEmu::ItemInstance* inst = user_inv.GetItem(slot);
const EQ::ItemInstance* inst = user_inv.GetItem(slot);
if (inst && !inst->IsStackable())
user->DeleteItemInInventory(slot, 0, true);
@@ -619,84 +619,84 @@ void Object::HandleAutoCombine(Client* user, const RecipeAutoCombine_Struct* rac
parse->EventPlayer(EVENT_COMBINE_FAILURE, user, spec.name.c_str(), spec.recipe_id);
}
EQEmu::skills::SkillType Object::TypeToSkill(uint32 type)
EQ::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 EQEmu::skills::SkillAlchemy;
case EQ::item::BagTypeMedicineBag:
return EQ::skills::SkillAlchemy;
/*SkillBaking*/
//case EQEmu::item::BagTypeMixingBowl: // No idea...
case EQEmu::item::BagTypeOven:
return EQEmu::skills::SkillBaking;
//case EQ::item::BagTypeMixingBowl: // No idea...
case EQ::item::BagTypeOven:
return EQ::skills::SkillBaking;
/*SkillBlacksmithing*/
case EQEmu::item::BagTypeForge:
//case EQEmu::item::BagTypeKoadaDalForge:
case EQEmu::item::BagTypeTeirDalForge:
case EQEmu::item::BagTypeOggokForge:
case EQEmu::item::BagTypeStormguardForge:
//case EQEmu::item::BagTypeAkanonForge:
//case EQEmu::item::BagTypeNorthmanForge:
//case EQEmu::item::BagTypeCabilisForge:
//case EQEmu::item::BagTypeFreeportForge:
//case EQEmu::item::BagTypeRoyalQeynosForge:
//case EQEmu::item::BagTypeTrollForge:
case EQEmu::item::BagTypeFierDalForge:
case EQEmu::item::BagTypeValeForge:
//case EQEmu::item::BagTypeErudForge:
//case EQEmu::item::BagTypeGuktaForge:
return EQEmu::skills::SkillBlacksmithing;
case EQ::item::BagTypeForge:
//case EQ::item::BagTypeKoadaDalForge:
case EQ::item::BagTypeTeirDalForge:
case EQ::item::BagTypeOggokForge:
case EQ::item::BagTypeStormguardForge:
//case EQ::item::BagTypeAkanonForge:
//case EQ::item::BagTypeNorthmanForge:
//case EQ::item::BagTypeCabilisForge:
//case EQ::item::BagTypeFreeportForge:
//case EQ::item::BagTypeRoyalQeynosForge:
//case EQ::item::BagTypeTrollForge:
case EQ::item::BagTypeFierDalForge:
case EQ::item::BagTypeValeForge:
//case EQ::item::BagTypeErudForge:
//case EQ::item::BagTypeGuktaForge:
return EQ::skills::SkillBlacksmithing;
/*SkillBrewing*/
//case EQEmu::item::BagTypeIceCreamChurn: // No idea...
case EQEmu::item::BagTypeBrewBarrel:
return EQEmu::skills::SkillBrewing;
//case EQ::item::BagTypeIceCreamChurn: // No idea...
case EQ::item::BagTypeBrewBarrel:
return EQ::skills::SkillBrewing;
/*SkillFishing*/
case EQEmu::item::BagTypeTackleBox:
return EQEmu::skills::SkillFishing;
case EQ::item::BagTypeTackleBox:
return EQ::skills::SkillFishing;
/*SkillFletching*/
case EQEmu::item::BagTypeFletchingKit:
//case EQEmu::item::BagTypeFierDalFletchingKit:
return EQEmu::skills::SkillFletching;
case EQ::item::BagTypeFletchingKit:
//case EQ::item::BagTypeFierDalFletchingKit:
return EQ::skills::SkillFletching;
/*SkillJewelryMaking*/
case EQEmu::item::BagTypeJewelersKit:
return EQEmu::skills::SkillJewelryMaking;
case EQ::item::BagTypeJewelersKit:
return EQ::skills::SkillJewelryMaking;
/*SkillMakePoison*/
// This is a guess and needs to be verified... (Could be SkillAlchemy)
//case EQEmu::item::BagTypeMortar:
//case EQ::item::BagTypeMortar:
// return SkillMakePoison;
/*SkillPottery*/
case EQEmu::item::BagTypePotteryWheel:
case EQEmu::item::BagTypeKiln:
//case EQEmu::item::BagTypeIksarPotteryWheel:
return EQEmu::skills::SkillPottery;
case EQ::item::BagTypePotteryWheel:
case EQ::item::BagTypeKiln:
//case EQ::item::BagTypeIksarPotteryWheel:
return EQ::skills::SkillPottery;
/*SkillResearch*/
//case EQEmu::item::BagTypeLexicon:
case EQEmu::item::BagTypeWizardsLexicon:
case EQEmu::item::BagTypeMagesLexicon:
case EQEmu::item::BagTypeNecromancersLexicon:
case EQEmu::item::BagTypeEnchantersLexicon:
//case EQEmu::item::BagTypeConcordanceofResearch:
return EQEmu::skills::SkillResearch;
//case EQ::item::BagTypeLexicon:
case EQ::item::BagTypeWizardsLexicon:
case EQ::item::BagTypeMagesLexicon:
case EQ::item::BagTypeNecromancersLexicon:
case EQ::item::BagTypeEnchantersLexicon:
//case EQ::item::BagTypeConcordanceofResearch:
return EQ::skills::SkillResearch;
/*SkillTailoring*/
case EQEmu::item::BagTypeSewingKit:
//case EQEmu::item::BagTypeHalflingTailoringKit:
//case EQEmu::item::BagTypeErudTailoringKit:
//case EQEmu::item::BagTypeFierDalTailoringKit:
return EQEmu::skills::SkillTailoring;
case EQ::item::BagTypeSewingKit:
//case EQ::item::BagTypeHalflingTailoringKit:
//case EQ::item::BagTypeErudTailoringKit:
//case EQ::item::BagTypeFierDalTailoringKit:
return EQ::skills::SkillTailoring;
/*SkillTinkering*/
case EQEmu::item::BagTypeToolBox:
return EQEmu::skills::SkillTinkering;
case EQ::item::BagTypeToolBox:
return EQ::skills::SkillTinkering;
/*Undefined*/
default:
@@ -733,7 +733,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((EQEmu::skills::SkillType)tradeskill)) > RuleI(Skills, MaxTradeskillSearchSkillDiff)
&& ((int32)trivial - (int32)GetSkill((EQ::skills::SkillType)tradeskill)) > RuleI(Skills, MaxTradeskillSearchSkillDiff)
&& row[4] == nullptr)
continue;
@@ -882,34 +882,34 @@ bool Client::TradeskillExecute(DBTradeskillRecipe_Struct *spec) {
// If you want to customize the stage1 success rate do it here.
// Remember: skillup_modifier is (float). Lower is better
switch(spec->tradeskill) {
case EQEmu::skills::SkillFletching:
case EQ::skills::SkillFletching:
skillup_modifier = RuleI(Character, TradeskillUpFletching);
break;
case EQEmu::skills::SkillAlchemy:
case EQ::skills::SkillAlchemy:
skillup_modifier = RuleI(Character, TradeskillUpAlchemy);
break;
case EQEmu::skills::SkillJewelryMaking:
case EQ::skills::SkillJewelryMaking:
skillup_modifier = RuleI(Character, TradeskillUpJewelcrafting);
break;
case EQEmu::skills::SkillPottery:
case EQ::skills::SkillPottery:
skillup_modifier = RuleI(Character, TradeskillUpPottery);
break;
case EQEmu::skills::SkillBaking:
case EQ::skills::SkillBaking:
skillup_modifier = RuleI(Character, TradeskillUpBaking);
break;
case EQEmu::skills::SkillBrewing:
case EQ::skills::SkillBrewing:
skillup_modifier = RuleI(Character, TradeskillUpBrewing);
break;
case EQEmu::skills::SkillBlacksmithing:
case EQ::skills::SkillBlacksmithing:
skillup_modifier = RuleI(Character, TradeskillUpBlacksmithing);
break;
case EQEmu::skills::SkillResearch:
case EQ::skills::SkillResearch:
skillup_modifier = RuleI(Character, TradeskillUpResearch);
break;
case EQEmu::skills::SkillMakePoison:
case EQ::skills::SkillMakePoison:
skillup_modifier = RuleI(Character, TradeskillUpMakePoison);
break;
case EQEmu::skills::SkillTinkering:
case EQ::skills::SkillTinkering:
skillup_modifier = RuleI(Character, TradeskillUpTinkering);
break;
default:
@@ -920,11 +920,11 @@ bool Client::TradeskillExecute(DBTradeskillRecipe_Struct *spec) {
// Some tradeskills take the higher of one additional stat beside INT and WIS
// to determine the skillup rate. Additionally these tradeskills do not have an
// -15 modifier on their statbonus.
if (spec->tradeskill == EQEmu::skills::SkillFletching || spec->tradeskill == EQEmu::skills::SkillMakePoison) {
if (spec->tradeskill == EQ::skills::SkillFletching || spec->tradeskill == EQ::skills::SkillMakePoison) {
thirdstat = GetDEX();
stat_modifier = 0;
}
else if (spec->tradeskill == EQEmu::skills::SkillBlacksmithing) {
else if (spec->tradeskill == EQ::skills::SkillBlacksmithing) {
thirdstat = GetSTR();
stat_modifier = 0;
}
@@ -977,7 +977,7 @@ bool Client::TradeskillExecute(DBTradeskillRecipe_Struct *spec) {
aa_chance = spellbonuses.ReduceTradeskillFail[spec->tradeskill] + itembonuses.ReduceTradeskillFail[spec->tradeskill] + aabonuses.ReduceTradeskillFail[spec->tradeskill];
const EQEmu::ItemData* item = nullptr;
const EQ::ItemData* item = nullptr;
chance = mod_tradeskill_chance(chance, spec);
@@ -1085,7 +1085,7 @@ bool Client::TradeskillExecute(DBTradeskillRecipe_Struct *spec) {
return(false);
}
void Client::CheckIncreaseTradeskill(int16 bonusstat, int16 stat_modifier, float skillup_modifier, uint16 success_modifier, EQEmu::skills::SkillType tradeskill)
void Client::CheckIncreaseTradeskill(int16 bonusstat, int16 stat_modifier, float skillup_modifier, uint16 success_modifier, EQ::skills::SkillType tradeskill)
{
uint16 current_raw_skill = GetRawSkill(tradeskill);
@@ -1129,7 +1129,7 @@ void Client::CheckIncreaseTradeskill(int16 bonusstat, int16 stat_modifier, float
LogTradeskills("Stage2 chance was: [{}] percent. 0 percent means stage1 failed", chance_stage2);
}
bool ZoneDatabase::GetTradeRecipe(const EQEmu::ItemInstance* container, uint8 c_type, uint32 some_id,
bool ZoneDatabase::GetTradeRecipe(const EQ::ItemInstance* container, uint8 c_type, uint32 some_id,
uint32 char_id, DBTradeskillRecipe_Struct *spec)
{
if (container == nullptr)
@@ -1148,11 +1148,11 @@ bool ZoneDatabase::GetTradeRecipe(const EQEmu::ItemInstance* container, uint8 c_
uint32 count = 0;
uint32 sum = 0;
for (uint8 i = 0; i < 10; i++) { // <watch> TODO: need to determine if this is bound to world/item container size
const EQEmu::ItemInstance* inst = container->GetItem(i);
const EQ::ItemInstance* inst = container->GetItem(i);
if (!inst)
continue;
const EQEmu::ItemData* item = GetItem(inst->GetItem()->ID);
const EQ::ItemData* item = GetItem(inst->GetItem()->ID);
if (!item)
continue;
@@ -1285,12 +1285,12 @@ bool ZoneDatabase::GetTradeRecipe(const EQEmu::ItemInstance* container, uint8 c_
for (auto row = results.begin(); row != results.end(); ++row) {
int ccnt = 0;
for (int x = EQEmu::invbag::SLOT_BEGIN; x < EQEmu::invtype::WORLD_SIZE; x++) {
const EQEmu::ItemInstance* inst = container->GetItem(x);
for (int x = EQ::invbag::SLOT_BEGIN; x < EQ::invtype::WORLD_SIZE; x++) {
const EQ::ItemInstance* inst = container->GetItem(x);
if(!inst)
continue;
const EQEmu::ItemData* item = GetItem(inst->GetItem()->ID);
const EQ::ItemData* item = GetItem(inst->GetItem()->ID);
if (!item)
continue;
@@ -1339,7 +1339,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 = (EQEmu::skills::SkillType)atoi(row[1]);
spec->tradeskill = (EQ::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;
@@ -1455,32 +1455,32 @@ void Client::LearnRecipe(uint32 recipeID)
results = database.QueryDatabase(query);
}
bool Client::CanIncreaseTradeskill(EQEmu::skills::SkillType tradeskill) {
bool Client::CanIncreaseTradeskill(EQ::skills::SkillType tradeskill) {
uint32 rawskill = GetRawSkill(tradeskill);
uint16 maxskill = MaxSkill(tradeskill);
if (rawskill >= maxskill) //Max skill sanity check
return false;
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 Baking = (GetRawSkill(EQ::skills::SkillBaking) > 200) ? 1 : 0;
uint8 Smithing = (GetRawSkill(EQ::skills::SkillBlacksmithing) > 200) ? 1 : 0;
uint8 Brewing = (GetRawSkill(EQ::skills::SkillBrewing) > 200) ? 1 : 0;
uint8 Fletching = (GetRawSkill(EQ::skills::SkillFletching) > 200) ? 1 : 0;
uint8 Jewelry = (GetRawSkill(EQ::skills::SkillJewelryMaking) > 200) ? 1 : 0;
uint8 Pottery = (GetRawSkill(EQ::skills::SkillPottery) > 200) ? 1 : 0;
uint8 Tailoring = (GetRawSkill(EQ::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 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:
case EQ::skills::SkillBaking:
case EQ::skills::SkillBlacksmithing:
case EQ::skills::SkillBrewing:
case EQ::skills::SkillFletching:
case EQ::skills::SkillJewelryMaking:
case EQ::skills::SkillPottery:
case EQ::skills::SkillTailoring:
if (aaLevel == 6)
break; //Maxed AA
if (SkillTotal == 0)
zone/trading.cpp
+125 -125
View File
@@ -99,14 +99,14 @@ void Trade::AddEntity(uint16 trade_slot_id, uint32 stack_size) {
// Item always goes into trade bucket from cursor
Client* client = owner->CastToClient();
EQEmu::ItemInstance* inst = client->GetInv().GetItem(EQEmu::invslot::slotCursor);
EQ::ItemInstance* inst = client->GetInv().GetItem(EQ::invslot::slotCursor);
if (!inst) {
client->Message(Chat::Red, "Error: Could not find item on your cursor!");
return;
}
EQEmu::ItemInstance* inst2 = client->GetInv().GetItem(trade_slot_id);
EQ::ItemInstance* inst2 = client->GetInv().GetItem(trade_slot_id);
// it looks like the original code attempted to allow stacking...
// (it just didn't handle partial stack move actions)
@@ -132,7 +132,7 @@ void Trade::AddEntity(uint16 trade_slot_id, uint32 stack_size) {
if (_stack_size > 0)
inst->SetCharges(_stack_size);
else
client->DeleteItemInInventory(EQEmu::invslot::slotCursor);
client->DeleteItemInInventory(EQ::invslot::slotCursor);
SendItemData(inst2, trade_slot_id);
}
@@ -147,7 +147,7 @@ void Trade::AddEntity(uint16 trade_slot_id, uint32 stack_size) {
LogTrading("[{}] added item [{}] to trade slot [{}]", owner->GetName(), inst->GetItem()->Name, trade_slot_id);
client->PutItemInInventory(trade_slot_id, *inst);
client->DeleteItemInInventory(EQEmu::invslot::slotCursor);
client->DeleteItemInInventory(EQ::invslot::slotCursor);
}
}
@@ -159,7 +159,7 @@ Mob* Trade::With()
}
// Private Method: Send item data for trade item to other person involved in trade
void Trade::SendItemData(const EQEmu::ItemInstance* inst, int16 dest_slot_id)
void Trade::SendItemData(const EQ::ItemInstance* inst, int16 dest_slot_id)
{
if (inst == nullptr)
return;
@@ -172,13 +172,13 @@ void Trade::SendItemData(const EQEmu::ItemInstance* inst, int16 dest_slot_id)
Client* with = mob->CastToClient();
Client* trader = owner->CastToClient();
if (with && with->IsClient()) {
with->SendItemPacket(dest_slot_id - EQEmu::invslot::TRADE_BEGIN, inst, ItemPacketTradeView);
with->SendItemPacket(dest_slot_id - EQ::invslot::TRADE_BEGIN, inst, ItemPacketTradeView);
if (inst->GetItem()->ItemClass == 1) {
for (uint16 i = EQEmu::invbag::SLOT_BEGIN; i <= EQEmu::invbag::SLOT_END; i++) {
uint16 bagslot_id = EQEmu::InventoryProfile::CalcSlotId(dest_slot_id, i);
const EQEmu::ItemInstance* bagitem = trader->GetInv().GetItem(bagslot_id);
for (uint16 i = EQ::invbag::SLOT_BEGIN; i <= EQ::invbag::SLOT_END; i++) {
uint16 bagslot_id = EQ::InventoryProfile::CalcSlotId(dest_slot_id, i);
const EQ::ItemInstance* bagitem = trader->GetInv().GetItem(bagslot_id);
if (bagitem) {
with->SendItemPacket(bagslot_id - EQEmu::invslot::TRADE_BEGIN, bagitem, ItemPacketTradeView);
with->SendItemPacket(bagslot_id - EQ::invslot::TRADE_BEGIN, bagitem, ItemPacketTradeView);
}
}
}
@@ -200,7 +200,7 @@ void Trade::LogTrade()
uint8 item_count = 0;
if (zone->tradevar != 0) {
for (uint16 i = EQEmu::invslot::TRADE_BEGIN; i <= EQEmu::invslot::TRADE_END; i++) {
for (uint16 i = EQ::invslot::TRADE_BEGIN; i <= EQ::invslot::TRADE_END; i++) {
if (trader->GetInv().GetItem(i))
item_count++;
}
@@ -252,8 +252,8 @@ void Trade::LogTrade()
if (item_count > 0) {
strcat(logtext, "items {");
for (uint16 i = EQEmu::invslot::TRADE_BEGIN; i <= EQEmu::invslot::TRADE_END; i++) {
const EQEmu::ItemInstance* inst = trader->GetInv().GetItem(i);
for (uint16 i = EQ::invslot::TRADE_BEGIN; i <= EQ::invslot::TRADE_END; i++) {
const EQ::ItemInstance* inst = trader->GetInv().GetItem(i);
if (!comma)
comma = true;
@@ -268,7 +268,7 @@ void Trade::LogTrade()
strcat(logtext, item_num);
if (inst->IsClassBag()) {
for (uint8 j = EQEmu::invbag::SLOT_BEGIN; j <= EQEmu::invbag::SLOT_END; j++) {
for (uint8 j = EQ::invbag::SLOT_BEGIN; j <= EQ::invbag::SLOT_END; j++) {
inst = trader->GetInv().GetItem(i, j);
if (inst) {
strcat(logtext, ",");
@@ -304,8 +304,8 @@ void Trade::DumpTrade()
return;
Client* trader = owner->CastToClient();
for (uint16 i = EQEmu::invslot::TRADE_BEGIN; i <= EQEmu::invslot::TRADE_END; i++) {
const EQEmu::ItemInstance* inst = trader->GetInv().GetItem(i);
for (uint16 i = EQ::invslot::TRADE_BEGIN; i <= EQ::invslot::TRADE_END; i++) {
const EQ::ItemInstance* inst = trader->GetInv().GetItem(i);
if (inst) {
LogTrading("Item [{}] (Charges=[{}], Slot=[{}], IsBag=[{}])",
@@ -313,12 +313,12 @@ void Trade::DumpTrade()
i, ((inst->IsClassBag()) ? "True" : "False"));
if (inst->IsClassBag()) {
for (uint8 j = EQEmu::invbag::SLOT_BEGIN; j <= EQEmu::invbag::SLOT_END; j++) {
for (uint8 j = EQ::invbag::SLOT_BEGIN; j <= EQ::invbag::SLOT_END; j++) {
inst = trader->GetInv().GetItem(i, j);
if (inst) {
LogTrading("\tBagItem [{}] (Charges=[{}], Slot=[{}])",
inst->GetItem()->ID, inst->GetCharges(),
EQEmu::InventoryProfile::CalcSlotId(i, j));
EQ::InventoryProfile::CalcSlotId(i, j));
}
}
}
@@ -333,8 +333,8 @@ void Client::ResetTrade() {
AddMoneyToPP(trade->cp, trade->sp, trade->gp, trade->pp, true);
// step 1: process bags
for (int16 trade_slot = EQEmu::invslot::TRADE_BEGIN; trade_slot <= EQEmu::invslot::TRADE_END; ++trade_slot) {
const EQEmu::ItemInstance* inst = m_inv[trade_slot];
for (int16 trade_slot = EQ::invslot::TRADE_BEGIN; trade_slot <= EQ::invslot::TRADE_END; ++trade_slot) {
const EQ::ItemInstance* inst = m_inv[trade_slot];
if (inst && inst->IsClassBag()) {
int16 free_slot = m_inv.FindFreeSlotForTradeItem(inst);
@@ -352,18 +352,18 @@ void Client::ResetTrade() {
}
// step 2a: process stackables
for (int16 trade_slot = EQEmu::invslot::TRADE_BEGIN; trade_slot <= EQEmu::invslot::TRADE_END; ++trade_slot) {
EQEmu::ItemInstance* inst = GetInv().GetItem(trade_slot);
for (int16 trade_slot = EQ::invslot::TRADE_BEGIN; trade_slot <= EQ::invslot::TRADE_END; ++trade_slot) {
EQ::ItemInstance* inst = GetInv().GetItem(trade_slot);
if (inst && inst->IsStackable()) {
while (true) {
// there's no built-in safety check against an infinite loop..but, it should break on one of the conditional checks
int16 free_slot = m_inv.FindFreeSlotForTradeItem(inst);
if ((free_slot == EQEmu::invslot::slotCursor) || (free_slot == INVALID_INDEX))
if ((free_slot == EQ::invslot::slotCursor) || (free_slot == INVALID_INDEX))
break;
EQEmu::ItemInstance* partial_inst = GetInv().GetItem(free_slot);
EQ::ItemInstance* partial_inst = GetInv().GetItem(free_slot);
if (!partial_inst)
break;
@@ -399,15 +399,15 @@ void Client::ResetTrade() {
// step 2b: adjust trade stack bias
// (if any partial stacks exist before the final stack, FindFreeSlotForTradeItem() will return that slot in step 3 and an overwrite will occur)
for (int16 trade_slot = EQEmu::invslot::TRADE_END; trade_slot >= EQEmu::invslot::TRADE_BEGIN; --trade_slot) {
EQEmu::ItemInstance* inst = GetInv().GetItem(trade_slot);
for (int16 trade_slot = EQ::invslot::TRADE_END; trade_slot >= EQ::invslot::TRADE_BEGIN; --trade_slot) {
EQ::ItemInstance* inst = GetInv().GetItem(trade_slot);
if (inst && inst->IsStackable()) {
for (int16 bias_slot = EQEmu::invslot::TRADE_BEGIN; bias_slot <= EQEmu::invslot::TRADE_END; ++bias_slot) {
for (int16 bias_slot = EQ::invslot::TRADE_BEGIN; bias_slot <= EQ::invslot::TRADE_END; ++bias_slot) {
if (bias_slot >= trade_slot)
break;
EQEmu::ItemInstance* bias_inst = GetInv().GetItem(bias_slot);
EQ::ItemInstance* bias_inst = GetInv().GetItem(bias_slot);
if (!bias_inst || (bias_inst->GetID() != inst->GetID()) || (bias_inst->GetCharges() >= bias_inst->GetItem()->StackSize))
continue;
@@ -433,8 +433,8 @@ void Client::ResetTrade() {
}
// step 3: process everything else
for (int16 trade_slot = EQEmu::invslot::TRADE_BEGIN; trade_slot <= EQEmu::invslot::TRADE_END; ++trade_slot) {
const EQEmu::ItemInstance* inst = m_inv[trade_slot];
for (int16 trade_slot = EQ::invslot::TRADE_BEGIN; trade_slot <= EQ::invslot::TRADE_END; ++trade_slot) {
const EQ::ItemInstance* inst = m_inv[trade_slot];
if (inst) {
int16 free_slot = m_inv.FindFreeSlotForTradeItem(inst);
@@ -488,8 +488,8 @@ void Client::FinishTrade(Mob* tradingWith, bool finalizer, void* event_entry, st
}
// step 1: process bags
for (int16 trade_slot = EQEmu::invslot::TRADE_BEGIN; trade_slot <= EQEmu::invslot::TRADE_END; ++trade_slot) {
const EQEmu::ItemInstance* inst = m_inv[trade_slot];
for (int16 trade_slot = EQ::invslot::TRADE_BEGIN; trade_slot <= EQ::invslot::TRADE_END; ++trade_slot) {
const EQ::ItemInstance* inst = m_inv[trade_slot];
if (inst && inst->IsClassBag()) {
LogTrading("Giving container [{}] ([{}]) in slot [{}] to [{}]", inst->GetItem()->Name, inst->GetItem()->ID, trade_slot, other->GetName());
@@ -523,16 +523,16 @@ void Client::FinishTrade(Mob* tradingWith, bool finalizer, void* event_entry, st
else
qs_audit->char1_count += detail->charges;
for (uint8 sub_slot = EQEmu::invbag::SLOT_BEGIN; (sub_slot <= EQEmu::invbag::SLOT_END); ++sub_slot) { // this is to catch ALL items
const EQEmu::ItemInstance* bag_inst = inst->GetItem(sub_slot);
for (uint8 sub_slot = EQ::invbag::SLOT_BEGIN; (sub_slot <= EQ::invbag::SLOT_END); ++sub_slot) { // this is to catch ALL items
const EQ::ItemInstance* bag_inst = inst->GetItem(sub_slot);
if (bag_inst) {
detail = new QSTradeItems_Struct;
detail->from_id = this->character_id;
detail->from_slot = EQEmu::InventoryProfile::CalcSlotId(trade_slot, sub_slot);
detail->from_slot = EQ::InventoryProfile::CalcSlotId(trade_slot, sub_slot);
detail->to_id = other->CharacterID();
detail->to_slot = EQEmu::InventoryProfile::CalcSlotId(free_slot, sub_slot);
detail->to_slot = EQ::InventoryProfile::CalcSlotId(free_slot, sub_slot);
detail->item_id = bag_inst->GetID();
detail->charges = (!bag_inst->IsStackable() ? 1 : bag_inst->GetCharges());
detail->aug_1 = bag_inst->GetAugmentItemID(1);
@@ -571,18 +571,18 @@ void Client::FinishTrade(Mob* tradingWith, bool finalizer, void* event_entry, st
}
// step 2a: process stackables
for (int16 trade_slot = EQEmu::invslot::TRADE_BEGIN; trade_slot <= EQEmu::invslot::TRADE_END; ++trade_slot) {
EQEmu::ItemInstance* inst = GetInv().GetItem(trade_slot);
for (int16 trade_slot = EQ::invslot::TRADE_BEGIN; trade_slot <= EQ::invslot::TRADE_END; ++trade_slot) {
EQ::ItemInstance* inst = GetInv().GetItem(trade_slot);
if (inst && inst->IsStackable()) {
while (true) {
// there's no built-in safety check against an infinite loop..but, it should break on one of the conditional checks
int16 partial_slot = other->GetInv().FindFreeSlotForTradeItem(inst);
if ((partial_slot == EQEmu::invslot::slotCursor) || (partial_slot == INVALID_INDEX))
if ((partial_slot == EQ::invslot::slotCursor) || (partial_slot == INVALID_INDEX))
break;
EQEmu::ItemInstance* partial_inst = other->GetInv().GetItem(partial_slot);
EQ::ItemInstance* partial_inst = other->GetInv().GetItem(partial_slot);
if (!partial_inst)
break;
@@ -653,15 +653,15 @@ void Client::FinishTrade(Mob* tradingWith, bool finalizer, void* event_entry, st
// step 2b: adjust trade stack bias
// (if any partial stacks exist before the final stack, FindFreeSlotForTradeItem() will return that slot in step 3 and an overwrite will occur)
for (int16 trade_slot = EQEmu::invslot::TRADE_END; trade_slot >= EQEmu::invslot::TRADE_BEGIN; --trade_slot) {
EQEmu::ItemInstance* inst = GetInv().GetItem(trade_slot);
for (int16 trade_slot = EQ::invslot::TRADE_END; trade_slot >= EQ::invslot::TRADE_BEGIN; --trade_slot) {
EQ::ItemInstance* inst = GetInv().GetItem(trade_slot);
if (inst && inst->IsStackable()) {
for (int16 bias_slot = EQEmu::invslot::TRADE_BEGIN; bias_slot <= EQEmu::invslot::TRADE_END; ++bias_slot) {
for (int16 bias_slot = EQ::invslot::TRADE_BEGIN; bias_slot <= EQ::invslot::TRADE_END; ++bias_slot) {
if (bias_slot >= trade_slot)
break;
EQEmu::ItemInstance* bias_inst = GetInv().GetItem(bias_slot);
EQ::ItemInstance* bias_inst = GetInv().GetItem(bias_slot);
if (!bias_inst || (bias_inst->GetID() != inst->GetID()) || (bias_inst->GetCharges() >= bias_inst->GetItem()->StackSize))
continue;
@@ -706,8 +706,8 @@ void Client::FinishTrade(Mob* tradingWith, bool finalizer, void* event_entry, st
}
// step 3: process everything else
for (int16 trade_slot = EQEmu::invslot::TRADE_BEGIN; trade_slot <= EQEmu::invslot::TRADE_END; ++trade_slot) {
const EQEmu::ItemInstance* inst = m_inv[trade_slot];
for (int16 trade_slot = EQ::invslot::TRADE_BEGIN; trade_slot <= EQ::invslot::TRADE_END; ++trade_slot) {
const EQ::ItemInstance* inst = m_inv[trade_slot];
if (inst) {
LogTrading("Giving item [{}] ([{}]) in slot [{}] to [{}]", inst->GetItem()->Name, inst->GetItem()->ID, trade_slot, other->GetName());
@@ -742,8 +742,8 @@ void Client::FinishTrade(Mob* tradingWith, bool finalizer, void* event_entry, st
qs_audit->char1_count += detail->charges;
// 'step 3' should never really see containers..but, just in case...
for (uint8 sub_slot = EQEmu::invbag::SLOT_BEGIN; (sub_slot <= EQEmu::invbag::SLOT_END); ++sub_slot) { // this is to catch ALL items
const EQEmu::ItemInstance* bag_inst = inst->GetItem(sub_slot);
for (uint8 sub_slot = EQ::invbag::SLOT_BEGIN; (sub_slot <= EQ::invbag::SLOT_END); ++sub_slot) { // this is to catch ALL items
const EQ::ItemInstance* bag_inst = inst->GetItem(sub_slot);
if (bag_inst) {
detail = new QSTradeItems_Struct;
@@ -819,8 +819,8 @@ void Client::FinishTrade(Mob* tradingWith, bool finalizer, void* event_entry, st
}
if(qs_log) { // This can be incorporated below when revisions are made
for (int16 trade_slot = EQEmu::invslot::TRADE_BEGIN; trade_slot <= EQEmu::invslot::TRADE_NPC_END; ++trade_slot) {
const EQEmu::ItemInstance* trade_inst = m_inv[trade_slot];
for (int16 trade_slot = EQ::invslot::TRADE_BEGIN; trade_slot <= EQ::invslot::TRADE_NPC_END; ++trade_slot) {
const EQ::ItemInstance* trade_inst = m_inv[trade_slot];
if(trade_inst) {
auto detail = new QSHandinItems_Struct;
@@ -840,15 +840,15 @@ void Client::FinishTrade(Mob* tradingWith, bool finalizer, void* event_entry, st
qs_audit->char_count += detail->charges;
if (trade_inst->IsClassBag()) {
for (uint8 sub_slot = EQEmu::invbag::SLOT_BEGIN; sub_slot < trade_inst->GetItem()->BagSlots; ++sub_slot) {
const EQEmu::ItemInstance* trade_baginst = trade_inst->GetItem(sub_slot);
for (uint8 sub_slot = EQ::invbag::SLOT_BEGIN; sub_slot < trade_inst->GetItem()->BagSlots; ++sub_slot) {
const EQ::ItemInstance* trade_baginst = trade_inst->GetItem(sub_slot);
if(trade_baginst) {
detail = new QSHandinItems_Struct;
strcpy(detail->action_type, "HANDIN");
detail->char_slot = EQEmu::InventoryProfile::CalcSlotId(trade_slot, sub_slot);
detail->char_slot = EQ::InventoryProfile::CalcSlotId(trade_slot, sub_slot);
detail->item_id = trade_baginst->GetID();
detail->charges = (!trade_inst->IsStackable() ? 1 : trade_inst->GetCharges());
detail->aug_1 = trade_baginst->GetAugmentItemID(1);
@@ -872,19 +872,19 @@ void Client::FinishTrade(Mob* tradingWith, bool finalizer, void* event_entry, st
quest_npc = true;
}
std::vector<EQEmu::Any> item_list;
std::list<EQEmu::ItemInstance*> items;
for (int i = EQEmu::invslot::TRADE_BEGIN; i <= EQEmu::invslot::TRADE_NPC_END; ++i) {
EQEmu::ItemInstance *inst = m_inv.GetItem(i);
std::vector<EQ::Any> item_list;
std::list<EQ::ItemInstance*> items;
for (int i = EQ::invslot::TRADE_BEGIN; i <= EQ::invslot::TRADE_NPC_END; ++i) {
EQ::ItemInstance *inst = m_inv.GetItem(i);
if(inst) {
items.push_back(inst);
item_list.push_back(inst);
} else {
item_list.push_back((EQEmu::ItemInstance*)nullptr);
item_list.push_back((EQ::ItemInstance*)nullptr);
continue;
}
const EQEmu::ItemData* item = inst->GetItem();
const EQ::ItemData* item = inst->GetItem();
if(item && quest_npc == false) {
bool isPetAndCanHaveNoDrop = (RuleB(Pets, CanTakeNoDrop) &&
_CLIENTPET(tradingWith) &&
@@ -894,10 +894,10 @@ void Client::FinishTrade(Mob* tradingWith, bool finalizer, void* event_entry, st
(item->NoDrop != 0 || isPetAndCanHaveNoDrop))) {
// pets need to look inside bags and try to equip items found there
if (item->IsClassBag() && item->BagSlots > 0) {
for (int16 bslot = EQEmu::invbag::SLOT_BEGIN; bslot < item->BagSlots; bslot++) {
const EQEmu::ItemInstance* baginst = inst->GetItem(bslot);
for (int16 bslot = EQ::invbag::SLOT_BEGIN; bslot < item->BagSlots; bslot++) {
const EQ::ItemInstance* baginst = inst->GetItem(bslot);
if (baginst) {
const EQEmu::ItemData* bagitem = baginst->GetItem();
const EQ::ItemData* bagitem = baginst->GetItem();
if (bagitem && (GetGM() || (bagitem->NoDrop != 0 && baginst->IsAttuned() == false))) {
tradingWith->CastToNPC()->AddLootDrop(bagitem, &tradingWith->CastToNPC()->itemlist,
baginst->GetCharges(), 1, 127, true, true);
@@ -950,9 +950,9 @@ void Client::FinishTrade(Mob* tradingWith, bool finalizer, void* event_entry, st
tradingWith->FaceTarget(this);
}
EQEmu::ItemInstance *insts[4] = { 0 };
for (int i = EQEmu::invslot::TRADE_BEGIN; i <= EQEmu::invslot::TRADE_NPC_END; ++i) {
insts[i - EQEmu::invslot::TRADE_BEGIN] = m_inv.PopItem(i);
EQ::ItemInstance *insts[4] = { 0 };
for (int i = EQ::invslot::TRADE_BEGIN; i <= EQ::invslot::TRADE_NPC_END; ++i) {
insts[i - EQ::invslot::TRADE_BEGIN] = m_inv.PopItem(i);
database.SaveInventory(CharacterID(), nullptr, i);
}
@@ -971,8 +971,8 @@ bool Client::CheckTradeLoreConflict(Client* other)
if (!other)
return true;
for (int16 index = EQEmu::invslot::TRADE_BEGIN; index <= EQEmu::invslot::TRADE_END; ++index) {
const EQEmu::ItemInstance* inst = m_inv[index];
for (int16 index = EQ::invslot::TRADE_BEGIN; index <= EQ::invslot::TRADE_END; ++index) {
const EQ::ItemInstance* inst = m_inv[index];
if (!inst || !inst->GetItem())
continue;
@@ -980,8 +980,8 @@ bool Client::CheckTradeLoreConflict(Client* other)
return true;
}
for (int16 index = EQEmu::invbag::TRADE_BAGS_BEGIN; index <= EQEmu::invbag::TRADE_BAGS_END; ++index) {
const EQEmu::ItemInstance* inst = m_inv[index];
for (int16 index = EQ::invbag::TRADE_BAGS_BEGIN; index <= EQ::invbag::TRADE_BAGS_END; ++index) {
const EQ::ItemInstance* inst = m_inv[index];
if (!inst || !inst->GetItem())
continue;
@@ -994,8 +994,8 @@ bool Client::CheckTradeLoreConflict(Client* other)
bool Client::CheckTradeNonDroppable()
{
for (int16 index = EQEmu::invslot::TRADE_BEGIN; index <= EQEmu::invslot::TRADE_END; ++index){
const EQEmu::ItemInstance* inst = m_inv[index];
for (int16 index = EQ::invslot::TRADE_BEGIN; index <= EQ::invslot::TRADE_END; ++index){
const EQ::ItemInstance* inst = m_inv[index];
if (!inst)
continue;
@@ -1115,7 +1115,7 @@ void Client::Trader_EndTrader() {
for(int i = 0; i < 80; i++) {
if(gis->Items[i] != 0) {
if (Customer->ClientVersion() >= EQEmu::versions::ClientVersion::RoF)
if (Customer->ClientVersion() >= EQ::versions::ClientVersion::RoF)
{
// RoF+ use Item IDs for now
tdis->ItemID = gis->Items[i];
@@ -1175,18 +1175,18 @@ void Client::SendTraderItem(uint32 ItemID, uint16 Quantity) {
std::string Packet;
int16 FreeSlotID=0;
const EQEmu::ItemData* item = database.GetItem(ItemID);
const EQ::ItemData* item = database.GetItem(ItemID);
if(!item){
LogTrading("Bogus item deleted in Client::SendTraderItem!\n");
return;
}
EQEmu::ItemInstance* inst = database.CreateItem(item, Quantity);
EQ::ItemInstance* inst = database.CreateItem(item, Quantity);
if (inst)
{
bool is_arrow = (inst->GetItem()->ItemType == EQEmu::item::ItemTypeArrow) ? true : false;
bool is_arrow = (inst->GetItem()->ItemType == EQ::item::ItemTypeArrow) ? true : false;
FreeSlotID = m_inv.FindFreeSlot(false, true, inst->GetItem()->Size, is_arrow);
PutItemInInventory(FreeSlotID, *inst);
@@ -1200,16 +1200,16 @@ void Client::SendTraderItem(uint32 ItemID, uint16 Quantity) {
void Client::SendSingleTraderItem(uint32 CharID, int SerialNumber) {
EQEmu::ItemInstance* inst= database.LoadSingleTraderItem(CharID, SerialNumber);
EQ::ItemInstance* inst= database.LoadSingleTraderItem(CharID, SerialNumber);
if(inst) {
SendItemPacket(EQEmu::invslot::slotCursor, inst, ItemPacketMerchant); // MainCursor?
SendItemPacket(EQ::invslot::slotCursor, inst, ItemPacketMerchant); // MainCursor?
safe_delete(inst);
}
}
void Client::BulkSendTraderInventory(uint32 char_id) {
const EQEmu::ItemData *item;
const EQ::ItemData *item;
TraderCharges_Struct* TraderItems = database.LoadTraderItemWithCharges(char_id);
@@ -1221,7 +1221,7 @@ void Client::BulkSendTraderInventory(uint32 char_id) {
item=database.GetItem(TraderItems->ItemID[i]);
if (item && (item->NoDrop!=0)) {
EQEmu::ItemInstance* inst = database.CreateItem(item);
EQ::ItemInstance* inst = database.CreateItem(item);
if (inst) {
inst->SetSerialNumber(TraderItems->SerialNumber[i]);
if(TraderItems->Charges[i] > 0)
@@ -1233,7 +1233,7 @@ void Client::BulkSendTraderInventory(uint32 char_id) {
}
inst->SetPrice(TraderItems->ItemCost[i]);
SendItemPacket(EQEmu::invslot::slotCursor, inst, ItemPacketMerchant); // MainCursor?
SendItemPacket(EQ::invslot::slotCursor, inst, ItemPacketMerchant); // MainCursor?
safe_delete(inst);
}
else
@@ -1245,14 +1245,14 @@ void Client::BulkSendTraderInventory(uint32 char_id) {
uint32 Client::FindTraderItemSerialNumber(int32 ItemID) {
EQEmu::ItemInstance* item = nullptr;
EQ::ItemInstance* item = nullptr;
uint16 SlotID = 0;
for (int i = EQEmu::invslot::GENERAL_BEGIN; i <= EQEmu::invslot::GENERAL_END; i++){
for (int i = EQ::invslot::GENERAL_BEGIN; i <= EQ::invslot::GENERAL_END; i++){
item = this->GetInv().GetItem(i);
if (item && item->GetItem()->ID == 17899){ //Traders Satchel
for (int x = EQEmu::invbag::SLOT_BEGIN; x <= EQEmu::invbag::SLOT_END; x++) {
for (int x = EQ::invbag::SLOT_BEGIN; x <= EQ::invbag::SLOT_END; x++) {
// we already have the parent bag and a contents iterator..why not just iterate the bag!??
SlotID = EQEmu::InventoryProfile::CalcSlotId(i, x);
SlotID = EQ::InventoryProfile::CalcSlotId(i, x);
item = this->GetInv().GetItem(SlotID);
if (item) {
if (item->GetID() == ItemID)
@@ -1266,16 +1266,16 @@ uint32 Client::FindTraderItemSerialNumber(int32 ItemID) {
return 0;
}
EQEmu::ItemInstance* Client::FindTraderItemBySerialNumber(int32 SerialNumber){
EQ::ItemInstance* Client::FindTraderItemBySerialNumber(int32 SerialNumber){
EQEmu::ItemInstance* item = nullptr;
EQ::ItemInstance* item = nullptr;
uint16 SlotID = 0;
for (int i = EQEmu::invslot::GENERAL_BEGIN; i <= EQEmu::invslot::GENERAL_END; i++){
for (int i = EQ::invslot::GENERAL_BEGIN; i <= EQ::invslot::GENERAL_END; i++){
item = this->GetInv().GetItem(i);
if(item && item->GetItem()->ID == 17899){ //Traders Satchel
for (int x = EQEmu::invbag::SLOT_BEGIN; x <= EQEmu::invbag::SLOT_END; x++) {
for (int x = EQ::invbag::SLOT_BEGIN; x <= EQ::invbag::SLOT_END; x++) {
// we already have the parent bag and a contents iterator..why not just iterate the bag!??
SlotID = EQEmu::InventoryProfile::CalcSlotId(i, x);
SlotID = EQ::InventoryProfile::CalcSlotId(i, x);
item = this->GetInv().GetItem(SlotID);
if(item) {
if(item->GetSerialNumber() == SerialNumber)
@@ -1292,7 +1292,7 @@ EQEmu::ItemInstance* Client::FindTraderItemBySerialNumber(int32 SerialNumber){
GetItems_Struct* Client::GetTraderItems(){
const EQEmu::ItemInstance* item = nullptr;
const EQ::ItemInstance* item = nullptr;
uint16 SlotID = INVALID_INDEX;
auto gis = new GetItems_Struct;
@@ -1301,16 +1301,16 @@ GetItems_Struct* Client::GetTraderItems(){
uint8 ndx = 0;
for (int i = EQEmu::invslot::GENERAL_BEGIN; i <= EQEmu::invslot::GENERAL_END; i++) {
for (int i = EQ::invslot::GENERAL_BEGIN; i <= EQ::invslot::GENERAL_END; i++) {
if (ndx >= 80)
break;
item = this->GetInv().GetItem(i);
if(item && item->GetItem()->ID == 17899){ //Traders Satchel
for (int x = EQEmu::invbag::SLOT_BEGIN; x <= EQEmu::invbag::SLOT_END; x++) {
for (int x = EQ::invbag::SLOT_BEGIN; x <= EQ::invbag::SLOT_END; x++) {
if (ndx >= 80)
break;
SlotID = EQEmu::InventoryProfile::CalcSlotId(i, x);
SlotID = EQ::InventoryProfile::CalcSlotId(i, x);
item = this->GetInv().GetItem(SlotID);
@@ -1328,13 +1328,13 @@ GetItems_Struct* Client::GetTraderItems(){
uint16 Client::FindTraderItem(int32 SerialNumber, uint16 Quantity){
const EQEmu::ItemInstance* item= nullptr;
const EQ::ItemInstance* item= nullptr;
uint16 SlotID = 0;
for (int i = EQEmu::invslot::GENERAL_BEGIN; i <= EQEmu::invslot::GENERAL_END; i++) {
for (int i = EQ::invslot::GENERAL_BEGIN; i <= EQ::invslot::GENERAL_END; i++) {
item = this->GetInv().GetItem(i);
if(item && item->GetItem()->ID == 17899){ //Traders Satchel
for (int x = EQEmu::invbag::SLOT_BEGIN; x <= EQEmu::invbag::SLOT_END; x++){
SlotID = EQEmu::InventoryProfile::CalcSlotId(i, x);
for (int x = EQ::invbag::SLOT_BEGIN; x <= EQ::invbag::SLOT_END; x++){
SlotID = EQ::InventoryProfile::CalcSlotId(i, x);
item = this->GetInv().GetItem(SlotID);
@@ -1371,7 +1371,7 @@ void Client::NukeTraderItem(uint16 Slot,int16 Charges,uint16 Quantity,Client* Cu
tdis->Unknown000 = 0;
tdis->TraderID = Customer->GetID();
if (Customer->ClientVersion() >= EQEmu::versions::ClientVersion::RoF)
if (Customer->ClientVersion() >= EQ::versions::ClientVersion::RoF)
{
// RoF+ use Item IDs for now
tdis->ItemID = itemid;
@@ -1390,7 +1390,7 @@ void Client::NukeTraderItem(uint16 Slot,int16 Charges,uint16 Quantity,Client* Cu
}
// This updates the trader. Removes it from his trading bags.
//
const EQEmu::ItemInstance* Inst = m_inv[Slot];
const EQ::ItemInstance* Inst = m_inv[Slot];
database.SaveInventory(CharacterID(), Inst, Slot);
@@ -1432,7 +1432,7 @@ void Client::TraderUpdate(uint16 SlotID,uint32 TraderID){
void Client::FindAndNukeTraderItem(int32 SerialNumber, uint16 Quantity, Client* Customer, uint16 TraderSlot){
const EQEmu::ItemInstance* item= nullptr;
const EQ::ItemInstance* item= nullptr;
bool Stackable = false;
int16 Charges=0;
@@ -1507,7 +1507,7 @@ void Client::ReturnTraderReq(const EQApplicationPacket* app, int16 TraderItemCha
EQApplicationPacket* outapp = nullptr;
if (ClientVersion() >= EQEmu::versions::ClientVersion::RoF)
if (ClientVersion() >= EQ::versions::ClientVersion::RoF)
{
outapp = new EQApplicationPacket(OP_TraderShop, sizeof(TraderBuy_Struct));
}
@@ -1519,7 +1519,7 @@ void Client::ReturnTraderReq(const EQApplicationPacket* app, int16 TraderItemCha
TraderBuy_Struct* outtbs = (TraderBuy_Struct*)outapp->pBuffer;
memcpy(outtbs, tbs, app->size);
if (ClientVersion() >= EQEmu::versions::ClientVersion::RoF)
if (ClientVersion() >= EQ::versions::ClientVersion::RoF)
{
// Convert Serial Number back to Item ID for RoF+
outtbs->ItemID = itemid;
@@ -1584,10 +1584,10 @@ void Client::BuyTraderItem(TraderBuy_Struct* tbs, Client* Trader, const EQApplic
outtbs->ItemID = tbs->ItemID;
const EQEmu::ItemInstance* BuyItem = nullptr;
const EQ::ItemInstance* BuyItem = nullptr;
uint32 ItemID = 0;
if (ClientVersion() >= EQEmu::versions::ClientVersion::RoF)
if (ClientVersion() >= EQ::versions::ClientVersion::RoF)
{
// Convert Item ID to Serial Number for RoF+
ItemID = tbs->ItemID;
@@ -1648,7 +1648,7 @@ void Client::BuyTraderItem(TraderBuy_Struct* tbs, Client* Trader, const EQApplic
// This cannot overflow assuming MAX_TRANSACTION_VALUE, checked above, is the default of 2000000000
uint32 TotalCost = tbs->Price * outtbs->Quantity;
if (Trader->ClientVersion() >= EQEmu::versions::ClientVersion::RoF)
if (Trader->ClientVersion() >= EQ::versions::ClientVersion::RoF)
{
// RoF+ uses individual item price where older clients use total price
outtbs->Price = tbs->Price;
@@ -1699,7 +1699,7 @@ void Client::BuyTraderItem(TraderBuy_Struct* tbs, Client* Trader, const EQApplic
Trader->FindAndNukeTraderItem(tbs->ItemID, outtbs->Quantity, this, 0);
if (ItemID > 0 && Trader->ClientVersion() >= EQEmu::versions::ClientVersion::RoF)
if (ItemID > 0 && Trader->ClientVersion() >= EQ::versions::ClientVersion::RoF)
{
// Convert Serial Number back to ItemID for RoF+
outtbs->ItemID = ItemID;
@@ -1717,7 +1717,7 @@ void Client::SendBazaarWelcome()
auto row = results.begin();
EQApplicationPacket* outapp = nullptr;
if (ClientVersion() >= EQEmu::versions::ClientVersion::RoF)
if (ClientVersion() >= EQ::versions::ClientVersion::RoF)
{
outapp = new EQApplicationPacket(OP_TraderShop, sizeof(BazaarWelcome_Struct));
}
@@ -1735,7 +1735,7 @@ void Client::SendBazaarWelcome()
bws->Traders = atoi(row[0]);
bws->Items = atoi(row[1]);
if (ClientVersion() >= EQEmu::versions::ClientVersion::RoF)
if (ClientVersion() >= EQ::versions::ClientVersion::RoF)
{
bws->Unknown012 = GetID();
}
@@ -2046,11 +2046,11 @@ static void UpdateTraderCustomerItemsAdded(uint32 CustomerID, TraderCharges_Stru
if(!Customer) return;
const EQEmu::ItemData *item = database.GetItem(ItemID);
const EQ::ItemData *item = database.GetItem(ItemID);
if(!item) return;
EQEmu::ItemInstance* inst = database.CreateItem(item);
EQ::ItemInstance* inst = database.CreateItem(item);
if(!inst) return;
@@ -2074,7 +2074,7 @@ static void UpdateTraderCustomerItemsAdded(uint32 CustomerID, TraderCharges_Stru
LogTrading("Sending price update for [{}], Serial No. [{}] with [{}] charges",
item->Name, gis->SerialNumber[i], gis->Charges[i]);
Customer->SendItemPacket(EQEmu::invslot::slotCursor, inst, ItemPacketMerchant); // MainCursor?
Customer->SendItemPacket(EQ::invslot::slotCursor, inst, ItemPacketMerchant); // MainCursor?
}
}
@@ -2090,7 +2090,7 @@ static void UpdateTraderCustomerPriceChanged(uint32 CustomerID, TraderCharges_St
if(!Customer) return;
const EQEmu::ItemData *item = database.GetItem(ItemID);
const EQ::ItemData *item = database.GetItem(ItemID);
if(!item) return;
@@ -2107,7 +2107,7 @@ static void UpdateTraderCustomerPriceChanged(uint32 CustomerID, TraderCharges_St
for(int i = 0; i < 80; i++) {
if(gis->ItemID[i] == ItemID) {
if (Customer->ClientVersion() >= EQEmu::versions::ClientVersion::RoF)
if (Customer->ClientVersion() >= EQ::versions::ClientVersion::RoF)
{
// RoF+ use Item IDs for now
tdis->ItemID = gis->ItemID[i];
@@ -2131,7 +2131,7 @@ static void UpdateTraderCustomerPriceChanged(uint32 CustomerID, TraderCharges_St
LogTrading("Sending price updates to customer [{}]", Customer->GetName());
EQEmu::ItemInstance* inst = database.CreateItem(item);
EQ::ItemInstance* inst = database.CreateItem(item);
if(!inst) return;
@@ -2158,7 +2158,7 @@ static void UpdateTraderCustomerPriceChanged(uint32 CustomerID, TraderCharges_St
LogTrading("Sending price update for [{}], Serial No. [{}] with [{}] charges",
item->Name, gis->SerialNumber[i], gis->Charges[i]);
Customer->SendItemPacket(EQEmu::invslot::slotCursor, inst, ItemPacketMerchant); // MainCursor??
Customer->SendItemPacket(EQ::invslot::slotCursor, inst, ItemPacketMerchant); // MainCursor??
}
safe_delete(inst);
}
@@ -2249,7 +2249,7 @@ void Client::HandleTraderPriceUpdate(const EQApplicationPacket *app) {
}
const EQEmu::ItemData *item = 0;
const EQ::ItemData *item = 0;
if(IDOfItemToAdd)
item = database.GetItem(IDOfItemToAdd);
@@ -2415,7 +2415,7 @@ void Client::SendBuyerResults(char* searchString, uint32 searchID) {
char *buf = (char *)outapp->pBuffer;
const EQEmu::ItemData* item = database.GetItem(itemID);
const EQ::ItemData* item = database.GetItem(itemID);
if(!item) {
safe_delete(outapp);
@@ -2511,7 +2511,7 @@ void Client::ShowBuyLines(const EQApplicationPacket *app) {
char *Buf = (char *)outapp->pBuffer;
const EQEmu::ItemData* item = database.GetItem(ItemID);
const EQ::ItemData* item = database.GetItem(ItemID);
if(!item) {
safe_delete(outapp);
@@ -2555,7 +2555,7 @@ void Client::SellToBuyer(const EQApplicationPacket *app) {
/*uint32 BuyerID2 =*/ VARSTRUCT_SKIP_TYPE(uint32, Buf); //unused
/*uint32 Unknown3 =*/ VARSTRUCT_SKIP_TYPE(uint32, Buf); //unused
const EQEmu::ItemData *item = database.GetItem(ItemID);
const EQ::ItemData *item = database.GetItem(ItemID);
if(!item || !Quantity || !Price || !QtyBuyerWants) return;
@@ -2621,7 +2621,7 @@ void Client::SellToBuyer(const EQApplicationPacket *app) {
return;
}
EQEmu::ItemInstance* ItemToTransfer = m_inv.PopItem(SellerSlot);
EQ::ItemInstance* ItemToTransfer = m_inv.PopItem(SellerSlot);
if(!ItemToTransfer || !Buyer->MoveItemToInventory(ItemToTransfer, true)) {
LogError("Unexpected error while moving item from seller to buyer");
@@ -2667,7 +2667,7 @@ void Client::SellToBuyer(const EQApplicationPacket *app) {
return;
}
EQEmu::ItemInstance* ItemToTransfer = m_inv.PopItem(SellerSlot);
EQ::ItemInstance* ItemToTransfer = m_inv.PopItem(SellerSlot);
if(!ItemToTransfer) {
LogError("Unexpected error while moving item from seller to buyer");
@@ -2767,7 +2767,7 @@ void Client::SellToBuyer(const EQApplicationPacket *app) {
VARSTRUCT_ENCODE_TYPE(uint32, Buf, Quantity);
VARSTRUCT_ENCODE_TYPE(uint32, Buf, Quantity * Price);
if (ClientVersion() >= EQEmu::versions::ClientVersion::SoD)
if (ClientVersion() >= EQ::versions::ClientVersion::SoD)
{
VARSTRUCT_ENCODE_TYPE(uint32, Buf, 0); // Think this is the upper 32 bits of a 64 bit price
}
@@ -2791,7 +2791,7 @@ void Client::SellToBuyer(const EQApplicationPacket *app) {
VARSTRUCT_ENCODE_TYPE(uint32, Buf, Quantity);
VARSTRUCT_ENCODE_TYPE(uint32, Buf, Quantity * Price);
if (Buyer->ClientVersion() >= EQEmu::versions::ClientVersion::SoD)
if (Buyer->ClientVersion() >= EQ::versions::ClientVersion::SoD)
{
VARSTRUCT_ENCODE_TYPE(uint32, Buf, 0); // Think this is the upper 32 bits of a 64 bit price
}
@@ -2946,7 +2946,7 @@ void Client::UpdateBuyLine(const EQApplicationPacket *app) {
/*uint32 UnknownZ =*/ VARSTRUCT_SKIP_TYPE(uint32, Buf); //unused
uint32 ItemCount = VARSTRUCT_DECODE_TYPE(uint32, Buf);
const EQEmu::ItemData *item = database.GetItem(ItemID);
const EQ::ItemData *item = database.GetItem(ItemID);
if(!item) return;
@@ -3010,7 +3010,7 @@ void Client::BuyerItemSearch(const EQApplicationPacket *app) {
BuyerItemSearchResults_Struct* bisr = (BuyerItemSearchResults_Struct*)outapp->pBuffer;
const EQEmu::ItemData* item = 0;
const EQ::ItemData* item = 0;
int Count=0;
zone/trap.cpp
+1 -1
View File
@@ -135,7 +135,7 @@ void Trap::Trigger(Mob* trigger)
entity_list.MessageClose(trigger,false,100,13,"%s",message.c_str());
}
if(hiddenTrigger){
hiddenTrigger->SpellFinished(effectvalue, trigger, EQEmu::spells::CastingSlot::Item, 0, -1, spells[effectvalue].ResistDiff);
hiddenTrigger->SpellFinished(effectvalue, trigger, EQ::spells::CastingSlot::Item, 0, -1, spells[effectvalue].ResistDiff);
}
break;
case trapTypeAlarm:
zone/tribute.cpp
+17 -17
View File
@@ -66,7 +66,7 @@ void Client::ToggleTribute(bool enabled) {
int r;
uint32 cost = 0;
uint32 level = GetLevel();
for (r = 0; r < EQEmu::invtype::TRIBUTE_SIZE; r++) {
for (r = 0; r < EQ::invtype::TRIBUTE_SIZE; r++) {
uint32 tid = m_pp.tributes[r].tribute;
if(tid == TRIBUTE_NONE)
continue;
@@ -119,7 +119,7 @@ void Client::DoTributeUpdate() {
tis->tribute_master_id = tribute_master_id; //Dont know what this is for
int r;
for (r = 0; r < EQEmu::invtype::TRIBUTE_SIZE; r++) {
for (r = 0; r < EQ::invtype::TRIBUTE_SIZE; r++) {
if(m_pp.tributes[r].tribute != TRIBUTE_NONE) {
tis->tributes[r] = m_pp.tributes[r].tribute;
tis->tiers[r] = m_pp.tributes[r].tier;
@@ -134,24 +134,24 @@ void Client::DoTributeUpdate() {
if(m_pp.tribute_active) {
//send and equip tribute items...
for (r = 0; r < EQEmu::invtype::TRIBUTE_SIZE; r++) {
for (r = 0; r < EQ::invtype::TRIBUTE_SIZE; r++) {
uint32 tid = m_pp.tributes[r].tribute;
if(tid == TRIBUTE_NONE) {
if (m_inv[EQEmu::invslot::TRIBUTE_BEGIN + r])
DeleteItemInInventory(EQEmu::invslot::TRIBUTE_BEGIN + r, 0, false);
if (m_inv[EQ::invslot::TRIBUTE_BEGIN + r])
DeleteItemInInventory(EQ::invslot::TRIBUTE_BEGIN + r, 0, false);
continue;
}
if(tribute_list.count(tid) != 1) {
if (m_inv[EQEmu::invslot::TRIBUTE_BEGIN + r])
DeleteItemInInventory(EQEmu::invslot::TRIBUTE_BEGIN + r, 0, false);
if (m_inv[EQ::invslot::TRIBUTE_BEGIN + r])
DeleteItemInInventory(EQ::invslot::TRIBUTE_BEGIN + r, 0, false);
continue;
}
//sanity check
if(m_pp.tributes[r].tier >= MAX_TRIBUTE_TIERS) {
if (m_inv[EQEmu::invslot::TRIBUTE_BEGIN + r])
DeleteItemInInventory(EQEmu::invslot::TRIBUTE_BEGIN + r, 0, false);
if (m_inv[EQ::invslot::TRIBUTE_BEGIN + r])
DeleteItemInInventory(EQ::invslot::TRIBUTE_BEGIN + r, 0, false);
m_pp.tributes[r].tier = 0;
continue;
}
@@ -161,19 +161,19 @@ void Client::DoTributeUpdate() {
uint32 item_id = tier.tribute_item_id;
//summon the item for them
const EQEmu::ItemInstance* inst = database.CreateItem(item_id, 1);
const EQ::ItemInstance* inst = database.CreateItem(item_id, 1);
if(inst == nullptr)
continue;
PutItemInInventory(EQEmu::invslot::TRIBUTE_BEGIN + r, *inst, false);
SendItemPacket(EQEmu::invslot::TRIBUTE_BEGIN + r, inst, ItemPacketTributeItem);
PutItemInInventory(EQ::invslot::TRIBUTE_BEGIN + r, *inst, false);
SendItemPacket(EQ::invslot::TRIBUTE_BEGIN + r, inst, ItemPacketTributeItem);
safe_delete(inst);
}
} else {
//unequip tribute items...
for (r = 0; r < EQEmu::invtype::TRIBUTE_SIZE; r++) {
if (m_inv[EQEmu::invslot::TRIBUTE_BEGIN + r])
DeleteItemInInventory(EQEmu::invslot::TRIBUTE_BEGIN + r, 0, false);
for (r = 0; r < EQ::invtype::TRIBUTE_SIZE; r++) {
if (m_inv[EQ::invslot::TRIBUTE_BEGIN + r])
DeleteItemInInventory(EQ::invslot::TRIBUTE_BEGIN + r, 0, false);
}
}
CalcBonuses();
@@ -192,7 +192,7 @@ void Client::SendTributeTimer() {
void Client::ChangeTributeSettings(TributeInfo_Struct *t) {
int r;
for (r = 0; r < EQEmu::invtype::TRIBUTE_SIZE; r++) {
for (r = 0; r < EQ::invtype::TRIBUTE_SIZE; r++) {
m_pp.tributes[r].tribute = TRIBUTE_NONE;
@@ -239,7 +239,7 @@ void Client::SendTributeDetails(uint32 client_id, uint32 tribute_id) {
//returns the number of points received from the tribute
int32 Client::TributeItem(uint32 slot, uint32 quantity) {
const EQEmu::ItemInstance*inst = m_inv[slot];
const EQ::ItemInstance*inst = m_inv[slot];
if(inst == nullptr)
return(0);
zone/tune.cpp
+62 -62
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(EQEmu::skills::SkillDefense) + GetLevel()) *
float softcap = (GetSkill(EQ::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(EQEmu::skills::SkillDefense) + itembonuses.HeroicAGI / 10) / 4.0) + armor + 1;
mitigation_rating = ((GetSkill(EQ::skills::SkillDefense) + itembonuses.HeroicAGI / 10) / 4.0) + armor + 1;
if (Msg >= 2)
GM->Message(Chat::White, "# + %.2f #### DEFENDER Armor Bonus [Defense Skill %i Heroic Agi %i]", mitigation_rating - tmp_armor, GetSkill(EQEmu::skills::SkillDefense), itembonuses.HeroicAGI);
GM->Message(Chat::White, "# + %.2f #### DEFENDER Armor Bonus [Defense Skill %i Heroic Agi %i]", mitigation_rating - tmp_armor, GetSkill(EQ::skills::SkillDefense), itembonuses.HeroicAGI);
}
else{
mitigation_rating = ((GetSkill(EQEmu::skills::SkillDefense) + itembonuses.HeroicAGI / 10) / 3.0) + (armor * 1.333333) + 1;
mitigation_rating = ((GetSkill(EQ::skills::SkillDefense) + itembonuses.HeroicAGI / 10) / 3.0) + (armor * 1.333333) + 1;
if (Msg >= 2)
GM->Message(Chat::White, "# + %.2f #### DEFENDER Armor Bonus [Defense Skill %i Heroic Agi %i]", mitigation_rating - tmp_armor, GetSkill(EQEmu::skills::SkillDefense), itembonuses.HeroicAGI);
GM->Message(Chat::White, "# + %.2f #### DEFENDER Armor Bonus [Defense Skill %i Heroic Agi %i]", mitigation_rating - tmp_armor, GetSkill(EQ::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(EQEmu::skills::SkillOffense)*1.345));
attack_rating = (atk_override + ((attacker->GetSTR() - 66) * 0.9) + (attacker->GetSkill(EQ::skills::SkillOffense)*1.345));
else
attack_rating = ((attacker->CastToClient()->CalcATK() + add_atk) + ((attacker->GetSTR() - 66) * 0.9) + (attacker->GetSkill(EQEmu::skills::SkillOffense)*1.345));
attack_rating = ((attacker->CastToClient()->CalcATK() + add_atk) + ((attacker->GetSTR() - 66) * 0.9) + (attacker->GetSkill(EQ::skills::SkillOffense)*1.345));
}
else{
if (atk_override)
attack_rating = (atk_override + (attacker->GetSkill(EQEmu::skills::SkillOffense)*1.345) + ((attacker->GetSTR() - 66) * 0.9));
attack_rating = (atk_override + (attacker->GetSkill(EQ::skills::SkillOffense)*1.345) + ((attacker->GetSTR() - 66) * 0.9));
else
attack_rating = ((attacker->GetATK() + add_atk) + (attacker->GetSkill(EQEmu::skills::SkillOffense)*1.345) + ((attacker->GetSTR() - 66) * 0.9));
attack_rating = ((attacker->GetATK() + add_atk) + (attacker->GetSkill(EQ::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(Chat::White, "# %i #### ATTACKER Worn/Equip ATK Bonus", attacker->itembonuses.ATK);
GM->Message(Chat::White, "# %i #### ATTACKER Worn/Equip ATK Bonus", attacker->itembonuses.ATK);
GM->Message(Chat::White, "# %.2f #### ATTACKER Strength Stat ATK Bonus [Stat Amt: %i]", ((attacker->GetSTR()-66) * 0.9),attacker->GetSTR());
GM->Message(Chat::White, "# %.2f #### ATTACKER Offensive Skill ATK Bonus [Stat Amt: %i]", (attacker->GetSkill(EQEmu::skills::SkillOffense)*1.345), attacker->GetSkill(EQEmu::skills::SkillOffense));
GM->Message(Chat::White, "# %.2f #### ATTACKER Offensive Skill ATK Bonus [Stat Amt: %i]", (attacker->GetSkill(EQ::skills::SkillOffense)*1.345), attacker->GetSkill(EQ::skills::SkillOffense));
}
else{
@@ -476,7 +476,7 @@ int32 Mob::Tune_MeleeMitigation(Mob* GM, Mob *attacker, int32 damage, int32 minh
GM->Message(Chat::White, "# %i #### ATTACKER SE_ATK(2) spell Bonus", attacker->spellbonuses.ATK);
GM->Message(Chat::White, "# %i #### ATTACKER NPC ATK Stat", attacker->CastToNPC()->ATK);
GM->Message(Chat::White, "# %.2f #### ATTACKER Strength Stat ATK Bonus [Stat Amt: %i]", ((attacker->GetSTR()-66) * 0.9),attacker->GetSTR());
GM->Message(Chat::White, "# %.2f #### ATTACKER Offensive Skill ATK Bonus [Stat Amt: %i]", (attacker->GetSkill(EQEmu::skills::SkillOffense)*1.345), attacker->GetSkill(EQEmu::skills::SkillOffense));
GM->Message(Chat::White, "# %.2f #### ATTACKER Offensive Skill ATK Bonus [Stat Amt: %i]", (attacker->GetSkill(EQ::skills::SkillOffense)*1.345), attacker->GetSkill(EQ::skills::SkillOffense));
}
}
@@ -582,13 +582,13 @@ int32 Client::Tune_GetMeleeMitDmg(Mob* GM, Mob *attacker, int32 damage, int32 mi
int32 Client::GetMeleeDamage(Mob* other, bool GetMinDamage)
{
int Hand = EQEmu::invslot::slotPrimary;
int Hand = EQ::invslot::slotPrimary;
if (!other)
return 0;
EQEmu::ItemInstance* weapon;
weapon = GetInv().GetItem(EQEmu::invslot::slotPrimary);
EQ::ItemInstance* weapon;
weapon = GetInv().GetItem(EQ::invslot::slotPrimary);
if(weapon != nullptr) {
if (!weapon->IsWeapon()) {
@@ -596,7 +596,7 @@ int32 Client::GetMeleeDamage(Mob* other, bool GetMinDamage)
}
}
EQEmu::skills::SkillType skillinuse = AttackAnimation(Hand, weapon);
EQ::skills::SkillType skillinuse = AttackAnimation(Hand, weapon);
int damage = 0;
uint8 mylevel = GetLevel() ? GetLevel() : 1;
@@ -620,16 +620,16 @@ int32 Client::GetMeleeDamage(Mob* other, bool GetMinDamage)
max_hit = (RuleI(Combat, HitCapPre20));
CheckIncreaseSkill(skillinuse, other, -15);
CheckIncreaseSkill(EQEmu::skills::SkillOffense, other, -15);
CheckIncreaseSkill(EQ::skills::SkillOffense, other, -15);
#ifndef EQEMU_NO_WEAPON_DAMAGE_BONUS
int ucDamageBonus = 0;
if (Hand == EQEmu::invslot::slotPrimary && GetLevel() >= 28 && IsWarriorClass())
if (Hand == EQ::invslot::slotPrimary && GetLevel() >= 28 && IsWarriorClass())
{
ucDamageBonus = GetWeaponDamageBonus(weapon ? weapon->GetItem() : (const EQEmu::ItemData*) nullptr);
ucDamageBonus = GetWeaponDamageBonus(weapon ? weapon->GetItem() : (const EQ::ItemData*) nullptr);
min_hit += (int) ucDamageBonus;
max_hit += (int) ucDamageBonus;
@@ -657,28 +657,28 @@ void Mob::Tune_FindAccuaryByHitChance(Mob* defender, Mob *attacker, float hit_ch
float tmp_hit_chance = 0.0f;
bool end = false;
EQEmu::skills::SkillType skillinuse = EQEmu::skills::SkillHandtoHand;
EQ::skills::SkillType skillinuse = EQ::skills::SkillHandtoHand;
if (attacker->IsClient())
{//Will check first equiped weapon for skill. Ie. remove wepaons to assess bow.
EQEmu::ItemInstance* weapon;
weapon = attacker->CastToClient()->GetInv().GetItem(EQEmu::invslot::slotPrimary);
EQ::ItemInstance* weapon;
weapon = attacker->CastToClient()->GetInv().GetItem(EQ::invslot::slotPrimary);
if(weapon && weapon->IsWeapon()){
skillinuse = attacker->CastToClient()->AttackAnimation(EQEmu::invslot::slotPrimary, weapon);
skillinuse = attacker->CastToClient()->AttackAnimation(EQ::invslot::slotPrimary, weapon);
}
else {
weapon = attacker->CastToClient()->GetInv().GetItem(EQEmu::invslot::slotSecondary);
weapon = attacker->CastToClient()->GetInv().GetItem(EQ::invslot::slotSecondary);
if (weapon && weapon->IsWeapon())
skillinuse = attacker->CastToClient()->AttackAnimation(EQEmu::invslot::slotSecondary, weapon);
skillinuse = attacker->CastToClient()->AttackAnimation(EQ::invslot::slotSecondary, weapon);
else {
weapon = attacker->CastToClient()->GetInv().GetItem(EQEmu::invslot::slotRange);
weapon = attacker->CastToClient()->GetInv().GetItem(EQ::invslot::slotRange);
if (weapon && weapon->IsWeapon())
skillinuse = attacker->CastToClient()->AttackAnimation(EQEmu::invslot::slotRange, weapon);
skillinuse = attacker->CastToClient()->AttackAnimation(EQ::invslot::slotRange, weapon);
}
}
}
tmp_hit_chance = Tune_CheckHitChance(defender, attacker, skillinuse, EQEmu::invslot::slotPrimary, 0, 0, 0, avoid_override);
tmp_hit_chance = Tune_CheckHitChance(defender, attacker, skillinuse, EQ::invslot::slotPrimary, 0, 0, 0, avoid_override);
Message(0, "#Tune - Begin Parse [Interval %i Max Loop Iterations %i]", interval, max_loop);
@@ -690,7 +690,7 @@ void Mob::Tune_FindAccuaryByHitChance(Mob* defender, Mob *attacker, float hit_ch
for (int j=0; j < max_loop; j++)
{
tmp_hit_chance = Tune_CheckHitChance(defender, attacker, skillinuse, EQEmu::invslot::slotPrimary, 0, false, 0, avoid_override, add_acc);
tmp_hit_chance = Tune_CheckHitChance(defender, attacker, skillinuse, EQ::invslot::slotPrimary, 0, false, 0, avoid_override, add_acc);
if (Msg >= 3)
Message(Chat::Yellow, "#Tune - Processing... [%i] [ACCURACY %i] Hit Chance %.2f ",j,add_acc,tmp_hit_chance);
@@ -705,7 +705,7 @@ void Mob::Tune_FindAccuaryByHitChance(Mob* defender, Mob *attacker, float hit_ch
if (end){
Tune_CheckHitChance(defender, attacker, skillinuse, EQEmu::invslot::slotPrimary, 0, Msg, 0, avoid_override);//Display Stat Report
Tune_CheckHitChance(defender, attacker, skillinuse, EQ::invslot::slotPrimary, 0, Msg, 0, avoid_override);//Display Stat Report
Message(0, " ");
@@ -737,28 +737,28 @@ void Mob::Tune_FindAvoidanceByHitChance(Mob* defender, Mob *attacker, float hit_
float tmp_hit_chance = 0.0f;
bool end = false;
EQEmu::skills::SkillType skillinuse = EQEmu::skills::SkillHandtoHand;
EQ::skills::SkillType skillinuse = EQ::skills::SkillHandtoHand;
if (attacker->IsClient())
{//Will check first equiped weapon for skill. Ie. remove wepaons to assess bow.
EQEmu::ItemInstance* weapon;
weapon = attacker->CastToClient()->GetInv().GetItem(EQEmu::invslot::slotPrimary);
EQ::ItemInstance* weapon;
weapon = attacker->CastToClient()->GetInv().GetItem(EQ::invslot::slotPrimary);
if(weapon && weapon->IsWeapon()){
skillinuse = attacker->CastToClient()->AttackAnimation(EQEmu::invslot::slotPrimary, weapon);
skillinuse = attacker->CastToClient()->AttackAnimation(EQ::invslot::slotPrimary, weapon);
}
else {
weapon = attacker->CastToClient()->GetInv().GetItem(EQEmu::invslot::slotSecondary);
weapon = attacker->CastToClient()->GetInv().GetItem(EQ::invslot::slotSecondary);
if (weapon && weapon->IsWeapon())
skillinuse = attacker->CastToClient()->AttackAnimation(EQEmu::invslot::slotSecondary, weapon);
skillinuse = attacker->CastToClient()->AttackAnimation(EQ::invslot::slotSecondary, weapon);
else {
weapon = attacker->CastToClient()->GetInv().GetItem(EQEmu::invslot::slotRange);
weapon = attacker->CastToClient()->GetInv().GetItem(EQ::invslot::slotRange);
if (weapon && weapon->IsWeapon())
skillinuse = attacker->CastToClient()->AttackAnimation(EQEmu::invslot::slotRange, weapon);
skillinuse = attacker->CastToClient()->AttackAnimation(EQ::invslot::slotRange, weapon);
}
}
}
tmp_hit_chance = Tune_CheckHitChance(defender, attacker, skillinuse, EQEmu::invslot::slotPrimary, 0, 0, acc_override, 0);
tmp_hit_chance = Tune_CheckHitChance(defender, attacker, skillinuse, EQ::invslot::slotPrimary, 0, 0, acc_override, 0);
Message(0, "#Tune - Begin Parse [Interval %i Max Loop Iterations %i]", interval, max_loop);
Message(0, "#Tune - Processing... Find Avoidance for hit chance on defender of (%.0f) pct from attacker. [Current Hit Chance %.2f]", hit_chance, tmp_hit_chance);
@@ -768,7 +768,7 @@ void Mob::Tune_FindAvoidanceByHitChance(Mob* defender, Mob *attacker, float hit_
for (int j=0; j < max_loop; j++)
{
tmp_hit_chance = Tune_CheckHitChance(defender, attacker, skillinuse, EQEmu::invslot::slotPrimary, 0, 0, acc_override, 0, 0, add_avoid);
tmp_hit_chance = Tune_CheckHitChance(defender, attacker, skillinuse, EQ::invslot::slotPrimary, 0, 0, acc_override, 0, 0, add_avoid);
if (Msg >= 3)
Message(0, "#Tune - Processing... [%i] [AVOIDANCE %i] Hit Chance %.2f ",j,add_avoid,tmp_hit_chance);
@@ -783,7 +783,7 @@ void Mob::Tune_FindAvoidanceByHitChance(Mob* defender, Mob *attacker, float hit_
if (end){
Tune_CheckHitChance(defender, attacker, skillinuse, EQEmu::invslot::slotPrimary, 0, Msg, acc_override, 0);//Display Stat Report
Tune_CheckHitChance(defender, attacker, skillinuse, EQ::invslot::slotPrimary, 0, Msg, acc_override, 0);//Display Stat Report
Message(0, " ");
@@ -808,7 +808,7 @@ void Mob::Tune_FindAvoidanceByHitChance(Mob* defender, Mob *attacker, float hit_
}
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 Mob::Tune_CheckHitChance(Mob* defender, Mob* attacker, EQ::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);
@@ -896,9 +896,9 @@ float Mob::Tune_CheckHitChance(Mob* defender, Mob* attacker, EQEmu::skills::Skil
if(defender->IsClient())
{
chancetohit += (RuleR(Combat, WeaponSkillFalloff) * (defender->CastToClient()->MaxSkill(EQEmu::skills::SkillDefense) - defender->GetSkill(EQEmu::skills::SkillDefense)));
chancetohit += (RuleR(Combat, WeaponSkillFalloff) * (defender->CastToClient()->MaxSkill(EQ::skills::SkillDefense) - defender->GetSkill(EQ::skills::SkillDefense)));
if (Msg >= 2)
Message(0, "# + %.2f Total: %.2f #### DEFENDER Defense Skill Mod", (RuleR(Combat, WeaponSkillFalloff) * (defender->CastToClient()->MaxSkill(EQEmu::skills::SkillDefense) - defender->GetSkill(EQEmu::skills::SkillDefense))), chancetohit);
Message(0, "# + %.2f Total: %.2f #### DEFENDER Defense Skill Mod", (RuleR(Combat, WeaponSkillFalloff) * (defender->CastToClient()->MaxSkill(EQ::skills::SkillDefense) - defender->GetSkill(EQ::skills::SkillDefense))), chancetohit);
}
@@ -987,17 +987,17 @@ float Mob::Tune_CheckHitChance(Mob* defender, Mob* attacker, EQEmu::skills::Skil
hitBonus += attacker->itembonuses.HitChanceEffect[skillinuse] +
attacker->spellbonuses.HitChanceEffect[skillinuse]+
attacker->aabonuses.HitChanceEffect[skillinuse]+
attacker->itembonuses.HitChanceEffect[EQEmu::skills::HIGHEST_SKILL + 1] +
attacker->spellbonuses.HitChanceEffect[EQEmu::skills::HIGHEST_SKILL + 1] +
attacker->aabonuses.HitChanceEffect[EQEmu::skills::HIGHEST_SKILL + 1];
attacker->itembonuses.HitChanceEffect[EQ::skills::HIGHEST_SKILL + 1] +
attacker->spellbonuses.HitChanceEffect[EQ::skills::HIGHEST_SKILL + 1] +
attacker->aabonuses.HitChanceEffect[EQ::skills::HIGHEST_SKILL + 1];
if (Msg >= 2){
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->aabonuses.HitChanceEffect[EQ::skills::HIGHEST_SKILL + 1])
Message(0, "# %i #### ATTACKER SE_HitChance(184) AA Bonus [All Skills]", attacker->aabonuses.HitChanceEffect[EQ::skills::HIGHEST_SKILL + 1]);
if (attacker->spellbonuses.HitChanceEffect[EQ::skills::HIGHEST_SKILL + 1])
Message(0, "# %i #### ATTACKER SE_HitChance(184) Spell Bonus [All Skills]", attacker->spellbonuses.HitChanceEffect[EQ::skills::HIGHEST_SKILL + 1]);
if (attacker->itembonuses.HitChanceEffect[EQ::skills::HIGHEST_SKILL + 1])
Message(0, "# %i #### ATTACKER SE_HitChance(184) Worn Bonus [All Skills]", attacker->itembonuses.HitChanceEffect[EQ::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])
@@ -1008,19 +1008,19 @@ float Mob::Tune_CheckHitChance(Mob* defender, Mob* attacker, EQEmu::skills::Skil
//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[EQEmu::skills::HIGHEST_SKILL + 1] +
attacker->spellbonuses.Accuracy[EQEmu::skills::HIGHEST_SKILL + 1] +
attacker->aabonuses.Accuracy[EQEmu::skills::HIGHEST_SKILL + 1] +
hitBonus += (attacker->itembonuses.Accuracy[EQ::skills::HIGHEST_SKILL + 1] +
attacker->spellbonuses.Accuracy[EQ::skills::HIGHEST_SKILL + 1] +
attacker->aabonuses.Accuracy[EQ::skills::HIGHEST_SKILL + 1] +
attacker->aabonuses.Accuracy[skillinuse] +
attacker->itembonuses.HitChance) / 15.0f; //Item Mod 'Accuracy'
if (Msg >= 2) {
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[EQ::skills::HIGHEST_SKILL + 1])
Message(0, "# %.2f #### ATTACKER SE_Accuracy(216) AA Bonus [All Skills] [Stat Amt: %i]", static_cast<float>(attacker->aabonuses.Accuracy[EQ::skills::HIGHEST_SKILL + 1]) / 15.0f, attacker->aabonuses.Accuracy[EQ::skills::HIGHEST_SKILL + 1]);
if (attacker->spellbonuses.Accuracy[EQ::skills::HIGHEST_SKILL + 1])
Message(0, "# %.2f #### ATTACKER SE_Accuracy(216) Spell Bonus [All Skills] [Stat Amt: %i]", static_cast<float>(attacker->spellbonuses.Accuracy[EQ::skills::HIGHEST_SKILL + 1]) / 15.0f, attacker->spellbonuses.Accuracy[EQ::skills::HIGHEST_SKILL + 1]);
if (attacker->itembonuses.Accuracy[EQ::skills::HIGHEST_SKILL + 1])
Message(0, "# %.2f #### ATTACKER SE_Accuracy(216) Worn Bonus [All Skills] [Stat Amt: %i]", static_cast<float>(attacker->itembonuses.Accuracy[EQ::skills::HIGHEST_SKILL + 1]) / 15.0f, attacker->itembonuses.Accuracy[EQ::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)
@@ -1052,7 +1052,7 @@ float Mob::Tune_CheckHitChance(Mob* defender, Mob* attacker, EQEmu::skills::Skil
hitBonus += (add_acc / 15.0f); //Modifier from database
}
if (skillinuse == EQEmu::skills::SkillArchery){
if (skillinuse == EQ::skills::SkillArchery){
hitBonus -= hitBonus*RuleR(Combat, ArcheryHitPenalty);
if (Msg >= 2)
Message(0, "# %.2f pct #### RuleR(Combat, ArcheryHitPenalty) ", RuleR(Combat, ArcheryHitPenalty));
zone/waypoints.cpp
+3 -3
View File
@@ -118,7 +118,7 @@ void NPC::ResumeWandering()
{ // we were paused by a quest
AI_walking_timer->Disable();
SetGrid(0 - GetGrid());
if (cur_wp == EQEmu::WaypointStatus::QuestControlGrid)
if (cur_wp == EQ::WaypointStatus::QuestControlGrid)
{ // got here by a MoveTo()
cur_wp = save_wp;
UpdateWaypoint(cur_wp); // have him head to last destination from here
@@ -184,7 +184,7 @@ void NPC::MoveTo(const glm::vec4 &position, bool saveguardspot)
AI_walking_timer->Disable(); // disable timer in case he is paused at a wp
if (cur_wp >= 0) { // we've not already done a MoveTo()
save_wp = cur_wp; // save the current waypoint
cur_wp = EQEmu::WaypointStatus::QuestControlGrid;
cur_wp = EQ::WaypointStatus::QuestControlGrid;
}
LogAI("MoveTo [{}], pausing regular grid wandering. Grid [{}], save_wp [{}]",
to_string(static_cast<glm::vec3>(position)).c_str(),
@@ -194,7 +194,7 @@ void NPC::MoveTo(const glm::vec4 &position, bool saveguardspot)
else { // not on a grid
roamer = true;
save_wp = 0;
cur_wp = EQEmu::WaypointStatus::QuestControlNoGrid;
cur_wp = EQ::WaypointStatus::QuestControlNoGrid;
LogAI("MoveTo [{}] without a grid", to_string(static_cast<glm::vec3>(position)).c_str());
}
zone/worldserver.cpp
+7 -7
View File
@@ -834,7 +834,7 @@ void WorldServer::HandleMessage(uint16 opcode, const EQ::Net::Packet &p)
break;
}
case ServerOP_RefreshCensorship: {
if (!EQEmu::ProfanityManager::LoadProfanityList(&database))
if (!EQ::ProfanityManager::LoadProfanityList(&database))
LogError("Received request to refresh the profanity list..but, the action failed");
break;
}
@@ -926,7 +926,7 @@ void WorldServer::HandleMessage(uint16 opcode, const EQ::Net::Packet &p)
database.SetGroupLeaderName(group->GetID(), Inviter->GetName());
group->UpdateGroupAAs();
if (Inviter->CastToClient()->ClientVersion() < EQEmu::versions::ClientVersion::SoD)
if (Inviter->CastToClient()->ClientVersion() < EQ::versions::ClientVersion::SoD)
{
auto outapp =
new EQApplicationPacket(OP_GroupUpdate, sizeof(GroupJoin_Struct));
@@ -1454,7 +1454,7 @@ void WorldServer::HandleMessage(uint16 opcode, const EQ::Net::Packet &p)
bool found_corpse = false;
for (auto const& it : entity_list.GetCorpseList()) {
if (it.second->IsPlayerCorpse() && strcmp(it.second->GetOwnerName(), s->ownername) == 0) {
if (s->consent_type == EQEmu::consent::Normal) {
if (s->consent_type == EQ::consent::Normal) {
if (s->permission == 1) {
it.second->AddConsentName(s->grantname);
}
@@ -1462,13 +1462,13 @@ void WorldServer::HandleMessage(uint16 opcode, const EQ::Net::Packet &p)
it.second->RemoveConsentName(s->grantname);
}
}
else if (s->consent_type == EQEmu::consent::Group) {
else if (s->consent_type == EQ::consent::Group) {
it.second->SetConsentGroupID(s->consent_id);
}
else if (s->consent_type == EQEmu::consent::Raid) {
else if (s->consent_type == EQ::consent::Raid) {
it.second->SetConsentRaidID(s->consent_id);
}
else if (s->consent_type == EQEmu::consent::Guild) {
else if (s->consent_type == EQ::consent::Guild) {
it.second->SetConsentGuildID(s->consent_id);
}
found_corpse = true;
@@ -1492,7 +1492,7 @@ void WorldServer::HandleMessage(uint16 opcode, const EQ::Net::Packet &p)
ServerOP_Consent_Struct* s = (ServerOP_Consent_Struct*)pack->pBuffer;
Client* owner_client = entity_list.GetClientByName(s->ownername);
Client* grant_client = nullptr;
if (s->consent_type == EQEmu::consent::Normal) {
if (s->consent_type == EQ::consent::Normal) {
grant_client = entity_list.GetClientByName(s->grantname);
}
if (owner_client || grant_client) {
zone/zone.cpp
+7 -7
View File
@@ -262,12 +262,12 @@ bool Zone::LoadZoneObjects()
data.tilt_y = atof(row[18]);
data.unknown084 = 0;
EQEmu::ItemInstance *inst = nullptr;
EQ::ItemInstance *inst = nullptr;
// FatherNitwit: this dosent seem to work...
// tradeskill containers do not have an itemid of 0... at least what I am seeing
if (itemid == 0) {
// Generic tradeskill container
inst = new EQEmu::ItemInstance(ItemInstWorldContainer);
inst = new EQ::ItemInstance(ItemInstWorldContainer);
} else {
// Groundspawn object
inst = database.CreateItem(itemid);
@@ -275,11 +275,11 @@ bool Zone::LoadZoneObjects()
// Father Nitwit's fix... not perfect...
if (inst == nullptr && type != OT_DROPPEDITEM) {
inst = new EQEmu::ItemInstance(ItemInstWorldContainer);
inst = new EQ::ItemInstance(ItemInstWorldContainer);
}
// Load child objects if container
if (inst && inst->IsType(EQEmu::item::ItemClassBag)) {
if (inst && inst->IsType(EQ::item::ItemClassBag)) {
database.LoadWorldContainer(id, inst);
}
@@ -308,7 +308,7 @@ bool Zone::LoadGroundSpawns() {
uint32 gsnumber=0;
for(gsindex=0;gsindex<50;gsindex++){
if(groundspawn.spawn[gsindex].item>0 && groundspawn.spawn[gsindex].item<SAYLINK_ITEM_ID){
EQEmu::ItemInstance* inst = nullptr;
EQ::ItemInstance* inst = nullptr;
inst = database.CreateItem(groundspawn.spawn[gsindex].item);
gsnumber=groundspawn.spawn[gsindex].max_allowed;
ix=0;
@@ -1288,7 +1288,7 @@ bool Zone::Process() {
LinkedListIterator<Spawn2 *> iterator(spawn2_list);
EQEmu::InventoryProfile::CleanDirty();
EQ::InventoryProfile::CleanDirty();
LogSpawns("Running Zone::Process -> Spawn2::Process");
@@ -2512,7 +2512,7 @@ void Zone::CalculateNpcUpdateDistanceSpread()
int x_spread = int(abs(max_x - min_x));
int y_spread = int(abs(max_y - min_y));
int combined_spread = int(abs((x_spread + y_spread) / 2));
int update_distance = EQEmu::ClampLower(int(combined_spread / 4), int(zone->GetMaxMovementUpdateRange()));
int update_distance = EQ::ClampLower(int(combined_spread / 4), int(zone->GetMaxMovementUpdateRange()));
SetNpcPositionUpdateDistance(update_distance);
zone/zone.h
+1 -1
View File
@@ -133,7 +133,7 @@ public:
const char *GetSpellBlockedMessage(uint32 spell_id, const glm::vec3 &location);
EQEmu::Random random;
EQ::Random random;
EQTime zone_time;
ZonePoint *GetClosestZonePoint(const glm::vec3 &location, const char *to_name, Client *client, float max_distance = 40000.0f);
zone/zonedb.cpp
+43 -43
View File
@@ -553,7 +553,7 @@ void ZoneDatabase::RegisterBug(Client* client, BugReport_Struct* bug_report) {
" '%s')",
zone->GetShortName(),
client->ClientVersion(),
EQEmu::versions::ClientVersionName(client->ClientVersion()),
EQ::versions::ClientVersionName(client->ClientVersion()),
client->AccountID(),
client->CharacterID(),
client->GetName(),
@@ -570,11 +570,11 @@ void ZoneDatabase::RegisterBug(Client* client, BugReport_Struct* bug_report) {
bug_report->target_id,
(target_name_ ? target_name_ : ""),
bug_report->optional_info_mask,
((bug_report->optional_info_mask & EQEmu::bug::infoCanDuplicate) != 0 ? 1 : 0),
((bug_report->optional_info_mask & EQEmu::bug::infoCrashBug) != 0 ? 1 : 0),
((bug_report->optional_info_mask & EQEmu::bug::infoTargetInfo) != 0 ? 1 : 0),
((bug_report->optional_info_mask & EQEmu::bug::infoCharacterFlags) != 0 ? 1 : 0),
((bug_report->optional_info_mask & EQEmu::bug::infoUnknownValue) != 0 ? 1 : 0),
((bug_report->optional_info_mask & EQ::bug::infoCanDuplicate) != 0 ? 1 : 0),
((bug_report->optional_info_mask & EQ::bug::infoCrashBug) != 0 ? 1 : 0),
((bug_report->optional_info_mask & EQ::bug::infoTargetInfo) != 0 ? 1 : 0),
((bug_report->optional_info_mask & EQ::bug::infoCharacterFlags) != 0 ? 1 : 0),
((bug_report->optional_info_mask & EQ::bug::infoUnknownValue) != 0 ? 1 : 0),
(bug_report_ ? bug_report_ : ""),
(system_info_ ? system_info_ : "")
);
@@ -679,7 +679,7 @@ void ZoneDatabase::GetEventLogs(const char* name,char* target,uint32 account_id,
}
// Load child objects for a world container (i.e., forge, bag dropped to ground, etc)
void ZoneDatabase::LoadWorldContainer(uint32 parentid, EQEmu::ItemInstance* container)
void ZoneDatabase::LoadWorldContainer(uint32 parentid, EQ::ItemInstance* container)
{
if (!container) {
LogError("Programming error: LoadWorldContainer passed nullptr pointer");
@@ -701,7 +701,7 @@ void ZoneDatabase::LoadWorldContainer(uint32 parentid, EQEmu::ItemInstance* cont
uint8 index = (uint8)atoi(row[0]);
uint32 item_id = (uint32)atoi(row[1]);
int8 charges = (int8)atoi(row[2]);
uint32 aug[EQEmu::invaug::SOCKET_COUNT];
uint32 aug[EQ::invaug::SOCKET_COUNT];
aug[0] = (uint32)atoi(row[3]);
aug[1] = (uint32)atoi(row[4]);
aug[2] = (uint32)atoi(row[5]);
@@ -709,9 +709,9 @@ void ZoneDatabase::LoadWorldContainer(uint32 parentid, EQEmu::ItemInstance* cont
aug[4] = (uint32)atoi(row[7]);
aug[5] = (uint32)atoi(row[8]);
EQEmu::ItemInstance* inst = database.CreateItem(item_id, charges);
EQ::ItemInstance* inst = database.CreateItem(item_id, charges);
if (inst && inst->GetItem()->IsClassCommon()) {
for (int i = EQEmu::invaug::SOCKET_BEGIN; i <= EQEmu::invaug::SOCKET_END; i++)
for (int i = EQ::invaug::SOCKET_BEGIN; i <= EQ::invaug::SOCKET_END; i++)
if (aug[i])
inst->PutAugment(&database, i, aug[i]);
// Put item inside world container
@@ -723,7 +723,7 @@ void ZoneDatabase::LoadWorldContainer(uint32 parentid, EQEmu::ItemInstance* cont
}
// Save child objects for a world container (i.e., forge, bag dropped to ground, etc)
void ZoneDatabase::SaveWorldContainer(uint32 zone_id, uint32 parent_id, const EQEmu::ItemInstance* container)
void ZoneDatabase::SaveWorldContainer(uint32 zone_id, uint32 parent_id, const EQ::ItemInstance* container)
{
// Since state is not saved for each world container action, we'll just delete
// all and save from scratch .. we may come back later to optimize
@@ -734,18 +734,18 @@ void ZoneDatabase::SaveWorldContainer(uint32 zone_id, uint32 parent_id, const EQ
DeleteWorldContainer(parent_id,zone_id);
// Save all 10 items, if they exist
for (uint8 index = EQEmu::invbag::SLOT_BEGIN; index <= EQEmu::invbag::SLOT_END; index++) {
for (uint8 index = EQ::invbag::SLOT_BEGIN; index <= EQ::invbag::SLOT_END; index++) {
EQEmu::ItemInstance* inst = container->GetItem(index);
EQ::ItemInstance* inst = container->GetItem(index);
if (!inst)
continue;
uint32 item_id = inst->GetItem()->ID;
uint32 augslot[EQEmu::invaug::SOCKET_COUNT] = { 0, 0, 0, 0, 0, 0 };
uint32 augslot[EQ::invaug::SOCKET_COUNT] = { 0, 0, 0, 0, 0, 0 };
if (inst->IsType(EQEmu::item::ItemClassCommon)) {
for (int i = EQEmu::invaug::SOCKET_BEGIN; i <= EQEmu::invaug::SOCKET_END; i++) {
EQEmu::ItemInstance *auginst=inst->GetAugment(i);
if (inst->IsType(EQ::item::ItemClassCommon)) {
for (int i = EQ::invaug::SOCKET_BEGIN; i <= EQ::invaug::SOCKET_END; i++) {
EQ::ItemInstance *auginst=inst->GetAugment(i);
augslot[i]=(auginst && auginst->GetItem()) ? auginst->GetItem()->ID : 0;
}
}
@@ -825,7 +825,7 @@ TraderCharges_Struct* ZoneDatabase::LoadTraderItemWithCharges(uint32 char_id)
return loadti;
}
EQEmu::ItemInstance* ZoneDatabase::LoadSingleTraderItem(uint32 CharID, int SerialNumber) {
EQ::ItemInstance* ZoneDatabase::LoadSingleTraderItem(uint32 CharID, int SerialNumber) {
std::string query = StringFormat("SELECT * FROM trader WHERE char_id = %i AND serialnumber = %i "
"ORDER BY slot_id LIMIT 80", CharID, SerialNumber);
auto results = QueryDatabase(query);
@@ -843,7 +843,7 @@ EQEmu::ItemInstance* ZoneDatabase::LoadSingleTraderItem(uint32 CharID, int Seria
int Charges = atoi(row[3]);
int Cost = atoi(row[4]);
const EQEmu::ItemData *item = database.GetItem(ItemID);
const EQ::ItemData *item = database.GetItem(ItemID);
if(!item) {
LogTrading("Unable to create item\n");
@@ -854,7 +854,7 @@ EQEmu::ItemInstance* ZoneDatabase::LoadSingleTraderItem(uint32 CharID, int Seria
if (item->NoDrop == 0)
return nullptr;
EQEmu::ItemInstance* inst = database.CreateItem(item);
EQ::ItemInstance* inst = database.CreateItem(item);
if(!inst) {
LogTrading("Unable to create item instance\n");
fflush(stdout);
@@ -897,7 +897,7 @@ void ZoneDatabase::UpdateTraderItemPrice(int CharID, uint32 ItemID, uint32 Charg
LogTrading("ZoneDatabase::UpdateTraderPrice([{}], [{}], [{}], [{}])", CharID, ItemID, Charges, NewPrice);
const EQEmu::ItemData *item = database.GetItem(ItemID);
const EQ::ItemData *item = database.GetItem(ItemID);
if(!item)
return;
@@ -1222,12 +1222,12 @@ bool ZoneDatabase::LoadCharacterMemmedSpells(uint32 character_id, PlayerProfile_
auto results = database.QueryDatabase(query);
int i = 0;
/* Initialize Spells */
for (i = 0; i < EQEmu::spells::SPELL_GEM_COUNT; i++){
for (i = 0; i < EQ::spells::SPELL_GEM_COUNT; i++){
pp->mem_spells[i] = 0xFFFFFFFF;
}
for (auto row = results.begin(); row != results.end(); ++row) {
i = atoi(row[0]);
if (i < EQEmu::spells::SPELL_GEM_COUNT && atoi(row[1]) <= SPDAT_RECORDS){
if (i < EQ::spells::SPELL_GEM_COUNT && atoi(row[1]) <= SPDAT_RECORDS){
pp->mem_spells[i] = atoi(row[1]);
}
}
@@ -1246,7 +1246,7 @@ bool ZoneDatabase::LoadCharacterSpellBook(uint32 character_id, PlayerProfile_Str
/* Initialize Spells */
memset(pp->spell_book, 0xFF, (sizeof(uint32) * EQEmu::spells::SPELLBOOK_SIZE));
memset(pp->spell_book, 0xFF, (sizeof(uint32) * EQ::spells::SPELLBOOK_SIZE));
// We have the ability to block loaded spells by max id on a per-client basis..
// but, we do not have to ability to keep players from using older clients after
@@ -1257,7 +1257,7 @@ bool ZoneDatabase::LoadCharacterSpellBook(uint32 character_id, PlayerProfile_Str
int idx = atoi(row[0]);
int id = atoi(row[1]);
if (idx < 0 || idx >= EQEmu::spells::SPELLBOOK_SIZE)
if (idx < 0 || idx >= EQ::spells::SPELLBOOK_SIZE)
continue;
if (id < 3 || id > SPDAT_RECORDS) // 3 ("Summon Corpse") is the first scribable spell in spells_us.txt
continue;
@@ -1405,11 +1405,11 @@ bool ZoneDatabase::LoadCharacterMaterialColor(uint32 character_id, PlayerProfile
bool ZoneDatabase::LoadCharacterBandolier(uint32 character_id, PlayerProfile_Struct* pp)
{
std::string query = StringFormat("SELECT `bandolier_id`, `bandolier_slot`, `item_id`, `icon`, `bandolier_name` FROM `character_bandolier` WHERE `id` = %u LIMIT %u",
character_id, EQEmu::profile::BANDOLIERS_SIZE);
character_id, EQ::profile::BANDOLIERS_SIZE);
auto results = database.QueryDatabase(query); int i = 0; int r = 0; int si = 0;
for (i = 0; i < EQEmu::profile::BANDOLIERS_SIZE; i++) {
for (i = 0; i < EQ::profile::BANDOLIERS_SIZE; i++) {
pp->bandoliers[i].Name[0] = '\0';
for (int si = 0; si < EQEmu::profile::BANDOLIER_ITEM_COUNT; si++) {
for (int si = 0; si < EQ::profile::BANDOLIER_ITEM_COUNT; si++) {
pp->bandoliers[i].Items[si].ID = 0;
pp->bandoliers[i].Items[si].Icon = 0;
pp->bandoliers[i].Items[si].Name[0] = '\0';
@@ -1421,7 +1421,7 @@ bool ZoneDatabase::LoadCharacterBandolier(uint32 character_id, PlayerProfile_Str
i = atoi(row[r]); /* Bandolier ID */ r++;
si = atoi(row[r]); /* Bandolier Slot */ r++;
const EQEmu::ItemData* item_data = database.GetItem(atoi(row[r]));
const EQ::ItemData* item_data = database.GetItem(atoi(row[r]));
if (item_data) {
pp->bandoliers[i].Items[si].ID = item_data->ID; r++;
pp->bandoliers[i].Items[si].Icon = atoi(row[r]); r++; // Must use db value in case an Ornamentation is assigned
@@ -1443,7 +1443,7 @@ bool ZoneDatabase::LoadCharacterTribute(uint32 character_id, PlayerProfile_Struc
std::string query = StringFormat("SELECT `tier`, `tribute` FROM `character_tribute` WHERE `id` = %u", character_id);
auto results = database.QueryDatabase(query);
int i = 0;
for (i = 0; i < EQEmu::invtype::TRIBUTE_SIZE; i++){
for (i = 0; i < EQ::invtype::TRIBUTE_SIZE; i++){
pp->tributes[i].tribute = 0xFFFFFFFF;
pp->tributes[i].tier = 0;
}
@@ -1462,10 +1462,10 @@ bool ZoneDatabase::LoadCharacterPotions(uint32 character_id, PlayerProfile_Struc
{
std::string query =
StringFormat("SELECT `potion_id`, `item_id`, `icon` FROM `character_potionbelt` WHERE `id` = %u LIMIT %u",
character_id, EQEmu::profile::POTION_BELT_SIZE);
character_id, EQ::profile::POTION_BELT_SIZE);
auto results = database.QueryDatabase(query);
int i = 0;
for (i = 0; i < EQEmu::profile::POTION_BELT_SIZE; i++) {
for (i = 0; i < EQ::profile::POTION_BELT_SIZE; i++) {
pp->potionbelt.Items[i].Icon = 0;
pp->potionbelt.Items[i].ID = 0;
pp->potionbelt.Items[i].Name[0] = '\0';
@@ -1473,7 +1473,7 @@ bool ZoneDatabase::LoadCharacterPotions(uint32 character_id, PlayerProfile_Struc
for (auto row = results.begin(); row != results.end(); ++row) {
i = atoi(row[0]);
const EQEmu::ItemData *item_data = database.GetItem(atoi(row[1]));
const EQ::ItemData *item_data = database.GetItem(atoi(row[1]));
if (!item_data)
continue;
pp->potionbelt.Items[i].ID = item_data->ID;
@@ -1562,7 +1562,7 @@ bool ZoneDatabase::SaveCharacterTribute(uint32 character_id, PlayerProfile_Struc
std::string query = StringFormat("DELETE FROM `character_tribute` WHERE `id` = %u", character_id);
QueryDatabase(query);
/* Save Tributes only if we have values... */
for (int i = 0; i < EQEmu::invtype::TRIBUTE_SIZE; i++){
for (int i = 0; i < EQ::invtype::TRIBUTE_SIZE; i++){
if (pp->tributes[i].tribute >= 0 && pp->tributes[i].tribute != TRIBUTE_NONE){
std::string query = StringFormat("REPLACE INTO `character_tribute` (id, tier, tribute) VALUES (%u, %u, %u)", character_id, pp->tributes[i].tier, pp->tributes[i].tribute);
QueryDatabase(query);
@@ -2641,7 +2641,7 @@ const NPCType *ZoneDatabase::LoadNPCTypesData(uint32 npc_type_id, bool bulk_load
else {
auto armorTint_row = armortint_results.begin();
for (int index = EQEmu::textures::textureBegin; index <= EQEmu::textures::LastTexture; index++) {
for (int index = EQ::textures::textureBegin; index <= EQ::textures::LastTexture; index++) {
temp_npctype_data->armor_tint.Slot[index].Color = atoi(armorTint_row[index * 3]) << 16;
temp_npctype_data->armor_tint.Slot[index].Color |= atoi(armorTint_row[index * 3 + 1]) << 8;
temp_npctype_data->armor_tint.Slot[index].Color |= atoi(armorTint_row[index * 3 + 2]);
@@ -2652,7 +2652,7 @@ const NPCType *ZoneDatabase::LoadNPCTypesData(uint32 npc_type_id, bool bulk_load
}
// Try loading npc_types tint fields if armor tint is 0 or query failed to get results
if (armor_tint_id == 0) {
for (int index = EQEmu::textures::armorChest; index < EQEmu::textures::materialCount; index++) {
for (int index = EQ::textures::armorChest; index < EQ::textures::materialCount; index++) {
temp_npctype_data->armor_tint.Slot[index].Color = temp_npctype_data->armor_tint.Slot[0].Color; // odd way to 'zero-out' the array...
}
}
@@ -2878,7 +2878,7 @@ const NPCType* ZoneDatabase::GetMercType(uint32 id, uint16 raceid, uint32 client
tmpNPCType->armor_tint.Slot[0].Color |= (tmpNPCType->armor_tint.Slot[0].Color) ? (0xFF << 24) : 0;
if (armor_tint_id == 0)
for (int index = EQEmu::textures::armorChest; index <= EQEmu::textures::LastTexture; index++)
for (int index = EQ::textures::armorChest; index <= EQ::textures::LastTexture; index++)
tmpNPCType->armor_tint.Slot[index].Color = tmpNPCType->armor_tint.Slot[0].Color;
else if (tmpNPCType->armor_tint.Slot[0].Color == 0) {
std::string armorTint_query = StringFormat("SELECT red1h, grn1h, blu1h, "
@@ -2898,7 +2898,7 @@ const NPCType* ZoneDatabase::GetMercType(uint32 id, uint16 raceid, uint32 client
else {
auto armorTint_row = results.begin();
for (int index = EQEmu::textures::textureBegin; index <= EQEmu::textures::LastTexture; index++) {
for (int index = EQ::textures::textureBegin; index <= EQ::textures::LastTexture; index++) {
tmpNPCType->armor_tint.Slot[index].Color = atoi(armorTint_row[index * 3]) << 16;
tmpNPCType->armor_tint.Slot[index].Color |= atoi(armorTint_row[index * 3 + 1]) << 8;
tmpNPCType->armor_tint.Slot[index].Color |= atoi(armorTint_row[index * 3 + 2]);
@@ -3257,7 +3257,7 @@ void ZoneDatabase::LoadMercEquipment(Merc *merc) {
int itemCount = 0;
for(auto row = results.begin(); row != results.end(); ++row) {
if (itemCount == EQEmu::invslot::EQUIPMENT_COUNT)
if (itemCount == EQ::invslot::EQUIPMENT_COUNT)
break;
if(atoi(row[0]) == 0)
@@ -3396,7 +3396,7 @@ void ZoneDatabase::RefreshGroupFromDB(Client *client){
client->QueuePacket(outapp);
safe_delete(outapp);
if (client->ClientVersion() >= EQEmu::versions::ClientVersion::SoD) {
if (client->ClientVersion() >= EQ::versions::ClientVersion::SoD) {
group->NotifyMainTank(client, 1);
group->NotifyPuller(client, 1);
}
@@ -3698,7 +3698,7 @@ void ZoneDatabase::LoadBuffs(Client *client)
}
// We load up to the most our client supports
max_slots = EQEmu::spells::StaticLookup(client->ClientVersion())->LongBuffs;
max_slots = EQ::spells::StaticLookup(client->ClientVersion())->LongBuffs;
for (int index = 0; index < max_slots; ++index) {
if (!IsValidSpell(buffs[index].spellid))
continue;
@@ -3807,7 +3807,7 @@ void ZoneDatabase::SavePetInfo(Client *client)
query.clear();
// pet inventory!
for (int index = EQEmu::invslot::EQUIPMENT_BEGIN; index <= EQEmu::invslot::EQUIPMENT_END; index++) {
for (int index = EQ::invslot::EQUIPMENT_BEGIN; index <= EQ::invslot::EQUIPMENT_END; index++) {
if (!petinfo->Items[index])
continue;
@@ -3939,7 +3939,7 @@ void ZoneDatabase::LoadPetInfo(Client *client)
continue;
int slot = atoi(row[1]);
if (slot < EQEmu::invslot::EQUIPMENT_BEGIN || slot > EQEmu::invslot::EQUIPMENT_END)
if (slot < EQ::invslot::EQUIPMENT_BEGIN || slot > EQ::invslot::EQUIPMENT_END)
continue;
pi->Items[slot] = atoul(row[2]);
zone/zonedb.h
+9 -9
View File
@@ -31,7 +31,7 @@ struct PlayerCorpse_Struct;
struct ZonePoint;
struct npcDecayTimes_Struct;
namespace EQEmu
namespace EQ
{
class ItemInstance;
}
@@ -106,7 +106,7 @@ struct DBnpcspellseffects_Struct {
};
struct DBTradeskillRecipe_Struct {
EQEmu::skills::SkillType tradeskill;
EQ::skills::SkillType tradeskill;
int16 skill_needed;
uint16 trivial;
bool nofail;
@@ -153,7 +153,7 @@ struct PetInfo {
uint32 Mana;
float size;
SpellBuff_Struct Buffs[PET_BUFF_COUNT];
uint32 Items[EQEmu::invslot::EQUIPMENT_COUNT];
uint32 Items[EQ::invslot::EQUIPMENT_COUNT];
char Name[64];
};
@@ -251,11 +251,11 @@ public:
virtual ~ZoneDatabase();
/* Objects and World Containers */
void LoadWorldContainer(uint32 parentid, EQEmu::ItemInstance* container);
void SaveWorldContainer(uint32 zone_id, uint32 parent_id, const EQEmu::ItemInstance* container);
void LoadWorldContainer(uint32 parentid, EQ::ItemInstance* container);
void SaveWorldContainer(uint32 zone_id, uint32 parent_id, const EQ::ItemInstance* container);
void DeleteWorldContainer(uint32 parent_id,uint32 zone_id);
uint32 AddObject(uint32 type, uint32 icon, const Object_Struct& object, const EQEmu::ItemInstance* inst);
void UpdateObject(uint32 id, uint32 type, uint32 icon, const Object_Struct& object, const EQEmu::ItemInstance* inst);
uint32 AddObject(uint32 type, uint32 icon, const Object_Struct& object, const EQ::ItemInstance* inst);
void UpdateObject(uint32 id, uint32 type, uint32 icon, const Object_Struct& object, const EQ::ItemInstance* inst);
void DeleteObject(uint32 id);
Ground_Spawns* LoadGroundSpawns(uint32 zone_id, int16 version, Ground_Spawns* gs);
@@ -266,7 +266,7 @@ public:
void DeleteTraderItem(uint32 char_id);
void DeleteTraderItem(uint32 char_id,uint16 slot_id);
EQEmu::ItemInstance* LoadSingleTraderItem(uint32 char_id, int uniqueid);
EQ::ItemInstance* LoadSingleTraderItem(uint32 char_id, int uniqueid);
Trader_Struct* LoadTraderItem(uint32 char_id);
TraderCharges_Struct* LoadTraderItemWithCharges(uint32 char_id);
@@ -488,7 +488,7 @@ public:
void DeleteMerchantTemp(uint32 npcid, uint32 slot);
/* Tradeskills */
bool GetTradeRecipe(const EQEmu::ItemInstance* container, uint8 c_type, uint32 some_id, uint32 char_id, DBTradeskillRecipe_Struct *spec);
bool GetTradeRecipe(const EQ::ItemInstance* container, uint8 c_type, uint32 some_id, uint32 char_id, DBTradeskillRecipe_Struct *spec);
bool GetTradeRecipe(uint32 recipe_id, uint8 c_type, uint32 some_id, uint32 char_id, DBTradeskillRecipe_Struct *spec);
uint32 GetZoneForage(uint32 ZoneID, uint8 skill); /* for foraging */
uint32 GetZoneFishing(uint32 ZoneID, uint8 skill, uint32 &npc_id, uint8 &npc_chance);
zone/zonedump.h
+2 -2
View File
@@ -86,7 +86,7 @@ struct NPCType
uint32 drakkin_heritage;
uint32 drakkin_tattoo;
uint32 drakkin_details;
EQEmu::TintProfile armor_tint;
EQ::TintProfile armor_tint;
uint32 min_dmg;
uint32 max_dmg;
uint32 charm_ac;
@@ -185,7 +185,7 @@ struct PlayerCorpse_Struct {
uint32 silver;
uint32 gold;
uint32 plat;
EQEmu::TintProfile item_tint;
EQ::TintProfile item_tint;
uint8 haircolor;
uint8 beardcolor;
uint8 eyecolor1;
zone/zoning.cpp
+2 -2
View File
@@ -561,7 +561,7 @@ void Client::ZonePC(uint32 zoneID, uint32 instance_id, float x, float y, float z
if (entity == 0)
{
Message(Chat::Red, "Error: OP_EndLootRequest: Corpse not found (ent = 0)");
if (ClientVersion() >= EQEmu::versions::ClientVersion::SoD)
if (ClientVersion() >= EQ::versions::ClientVersion::SoD)
Corpse::SendEndLootErrorPacket(this);
else
Corpse::SendLootReqErrorPacket(this);
@@ -588,7 +588,7 @@ void Client::ZonePC(uint32 zoneID, uint32 instance_id, float x, float y, float z
// If we are SoF and later and are respawning from hover, we want the real zone ID, else zero to use the old hack.
//
if(zone->GetZoneID() == zoneID) {
if ((ClientVersionBit() & EQEmu::versions::maskSoFAndLater) && (!RuleB(Character, RespawnFromHover) || !IsHoveringForRespawn()))
if ((ClientVersionBit() & EQ::versions::maskSoFAndLater) && (!RuleB(Character, RespawnFromHover) || !IsHoveringForRespawn()))
gmg->bind_zone_id = 0;
else
gmg->bind_zone_id = zoneID;