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

Merge fix

Browse Source
This commit is contained in:
KimLS
2016-11-19 15:54:31 -08:00
parent c77e65c07d bbd2796ea4
commit 0db70218e9
144 changed files with 8239 additions and 6580 deletions
Download Patch File Download Diff File Expand all files Collapse all files
zone/aa.cpp
+6 -1
View File
@@ -423,7 +423,7 @@ void Mob::WakeTheDead(uint16 spell_id, Mob *target, uint32 duration)
uint32 sitem = 0;
sitem = CorpseToUse->GetWornItem(x);
if(sitem){
const EQEmu::ItemBase * itm = database.GetItem(sitem);
const EQEmu::ItemData * itm = database.GetItem(sitem);
npca->AddLootDrop(itm, &npca->itemlist, 1, 1, 255, true, true);
}
}
@@ -1181,6 +1181,11 @@ void Client::ActivateAlternateAdvancementAbility(int rank_id, int target_id) {
if (!IsCastWhileInvis(rank->spell))
CommonBreakInvisible();
if (spells[rank->spell].sneak && (!hidden || (hidden && (Timer::GetCurrentTime() - tmHidden) < 4000))) {
Message_StringID(MT_SpellFailure, SNEAK_RESTRICT);
return;
}
// 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::CastingSlot::AltAbility, spells[rank->spell].mana, -1, spells[rank->spell].ResistDiff, false)) {
zone/aggro.cpp
+2 -2
View File
@@ -1343,8 +1343,8 @@ bool Mob::PassCharismaCheck(Mob* caster, uint16 spell_id) {
void Mob::RogueEvade(Mob *other)
{
int amount = other->GetHateAmount(this) - (GetLevel() * 13);
other->SetHateAmountOnEnt(this, std::max(1, amount));
int amount = other->GetHateAmount(this) * zone->random.Int(40, 70) / 100;
other->SetHateAmountOnEnt(this, std::max(100, amount));
return;
}
zone/attack.cpp
+76 -76
View File
@@ -51,12 +51,12 @@ extern WorldServer worldserver;
extern EntityList entity_list;
extern Zone* zone;
bool Mob::AttackAnimation(EQEmu::skills::SkillType &skillinuse, int Hand, const ItemInst* weapon)
bool Mob::AttackAnimation(EQEmu::skills::SkillType &skillinuse, int Hand, const EQEmu::ItemInstance* weapon)
{
// Determine animation
int type = 0;
if (weapon && weapon->IsClassCommon()) {
const EQEmu::ItemBase* item = weapon->GetItem();
const EQEmu::ItemData* item = weapon->GetItem();
Log.Out(Logs::Detail, Logs::Attack, "Weapon skill : %i", item->ItemType);
@@ -132,7 +132,7 @@ bool Mob::AttackAnimation(EQEmu::skills::SkillType &skillinuse, int Hand, const
}
// If we're attacking with the secondary hand, play the dual wield anim
if (Hand == EQEmu::legacy::SlotSecondary) // DW anim
if (Hand == EQEmu::inventory::slotSecondary) // DW anim
type = animDualWield;
DoAnim(type);
@@ -373,7 +373,7 @@ bool Mob::AvoidDamage(Mob *other, int32 &damage, int hand)
// riposte -- it may seem crazy, but if the attacker has SPA 173 on them, they are immune to Ripo
bool ImmuneRipo = attacker->aabonuses.RiposteChance || attacker->spellbonuses.RiposteChance || attacker->itembonuses.RiposteChance;
// Need to check if we have something in MainHand to actually attack with (or fists)
if (hand != EQEmu::legacy::SlotRange && (CanThisClassRiposte() || IsEnraged()) && InFront && !ImmuneRipo) {
if (hand != EQEmu::inventory::slotRange && (CanThisClassRiposte() || IsEnraged()) && InFront && !ImmuneRipo) {
if (IsEnraged()) {
damage = -3;
Log.Out(Logs::Detail, Logs::Combat, "I am enraged, riposting frontal attack.");
@@ -395,7 +395,7 @@ bool Mob::AvoidDamage(Mob *other, int32 &damage, int hand)
chance -= chance * counter;
}
// AA Slippery Attacks
if (hand == EQEmu::legacy::SlotSecondary) {
if (hand == EQEmu::inventory::slotSecondary) {
int slip = aabonuses.OffhandRiposteFail + itembonuses.OffhandRiposteFail + spellbonuses.OffhandRiposteFail;
chance += chance * slip / 100;
}
@@ -440,7 +440,7 @@ bool Mob::AvoidDamage(Mob *other, int32 &damage, int hand)
}
// parry
if (CanThisClassParry() && InFront && hand != EQEmu::legacy::SlotRange) {
if (CanThisClassParry() && InFront && hand != EQEmu::inventory::slotRange) {
if (IsClient())
CastToClient()->CheckIncreaseSkill(EQEmu::skills::SkillParry, other, -10);
// check auto discs ... I guess aa/items too :P
@@ -786,9 +786,9 @@ int32 Client::GetMeleeMitDmg(Mob *attacker, int32 damage, int32 minhit,
//Returns the weapon damage against the input mob
//if we cannot hit the mob with the current weapon we will get a value less than or equal to zero
//Else we know we can hit.
//GetWeaponDamage(mob*, const ItemBase*) is intended to be used for mobs or any other situation where we do not have a client inventory item
//GetWeaponDamage(mob*, const ItemInst*) is intended to be used for situations where we have a client inventory item
int Mob::GetWeaponDamage(Mob *against, const EQEmu::ItemBase *weapon_item) {
//GetWeaponDamage(mob*, const EQEmu::ItemData*) is intended to be used for mobs or any other situation where we do not have a client inventory item
//GetWeaponDamage(mob*, const EQEmu::ItemInstance*) is intended to be used for situations where we have a client inventory item
int Mob::GetWeaponDamage(Mob *against, const EQEmu::ItemData *weapon_item) {
int dmg = 0;
int banedmg = 0;
@@ -858,7 +858,7 @@ int Mob::GetWeaponDamage(Mob *against, const EQEmu::ItemBase *weapon_item) {
}
}
if(!eledmg && !banedmg){
if(!banedmg){
if(!GetSpecialAbility(SPECATK_BANE))
return 0;
else
@@ -888,7 +888,7 @@ int Mob::GetWeaponDamage(Mob *against, const EQEmu::ItemBase *weapon_item) {
return dmg;
}
int Mob::GetWeaponDamage(Mob *against, const ItemInst *weapon_item, uint32 *hate)
int Mob::GetWeaponDamage(Mob *against, const EQEmu::ItemInstance *weapon_item, uint32 *hate)
{
int dmg = 0;
int banedmg = 0;
@@ -927,7 +927,7 @@ int Mob::GetWeaponDamage(Mob *against, const ItemInst *weapon_item, uint32 *hate
} else {
bool MagicGloves = false;
if (IsClient()) {
const ItemInst *gloves = CastToClient()->GetInv().GetItem(EQEmu::legacy::SlotHands);
const EQEmu::ItemInstance *gloves = CastToClient()->GetInv().GetItem(EQEmu::inventory::slotHands);
if (gloves)
MagicGloves = gloves->GetItemMagical(true);
}
@@ -979,7 +979,7 @@ int Mob::GetWeaponDamage(Mob *against, const ItemInst *weapon_item, uint32 *hate
banedmg = against->CheckBaneDamage(weapon_item);
if (against->GetSpecialAbility(IMMUNE_MELEE_EXCEPT_BANE)) {
if (!eledmg && !banedmg) {
if (!banedmg) {
if (!GetSpecialAbility(SPECATK_BANE))
return 0;
else
@@ -1035,13 +1035,13 @@ bool Client::Attack(Mob* other, int Hand, bool bRiposte, bool IsStrikethrough, b
if (GetFeigned())
return false; // Rogean: How can you attack while feigned? Moved up from Aggro Code.
ItemInst* weapon;
if (Hand == EQEmu::legacy::SlotSecondary){ // Kaiyodo - Pick weapon from the attacking hand
weapon = GetInv().GetItem(EQEmu::legacy::SlotSecondary);
EQEmu::ItemInstance* weapon;
if (Hand == EQEmu::inventory::slotSecondary){ // Kaiyodo - Pick weapon from the attacking hand
weapon = GetInv().GetItem(EQEmu::inventory::slotSecondary);
OffHandAtk(true);
}
else{
weapon = GetInv().GetItem(EQEmu::legacy::SlotPrimary);
weapon = GetInv().GetItem(EQEmu::inventory::slotPrimary);
OffHandAtk(false);
}
@@ -1109,12 +1109,12 @@ bool Client::Attack(Mob* other, int Hand, bool bRiposte, bool IsStrikethrough, b
int ucDamageBonus = 0;
if (Hand == EQEmu::legacy::SlotPrimary && GetLevel() >= 28 && IsWarriorClass())
if (Hand == EQEmu::inventory::slotPrimary && GetLevel() >= 28 && IsWarriorClass())
{
// Damage bonuses apply only to hits from the main hand (Hand == MainPrimary) by characters level 28 and above
// who belong to a melee class. If we're here, then all of these conditions apply.
ucDamageBonus = GetWeaponDamageBonus(weapon ? weapon->GetItem() : (const EQEmu::ItemBase*) nullptr);
ucDamageBonus = GetWeaponDamageBonus(weapon ? weapon->GetItem() : (const EQEmu::ItemData*) nullptr);
min_hit += (int) ucDamageBonus;
max_hit += (int) ucDamageBonus;
@@ -1122,10 +1122,10 @@ bool Client::Attack(Mob* other, int Hand, bool bRiposte, bool IsStrikethrough, b
}
#endif
//Live AA - Sinister Strikes *Adds weapon damage bonus to offhand weapon.
if (Hand == EQEmu::legacy::SlotSecondary) {
if (Hand == EQEmu::inventory::slotSecondary) {
if (aabonuses.SecondaryDmgInc || itembonuses.SecondaryDmgInc || spellbonuses.SecondaryDmgInc){
ucDamageBonus = GetWeaponDamageBonus(weapon ? weapon->GetItem() : (const EQEmu::ItemBase*) nullptr, true);
ucDamageBonus = GetWeaponDamageBonus(weapon ? weapon->GetItem() : (const EQEmu::ItemData*) nullptr, true);
min_hit += (int) ucDamageBonus;
max_hit += (int) ucDamageBonus;
@@ -1583,28 +1583,28 @@ bool NPC::Attack(Mob* other, int Hand, bool bRiposte, bool IsStrikethrough, bool
FaceTarget(GetTarget());
EQEmu::skills::SkillType skillinuse = EQEmu::skills::SkillHandtoHand;
if (Hand == EQEmu::legacy::SlotPrimary) {
if (Hand == EQEmu::inventory::slotPrimary) {
skillinuse = static_cast<EQEmu::skills::SkillType>(GetPrimSkill());
OffHandAtk(false);
}
if (Hand == EQEmu::legacy::SlotSecondary) {
if (Hand == EQEmu::inventory::slotSecondary) {
skillinuse = static_cast<EQEmu::skills::SkillType>(GetSecSkill());
OffHandAtk(true);
}
//figure out what weapon they are using, if any
const EQEmu::ItemBase* weapon = nullptr;
if (Hand == EQEmu::legacy::SlotPrimary && equipment[EQEmu::legacy::SlotPrimary] > 0)
weapon = database.GetItem(equipment[EQEmu::legacy::SlotPrimary]);
else if (equipment[EQEmu::legacy::SlotSecondary])
weapon = database.GetItem(equipment[EQEmu::legacy::SlotSecondary]);
const EQEmu::ItemData* weapon = nullptr;
if (Hand == EQEmu::inventory::slotPrimary && equipment[EQEmu::inventory::slotPrimary] > 0)
weapon = database.GetItem(equipment[EQEmu::inventory::slotPrimary]);
else if (equipment[EQEmu::inventory::slotSecondary])
weapon = database.GetItem(equipment[EQEmu::inventory::slotSecondary]);
//We dont factor much from the weapon into the attack.
//Just the skill type so it doesn't look silly using punching animations and stuff while wielding weapons
if(weapon) {
Log.Out(Logs::Detail, Logs::Combat, "Attacking with weapon: %s (%d) (too bad im not using it for much)", weapon->Name, weapon->ID);
if (Hand == EQEmu::legacy::SlotSecondary && weapon->ItemType == EQEmu::item::ItemTypeShield){
if (Hand == EQEmu::inventory::slotSecondary && weapon->ItemType == EQEmu::item::ItemTypeShield){
Log.Out(Logs::Detail, Logs::Combat, "Attack with shield canceled.");
return false;
}
@@ -1645,7 +1645,7 @@ bool NPC::Attack(Mob* other, int Hand, bool bRiposte, bool IsStrikethrough, bool
//do attack animation regardless of whether or not we can hit below
int16 charges = 0;
ItemInst weapon_inst(weapon, charges);
EQEmu::ItemInstance weapon_inst(weapon, charges);
AttackAnimation(skillinuse, Hand, &weapon_inst);
//basically "if not immune" then do the attack
@@ -2515,7 +2515,7 @@ void Mob::DamageShield(Mob* attacker, bool spell_ds) {
}
}
uint8 Mob::GetWeaponDamageBonus(const EQEmu::ItemBase *weapon, bool offhand)
uint8 Mob::GetWeaponDamageBonus(const EQEmu::ItemData *weapon, bool offhand)
{
// dev quote with old and new formulas
// https://forums.daybreakgames.com/eq/index.php?threads/test-update-09-17-15.226618/page-5#post-3326194
@@ -3497,7 +3497,7 @@ void Mob::TryDefensiveProc(Mob *on, uint16 hand) {
float ProcChance, ProcBonus;
on->GetDefensiveProcChances(ProcBonus, ProcChance, hand , this);
if (hand != EQEmu::legacy::SlotPrimary)
if (hand != EQEmu::inventory::slotPrimary)
ProcChance /= 2;
int level_penalty = 0;
@@ -3522,7 +3522,7 @@ void Mob::TryDefensiveProc(Mob *on, uint16 hand) {
}
}
void Mob::TryWeaponProc(const ItemInst* weapon_g, Mob *on, uint16 hand) {
void Mob::TryWeaponProc(const EQEmu::ItemInstance* weapon_g, Mob *on, uint16 hand) {
if(!on) {
SetTarget(nullptr);
Log.Out(Logs::General, Logs::Error, "A null Mob object was passed to Mob::TryWeaponProc for evaluation!");
@@ -3540,12 +3540,12 @@ void Mob::TryWeaponProc(const ItemInst* weapon_g, Mob *on, uint16 hand) {
}
if(!weapon_g) {
TrySpellProc(nullptr, (const EQEmu::ItemBase*)nullptr, on);
TrySpellProc(nullptr, (const EQEmu::ItemData*)nullptr, on);
return;
}
if (!weapon_g->IsClassCommon()) {
TrySpellProc(nullptr, (const EQEmu::ItemBase*)nullptr, on);
TrySpellProc(nullptr, (const EQEmu::ItemData*)nullptr, on);
return;
}
@@ -3558,7 +3558,7 @@ void Mob::TryWeaponProc(const ItemInst* weapon_g, Mob *on, uint16 hand) {
return;
}
void Mob::TryWeaponProc(const ItemInst *inst, const EQEmu::ItemBase *weapon, Mob *on, uint16 hand)
void Mob::TryWeaponProc(const EQEmu::ItemInstance *inst, const EQEmu::ItemData *weapon, Mob *on, uint16 hand)
{
if (!weapon)
@@ -3570,7 +3570,7 @@ void Mob::TryWeaponProc(const ItemInst *inst, const EQEmu::ItemBase *weapon, Mob
ProcBonus += static_cast<float>(itembonuses.ProcChance) / 10.0f; // Combat Effects
float ProcChance = GetProcChances(ProcBonus, hand);
if (hand != EQEmu::legacy::SlotPrimary) //Is Archery intened to proc at 50% rate?
if (hand != EQEmu::inventory::slotPrimary) //Is Archery intened to proc at 50% rate?
ProcChance /= 2;
// Try innate proc on weapon
@@ -3607,11 +3607,11 @@ void Mob::TryWeaponProc(const ItemInst *inst, const EQEmu::ItemBase *weapon, Mob
proced = false;
if (!proced && inst) {
for (int r = 0; r < EQEmu::legacy::ITEM_COMMON_SIZE; r++) {
const ItemInst *aug_i = inst->GetAugment(r);
for (int r = EQEmu::inventory::socketBegin; r < EQEmu::inventory::SocketCount; r++) {
const EQEmu::ItemInstance *aug_i = inst->GetAugment(r);
if (!aug_i) // no aug, try next slot!
continue;
const EQEmu::ItemBase *aug = aug_i->GetItem();
const EQEmu::ItemData *aug = aug_i->GetItem();
if (!aug)
continue;
@@ -3641,18 +3641,18 @@ void Mob::TryWeaponProc(const ItemInst *inst, const EQEmu::ItemBase *weapon, Mob
return;
}
void Mob::TrySpellProc(const ItemInst *inst, const EQEmu::ItemBase *weapon, Mob *on, uint16 hand)
void Mob::TrySpellProc(const EQEmu::ItemInstance *inst, const EQEmu::ItemData *weapon, Mob *on, uint16 hand)
{
float ProcBonus = static_cast<float>(spellbonuses.SpellProcChance +
itembonuses.SpellProcChance + aabonuses.SpellProcChance);
float ProcChance = 0.0f;
ProcChance = GetProcChances(ProcBonus, hand);
if (hand != EQEmu::legacy::SlotPrimary) //Is Archery intened to proc at 50% rate?
if (hand != EQEmu::inventory::slotPrimary) //Is Archery intened to proc at 50% rate?
ProcChance /= 2;
bool rangedattk = false;
if (weapon && hand == EQEmu::legacy::SlotRange) {
if (weapon && hand == EQEmu::inventory::slotRange) {
if (weapon->ItemType == EQEmu::item::ItemTypeArrow ||
weapon->ItemType == EQEmu::item::ItemTypeLargeThrowing ||
weapon->ItemType == EQEmu::item::ItemTypeSmallThrowing ||
@@ -3661,11 +3661,11 @@ void Mob::TrySpellProc(const ItemInst *inst, const EQEmu::ItemBase *weapon, Mob
}
}
if (!weapon && hand == EQEmu::legacy::SlotRange && GetSpecialAbility(SPECATK_RANGED_ATK))
if (!weapon && hand == EQEmu::inventory::slotRange && GetSpecialAbility(SPECATK_RANGED_ATK))
rangedattk = true;
for (uint32 i = 0; i < MAX_PROCS; i++) {
if (IsPet() && hand != EQEmu::legacy::SlotPrimary) //Pets can only proc spell procs from their primay hand (ie; beastlord pets)
if (IsPet() && hand != EQEmu::inventory::slotPrimary) //Pets can only proc spell procs from their primay hand (ie; beastlord pets)
continue; // If pets ever can proc from off hand, this will need to change
// Not ranged
@@ -3728,7 +3728,7 @@ void Mob::TrySpellProc(const ItemInst *inst, const EQEmu::ItemBase *weapon, Mob
}
}
if (HasSkillProcs() && hand != EQEmu::legacy::SlotRange){ //We check ranged skill procs within the attack functions.
if (HasSkillProcs() && hand != EQEmu::inventory::slotRange){ //We check ranged skill procs within the attack functions.
uint16 skillinuse = 28;
if (weapon)
skillinuse = GetSkillByItemType(weapon->ItemType);
@@ -3976,7 +3976,7 @@ void Mob::DoRiposte(Mob *defender)
if (!defender)
return;
defender->Attack(this, EQEmu::legacy::SlotPrimary, true);
defender->Attack(this, EQEmu::inventory::slotPrimary, true);
if (HasDied())
return;
@@ -3987,7 +3987,7 @@ void Mob::DoRiposte(Mob *defender)
if (DoubleRipChance && zone->random.Roll(DoubleRipChance)) {
Log.Out(Logs::Detail, Logs::Combat,
"Preforming a double riposted from SE_DoubleRiposte (%d percent chance)", DoubleRipChance);
defender->Attack(this, EQEmu::legacy::SlotPrimary, true);
defender->Attack(this, EQEmu::inventory::slotPrimary, true);
if (HasDied())
return;
}
@@ -4000,7 +4000,7 @@ void Mob::DoRiposte(Mob *defender)
Log.Out(Logs::Detail, Logs::Combat,
"Preforming a double riposted from SE_GiveDoubleRiposte base1 == 0 (%d percent chance)",
DoubleRipChance);
defender->Attack(this, EQEmu::legacy::SlotPrimary, true);
defender->Attack(this, EQEmu::inventory::slotPrimary, true);
if (HasDied())
return;
}
@@ -4284,7 +4284,7 @@ float Mob::GetSkillProcChances(uint16 ReuseTime, uint16 hand) {
if (!ReuseTime && hand) {
weapon_speed = GetWeaponSpeedbyHand(hand);
ProcChance = static_cast<float>(weapon_speed) * (RuleR(Combat, AvgProcsPerMinute) / 60000.0f);
if (hand != EQEmu::legacy::SlotPrimary)
if (hand != EQEmu::inventory::slotPrimary)
ProcChance /= 2;
}
@@ -4474,26 +4474,26 @@ void Client::SetAttackTimer()
Timer *TimerToUse = nullptr;
for (int i = EQEmu::legacy::SlotRange; i <= EQEmu::legacy::SlotSecondary; i++) {
for (int i = EQEmu::inventory::slotRange; i <= EQEmu::inventory::slotSecondary; i++) {
//pick a timer
if (i == EQEmu::legacy::SlotPrimary)
if (i == EQEmu::inventory::slotPrimary)
TimerToUse = &attack_timer;
else if (i == EQEmu::legacy::SlotRange)
else if (i == EQEmu::inventory::slotRange)
TimerToUse = &ranged_timer;
else if (i == EQEmu::legacy::SlotSecondary)
else if (i == EQEmu::inventory::slotSecondary)
TimerToUse = &attack_dw_timer;
else //invalid slot (hands will always hit this)
continue;
const EQEmu::ItemBase *ItemToUse = nullptr;
const EQEmu::ItemData *ItemToUse = nullptr;
//find our item
ItemInst *ci = GetInv().GetItem(i);
EQEmu::ItemInstance *ci = GetInv().GetItem(i);
if (ci)
ItemToUse = ci->GetItem();
//special offhand stuff
if (i == EQEmu::legacy::SlotSecondary) {
if (i == EQEmu::inventory::slotSecondary) {
//if we cant dual wield, skip it
if (!CanThisClassDualWield() || HasTwoHanderEquipped()) {
attack_dw_timer.Disable();
@@ -4567,19 +4567,19 @@ void NPC::SetAttackTimer()
else
speed = static_cast<int>(((attack_delay / haste_mod) + ((hhe / 100.0f) * attack_delay)) * 100);
for (int i = EQEmu::legacy::SlotRange; i <= EQEmu::legacy::SlotSecondary; i++) {
for (int i = EQEmu::inventory::slotRange; i <= EQEmu::inventory::slotSecondary; i++) {
//pick a timer
if (i == EQEmu::legacy::SlotPrimary)
if (i == EQEmu::inventory::slotPrimary)
TimerToUse = &attack_timer;
else if (i == EQEmu::legacy::SlotRange)
else if (i == EQEmu::inventory::slotRange)
TimerToUse = &ranged_timer;
else if (i == EQEmu::legacy::SlotSecondary)
else if (i == EQEmu::inventory::slotSecondary)
TimerToUse = &attack_dw_timer;
else //invalid slot (hands will always hit this)
continue;
//special offhand stuff
if (i == EQEmu::legacy::SlotSecondary) {
if (i == EQEmu::inventory::slotSecondary) {
// SPECATK_QUAD is uncheesable
if(!CanThisClassDualWield() || (HasTwoHanderEquipped() && !GetSpecialAbility(SPECATK_QUAD))) {
attack_dw_timer.Disable();
@@ -4601,7 +4601,7 @@ void Client::DoAttackRounds(Mob *target, int hand, bool IsFromSpell)
bool candouble = CanThisClassDoubleAttack();
// extra off hand non-sense, can only double with skill of 150 or above
// or you have any amount of GiveDoubleAttack
if (candouble && hand == EQEmu::legacy::SlotSecondary)
if (candouble && hand == EQEmu::inventory::slotSecondary)
candouble = GetSkill(EQEmu::skills::SkillDoubleAttack) > 149 || (aabonuses.GiveDoubleAttack + spellbonuses.GiveDoubleAttack + itembonuses.GiveDoubleAttack) > 0;
if (candouble) {
@@ -4609,7 +4609,7 @@ void Client::DoAttackRounds(Mob *target, int hand, bool IsFromSpell)
if (CheckDoubleAttack()) {
Attack(target, hand, false, false, IsFromSpell);
// you can only triple from the main hand
if (hand == EQEmu::legacy::SlotPrimary && CanThisClassTripleAttack()) {
if (hand == EQEmu::inventory::slotPrimary && CanThisClassTripleAttack()) {
CheckIncreaseSkill(EQEmu::skills::SkillTripleAttack, target, -10);
if (CheckTripleAttack())
Attack(target, hand, false, false, IsFromSpell);
@@ -4617,7 +4617,7 @@ void Client::DoAttackRounds(Mob *target, int hand, bool IsFromSpell)
}
}
if (hand == EQEmu::legacy::SlotPrimary) {
if (hand == EQEmu::inventory::slotPrimary) {
// According to http://www.monkly-business.net/forums/showpost.php?p=312095&postcount=168 a dev told them flurry isn't dependant on triple attack
// the parses kind of back that up and all of my parses seemed to be 4 or 5 attacks in the round which would work out to be
// doubles or triples with 2 from flurries or triple with 1 or 2 flurries ... Going with the "dev quote" I guess like we've always had it
@@ -4670,9 +4670,9 @@ void Mob::DoMainHandAttackRounds(Mob *target, ExtraAttackOptions *opts, int spec
if (RuleB(Combat, UseLiveCombatRounds)) {
// A "quad" on live really is just a successful dual wield where both double attack
// The mobs that could triple lost the ability to when the triple attack skill was added in
Attack(target, EQEmu::legacy::SlotPrimary, false, false, false, opts, special);
Attack(target, EQEmu::inventory::slotPrimary, false, false, false, opts, special);
if (CanThisClassDoubleAttack() && CheckDoubleAttack()){
Attack(target, EQEmu::legacy::SlotPrimary, false, false, false, opts, special);
Attack(target, EQEmu::inventory::slotPrimary, false, false, false, opts, special);
if ((IsPet() || IsTempPet()) && IsPetOwnerClient()){
int chance = spellbonuses.PC_Pet_Flurry + itembonuses.PC_Pet_Flurry + aabonuses.PC_Pet_Flurry;
@@ -4686,14 +4686,14 @@ void Mob::DoMainHandAttackRounds(Mob *target, ExtraAttackOptions *opts, int spec
if (IsNPC()) {
int16 n_atk = CastToNPC()->GetNumberOfAttacks();
if (n_atk <= 1) {
Attack(target, EQEmu::legacy::SlotPrimary, false, false, false, opts, special);
Attack(target, EQEmu::inventory::slotPrimary, false, false, false, opts, special);
} else {
for (int i = 0; i < n_atk; ++i) {
Attack(target, EQEmu::legacy::SlotPrimary, false, false, false, opts, special);
Attack(target, EQEmu::inventory::slotPrimary, false, false, false, opts, special);
}
}
} else {
Attack(target, EQEmu::legacy::SlotPrimary, false, false, false, opts, special);
Attack(target, EQEmu::inventory::slotPrimary, false, false, false, opts, special);
}
// we use this random value in three comparisons with different
@@ -4704,15 +4704,15 @@ void Mob::DoMainHandAttackRounds(Mob *target, ExtraAttackOptions *opts, int spec
// check double attack, this is NOT the same rules that clients use...
&&
RandRoll < (GetLevel() + NPCDualAttackModifier)) {
Attack(target, EQEmu::legacy::SlotPrimary, false, false, false, opts, special);
Attack(target, EQEmu::inventory::slotPrimary, false, false, false, opts, special);
// lets see if we can do a triple attack with the main hand
// pets are excluded from triple and quads...
if ((GetSpecialAbility(SPECATK_TRIPLE) || GetSpecialAbility(SPECATK_QUAD)) && !IsPet() &&
RandRoll < (GetLevel() + NPCTripleAttackModifier)) {
Attack(target, EQEmu::legacy::SlotPrimary, false, false, false, opts, special);
Attack(target, EQEmu::inventory::slotPrimary, false, false, false, opts, special);
// now lets check the quad attack
if (GetSpecialAbility(SPECATK_QUAD) && RandRoll < (GetLevel() + NPCQuadAttackModifier)) {
Attack(target, EQEmu::legacy::SlotPrimary, false, false, false, opts, special);
Attack(target, EQEmu::inventory::slotPrimary, false, false, false, opts, special);
}
}
}
@@ -4726,11 +4726,11 @@ void Mob::DoOffHandAttackRounds(Mob *target, ExtraAttackOptions *opts, int speci
// For now, SPECATK_QUAD means innate DW when Combat:UseLiveCombatRounds is true
if ((GetSpecialAbility(SPECATK_INNATE_DW) ||
(RuleB(Combat, UseLiveCombatRounds) && GetSpecialAbility(SPECATK_QUAD))) ||
GetEquipment(EQEmu::textures::TextureSecondary) != 0) {
GetEquipment(EQEmu::textures::weaponSecondary) != 0) {
if (CheckDualWield()) {
Attack(target, EQEmu::legacy::SlotSecondary, false, false, false, opts, special);
Attack(target, EQEmu::inventory::slotSecondary, false, false, false, opts, special);
if (CanThisClassDoubleAttack() && GetLevel() > 35 && CheckDoubleAttack()){
Attack(target, EQEmu::legacy::SlotSecondary, false, false, false, opts, special);
Attack(target, EQEmu::inventory::slotSecondary, false, false, false, opts, special);
if ((IsPet() || IsTempPet()) && IsPetOwnerClient()){
int chance = spellbonuses.PC_Pet_Flurry + itembonuses.PC_Pet_Flurry + aabonuses.PC_Pet_Flurry;
zone/beacon.h
+1 -1
View File
@@ -36,7 +36,7 @@ public:
//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, int special = 0) { return; }
virtual bool Attack(Mob* other, int Hand = EQEmu::legacy::SlotPrimary, bool FromRiposte = false, bool IsStrikethrough = false, bool IsFromSpell = false,
virtual bool Attack(Mob* other, int Hand = EQEmu::inventory::slotPrimary, bool FromRiposte = false, bool IsStrikethrough = false, bool IsFromSpell = false,
ExtraAttackOptions *opts = nullptr, int special = 0) { return false; }
virtual bool HasRaid() { return false; }
virtual bool HasGroup() { return false; }
zone/bonuses.cpp
+37 -37
View File
@@ -17,7 +17,7 @@
*/
#include "../common/classes.h"
#include "../common/global_define.h"
#include "../common/item.h"
#include "../common/item_instance.h"
#include "../common/rulesys.h"
#include "../common/skills.h"
#include "../common/spdat.h"
@@ -145,35 +145,35 @@ void Client::CalcItemBonuses(StatBonuses* newbon) {
unsigned int i;
// Update: MainAmmo should only calc skill mods (TODO: Check for other cases)
for (i = EQEmu::legacy::SlotCharm; i <= EQEmu::legacy::SlotAmmo; i++) {
const ItemInst* inst = m_inv[i];
for (i = EQEmu::inventory::slotCharm; i <= EQEmu::inventory::slotAmmo; i++) {
const EQEmu::ItemInstance* inst = m_inv[i];
if(inst == 0)
continue;
AddItemBonuses(inst, newbon, false, false, 0, (i == EQEmu::legacy::SlotAmmo));
AddItemBonuses(inst, newbon, false, false, 0, (i == EQEmu::inventory::slotAmmo));
//These are given special flags due to how often they are checked for various spell effects.
const EQEmu::ItemBase *item = inst->GetItem();
if (i == EQEmu::legacy::SlotSecondary && (item && item->ItemType == EQEmu::item::ItemTypeShield))
const EQEmu::ItemData *item = inst->GetItem();
if (i == EQEmu::inventory::slotSecondary && (item && item->ItemType == EQEmu::item::ItemTypeShield))
SetShieldEquiped(true);
else if (i == EQEmu::legacy::SlotPrimary && (item && item->ItemType == EQEmu::item::ItemType2HBlunt)) {
else if (i == EQEmu::inventory::slotPrimary && (item && item->ItemType == EQEmu::item::ItemType2HBlunt)) {
SetTwoHandBluntEquiped(true);
SetTwoHanderEquipped(true);
}
else if (i == EQEmu::legacy::SlotPrimary && (item && (item->ItemType == EQEmu::item::ItemType2HSlash || item->ItemType == EQEmu::item::ItemType2HPiercing)))
else if (i == EQEmu::inventory::slotPrimary && (item && (item->ItemType == EQEmu::item::ItemType2HSlash || item->ItemType == EQEmu::item::ItemType2HPiercing)))
SetTwoHanderEquipped(true);
}
//Power Source Slot
if (ClientVersion() >= EQEmu::versions::ClientVersion::SoF)
{
const ItemInst* inst = m_inv[EQEmu::legacy::SlotPowerSource];
const EQEmu::ItemInstance* inst = m_inv[EQEmu::inventory::slotPowerSource];
if(inst)
AddItemBonuses(inst, newbon);
}
//tribute items
for (i = 0; i < EQEmu::legacy::TRIBUTE_SIZE; i++) {
const ItemInst* inst = m_inv[EQEmu::legacy::TRIBUTE_BEGIN + i];
const EQEmu::ItemInstance* inst = m_inv[EQEmu::legacy::TRIBUTE_BEGIN + i];
if(inst == 0)
continue;
AddItemBonuses(inst, newbon, false, true);
@@ -181,8 +181,8 @@ void Client::CalcItemBonuses(StatBonuses* newbon) {
//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::legacy::SlotCharm; i < EQEmu::legacy::SlotAmmo; i++) {
const ItemInst* inst = m_inv[i];
for (i = EQEmu::inventory::slotCharm; i < EQEmu::inventory::slotAmmo; i++) {
const EQEmu::ItemInstance* inst = m_inv[i];
if(inst == 0)
continue;
AdditiveWornBonuses(inst, newbon);
@@ -208,7 +208,7 @@ void Client::ProcessItemCaps()
itembonuses.ATK = std::min(itembonuses.ATK, CalcItemATKCap());
}
void Client::AddItemBonuses(const ItemInst *inst, StatBonuses *newbon, bool isAug, bool isTribute, int rec_override, bool ammo_slot_item)
void Client::AddItemBonuses(const EQEmu::ItemInstance *inst, StatBonuses *newbon, bool isAug, bool isTribute, int rec_override, bool ammo_slot_item)
{
if (!inst || !inst->IsClassCommon()) {
return;
@@ -218,7 +218,7 @@ void Client::AddItemBonuses(const ItemInst *inst, StatBonuses *newbon, bool isAu
return;
}
const EQEmu::ItemBase *item = inst->GetItem();
const EQEmu::ItemData *item = inst->GetItem();
if (!isTribute && !inst->IsEquipable(GetBaseRace(), GetClass())) {
if (item->ItemType != EQEmu::item::ItemTypeFood && item->ItemType != EQEmu::item::ItemTypeDrink)
@@ -527,12 +527,12 @@ void Client::AddItemBonuses(const ItemInst *inst, StatBonuses *newbon, bool isAu
}
if (!isAug) {
for (int i = 0; i < EQEmu::legacy::ITEM_COMMON_SIZE; i++)
for (int i = EQEmu::inventory::socketBegin; i < EQEmu::inventory::SocketCount; i++)
AddItemBonuses(inst->GetAugment(i), newbon, true, false, rec_level, ammo_slot_item);
}
}
void Client::AdditiveWornBonuses(const ItemInst *inst, StatBonuses* newbon, bool isAug) {
void Client::AdditiveWornBonuses(const EQEmu::ItemInstance *inst, StatBonuses* newbon, bool isAug) {
/*
Powerful Non-live like option allows developers to add worn effects on items that
@@ -550,7 +550,7 @@ void Client::AdditiveWornBonuses(const ItemInst *inst, StatBonuses* newbon, bool
if(inst->GetAugmentType()==0 && isAug == true)
return;
const EQEmu::ItemBase *item = inst->GetItem();
const EQEmu::ItemData *item = inst->GetItem();
if(!inst->IsEquipable(GetBaseRace(),GetClass()))
return;
@@ -565,7 +565,7 @@ void Client::AdditiveWornBonuses(const ItemInst *inst, StatBonuses* newbon, bool
if (!isAug)
{
int i;
for (i = 0; i < EQEmu::legacy::ITEM_COMMON_SIZE; i++) {
for (i = EQEmu::inventory::socketBegin; i < EQEmu::inventory::SocketCount; i++) {
AdditiveWornBonuses(inst->GetAugment(i),newbon,true);
}
}
@@ -580,9 +580,9 @@ void Client::CalcEdibleBonuses(StatBonuses* newbon) {
{
if (food && drink)
break;
const ItemInst* inst = GetInv().GetItem(i);
const EQEmu::ItemInstance* inst = GetInv().GetItem(i);
if (inst && inst->GetItem() && inst->IsClassCommon()) {
const EQEmu::ItemBase *item = inst->GetItem();
const EQEmu::ItemData *item = inst->GetItem();
if (item->ItemType == EQEmu::item::ItemTypeFood && !food)
food = true;
else if (item->ItemType == EQEmu::item::ItemTypeDrink && !drink)
@@ -596,9 +596,9 @@ void Client::CalcEdibleBonuses(StatBonuses* newbon) {
{
if (food && drink)
break;
const ItemInst* inst = GetInv().GetItem(i);
const EQEmu::ItemInstance* inst = GetInv().GetItem(i);
if (inst && inst->GetItem() && inst->IsClassCommon()) {
const EQEmu::ItemBase *item = inst->GetItem();
const EQEmu::ItemData *item = inst->GetItem();
if (item->ItemType == EQEmu::item::ItemTypeFood && !food)
food = true;
else if (item->ItemType == EQEmu::item::ItemTypeDrink && !drink)
@@ -3205,7 +3205,7 @@ void NPC::CalcItemBonuses(StatBonuses *newbon)
if(newbon){
for (int i = 0; i < EQEmu::legacy::EQUIPMENT_SIZE; i++){
const EQEmu::ItemBase *cur = database.GetItem(equipment[i]);
const EQEmu::ItemData *cur = database.GetItem(equipment[i]);
if(cur){
//basic stats
newbon->AC += cur->AC;
@@ -3299,7 +3299,7 @@ void Client::CalcItemScale() {
//Power Source Slot
if (ClientVersion() >= EQEmu::versions::ClientVersion::SoF)
{
if (CalcItemScale(EQEmu::legacy::SlotPowerSource, EQEmu::legacy::SlotPowerSource))
if (CalcItemScale(EQEmu::inventory::slotPowerSource, EQEmu::inventory::slotPowerSource))
changed = true;
}
@@ -3314,10 +3314,10 @@ 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::legacy::SlotAmmo) // moved here from calling procedure to facilitate future range changes where MainAmmo may not be the last slot
if (i == EQEmu::inventory::slotAmmo) // moved here from calling procedure to facilitate future range changes where MainAmmo may not be the last slot
continue;
ItemInst* inst = m_inv.GetItem(i);
EQEmu::ItemInstance* inst = m_inv.GetItem(i);
if(inst == nullptr)
continue;
@@ -3325,7 +3325,7 @@ bool Client::CalcItemScale(uint32 slot_x, uint32 slot_y) {
// TEST CODE: test for bazaar trader crashing with charm items
if (Trader)
if (i >= EQEmu::legacy::GENERAL_BAGS_BEGIN && i <= EQEmu::legacy::GENERAL_BAGS_END) {
ItemInst* parent_item = m_inv.GetItem(Inventory::CalcSlotId(i));
EQEmu::ItemInstance* parent_item = m_inv.GetItem(EQEmu::InventoryProfile::CalcSlotId(i));
if (parent_item && parent_item->GetItem()->ID == 17899) // trader satchel
continue;
}
@@ -3344,9 +3344,9 @@ bool Client::CalcItemScale(uint32 slot_x, uint32 slot_y) {
}
//iterate all augments
for (int x = AUG_INDEX_BEGIN; x < EQEmu::legacy::ITEM_COMMON_SIZE; ++x)
for (int x = EQEmu::inventory::socketBegin; x < EQEmu::inventory::SocketCount; ++x)
{
ItemInst * a_inst = inst->GetAugment(x);
EQEmu::ItemInstance * a_inst = inst->GetAugment(x);
if(!a_inst)
continue;
@@ -3393,7 +3393,7 @@ void Client::DoItemEnterZone() {
//Power Source Slot
if (ClientVersion() >= EQEmu::versions::ClientVersion::SoF)
{
if (DoItemEnterZone(EQEmu::legacy::SlotPowerSource, EQEmu::legacy::SlotPowerSource))
if (DoItemEnterZone(EQEmu::inventory::slotPowerSource, EQEmu::inventory::slotPowerSource))
changed = true;
}
@@ -3407,10 +3407,10 @@ 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::legacy::SlotAmmo) // moved here from calling procedure to facilitate future range changes where MainAmmo may not be the last slot
if (i == EQEmu::inventory::slotAmmo) // moved here from calling procedure to facilitate future range changes where MainAmmo may not be the last slot
continue;
ItemInst* inst = m_inv.GetItem(i);
EQEmu::ItemInstance* inst = m_inv.GetItem(i);
if(!inst)
continue;
@@ -3418,7 +3418,7 @@ bool Client::DoItemEnterZone(uint32 slot_x, uint32 slot_y) {
// TEST CODE: test for bazaar trader crashing with charm items
if (Trader)
if (i >= EQEmu::legacy::GENERAL_BAGS_BEGIN && i <= EQEmu::legacy::GENERAL_BAGS_END) {
ItemInst* parent_item = m_inv.GetItem(Inventory::CalcSlotId(i));
EQEmu::ItemInstance* parent_item = m_inv.GetItem(EQEmu::InventoryProfile::CalcSlotId(i));
if (parent_item && parent_item->GetItem()->ID == 17899) // trader satchel
continue;
}
@@ -3429,7 +3429,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::legacy::SlotAmmo || i == EQEmu::legacy::SlotPowerSource) {
if (i <= EQEmu::inventory::slotAmmo || i == EQEmu::inventory::slotPowerSource) {
parse->EventItem(EVENT_EQUIP_ITEM, this, inst, nullptr, "", i);
}
@@ -3439,7 +3439,7 @@ bool Client::DoItemEnterZone(uint32 slot_x, uint32 slot_y) {
update_slot = true;
}
} else {
if (i <= EQEmu::legacy::SlotAmmo || i == EQEmu::legacy::SlotPowerSource) {
if (i <= EQEmu::inventory::slotAmmo || i == EQEmu::inventory::slotPowerSource) {
parse->EventItem(EVENT_EQUIP_ITEM, this, inst, nullptr, "", i);
}
@@ -3447,9 +3447,9 @@ bool Client::DoItemEnterZone(uint32 slot_x, uint32 slot_y) {
}
//iterate all augments
for (int x = AUG_INDEX_BEGIN; x < EQEmu::legacy::ITEM_COMMON_SIZE; ++x)
for (int x = EQEmu::inventory::socketBegin; x < EQEmu::inventory::SocketCount; ++x)
{
ItemInst *a_inst = inst->GetAugment(x);
EQEmu::ItemInstance *a_inst = inst->GetAugment(x);
if(!a_inst)
continue;
zone/bot.cpp
+171 -171
View File
@@ -229,13 +229,13 @@ void Bot::SetBotSpellID(uint32 newSpellID) {
}
uint32 Bot::GetBotArcheryRange() {
const ItemInst *range_inst = GetBotItem(EQEmu::legacy::SlotRange);
const ItemInst *ammo_inst = GetBotItem(EQEmu::legacy::SlotAmmo);
const EQEmu::ItemInstance *range_inst = GetBotItem(EQEmu::inventory::slotRange);
const EQEmu::ItemInstance *ammo_inst = GetBotItem(EQEmu::inventory::slotAmmo);
if (!range_inst || !ammo_inst)
return 0;
const EQEmu::ItemBase *range_item = range_inst->GetItem();
const EQEmu::ItemBase *ammo_item = ammo_inst->GetItem();
const EQEmu::ItemData *range_item = range_inst->GetItem();
const EQEmu::ItemData *ammo_item = ammo_inst->GetItem();
if (!range_item || !ammo_item || range_item->ItemType != EQEmu::item::ItemTypeBow || ammo_item->ItemType != EQEmu::item::ItemTypeArrow)
return 0;
@@ -246,15 +246,15 @@ uint32 Bot::GetBotArcheryRange() {
void Bot::ChangeBotArcherWeapons(bool isArcher) {
if((GetClass()==WARRIOR) || (GetClass()==PALADIN) || (GetClass()==RANGER) || (GetClass()==SHADOWKNIGHT) || (GetClass()==ROGUE)) {
if(!isArcher) {
BotAddEquipItem(EQEmu::legacy::SlotPrimary, GetBotItemBySlot(EQEmu::legacy::SlotPrimary));
BotAddEquipItem(EQEmu::legacy::SlotSecondary, GetBotItemBySlot(EQEmu::legacy::SlotSecondary));
BotAddEquipItem(EQEmu::inventory::slotPrimary, GetBotItemBySlot(EQEmu::inventory::slotPrimary));
BotAddEquipItem(EQEmu::inventory::slotSecondary, GetBotItemBySlot(EQEmu::inventory::slotSecondary));
SetAttackTimer();
BotGroupSay(this, "My blade is ready");
} else {
BotRemoveEquipItem(EQEmu::legacy::SlotPrimary);
BotRemoveEquipItem(EQEmu::legacy::SlotSecondary);
BotAddEquipItem(EQEmu::legacy::SlotAmmo, GetBotItemBySlot(EQEmu::legacy::SlotAmmo));
BotAddEquipItem(EQEmu::legacy::SlotSecondary, GetBotItemBySlot(EQEmu::legacy::SlotRange));
BotRemoveEquipItem(EQEmu::inventory::slotPrimary);
BotRemoveEquipItem(EQEmu::inventory::slotSecondary);
BotAddEquipItem(EQEmu::inventory::slotAmmo, GetBotItemBySlot(EQEmu::inventory::slotAmmo));
BotAddEquipItem(EQEmu::inventory::slotSecondary, GetBotItemBySlot(EQEmu::inventory::slotRange));
SetAttackTimer();
BotGroupSay(this, "My bow is true and ready");
}
@@ -1175,11 +1175,11 @@ void Bot::GenerateArmorClass() {
uint16 Bot::GetPrimarySkillValue() {
EQEmu::skills::SkillType skill = EQEmu::skills::HIGHEST_SKILL; //because nullptr == 0, which is 1H Slashing, & we want it to return 0 from GetSkill
bool equiped = m_inv.GetItem(EQEmu::legacy::SlotPrimary);
bool equiped = m_inv.GetItem(EQEmu::inventory::slotPrimary);
if(!equiped)
skill = EQEmu::skills::SkillHandtoHand;
else {
uint8 type = m_inv.GetItem(EQEmu::legacy::SlotPrimary)->GetItem()->ItemType; //is this the best way to do this?
uint8 type = m_inv.GetItem(EQEmu::inventory::slotPrimary)->GetItem()->ItemType; //is this the best way to do this?
switch(type) {
case EQEmu::item::ItemType1HSlash:
skill = EQEmu::skills::Skill1HSlashing;
@@ -1900,13 +1900,13 @@ void Bot::BotRangedAttack(Mob* other) {
return;
}
ItemInst* rangedItem = GetBotItem(EQEmu::legacy::SlotRange);
const EQEmu::ItemBase* RangeWeapon = 0;
EQEmu::ItemInstance* rangedItem = GetBotItem(EQEmu::inventory::slotRange);
const EQEmu::ItemData* RangeWeapon = 0;
if(rangedItem)
RangeWeapon = rangedItem->GetItem();
ItemInst* ammoItem = GetBotItem(EQEmu::legacy::SlotAmmo);
const EQEmu::ItemBase* Ammo = 0;
EQEmu::ItemInstance* ammoItem = GetBotItem(EQEmu::inventory::slotAmmo);
const EQEmu::ItemData* Ammo = 0;
if(ammoItem)
Ammo = ammoItem->GetItem();
@@ -2002,7 +2002,7 @@ void Bot::DoMeleeSkillAttackDmg(Mob* other, uint16 weapon_damage, EQEmu::skills:
int damage = 0;
uint32 hate = 0;
int Hand = EQEmu::legacy::SlotPrimary;
int Hand = EQEmu::inventory::slotPrimary;
if (hate == 0 && weapon_damage > 1)
hate = weapon_damage;
@@ -2015,7 +2015,7 @@ void Bot::DoMeleeSkillAttackDmg(Mob* other, uint16 weapon_damage, EQEmu::skills:
int32 min_hit = 1;
int32 max_hit = ((2 * weapon_damage * GetDamageTable(skillinuse)) / 100);
if(GetLevel() >= 28 && IsWarriorClass()) {
int ucDamageBonus = GetWeaponDamageBonus((const EQEmu::ItemBase*) nullptr);
int ucDamageBonus = GetWeaponDamageBonus((const EQEmu::ItemData*) nullptr);
min_hit += (int) ucDamageBonus;
max_hit += (int) ucDamageBonus;
hate += ucDamageBonus;
@@ -2031,7 +2031,7 @@ void Bot::DoMeleeSkillAttackDmg(Mob* other, uint16 weapon_damage, EQEmu::skills:
else
damage = zone->random.Int(min_hit, max_hit);
if (other->AvoidDamage(this, damage, CanRiposte ? EQEmu::legacy::SlotRange : EQEmu::legacy::SlotPrimary)) { // MainRange excludes ripo, primary doesn't have any extra behavior
if (other->AvoidDamage(this, damage, CanRiposte ? EQEmu::inventory::slotRange : EQEmu::inventory::slotPrimary)) { // MainRange excludes ripo, primary doesn't have any extra behavior
if (damage == -3) {
DoRiposte(other);
if (HasDied())
@@ -2056,8 +2056,8 @@ void Bot::DoMeleeSkillAttackDmg(Mob* other, uint16 weapon_damage, EQEmu::skills:
damage = -5;
if (skillinuse == EQEmu::skills::SkillBash){
const ItemInst* inst = GetBotItem(EQEmu::legacy::SlotSecondary);
const EQEmu::ItemBase* botweapon = 0;
const EQEmu::ItemInstance* inst = GetBotItem(EQEmu::inventory::slotSecondary);
const EQEmu::ItemData* botweapon = 0;
if(inst)
botweapon = inst->GetItem();
@@ -2103,21 +2103,21 @@ void Bot::ApplySpecialAttackMod(EQEmu::skills::SkillType skill, int32 &dmg, int3
case EQEmu::skills::SkillFlyingKick:
case EQEmu::skills::SkillRoundKick:
case EQEmu::skills::SkillKick:
item_slot = EQEmu::legacy::SlotFeet;
item_slot = EQEmu::inventory::slotFeet;
break;
case EQEmu::skills::SkillBash:
item_slot = EQEmu::legacy::SlotSecondary;
item_slot = EQEmu::inventory::slotSecondary;
break;
case EQEmu::skills::SkillDragonPunch:
case EQEmu::skills::SkillEagleStrike:
case EQEmu::skills::SkillTigerClaw:
item_slot = EQEmu::legacy::SlotHands;
item_slot = EQEmu::inventory::slotHands;
break;
}
if (item_slot >= EQEmu::legacy::EQUIPMENT_BEGIN){
const ItemInst* inst = GetBotItem(item_slot);
const EQEmu::ItemBase* botweapon = 0;
const EQEmu::ItemInstance* inst = GetBotItem(item_slot);
const EQEmu::ItemData* botweapon = 0;
if(inst)
botweapon = inst->GetItem();
@@ -2449,23 +2449,23 @@ void Bot::AI_Process() {
// First, special attack per class (kick, backstab etc..)
DoClassAttacks(GetTarget());
if(attack_timer.Check()) {
Attack(GetTarget(), EQEmu::legacy::SlotPrimary);
TriggerDefensiveProcs(GetTarget(), EQEmu::legacy::SlotPrimary, false);
ItemInst *wpn = GetBotItem(EQEmu::legacy::SlotPrimary);
TryWeaponProc(wpn, GetTarget(), EQEmu::legacy::SlotPrimary);
Attack(GetTarget(), EQEmu::inventory::slotPrimary);
TriggerDefensiveProcs(GetTarget(), EQEmu::inventory::slotPrimary, false);
EQEmu::ItemInstance *wpn = GetBotItem(EQEmu::inventory::slotPrimary);
TryWeaponProc(wpn, GetTarget(), EQEmu::inventory::slotPrimary);
bool tripleSuccess = false;
if(BotOwner && GetTarget() && CanThisClassDoubleAttack()) {
if(BotOwner && CheckBotDoubleAttack())
Attack(GetTarget(), EQEmu::legacy::SlotPrimary, true);
Attack(GetTarget(), EQEmu::inventory::slotPrimary, true);
if(BotOwner && GetTarget() && GetSpecialAbility(SPECATK_TRIPLE) && CheckBotDoubleAttack(true)) {
tripleSuccess = true;
Attack(GetTarget(), EQEmu::legacy::SlotPrimary, true);
Attack(GetTarget(), EQEmu::inventory::slotPrimary, true);
}
//quad attack, does this belong here??
if(BotOwner && GetTarget() && GetSpecialAbility(SPECATK_QUAD) && CheckBotDoubleAttack(true))
Attack(GetTarget(), EQEmu::legacy::SlotPrimary, true);
Attack(GetTarget(), EQEmu::inventory::slotPrimary, true);
}
//Live AA - Flurry, Rapid Strikes ect (Flurry does not require Triple Attack).
@@ -2473,18 +2473,18 @@ void Bot::AI_Process() {
if (GetTarget() && flurrychance) {
if(zone->random.Int(0, 100) < flurrychance) {
Message_StringID(MT_NPCFlurry, YOU_FLURRY);
Attack(GetTarget(), EQEmu::legacy::SlotPrimary, false);
Attack(GetTarget(), EQEmu::legacy::SlotPrimary, false);
Attack(GetTarget(), EQEmu::inventory::slotPrimary, false);
Attack(GetTarget(), EQEmu::inventory::slotPrimary, false);
}
}
int32 ExtraAttackChanceBonus = (spellbonuses.ExtraAttackChance + itembonuses.ExtraAttackChance + aabonuses.ExtraAttackChance);
if (GetTarget() && ExtraAttackChanceBonus) {
ItemInst *wpn = GetBotItem(EQEmu::legacy::SlotPrimary);
EQEmu::ItemInstance *wpn = GetBotItem(EQEmu::inventory::slotPrimary);
if(wpn) {
if (wpn->GetItem()->IsType2HWeapon()) {
if(zone->random.Int(0, 100) < ExtraAttackChanceBonus)
Attack(GetTarget(), EQEmu::legacy::SlotPrimary, false);
Attack(GetTarget(), EQEmu::inventory::slotPrimary, false);
}
}
}
@@ -2504,8 +2504,8 @@ void Bot::AI_Process() {
//now off hand
if(GetTarget() && attack_dw_timer.Check() && CanThisClassDualWield()) {
const ItemInst* instweapon = GetBotItem(EQEmu::legacy::SlotSecondary);
const EQEmu::ItemBase* weapon = 0;
const EQEmu::ItemInstance* instweapon = GetBotItem(EQEmu::inventory::slotSecondary);
const EQEmu::ItemData* weapon = 0;
//can only dual wield without a weapon if you're a monk
if(instweapon || (botClass == MONK)) {
if(instweapon)
@@ -2526,12 +2526,12 @@ void Bot::AI_Process() {
DualWieldProbability += (DualWieldProbability * float(DWBonus) / 100.0f);
float random = zone->random.Real(0, 1);
if (random < DualWieldProbability){ // Max 78% of DW
Attack(GetTarget(), EQEmu::legacy::SlotSecondary); // Single attack with offhand
ItemInst *wpn = GetBotItem(EQEmu::legacy::SlotSecondary);
TryWeaponProc(wpn, GetTarget(), EQEmu::legacy::SlotSecondary);
Attack(GetTarget(), EQEmu::inventory::slotSecondary); // Single attack with offhand
EQEmu::ItemInstance *wpn = GetBotItem(EQEmu::inventory::slotSecondary);
TryWeaponProc(wpn, GetTarget(), EQEmu::inventory::slotSecondary);
if( CanThisClassDoubleAttack() && CheckBotDoubleAttack()) {
if(GetTarget() && GetTarget()->GetHP() > -10)
Attack(GetTarget(), EQEmu::legacy::SlotSecondary); // Single attack with offhand
Attack(GetTarget(), EQEmu::inventory::slotSecondary); // Single attack with offhand
}
}
}
@@ -2702,12 +2702,12 @@ void Bot::PetAIProcess() {
if(!botPet->BehindMob(botPet->GetTarget(), botPet->GetX(), botPet->GetY()) && botPet->GetTarget()->IsEnraged())
return;
if (botPet->Attack(GetTarget(), EQEmu::legacy::SlotPrimary)) // try the main hand
if (botPet->Attack(GetTarget(), EQEmu::inventory::slotPrimary)) // try the main hand
if (botPet->GetTarget()) {
// We're a pet so we re able to dual attack
int32 RandRoll = zone->random.Int(0, 99);
if (botPet->CanThisClassDoubleAttack() && (RandRoll < (botPet->GetLevel() + NPCDualAttackModifier))) {
if (botPet->Attack(botPet->GetTarget(), EQEmu::legacy::SlotPrimary)) {}
if (botPet->Attack(botPet->GetTarget(), EQEmu::inventory::slotPrimary)) {}
}
}
@@ -2745,11 +2745,11 @@ void Bot::PetAIProcess() {
float DualWieldProbability = ((botPet->GetSkill(EQEmu::skills::SkillDualWield) + botPet->GetLevel()) / 400.0f);
DualWieldProbability -= zone->random.Real(0, 1);
if(DualWieldProbability < 0) {
botPet->Attack(botPet->GetTarget(), EQEmu::legacy::SlotSecondary);
botPet->Attack(botPet->GetTarget(), EQEmu::inventory::slotSecondary);
if (botPet->CanThisClassDoubleAttack()) {
int32 RandRoll = zone->random.Int(0, 99);
if (RandRoll < (botPet->GetLevel() + 20))
botPet->Attack(botPet->GetTarget(), EQEmu::legacy::SlotSecondary);
botPet->Attack(botPet->GetTarget(), EQEmu::inventory::slotSecondary);
}
}
}
@@ -2875,7 +2875,7 @@ void Bot::Spawn(Client* botCharacterOwner) {
for (int i = EQEmu::legacy::EQUIPMENT_BEGIN; i <= EQEmu::legacy::EQUIPMENT_END; ++i) {
itemID = GetBotItemBySlot(i);
if(itemID != 0) {
materialFromSlot = Inventory::CalcMaterialFromSlot(i);
materialFromSlot = EQEmu::InventoryProfile::CalcMaterialFromSlot(i);
if(materialFromSlot != 0xFF)
this->SendWearChange(materialFromSlot);
}
@@ -2897,7 +2897,7 @@ void Bot::RemoveBotItemBySlot(uint32 slotID, std::string *errorMessage)
}
// Retrieves all the inventory records from the database for this bot.
void Bot::GetBotItems(Inventory &inv, std::string* errorMessage)
void Bot::GetBotItems(EQEmu::InventoryProfile &inv, std::string* errorMessage)
{
if(!GetBotID())
return;
@@ -2952,18 +2952,18 @@ void Bot::FillSpawnStruct(NewSpawn_Struct* ns, Mob* ForWho) {
ns->spawn.light = m_Light.Type[EQEmu::lightsource::LightActive];
ns->spawn.helm = helmtexture; //(GetShowHelm() ? helmtexture : 0); //0xFF;
ns->spawn.equip_chest2 = texture; //0xFF;
const EQEmu::ItemBase* item = 0;
const ItemInst* inst = 0;
const EQEmu::ItemData* item = 0;
const EQEmu::ItemInstance* inst = 0;
uint32 spawnedbotid = 0;
spawnedbotid = this->GetBotID();
for (int i = 0; i < EQEmu::textures::TexturePrimary; i++) {
for (int i = EQEmu::textures::textureBegin; i < EQEmu::textures::weaponPrimary; i++) {
inst = GetBotItem(i);
if (inst) {
item = inst->GetItem();
if (item != 0) {
ns->spawn.equipment.Slot[i].Material = item->Material;
ns->spawn.equipment.Slot[i].EliteMaterial = item->EliteMaterial;
ns->spawn.equipment.Slot[i].HeroForgeModel = item->HerosForgeModel;
ns->spawn.equipment.Slot[i].EliteModel = item->EliteMaterial;
ns->spawn.equipment.Slot[i].HerosForgeModel = item->HerosForgeModel;
if (armor_tint.Slot[i].Color)
ns->spawn.equipment_tint.Slot[i].Color = armor_tint.Slot[i].Color;
else
@@ -2975,25 +2975,25 @@ void Bot::FillSpawnStruct(NewSpawn_Struct* ns, Mob* ForWho) {
}
}
inst = GetBotItem(EQEmu::legacy::SlotPrimary);
inst = GetBotItem(EQEmu::inventory::slotPrimary);
if(inst) {
item = inst->GetItem();
if(item) {
if(strlen(item->IDFile) > 2)
ns->spawn.equipment.Primary.Material = atoi(&item->IDFile[2]);
ns->spawn.equipment_tint.Primary.Color = GetEquipmentColor(EQEmu::textures::TexturePrimary);
ns->spawn.equipment_tint.Primary.Color = GetEquipmentColor(EQEmu::textures::weaponPrimary);
}
}
inst = GetBotItem(EQEmu::legacy::SlotSecondary);
inst = GetBotItem(EQEmu::inventory::slotSecondary);
if(inst) {
item = inst->GetItem();
if(item) {
if(strlen(item->IDFile) > 2)
ns->spawn.equipment.Secondary.Material = atoi(&item->IDFile[2]);
ns->spawn.equipment_tint.Secondary.Color = GetEquipmentColor(EQEmu::textures::TextureSecondary);
ns->spawn.equipment_tint.Secondary.Color = GetEquipmentColor(EQEmu::textures::weaponSecondary);
}
}
}
@@ -3224,8 +3224,8 @@ void Bot::SendBotArcheryWearChange(uint8 material_slot, uint32 material, uint32
}
// Returns the item id that is in the bot inventory collection for the specified slot.
ItemInst* Bot::GetBotItem(uint32 slotID) {
ItemInst* item = m_inv.GetItem(slotID);
EQEmu::ItemInstance* Bot::GetBotItem(uint32 slotID) {
EQEmu::ItemInstance* item = m_inv.GetItem(slotID);
if(item)
return item;
@@ -3235,9 +3235,9 @@ ItemInst* Bot::GetBotItem(uint32 slotID) {
// Adds the specified item it bot to the NPC equipment array and to the bot inventory collection.
void Bot::BotAddEquipItem(int slot, uint32 id) {
if(slot > 0 && id > 0) {
uint8 materialFromSlot = Inventory::CalcMaterialFromSlot(slot);
uint8 materialFromSlot = EQEmu::InventoryProfile::CalcMaterialFromSlot(slot);
if (materialFromSlot != EQEmu::textures::TextureInvalid) {
if (materialFromSlot != EQEmu::textures::materialInvalid) {
equipment[slot] = id; // npc has more than just material slots. Valid material should mean valid inventory index
SendWearChange(materialFromSlot);
}
@@ -3251,13 +3251,13 @@ void Bot::BotAddEquipItem(int slot, uint32 id) {
// Erases the specified item from bot the NPC equipment array and from the bot inventory collection.
void Bot::BotRemoveEquipItem(int slot) {
if(slot > 0) {
uint8 materialFromSlot = Inventory::CalcMaterialFromSlot(slot);
uint8 materialFromSlot = EQEmu::InventoryProfile::CalcMaterialFromSlot(slot);
if (materialFromSlot != EQEmu::textures::TextureInvalid) {
if (materialFromSlot != EQEmu::textures::materialInvalid) {
equipment[slot] = 0; // npc has more than just material slots. Valid material should mean valid inventory index
SendWearChange(materialFromSlot);
if (materialFromSlot == EQEmu::textures::TextureChest)
SendWearChange(EQEmu::textures::TextureArms);
if (materialFromSlot == EQEmu::textures::armorChest)
SendWearChange(EQEmu::textures::armorArms);
}
UpdateEquipmentLight();
@@ -3266,7 +3266,7 @@ void Bot::BotRemoveEquipItem(int slot) {
}
}
void Bot::BotTradeSwapItem(Client* client, int16 lootSlot, const ItemInst* inst, const ItemInst* inst_swap, uint32 equipableSlots, std::string* errorMessage, bool swap) {
void Bot::BotTradeSwapItem(Client* client, int16 lootSlot, const EQEmu::ItemInstance* inst, const EQEmu::ItemInstance* inst_swap, uint32 equipableSlots, std::string* errorMessage, bool swap) {
if(!errorMessage->empty())
return;
@@ -3289,7 +3289,7 @@ void Bot::BotTradeSwapItem(Client* client, int16 lootSlot, const ItemInst* inst,
}
}
void Bot::BotTradeAddItem(uint32 id, const ItemInst* inst, int16 charges, uint32 equipableSlots, uint16 lootSlot, std::string* errorMessage, bool addToDb)
void Bot::BotTradeAddItem(uint32 id, const EQEmu::ItemInstance* inst, int16 charges, uint32 equipableSlots, uint16 lootSlot, std::string* errorMessage, bool addToDb)
{
if(addToDb) {
if (!botdb.SaveItemBySlot(this, lootSlot, inst)) {
@@ -3360,7 +3360,7 @@ void Bot::FinishTrade(Client* client, BotTradeType tradeType) {
else if(tradeType == BotTradeClientNoDropNoTrade) {
// Items being traded are found on the Client's cursor slot, slot id 30. This item can be either a single item or it can be a bag.
// If it is a bag, then we have to search for items in slots 331 thru 340
PerformTradeWithClient(EQEmu::legacy::SlotCursor, EQEmu::legacy::SlotCursor, client);
PerformTradeWithClient(EQEmu::inventory::slotCursor, EQEmu::inventory::slotCursor, client);
// TODO: Add logic here to test if the item in SLOT_CURSOR is a container type, if it is then we need to call the following:
// PerformTradeWithClient(331, 340, client);
@@ -3382,23 +3382,23 @@ void Bot::PerformTradeWithClient(int16 beginSlotID, int16 endSlotID, Client* cli
bool UpdateClient = false;
bool already_returned = false;
Inventory& clientInventory = client->GetInv();
const ItemInst* inst = clientInventory[i];
EQEmu::InventoryProfile& clientInventory = client->GetInv();
const EQEmu::ItemInstance* inst = clientInventory[i];
if(inst) {
items[i] = inst->GetItem()->ID;
charges[i] = inst->GetCharges();
}
if (i == EQEmu::legacy::SlotCursor)
if (i == EQEmu::inventory::slotCursor)
UpdateClient = true;
//EQoffline: will give the items to the bots and change the bot stats
if(inst && (GetBotOwner() == client->CastToMob()) && !IsEngaged()) {
std::string TempErrorMessage;
const EQEmu::ItemBase* mWeaponItem = inst->GetItem();
const EQEmu::ItemData* mWeaponItem = inst->GetItem();
bool failedLoreCheck = false;
for (int m = AUG_INDEX_BEGIN; m < EQEmu::legacy::ITEM_COMMON_SIZE; ++m) {
ItemInst *itm = inst->GetAugment(m);
for (int m = EQEmu::inventory::socketBegin; m < EQEmu::inventory::SocketCount; ++m) {
EQEmu::ItemInstance *itm = inst->GetAugment(m);
if(itm)
{
if(CheckLoreConflict(itm->GetItem())) {
@@ -3415,7 +3415,7 @@ void Bot::PerformTradeWithClient(int16 beginSlotID, int16 endSlotID, Client* cli
if(!failedLoreCheck && mWeaponItem && inst->IsEquipable(GetBaseRace(), GetClass()) && (GetLevel() >= mWeaponItem->ReqLevel)) {
BotCanWear = true;
botCanWear[i] = BotCanWear;
ItemInst* swap_item = nullptr;
EQEmu::ItemInstance* swap_item = nullptr;
const char* equipped[EQEmu::legacy::EQUIPMENT_SIZE + 1] = { "Charm", "Left Ear", "Head", "Face", "Right Ear", "Neck", "Shoulders", "Arms", "Back",
"Left Wrist", "Right Wrist", "Range", "Hands", "Primary Hand", "Secondary Hand",
@@ -3429,17 +3429,17 @@ void Bot::PerformTradeWithClient(int16 beginSlotID, int16 endSlotID, Client* cli
how_many_slots++;
if(!GetBotItem(j)) {
if (j == EQEmu::legacy::SlotPrimary) {
if (j == EQEmu::inventory::slotPrimary) {
if (mWeaponItem->IsType2HWeapon()) {
if (GetBotItem(EQEmu::legacy::SlotSecondary)) {
if (GetBotItem(EQEmu::inventory::slotSecondary)) {
if (mWeaponItem && mWeaponItem->IsType2HWeapon()) {
if (client->CheckLoreConflict(GetBotItem(EQEmu::legacy::SlotSecondary)->GetItem())) {
if (client->CheckLoreConflict(GetBotItem(EQEmu::inventory::slotSecondary)->GetItem())) {
failedLoreCheck = true;
}
}
else {
ItemInst* remove_item = GetBotItem(EQEmu::legacy::SlotSecondary);
BotTradeSwapItem(client, EQEmu::legacy::SlotSecondary, 0, remove_item, remove_item->GetItem()->Slots, &TempErrorMessage, false);
EQEmu::ItemInstance* remove_item = GetBotItem(EQEmu::inventory::slotSecondary);
BotTradeSwapItem(client, EQEmu::inventory::slotSecondary, 0, remove_item, remove_item->GetItem()->Slots, &TempErrorMessage, false);
}
}
}
@@ -3449,7 +3449,7 @@ void Bot::PerformTradeWithClient(int16 beginSlotID, int16 endSlotID, Client* cli
}
break;
}
else if (j == EQEmu::legacy::SlotSecondary) {
else if (j == EQEmu::inventory::slotSecondary) {
if(inst->IsWeapon()) {
if(CanThisClassDualWield()) {
BotTradeAddItem(mWeaponItem->ID, inst, inst->GetCharges(), mWeaponItem->Slots, j, &TempErrorMessage);
@@ -3465,10 +3465,10 @@ void Bot::PerformTradeWithClient(int16 beginSlotID, int16 endSlotID, Client* cli
success = true;
}
if(success) {
if (GetBotItem(EQEmu::legacy::SlotPrimary)) {
ItemInst* remove_item = GetBotItem(EQEmu::legacy::SlotPrimary);
if (GetBotItem(EQEmu::inventory::slotPrimary)) {
EQEmu::ItemInstance* remove_item = GetBotItem(EQEmu::inventory::slotPrimary);
if (remove_item->GetItem()->IsType2HWeapon()) {
BotTradeSwapItem(client, EQEmu::legacy::SlotPrimary, 0, remove_item, remove_item->GetItem()->Slots, &TempErrorMessage, false);
BotTradeSwapItem(client, EQEmu::inventory::slotPrimary, 0, remove_item, remove_item->GetItem()->Slots, &TempErrorMessage, false);
}
}
break;
@@ -3490,8 +3490,8 @@ void Bot::PerformTradeWithClient(int16 beginSlotID, int16 endSlotID, Client* cli
swap_item = GetBotItem(j);
failedLoreCheck = false;
for (int k = AUG_INDEX_BEGIN; k < EQEmu::legacy::ITEM_COMMON_SIZE; ++k) {
ItemInst *itm = swap_item->GetAugment(k);
for (int k = EQEmu::inventory::socketBegin; k < EQEmu::inventory::SocketCount; ++k) {
EQEmu::ItemInstance *itm = swap_item->GetAugment(k);
if(itm)
{
if(client->CheckLoreConflict(itm->GetItem())) {
@@ -3503,28 +3503,28 @@ void Bot::PerformTradeWithClient(int16 beginSlotID, int16 endSlotID, Client* cli
failedLoreCheck = true;
}
if(!failedLoreCheck) {
if (j == EQEmu::legacy::SlotPrimary) {
if (j == EQEmu::inventory::slotPrimary) {
if (mWeaponItem->IsType2HWeapon()) {
if (GetBotItem(EQEmu::legacy::SlotSecondary)) {
if (client->CheckLoreConflict(GetBotItem(EQEmu::legacy::SlotSecondary)->GetItem())) {
if (GetBotItem(EQEmu::inventory::slotSecondary)) {
if (client->CheckLoreConflict(GetBotItem(EQEmu::inventory::slotSecondary)->GetItem())) {
failedLoreCheck = true;
}
else {
ItemInst* remove_item = GetBotItem(EQEmu::legacy::SlotSecondary);
BotTradeSwapItem(client, EQEmu::legacy::SlotSecondary, 0, remove_item, remove_item->GetItem()->Slots, &TempErrorMessage, false);
EQEmu::ItemInstance* remove_item = GetBotItem(EQEmu::inventory::slotSecondary);
BotTradeSwapItem(client, EQEmu::inventory::slotSecondary, 0, remove_item, remove_item->GetItem()->Slots, &TempErrorMessage, false);
}
}
}
if(!failedLoreCheck) {
BotTradeSwapItem(client, EQEmu::legacy::SlotPrimary, inst, swap_item, mWeaponItem->Slots, &TempErrorMessage);
BotTradeSwapItem(client, EQEmu::inventory::slotPrimary, inst, swap_item, mWeaponItem->Slots, &TempErrorMessage);
success = true;
}
break;
}
else if (j == EQEmu::legacy::SlotSecondary) {
else if (j == EQEmu::inventory::slotSecondary) {
if(inst->IsWeapon()) {
if(CanThisClassDualWield()) {
BotTradeSwapItem(client, EQEmu::legacy::SlotSecondary, inst, swap_item, mWeaponItem->Slots, &TempErrorMessage);
BotTradeSwapItem(client, EQEmu::inventory::slotSecondary, inst, swap_item, mWeaponItem->Slots, &TempErrorMessage);
success = true;
}
else {
@@ -3533,13 +3533,13 @@ void Bot::PerformTradeWithClient(int16 beginSlotID, int16 endSlotID, Client* cli
}
}
else {
BotTradeSwapItem(client, EQEmu::legacy::SlotSecondary, inst, swap_item, mWeaponItem->Slots, &TempErrorMessage);
BotTradeSwapItem(client, EQEmu::inventory::slotSecondary, inst, swap_item, mWeaponItem->Slots, &TempErrorMessage);
success = true;
}
if (success && GetBotItem(EQEmu::legacy::SlotPrimary)) {
ItemInst* remove_item = GetBotItem(EQEmu::legacy::SlotPrimary);
if (success && GetBotItem(EQEmu::inventory::slotPrimary)) {
EQEmu::ItemInstance* remove_item = GetBotItem(EQEmu::inventory::slotPrimary);
if (remove_item->GetItem()->IsType2HWeapon()) {
BotTradeSwapItem(client, EQEmu::legacy::SlotPrimary, 0, remove_item, remove_item->GetItem()->Slots, &TempErrorMessage, false);
BotTradeSwapItem(client, EQEmu::inventory::slotPrimary, 0, remove_item, remove_item->GetItem()->Slots, &TempErrorMessage, false);
}
}
break;
@@ -3574,7 +3574,7 @@ void Bot::PerformTradeWithClient(int16 beginSlotID, int16 endSlotID, Client* cli
}
}
const EQEmu::ItemBase* item2 = 0;
const EQEmu::ItemData* item2 = 0;
for(int y = beginSlotID; y <= endSlotID; ++y) {
item2 = database.GetItem(items[y]);
if(item2) {
@@ -3738,14 +3738,14 @@ bool Bot::Attack(Mob* other, int Hand, bool FromRiposte, bool IsStrikethrough, b
}
FaceTarget(GetTarget());
ItemInst* weapon = nullptr;
if (Hand == EQEmu::legacy::SlotPrimary) {
weapon = GetBotItem(EQEmu::legacy::SlotPrimary);
EQEmu::ItemInstance* weapon = nullptr;
if (Hand == EQEmu::inventory::slotPrimary) {
weapon = GetBotItem(EQEmu::inventory::slotPrimary);
OffHandAtk(false);
}
if (Hand == EQEmu::legacy::SlotSecondary) {
weapon = GetBotItem(EQEmu::legacy::SlotSecondary);
if (Hand == EQEmu::inventory::slotSecondary) {
weapon = GetBotItem(EQEmu::inventory::slotSecondary);
OffHandAtk(true);
}
@@ -3810,19 +3810,19 @@ bool Bot::Attack(Mob* other, int Hand, bool FromRiposte, bool IsStrikethrough, b
// This is not recommended for normal usage, as the damage bonus represents a non-trivial component of the DPS output
// of weapons wielded by higher-level melee characters (especially for two-handed weapons).
int ucDamageBonus = 0;
if (Hand == EQEmu::legacy::SlotPrimary && GetLevel() >= 28 && IsWarriorClass()) {
if (Hand == EQEmu::inventory::slotPrimary && GetLevel() >= 28 && IsWarriorClass()) {
// Damage bonuses apply only to hits from the main hand (Hand == MainPrimary) by characters level 28 and above
// who belong to a melee class. If we're here, then all of these conditions apply.
ucDamageBonus = GetWeaponDamageBonus(weapon ? weapon->GetItem() : (const EQEmu::ItemBase*) nullptr);
ucDamageBonus = GetWeaponDamageBonus(weapon ? weapon->GetItem() : (const EQEmu::ItemData*) nullptr);
min_hit += (int) ucDamageBonus;
max_hit += (int) ucDamageBonus;
hate += ucDamageBonus;
}
#endif
//Live AA - Sinister Strikes *Adds weapon damage bonus to offhand weapon.
if (Hand == EQEmu::legacy::SlotSecondary) {
if (Hand == EQEmu::inventory::slotSecondary) {
if (aabonuses.SecondaryDmgInc || itembonuses.SecondaryDmgInc || spellbonuses.SecondaryDmgInc){
ucDamageBonus = GetWeaponDamageBonus(weapon ? weapon->GetItem() : (const EQEmu::ItemBase*) nullptr);
ucDamageBonus = GetWeaponDamageBonus(weapon ? weapon->GetItem() : (const EQEmu::ItemData*) nullptr);
min_hit += (int) ucDamageBonus;
max_hit += (int) ucDamageBonus;
hate += ucDamageBonus;
@@ -4280,9 +4280,9 @@ int32 Bot::GetBotFocusEffect(BotfocusType bottype, uint16 spell_id) {
//Check if item focus effect exists for the client.
if (itembonuses.FocusEffects[bottype]) {
const EQEmu::ItemBase* TempItem = 0;
const EQEmu::ItemBase* UsedItem = 0;
const ItemInst* TempInst = 0;
const EQEmu::ItemData* TempItem = 0;
const EQEmu::ItemData* UsedItem = 0;
const EQEmu::ItemInstance* TempInst = 0;
uint16 UsedFocusID = 0;
int32 Total = 0;
int32 focus_max = 0;
@@ -4290,7 +4290,7 @@ int32 Bot::GetBotFocusEffect(BotfocusType bottype, uint16 spell_id) {
//item focus
for (int x = EQEmu::legacy::EQUIPMENT_BEGIN; x <= EQEmu::legacy::EQUIPMENT_END; x++) {
TempItem = nullptr;
ItemInst* ins = GetBotItem(x);
EQEmu::ItemInstance* ins = GetBotItem(x);
if (!ins)
continue;
@@ -4313,11 +4313,11 @@ int32 Bot::GetBotFocusEffect(BotfocusType bottype, uint16 spell_id) {
}
}
for (int y = AUG_INDEX_BEGIN; y < EQEmu::legacy::ITEM_COMMON_SIZE; ++y) {
ItemInst *aug = nullptr;
for (int y = EQEmu::inventory::socketBegin; y < EQEmu::inventory::SocketCount; ++y) {
EQEmu::ItemInstance *aug = nullptr;
aug = ins->GetAugment(y);
if(aug) {
const EQEmu::ItemBase* TempItemAug = aug->GetItem();
const EQEmu::ItemData* TempItemAug = aug->GetItem();
if (TempItemAug && TempItemAug->Focus.Effect > 0 && TempItemAug->Focus.Effect != SPELL_UNKNOWN) {
if(rand_effectiveness) {
focus_max = CalcBotFocusEffect(bottype, TempItemAug->Focus.Effect, spell_id, true);
@@ -4749,13 +4749,13 @@ float Bot::GetProcChances(float ProcBonus, uint16 hand) {
float ProcChance = 0.0f;
uint32 weapon_speed = 0;
switch (hand) {
case EQEmu::legacy::SlotPrimary:
case EQEmu::inventory::slotPrimary:
weapon_speed = attack_timer.GetDuration();
break;
case EQEmu::legacy::SlotSecondary:
case EQEmu::inventory::slotSecondary:
weapon_speed = attack_dw_timer.GetDuration();
break;
case EQEmu::legacy::SlotRange:
case EQEmu::inventory::slotRange:
weapon_speed = ranged_timer.GetDuration();
break;
}
@@ -4781,7 +4781,7 @@ int Bot::GetHandToHandDamage(void) {
// everyone uses this in the revamp!
int skill = GetSkill(EQEmu::skills::SkillHandtoHand);
int epic = 0;
if (CastToNPC()->GetEquipment(EQEmu::textures::TextureHands) == 10652 && GetLevel() > 46)
if (CastToNPC()->GetEquipment(EQEmu::textures::armorHands) == 10652 && GetLevel() > 46)
epic = 280;
if (epic > skill)
skill = epic;
@@ -4803,7 +4803,7 @@ int Bot::GetHandToHandDamage(void) {
9, 9, 9, 9, 9, 10, 10, 10, 10, 10, // 31-40
10, 11, 11, 11, 11, 11, 11, 12, 12}; // 41-49
if (GetClass() == MONK) {
if (CastToNPC()->GetEquipment(EQEmu::textures::TextureHands) == 10652 && GetLevel() > 50)
if (CastToNPC()->GetEquipment(EQEmu::textures::armorHands) == 10652 && GetLevel() > 50)
return 9;
if (level > 62)
return 15;
@@ -4842,11 +4842,11 @@ void Bot::DoRiposte(Mob* defender) {
if (!defender)
return;
defender->Attack(this, EQEmu::legacy::SlotPrimary, true);
defender->Attack(this, EQEmu::inventory::slotPrimary, true);
int32 DoubleRipChance = (defender->GetAABonuses().GiveDoubleRiposte[0] + defender->GetSpellBonuses().GiveDoubleRiposte[0] + defender->GetItemBonuses().GiveDoubleRiposte[0]);
if(DoubleRipChance && (DoubleRipChance >= zone->random.Int(0, 100))) {
Log.Out(Logs::Detail, Logs::Combat, "Preforming a double riposte (%d percent chance)", DoubleRipChance);
defender->Attack(this, EQEmu::legacy::SlotPrimary, true);
defender->Attack(this, EQEmu::inventory::slotPrimary, true);
}
DoubleRipChance = defender->GetAABonuses().GiveDoubleRiposte[1];
@@ -4864,8 +4864,8 @@ void Bot::DoSpecialAttackDamage(Mob *who, EQEmu::skills::SkillType skill, int32
hate = hate_override;
if (skill == EQEmu::skills::SkillBash) {
const ItemInst* inst = GetBotItem(EQEmu::legacy::SlotSecondary);
const EQEmu::ItemBase* botweapon = 0;
const EQEmu::ItemInstance* inst = GetBotItem(EQEmu::inventory::slotSecondary);
const EQEmu::ItemData* botweapon = 0;
if(inst)
botweapon = inst->GetItem();
@@ -4878,14 +4878,14 @@ void Bot::DoSpecialAttackDamage(Mob *who, EQEmu::skills::SkillType skill, int32
}
min_damage += (min_damage * GetMeleeMinDamageMod_SE(skill) / 100);
int hand = EQEmu::legacy::SlotPrimary;
int hand = EQEmu::inventory::slotPrimary;
if (skill == EQEmu::skills::SkillThrowing || skill == EQEmu::skills::SkillArchery)
hand = EQEmu::legacy::SlotRange;
hand = EQEmu::inventory::slotRange;
if (who->AvoidDamage(this, max_damage, hand)) {
if (max_damage == -3)
DoRiposte(who);
} else {
if (HitChance || who->CheckHitChance(this, skill, EQEmu::legacy::SlotPrimary)) {
if (HitChance || who->CheckHitChance(this, skill, EQEmu::inventory::slotPrimary)) {
who->MeleeMitigation(this, max_damage, min_damage);
ApplyMeleeDamageBonus(skill, max_damage);
max_damage += who->GetFcDamageAmtIncoming(this, 0, true, skill);
@@ -4929,8 +4929,8 @@ void Bot::TryBackstab(Mob *other, int ReuseTime) {
bool bIsBehind = false;
bool bCanFrontalBS = false;
const ItemInst* inst = GetBotItem(EQEmu::legacy::SlotPrimary);
const EQEmu::ItemBase* botpiercer = nullptr;
const EQEmu::ItemInstance* inst = GetBotItem(EQEmu::inventory::slotPrimary);
const EQEmu::ItemData* botpiercer = nullptr;
if(inst)
botpiercer = inst->GetItem();
@@ -4979,7 +4979,7 @@ void Bot::TryBackstab(Mob *other, int ReuseTime) {
}
}
else
Attack(other, EQEmu::legacy::SlotPrimary);
Attack(other, EQEmu::inventory::slotPrimary);
}
void Bot::RogueBackstab(Mob* other, bool min_damage, int ReuseTime) {
@@ -4989,12 +4989,12 @@ void Bot::RogueBackstab(Mob* other, bool min_damage, int ReuseTime) {
int32 hate = 0;
int32 primaryweapondamage = 0;
int32 backstab_dmg = 0;
ItemInst* botweaponInst = GetBotItem(EQEmu::legacy::SlotPrimary);
EQEmu::ItemInstance* botweaponInst = GetBotItem(EQEmu::inventory::slotPrimary);
if(botweaponInst) {
primaryweapondamage = GetWeaponDamage(other, botweaponInst);
backstab_dmg = botweaponInst->GetItem()->BackstabDmg;
for (int i = AUG_INDEX_BEGIN; i < EQEmu::legacy::ITEM_COMMON_SIZE; ++i) {
ItemInst *aug = botweaponInst->GetAugment(i);
for (int i = EQEmu::inventory::socketBegin; i < EQEmu::inventory::SocketCount; ++i) {
EQEmu::ItemInstance *aug = botweaponInst->GetAugment(i);
if(aug)
backstab_dmg += aug->GetItem()->BackstabDmg;
}
@@ -5037,7 +5037,7 @@ void Bot::RogueBackstab(Mob* other, bool min_damage, int ReuseTime) {
}
void Bot::RogueAssassinate(Mob* other) {
ItemInst* botweaponInst = GetBotItem(EQEmu::legacy::SlotPrimary);
EQEmu::ItemInstance* botweaponInst = GetBotItem(EQEmu::inventory::slotPrimary);
if(botweaponInst) {
if(GetWeaponDamage(other, botweaponInst))
other->Damage(this, 32000, SPELL_UNKNOWN, EQEmu::skills::SkillBackstab);
@@ -5103,7 +5103,7 @@ void Bot::DoClassAttacks(Mob *target, bool IsRiposte) {
case WARRIOR:
if(level >= RuleI(Combat, NPCBashKickLevel)){
bool canBash = false;
if ((GetRace() == OGRE || GetRace() == TROLL || GetRace() == BARBARIAN) || (m_inv.GetItem(EQEmu::legacy::SlotSecondary) && m_inv.GetItem(EQEmu::legacy::SlotSecondary)->GetItem()->ItemType == EQEmu::item::ItemTypeShield) || (m_inv.GetItem(EQEmu::legacy::SlotPrimary) && m_inv.GetItem(EQEmu::legacy::SlotPrimary)->GetItem()->IsType2HWeapon() && GetAA(aa2HandBash) >= 1))
if ((GetRace() == OGRE || GetRace() == TROLL || GetRace() == BARBARIAN) || (m_inv.GetItem(EQEmu::inventory::slotSecondary) && m_inv.GetItem(EQEmu::inventory::slotSecondary)->GetItem()->ItemType == EQEmu::item::ItemTypeShield) || (m_inv.GetItem(EQEmu::inventory::slotPrimary) && m_inv.GetItem(EQEmu::inventory::slotPrimary)->GetItem()->IsType2HWeapon() && GetAA(aa2HandBash) >= 1))
canBash = true;
if(!canBash || zone->random.Int(0, 100) > 25)
@@ -5122,7 +5122,7 @@ void Bot::DoClassAttacks(Mob *target, bool IsRiposte) {
case SHADOWKNIGHT:
case PALADIN:
if(level >= RuleI(Combat, NPCBashKickLevel)){
if ((GetRace() == OGRE || GetRace() == TROLL || GetRace() == BARBARIAN) || (m_inv.GetItem(EQEmu::legacy::SlotSecondary) && m_inv.GetItem(EQEmu::legacy::SlotSecondary)->GetItem()->ItemType == EQEmu::item::ItemTypeShield) || (m_inv.GetItem(EQEmu::legacy::SlotPrimary) && m_inv.GetItem(EQEmu::legacy::SlotPrimary)->GetItem()->IsType2HWeapon() && GetAA(aa2HandBash) >= 1))
if ((GetRace() == OGRE || GetRace() == TROLL || GetRace() == BARBARIAN) || (m_inv.GetItem(EQEmu::inventory::slotSecondary) && m_inv.GetItem(EQEmu::inventory::slotSecondary)->GetItem()->ItemType == EQEmu::item::ItemTypeShield) || (m_inv.GetItem(EQEmu::inventory::slotPrimary) && m_inv.GetItem(EQEmu::inventory::slotPrimary)->GetItem()->IsType2HWeapon() && GetAA(aa2HandBash) >= 1))
skill_to_use = EQEmu::skills::SkillBash;
}
break;
@@ -5151,7 +5151,7 @@ void Bot::DoClassAttacks(Mob *target, bool IsRiposte) {
if (skill_to_use == EQEmu::skills::SkillBash) {
if (target != this) {
DoAnim(animTailRake);
if (GetWeaponDamage(target, GetBotItem(EQEmu::legacy::SlotSecondary)) <= 0 && GetWeaponDamage(target, GetBotItem(EQEmu::legacy::SlotShoulders)) <= 0)
if (GetWeaponDamage(target, GetBotItem(EQEmu::inventory::slotSecondary)) <= 0 && GetWeaponDamage(target, GetBotItem(EQEmu::inventory::slotShoulders)) <= 0)
dmg = -5;
else {
if (!target->CheckHitChance(this, EQEmu::skills::SkillBash, 0))
@@ -5201,7 +5201,7 @@ void Bot::DoClassAttacks(Mob *target, bool IsRiposte) {
if (skill_to_use == EQEmu::skills::SkillKick) {
if(target != this) {
DoAnim(animKick);
if (GetWeaponDamage(target, GetBotItem(EQEmu::legacy::SlotFeet)) <= 0)
if (GetWeaponDamage(target, GetBotItem(EQEmu::inventory::slotFeet)) <= 0)
dmg = -5;
else {
if (!target->CheckHitChance(this, EQEmu::skills::SkillKick, 0))
@@ -5366,8 +5366,8 @@ bool Bot::IsBotAttackAllowed(Mob* attacker, Mob* target, bool& hasRuleDefined) {
void Bot::EquipBot(std::string* errorMessage) {
GetBotItems(m_inv, errorMessage);
const ItemInst* inst = 0;
const EQEmu::ItemBase* item = 0;
const EQEmu::ItemInstance* inst = 0;
const EQEmu::ItemData* item = 0;
for (int i = EQEmu::legacy::EQUIPMENT_BEGIN; i <= EQEmu::legacy::EQUIPMENT_END; ++i) {
inst = GetBotItem(i);
if(inst) {
@@ -5494,23 +5494,23 @@ void Bot::SetAttackTimer() {
float haste_mod = (GetHaste() * 0.01f);
attack_timer.SetAtTrigger(4000, true);
Timer* TimerToUse = nullptr;
const EQEmu::ItemBase* PrimaryWeapon = nullptr;
for (int i = EQEmu::legacy::SlotRange; i <= EQEmu::legacy::SlotSecondary; i++) {
if (i == EQEmu::legacy::SlotPrimary)
const EQEmu::ItemData* PrimaryWeapon = nullptr;
for (int i = EQEmu::inventory::slotRange; i <= EQEmu::inventory::slotSecondary; i++) {
if (i == EQEmu::inventory::slotPrimary)
TimerToUse = &attack_timer;
else if (i == EQEmu::legacy::SlotRange)
else if (i == EQEmu::inventory::slotRange)
TimerToUse = &ranged_timer;
else if (i == EQEmu::legacy::SlotSecondary)
else if (i == EQEmu::inventory::slotSecondary)
TimerToUse = &attack_dw_timer;
else
continue;
const EQEmu::ItemBase* ItemToUse = nullptr;
ItemInst* ci = GetBotItem(i);
const EQEmu::ItemData* ItemToUse = nullptr;
EQEmu::ItemInstance* ci = GetBotItem(i);
if (ci)
ItemToUse = ci->GetItem();
if (i == EQEmu::legacy::SlotSecondary) {
if (i == EQEmu::inventory::slotSecondary) {
if (PrimaryWeapon != nullptr) {
if (PrimaryWeapon->IsClassCommon() && PrimaryWeapon->IsType2HWeapon()) {
attack_dw_timer.Disable();
@@ -5541,7 +5541,7 @@ void Bot::SetAttackTimer() {
speed = (RuleB(Spells, Jun182014HundredHandsRevamp) ? static_cast<int>(((delay / haste_mod) + ((hhe / 1000.0f) * (delay / haste_mod))) * 100) : static_cast<int>(((delay / haste_mod) + ((hhe / 100.0f) * delay)) * 100));
TimerToUse->SetAtTrigger(std::max(RuleI(Combat, MinHastedDelay), speed), true);
if (i == EQEmu::legacy::SlotPrimary)
if (i == EQEmu::inventory::slotPrimary)
PrimaryWeapon = ItemToUse;
}
}
@@ -7180,13 +7180,13 @@ void Bot::ProcessBotInspectionRequest(Bot* inspectedBot, Client* client) {
insr->TargetID = inspectedBot->GetNPCTypeID();
insr->playerid = inspectedBot->GetID();
const EQEmu::ItemBase* item = 0;
const ItemInst* inst = 0;
const EQEmu::ItemData* item = 0;
const EQEmu::ItemInstance* inst = 0;
// Modded to display power source items (will only show up on SoF+ client inspect windows though.)
// I don't think bots are currently coded to use them..but, you'll have to use '#bot inventory list'
// to see them on a Titanium client when/if they are activated.
for (int16 L = EQEmu::legacy::EQUIPMENT_BEGIN; L <= EQEmu::legacy::SlotWaist; L++) {
for (int16 L = EQEmu::legacy::EQUIPMENT_BEGIN; L <= EQEmu::inventory::slotWaist; L++) {
inst = inspectedBot->GetBotItem(L);
if(inst) {
@@ -7200,7 +7200,7 @@ void Bot::ProcessBotInspectionRequest(Bot* inspectedBot, Client* client) {
}
}
inst = inspectedBot->GetBotItem(EQEmu::legacy::SlotPowerSource);
inst = inspectedBot->GetBotItem(EQEmu::inventory::slotPowerSource);
if(inst) {
item = inst->GetItem();
@@ -7212,7 +7212,7 @@ void Bot::ProcessBotInspectionRequest(Bot* inspectedBot, Client* client) {
insr->itemicons[SoF::invslot::PossessionsPowerSource] = 0xFFFFFFFF;
}
inst = inspectedBot->GetBotItem(EQEmu::legacy::SlotAmmo);
inst = inspectedBot->GetBotItem(EQEmu::inventory::slotAmmo);
if(inst) {
item = inst->GetItem();
@@ -7232,10 +7232,10 @@ void Bot::ProcessBotInspectionRequest(Bot* inspectedBot, Client* client) {
void Bot::CalcItemBonuses(StatBonuses* newbon)
{
const EQEmu::ItemBase* itemtmp = 0;
const EQEmu::ItemData* itemtmp = 0;
for (int i = EQEmu::legacy::EQUIPMENT_BEGIN; i <= (EQEmu::legacy::EQUIPMENT_END + 1); ++i) {
const ItemInst* item = GetBotItem((i == 22 ? 9999 : i));
const EQEmu::ItemInstance* item = GetBotItem((i == 22 ? 9999 : i));
if(item) {
AddItemBonuses(item, newbon);
}
@@ -7252,7 +7252,7 @@ void Bot::CalcItemBonuses(StatBonuses* newbon)
newbon->EnduranceRegen = CalcEnduranceRegenCap();
}
void Bot::AddItemBonuses(const ItemInst *inst, StatBonuses* newbon, bool isAug, bool isTribute, int rec_override) {
void Bot::AddItemBonuses(const EQEmu::ItemInstance *inst, StatBonuses* newbon, bool isAug, bool isTribute, int rec_override) {
if (!inst || !inst->IsClassCommon())
{
return;
@@ -7263,7 +7263,7 @@ void Bot::AddItemBonuses(const ItemInst *inst, StatBonuses* newbon, bool isAug,
return;
}
const EQEmu::ItemBase *item = inst->GetItem();
const EQEmu::ItemData *item = inst->GetItem();
if(!isTribute && !inst->IsEquipable(GetBaseRace(),GetClass()))
{
@@ -7547,7 +7547,7 @@ void Bot::AddItemBonuses(const ItemInst *inst, StatBonuses* newbon, bool isAug,
if (!isAug)
{
for (int i = 0; i < EQEmu::legacy::ITEM_COMMON_SIZE; i++)
for (int i = EQEmu::inventory::socketBegin; i < EQEmu::inventory::SocketCount; i++)
AddItemBonuses(inst->GetAugment(i),newbon,true, false, rec_level);
}
@@ -7630,7 +7630,7 @@ void Bot::CalcBotStats(bool showtext) {
}
}
bool Bot::CheckLoreConflict(const EQEmu::ItemBase* item) {
bool Bot::CheckLoreConflict(const EQEmu::ItemData* item) {
if (!item || !(item->LoreFlag))
return false;
@@ -8036,12 +8036,12 @@ uint8 Bot::GetNumberNeedingHealedInGroup(uint8 hpr, bool includePets) {
int Bot::GetRawACNoShield(int &shield_ac) {
int ac = itembonuses.AC + spellbonuses.AC;
shield_ac = 0;
ItemInst* inst = GetBotItem(EQEmu::legacy::SlotSecondary);
EQEmu::ItemInstance* inst = GetBotItem(EQEmu::inventory::slotSecondary);
if(inst) {
if (inst->GetItem()->ItemType == EQEmu::item::ItemTypeShield) {
ac -= inst->GetItem()->AC;
shield_ac = inst->GetItem()->AC;
for (uint8 i = AUG_INDEX_BEGIN; i < EQEmu::legacy::ITEM_COMMON_SIZE; i++) {
for (uint8 i = EQEmu::inventory::socketBegin; i < EQEmu::inventory::SocketCount; i++) {
if(inst->GetAugment(i)) {
ac -= inst->GetAugment(i)->GetItem()->AC;
shield_ac += inst->GetAugment(i)->GetItem()->AC;
@@ -8053,8 +8053,8 @@ int Bot::GetRawACNoShield(int &shield_ac) {
}
uint32 Bot::CalcCurrentWeight() {
const EQEmu::ItemBase* TempItem = 0;
ItemInst* inst;
const EQEmu::ItemData* TempItem = 0;
EQEmu::ItemInstance* inst;
uint32 Total = 0;
for (int i = EQEmu::legacy::EQUIPMENT_BEGIN; i <= EQEmu::legacy::EQUIPMENT_END; ++i) {
inst = GetBotItem(i);
@@ -8433,9 +8433,9 @@ bool Bot::DyeArmor(int16 slot_id, uint32 rgb, bool all_flag, bool save_flag)
if (slot_id != INVALID_INDEX)
return false;
for (uint8 i = 0; i < EQEmu::textures::TexturePrimary; ++i) {
uint8 inv_slot = Inventory::CalcSlotFromMaterial(i);
ItemInst* inst = m_inv.GetItem(inv_slot);
for (uint8 i = EQEmu::textures::textureBegin; i < EQEmu::textures::weaponPrimary; ++i) {
uint8 inv_slot = EQEmu::InventoryProfile::CalcSlotFromMaterial(i);
EQEmu::ItemInstance* inst = m_inv.GetItem(inv_slot);
if (!inst)
continue;
@@ -8444,11 +8444,11 @@ bool Bot::DyeArmor(int16 slot_id, uint32 rgb, bool all_flag, bool save_flag)
}
}
else {
uint8 mat_slot = Inventory::CalcMaterialFromSlot(slot_id);
if (mat_slot == EQEmu::textures::TextureInvalid || mat_slot >= EQEmu::textures::TexturePrimary)
uint8 mat_slot = EQEmu::InventoryProfile::CalcMaterialFromSlot(slot_id);
if (mat_slot == EQEmu::textures::materialInvalid || mat_slot >= EQEmu::textures::weaponPrimary)
return false;
ItemInst* inst = m_inv.GetItem(slot_id);
EQEmu::ItemInstance* inst = m_inv.GetItem(slot_id);
if (!inst)
return false;
zone/bot.h
+9 -9
View File
@@ -77,7 +77,7 @@ static const std::string bot_stance_name[BOT_STANCE_COUNT] = {
static const char* GetBotStanceName(int stance_id) { return bot_stance_name[VALIDBOTSTANCE(stance_id)].c_str(); }
#define VALIDBOTEQUIPSLOT(x) ((x >= EQEmu::legacy::EQUIPMENT_BEGIN && x <= EQEmu::legacy::EQUIPMENT_END) ? (x) : ((x == EQEmu::legacy::SlotPowerSource) ? (22) : (23)))
#define VALIDBOTEQUIPSLOT(x) ((x >= EQEmu::legacy::EQUIPMENT_BEGIN && x <= EQEmu::legacy::EQUIPMENT_END) ? (x) : ((x == EQEmu::inventory::slotPowerSource) ? (22) : (23)))
static std::string bot_equip_slot_name[EQEmu::legacy::EQUIPMENT_SIZE + 2] =
{
@@ -207,7 +207,7 @@ public:
//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, int special = 0);
virtual bool Attack(Mob* other, int Hand = EQEmu::legacy::SlotPrimary, bool FromRiposte = false, bool IsStrikethrough = false, bool IsFromSpell = false,
virtual bool Attack(Mob* other, int Hand = EQEmu::inventory::slotPrimary, bool FromRiposte = false, bool IsStrikethrough = false, bool IsFromSpell = false,
ExtraAttackOptions *opts = nullptr, int special = 0);
virtual bool HasRaid() { return (GetRaid() ? true : false); }
virtual bool HasGroup() { return (GetGroup() ? true : false); }
@@ -260,7 +260,7 @@ public:
virtual int32 CheckAggroAmount(uint16 spellid);
virtual void CalcBonuses();
void CalcItemBonuses(StatBonuses* newbon);
void AddItemBonuses(const ItemInst *inst, StatBonuses* newbon, bool isAug = false, bool isTribute = false, int rec_override = 0);
void AddItemBonuses(const EQEmu::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);
@@ -382,10 +382,10 @@ public:
virtual bool DoCastSpell(uint16 spell_id, uint16 target_id, EQEmu::CastingSlot slot = EQEmu::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 ItemInst* inst, const ItemInst* inst_swap, uint32 equipableSlots, std::string* errorMessage, bool swap = true);
void BotTradeAddItem(uint32 id, const ItemInst* inst, int16 charges, uint32 equipableSlots, uint16 lootSlot, std::string* errorMessage, bool addToDb = true);
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 EquipBot(std::string* errorMessage);
bool CheckLoreConflict(const EQEmu::ItemBase* item);
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]); }
// Static Class Methods
@@ -457,7 +457,7 @@ public:
uint32 GetBotSpellID() { return npc_spells_id; }
Mob* GetBotOwner() { return this->_botOwner; }
uint32 GetBotArcheryRange();
ItemInst* GetBotItem(uint32 slotID);
EQEmu::ItemInstance* GetBotItem(uint32 slotID);
virtual bool GetSpawnStatus() { return _spawnStatus; }
uint8 GetPetChooserID() { return _petChooserID; }
bool IsPetChooser() { return _petChooser; }
@@ -647,7 +647,7 @@ private:
bool _petChooser;
uint8 _petChooserID;
bool berserk;
Inventory m_inv;
EQEmu::InventoryProfile m_inv;
double _lastTotalPlayTime;
time_t _startTotalPlayTime;
Mob* _previousTarget;
@@ -711,7 +711,7 @@ private:
void SetBotID(uint32 botID);
// Private "Inventory" Methods
void GetBotItems(Inventory &inv, std::string* errorMessage);
void GetBotItems(EQEmu::InventoryProfile &inv, std::string* errorMessage);
void BotAddEquipItem(int slot, uint32 id);
uint32 GetBotItemBySlot(uint32 slotID);
zone/bot_command.cpp
+53 -48
View File
@@ -2402,7 +2402,7 @@ namespace ActionableBots
mod_skill_value = base_skill_value;
for (int16 index = EQEmu::legacy::EQUIPMENT_BEGIN; index <= EQEmu::legacy::EQUIPMENT_END; ++index) {
const ItemInst* indexed_item = bot_iter->GetBotItem(index);
const EQEmu::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));
}
@@ -3397,15 +3397,18 @@ void bot_command_movement_speed(Client *c, const Seperator *sep)
if (helper_spell_list_fail(c, local_list, BCEnum::SpT_MovementSpeed) || helper_command_alias_fail(c, "bot_command_movement_speed", sep->arg[0], "movementspeed"))
return;
if (helper_is_help_or_usage(sep->arg[1])) {
c->Message(m_usage, "usage: (<friendly_target>) %s ([group])", sep->arg[0]);
c->Message(m_usage, "usage: (<friendly_target>) %s ([group | sow])", sep->arg[0]);
helper_send_usage_required_bots(c, BCEnum::SpT_MovementSpeed);
return;
}
bool group = false;
std::string group_arg = sep->arg[1];
if (!group_arg.compare("group"))
bool sow = false;
std::string arg1 = sep->arg[1];
if (!arg1.compare("group"))
group = true;
else if (!arg1.compare("sow"))
sow = true;
ActionableTarget::Types actionable_targets;
Bot* my_bot = nullptr;
@@ -3417,7 +3420,9 @@ void bot_command_movement_speed(Client *c, const Seperator *sep)
auto local_entry = list_iter->SafeCastToMovementSpeed();
if (helper_spell_check_fail(local_entry))
continue;
if (local_entry->group != group)
if (!sow && (local_entry->group != group))
continue;
if (sow && (local_entry->spell_id != 278)) // '278' = single-target "Spirit of Wolf"
continue;
auto target_mob = actionable_targets.Select(c, local_entry->target_type, FRIENDLY);
@@ -4358,7 +4363,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::TextureHead, EQEmu::textures::TextureChest, EQEmu::textures::TextureArms, EQEmu::textures::TextureWrist, EQEmu::textures::TextureHands, EQEmu::textures::TextureLegs, EQEmu::textures::TextureFeet);
'*', EQEmu::textures::armorHead, EQEmu::textures::armorChest, EQEmu::textures::armorArms, EQEmu::textures::armorWrist, EQEmu::textures::armorHands, EQEmu::textures::armorLegs, EQEmu::textures::armorFeet);
if (helper_command_alias_fail(c, "bot_subcommand_bot_dye_armor", sep->arg[0], "botdyearmor"))
return;
@@ -4369,15 +4374,15 @@ void bot_subcommand_bot_dye_armor(Client *c, const Seperator *sep)
}
const int ab_mask = ActionableBots::ABM_NoFilter;
uint8 material_slot = EQEmu::textures::TextureInvalid;
uint8 material_slot = EQEmu::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 = Inventory::CalcSlotFromMaterial(material_slot);
slot_id = EQEmu::InventoryProfile::CalcSlotFromMaterial(material_slot);
if (!sep->IsNumber(1) || slot_id == INVALID_INDEX || material_slot > EQEmu::textures::TextureFeet) {
if (!sep->IsNumber(1) || slot_id == INVALID_INDEX || material_slot > EQEmu::textures::LastTintableTexture) {
c->Message(m_fail, "Valid [mat_slot]s for this command are:");
c->Message(m_fail, msg_matslot.c_str());
return;
@@ -7062,8 +7067,8 @@ void bot_subcommand_inventory_list(Client *c, const Seperator *sep)
return;
}
const ItemInst* inst = nullptr;
const EQEmu::ItemBase* item = nullptr;
const EQEmu::ItemInstance* inst = nullptr;
const EQEmu::ItemData* item = nullptr;
bool is2Hweapon = false;
std::string item_link;
@@ -7072,23 +7077,23 @@ void bot_subcommand_inventory_list(Client *c, const Seperator *sep)
uint32 inventory_count = 0;
for (int i = EQEmu::legacy::EQUIPMENT_BEGIN; i <= (EQEmu::legacy::EQUIPMENT_END + 1); ++i) {
if ((i == EQEmu::legacy::SlotSecondary) && is2Hweapon)
if ((i == EQEmu::inventory::slotSecondary) && is2Hweapon)
continue;
inst = my_bot->CastToBot()->GetBotItem(i == 22 ? EQEmu::legacy::SlotPowerSource : i);
inst = my_bot->CastToBot()->GetBotItem(i == 22 ? EQEmu::inventory::slotPowerSource : i);
if (!inst || !inst->GetItem()) {
c->Message(m_message, "I need something for my %s (slot %i)", GetBotEquipSlotName(i), (i == 22 ? EQEmu::legacy::SlotPowerSource : i));
c->Message(m_message, "I need something for my %s (slot %i)", GetBotEquipSlotName(i), (i == 22 ? EQEmu::inventory::slotPowerSource : i));
continue;
}
item = inst->GetItem();
if ((i == EQEmu::legacy::SlotPrimary) && item->IsType2HWeapon()) {
if ((i == EQEmu::inventory::slotPrimary) && item->IsType2HWeapon()) {
is2Hweapon = true;
}
linker.SetItemInst(inst);
item_link = linker.GenerateLink();
c->Message(m_message, "Using %s in my %s (slot %i)", item_link.c_str(), GetBotEquipSlotName(i), (i == 22 ? EQEmu::legacy::SlotPowerSource : i));
c->Message(m_message, "Using %s in my %s (slot %i)", item_link.c_str(), GetBotEquipSlotName(i), (i == 22 ? EQEmu::inventory::slotPowerSource : i));
++inventory_count;
}
@@ -7127,13 +7132,13 @@ void bot_subcommand_inventory_remove(Client *c, const Seperator *sep)
}
int slotId = atoi(sep->arg[1]);
if (!sep->IsNumber(1) || ((slotId > EQEmu::legacy::EQUIPMENT_END || slotId < EQEmu::legacy::EQUIPMENT_BEGIN) && slotId != EQEmu::legacy::SlotPowerSource)) {
if (!sep->IsNumber(1) || ((slotId > EQEmu::legacy::EQUIPMENT_END || slotId < EQEmu::legacy::EQUIPMENT_BEGIN) && slotId != EQEmu::inventory::slotPowerSource)) {
c->Message(m_fail, "Valid slots are 0-21 or 9999");
return;
}
const EQEmu::ItemBase* itm = nullptr;
const ItemInst* itminst = my_bot->GetBotItem(slotId);
const EQEmu::ItemData* itm = nullptr;
const EQEmu::ItemInstance* itminst = my_bot->GetBotItem(slotId);
if (itminst)
itm = itminst->GetItem();
@@ -7142,11 +7147,11 @@ void bot_subcommand_inventory_remove(Client *c, const Seperator *sep)
return;
}
for (int m = AUG_INDEX_BEGIN; m < EQEmu::legacy::ITEM_COMMON_SIZE; ++m) {
for (int m = EQEmu::inventory::socketBegin; m < EQEmu::inventory::SocketCount; ++m) {
if (!itminst)
break;
ItemInst *itma = itminst->GetAugment(m);
EQEmu::ItemInstance *itma = itminst->GetAugment(m);
if (!itma)
continue;
if (!c->CheckLoreConflict(itma->GetItem()))
@@ -7159,7 +7164,7 @@ void bot_subcommand_inventory_remove(Client *c, const Seperator *sep)
std::string error_message;
if (itm) {
c->PushItemOnCursor(*itminst, true);
if ((slotId == EQEmu::legacy::SlotRange) || (slotId == EQEmu::legacy::SlotAmmo) || (slotId == EQEmu::legacy::SlotPrimary) || (slotId == EQEmu::legacy::SlotSecondary))
if ((slotId == EQEmu::inventory::slotRange) || (slotId == EQEmu::inventory::slotAmmo) || (slotId == EQEmu::inventory::slotPrimary) || (slotId == EQEmu::inventory::slotSecondary))
my_bot->SetBotArcher(false);
my_bot->RemoveBotItemBySlot(slotId, &error_message);
@@ -7173,31 +7178,31 @@ void bot_subcommand_inventory_remove(Client *c, const Seperator *sep)
}
switch (slotId) {
case EQEmu::legacy::SlotCharm:
case EQEmu::legacy::SlotEar1:
case EQEmu::legacy::SlotHead:
case EQEmu::legacy::SlotFace:
case EQEmu::legacy::SlotEar2:
case EQEmu::legacy::SlotNeck:
case EQEmu::legacy::SlotBack:
case EQEmu::legacy::SlotWrist1:
case EQEmu::legacy::SlotWrist2:
case EQEmu::legacy::SlotRange:
case EQEmu::legacy::SlotPrimary:
case EQEmu::legacy::SlotSecondary:
case EQEmu::legacy::SlotFinger1:
case EQEmu::legacy::SlotFinger2:
case EQEmu::legacy::SlotChest:
case EQEmu::legacy::SlotWaist:
case EQEmu::legacy::SlotPowerSource:
case EQEmu::legacy::SlotAmmo:
case EQEmu::inventory::slotCharm:
case EQEmu::inventory::slotEar1:
case EQEmu::inventory::slotHead:
case EQEmu::inventory::slotFace:
case EQEmu::inventory::slotEar2:
case EQEmu::inventory::slotNeck:
case EQEmu::inventory::slotBack:
case EQEmu::inventory::slotWrist1:
case EQEmu::inventory::slotWrist2:
case EQEmu::inventory::slotRange:
case EQEmu::inventory::slotPrimary:
case EQEmu::inventory::slotSecondary:
case EQEmu::inventory::slotFinger1:
case EQEmu::inventory::slotFinger2:
case EQEmu::inventory::slotChest:
case EQEmu::inventory::slotWaist:
case EQEmu::inventory::slotPowerSource:
case EQEmu::inventory::slotAmmo:
c->Message(m_message, "My %s is %s unequipped", GetBotEquipSlotName(slotId), ((itm) ? ("now") : ("already")));
break;
case EQEmu::legacy::SlotShoulders:
case EQEmu::legacy::SlotArms:
case EQEmu::legacy::SlotHands:
case EQEmu::legacy::SlotLegs:
case EQEmu::legacy::SlotFeet:
case EQEmu::inventory::slotShoulders:
case EQEmu::inventory::slotArms:
case EQEmu::inventory::slotHands:
case EQEmu::inventory::slotLegs:
case EQEmu::inventory::slotFeet:
c->Message(m_message, "My %s are %s unequipped", GetBotEquipSlotName(slotId), ((itm) ? ("now") : ("already")));
break;
default:
@@ -7235,13 +7240,13 @@ void bot_subcommand_inventory_window(Client *c, const Seperator *sep)
//linker.SetLinkType(linker.linkItemInst);
for (int i = EQEmu::legacy::EQUIPMENT_BEGIN; i <= (EQEmu::legacy::EQUIPMENT_END + 1); ++i) {
const EQEmu::ItemBase* item = nullptr;
const ItemInst* inst = my_bot->CastToBot()->GetBotItem(i == 22 ? EQEmu::legacy::SlotPowerSource : i);
const EQEmu::ItemData* item = nullptr;
const EQEmu::ItemInstance* inst = my_bot->CastToBot()->GetBotItem(i == 22 ? EQEmu::inventory::slotPowerSource : i);
if (inst)
item = inst->GetItem();
window_text.append("<c \"#FFFFFF\">");
window_text.append(GetBotEquipSlotName(i == 22 ? EQEmu::legacy::SlotPowerSource : i));
window_text.append(GetBotEquipSlotName(i == 22 ? EQEmu::inventory::slotPowerSource : i));
window_text.append(": ");
if (item) {
//window_text.append("</c>");
zone/bot_database.cpp
+15 -15
View File
@@ -1023,7 +1023,7 @@ bool BotDatabase::QueryInventoryCount(const uint32 bot_id, uint32& item_count)
return true;
}
bool BotDatabase::LoadItems(const uint32 bot_id, Inventory& inventory_inst)
bool BotDatabase::LoadItems(const uint32 bot_id, EQEmu::InventoryProfile& inventory_inst)
{
if (!bot_id)
return false;
@@ -1058,13 +1058,13 @@ bool BotDatabase::LoadItems(const uint32 bot_id, Inventory& inventory_inst)
for (auto row = results.begin(); row != results.end(); ++row) {
int16 slot_id = atoi(row[0]);
if ((slot_id < EQEmu::legacy::EQUIPMENT_BEGIN || slot_id > EQEmu::legacy::EQUIPMENT_END) && slot_id != EQEmu::legacy::SlotPowerSource)
if ((slot_id < EQEmu::legacy::EQUIPMENT_BEGIN || slot_id > EQEmu::legacy::EQUIPMENT_END) && slot_id != EQEmu::inventory::slotPowerSource)
continue;
uint32 item_id = atoi(row[1]);
uint16 item_charges = (uint16)atoi(row[2]);
ItemInst* item_inst = database.CreateItem(
EQEmu::ItemInstance* item_inst = database.CreateItem(
item_id,
item_charges,
(uint32)atoul(row[9]),
@@ -1093,7 +1093,7 @@ bool BotDatabase::LoadItems(const uint32 bot_id, Inventory& inventory_inst)
if (item_inst->GetItem()->Attuneable) {
if (atoi(row[4]))
item_inst->SetAttuned(true);
else if (((slot_id >= EQEmu::legacy::EQUIPMENT_BEGIN) && (slot_id <= EQEmu::legacy::EQUIPMENT_END) || slot_id == EQEmu::legacy::SlotPowerSource))
else if (((slot_id >= EQEmu::legacy::EQUIPMENT_BEGIN) && (slot_id <= EQEmu::legacy::EQUIPMENT_END) || slot_id == EQEmu::inventory::slotPowerSource))
item_inst->SetAttuned(true);
}
@@ -1161,7 +1161,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::legacy::EQUIPMENT_END && slot_id != EQEmu::legacy::SlotPowerSource))
if (!bot_id || (slot_id > EQEmu::legacy::EQUIPMENT_END && slot_id != EQEmu::inventory::slotPowerSource))
return false;
query = StringFormat("SELECT `item_id` FROM `bot_inventories` WHERE `bot_id` = '%i' AND `slot_id` = '%i' LIMIT 1", bot_id, slot_id);
@@ -1177,9 +1177,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 ItemInst* item_inst)
bool BotDatabase::SaveItemBySlot(Bot* bot_inst, const uint32 slot_id, const EQEmu::ItemInstance* item_inst)
{
if (!bot_inst || !bot_inst->GetBotID() || (slot_id > EQEmu::legacy::EQUIPMENT_END && slot_id != EQEmu::legacy::SlotPowerSource))
if (!bot_inst || !bot_inst->GetBotID() || (slot_id > EQEmu::legacy::EQUIPMENT_END && slot_id != EQEmu::inventory::slotPowerSource))
return false;
if (!DeleteItemBySlot(bot_inst->GetBotID(), slot_id))
@@ -1188,8 +1188,8 @@ bool BotDatabase::SaveItemBySlot(Bot* bot_inst, const uint32 slot_id, const Item
if (!item_inst || !item_inst->GetID())
return true;
uint32 augment_id[] = { 0, 0, 0, 0, 0, 0 };
for (int augment_iter = 0; augment_iter < EQEmu::legacy::ITEM_COMMON_SIZE; ++augment_iter)
uint32 augment_id[EQEmu::inventory::SocketCount] = { 0, 0, 0, 0, 0, 0 };
for (int augment_iter = EQEmu::inventory::socketBegin; augment_iter < EQEmu::inventory::SocketCount; ++augment_iter)
augment_id[augment_iter] = item_inst->GetAugmentItemID(augment_iter);
uint16 item_charges = 0;
@@ -1263,7 +1263,7 @@ bool BotDatabase::SaveItemBySlot(Bot* bot_inst, const uint32 slot_id, const Item
bool BotDatabase::DeleteItemBySlot(const uint32 bot_id, const uint32 slot_id)
{
if (!bot_id || (slot_id > EQEmu::legacy::EQUIPMENT_END && slot_id != EQEmu::legacy::SlotPowerSource))
if (!bot_id || (slot_id > EQEmu::legacy::EQUIPMENT_END && slot_id != EQEmu::inventory::slotPowerSource))
return false;
query = StringFormat("DELETE FROM `bot_inventories` WHERE `bot_id` = '%u' AND `slot_id` = '%u'", bot_id, slot_id);
@@ -1279,7 +1279,7 @@ bool BotDatabase::LoadEquipmentColor(const uint32 bot_id, const uint8 material_s
if (!bot_id)
return false;
int16 slot_id = Inventory::CalcSlotFromMaterial(material_slot_id);
int16 slot_id = EQEmu::InventoryProfile::CalcSlotFromMaterial(material_slot_id);
if (slot_id == INVALID_INDEX)
return false;
@@ -1302,12 +1302,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::legacy::EQUIPMENT_BEGIN || slot_id > EQEmu::legacy::EQUIPMENT_END) && slot_id != EQEmu::legacy::SlotPowerSource && !all_flag)
if ((slot_id < EQEmu::legacy::EQUIPMENT_BEGIN || slot_id > EQEmu::legacy::EQUIPMENT_END) && slot_id != EQEmu::inventory::slotPowerSource && !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::legacy::SlotHead, EQEmu::legacy::SlotArms, EQEmu::legacy::SlotWrist1, EQEmu::legacy::SlotHands, EQEmu::legacy::SlotChest, EQEmu::legacy::SlotLegs, EQEmu::legacy::SlotFeet);
where_clause = StringFormat(" AND `slot_id` IN ('%u', '%u', '%u', '%u', '%u', '%u', '%u')", EQEmu::inventory::slotHead, EQEmu::inventory::slotArms, EQEmu::inventory::slotWrist1, EQEmu::inventory::slotHands, EQEmu::inventory::slotChest, EQEmu::inventory::slotLegs, EQEmu::inventory::slotFeet);
else
where_clause = StringFormat(" AND `slot_id` = '%u'", slot_id);
@@ -1752,7 +1752,7 @@ bool BotDatabase::SaveAllArmorColorBySlot(const uint32 owner_id, const int16 slo
" AND bi.`slot_id` = '%i'",
owner_id,
rgb_value,
EQEmu::legacy::SlotHead, EQEmu::legacy::SlotChest, EQEmu::legacy::SlotArms, EQEmu::legacy::SlotWrist1, EQEmu::legacy::SlotWrist2, EQEmu::legacy::SlotHands, EQEmu::legacy::SlotLegs, EQEmu::legacy::SlotFeet,
EQEmu::inventory::slotHead, EQEmu::inventory::slotChest, EQEmu::inventory::slotArms, EQEmu::inventory::slotWrist1, EQEmu::inventory::slotWrist2, EQEmu::inventory::slotHands, EQEmu::inventory::slotLegs, EQEmu::inventory::slotFeet,
slot_id
);
auto results = QueryDatabase(query);
@@ -1776,7 +1776,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::legacy::SlotHead, EQEmu::legacy::SlotChest, EQEmu::legacy::SlotArms, EQEmu::legacy::SlotWrist1, EQEmu::legacy::SlotWrist2, EQEmu::legacy::SlotHands, EQEmu::legacy::SlotLegs, EQEmu::legacy::SlotFeet
EQEmu::inventory::slotHead, EQEmu::inventory::slotChest, EQEmu::inventory::slotArms, EQEmu::inventory::slotWrist1, EQEmu::inventory::slotWrist2, EQEmu::inventory::slotHands, EQEmu::inventory::slotLegs, EQEmu::inventory::slotFeet
);
auto results = QueryDatabase(query);
if (!results.Success())
zone/bot_database.h
+8 -4
View File
@@ -31,10 +31,14 @@
class Bot;
class ItemInst;
class Inventory;
struct BotsAvailableList;
namespace EQEmu
{
class ItemInstance;
class InventoryProfile;
}
class BotDatabase : public DBcore
{
@@ -85,13 +89,13 @@ public:
/* Bot inventory functions */
bool QueryInventoryCount(const uint32 bot_id, uint32& item_count);
bool LoadItems(const uint32 bot_id, Inventory &inventory_inst);
bool LoadItems(const uint32 bot_id, EQEmu::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 ItemInst* item_inst);
bool SaveItemBySlot(Bot* bot_inst, const uint32 slot_id, const EQEmu::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/client.cpp
+73 -72
View File
@@ -2017,7 +2017,7 @@ void Client::ReadBook(BookRequest_Struct *book) {
out->window = book->window;
if (ClientVersion() >= EQEmu::versions::ClientVersion::SoF)
{
const ItemInst *inst = m_inv[book->invslot];
const EQEmu::ItemInstance *inst = m_inv[book->invslot];
if(inst)
out->type = inst->GetItem()->Book;
else
@@ -2549,7 +2549,7 @@ void Client::SetFeigned(bool in_feigned) {
feigned=in_feigned;
}
void Client::LogMerchant(Client* player, Mob* merchant, uint32 quantity, uint32 price, const EQEmu::ItemBase* item, bool buying)
void Client::LogMerchant(Client* player, Mob* merchant, uint32 quantity, uint32 price, const EQEmu::ItemData* item, bool buying)
{
if(!player || !merchant || !item)
return;
@@ -2796,11 +2796,11 @@ bool Client::BindWound(Mob *bindmob, bool start, bool fail)
}
void Client::SetMaterial(int16 in_slot, uint32 item_id) {
const EQEmu::ItemBase* item = database.GetItem(item_id);
const EQEmu::ItemData* item = database.GetItem(item_id);
if (item && item->IsClassCommon())
{
uint8 matslot = Inventory::CalcMaterialFromSlot(in_slot);
if (matslot != EQEmu::textures::TextureInvalid)
uint8 matslot = EQEmu::InventoryProfile::CalcMaterialFromSlot(in_slot);
if (matslot != EQEmu::textures::materialInvalid)
{
m_pp.item_material.Slot[matslot].Material = GetEquipmentMaterial(matslot);
}
@@ -3132,17 +3132,17 @@ void Client::Tell_StringID(uint32 string_id, const char *who, const char *messag
}
void Client::SetTint(int16 in_slot, uint32 color) {
EQEmu::Tint_Struct new_color;
EQEmu::textures::Tint_Struct new_color;
new_color.Color = color;
SetTint(in_slot, new_color);
database.SaveCharacterMaterialColor(this->CharacterID(), in_slot, color);
}
// Still need to reconcile bracer01 versus bracer02
void Client::SetTint(int16 in_slot, EQEmu::Tint_Struct& color) {
void Client::SetTint(int16 in_slot, EQEmu::textures::Tint_Struct& color) {
uint8 matslot = Inventory::CalcMaterialFromSlot(in_slot);
if (matslot != EQEmu::textures::TextureInvalid)
uint8 matslot = EQEmu::InventoryProfile::CalcMaterialFromSlot(in_slot);
if (matslot != EQEmu::textures::materialInvalid)
{
m_pp.item_tint.Slot[matslot].Color = color.Color;
database.SaveCharacterMaterialColor(this->CharacterID(), in_slot, color.Color);
@@ -3219,28 +3219,28 @@ void Client::LinkDead()
uint8 Client::SlotConvert(uint8 slot,bool bracer){
uint8 slot2 = 0; // why are we returning MainCharm instead of INVALID_INDEX? (must be a pre-charm segment...)
if(bracer)
return EQEmu::legacy::SlotWrist2;
return EQEmu::inventory::slotWrist2;
switch(slot) {
case EQEmu::textures::TextureHead:
slot2 = EQEmu::legacy::SlotHead;
case EQEmu::textures::armorHead:
slot2 = EQEmu::inventory::slotHead;
break;
case EQEmu::textures::TextureChest:
slot2 = EQEmu::legacy::SlotChest;
case EQEmu::textures::armorChest:
slot2 = EQEmu::inventory::slotChest;
break;
case EQEmu::textures::TextureArms:
slot2 = EQEmu::legacy::SlotArms;
case EQEmu::textures::armorArms:
slot2 = EQEmu::inventory::slotArms;
break;
case EQEmu::textures::TextureWrist:
slot2 = EQEmu::legacy::SlotWrist1;
case EQEmu::textures::armorWrist:
slot2 = EQEmu::inventory::slotWrist1;
break;
case EQEmu::textures::TextureHands:
slot2 = EQEmu::legacy::SlotHands;
case EQEmu::textures::armorHands:
slot2 = EQEmu::inventory::slotHands;
break;
case EQEmu::textures::TextureLegs:
slot2 = EQEmu::legacy::SlotLegs;
case EQEmu::textures::armorLegs:
slot2 = EQEmu::inventory::slotLegs;
break;
case EQEmu::textures::TextureFeet:
slot2 = EQEmu::legacy::SlotFeet;
case EQEmu::textures::armorFeet:
slot2 = EQEmu::inventory::slotFeet;
break;
}
return slot2;
@@ -3249,26 +3249,26 @@ uint8 Client::SlotConvert(uint8 slot,bool bracer){
uint8 Client::SlotConvert2(uint8 slot){
uint8 slot2 = 0; // same as above...
switch(slot){
case EQEmu::legacy::SlotHead:
slot2 = EQEmu::textures::TextureHead;
case EQEmu::inventory::slotHead:
slot2 = EQEmu::textures::armorHead;
break;
case EQEmu::legacy::SlotChest:
slot2 = EQEmu::textures::TextureChest;
case EQEmu::inventory::slotChest:
slot2 = EQEmu::textures::armorChest;
break;
case EQEmu::legacy::SlotArms:
slot2 = EQEmu::textures::TextureArms;
case EQEmu::inventory::slotArms:
slot2 = EQEmu::textures::armorArms;
break;
case EQEmu::legacy::SlotWrist1:
slot2 = EQEmu::textures::TextureWrist;
case EQEmu::inventory::slotWrist1:
slot2 = EQEmu::textures::armorWrist;
break;
case EQEmu::legacy::SlotHands:
slot2 = EQEmu::textures::TextureHands;
case EQEmu::inventory::slotHands:
slot2 = EQEmu::textures::armorHands;
break;
case EQEmu::legacy::SlotLegs:
slot2 = EQEmu::textures::TextureLegs;
case EQEmu::inventory::slotLegs:
slot2 = EQEmu::textures::armorLegs;
break;
case EQEmu::legacy::SlotFeet:
slot2 = EQEmu::textures::TextureFeet;
case EQEmu::inventory::slotFeet:
slot2 = EQEmu::textures::armorFeet;
break;
}
return slot2;
@@ -3839,7 +3839,7 @@ void Client::SendOPTranslocateConfirm(Mob *Caster, uint16 SpellID) {
return;
}
void Client::SendPickPocketResponse(Mob *from, uint32 amt, int type, const EQEmu::ItemBase* item){
void Client::SendPickPocketResponse(Mob *from, uint32 amt, int type, const EQEmu::ItemData* item){
auto outapp = new EQApplicationPacket(OP_PickPocket, sizeof(sPickPocket_Struct));
sPickPocket_Struct *pick_out = (sPickPocket_Struct *)outapp->pBuffer;
pick_out->coin = amt;
@@ -4013,7 +4013,7 @@ bool Client::KeyRingCheck(uint32 item_id)
void Client::KeyRingList()
{
Message(4,"Keys on Keyring:");
const EQEmu::ItemBase *item = 0;
const EQEmu::ItemData *item = 0;
for (auto iter = keyring.begin(); iter != keyring.end(); ++iter) {
if ((item = database.GetItem(*iter))!=nullptr) {
Message(4,item->Name);
@@ -4268,14 +4268,14 @@ bool Client::GroupFollow(Client* inviter) {
uint16 Client::GetPrimarySkillValue()
{
EQEmu::skills::SkillType skill = EQEmu::skills::HIGHEST_SKILL; //because nullptr == 0, which is 1H Slashing, & we want it to return 0 from GetSkill
bool equiped = m_inv.GetItem(EQEmu::legacy::SlotPrimary);
bool equiped = m_inv.GetItem(EQEmu::inventory::slotPrimary);
if (!equiped)
skill = EQEmu::skills::SkillHandtoHand;
else {
uint8 type = m_inv.GetItem(EQEmu::legacy::SlotPrimary)->GetItem()->ItemType; //is this the best way to do this?
uint8 type = m_inv.GetItem(EQEmu::inventory::slotPrimary)->GetItem()->ItemType; //is this the best way to do this?
switch (type) {
case EQEmu::item::ItemType1HSlash: // 1H Slashing
@@ -5440,7 +5440,7 @@ bool Client::TryReward(uint32 claim_id)
uint32 free_slot = 0xFFFFFFFF;
for (int i = EQEmu::legacy::GENERAL_BEGIN; i <= EQEmu::legacy::GENERAL_END; ++i) {
ItemInst *item = GetInv().GetItem(i);
EQEmu::ItemInstance *item = GetInv().GetItem(i);
if (!item) {
free_slot = i;
break;
@@ -5486,7 +5486,7 @@ bool Client::TryReward(uint32 claim_id)
}
auto &ivr = (*iter);
ItemInst *claim = database.CreateItem(ivr.items[0].item_id, ivr.items[0].charges);
EQEmu::ItemInstance *claim = database.CreateItem(ivr.items[0].item_id, ivr.items[0].charges);
if (!claim) {
Save();
return true;
@@ -5496,7 +5496,7 @@ bool Client::TryReward(uint32 claim_id)
for (int y = 1; y < 8; y++)
if (ivr.items[y].item_id && claim->GetItem()->ItemClass == 1) {
ItemInst *item_temp = database.CreateItem(ivr.items[y].item_id, ivr.items[y].charges);
EQEmu::ItemInstance *item_temp = database.CreateItem(ivr.items[y].item_id, ivr.items[y].charges);
if (item_temp) {
if (CheckLoreConflict(item_temp->GetItem())) {
lore_conflict = true;
@@ -5756,8 +5756,8 @@ void Client::ProcessInspectRequest(Client* requestee, Client* requester) {
insr->TargetID = requester->GetID();
insr->playerid = requestee->GetID();
const EQEmu::ItemBase* item = nullptr;
const ItemInst* inst = nullptr;
const EQEmu::ItemData* item = nullptr;
const EQEmu::ItemInstance* inst = nullptr;
int ornamentationAugtype = RuleI(Character, OrnamentationAugmentType);
for(int16 L = 0; L <= 20; L++) {
inst = requestee->GetInv().GetItem(L);
@@ -5768,7 +5768,7 @@ void Client::ProcessInspectRequest(Client* requestee, Client* requester) {
strcpy(insr->itemnames[L], item->Name);
if (inst && inst->GetOrnamentationAug(ornamentationAugtype))
{
const EQEmu::ItemBase *aug_item = inst->GetOrnamentationAug(ornamentationAugtype)->GetItem();
const EQEmu::ItemData *aug_item = inst->GetOrnamentationAug(ornamentationAugtype)->GetItem();
insr->itemicons[L] = aug_item->Icon;
}
else if (inst && inst->GetOrnamentationIcon())
@@ -5785,7 +5785,7 @@ void Client::ProcessInspectRequest(Client* requestee, Client* requester) {
}
}
inst = requestee->GetInv().GetItem(EQEmu::legacy::SlotPowerSource);
inst = requestee->GetInv().GetItem(EQEmu::inventory::slotPowerSource);
if(inst) {
item = inst->GetItem();
@@ -5799,7 +5799,7 @@ void Client::ProcessInspectRequest(Client* requestee, Client* requester) {
insr->itemicons[SoF::invslot::PossessionsPowerSource] = 0xFFFFFFFF;
}
inst = requestee->GetInv().GetItem(EQEmu::legacy::SlotAmmo);
inst = requestee->GetInv().GetItem(EQEmu::inventory::slotAmmo);
if(inst) {
item = inst->GetItem();
@@ -6341,8 +6341,8 @@ void Client::Doppelganger(uint16 spell_id, Mob *target, const char *name_overrid
made_npc->Corrup = GetCorrup();
made_npc->PhR = GetPhR();
// looks
made_npc->texture = GetEquipmentMaterial(EQEmu::textures::TextureChest);
made_npc->helmtexture = GetEquipmentMaterial(EQEmu::textures::TextureHead);
made_npc->texture = GetEquipmentMaterial(EQEmu::textures::armorChest);
made_npc->helmtexture = GetEquipmentMaterial(EQEmu::textures::armorHead);
made_npc->haircolor = GetHairColor();
made_npc->beardcolor = GetBeardColor();
made_npc->eyecolor1 = GetEyeColor1();
@@ -6353,9 +6353,9 @@ void Client::Doppelganger(uint16 spell_id, Mob *target, const char *name_overrid
made_npc->drakkin_heritage = GetDrakkinHeritage();
made_npc->drakkin_tattoo = GetDrakkinTattoo();
made_npc->drakkin_details = GetDrakkinDetails();
made_npc->d_melee_texture1 = GetEquipmentMaterial(EQEmu::textures::TexturePrimary);
made_npc->d_melee_texture2 = GetEquipmentMaterial(EQEmu::textures::TextureSecondary);
for (int i = EQEmu::textures::TextureBegin; i <= EQEmu::textures::LastTexture; i++) {
made_npc->d_melee_texture1 = GetEquipmentMaterial(EQEmu::textures::weaponPrimary);
made_npc->d_melee_texture2 = GetEquipmentMaterial(EQEmu::textures::weaponSecondary);
for (int i = EQEmu::textures::textureBegin; i <= EQEmu::textures::LastTexture; i++) {
made_npc->armor_tint.Slot[i].Color = GetEquipmentColor(i);
}
made_npc->loottable_id = 0;
@@ -6949,7 +6949,7 @@ void Client::SendAltCurrencies() {
uint32 i = 0;
auto iter = zone->AlternateCurrencies.begin();
while(iter != zone->AlternateCurrencies.end()) {
const EQEmu::ItemBase* item = database.GetItem((*iter).item_id);
const EQEmu::ItemData* item = database.GetItem((*iter).item_id);
altc->entries[i].currency_number = (*iter).id;
altc->entries[i].unknown00 = 1;
altc->entries[i].currency_number2 = (*iter).id;
@@ -7272,7 +7272,8 @@ void Client::SendXTargetUpdates()
for (int i = 0; i < GetMaxXTargets(); ++i) {
if (XTargets[i].dirty) {
outapp->WriteUInt32(i);
outapp->WriteUInt8(0); // no idea what this is
// MQ2 checks this for valid mobs, so 0 is bad here at least ...
outapp->WriteUInt8(XTargets[i].ID ? 1 : 0);
outapp->WriteUInt32(XTargets[i].ID);
outapp->WriteString(XTargets[i].Name);
count++;
@@ -7604,7 +7605,7 @@ void Client::DuplicateLoreMessage(uint32 ItemID)
return;
}
const EQEmu::ItemBase *item = database.GetItem(ItemID);
const EQEmu::ItemData *item = database.GetItem(ItemID);
if(!item)
return;
@@ -8061,7 +8062,7 @@ void Client::TickItemCheck()
TryItemTick(i);
}
//Scan main inventory + cursor
for (i = EQEmu::legacy::GENERAL_BEGIN; i <= EQEmu::legacy::SlotCursor; i++)
for (i = EQEmu::legacy::GENERAL_BEGIN; i <= EQEmu::inventory::slotCursor; i++)
{
TryItemTick(i);
}
@@ -8075,7 +8076,7 @@ void Client::TickItemCheck()
void Client::TryItemTick(int slot)
{
int iid = 0;
const ItemInst* inst = m_inv[slot];
const EQEmu::ItemInstance* inst = m_inv[slot];
if(inst == 0) { return; }
iid = inst->GetID();
@@ -8084,7 +8085,7 @@ void Client::TryItemTick(int slot)
{
if (GetLevel() >= zone->tick_items[iid].level && zone->random.Int(0, 100) >= (100 - zone->tick_items[iid].chance) && (zone->tick_items[iid].bagslot || slot <= EQEmu::legacy::EQUIPMENT_END))
{
ItemInst* e_inst = (ItemInst*)inst;
EQEmu::ItemInstance* e_inst = (EQEmu::ItemInstance*)inst;
parse->EventItem(EVENT_ITEM_TICK, this, e_inst, nullptr, "", slot);
}
}
@@ -8092,9 +8093,9 @@ void Client::TryItemTick(int slot)
//Only look at augs in main inventory
if (slot > EQEmu::legacy::EQUIPMENT_END) { return; }
for (int x = AUG_INDEX_BEGIN; x < EQEmu::legacy::ITEM_COMMON_SIZE; ++x)
for (int x = EQEmu::inventory::socketBegin; x < EQEmu::inventory::SocketCount; ++x)
{
ItemInst * a_inst = inst->GetAugment(x);
EQEmu::ItemInstance * a_inst = inst->GetAugment(x);
if(!a_inst) { continue; }
iid = a_inst->GetID();
@@ -8103,7 +8104,7 @@ void Client::TryItemTick(int slot)
{
if( GetLevel() >= zone->tick_items[iid].level && zone->random.Int(0, 100) >= (100 - zone->tick_items[iid].chance) )
{
ItemInst* e_inst = (ItemInst*)a_inst;
EQEmu::ItemInstance* e_inst = (EQEmu::ItemInstance*)a_inst;
parse->EventItem(EVENT_ITEM_TICK, this, e_inst, nullptr, "", slot);
}
}
@@ -8118,7 +8119,7 @@ void Client::ItemTimerCheck()
TryItemTimer(i);
}
for (i = EQEmu::legacy::GENERAL_BEGIN; i <= EQEmu::legacy::SlotCursor; i++)
for (i = EQEmu::legacy::GENERAL_BEGIN; i <= EQEmu::inventory::slotCursor; i++)
{
TryItemTimer(i);
}
@@ -8131,7 +8132,7 @@ void Client::ItemTimerCheck()
void Client::TryItemTimer(int slot)
{
ItemInst* inst = m_inv.GetItem(slot);
EQEmu::ItemInstance* inst = m_inv.GetItem(slot);
if(!inst) {
return;
}
@@ -8149,9 +8150,9 @@ void Client::TryItemTimer(int slot)
return;
}
for (int x = AUG_INDEX_BEGIN; x < EQEmu::legacy::ITEM_COMMON_SIZE; ++x)
for (int x = EQEmu::inventory::socketBegin; x < EQEmu::inventory::SocketCount; ++x)
{
ItemInst * a_inst = inst->GetAugment(x);
EQEmu::ItemInstance * a_inst = inst->GetAugment(x);
if(!a_inst) {
continue;
}
@@ -8167,7 +8168,7 @@ void Client::TryItemTimer(int slot)
}
}
void Client::SendItemScale(ItemInst *inst) {
void Client::SendItemScale(EQEmu::ItemInstance *inst) {
int slot = m_inv.GetSlotByItemInst(inst);
if(slot != -1) {
inst->ScaleItem();
@@ -8321,7 +8322,7 @@ void Client::SetConsumption(int32 in_hunger, int32 in_thirst)
safe_delete(outapp);
}
void Client::Consume(const EQEmu::ItemBase *item, uint8 type, int16 slot, bool auto_consume)
void Client::Consume(const EQEmu::ItemData *item, uint8 type, int16 slot, bool auto_consume)
{
if(!item) { return; }
@@ -8436,7 +8437,7 @@ void Client::ShowNumHits()
int Client::GetQuiverHaste(int delay)
{
const ItemInst *pi = nullptr;
const EQEmu::ItemInstance *pi = nullptr;
for (int r = EQEmu::legacy::GENERAL_BEGIN; r <= EQEmu::legacy::GENERAL_END; r++) {
pi = GetInv().GetItem(r);
if (pi && pi->IsClassBag() && pi->GetItem()->BagType == EQEmu::item::BagTypeQuiver &&
@@ -8482,7 +8483,7 @@ void Client::QuestReward(Mob* target, uint32 copper, uint32 silver, uint32 gold,
AddMoneyToPP(copper, silver, gold, platinum, false);
if (itemid > 0)
SummonItem(itemid, 0, 0, 0, 0, 0, 0, false, EQEmu::legacy::SlotPowerSource);
SummonItem(itemid, 0, 0, 0, 0, 0, 0, false, EQEmu::inventory::slotPowerSource);
if (faction)
{
zone/client.h
+42 -42
View File
@@ -31,7 +31,7 @@ enum WaterRegionType : int;
namespace EQEmu
{
struct ItemBase;
struct ItemData;
}
#include "../common/timer.h"
@@ -45,9 +45,9 @@ namespace EQEmu
#include "../common/extprofile.h"
#include "../common/races.h"
#include "../common/seperator.h"
#include "../common/item.h"
#include "../common/inventory_profile.h"
#include "../common/guilds.h"
#include "../common/item_base.h"
//#include "../common/item_data.h"
#include "common.h"
#include "merc.h"
@@ -222,7 +222,7 @@ public:
//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, int special = 0);
virtual bool Attack(Mob* other, int Hand = EQEmu::legacy::SlotPrimary, bool FromRiposte = false, bool IsStrikethrough = false, bool IsFromSpell = false,
virtual bool Attack(Mob* other, int Hand = EQEmu::inventory::slotPrimary, bool FromRiposte = false, bool IsStrikethrough = false, bool IsFromSpell = false,
ExtraAttackOptions *opts = nullptr, int special = 0);
virtual bool HasRaid() { return (GetRaid() ? true : false); }
virtual bool HasGroup() { return (GetGroup() ? true : false); }
@@ -250,7 +250,7 @@ public:
void KeyRingList();
virtual bool IsClient() const { return true; }
void CompleteConnect();
bool TryStacking(ItemInst* item, uint8 type = ItemPacketTrade, bool try_worn = true, bool try_cursor = true);
bool TryStacking(EQEmu::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();
@@ -273,7 +273,7 @@ public:
void SendTraderItem(uint32 item_id,uint16 quantity);
uint16 FindTraderItem(int32 SerialNumber,uint16 Quantity);
uint32 FindTraderItemSerialNumber(int32 ItemID);
ItemInst* FindTraderItemBySerialNumber(int32 SerialNumber);
EQEmu::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);
@@ -294,7 +294,7 @@ public:
void FillSpawnStruct(NewSpawn_Struct* ns, Mob* ForWho);
virtual bool Process();
void LogMerchant(Client* player, Mob* merchant, uint32 quantity, uint32 price, const EQEmu::ItemBase* item, bool buying);
void LogMerchant(Client* player, Mob* merchant, uint32 quantity, uint32 price, const EQEmu::ItemData* item, bool buying);
void SendPacketQueue(bool Block = true);
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);
@@ -308,7 +308,7 @@ public:
void LearnRecipe(uint32 recipeID);
bool CanIncreaseTradeskill(EQEmu::skills::SkillType tradeskill);
EQApplicationPacket* ReturnItemPacket(int16 slot_id, const ItemInst* inst, ItemPacketType packet_type);
EQApplicationPacket* ReturnItemPacket(int16 slot_id, const EQEmu::ItemInstance* inst, ItemPacketType packet_type);
bool GetRevoked() const { return revoked; }
void SetRevoked(bool rev) { revoked = rev; }
@@ -340,8 +340,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 Inventory& GetInv() { return m_inv; }
inline const Inventory& GetInv() const { return m_inv; }
inline EQEmu::InventoryProfile& GetInv() { return m_inv; }
inline const EQEmu::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; }
@@ -403,7 +403,7 @@ public:
inline uint8 GetLanguageSkill(uint16 n) const { return m_pp.languages[n]; }
void SendPickPocketResponse(Mob *from, uint32 amt, int type, const EQEmu::ItemBase* item = nullptr);
void SendPickPocketResponse(Mob *from, uint32 amt, int type, const EQEmu::ItemData* item = nullptr);
inline const char* GetLastName() const { return lastname; }
@@ -509,10 +509,10 @@ public:
virtual int GetCurrentBuffSlots() const;
virtual int GetCurrentSongSlots() const;
virtual int GetCurrentDiscSlots() const { return 1; }
virtual int GetMaxBuffSlots() const { return 25; }
virtual int GetMaxSongSlots() const { return 12; }
virtual int GetMaxDiscSlots() const { return 1; }
virtual int GetMaxTotalSlots() const { return 38; }
virtual int GetMaxBuffSlots() const { return EQEmu::constants::LongBuffs; }
virtual int GetMaxSongSlots() const { return EQEmu::constants::ShortBuffs; }
virtual int GetMaxDiscSlots() const { return EQEmu::constants::DiscBuffs; }
virtual int GetMaxTotalSlots() const { return EQEmu::constants::TotalBuffs; }
virtual uint32 GetFirstBuffSlot(bool disc, bool song);
virtual uint32 GetLastBuffSlot(bool disc, bool song);
virtual void InitializeBuffSlots();
@@ -601,7 +601,7 @@ public:
void AssignToInstance(uint16 instance_id);
void RemoveFromInstance(uint16 instance_id);
void WhoAll();
bool CheckLoreConflict(const EQEmu::ItemBase* item);
bool CheckLoreConflict(const EQEmu::ItemData* item);
void ChangeLastName(const char* in_lastname);
void GetGroupAAs(GroupLeadershipAA_Struct *into) const;
void GetRaidAAs(RaidLeadershipAA_Struct *into) const;
@@ -808,30 +808,30 @@ 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::Tint_Struct& color);
void SetTint(int16 slot_id, EQEmu::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 ItemInst& inst, bool client_update = false);
bool PushItemOnCursor(const ItemInst& inst, bool client_update = false);
bool PutItemInInventory(int16 slot_id, const EQEmu::ItemInstance& inst, bool client_update = false);
bool PushItemOnCursor(const EQEmu::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 ItemInst &inst, ServerLootItem_Struct** bag_item_data = 0);
bool AutoPutLootInInventory(ItemInst& 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::legacy::SlotCursor, uint32 ornament_icon = 0, uint32 ornament_idfile = 0, uint32 ornament_hero_model = 0);
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::inventory::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);
int GetItemLinkHash(const ItemInst* inst); // move to ItemBase..or make use of the pre-calculated database field
int GetItemLinkHash(const EQEmu::ItemInstance* inst); // move to ItemData..or make use of the pre-calculated database field
void SendItemLink(const ItemInst* inst, bool sendtoall=false);
void SendLootItemInPacket(const ItemInst* inst, int16 slot_id);
void SendItemPacket(int16 slot_id, const ItemInst* inst, ItemPacketType packet_type);
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);
bool IsValidSlot(uint32 slot);
bool IsBankSlot(uint32 slot);
@@ -887,7 +887,7 @@ public:
//Calculate vendor price modifier based on CHA: (reverse==selling)
float CalcPriceMod(Mob* other = 0, bool reverse = false);
void ResetTrade();
void DropInst(const ItemInst* inst);
void DropInst(const EQEmu::ItemInstance* inst);
bool TrainDiscipline(uint32 itemid);
void TrainDiscBySpellID(int32 spell_id);
int GetDiscSlotBySpellID(int32 spellid);
@@ -965,7 +965,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<ItemInst*>& Items, int Cash, int NPCTypeID) { if (taskstate) return taskstate->UpdateTasksOnDeliver(this, Items, Cash, 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 void TaskSetSelector(Mob *mob, int TaskSetID) { if(taskmanager) taskmanager->TaskSetSelector(this, taskstate, mob, TaskSetID); }
inline void EnableTask(int TaskCount, int *TaskList) { if(taskstate) taskstate->EnableTask(CharacterID(), TaskCount, TaskList); }
inline void DisableTask(int TaskCount, int *TaskList) { if(taskstate) taskstate->DisableTask(CharacterID(), TaskCount, TaskList); }
@@ -1080,7 +1080,7 @@ public:
inline bool GetPendingGuildInvitation() { return PendingGuildInvitation; }
void LocateCorpse();
void SendTargetCommand(uint32 EntityID);
bool MoveItemToInventory(ItemInst *BInst, bool UpdateClient = false);
bool MoveItemToInventory(EQEmu::ItemInstance *BInst, bool UpdateClient = false);
void HandleRespawnFromHover(uint32 Option);
bool IsHoveringForRespawn() { return RespawnFromHoverTimer.Enabled(); }
std::list<RespawnOption> respawn_options;
@@ -1173,7 +1173,7 @@ public:
void TryItemTick(int slot);
void ItemTimerCheck();
void TryItemTimer(int slot);
void SendItemScale(ItemInst *inst);
void SendItemScale(EQEmu::ItemInstance *inst);
int32 GetActSTR() { return( std::min(GetMaxSTR(), GetSTR()) ); }
int32 GetActSTA() { return( std::min(GetMaxSTA(), GetSTA()) ); }
@@ -1186,10 +1186,10 @@ public:
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::ItemBase *item, uint8 type, int16 slot, bool auto_consume);
void Consume(const EQEmu::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 ItemInst* weapon, Mob* other);
int mod_client_damage(int damage, EQEmu::skills::SkillType skillinuse, int hand, const EQEmu::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);
int16 mod_increase_skill_chance(int16 chance, Mob* against_who);
@@ -1201,16 +1201,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 ItemInst* item);
int32 mod_tribute_item_value(int32 pts, const EQEmu::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::ItemBase *item, EQEmu::item::ItemType type, int change);
int mod_food_value(const EQEmu::ItemBase *item, int change);
int mod_drink_value(const EQEmu::ItemBase *item, int change);
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);
void SetEngagedRaidTarget(bool value) { EngagedRaidTarget = value; }
bool GetEngagedRaidTarget() const { return EngagedRaidTarget; }
@@ -1244,8 +1244,8 @@ public:
protected:
friend class Mob;
void CalcItemBonuses(StatBonuses* newbon);
void AddItemBonuses(const ItemInst *inst, StatBonuses* newbon, bool isAug = false, bool isTribute = false, int rec_override = 0, bool ammo_slot_item = false);
void AdditiveWornBonuses(const ItemInst *inst, StatBonuses* newbon, bool isAug = false);
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);
int CalcRecommendedLevelBonus(uint8 level, uint8 reclevel, int basestat);
void CalcEdibleBonuses(StatBonuses* newbon);
void ProcessItemCaps();
@@ -1286,7 +1286,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(ItemInst &from, int16 to_slot, uint8 type);
void MoveItemCharges(EQEmu::ItemInstance &from, int16 to_slot, uint8 type);
void OPGMTraining(const EQApplicationPacket *app);
void OPGMEndTraining(const EQApplicationPacket *app);
void OPGMTrainSkill(const EQApplicationPacket *app);
@@ -1395,7 +1395,7 @@ private:
PlayerProfile_Struct m_pp;
ExtendedProfile_Struct m_epp;
Inventory m_inv;
EQEmu::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.
@@ -1561,8 +1561,8 @@ private:
bool interrogateinv_flag; // used to minimize log spamming by players
void InterrogateInventory_(bool errorcheck, Client* requester, int16 head, int16 index, const ItemInst* inst, const ItemInst* parent, bool log, bool silent, bool &error, int depth);
bool InterrogateInventory_error(int16 head, int16 index, const ItemInst* inst, const ItemInst* parent, int depth);
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);
};
#endif
zone/client_mods.cpp
+13 -13
View File
@@ -486,7 +486,7 @@ int32 Client::GetRawItemAC()
int32 Total = 0;
// this skips MainAmmo..add an '=' conditional if that slot is required (original behavior)
for (int16 slot_id = EQEmu::legacy::EQUIPMENT_BEGIN; slot_id < EQEmu::legacy::EQUIPMENT_END; slot_id++) {
const ItemInst* inst = m_inv[slot_id];
const EQEmu::ItemInstance* inst = m_inv[slot_id];
if (inst && inst->IsClassCommon()) {
Total += inst->GetItem()->AC;
}
@@ -1074,9 +1074,9 @@ int32 Client::CalcAC()
}
// Shield AC bonus for HeroicSTR
if (itembonuses.HeroicSTR) {
bool equiped = CastToClient()->m_inv.GetItem(EQEmu::legacy::SlotSecondary);
bool equiped = CastToClient()->m_inv.GetItem(EQEmu::inventory::slotSecondary);
if (equiped) {
uint8 shield = CastToClient()->m_inv.GetItem(EQEmu::legacy::SlotSecondary)->GetItem()->ItemType;
uint8 shield = CastToClient()->m_inv.GetItem(EQEmu::inventory::slotSecondary)->GetItem()->ItemType;
if (shield == EQEmu::item::ItemTypeShield) {
displayed += itembonuses.HeroicSTR / 2;
}
@@ -1103,9 +1103,9 @@ int32 Client::GetACMit()
}
// Shield AC bonus for HeroicSTR
if (itembonuses.HeroicSTR) {
bool equiped = CastToClient()->m_inv.GetItem(EQEmu::legacy::SlotSecondary);
bool equiped = CastToClient()->m_inv.GetItem(EQEmu::inventory::slotSecondary);
if (equiped) {
uint8 shield = CastToClient()->m_inv.GetItem(EQEmu::legacy::SlotSecondary)->GetItem()->ItemType;
uint8 shield = CastToClient()->m_inv.GetItem(EQEmu::inventory::slotSecondary)->GetItem()->ItemType;
if (shield == EQEmu::item::ItemTypeShield) {
mitigation += itembonuses.HeroicSTR / 2;
}
@@ -1316,11 +1316,11 @@ int32 Client::CalcManaRegenCap()
uint32 Client::CalcCurrentWeight()
{
const EQEmu::ItemBase* TempItem = 0;
ItemInst* ins;
const EQEmu::ItemData* TempItem = 0;
EQEmu::ItemInstance* ins;
uint32 Total = 0;
int x;
for (x = EQEmu::legacy::EQUIPMENT_BEGIN; x <= EQEmu::legacy::SlotCursor; x++) { // include cursor or not?
for (x = EQEmu::legacy::EQUIPMENT_BEGIN; x <= EQEmu::inventory::slotCursor; x++) { // include cursor or not?
TempItem = 0;
ins = GetInv().GetItem(x);
if (ins) {
@@ -1343,14 +1343,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::legacy::SlotGeneral1;
int bagslot = EQEmu::inventory::slotGeneral1;
int reduction = 0;
for (int m = EQEmu::legacy::GENERAL_BAGS_BEGIN + 10; m <= EQEmu::legacy::GENERAL_BAGS_END; m += 10) { // include cursor bags or not?
if (x >= m) {
bagslot += 1;
}
}
ItemInst* baginst = GetInv().GetItem(bagslot);
EQEmu::ItemInstance* baginst = GetInv().GetItem(bagslot);
if (baginst && baginst->GetItem() && baginst->IsClassBag()) {
reduction = baginst->GetItem()->BagWR;
}
@@ -1369,7 +1369,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::Lookup(EQEmu::versions::ConvertClientVersionToInventoryVersion(ClientVersion()))->CoinHasWeight) {
if (EQEmu::behavior::Lookup(EQEmu::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;
@@ -2219,12 +2219,12 @@ int Client::GetRawACNoShield(int &shield_ac) const
{
int ac = itembonuses.AC + spellbonuses.AC + aabonuses.AC;
shield_ac = 0;
const ItemInst *inst = m_inv.GetItem(EQEmu::legacy::SlotSecondary);
const EQEmu::ItemInstance *inst = m_inv.GetItem(EQEmu::inventory::slotSecondary);
if (inst) {
if (inst->GetItem()->ItemType == EQEmu::item::ItemTypeShield) {
ac -= inst->GetItem()->AC;
shield_ac = inst->GetItem()->AC;
for (uint8 i = AUG_INDEX_BEGIN; i < EQEmu::legacy::ITEM_COMMON_SIZE; i++) {
for (uint8 i = EQEmu::inventory::socketBegin; i < EQEmu::inventory::SocketCount; i++) {
if (inst->GetAugment(i)) {
ac -= inst->GetAugment(i)->GetItem()->AC;
shield_ac += inst->GetAugment(i)->GetItem()->AC;
zone/client_packet.cpp
+96 -96
View File
@@ -1334,7 +1334,7 @@ void Client::Handle_Connect_OP_ZoneEntry(const EQApplicationPacket *app)
}
/* Set item material tint */
for (int i = EQEmu::textures::TextureBegin; i <= EQEmu::textures::LastTexture; i++)
for (int i = EQEmu::textures::textureBegin; i <= EQEmu::textures::LastTexture; i++)
{
if (m_pp.item_tint.Slot[i].UseTint == 1 || m_pp.item_tint.Slot[i].UseTint == 255)
{
@@ -1690,8 +1690,8 @@ void Client::Handle_Connect_OP_ZoneEntry(const EQApplicationPacket *app)
/* First item cursor is sent in bulk inventory packet */
if (iter == m_inv.cursor_cbegin())
continue;
const ItemInst *inst = *iter;
SendItemPacket(EQEmu::legacy::SlotCursor, inst, ItemPacketLimbo);
const EQEmu::ItemInstance *inst = *iter;
SendItemPacket(EQEmu::inventory::slotCursor, inst, ItemPacketLimbo);
}
}
@@ -1883,7 +1883,7 @@ void Client::Handle_OP_AdventureMerchantPurchase(const EQApplicationPacket *app)
merchantid = tmp->CastToNPC()->MerchantType;
const EQEmu::ItemBase* item = nullptr;
const EQEmu::ItemData* item = nullptr;
bool found = false;
std::list<MerchantList> merlist = zone->merchanttable[merchantid];
std::list<MerchantList>::const_iterator itr;
@@ -2026,10 +2026,10 @@ void Client::Handle_OP_AdventureMerchantPurchase(const EQApplicationPacket *app)
if (item->MaxCharges != 0)
charges = item->MaxCharges;
ItemInst *inst = database.CreateItem(item, charges);
EQEmu::ItemInstance *inst = database.CreateItem(item, charges);
if (!AutoPutLootInInventory(*inst, true, true))
{
PutLootInInventory(EQEmu::legacy::SlotCursor, *inst);
PutLootInInventory(EQEmu::inventory::slotCursor, *inst);
}
Save(1);
}
@@ -2059,7 +2059,7 @@ void Client::Handle_OP_AdventureMerchantRequest(const EQApplicationPacket *app)
merchantid = tmp->CastToNPC()->MerchantType;
tmp->CastToNPC()->FaceTarget(this->CastToMob());
const EQEmu::ItemBase *item = 0;
const EQEmu::ItemData *item = 0;
std::list<MerchantList> merlist = zone->merchanttable[merchantid];
std::list<MerchantList>::const_iterator itr;
for (itr = merlist.begin(); itr != merlist.end() && count<255; ++itr){
@@ -2158,8 +2158,8 @@ void Client::Handle_OP_AdventureMerchantSell(const EQApplicationPacket *app)
return;
}
const EQEmu::ItemBase* item = database.GetItem(itemid);
ItemInst* inst = GetInv().GetItem(ams_in->slot);
const EQEmu::ItemData* item = database.GetItem(itemid);
EQEmu::ItemInstance* inst = GetInv().GetItem(ams_in->slot);
if (!item || !inst){
Message(13, "You seemed to have misplaced that item...");
return;
@@ -2435,7 +2435,7 @@ void Client::Handle_OP_AltCurrencyMerchantRequest(const EQApplicationPacket *app
ss << alt_cur_id << "|1|" << alt_cur_id;
uint32 count = 0;
uint32 merchant_id = tar->MerchantType;
const EQEmu::ItemBase *item = nullptr;
const EQEmu::ItemData *item = nullptr;
std::list<MerchantList> merlist = zone->merchanttable[merchant_id];
std::list<MerchantList>::const_iterator itr;
@@ -2495,7 +2495,7 @@ void Client::Handle_OP_AltCurrencyPurchase(const EQApplicationPacket *app)
return;
}
const EQEmu::ItemBase* item = nullptr;
const EQEmu::ItemData* item = nullptr;
uint32 cost = 0;
uint32 current_currency = GetAlternateCurrencyValue(alt_cur_id);
uint32 merchant_id = tar->MerchantType;
@@ -2551,10 +2551,10 @@ void Client::Handle_OP_AltCurrencyPurchase(const EQApplicationPacket *app)
if (item->MaxCharges != 0)
charges = item->MaxCharges;
ItemInst *inst = database.CreateItem(item, charges);
EQEmu::ItemInstance *inst = database.CreateItem(item, charges);
if (!AutoPutLootInInventory(*inst, true, true))
{
PutLootInInventory(EQEmu::legacy::SlotCursor, *inst);
PutLootInInventory(EQEmu::inventory::slotCursor, *inst);
}
Save(1);
@@ -2604,7 +2604,7 @@ void Client::Handle_OP_AltCurrencyReclaim(const EQApplicationPacket *app)
SetAlternateCurrencyValue(reclaim->currency_id, 0);
}
else {
SummonItem(item_id, reclaim->count, 0, 0, 0, 0, 0, 0, false, EQEmu::legacy::SlotCursor);
SummonItem(item_id, reclaim->count, 0, 0, 0, 0, 0, 0, false, EQEmu::inventory::slotCursor);
AddAlternateCurrencyValue(reclaim->currency_id, -((int32)reclaim->count));
}
/* QS: PlayerLogAlternateCurrencyTransactions :: Cursor to Item Storage */
@@ -2635,7 +2635,7 @@ void Client::Handle_OP_AltCurrencySell(const EQApplicationPacket *app)
return;
}
ItemInst* inst = GetInv().GetItem(sell->slot_id);
EQEmu::ItemInstance* inst = GetInv().GetItem(sell->slot_id);
if (!inst) {
return;
}
@@ -2644,7 +2644,7 @@ void Client::Handle_OP_AltCurrencySell(const EQApplicationPacket *app)
return;
}
const EQEmu::ItemBase* item = nullptr;
const EQEmu::ItemData* item = nullptr;
uint32 cost = 0;
uint32 current_currency = GetAlternateCurrencyValue(alt_cur_id);
uint32 merchant_id = tar->MerchantType;
@@ -2732,12 +2732,12 @@ void Client::Handle_OP_AltCurrencySellSelection(const EQApplicationPacket *app)
return;
}
ItemInst *inst = m_inv.GetItem(select->slot_id);
EQEmu::ItemInstance *inst = m_inv.GetItem(select->slot_id);
if (!inst) {
return;
}
const EQEmu::ItemBase* item = nullptr;
const EQEmu::ItemData* item = nullptr;
uint32 cost = 0;
uint32 current_currency = GetAlternateCurrencyValue(alt_cur_id);
uint32 merchant_id = tar->MerchantType;
@@ -2816,9 +2816,9 @@ void Client::Handle_OP_ApplyPoison(const EQApplicationPacket *app)
}
uint32 ApplyPoisonSuccessResult = 0;
ApplyPoison_Struct* ApplyPoisonData = (ApplyPoison_Struct*)app->pBuffer;
const ItemInst* PrimaryWeapon = GetInv().GetItem(EQEmu::legacy::SlotPrimary);
const ItemInst* SecondaryWeapon = GetInv().GetItem(EQEmu::legacy::SlotSecondary);
const ItemInst* PoisonItemInstance = GetInv()[ApplyPoisonData->inventorySlot];
const EQEmu::ItemInstance* PrimaryWeapon = GetInv().GetItem(EQEmu::inventory::slotPrimary);
const EQEmu::ItemInstance* SecondaryWeapon = GetInv().GetItem(EQEmu::inventory::slotSecondary);
const EQEmu::ItemInstance* PoisonItemInstance = GetInv()[ApplyPoisonData->inventorySlot];
bool IsPoison = PoisonItemInstance && (PoisonItemInstance->GetItem()->ItemType == EQEmu::item::ItemTypePoison);
@@ -2912,7 +2912,7 @@ void Client::Handle_OP_AugmentInfo(const EQApplicationPacket *app)
}
AugmentInfo_Struct* AugInfo = (AugmentInfo_Struct*)app->pBuffer;
const EQEmu::ItemBase * item = database.GetItem(AugInfo->itemid);
const EQEmu::ItemData * item = database.GetItem(AugInfo->itemid);
if (item) {
strn0cpy(AugInfo->augment_info, item->Name, 64);
@@ -2933,13 +2933,17 @@ void Client::Handle_OP_AugmentItem(const EQApplicationPacket *app)
bool deleteItems = false;
if (ClientVersion() >= EQEmu::versions::ClientVersion::RoF)
{
ItemInst *itemOneToPush = nullptr, *itemTwoToPush = nullptr;
ItemInst *tobe_auged = nullptr, *old_aug = nullptr, *new_aug = nullptr, *aug = nullptr, *solvent = nullptr;
Inventory& user_inv = GetInv();
EQEmu::ItemInstance *itemOneToPush = nullptr, *itemTwoToPush = nullptr;
//Log.Out(Logs::DebugLevel::Moderate, Logs::Debug, "cslot: %i aslot: %i cidx: %i aidx: %i act: %i dest: %i",
// in_augment->container_slot, in_augment->augment_slot, in_augment->container_index, in_augment->augment_index, in_augment->augment_action, in_augment->dest_inst_id);
EQEmu::ItemInstance *tobe_auged = nullptr, *old_aug = nullptr, *new_aug = nullptr, *aug = nullptr, *solvent = nullptr;
EQEmu::InventoryProfile& user_inv = GetInv();
uint16 item_slot = in_augment->container_slot;
uint16 solvent_slot = in_augment->augment_slot;
uint8 mat = Inventory::CalcMaterialFromSlot(item_slot); // for when player is augging a piece of equipment while they're wearing it
uint8 mat = EQEmu::InventoryProfile::CalcMaterialFromSlot(item_slot); // for when player is augging a piece of equipment while they're wearing it
if (item_slot == INVALID_INDEX || solvent_slot == INVALID_INDEX)
{
@@ -2995,7 +2999,7 @@ void Client::Handle_OP_AugmentItem(const EQApplicationPacket *app)
{
case 0: // Adding an augment
case 2: // Swapping augment
new_aug = user_inv.GetItem(EQEmu::legacy::SlotCursor);
new_aug = user_inv.GetItem(EQEmu::inventory::slotCursor);
if (!new_aug) // Shouldn't get the OP code without the augment on the user's cursor, but maybe it's h4x.
{
@@ -3053,7 +3057,7 @@ void Client::Handle_OP_AugmentItem(const EQApplicationPacket *app)
if (itemOneToPush)
{
DeleteItemInInventory(item_slot, 0, true);
DeleteItemInInventory(EQEmu::legacy::SlotCursor, new_aug->IsStackable() ? 1 : 0, true);
DeleteItemInInventory(EQEmu::inventory::slotCursor, new_aug->IsStackable() ? 1 : 0, true);
if (solvent)
{
@@ -3064,7 +3068,7 @@ void Client::Handle_OP_AugmentItem(const EQApplicationPacket *app)
if (itemTwoToPush)
{
// This is a swap. Return the old aug to the player's cursor.
if (!PutItemInInventory(EQEmu::legacy::SlotCursor, *itemTwoToPush, true))
if (!PutItemInInventory(EQEmu::inventory::slotCursor, *itemTwoToPush, true))
{
Log.Out(Logs::General, Logs::Error, "Problem returning old augment to player's cursor after augmentation swap.");
Message(15, "Error: Failed to retrieve old augment after augmentation swap!");
@@ -3077,7 +3081,7 @@ void Client::Handle_OP_AugmentItem(const EQApplicationPacket *app)
CalcBonuses();
if (mat != EQEmu::textures::TextureInvalid)
if (mat != EQEmu::textures::materialInvalid)
{
SendWearChange(mat); // Visible item augged while equipped. Send WC in case ornamentation changed.
}
@@ -3142,13 +3146,13 @@ void Client::Handle_OP_AugmentItem(const EQApplicationPacket *app)
CalcBonuses();
if (mat != EQEmu::textures::TextureInvalid)
if (mat != EQEmu::textures::materialInvalid)
{
SendWearChange(mat); // Visible item augged while equipped. Send WC in case ornamentation changed.
}
// Drop the removed augment on the player's cursor
if (!PutItemInInventory(EQEmu::legacy::SlotCursor, *itemTwoToPush, true))
if (!PutItemInInventory(EQEmu::inventory::slotCursor, *itemTwoToPush, true))
{
Log.Out(Logs::General, Logs::Error, "Problem returning augment to player's cursor after safe removal.");
Message(15, "Error: Failed to return augment after removal from item!");
@@ -3197,7 +3201,7 @@ void Client::Handle_OP_AugmentItem(const EQApplicationPacket *app)
CalcBonuses();
if (mat != EQEmu::textures::TextureInvalid)
if (mat != EQEmu::textures::materialInvalid)
{
SendWearChange(mat);
}
@@ -3490,13 +3494,13 @@ void Client::Handle_OP_Barter(const EQApplicationPacket *app)
{
BarterItemSearchLinkRequest_Struct* bislr = (BarterItemSearchLinkRequest_Struct*)app->pBuffer;
const EQEmu::ItemBase* item = database.GetItem(bislr->ItemID);
const EQEmu::ItemData* item = database.GetItem(bislr->ItemID);
if (!item)
Message(13, "Error: This item does not exist!");
else
{
ItemInst* inst = database.CreateItem(item);
EQEmu::ItemInstance* inst = database.CreateItem(item);
if (inst)
{
SendItemPacket(0, inst, ItemPacketViewLink);
@@ -3523,13 +3527,13 @@ void Client::Handle_OP_Barter(const EQApplicationPacket *app)
{
BuyerItemSearchLinkRequest_Struct* bislr = (BuyerItemSearchLinkRequest_Struct*)app->pBuffer;
const EQEmu::ItemBase* item = database.GetItem(bislr->ItemID);
const EQEmu::ItemData* item = database.GetItem(bislr->ItemID);
if (!item)
Message(13, "Error: This item does not exist!");
else
{
ItemInst* inst = database.CreateItem(item);
EQEmu::ItemInstance* inst = database.CreateItem(item);
if (inst)
{
SendItemPacket(0, inst, ItemPacketViewLink);
@@ -3562,14 +3566,14 @@ void Client::Handle_OP_BazaarInspect(const EQApplicationPacket *app)
BazaarInspect_Struct* bis = (BazaarInspect_Struct*)app->pBuffer;
const EQEmu::ItemBase* item = database.GetItem(bis->ItemID);
const EQEmu::ItemData* item = database.GetItem(bis->ItemID);
if (!item) {
Message(13, "Error: This item does not exist!");
return;
}
ItemInst* inst = database.CreateItem(item);
EQEmu::ItemInstance* inst = database.CreateItem(item);
if (inst) {
SendItemPacket(0, inst, ItemPacketViewLink);
@@ -3602,7 +3606,7 @@ void Client::Handle_OP_BazaarSearch(const EQApplicationPacket *app)
Client *c = entity_list.GetClientByName(nbis->Name);
if (c) {
ItemInst* inst = c->FindTraderItemBySerialNumber(nbis->SerialNumber);
EQEmu::ItemInstance* inst = c->FindTraderItemBySerialNumber(nbis->SerialNumber);
if (inst)
SendItemPacket(0, inst, ItemPacketViewLink);
}
@@ -4003,11 +4007,11 @@ void Client::Handle_OP_CastSpell(const EQApplicationPacket *app)
if (m_inv.SupportsClickCasting(castspell->inventoryslot) || slot == CastingSlot::PotionBelt) // sanity check
{
// packet field types will be reviewed as packet transistions occur
const ItemInst* inst = m_inv[castspell->inventoryslot]; //slot values are int16, need to check packet on this field
const EQEmu::ItemInstance* inst = m_inv[castspell->inventoryslot]; //slot values are int16, need to check packet on this field
//bool cancast = true;
if (inst && inst->IsClassCommon())
{
const EQEmu::ItemBase* item = inst->GetItem();
const EQEmu::ItemData* item = inst->GetItem();
if (item->Click.Effect != (uint32)castspell->spell_id)
{
database.SetMQDetectionFlag(account_name, name, "OP_CastSpell with item, tried to cast a different spell.", zone->GetShortName());
@@ -4021,7 +4025,7 @@ void Client::Handle_OP_CastSpell(const EQApplicationPacket *app)
{
if (GetLevel() >= item->Click.Level2)
{
ItemInst* p_inst = (ItemInst*)inst;
EQEmu::ItemInstance* p_inst = (EQEmu::ItemInstance*)inst;
int i = parse->EventItem(EVENT_ITEM_CLICK_CAST, this, p_inst, nullptr, "", castspell->inventoryslot);
if (i == 0) {
@@ -4041,7 +4045,7 @@ void Client::Handle_OP_CastSpell(const EQApplicationPacket *app)
}
else
{
ItemInst* p_inst = (ItemInst*)inst;
EQEmu::ItemInstance* p_inst = (EQEmu::ItemInstance*)inst;
int i = parse->EventItem(EVENT_ITEM_CLICK_CAST, this, p_inst, nullptr, "", castspell->inventoryslot);
if (i == 0) {
@@ -4066,7 +4070,7 @@ void Client::Handle_OP_CastSpell(const EQApplicationPacket *app)
}
else
{
Message(0, "Error: castspell->inventoryslot >= %i (0x%04x)", EQEmu::legacy::SlotCursor, castspell->inventoryslot);
Message(0, "Error: castspell->inventoryslot >= %i (0x%04x)", EQEmu::inventory::slotCursor, castspell->inventoryslot);
InterruptSpell(castspell->spell_id);
}
}
@@ -4853,13 +4857,13 @@ void Client::Handle_OP_Consume(const EQApplicationPacket *app)
}
}
ItemInst *myitem = GetInv().GetItem(pcs->slot);
EQEmu::ItemInstance *myitem = GetInv().GetItem(pcs->slot);
if (myitem == nullptr) {
Log.Out(Logs::General, Logs::Error, "Consuming from empty slot %d", pcs->slot);
return;
}
const EQEmu::ItemBase* eat_item = myitem->GetItem();
const EQEmu::ItemData* eat_item = myitem->GetItem();
if (pcs->type == 0x01) {
Consume(eat_item, EQEmu::item::ItemTypeFood, pcs->slot, (pcs->auto_consumed == 0xffffffff));
}
@@ -4989,7 +4993,7 @@ void Client::Handle_OP_CrashDump(const EQApplicationPacket *app)
void Client::Handle_OP_CreateObject(const EQApplicationPacket *app)
{
DropItem(EQEmu::legacy::SlotCursor);
DropItem(EQEmu::inventory::slotCursor);
return;
}
@@ -5142,7 +5146,7 @@ void Client::Handle_OP_DeleteItem(const EQApplicationPacket *app)
}
DeleteItem_Struct* alc = (DeleteItem_Struct*)app->pBuffer;
const ItemInst *inst = GetInv().GetItem(alc->from_slot);
const EQEmu::ItemInstance *inst = GetInv().GetItem(alc->from_slot);
if (inst && inst->GetItem()->ItemType == EQEmu::item::ItemTypeAlcohol) {
entity_list.MessageClose_StringID(this, true, 50, 0, DRINKING_MESSAGE, GetName(), inst->GetItem()->Name);
CheckIncreaseSkill(EQEmu::skills::SkillAlcoholTolerance, nullptr, 25);
@@ -6872,7 +6876,7 @@ void Client::Handle_OP_GuildBank(const EQApplicationPacket *app)
if (Slot >= 0)
{
ItemInst* inst = GuildBanks->GetItem(GuildID(), GuildBankMainArea, Slot, 1);
EQEmu::ItemInstance* inst = GuildBanks->GetItem(GuildID(), GuildBankMainArea, Slot, 1);
if (inst)
{
@@ -6892,7 +6896,7 @@ void Client::Handle_OP_GuildBank(const EQApplicationPacket *app)
{
GuildBankViewItem_Struct *gbvis = (GuildBankViewItem_Struct*)app->pBuffer;
ItemInst* inst = GuildBanks->GetItem(GuildID(), gbvis->Area, gbvis->SlotID, 1);
EQEmu::ItemInstance* inst = GuildBanks->GetItem(GuildID(), gbvis->Area, gbvis->SlotID, 1);
if (!inst)
break;
@@ -6915,7 +6919,7 @@ void Client::Handle_OP_GuildBank(const EQApplicationPacket *app)
return;
}
ItemInst *CursorItemInst = GetInv().GetItem(EQEmu::legacy::SlotCursor);
EQEmu::ItemInstance *CursorItemInst = GetInv().GetItem(EQEmu::inventory::slotCursor);
bool Allowed = true;
@@ -6928,7 +6932,7 @@ void Client::Handle_OP_GuildBank(const EQApplicationPacket *app)
return;
}
const EQEmu::ItemBase* CursorItem = CursorItemInst->GetItem();
const EQEmu::ItemData* CursorItem = CursorItemInst->GetItem();
if (!CursorItem->NoDrop || CursorItemInst->IsAttuned())
{
@@ -6963,7 +6967,7 @@ void Client::Handle_OP_GuildBank(const EQApplicationPacket *app)
{
GuildBankDepositAck(false, sentAction);
DeleteItemInInventory(EQEmu::legacy::SlotCursor, 0, false);
DeleteItemInInventory(EQEmu::inventory::slotCursor, 0, false);
}
break;
@@ -6984,7 +6988,7 @@ void Client::Handle_OP_GuildBank(const EQApplicationPacket *app)
case GuildBankWithdraw:
{
if (GetInv()[EQEmu::legacy::SlotCursor])
if (GetInv()[EQEmu::inventory::slotCursor])
{
Message_StringID(13, GUILD_BANK_EMPTY_HANDS);
@@ -6995,7 +6999,7 @@ void Client::Handle_OP_GuildBank(const EQApplicationPacket *app)
GuildBankWithdrawItem_Struct *gbwis = (GuildBankWithdrawItem_Struct*)app->pBuffer;
ItemInst* inst = GuildBanks->GetItem(GuildID(), gbwis->Area, gbwis->SlotID, gbwis->Quantity);
EQEmu::ItemInstance* inst = GuildBanks->GetItem(GuildID(), gbwis->Area, gbwis->SlotID, gbwis->Quantity);
if (!inst)
{
@@ -7030,7 +7034,7 @@ void Client::Handle_OP_GuildBank(const EQApplicationPacket *app)
{
PushItemOnCursor(*inst);
SendItemPacket(EQEmu::legacy::SlotCursor, inst, ItemPacketLimbo);
SendItemPacket(EQEmu::inventory::slotCursor, inst, ItemPacketLimbo);
GuildBanks->DeleteItem(GuildID(), gbwis->Area, gbwis->SlotID, gbwis->Quantity);
}
@@ -7907,6 +7911,7 @@ void Client::Handle_OP_Hide(const EQApplicationPacket *app)
}
else
hidden = true;
tmHidden = Timer::GetCurrentTime();
}
if (GetClass() == ROGUE){
auto outapp = new EQApplicationPacket(OP_SimpleMessage, sizeof(SimpleMessage_Struct));
@@ -8009,17 +8014,17 @@ void Client::Handle_OP_InspectAnswer(const EQApplicationPacket *app)
EQApplicationPacket* outapp = app->Copy();
InspectResponse_Struct* insr = (InspectResponse_Struct*)outapp->pBuffer;
Mob* tmp = entity_list.GetMob(insr->TargetID);
const EQEmu::ItemBase* item = nullptr;
const EQEmu::ItemData* item = nullptr;
int ornamentationAugtype = RuleI(Character, OrnamentationAugmentType);
for (int16 L = EQEmu::legacy::EQUIPMENT_BEGIN; L <= EQEmu::legacy::SlotWaist; L++) {
const ItemInst* inst = GetInv().GetItem(L);
for (int16 L = EQEmu::legacy::EQUIPMENT_BEGIN; L <= EQEmu::inventory::slotWaist; L++) {
const EQEmu::ItemInstance* inst = GetInv().GetItem(L);
item = inst ? inst->GetItem() : nullptr;
if (item) {
strcpy(insr->itemnames[L], item->Name);
if (inst && inst->GetOrnamentationAug(ornamentationAugtype)) {
const EQEmu::ItemBase *aug_item = inst->GetOrnamentationAug(ornamentationAugtype)->GetItem();
const EQEmu::ItemData *aug_item = inst->GetOrnamentationAug(ornamentationAugtype)->GetItem();
insr->itemicons[L] = aug_item->Icon;
}
else if (inst->GetOrnamentationIcon()) {
@@ -8032,7 +8037,7 @@ void Client::Handle_OP_InspectAnswer(const EQApplicationPacket *app)
else { insr->itemicons[L] = 0xFFFFFFFF; }
}
const ItemInst* inst = GetInv().GetItem(EQEmu::legacy::SlotAmmo);
const EQEmu::ItemInstance* inst = GetInv().GetItem(EQEmu::inventory::slotAmmo);
item = inst ? inst->GetItem() : nullptr;
if (item) {
@@ -8119,7 +8124,7 @@ void Client::Handle_OP_ItemLinkClick(const EQApplicationPacket *app)
// todo: verify ivrs->link_hash based on a rule, in case we don't care about people being able to sniff data
// from the item DB
const EQEmu::ItemBase *item = database.GetItem(ivrs->item_id);
const EQEmu::ItemData *item = database.GetItem(ivrs->item_id);
if (!item) {
if (ivrs->item_id != SAYLINK_ITEM_ID) {
Message(13, "Error: The item for the link you have clicked on does not exist!");
@@ -8177,7 +8182,7 @@ void Client::Handle_OP_ItemLinkClick(const EQApplicationPacket *app)
}
}
ItemInst *inst =
EQEmu::ItemInstance *inst =
database.CreateItem(item, item->MaxCharges, ivrs->augments[0], ivrs->augments[1], ivrs->augments[2],
ivrs->augments[3], ivrs->augments[4], ivrs->augments[5]);
if (inst) {
@@ -8194,7 +8199,7 @@ void Client::Handle_OP_ItemLinkResponse(const EQApplicationPacket *app)
return;
}
LDONItemViewRequest_Struct* item = (LDONItemViewRequest_Struct*)app->pBuffer;
ItemInst* inst = database.CreateItem(item->item_id);
EQEmu::ItemInstance* inst = database.CreateItem(item->item_id);
if (inst) {
SendItemPacket(0, inst, ItemPacketViewLink);
safe_delete(inst);
@@ -8210,7 +8215,7 @@ void Client::Handle_OP_ItemName(const EQApplicationPacket *app)
return;
}
ItemNamePacket_Struct *p = (ItemNamePacket_Struct*)app->pBuffer;
const EQEmu::ItemBase *item = 0;
const EQEmu::ItemData *item = 0;
if ((item = database.GetItem(p->item_id)) != nullptr) {
auto outapp = new EQApplicationPacket(OP_ItemName, sizeof(ItemNamePacket_Struct));
p = (ItemNamePacket_Struct*)outapp->pBuffer;
@@ -8226,7 +8231,7 @@ void Client::Handle_OP_ItemPreview(const EQApplicationPacket *app)
VERIFY_PACKET_LENGTH(OP_ItemPreview, app, ItemPreview_Struct);
ItemPreview_Struct *ips = (ItemPreview_Struct *)app->pBuffer;
const EQEmu::ItemBase* item = database.GetItem(ips->itemid);
const EQEmu::ItemData* item = database.GetItem(ips->itemid);
if (item) {
auto outapp = new EQApplicationPacket(OP_ItemPreview, strlen(item->Name) + strlen(item->Lore) +
@@ -8437,14 +8442,14 @@ void Client::Handle_OP_ItemVerifyRequest(const EQApplicationPacket *app)
return;
}
const ItemInst* inst = m_inv[slot_id];
const EQEmu::ItemInstance* inst = m_inv[slot_id];
if (!inst) {
Message(0, "Error: item not found in inventory slot #%i", slot_id);
DeleteItemInInventory(slot_id, 0, true);
return;
}
const EQEmu::ItemBase* item = inst->GetItem();
const EQEmu::ItemData* item = inst->GetItem();
if (!item) {
Message(0, "Error: item not found in inventory slot #%i", slot_id);
DeleteItemInInventory(slot_id, 0, true);
@@ -8480,7 +8485,7 @@ void Client::Handle_OP_ItemVerifyRequest(const EQApplicationPacket *app)
if (m_inv.SupportsClickCasting(slot_id) || ((item->ItemType == EQEmu::item::ItemTypePotion || item->PotionBelt) && m_inv.SupportsPotionBeltCasting(slot_id))) // sanity check
{
ItemInst* p_inst = (ItemInst*)inst;
EQEmu::ItemInstance* p_inst = (EQEmu::ItemInstance*)inst;
parse->EventItem(EVENT_ITEM_CLICK, this, p_inst, nullptr, "", slot_id);
inst = m_inv[slot_id];
@@ -8491,22 +8496,22 @@ void Client::Handle_OP_ItemVerifyRequest(const EQApplicationPacket *app)
int r;
bool tryaug = false;
ItemInst* clickaug = 0;
EQEmu::ItemBase* augitem = 0;
EQEmu::ItemInstance* clickaug = 0;
EQEmu::ItemData* augitem = 0;
for (r = 0; r < EQEmu::legacy::ITEM_COMMON_SIZE; r++) {
const ItemInst* aug_i = inst->GetAugment(r);
for (r = EQEmu::inventory::socketBegin; r < EQEmu::inventory::SocketCount; r++) {
const EQEmu::ItemInstance* aug_i = inst->GetAugment(r);
if (!aug_i)
continue;
const EQEmu::ItemBase* aug = aug_i->GetItem();
const EQEmu::ItemData* aug = aug_i->GetItem();
if (!aug)
continue;
if ((aug->Click.Type == EQEmu::item::ItemEffectClick) || (aug->Click.Type == EQEmu::item::ItemEffectExpendable) || (aug->Click.Type == EQEmu::item::ItemEffectEquipClick) || (aug->Click.Type == EQEmu::item::ItemEffectClick2))
{
tryaug = true;
clickaug = (ItemInst*)aug_i;
augitem = (EQEmu::ItemBase*)aug;
clickaug = (EQEmu::ItemInstance*)aug_i;
augitem = (EQEmu::ItemData*)aug;
spell_id = aug->Click.Effect;
break;
}
@@ -9674,8 +9679,8 @@ void Client::Handle_OP_MoveItem(const EQApplicationPacket *app)
if (mi->from_slot != mi->to_slot && (mi->from_slot <= EQEmu::legacy::GENERAL_END || mi->from_slot > 39) && IsValidSlot(mi->from_slot) && IsValidSlot(mi->to_slot))
{
char *detect = nullptr;
const ItemInst *itm_from = GetInv().GetItem(mi->from_slot);
const ItemInst *itm_to = GetInv().GetItem(mi->to_slot);
const EQEmu::ItemInstance *itm_from = GetInv().GetItem(mi->from_slot);
const EQEmu::ItemInstance *itm_to = GetInv().GetItem(mi->to_slot);
MakeAnyLenString(&detect, "Player issued a move item from %u(item id %u) to %u(item id %u) while casting %u.",
mi->from_slot,
itm_from ? itm_from->GetID() : 0,
@@ -10541,7 +10546,7 @@ void Client::Handle_OP_PotionBelt(const EQApplicationPacket *app)
}
if (mptbs->Action == 0) {
const EQEmu::ItemBase *BaseItem = database.GetItem(mptbs->ItemID);
const EQEmu::ItemData *BaseItem = database.GetItem(mptbs->ItemID);
if (BaseItem) {
m_pp.potionbelt.Items[mptbs->SlotNumber].ID = BaseItem->ID;
m_pp.potionbelt.Items[mptbs->SlotNumber].Icon = BaseItem->Icon;
@@ -12027,12 +12032,12 @@ void Client::Handle_OP_Shielding(const EQApplicationPacket *app)
Shielding_Struct* shield = (Shielding_Struct*)app->pBuffer;
shield_target = entity_list.GetMob(shield->target_id);
bool ack = false;
ItemInst* inst = GetInv().GetItem(EQEmu::legacy::SlotSecondary);
EQEmu::ItemInstance* inst = GetInv().GetItem(EQEmu::inventory::slotSecondary);
if (!shield_target)
return;
if (inst)
{
const EQEmu::ItemBase* shield = inst->GetItem();
const EQEmu::ItemData* shield = inst->GetItem();
if (shield && shield->ItemType == EQEmu::item::ItemTypeShield)
{
for (int x = 0; x < 2; x++)
@@ -12130,17 +12135,12 @@ void Client::Handle_OP_ShopPlayerBuy(const EQApplicationPacket *app)
continue;
}
int32 fac = tmp->GetPrimaryFaction();
if (fac != 0 && GetModCharacterFactionLevel(fac) < ml.faction_required) {
continue;
}
if (mp->itemslot == ml.slot){
item_id = ml.item;
break;
}
}
const EQEmu::ItemBase* item = nullptr;
const EQEmu::ItemData* item = nullptr;
uint32 prevcharges = 0;
if (item_id == 0) { //check to see if its on the temporary table
std::list<TempMerchantList> tmp_merlist = zone->tmpmerchanttable[tmp->GetNPCTypeID()];
@@ -12201,7 +12201,7 @@ void Client::Handle_OP_ShopPlayerBuy(const EQApplicationPacket *app)
else
charges = item->MaxCharges;
ItemInst* inst = database.CreateItem(item, charges);
EQEmu::ItemInstance* inst = database.CreateItem(item, charges);
int SinglePrice = 0;
if (RuleB(Merchant, UsePriceMod))
@@ -12244,8 +12244,8 @@ void Client::Handle_OP_ShopPlayerBuy(const EQApplicationPacket *app)
// shouldn't we be reimbursing if these two fail?
//make sure we are not completely full...
if (freeslotid == EQEmu::legacy::SlotCursor) {
if (m_inv.GetItem(EQEmu::legacy::SlotCursor) != nullptr) {
if (freeslotid == EQEmu::inventory::slotCursor) {
if (m_inv.GetItem(EQEmu::inventory::slotCursor) != nullptr) {
Message(13, "You do not have room for any more items.");
safe_delete(outapp);
safe_delete(inst);
@@ -12322,7 +12322,7 @@ void Client::Handle_OP_ShopPlayerBuy(const EQApplicationPacket *app)
qsaudit->items[0].item_id = item->ID;
qsaudit->items[0].charges = mpo->quantity;
const ItemInst* audit_inst = m_inv[freeslotid];
const EQEmu::ItemInstance* audit_inst = m_inv[freeslotid];
if (audit_inst) {
qsaudit->items[0].aug_1 = audit_inst->GetAugmentItemID(0);
@@ -12388,8 +12388,8 @@ void Client::Handle_OP_ShopPlayerSell(const EQApplicationPacket *app)
uint32 itemid = GetItemIDAt(mp->itemslot);
if (itemid == 0)
return;
const EQEmu::ItemBase* item = database.GetItem(itemid);
ItemInst* inst = GetInv().GetItem(mp->itemslot);
const EQEmu::ItemData* item = database.GetItem(itemid);
EQEmu::ItemInstance* inst = GetInv().GetItem(mp->itemslot);
if (!item || !inst){
Message(13, "You seemed to have misplaced that item..");
return;
@@ -12434,7 +12434,7 @@ void Client::Handle_OP_ShopPlayerSell(const EQApplicationPacket *app)
int freeslot = 0;
if (charges > 0 && (freeslot = zone->SaveTempItem(vendor->CastToNPC()->MerchantType, vendor->GetNPCTypeID(), itemid, charges, true)) > 0){
ItemInst* inst2 = inst->Clone();
EQEmu::ItemInstance* inst2 = inst->Clone();
while (true) {
if (inst2 == nullptr)
@@ -13499,7 +13499,7 @@ void Client::Handle_OP_Trader(const EQApplicationPacket *app)
TradeItemsValid = false;
break;
}
const EQEmu::ItemBase *Item = database.GetItem(gis->Items[i]);
const EQEmu::ItemData *Item = database.GetItem(gis->Items[i]);
if (!Item) {
Message(13, "Unexpected error. Unable to start trader mode");
zone/client_process.cpp
+37 -23
View File
@@ -296,7 +296,7 @@ bool Client::Process() {
}
if(AutoFireEnabled()){
ItemInst *ranged = GetInv().GetItem(EQEmu::legacy::SlotRange);
EQEmu::ItemInstance *ranged = GetInv().GetItem(EQEmu::inventory::slotRange);
if(ranged)
{
if (ranged->GetItem() && ranged->GetItem()->ItemType == EQEmu::item::ItemTypeBow){
@@ -391,10 +391,10 @@ bool Client::Process() {
}
else if (auto_attack_target->GetHP() > -10) // -10 so we can watch people bleed in PvP
{
ItemInst *wpn = GetInv().GetItem(EQEmu::legacy::SlotPrimary);
TryWeaponProc(wpn, auto_attack_target, EQEmu::legacy::SlotPrimary);
EQEmu::ItemInstance *wpn = GetInv().GetItem(EQEmu::inventory::slotPrimary);
TryWeaponProc(wpn, auto_attack_target, EQEmu::inventory::slotPrimary);
DoAttackRounds(auto_attack_target, EQEmu::legacy::SlotPrimary);
DoAttackRounds(auto_attack_target, EQEmu::inventory::slotPrimary);
if (CheckAATimer(aaTimerRampage))
entity_list.AEAttack(this, 30);
}
@@ -430,10 +430,10 @@ bool Client::Process() {
else if(auto_attack_target->GetHP() > -10) {
CheckIncreaseSkill(EQEmu::skills::SkillDualWield, auto_attack_target, -10);
if (CheckDualWield()) {
ItemInst *wpn = GetInv().GetItem(EQEmu::legacy::SlotSecondary);
TryWeaponProc(wpn, auto_attack_target, EQEmu::legacy::SlotSecondary);
EQEmu::ItemInstance *wpn = GetInv().GetItem(EQEmu::inventory::slotSecondary);
TryWeaponProc(wpn, auto_attack_target, EQEmu::inventory::slotSecondary);
DoAttackRounds(auto_attack_target, EQEmu::legacy::SlotSecondary);
DoAttackRounds(auto_attack_target, EQEmu::inventory::slotSecondary);
}
}
}
@@ -738,7 +738,7 @@ 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::legacy::TRADE_BEGIN; slot_id <= EQEmu::legacy::TRADE_END; slot_id++) {
ItemInst* inst = m_inv.PopItem(slot_id);
EQEmu::ItemInstance* inst = m_inv.PopItem(slot_id);
if(inst) {
bool is_arrow = (inst->GetItem()->ItemType == EQEmu::item::ItemTypeArrow) ? true : false;
int16 free_slot_id = m_inv.FindFreeSlot(inst->IsClassBag(), true, inst->GetItem()->Size, is_arrow);
@@ -763,8 +763,8 @@ void Client::BulkSendInventoryItems()
EQEmu::OutBuffer::pos_type last_pos = ob.tellp();
// Possessions items
for (int16 slot_id = SLOT_BEGIN; slot_id < EQEmu::legacy::TYPE_POSSESSIONS_SIZE; slot_id++) {
const ItemInst* inst = m_inv[slot_id];
for (int16 slot_id = EQEmu::inventory::slotBegin; slot_id < EQEmu::legacy::TYPE_POSSESSIONS_SIZE; slot_id++) {
const EQEmu::ItemInstance* inst = m_inv[slot_id];
if (!inst)
continue;
@@ -778,12 +778,12 @@ void Client::BulkSendInventoryItems()
// PowerSource item
if (ClientVersion() >= EQEmu::versions::ClientVersion::SoF) {
const ItemInst* inst = m_inv[EQEmu::legacy::SlotPowerSource];
const EQEmu::ItemInstance* inst = m_inv[EQEmu::inventory::slotPowerSource];
if (inst) {
inst->Serialize(ob, EQEmu::legacy::SlotPowerSource);
inst->Serialize(ob, EQEmu::inventory::slotPowerSource);
if (ob.tellp() == last_pos)
Log.Out(Logs::General, Logs::Inventory, "Serialization failed on item slot %d during BulkSendInventoryItems. Item skipped.", EQEmu::legacy::SlotPowerSource);
Log.Out(Logs::General, Logs::Inventory, "Serialization failed on item slot %d during BulkSendInventoryItems. Item skipped.", EQEmu::inventory::slotPowerSource);
last_pos = ob.tellp();
}
@@ -791,7 +791,7 @@ void Client::BulkSendInventoryItems()
// Bank items
for (int16 slot_id = EQEmu::legacy::BANK_BEGIN; slot_id <= EQEmu::legacy::BANK_END; slot_id++) {
const ItemInst* inst = m_inv[slot_id];
const EQEmu::ItemInstance* inst = m_inv[slot_id];
if (!inst)
continue;
@@ -805,7 +805,7 @@ void Client::BulkSendInventoryItems()
// SharedBank items
for (int16 slot_id = EQEmu::legacy::SHARED_BANK_BEGIN; slot_id <= EQEmu::legacy::SHARED_BANK_END; slot_id++) {
const ItemInst* inst = m_inv[slot_id];
const EQEmu::ItemInstance* inst = m_inv[slot_id];
if (!inst)
continue;
@@ -825,12 +825,12 @@ void Client::BulkSendInventoryItems()
}
void Client::BulkSendMerchantInventory(int merchant_id, int npcid) {
const EQEmu::ItemBase* handyitem = nullptr;
const EQEmu::ItemData* handyitem = nullptr;
uint32 numItemSlots = 80; //The max number of items passed in the transaction.
if (m_ClientVersionBit & EQEmu::versions::bit_RoFAndLater) { // RoF+ can send 200 items
numItemSlots = 200;
}
const EQEmu::ItemBase *item;
const EQEmu::ItemData *item;
std::list<MerchantList> merlist = zone->merchanttable[merchant_id];
std::list<MerchantList>::const_iterator itr;
Mob* merch = entity_list.GetMobByNpcTypeID(npcid);
@@ -857,7 +857,15 @@ void Client::BulkSendMerchantInventory(int merchant_id, int npcid) {
continue;
int32 fac = merch ? merch->GetPrimaryFaction() : 0;
if (fac != 0 && GetModCharacterFactionLevel(fac) < ml.faction_required)
int32 cur_fac_level;
if (fac == 0 || sneaking) {
cur_fac_level = 0;
}
else {
cur_fac_level = GetModCharacterFactionLevel(fac);
}
if (cur_fac_level < ml.faction_required)
continue;
handychance = zone->random.Int(0, merlist.size() + tmp_merlist.size() - 1);
@@ -871,7 +879,7 @@ void Client::BulkSendMerchantInventory(int merchant_id, int npcid) {
int charges = 1;
if (item->IsClassCommon())
charges = item->MaxCharges;
ItemInst* inst = database.CreateItem(item, charges);
EQEmu::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)));
@@ -912,7 +920,7 @@ void Client::BulkSendMerchantInventory(int merchant_id, int npcid) {
// charges=ml.charges;
//else
charges = item->MaxCharges;
ItemInst* inst = database.CreateItem(item, charges);
EQEmu::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)));
@@ -1087,11 +1095,11 @@ void Client::OPMemorizeSpell(const EQApplicationPacket* app)
switch(memspell->scribing)
{
case memSpellScribing: { // scribing spell to book
const ItemInst* inst = m_inv[EQEmu::legacy::SlotCursor];
const EQEmu::ItemInstance* inst = m_inv[EQEmu::inventory::slotCursor];
if (inst && inst->IsClassCommon())
{
const EQEmu::ItemBase* item = inst->GetItem();
const EQEmu::ItemData* item = inst->GetItem();
if (RuleB(Character, RestrictSpellScribing) && !item->IsEquipable(GetRace(), GetClass())) {
Message_StringID(13, CANNOT_USE_ITEM);
@@ -1101,7 +1109,7 @@ void Client::OPMemorizeSpell(const EQApplicationPacket* app)
if(item && item->Scroll.Effect == (int32)(memspell->spell_id))
{
ScribeSpell(memspell->spell_id, memspell->slot);
DeleteItemInInventory(EQEmu::legacy::SlotCursor, 1, true);
DeleteItemInInventory(EQEmu::inventory::slotCursor, 1, true);
}
else
Message(0,"Scribing spell: inst exists but item does not or spell ids do not match.");
@@ -1186,6 +1194,12 @@ void Client::OPMoveCoin(const EQApplicationPacket* app)
int32 *from_bucket = 0, *to_bucket = 0;
Mob* trader = trade->With();
// if amount < 0, client is sending a malicious packet
if (mc->amount < 0)
{
return;
}
// could just do a range, but this is clearer and explicit
if
(
zone/command.cpp
+57 -44
View File
@@ -1471,16 +1471,29 @@ void command_npcstats(Client *c, const Seperator *sep)
else if (!c->GetTarget()->IsNPC())
c->Message(0, "ERROR: Target is not a NPC!");
else {
auto target_npc = c->GetTarget()->CastToNPC();
c->Message(0, "NPC Stats:");
c->Message(0, "Name: %s NpcID: %u", c->GetTarget()->GetName(), c->GetTarget()->GetNPCTypeID());
c->Message(0, "Race: %i Level: %i Class: %i Material: %i", c->GetTarget()->GetRace(), c->GetTarget()->GetLevel(), c->GetTarget()->GetClass(), c->GetTarget()->GetTexture());
c->Message(0, "Current HP: %i Max HP: %i", c->GetTarget()->GetHP(), c->GetTarget()->GetMaxHP());
//c->Message(0, "Weapon Item Number: %s", c->GetTarget()->GetWeapNo());
c->Message(0, "Gender: %i Size: %f Bodytype: %d", c->GetTarget()->GetGender(), c->GetTarget()->GetSize(), c->GetTarget()->GetBodyType());
c->Message(0, "Runspeed: %.3f Walkspeed: %.3f", static_cast<float>(0.025f * c->GetTarget()->GetRunspeed()), static_cast<float>(0.025f * c->GetTarget()->GetWalkspeed()));
c->Message(0, "Spawn Group: %i Grid: %i", c->GetTarget()->CastToNPC()->GetSp2(), c->GetTarget()->CastToNPC()->GetGrid());
c->Message(0, "EmoteID: %i", c->GetTarget()->CastToNPC()->GetEmoteID());
c->GetTarget()->CastToNPC()->QueryLoot(c);
c->Message(0, "Name: %s NpcID: %u", target_npc->GetName(), target_npc->GetNPCTypeID());
c->Message(0, "Race: %i Level: %i Class: %i Material: %i", target_npc->GetRace(), target_npc->GetLevel(), target_npc->GetClass(), target_npc->GetTexture());
c->Message(0, "Current HP: %i Max HP: %i", target_npc->GetHP(), target_npc->GetMaxHP());
//c->Message(0, "Weapon Item Number: %s", target_npc->GetWeapNo());
c->Message(0, "Gender: %i Size: %f Bodytype: %d", target_npc->GetGender(), target_npc->GetSize(), target_npc->GetBodyType());
c->Message(0, "Runspeed: %.3f Walkspeed: %.3f", static_cast<float>(0.025f * target_npc->GetRunspeed()), static_cast<float>(0.025f * target_npc->GetWalkspeed()));
c->Message(0, "Spawn Group: %i Grid: %i", target_npc->GetSp2(), target_npc->GetGrid());
if (target_npc->proximity) {
c->Message(0, "Proximity: Enabled");
c->Message(0, "Cur_X: %1.3f, Cur_Y: %1.3f, Cur_Z: %1.3f", target_npc->GetX(), target_npc->GetY(), target_npc->GetZ());
c->Message(0, "Min_X: %1.3f(%1.3f), Max_X: %1.3f(%1.3f), X_Range: %1.3f", target_npc->proximity->min_x, (target_npc->proximity->min_x - target_npc->GetX()), target_npc->proximity->max_x, (target_npc->proximity->max_x - target_npc->GetX()), (target_npc->proximity->max_x - target_npc->proximity->min_x));
c->Message(0, "Min_Y: %1.3f(%1.3f), Max_Y: %1.3f(%1.3f), Y_Range: %1.3f", target_npc->proximity->min_y, (target_npc->proximity->min_y - target_npc->GetY()), target_npc->proximity->max_y, (target_npc->proximity->max_y - target_npc->GetY()), (target_npc->proximity->max_y - target_npc->proximity->min_y));
c->Message(0, "Min_Z: %1.3f(%1.3f), Max_Z: %1.3f(%1.3f), Z_Range: %1.3f", target_npc->proximity->min_z, (target_npc->proximity->min_z - target_npc->GetZ()), target_npc->proximity->max_z, (target_npc->proximity->max_z - target_npc->GetZ()), (target_npc->proximity->max_z - target_npc->proximity->min_z));
c->Message(0, "Say: %s", (target_npc->proximity->say ? "Enabled" : "Disabled"));
}
else {
c->Message(0, "Proximity: Disabled");
}
c->Message(0, "");
c->Message(0, "EmoteID: %i", target_npc->GetEmoteID());
target_npc->QueryLoot(c);
}
}
@@ -2417,14 +2430,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 = EQEmu::textures::textureBegin; i <= EQEmu::textures::LastTintableTexture; i++)
{
c->SendTextureWC(i, texture);
}
else if ((c->GetTarget()->GetRace() > 0 && c->GetTarget()->GetRace() <= 12) ||
c->GetTarget()->GetRace() == 128 || c->GetTarget()->GetRace() == 130 ||
c->GetTarget()->GetRace() == 330 || c->GetTarget()->GetRace() == 522) {
for (i = EQEmu::textures::TextureBegin; i <= EQEmu::textures::LastTintableTexture; i++)
for (i = EQEmu::textures::textureBegin; i <= EQEmu::textures::LastTintableTexture; i++)
{
c->GetTarget()->SendTextureWC(i, texture);
}
@@ -2545,9 +2558,9 @@ void command_peekinv(Client *c, const Seperator *sep)
}
Client* targetClient = c->GetTarget()->CastToClient();
const ItemInst* inst_main = nullptr;
const ItemInst* inst_sub = nullptr;
const EQEmu::ItemBase* item_data = nullptr;
const EQEmu::ItemInstance* inst_main = nullptr;
const EQEmu::ItemInstance* inst_sub = nullptr;
const EQEmu::ItemData* item_data = nullptr;
std::string item_link;
EQEmu::SayLinkEngine linker;
linker.SetLinkType(EQEmu::saylink::SayLinkItemInst);
@@ -2567,14 +2580,14 @@ void command_peekinv(Client *c, const Seperator *sep)
}
if ((scopeWhere & peekWorn) && (targetClient->ClientVersion() >= EQEmu::versions::ClientVersion::SoF)) {
inst_main = targetClient->GetInv().GetItem(EQEmu::legacy::SlotPowerSource);
inst_main = targetClient->GetInv().GetItem(EQEmu::inventory::slotPowerSource);
item_data = (inst_main == nullptr) ? nullptr : inst_main->GetItem();
linker.SetItemInst(inst_main);
item_link = linker.GenerateLink();
c->Message((item_data == nullptr), "WornSlot: %i, Item: %i (%s), Charges: %i",
EQEmu::legacy::SlotPowerSource, ((item_data == nullptr) ? 0 : item_data->ID), item_link.c_str(), ((inst_main == nullptr) ? 0 : inst_main->GetCharges()));
EQEmu::inventory::slotPowerSource, ((item_data == nullptr) ? 0 : item_data->ID), item_link.c_str(), ((inst_main == nullptr) ? 0 : inst_main->GetCharges()));
}
// inv
@@ -2588,7 +2601,7 @@ void command_peekinv(Client *c, const Seperator *sep)
c->Message((item_data == nullptr), "InvSlot: %i, Item: %i (%s), Charges: %i",
indexMain, ((item_data == nullptr) ? 0 : item_data->ID), item_link.c_str(), ((inst_main == nullptr) ? 0 : inst_main->GetCharges()));
for (uint8 indexSub = SUB_INDEX_BEGIN; inst_main && inst_main->IsClassBag() && (indexSub < EQEmu::legacy::ITEM_CONTAINER_SIZE); ++indexSub) {
for (uint8 indexSub = EQEmu::inventory::containerBegin; inst_main && inst_main->IsClassBag() && (indexSub < EQEmu::inventory::ContainerCount); ++indexSub) {
inst_sub = inst_main->GetItem(indexSub);
item_data = (inst_sub == nullptr) ? nullptr : inst_sub->GetItem();
linker.SetItemInst(inst_sub);
@@ -2596,7 +2609,7 @@ void command_peekinv(Client *c, const Seperator *sep)
item_link = linker.GenerateLink();
c->Message((item_data == nullptr), " InvBagSlot: %i (Slot #%i, Bag #%i), Item: %i (%s), Charges: %i",
Inventory::CalcSlotId(indexMain, indexSub), indexMain, indexSub, ((item_data == nullptr) ? 0 : item_data->ID), item_link.c_str(), ((inst_sub == nullptr) ? 0 : inst_sub->GetCharges()));
EQEmu::InventoryProfile::CalcSlotId(indexMain, indexSub), indexMain, indexSub, ((item_data == nullptr) ? 0 : item_data->ID), item_link.c_str(), ((inst_sub == nullptr) ? 0 : inst_sub->GetCharges()));
}
}
@@ -2608,7 +2621,7 @@ void command_peekinv(Client *c, const Seperator *sep)
item_link = linker.GenerateLink();
c->Message(1, "CursorSlot: %i, Item: %i (%s), Charges: %i",
EQEmu::legacy::SlotCursor, 0, item_link.c_str(), 0);
EQEmu::inventory::slotCursor, 0, item_link.c_str(), 0);
}
else {
int cursorDepth = 0;
@@ -2620,9 +2633,9 @@ void command_peekinv(Client *c, const Seperator *sep)
item_link = linker.GenerateLink();
c->Message((item_data == nullptr), "CursorSlot: %i, Depth: %i, Item: %i (%s), Charges: %i",
EQEmu::legacy::SlotCursor, cursorDepth, ((item_data == nullptr) ? 0 : item_data->ID), item_link.c_str(), ((inst_main == nullptr) ? 0 : inst_main->GetCharges()));
EQEmu::inventory::slotCursor, cursorDepth, ((item_data == nullptr) ? 0 : item_data->ID), item_link.c_str(), ((inst_main == nullptr) ? 0 : inst_main->GetCharges()));
for (uint8 indexSub = SUB_INDEX_BEGIN; (cursorDepth == 0) && inst_main && inst_main->IsClassBag() && (indexSub < EQEmu::legacy::ITEM_CONTAINER_SIZE); ++indexSub) {
for (uint8 indexSub = EQEmu::inventory::containerBegin; (cursorDepth == 0) && inst_main && inst_main->IsClassBag() && (indexSub < EQEmu::inventory::ContainerCount); ++indexSub) {
inst_sub = inst_main->GetItem(indexSub);
item_data = (inst_sub == nullptr) ? nullptr : inst_sub->GetItem();
linker.SetItemInst(inst_sub);
@@ -2630,7 +2643,7 @@ void command_peekinv(Client *c, const Seperator *sep)
item_link = linker.GenerateLink();
c->Message((item_data == nullptr), " CursorBagSlot: %i (Slot #%i, Bag #%i), Item: %i (%s), Charges: %i",
Inventory::CalcSlotId(EQEmu::legacy::SlotCursor, indexSub), EQEmu::legacy::SlotCursor, indexSub, ((item_data == nullptr) ? 0 : item_data->ID), item_link.c_str(), ((inst_sub == nullptr) ? 0 : inst_sub->GetCharges()));
EQEmu::InventoryProfile::CalcSlotId(EQEmu::inventory::slotCursor, indexSub), EQEmu::inventory::slotCursor, indexSub, ((item_data == nullptr) ? 0 : item_data->ID), item_link.c_str(), ((inst_sub == nullptr) ? 0 : inst_sub->GetCharges()));
}
}
}
@@ -2659,7 +2672,7 @@ void command_peekinv(Client *c, const Seperator *sep)
c->Message((item_data == nullptr), "BankSlot: %i, Item: %i (%s), Charges: %i",
indexMain, ((item_data == nullptr) ? 0 : item_data->ID), item_link.c_str(), ((inst_main == nullptr) ? 0 : inst_main->GetCharges()));
for (uint8 indexSub = SUB_INDEX_BEGIN; inst_main && inst_main->IsClassBag() && (indexSub < EQEmu::legacy::ITEM_CONTAINER_SIZE); ++indexSub) {
for (uint8 indexSub = EQEmu::inventory::containerBegin; inst_main && inst_main->IsClassBag() && (indexSub < EQEmu::inventory::ContainerCount); ++indexSub) {
inst_sub = inst_main->GetItem(indexSub);
item_data = (inst_sub == nullptr) ? nullptr : inst_sub->GetItem();
linker.SetItemInst(inst_sub);
@@ -2667,7 +2680,7 @@ void command_peekinv(Client *c, const Seperator *sep)
item_link = linker.GenerateLink();
c->Message((item_data == nullptr), " BankBagSlot: %i (Slot #%i, Bag #%i), Item: %i (%s), Charges: %i",
Inventory::CalcSlotId(indexMain, indexSub), indexMain, indexSub, ((item_data == nullptr) ? 0 : item_data->ID), item_link.c_str(), ((inst_sub == nullptr) ? 0 : inst_sub->GetCharges()));
EQEmu::InventoryProfile::CalcSlotId(indexMain, indexSub), indexMain, indexSub, ((item_data == nullptr) ? 0 : item_data->ID), item_link.c_str(), ((inst_sub == nullptr) ? 0 : inst_sub->GetCharges()));
}
}
@@ -2681,7 +2694,7 @@ void command_peekinv(Client *c, const Seperator *sep)
c->Message((item_data == nullptr), "SharedBankSlot: %i, Item: %i (%s), Charges: %i",
indexMain, ((item_data == nullptr) ? 0 : item_data->ID), item_link.c_str(), ((inst_main == nullptr) ? 0 : inst_main->GetCharges()));
for (uint8 indexSub = SUB_INDEX_BEGIN; inst_main && inst_main->IsClassBag() && (indexSub < EQEmu::legacy::ITEM_CONTAINER_SIZE); ++indexSub) {
for (uint8 indexSub = EQEmu::inventory::containerBegin; inst_main && inst_main->IsClassBag() && (indexSub < EQEmu::inventory::ContainerCount); ++indexSub) {
inst_sub = inst_main->GetItem(indexSub);
item_data = (inst_sub == nullptr) ? nullptr : inst_sub->GetItem();
linker.SetItemInst(inst_sub);
@@ -2689,7 +2702,7 @@ void command_peekinv(Client *c, const Seperator *sep)
item_link = linker.GenerateLink();
c->Message((item_data == nullptr), " SharedBankBagSlot: %i (Slot #%i, Bag #%i), Item: %i (%s), Charges: %i",
Inventory::CalcSlotId(indexMain, indexSub), indexMain, indexSub, ((item_data == nullptr) ? 0 : item_data->ID), item_link.c_str(), ((inst_sub == nullptr) ? 0 : inst_sub->GetCharges()));
EQEmu::InventoryProfile::CalcSlotId(indexMain, indexSub), indexMain, indexSub, ((item_data == nullptr) ? 0 : item_data->ID), item_link.c_str(), ((inst_sub == nullptr) ? 0 : inst_sub->GetCharges()));
}
}
@@ -2704,7 +2717,7 @@ void command_peekinv(Client *c, const Seperator *sep)
c->Message((item_data == nullptr), "TradeSlot: %i, Item: %i (%s), Charges: %i",
indexMain, ((item_data == nullptr) ? 0 : item_data->ID), item_link.c_str(), ((inst_main == nullptr) ? 0 : inst_main->GetCharges()));
for (uint8 indexSub = SUB_INDEX_BEGIN; inst_main && inst_main->IsClassBag() && (indexSub < EQEmu::legacy::ITEM_CONTAINER_SIZE); ++indexSub) {
for (uint8 indexSub = EQEmu::inventory::containerBegin; inst_main && inst_main->IsClassBag() && (indexSub < EQEmu::inventory::ContainerCount); ++indexSub) {
inst_sub = inst_main->GetItem(indexSub);
item_data = (inst_sub == nullptr) ? nullptr : inst_sub->GetItem();
linker.SetItemInst(inst_sub);
@@ -2712,7 +2725,7 @@ void command_peekinv(Client *c, const Seperator *sep)
item_link = linker.GenerateLink();
c->Message((item_data == nullptr), " TradeBagSlot: %i (Slot #%i, Bag #%i), Item: %i (%s), Charges: %i",
Inventory::CalcSlotId(indexMain, indexSub), indexMain, indexSub, ((item_data == nullptr) ? 0 : item_data->ID), item_link.c_str(), ((inst_sub == nullptr) ? 0 : inst_sub->GetCharges()));
EQEmu::InventoryProfile::CalcSlotId(indexMain, indexSub), indexMain, indexSub, ((item_data == nullptr) ? 0 : item_data->ID), item_link.c_str(), ((inst_sub == nullptr) ? 0 : inst_sub->GetCharges()));
}
}
@@ -2726,7 +2739,7 @@ void command_peekinv(Client *c, const Seperator *sep)
else {
c->Message(0, "[WorldObject DBID: %i (entityid: %i)]", objectTradeskill->GetDBID(), objectTradeskill->GetID());
for (int16 indexMain = SLOT_BEGIN; indexMain < EQEmu::legacy::TYPE_WORLD_SIZE; ++indexMain) {
for (int16 indexMain = EQEmu::inventory::slotBegin; indexMain < EQEmu::legacy::TYPE_WORLD_SIZE; ++indexMain) {
inst_main = objectTradeskill->GetItem(indexMain);
item_data = (inst_main == nullptr) ? nullptr : inst_main->GetItem();
linker.SetItemInst(inst_main);
@@ -2736,7 +2749,7 @@ void command_peekinv(Client *c, const Seperator *sep)
c->Message((item_data == nullptr), "WorldSlot: %i, Item: %i (%s), Charges: %i",
(EQEmu::legacy::WORLD_BEGIN + indexMain), ((item_data == nullptr) ? 0 : item_data->ID), item_link.c_str(), ((inst_main == nullptr) ? 0 : inst_main->GetCharges()));
for (uint8 indexSub = SUB_INDEX_BEGIN; inst_main && inst_main->IsType(EQEmu::item::ItemClassBag) && (indexSub < EQEmu::legacy::ITEM_CONTAINER_SIZE); ++indexSub) {
for (uint8 indexSub = EQEmu::inventory::containerBegin; inst_main && inst_main->IsType(EQEmu::item::ItemClassBag) && (indexSub < EQEmu::inventory::ContainerCount); ++indexSub) {
inst_sub = inst_main->GetItem(indexSub);
item_data = (inst_sub == nullptr) ? nullptr : inst_sub->GetItem();
linker.SetItemInst(inst_sub);
@@ -2780,7 +2793,7 @@ void command_interrogateinv(Client *c, const Seperator *sep)
}
Client* target = nullptr;
std::map<int16, const ItemInst*> instmap;
std::map<int16, const EQEmu::ItemInstance*> instmap;
bool log = false;
bool silent = false;
bool error = false;
@@ -3145,16 +3158,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::legacy::EQUIPMENT_BEGIN) && (slot_id <= EQEmu::legacy::EQUIPMENT_END) || (slot_id == EQEmu::legacy::SlotPowerSource))) {
const ItemInst* from_inst = c->GetInv().GetItem(EQEmu::legacy::SlotCursor);
const ItemInst* to_inst = c->GetInv().GetItem(slot_id); // added (desync issue when forcing stack to stack)
if (sep->IsNumber(1) && ((slot_id >= EQEmu::legacy::EQUIPMENT_BEGIN) && (slot_id <= EQEmu::legacy::EQUIPMENT_END) || (slot_id == EQEmu::inventory::slotPowerSource))) {
const EQEmu::ItemInstance* from_inst = c->GetInv().GetItem(EQEmu::inventory::slotCursor);
const EQEmu::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::legacy::SlotCursor;
mi->from_slot = EQEmu::inventory::slotCursor;
mi->to_slot = slot_id;
// mi->number_in_stack = from_inst->GetCharges(); // replaced with con check for stacking
@@ -4339,7 +4352,7 @@ void command_goto(Client *c, const Seperator *sep)
void command_iteminfo(Client *c, const Seperator *sep)
{
auto inst = c->GetInv()[EQEmu::legacy::SlotCursor];
auto inst = c->GetInv()[EQEmu::inventory::slotCursor];
if (!inst) {
c->Message(13, "Error: You need an item on your cursor for this command");
return;
@@ -5519,7 +5532,7 @@ void command_summonitem(Client *c, const Seperator *sep)
}
int16 item_status = 0;
const EQEmu::ItemBase* item = database.GetItem(itemid);
const EQEmu::ItemData* item = database.GetItem(itemid);
if (item) {
item_status = static_cast<int16>(item->MinStatus);
}
@@ -5558,7 +5571,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::ItemBase* item = database.GetItem(itemid);
const EQEmu::ItemData* item = database.GetItem(itemid);
if(item) {
item_status = static_cast<int16>(item->MinStatus);
}
@@ -5611,7 +5624,7 @@ void command_itemsearch(Client *c, const Seperator *sep)
{
const char *search_criteria=sep->argplus[1];
const EQEmu::ItemBase* item = nullptr;
const EQEmu::ItemData* item = nullptr;
std::string item_link;
EQEmu::SayLinkEngine linker;
linker.SetLinkType(EQEmu::saylink::SayLinkItemData);
@@ -7124,9 +7137,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 = EQEmu::textures::textureBegin; cur_slot <= EQEmu::textures::LastTexture; cur_slot++) {
uint8 slot2=SlotConvert(cur_slot);
ItemInst* inst = m_inv.GetItem(slot2);
EQEmu::ItemInstance* inst = m_inv.GetItem(slot2);
if(inst != nullptr) {
inst->SetColor(inst->GetItem()->Color);
@@ -10235,7 +10248,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::ItemBase* FakeItem = database.GetItem(itemid);
const EQEmu::ItemData* FakeItem = database.GetItem(itemid);
if (!FakeItem) {
c->Message(13, "Error: Item [%u] is not a valid item id.", itemid);
@@ -10243,7 +10256,7 @@ void command_zopp(Client *c, const Seperator *sep)
}
int16 item_status = 0;
const EQEmu::ItemBase* item = database.GetItem(itemid);
const EQEmu::ItemData* item = database.GetItem(itemid);
if(item) {
item_status = static_cast<int16>(item->MinStatus);
}
@@ -10257,7 +10270,7 @@ void command_zopp(Client *c, const Seperator *sep)
c->Message(0, "Processing request..results may cause unpredictable behavior.");
}
ItemInst* FakeItemInst = database.CreateItem(FakeItem, charges);
EQEmu::ItemInstance* FakeItemInst = database.CreateItem(FakeItem, charges);
c->SendItemPacket(slotid, FakeItemInst, packettype);
c->Message(0, "Sending zephyr op packet to client - [%s] %s (%u) with %i %s to slot %i.",
packettype == ItemPacketTrade ? "Trade" : "Summon", FakeItem->Name, itemid, charges,
zone/common.h
+6 -2
View File
@@ -568,7 +568,11 @@ struct MercData {
uint32 NPCID;
};
class ItemInst;
namespace EQEmu
{
class ItemInstance;
}
class Mob;
// All data associated with a single trade
class Trade
@@ -606,7 +610,7 @@ public:
private:
// Send item data for trade item to other person involved in trade
void SendItemData(const ItemInst* inst, int16 dest_slot_id);
void SendItemData(const EQEmu::ItemInstance* inst, int16 dest_slot_id);
uint32 with_id;
Mob* owner;
zone/corpse.cpp
+37 -37
View File
@@ -268,7 +268,7 @@ Corpse::Corpse(Client* client, int32 in_rezexp) : Mob (
int i;
PlayerProfile_Struct *pp = &client->GetPP();
ItemInst *item;
EQEmu::ItemInstance *item;
/* Check if Zone has Graveyard First */
if(!zone->HasGraveyard()) {
@@ -323,12 +323,12 @@ Corpse::Corpse(Client* client, int32 in_rezexp) : Mob (
// to go into the regular slots on the player, out of bags
std::list<uint32> removed_list;
for (i = SLOT_BEGIN; i < EQEmu::legacy::TYPE_POSSESSIONS_SIZE; ++i) {
if (i == EQEmu::legacy::SlotAmmo && client->ClientVersion() >= EQEmu::versions::ClientVersion::SoF) {
item = client->GetInv().GetItem(EQEmu::legacy::SlotPowerSource);
for (i = EQEmu::inventory::slotBegin; i < EQEmu::legacy::TYPE_POSSESSIONS_SIZE; ++i) {
if (i == EQEmu::inventory::slotAmmo && client->ClientVersion() >= EQEmu::versions::ClientVersion::SoF) {
item = client->GetInv().GetItem(EQEmu::inventory::slotPowerSource);
if (item != nullptr) {
if (!client->IsBecomeNPC() || (client->IsBecomeNPC() && !item->GetItem()->NoRent))
MoveItemToCorpse(client, item, EQEmu::legacy::SlotPowerSource, removed_list);
MoveItemToCorpse(client, item, EQEmu::inventory::slotPowerSource, removed_list);
}
}
@@ -387,7 +387,7 @@ Corpse::Corpse(Client* client, int32 in_rezexp) : Mob (
Save();
}
void Corpse::MoveItemToCorpse(Client *client, ItemInst *inst, int16 equipSlot, std::list<uint32> &removedList)
void Corpse::MoveItemToCorpse(Client *client, EQEmu::ItemInstance *inst, int16 equipSlot, std::list<uint32> &removedList)
{
AddItem(
inst->GetItem()->ID,
@@ -405,10 +405,10 @@ void Corpse::MoveItemToCorpse(Client *client, ItemInst *inst, int16 equipSlot, s
while (true) {
if (!inst->IsClassBag()) { break; }
if (equipSlot < EQEmu::legacy::GENERAL_BEGIN || equipSlot > EQEmu::legacy::SlotCursor) { break; }
if (equipSlot < EQEmu::legacy::GENERAL_BEGIN || equipSlot > EQEmu::inventory::slotCursor) { break; }
for (auto sub_index = SUB_INDEX_BEGIN; sub_index < EQEmu::legacy::ITEM_CONTAINER_SIZE; ++sub_index) {
int16 real_bag_slot = Inventory::CalcSlotId(equipSlot, sub_index);
for (int16 sub_index = EQEmu::inventory::containerBegin; sub_index < EQEmu::inventory::ContainerCount; ++sub_index) {
int16 real_bag_slot = EQEmu::InventoryProfile::CalcSlotId(equipSlot, sub_index);
auto bag_inst = client->GetInv().GetItem(real_bag_slot);
if (bag_inst == nullptr) { continue; }
@@ -684,8 +684,8 @@ ServerLootItem_Struct* Corpse::GetItem(uint16 lootslot, ServerLootItem_Struct**
}
}
if (sitem && bag_item_data && Inventory::SupportsContainers(sitem->equip_slot)) {
int16 bagstart = Inventory::CalcSlotId(sitem->equip_slot, SUB_INDEX_BEGIN);
if (sitem && bag_item_data && EQEmu::InventoryProfile::SupportsContainers(sitem->equip_slot)) {
int16 bagstart = EQEmu::InventoryProfile::CalcSlotId(sitem->equip_slot, EQEmu::inventory::containerBegin);
cur = itemlist.begin();
end = itemlist.end();
@@ -739,8 +739,8 @@ void Corpse::RemoveItem(ServerLootItem_Struct* item_data)
is_corpse_changed = true;
itemlist.erase(iter);
uint8 material = Inventory::CalcMaterialFromSlot(sitem->equip_slot); // autos to unsigned char
if (material != EQEmu::textures::TextureInvalid)
uint8 material = EQEmu::InventoryProfile::CalcMaterialFromSlot(sitem->equip_slot); // autos to unsigned char
if (material != EQEmu::textures::materialInvalid)
SendWearChange(material);
UpdateEquipmentLight();
@@ -979,8 +979,8 @@ void Corpse::MakeLootRequestPackets(Client* client, const EQApplicationPacket* a
safe_delete(outapp);
if(Loot_Request_Type == 5) {
int pkitem = GetPlayerKillItem();
const EQEmu::ItemBase* item = database.GetItem(pkitem);
ItemInst* inst = database.CreateItem(item, item->MaxCharges);
const EQEmu::ItemData* item = database.GetItem(pkitem);
EQEmu::ItemInstance* inst = database.CreateItem(item, item->MaxCharges);
if(inst) {
if (item->RecastDelay)
inst->SetRecastTimestamp(timestamps.count(item->RecastType) ? timestamps.at(item->RecastType) : 0);
@@ -994,12 +994,12 @@ void Corpse::MakeLootRequestPackets(Client* client, const EQApplicationPacket* a
}
int i = 0;
const EQEmu::ItemBase* item = 0;
const EQEmu::ItemData* item = 0;
ItemList::iterator cur,end;
cur = itemlist.begin();
end = itemlist.end();
int corpselootlimit = EQEmu::inventory::Lookup(EQEmu::versions::ConvertClientVersionToInventoryVersion(client->ClientVersion()))->InventoryTypeSize[EQEmu::legacy::TypeCorpse];
int corpselootlimit = EQEmu::inventory::Lookup(EQEmu::versions::ConvertClientVersionToMobVersion(client->ClientVersion()))->InventoryTypeSize[EQEmu::inventory::typeCorpse];
for(; cur != end; ++cur) {
ServerLootItem_Struct* item_data = *cur;
@@ -1008,12 +1008,12 @@ void Corpse::MakeLootRequestPackets(Client* client, const EQApplicationPacket* a
// Dont display the item if it's in a bag
// Added cursor queue slots to corpse item visibility list. Nothing else should be making it to corpse.
if (!IsPlayerCorpse() || item_data->equip_slot <= EQEmu::legacy::SlotCursor || item_data->equip_slot == EQEmu::legacy::SlotPowerSource || Loot_Request_Type >= 3 ||
if (!IsPlayerCorpse() || item_data->equip_slot <= EQEmu::inventory::slotCursor || item_data->equip_slot == EQEmu::inventory::slotPowerSource || Loot_Request_Type >= 3 ||
(item_data->equip_slot >= 8000 && item_data->equip_slot <= 8999)) {
if(i < corpselootlimit) {
item = database.GetItem(item_data->item_id);
if(client && item) {
ItemInst* inst = database.CreateItem(item, item_data->charges, item_data->aug_1, item_data->aug_2, item_data->aug_3, item_data->aug_4, item_data->aug_5, item_data->aug_6, item_data->attuned);
EQEmu::ItemInstance* inst = database.CreateItem(item, item_data->charges, item_data->aug_1, item_data->aug_2, item_data->aug_3, item_data->aug_4, item_data->aug_5, item_data->aug_6, item_data->attuned);
if(inst) {
if (item->RecastDelay)
inst->SetRecastTimestamp(timestamps.count(item->RecastType) ? timestamps.at(item->RecastType) : 0);
@@ -1110,8 +1110,8 @@ void Corpse::LootItem(Client* client, const EQApplicationPacket* app) {
being_looted_by = 0xFFFFFFFF;
return;
}
const EQEmu::ItemBase* item = 0;
ItemInst *inst = 0;
const EQEmu::ItemData* item = 0;
EQEmu::ItemInstance *inst = 0;
ServerLootItem_Struct* item_data = nullptr, *bag_item_data[10];
memset(bag_item_data, 0, sizeof(bag_item_data));
@@ -1148,8 +1148,8 @@ void Corpse::LootItem(Client* client, const EQApplicationPacket* app) {
}
if (inst->IsAugmented()) {
for (int i = AUG_INDEX_BEGIN; i < EQEmu::legacy::ITEM_COMMON_SIZE; i++) {
ItemInst *itm = inst->GetAugment(i);
for (int i = EQEmu::inventory::socketBegin; i < EQEmu::inventory::SocketCount; i++) {
EQEmu::ItemInstance *itm = inst->GetAugment(i);
if (itm) {
if (client->CheckLoreConflict(itm->GetItem())) {
client->Message_StringID(0, LOOT_LORE_ERROR);
@@ -1190,10 +1190,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) {
if (!client->AutoPutLootInInventory(*inst, true, true, bag_item_data))
client->PutLootInInventory(EQEmu::legacy::SlotCursor, *inst, bag_item_data);
client->PutLootInInventory(EQEmu::inventory::slotCursor, *inst, bag_item_data);
}
else {
client->PutLootInInventory(EQEmu::legacy::SlotCursor, *inst, bag_item_data);
client->PutLootInInventory(EQEmu::inventory::slotCursor, *inst, bag_item_data);
}
/* Update any tasks that have an activity to loot this item */
@@ -1210,7 +1210,7 @@ void Corpse::LootItem(Client* client, const EQApplicationPacket* app) {
/* Remove Bag Contents */
if (item->IsClassBag() && (GetPlayerKillItem() != -1 || GetPlayerKillItem() != 1)) {
for (int i = SUB_INDEX_BEGIN; i < EQEmu::legacy::ITEM_CONTAINER_SIZE; i++) {
for (int i = EQEmu::inventory::containerBegin; i < EQEmu::inventory::ContainerCount; i++) {
if (bag_item_data[i]) {
/* Delete needs to be before RemoveItem because its deletes the pointer for item_data/bag_item_data */
database.DeleteItemOffCharacterCorpse(this->corpse_db_id, bag_item_data[i]->equip_slot, bag_item_data[i]->item_id);
@@ -1294,7 +1294,7 @@ void Corpse::QueryLoot(Client* to) {
cur = itemlist.begin();
end = itemlist.end();
int corpselootlimit = EQEmu::inventory::Lookup(EQEmu::versions::ConvertClientVersionToInventoryVersion(to->ClientVersion()))->InventoryTypeSize[EQEmu::legacy::TypeCorpse];
int corpselootlimit = EQEmu::inventory::Lookup(EQEmu::versions::ConvertClientVersionToMobVersion(to->ClientVersion()))->InventoryTypeSize[EQEmu::inventory::typeCorpse];
for(; cur != end; ++cur) {
ServerLootItem_Struct* sitem = *cur;
@@ -1305,7 +1305,7 @@ void Corpse::QueryLoot(Client* to) {
else
x < corpselootlimit ? sitem->lootslot = x : sitem->lootslot = 0xFFFF;
const EQEmu::ItemBase* item = database.GetItem(sitem->item_id);
const EQEmu::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);
@@ -1319,7 +1319,7 @@ void Corpse::QueryLoot(Client* to) {
}
else {
sitem->lootslot=y;
const EQEmu::ItemBase* item = database.GetItem(sitem->item_id);
const EQEmu::ItemData* item = database.GetItem(sitem->item_id);
if (item)
to->Message(0, "LootSlot: %i Item: %s (%d), Count: %i", sitem->lootslot, item->Name, item->ID, sitem->charges);
@@ -1403,25 +1403,25 @@ uint32 Corpse::GetEquipment(uint8 material_slot) const {
int16 invslot;
if (material_slot > EQEmu::textures::LastTexture) {
return NO_ITEM;
return 0;
}
invslot = Inventory::CalcSlotFromMaterial(material_slot);
if(invslot == INVALID_INDEX) // GetWornItem() should be returning a NO_ITEM for any invalid index...
return NO_ITEM;
invslot = EQEmu::InventoryProfile::CalcSlotFromMaterial(material_slot);
if(invslot == INVALID_INDEX) // GetWornItem() should be returning a 0 for any invalid index...
return 0;
return GetWornItem(invslot);
}
uint32 Corpse::GetEquipmentColor(uint8 material_slot) const {
const EQEmu::ItemBase *item;
const EQEmu::ItemData *item;
if (material_slot > EQEmu::textures::LastTexture) {
return 0;
}
item = database.GetItem(GetEquipment(material_slot));
if(item != NO_ITEM) {
if(item != 0) {
return (item_tint.Slot[material_slot].UseTint ? item_tint.Slot[material_slot].Color : item->Color);
}
@@ -1434,8 +1434,8 @@ void Corpse::UpdateEquipmentLight()
m_Light.Level[EQEmu::lightsource::LightEquipment] = 0;
for (auto iter = itemlist.begin(); iter != itemlist.end(); ++iter) {
if (((*iter)->equip_slot < EQEmu::legacy::EQUIPMENT_BEGIN || (*iter)->equip_slot > EQEmu::legacy::EQUIPMENT_END) && (*iter)->equip_slot != EQEmu::legacy::SlotPowerSource) { continue; }
if ((*iter)->equip_slot == EQEmu::legacy::SlotAmmo) { continue; }
if (((*iter)->equip_slot < EQEmu::legacy::EQUIPMENT_BEGIN || (*iter)->equip_slot > EQEmu::legacy::EQUIPMENT_END) && (*iter)->equip_slot != EQEmu::inventory::slotPowerSource) { continue; }
if ((*iter)->equip_slot == EQEmu::inventory::slotAmmo) { continue; }
auto item = database.GetItem((*iter)->item_id);
if (item == nullptr) { continue; }
zone/corpse.h
+7 -3
View File
@@ -24,13 +24,17 @@
class Client;
class EQApplicationPacket;
class Group;
class ItemInst;
class NPC;
class Raid;
struct ExtraAttackOptions;
struct NPCType;
namespace EQEmu
{
class ItemInstance;
}
#define MAX_LOOTERS 72
class Corpse : public Mob {
@@ -49,7 +53,7 @@ class Corpse : public Mob {
/* 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, int special = 0) { return; }
virtual bool Attack(Mob* other, int Hand = EQEmu::legacy::SlotPrimary, bool FromRiposte = false, bool IsStrikethrough = true, bool IsFromSpell = false, ExtraAttackOptions *opts = nullptr, int special = 0) { return false; }
virtual bool Attack(Mob* other, int Hand = EQEmu::inventory::slotPrimary, bool FromRiposte = false, bool IsStrikethrough = true, bool IsFromSpell = false, ExtraAttackOptions *opts = nullptr, int special = 0) { return false; }
virtual bool HasRaid() { return false; }
virtual bool HasGroup() { return false; }
virtual Raid* GetRaid() { return 0; }
@@ -128,7 +132,7 @@ class Corpse : public Mob {
virtual void UpdateEquipmentLight();
protected:
void MoveItemToCorpse(Client *client, ItemInst *inst, int16 equipSlot, std::list<uint32> &removedList);
void MoveItemToCorpse(Client *client, EQEmu::ItemInstance *inst, int16 equipSlot, std::list<uint32> &removedList);
private:
bool is_player_corpse; /* Determines if Player Corpse or not */
zone/doors.cpp
+1 -1
View File
@@ -188,7 +188,7 @@ void Doors::HandleClick(Client* sender, uint8 trigger)
uint8 keepoffkeyring = GetNoKeyring();
uint32 haskey = 0;
uint32 playerkey = 0;
const ItemInst *lockpicks = sender->GetInv().GetItem(EQEmu::legacy::SlotCursor);
const EQEmu::ItemInstance *lockpicks = sender->GetInv().GetItem(EQEmu::inventory::slotCursor);
haskey = sender->GetInv().HasItem(keyneeded, 1);
zone/effects.cpp
+18 -12
View File
@@ -481,7 +481,7 @@ int32 Client::GetActSpellCasttime(uint16 spell_id, int32 casttime)
bool Client::TrainDiscipline(uint32 itemid) {
//get the item info
const EQEmu::ItemBase *item = database.GetItem(itemid);
const EQEmu::ItemData *item = database.GetItem(itemid);
if(item == nullptr) {
Message(13, "Unable to find the tome you turned in!");
Log.Out(Logs::General, Logs::Error, "Unable to find turned in tome id %lu\n", (unsigned long)itemid);
@@ -630,17 +630,6 @@ bool Client::UseDiscipline(uint32 spell_id, uint32 target) {
if(r == MAX_PP_DISCIPLINES)
return(false); //not found.
//Check the disc timer
pTimerType DiscTimer = pTimerDisciplineReuseStart + spells[spell_id].EndurTimerIndex;
if(!p_timers.Expired(&database, DiscTimer)) {
/*char val1[20]={0};*/ //unused
/*char val2[20]={0};*/ //unused
uint32 remain = p_timers.GetRemainingTime(DiscTimer);
//Message_StringID(0, DISCIPLINE_CANUSEIN, ConvertArray((remain)/60,val1), ConvertArray(remain%60,val2));
Message(0, "You can use this discipline in %d minutes %d seconds.", ((remain)/60), (remain%60));
return(false);
}
//make sure we can use it..
if(!IsValidSpell(spell_id)) {
Message(13, "This tome contains invalid knowledge.");
@@ -667,6 +656,23 @@ bool Client::UseDiscipline(uint32 spell_id, uint32 target) {
return(false);
}
// sneak attack discs require you to be hidden for 4 seconds before use
if (spell.sneak && (!hidden || (hidden && (Timer::GetCurrentTime() - tmHidden) < 4000))) {
Message_StringID(MT_SpellFailure, SNEAK_RESTRICT);
return false;
}
//Check the disc timer
pTimerType DiscTimer = pTimerDisciplineReuseStart + spell.EndurTimerIndex;
if(!p_timers.Expired(&database, DiscTimer)) {
/*char val1[20]={0};*/ //unused
/*char val2[20]={0};*/ //unused
uint32 remain = p_timers.GetRemainingTime(DiscTimer);
//Message_StringID(0, DISCIPLINE_CANUSEIN, ConvertArray((remain)/60,val1), ConvertArray(remain%60,val2));
Message(0, "You can use this discipline in %d minutes %d seconds.", ((remain)/60), (remain%60));
return(false);
}
if(spell.recast_time > 0)
{
uint32 reduced_recast = spell.recast_time / 1000;
zone/embparser.cpp
+28 -28
View File
@@ -157,7 +157,7 @@ void PerlembParser::ReloadQuests() {
spell_quest_status_.clear();
}
int PerlembParser::EventCommon(QuestEventID event, uint32 objid, const char * data, NPC* npcmob, ItemInst* iteminst, Mob* mob,
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)
{
if(!perl)
@@ -174,9 +174,9 @@ int PerlembParser::EventCommon(QuestEventID event, uint32 objid, const char * da
std::string package_name;
GetQuestTypes(isPlayerQuest, isGlobalPlayerQuest, isGlobalNPC, isItemQuest, isSpellQuest,
event, npcmob, iteminst, mob, global);
event, npcmob, item_inst, mob, global);
GetQuestPackageName(isPlayerQuest, isGlobalPlayerQuest, isGlobalNPC, isItemQuest, isSpellQuest,
package_name, event, objid, data, npcmob, iteminst, global);
package_name, event, objid, data, npcmob, item_inst, global);
const char *sub_name = QuestEventSubroutines[event];
if(!perl->SubExists(package_name.c_str(), sub_name)) {
@@ -208,14 +208,14 @@ int PerlembParser::EventCommon(QuestEventID event, uint32 objid, const char * da
/* Check for Event export event enable */
if (parse->perl_event_export_settings[event].event_variables){
ExportEventVariables(package_name, event, objid, data, npcmob, iteminst, mob, extradata, extra_pointers);
ExportEventVariables(package_name, event, objid, data, npcmob, item_inst, mob, extradata, extra_pointers);
}
if(isPlayerQuest || isGlobalPlayerQuest){
return SendCommands(package_name.c_str(), sub_name, 0, mob, mob, nullptr);
}
else if(isItemQuest) {
return SendCommands(package_name.c_str(), sub_name, 0, mob, mob, iteminst);
return SendCommands(package_name.c_str(), sub_name, 0, mob, mob, item_inst);
}
else if(isSpellQuest){
if(mob) {
@@ -249,7 +249,7 @@ int PerlembParser::EventGlobalPlayer(QuestEventID evt, Client *client, std::stri
return EventCommon(evt, 0, data.c_str(), nullptr, nullptr, client, extra_data, true, extra_pointers);
}
int PerlembParser::EventItem(QuestEventID evt, Client *client, ItemInst *item, Mob *mob, std::string data, uint32 extra_data,
int PerlembParser::EventItem(QuestEventID evt, Client *client, EQEmu::ItemInstance *item, Mob *mob, std::string data, uint32 extra_data,
std::vector<EQEmu::Any> *extra_pointers) {
// needs pointer validation on 'item' argument
return EventCommon(evt, item->GetID(), nullptr, nullptr, item, client, extra_data, false, extra_pointers);
@@ -348,7 +348,7 @@ bool PerlembParser::SpellHasQuestSub(uint32 spell_id, QuestEventID evt) {
return(perl->SubExists(package_name.str().c_str(), subname));
}
bool PerlembParser::ItemHasQuestSub(ItemInst *itm, QuestEventID evt) {
bool PerlembParser::ItemHasQuestSub(EQEmu::ItemInstance *itm, QuestEventID evt) {
std::stringstream package_name;
package_name << "qst_item_" << itm->GetID();
@@ -471,7 +471,7 @@ void PerlembParser::LoadGlobalPlayerScript(std::string filename) {
global_player_quest_status_ = questLoaded;
}
void PerlembParser::LoadItemScript(std::string filename, ItemInst *item) {
void PerlembParser::LoadItemScript(std::string filename, EQEmu::ItemInstance *item) {
if (item == nullptr)
return;
@@ -642,13 +642,13 @@ void PerlembParser::ExportVar(const char *pkgprefix, const char *varname, const
}
}
int PerlembParser::SendCommands(const char *pkgprefix, const char *event, uint32 npcid, Mob* other, Mob* mob, ItemInst* iteminst) {
int PerlembParser::SendCommands(const char *pkgprefix, const char *event, uint32 npcid, Mob* other, Mob* mob, EQEmu::ItemInstance* item_inst) {
if(!perl)
return 0;
int ret_value = 0;
if(mob && mob->IsClient())
quest_manager.StartQuest(other, mob->CastToClient(), iteminst);
quest_manager.StartQuest(other, mob->CastToClient(), item_inst);
else
quest_manager.StartQuest(other, nullptr, nullptr);
@@ -711,8 +711,8 @@ int PerlembParser::SendCommands(const char *pkgprefix, const char *event, uint32
}
//only export QuestItem if it's an item quest
if(iteminst) {
ItemInst* curi = quest_manager.GetQuestItem();
if(item_inst) {
EQEmu::ItemInstance* curi = quest_manager.GetQuestItem();
snprintf(namebuf, 64, "%s::questitem", pkgprefix);
SV *questitem = get_sv(namebuf, true);
sv_setref_pv(questitem, "QuestItem", curi);
@@ -840,7 +840,7 @@ void PerlembParser::MapFunctions() {
}
void PerlembParser::GetQuestTypes(bool &isPlayerQuest, bool &isGlobalPlayerQuest, bool &isGlobalNPC, bool &isItemQuest,
bool &isSpellQuest, QuestEventID event, NPC* npcmob, ItemInst* iteminst, Mob* mob, bool global)
bool &isSpellQuest, QuestEventID event, NPC* npcmob, EQEmu::ItemInstance* item_inst, Mob* mob, bool global)
{
if(event == EVENT_SPELL_EFFECT_CLIENT ||
event == EVENT_SPELL_EFFECT_NPC ||
@@ -854,7 +854,7 @@ void PerlembParser::GetQuestTypes(bool &isPlayerQuest, bool &isGlobalPlayerQuest
else
{
if(!npcmob && mob) {
if(!iteminst) {
if(!item_inst) {
if(global) {
isGlobalPlayerQuest = true;
} else {
@@ -869,7 +869,7 @@ void PerlembParser::GetQuestTypes(bool &isPlayerQuest, bool &isGlobalPlayerQuest
void PerlembParser::GetQuestPackageName(bool &isPlayerQuest, bool &isGlobalPlayerQuest, bool &isGlobalNPC, bool &isItemQuest,
bool &isSpellQuest, std::string &package_name, QuestEventID event, uint32 objid, const char * data,
NPC* npcmob, ItemInst* iteminst, bool global)
NPC* npcmob, EQEmu::ItemInstance* item_inst, bool global)
{
if(!isPlayerQuest && !isGlobalPlayerQuest && !isItemQuest && !isSpellQuest) {
if(global) {
@@ -881,8 +881,8 @@ void PerlembParser::GetQuestPackageName(bool &isPlayerQuest, bool &isGlobalPlaye
}
}
else if(isItemQuest) {
// need a valid ItemInst pointer check here..unsure how to cancel this process
const EQEmu::ItemBase* item = iteminst->GetItem();
// need a valid EQEmu::ItemInstance pointer check here..unsure how to cancel this process
const EQEmu::ItemData* item = item_inst->GetItem();
package_name = "qst_item_";
package_name += itoa(item->ID);
}
@@ -1141,7 +1141,7 @@ void PerlembParser::ExportItemVariables(std::string &package_name, Mob *mob) {
#undef HASITEM_ISNULLITEM
void PerlembParser::ExportEventVariables(std::string &package_name, QuestEventID event, uint32 objid, const char * data,
NPC* npcmob, ItemInst* iteminst, Mob* mob, uint32 extradata, std::vector<EQEmu::Any> *extra_pointers)
NPC* npcmob, EQEmu::ItemInstance* item_inst, Mob* mob, uint32 extradata, std::vector<EQEmu::Any> *extra_pointers)
{
switch (event) {
case EVENT_SAY: {
@@ -1159,7 +1159,7 @@ void PerlembParser::ExportEventVariables(std::string &package_name, QuestEventID
if(extra_pointers) {
size_t sz = extra_pointers->size();
for(size_t i = 0; i < sz; ++i) {
ItemInst *inst = EQEmu::any_cast<ItemInst*>(extra_pointers->at(i));
EQEmu::ItemInstance *inst = EQEmu::any_cast<EQEmu::ItemInstance*>(extra_pointers->at(i));
std::string var_name = "item";
var_name += std::to_string(i + 1);
@@ -1327,19 +1327,19 @@ void PerlembParser::ExportEventVariables(std::string &package_name, QuestEventID
case EVENT_SCALE_CALC:
case EVENT_ITEM_ENTER_ZONE: {
// need a valid ItemInst pointer check here..unsure how to cancel this process
// need a valid EQEmu::ItemInstance pointer check here..unsure how to cancel this process
ExportVar(package_name.c_str(), "itemid", objid);
ExportVar(package_name.c_str(), "itemname", iteminst->GetItem()->Name);
ExportVar(package_name.c_str(), "itemname", item_inst->GetItem()->Name);
break;
}
case EVENT_ITEM_CLICK_CAST:
case EVENT_ITEM_CLICK: {
// need a valid ItemInst pointer check here..unsure how to cancel this process
// need a valid EQEmu::ItemInstance pointer check here..unsure how to cancel this process
ExportVar(package_name.c_str(), "itemid", objid);
ExportVar(package_name.c_str(), "itemname", iteminst->GetItem()->Name);
ExportVar(package_name.c_str(), "itemname", item_inst->GetItem()->Name);
ExportVar(package_name.c_str(), "slotid", extradata);
ExportVar(package_name.c_str(), "spell_id", iteminst->GetItem()->Click.Effect);
ExportVar(package_name.c_str(), "spell_id", item_inst->GetItem()->Click.Effect);
break;
}
@@ -1419,10 +1419,10 @@ void PerlembParser::ExportEventVariables(std::string &package_name, QuestEventID
break;
}
case EVENT_DROP_ITEM: {
ExportVar(package_name.c_str(), "quantity", iteminst->IsStackable() ? iteminst->GetCharges() : 1);
ExportVar(package_name.c_str(), "itemname", iteminst->GetItem()->Name);
ExportVar(package_name.c_str(), "itemid", iteminst->GetItem()->ID);
ExportVar(package_name.c_str(), "spell_id", iteminst->GetItem()->Click.Effect);
ExportVar(package_name.c_str(), "quantity", item_inst->IsStackable() ? item_inst->GetCharges() : 1);
ExportVar(package_name.c_str(), "itemname", item_inst->GetItem()->Name);
ExportVar(package_name.c_str(), "itemid", item_inst->GetItem()->ID);
ExportVar(package_name.c_str(), "spell_id", item_inst->GetItem()->Click.Effect);
ExportVar(package_name.c_str(), "slotid", extradata);
break;
}
zone/embparser.h
+14 -10
View File
@@ -17,7 +17,7 @@
*/
#ifndef EQEMU_EMBPARSER_H
#define EQMEU_EMBPARSER_H
#define EQEMU_EMBPARSER_H
#ifdef EMBPERL
#include "quest_parser_collection.h"
@@ -27,11 +27,15 @@
#include <map>
#include "embperl.h"
class ItemInst;
class Mob;
class Client;
class NPC;
namespace EQEmu
{
class ItemInstance;
}
typedef enum
{
questUnloaded,
@@ -52,7 +56,7 @@ public:
std::vector<EQEmu::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, ItemInst *item, Mob *mob, std::string data, uint32 extra_data,
virtual int EventItem(QuestEventID evt, Client *client, EQEmu::ItemInstance *item, Mob *mob, std::string data, uint32 extra_data,
std::vector<EQEmu::Any> *extra_pointers);
virtual int EventSpell(QuestEventID evt, NPC* npc, Client *client, uint32 spell_id, uint32 extra_data,
std::vector<EQEmu::Any> *extra_pointers);
@@ -62,13 +66,13 @@ public:
virtual bool PlayerHasQuestSub(QuestEventID evt);
virtual bool GlobalPlayerHasQuestSub(QuestEventID evt);
virtual bool SpellHasQuestSub(uint32 spell_id, QuestEventID evt);
virtual bool ItemHasQuestSub(ItemInst *itm, QuestEventID evt);
virtual bool ItemHasQuestSub(EQEmu::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, ItemInst *item);
virtual void LoadItemScript(std::string filename, EQEmu::ItemInstance *item);
virtual void LoadSpellScript(std::string filename, uint32 spell_id);
virtual void AddVar(std::string name, std::string val);
@@ -86,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, ItemInst* iteminst, Mob* mob,
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, ItemInst *iteminst);
int SendCommands(const char *pkgprefix, const char *event, uint32 npcid, Mob* other, Mob* mob, EQEmu::ItemInstance *item_inst);
void MapFunctions();
void GetQuestTypes(bool &isPlayerQuest, bool &isGlobalPlayerQuest, bool &isGlobalNPC, bool &isItemQuest,
bool &isSpellQuest, QuestEventID event, NPC* npcmob, ItemInst* iteminst, Mob* mob, bool global);
bool &isSpellQuest, QuestEventID event, NPC* npcmob, EQEmu::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, ItemInst* iteminst, bool global);
NPC* npcmob, EQEmu::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);
@@ -104,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, ItemInst* iteminst, Mob* mob, uint32 extradata, std::vector<EQEmu::Any> *extra_pointers);
NPC* npcmob, EQEmu::ItemInstance* item_inst, Mob* mob, uint32 extradata, std::vector<EQEmu::Any> *extra_pointers);
std::map<uint32, PerlQuestStatus> npc_quest_status_;
PerlQuestStatus global_npc_quest_status_;
zone/embparser_api.cpp
+1 -1
View File
@@ -110,7 +110,7 @@ XS(XS_QuestItem_new)
if (items != 1)
Perl_croak(aTHX_ "Usage: QuestItem::new()");
ItemInst* RETVAL;
EQEmu::ItemInstance* RETVAL;
RETVAL = quest_manager.GetQuestItem();
ST(0) = sv_newmortal();
zone/embxs.cpp
+1 -1
View File
@@ -33,7 +33,7 @@
const char *getItemName(unsigned itemid)
{
const EQEmu::ItemBase* item = nullptr;
const EQEmu::ItemData* item = nullptr;
item = database.GetItem(itemid);
if (item)
zone/encounter.h
+1 -1
View File
@@ -36,7 +36,7 @@ public:
//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, int special = 0) { return; }
virtual bool Attack(Mob* other, int Hand = EQEmu::legacy::SlotPrimary, bool FromRiposte = false, bool IsStrikethrough = false, bool IsFromSpell = false,
virtual bool Attack(Mob* other, int Hand = EQEmu::inventory::slotPrimary, bool FromRiposte = false, bool IsStrikethrough = false, bool IsFromSpell = false,
ExtraAttackOptions *opts = nullptr, int special = 0) {
return false;
}
zone/entity.cpp
+3 -3
View File
@@ -2009,7 +2009,7 @@ void EntityList::QueueClientsGuildBankItemUpdate(const GuildBankItemUpdate_Struc
memcpy(outgbius, gbius, sizeof(GuildBankItemUpdate_Struct));
const EQEmu::ItemBase *Item = database.GetItem(gbius->ItemID);
const EQEmu::ItemData *Item = database.GetItem(gbius->ItemID);
auto it = client_list.begin();
while (it != client_list.end()) {
@@ -3878,11 +3878,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::ItemBase *is = database.GetItem(itemid);
const EQEmu::ItemData *is = database.GetItem(itemid);
if (!is)
return 0;
auto i = new ItemInst(is, is->MaxCharges);
auto i = new EQEmu::ItemInstance(is, is->MaxCharges);
if (!i)
return 0;
zone/entity.h
+1 -1
View File
@@ -352,7 +352,7 @@ public:
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 dist, int Hand = EQEmu::legacy::SlotPrimary, int count = 0, bool IsFromSpell = false);
void AEAttack(Mob *attacker, float dist, int Hand = EQEmu::inventory::slotPrimary, int count = 0, bool IsFromSpell = false);
void AETaunt(Client *caster, float range=0, int32 bonus_hate=0);
void AESpell(Mob *caster, Mob *center, uint16 spell_id, bool affect_caster = true, int16 resist_adjust = 0);
void MassGroupBuff(Mob *caster, Mob *center, uint16 spell_id, bool affect_caster = true);
zone/exp.cpp
+41 -10
View File
@@ -350,19 +350,50 @@ void Client::SetEXP(uint32 set_exp, uint32 set_aaxp, bool isrezzexp) {
}
if ((set_exp + set_aaxp) > (m_pp.exp+m_pp.expAA)) {
if (isrezzexp)
this->Message_StringID(MT_Experience, REZ_REGAIN);
else{
if(membercount > 1)
this->Message_StringID(MT_Experience, GAIN_GROUPXP);
else if(IsRaidGrouped())
Message_StringID(MT_Experience, GAIN_RAIDEXP);
else
this->Message_StringID(MT_Experience, GAIN_XP);
uint32 exp_gained = set_exp - m_pp.exp;
uint32 aaxp_gained = set_aaxp - m_pp.expAA;
float exp_percent = (float)((float)exp_gained / (float)(GetEXPForLevel(GetLevel() + 1) - GetEXPForLevel(GetLevel())))*(float)100; //EXP needed for level
float aaxp_percent = (float)((float)aaxp_gained / (float)(RuleI(AA, ExpPerPoint)))*(float)100; //AAEXP needed for level
std::string exp_amount_message = "";
if (RuleI(Character, ShowExpValues) >= 1) {
if (exp_gained > 0 && aaxp_gained > 0) exp_amount_message = StringFormat("%u, %u AA", exp_gained, aaxp_gained);
else if (exp_gained > 0) exp_amount_message = StringFormat("%u", exp_gained);
else exp_amount_message = StringFormat("%u AA", aaxp_gained);
}
std::string exp_percent_message = "";
if (RuleI(Character, ShowExpValues) >= 2) {
if (exp_gained > 0 && aaxp_gained > 0) exp_percent_message = StringFormat("(%.3f%%, %.3f%%AA)", exp_percent, aaxp_percent);
else if (exp_gained > 0) exp_percent_message = StringFormat("(%.3f%%)", exp_percent);
else exp_percent_message = StringFormat("(%.3f%%AA)", aaxp_percent);
}
if (isrezzexp) {
if (RuleI(Character, ShowExpValues) > 0) Message(MT_Experience, "You regain %s experience from resurrection. %s", exp_amount_message.c_str(), exp_percent_message.c_str());
else Message_StringID(MT_Experience, REZ_REGAIN);
} else {
if (membercount > 1) {
if (RuleI(Character, ShowExpValues) > 0) Message(MT_Experience, "You have gained %s party experience! %s", exp_amount_message.c_str(), exp_percent_message.c_str());
else Message_StringID(MT_Experience, GAIN_GROUPXP);
}
else if (IsRaidGrouped()) {
if (RuleI(Character, ShowExpValues) > 0) Message(MT_Experience, "You have gained %s raid experience! %s", exp_amount_message.c_str(), exp_percent_message.c_str());
else Message_StringID(MT_Experience, GAIN_RAIDEXP);
}
else {
if (RuleI(Character, ShowExpValues) > 0) Message(MT_Experience, "You have gained %s experience! %s", exp_amount_message.c_str(), exp_percent_message.c_str());
else Message_StringID(MT_Experience, GAIN_XP);
}
}
}
else if((set_exp + set_aaxp) < (m_pp.exp+m_pp.expAA)){ //only loss message if you lose exp, no message if you gained/lost nothing.
Message(15, "You have lost experience.");
uint32 exp_lost = m_pp.exp - set_exp;
float exp_percent = (float)((float)exp_lost / (float)(GetEXPForLevel(GetLevel() + 1) - GetEXPForLevel(GetLevel())))*(float)100;
if (RuleI(Character, ShowExpValues) == 1 && exp_lost > 0) Message(15, "You have lost %i experience.", exp_lost);
else if (RuleI(Character, ShowExpValues) == 2 && exp_lost > 0) Message(15, "You have lost %i experience. (%.3f%%)", exp_lost, exp_percent);
else Message(15, "You have lost experience.");
}
//check_level represents the level we should be when we have
zone/forage.cpp
+12 -12
View File
@@ -153,9 +153,9 @@ 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 ItemInst* Pole = m_inv[EQEmu::legacy::SlotPrimary];
const EQEmu::ItemInstance* Pole = m_inv[EQEmu::inventory::slotPrimary];
int32 bslot = m_inv.HasItemByUse(EQEmu::item::ItemTypeFishingBait, 1, invWhereWorn | invWherePersonal);
const ItemInst* Bait = nullptr;
const EQEmu::ItemInstance* Bait = nullptr;
if (bslot != INVALID_INDEX)
Bait = m_inv.GetItem(bslot);
@@ -253,7 +253,7 @@ void Client::GoFish()
//make sure we still have a fishing pole on:
int32 bslot = m_inv.HasItemByUse(EQEmu::item::ItemTypeFishingBait, 1, invWhereWorn | invWherePersonal);
const ItemInst* Bait = nullptr;
const EQEmu::ItemInstance* Bait = nullptr;
if (bslot != INVALID_INDEX)
Bait = m_inv.GetItem(bslot);
@@ -304,10 +304,10 @@ void Client::GoFish()
food_id = common_fish_ids[index];
}
const EQEmu::ItemBase* food_item = database.GetItem(food_id);
const EQEmu::ItemData* food_item = database.GetItem(food_id);
Message_StringID(MT_Skills, FISHING_SUCCESS);
ItemInst* inst = database.CreateItem(food_item, 1);
EQEmu::ItemInstance* inst = database.CreateItem(food_item, 1);
if(inst != nullptr) {
if(CheckLoreConflict(inst->GetItem()))
{
@@ -317,12 +317,12 @@ void Client::GoFish()
else
{
PushItemOnCursor(*inst);
SendItemPacket(EQEmu::legacy::SlotCursor, inst, ItemPacketLimbo);
SendItemPacket(EQEmu::inventory::slotCursor, inst, ItemPacketLimbo);
if(RuleB(TaskSystem, EnableTaskSystem))
UpdateTasksForItem(ActivityFish, food_id);
safe_delete(inst);
inst = m_inv.GetItem(EQEmu::legacy::SlotCursor);
inst = m_inv.GetItem(EQEmu::inventory::slotCursor);
}
if(inst) {
@@ -354,7 +354,7 @@ void Client::GoFish()
//and then swap out items in primary slot... too lazy to fix right now
if (zone->random.Int(0, 49) == 1) {
Message_StringID(MT_Skills, FISHING_POLE_BROKE); //Your fishing pole broke!
DeleteItemInInventory(EQEmu::legacy::SlotPrimary, 0, true);
DeleteItemInInventory(EQEmu::inventory::slotPrimary, 0, true);
}
if (CheckIncreaseSkill(EQEmu::skills::SkillFishing, nullptr, 5))
@@ -396,7 +396,7 @@ void Client::ForageItem(bool guarantee) {
foragedfood = common_food_ids[index];
}
const EQEmu::ItemBase* food_item = database.GetItem(foragedfood);
const EQEmu::ItemData* food_item = database.GetItem(foragedfood);
if(!food_item) {
Log.Out(Logs::General, Logs::Error, "nullptr returned from database.GetItem in ClientForageItem");
@@ -421,7 +421,7 @@ void Client::ForageItem(bool guarantee) {
}
Message_StringID(MT_Skills, stringid);
ItemInst* inst = database.CreateItem(food_item, 1);
EQEmu::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()))
@@ -431,12 +431,12 @@ void Client::ForageItem(bool guarantee) {
}
else {
PushItemOnCursor(*inst);
SendItemPacket(EQEmu::legacy::SlotCursor, inst, ItemPacketLimbo);
SendItemPacket(EQEmu::inventory::slotCursor, inst, ItemPacketLimbo);
if(RuleB(TaskSystem, EnableTaskSystem))
UpdateTasksForItem(ActivityForage, foragedfood);
safe_delete(inst);
inst = m_inv.GetItem(EQEmu::legacy::SlotCursor);
inst = m_inv.GetItem(EQEmu::inventory::slotCursor);
}
if(inst) {
zone/guild_mgr.cpp
+12 -12
View File
@@ -694,7 +694,7 @@ void GuildBankManager::SendGuildBank(Client *c)
if (c->ClientVersionBit() & EQEmu::versions::bit_RoFAndLater) {
auto outapp = new EQApplicationPacket(OP_GuildBankItemList, sizeof(GuildBankItemListEntry_Struct) * 240);
for (int i = 0; i < GUILD_BANK_DEPOSIT_AREA_SIZE; ++i) {
const EQEmu::ItemBase *Item = database.GetItem(guild_bank->Items.DepositArea[i].ItemID);
const EQEmu::ItemData *Item = database.GetItem(guild_bank->Items.DepositArea[i].ItemID);
if (Item) {
outapp->WriteUInt8(1);
outapp->WriteUInt32(guild_bank->Items.DepositArea[i].Permissions);
@@ -718,7 +718,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::ItemBase *Item = database.GetItem(guild_bank->Items.MainArea[i].ItemID);
const EQEmu::ItemData *Item = database.GetItem(guild_bank->Items.MainArea[i].ItemID);
if (Item) {
outapp->WriteUInt8(1);
outapp->WriteUInt32(guild_bank->Items.MainArea[i].Permissions);
@@ -749,7 +749,7 @@ void GuildBankManager::SendGuildBank(Client *c)
{
if(guild_bank->Items.DepositArea[i].ItemID > 0)
{
const EQEmu::ItemBase *Item = database.GetItem(guild_bank->Items.DepositArea[i].ItemID);
const EQEmu::ItemData *Item = database.GetItem(guild_bank->Items.DepositArea[i].ItemID);
if(!Item)
continue;
@@ -785,7 +785,7 @@ void GuildBankManager::SendGuildBank(Client *c)
{
if(guild_bank->Items.MainArea[i].ItemID > 0)
{
const EQEmu::ItemBase *Item = database.GetItem(guild_bank->Items.MainArea[i].ItemID);
const EQEmu::ItemData *Item = database.GetItem(guild_bank->Items.MainArea[i].ItemID);
if(!Item)
continue;
@@ -916,7 +916,7 @@ bool GuildBankManager::AddItem(uint32 GuildID, uint8 Area, uint32 ItemID, int32
return false;
}
const EQEmu::ItemBase *Item = database.GetItem(ItemID);
const EQEmu::ItemData *Item = database.GetItem(ItemID);
GuildBankItemUpdate_Struct gbius;
@@ -982,7 +982,7 @@ int GuildBankManager::Promote(uint32 guildID, int slotID)
(*iter)->Items.DepositArea[slotID].ItemID = 0;
const EQEmu::ItemBase *Item = database.GetItem((*iter)->Items.MainArea[mainSlot].ItemID);
const EQEmu::ItemData *Item = database.GetItem((*iter)->Items.MainArea[mainSlot].ItemID);
GuildBankItemUpdate_Struct gbius;
@@ -1038,7 +1038,7 @@ void GuildBankManager::SetPermissions(uint32 guildID, uint16 slotID, uint32 perm
else
(*iter)->Items.MainArea[slotID].WhoFor[0] = '\0';
const EQEmu::ItemBase *Item = database.GetItem((*iter)->Items.MainArea[slotID].ItemID);
const EQEmu::ItemData *Item = database.GetItem((*iter)->Items.MainArea[slotID].ItemID);
GuildBankItemUpdate_Struct gbius;
@@ -1062,7 +1062,7 @@ void GuildBankManager::SetPermissions(uint32 guildID, uint16 slotID, uint32 perm
entity_list.QueueClientsGuildBankItemUpdate(&gbius, guildID);
}
ItemInst* GuildBankManager::GetItem(uint32 GuildID, uint16 Area, uint16 SlotID, uint32 Quantity)
EQEmu::ItemInstance* GuildBankManager::GetItem(uint32 GuildID, uint16 Area, uint16 SlotID, uint32 Quantity)
{
auto Iterator = GetGuildBank(GuildID);
@@ -1071,7 +1071,7 @@ ItemInst* GuildBankManager::GetItem(uint32 GuildID, uint16 Area, uint16 SlotID,
GuildBankItem* BankArea = nullptr;
ItemInst* inst = nullptr;
EQEmu::ItemInstance* inst = nullptr;
if(Area == GuildBankDepositArea)
{
@@ -1169,7 +1169,7 @@ bool GuildBankManager::DeleteItem(uint32 guildID, uint16 area, uint16 slotID, ui
bool deleted = true;
const EQEmu::ItemBase *Item = database.GetItem(BankArea[slotID].ItemID);
const EQEmu::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 "
@@ -1230,7 +1230,7 @@ bool GuildBankManager::MergeStacks(uint32 GuildID, uint16 SlotID)
if(BankArea[SlotID].ItemID == 0)
return false;
const EQEmu::ItemBase *Item = database.GetItem(BankArea[SlotID].ItemID);
const EQEmu::ItemData *Item = database.GetItem(BankArea[SlotID].ItemID);
if(!Item->Stackable)
return false;
@@ -1328,7 +1328,7 @@ bool GuildBankManager::SplitStack(uint32 GuildID, uint16 SlotID, uint32 Quantity
if(BankArea[SlotID].Quantity <= Quantity || Quantity == 0)
return false;
const EQEmu::ItemBase *Item = database.GetItem(BankArea[SlotID].ItemID);
const EQEmu::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);
ItemInst* GetItem(uint32 GuildID, uint16 Area, uint16 SlotID, uint32 Quantity);
EQEmu::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/inventory.cpp
+224 -224
View File
File diff suppressed because it is too large Load Diff
zone/loottables.cpp
+35 -35
View File
@@ -119,7 +119,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::ItemBase* dbitem = GetItem(lds->Entries[i].item_id);
const EQEmu::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);
}
@@ -140,7 +140,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::ItemBase* db_item = GetItem(lds->Entries[i].item_id);
const EQEmu::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
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::ItemBase* db_item = GetItem(lds->Entries[j].item_id);
const EQEmu::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,
@@ -187,7 +187,7 @@ 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::ItemBase* db_item = GetItem(lds->Entries[j].item_id);
const EQEmu::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,
@@ -221,7 +221,7 @@ void ZoneDatabase::AddLootDropToNPC(NPC* npc,uint32 lootdrop_id, ItemList* iteml
}
//if itemlist is null, just send wear changes
void NPC::AddLootDrop(const EQEmu::ItemBase *item2, ItemList* itemlist, int16 charges, uint8 minlevel, uint8 maxlevel, bool equipit, bool wearchange) {
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) {
if(item2 == nullptr)
return;
@@ -245,12 +245,12 @@ void NPC::AddLootDrop(const EQEmu::ItemBase *item2, ItemList* itemlist, int16 ch
item->item_id = item2->ID;
item->charges = charges;
item->aug_1 = 0;
item->aug_2 = 0;
item->aug_3 = 0;
item->aug_4 = 0;
item->aug_5 = 0;
item->aug_6 = 0;
item->aug_1 = aug1;
item->aug_2 = aug2;
item->aug_3 = aug3;
item->aug_4 = aug4;
item->aug_5 = aug5;
item->aug_6 = aug6;
item->attuned = 0;
item->min_level = minlevel;
item->max_level = maxlevel;
@@ -258,7 +258,7 @@ void NPC::AddLootDrop(const EQEmu::ItemBase *item2, ItemList* itemlist, int16 ch
if (equipit) {
uint8 eslot = 0xFF;
char newid[20];
const EQEmu::ItemBase* compitem = nullptr;
const EQEmu::ItemData* compitem = nullptr;
bool found = false; // track if we found an empty slot we fit into
int32 foundslot = -1; // for multi-slot items
@@ -313,7 +313,7 @@ void NPC::AddLootDrop(const EQEmu::ItemBase *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::legacy::SlotPrimary | 1 << EQEmu::legacy::SlotSecondary)) {
|| item2->Slots & (1 << EQEmu::inventory::slotPrimary | 1 << EQEmu::inventory::slotSecondary)) {
memset(newid, 0, sizeof(newid));
for(int i=0;i<7;i++){
if (!isalpha(item2->IDFile[i])){
@@ -327,47 +327,47 @@ void NPC::AddLootDrop(const EQEmu::ItemBase *item2, ItemList* itemlist, int16 ch
emat = item2->Material;
}
if (foundslot == EQEmu::legacy::SlotPrimary) {
if (foundslot == EQEmu::inventory::slotPrimary) {
if (item2->Proc.Effect != 0)
CastToMob()->AddProcToWeapon(item2->Proc.Effect, true);
eslot = EQEmu::textures::TexturePrimary;
eslot = EQEmu::textures::weaponPrimary;
if (item2->Damage > 0)
SendAddPlayerState(PlayerState::PrimaryWeaponEquipped);
if (item2->IsType2HWeapon())
SetTwoHanderEquipped(true);
}
else if (foundslot == EQEmu::legacy::SlotSecondary
else if (foundslot == EQEmu::inventory::slotSecondary
&& (GetOwner() != nullptr || (CanThisClassDualWield() && zone->random.Roll(NPC_DW_CHANCE)) || (item2->Damage==0)) &&
(item2->IsType1HWeapon() || item2->ItemType == EQEmu::item::ItemTypeShield))
{
if (item2->Proc.Effect!=0)
CastToMob()->AddProcToWeapon(item2->Proc.Effect, true);
eslot = EQEmu::textures::TextureSecondary;
eslot = EQEmu::textures::weaponSecondary;
if (item2->Damage > 0)
SendAddPlayerState(PlayerState::SecondaryWeaponEquipped);
}
else if (foundslot == EQEmu::legacy::SlotHead) {
eslot = EQEmu::textures::TextureHead;
else if (foundslot == EQEmu::inventory::slotHead) {
eslot = EQEmu::textures::armorHead;
}
else if (foundslot == EQEmu::legacy::SlotChest) {
eslot = EQEmu::textures::TextureChest;
else if (foundslot == EQEmu::inventory::slotChest) {
eslot = EQEmu::textures::armorChest;
}
else if (foundslot == EQEmu::legacy::SlotArms) {
eslot = EQEmu::textures::TextureArms;
else if (foundslot == EQEmu::inventory::slotArms) {
eslot = EQEmu::textures::armorArms;
}
else if (foundslot == EQEmu::legacy::SlotWrist1 || foundslot == EQEmu::legacy::SlotWrist2) {
eslot = EQEmu::textures::TextureWrist;
else if (foundslot == EQEmu::inventory::slotWrist1 || foundslot == EQEmu::inventory::slotWrist2) {
eslot = EQEmu::textures::armorWrist;
}
else if (foundslot == EQEmu::legacy::SlotHands) {
eslot = EQEmu::textures::TextureHands;
else if (foundslot == EQEmu::inventory::slotHands) {
eslot = EQEmu::textures::armorHands;
}
else if (foundslot == EQEmu::legacy::SlotLegs) {
eslot = EQEmu::textures::TextureLegs;
else if (foundslot == EQEmu::inventory::slotLegs) {
eslot = EQEmu::textures::armorLegs;
}
else if (foundslot == EQEmu::legacy::SlotFeet) {
eslot = EQEmu::textures::TextureFeet;
else if (foundslot == EQEmu::inventory::slotFeet) {
eslot = EQEmu::textures::armorFeet;
}
/*
@@ -415,17 +415,17 @@ void NPC::AddLootDrop(const EQEmu::ItemBase *item2, ItemList* itemlist, int16 ch
SendAppearancePacket(AT_Light, GetActiveLightType());
}
void NPC::AddItem(const EQEmu::ItemBase* item, uint16 charges, bool equipitem) {
void NPC::AddItem(const EQEmu::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) {
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::ItemBase * i = database.GetItem(itemid);
const EQEmu::ItemData * i = database.GetItem(itemid);
if(i == nullptr)
return;
AddLootDrop(i, &itemlist, charges, 1, 255, equipitem, equipitem);
AddLootDrop(i, &itemlist, charges, 1, 255, equipitem, equipitem, aug1, aug2, aug3, aug4, aug5, aug6);
}
void NPC::AddLootTable() {
zone/lua_client.cpp
+2 -2
View File
@@ -1219,13 +1219,13 @@ Lua_Raid Lua_Client::GetRaid() {
bool Lua_Client::PutItemInInventory(int slot_id, Lua_ItemInst inst) {
Lua_Safe_Call_Bool();
ItemInst *rinst = inst;
EQEmu::ItemInstance *rinst = inst;
return self->PutItemInInventory(slot_id, *rinst, true);
}
bool Lua_Client::PushItemOnCursor(Lua_ItemInst inst) {
Lua_Safe_Call_Bool();
ItemInst *rinst = inst;
EQEmu::ItemInstance *rinst = inst;
return self->PushItemOnCursor(*rinst, true);
}
zone/lua_general.cpp
+50 -50
View File
@@ -1762,43 +1762,43 @@ luabind::scope lua_register_slot() {
return luabind::class_<Slots>("Slot")
.enum_("constants")
[
luabind::value("Charm", static_cast<int>(EQEmu::legacy::SlotCharm)),
luabind::value("Ear1", static_cast<int>(EQEmu::legacy::SlotEar1)),
luabind::value("Head", static_cast<int>(EQEmu::legacy::SlotHead)),
luabind::value("Face", static_cast<int>(EQEmu::legacy::SlotFace)),
luabind::value("Ear2", static_cast<int>(EQEmu::legacy::SlotEar2)),
luabind::value("Neck", static_cast<int>(EQEmu::legacy::SlotNeck)),
luabind::value("Shoulder", static_cast<int>(EQEmu::legacy::SlotShoulders)), // deprecated
luabind::value("Shoulders", static_cast<int>(EQEmu::legacy::SlotShoulders)),
luabind::value("Arms", static_cast<int>(EQEmu::legacy::SlotArms)),
luabind::value("Back", static_cast<int>(EQEmu::legacy::SlotBack)),
luabind::value("Bracer1", static_cast<int>(EQEmu::legacy::SlotWrist1)), // deprecated
luabind::value("Wrist1", static_cast<int>(EQEmu::legacy::SlotWrist1)),
luabind::value("Bracer2", static_cast<int>(EQEmu::legacy::SlotWrist2)), // deprecated
luabind::value("Wrist2", static_cast<int>(EQEmu::legacy::SlotWrist2)),
luabind::value("Range", static_cast<int>(EQEmu::legacy::SlotRange)),
luabind::value("Hands", static_cast<int>(EQEmu::legacy::SlotHands)),
luabind::value("Primary", static_cast<int>(EQEmu::legacy::SlotPrimary)),
luabind::value("Secondary", static_cast<int>(EQEmu::legacy::SlotSecondary)),
luabind::value("Ring1", static_cast<int>(EQEmu::legacy::SlotFinger1)), // deprecated
luabind::value("Finger1", static_cast<int>(EQEmu::legacy::SlotFinger1)),
luabind::value("Ring2", static_cast<int>(EQEmu::legacy::SlotFinger2)), // deprecated
luabind::value("Finger2", static_cast<int>(EQEmu::legacy::SlotFinger2)),
luabind::value("Chest", static_cast<int>(EQEmu::legacy::SlotChest)),
luabind::value("Legs", static_cast<int>(EQEmu::legacy::SlotLegs)),
luabind::value("Feet", static_cast<int>(EQEmu::legacy::SlotFeet)),
luabind::value("Waist", static_cast<int>(EQEmu::legacy::SlotWaist)),
luabind::value("PowerSource", static_cast<int>(EQEmu::legacy::SlotPowerSource)),
luabind::value("Ammo", static_cast<int>(EQEmu::legacy::SlotAmmo)),
luabind::value("General1", static_cast<int>(EQEmu::legacy::SlotGeneral1)),
luabind::value("General2", static_cast<int>(EQEmu::legacy::SlotGeneral2)),
luabind::value("General3", static_cast<int>(EQEmu::legacy::SlotGeneral3)),
luabind::value("General4", static_cast<int>(EQEmu::legacy::SlotGeneral4)),
luabind::value("General5", static_cast<int>(EQEmu::legacy::SlotGeneral5)),
luabind::value("General6", static_cast<int>(EQEmu::legacy::SlotGeneral6)),
luabind::value("General7", static_cast<int>(EQEmu::legacy::SlotGeneral7)),
luabind::value("General8", static_cast<int>(EQEmu::legacy::SlotGeneral8)),
luabind::value("Cursor", static_cast<int>(EQEmu::legacy::SlotCursor)),
luabind::value("Charm", static_cast<int>(EQEmu::inventory::slotCharm)),
luabind::value("Ear1", static_cast<int>(EQEmu::inventory::slotEar1)),
luabind::value("Head", static_cast<int>(EQEmu::inventory::slotHead)),
luabind::value("Face", static_cast<int>(EQEmu::inventory::slotFace)),
luabind::value("Ear2", static_cast<int>(EQEmu::inventory::slotEar2)),
luabind::value("Neck", static_cast<int>(EQEmu::inventory::slotNeck)),
luabind::value("Shoulder", static_cast<int>(EQEmu::inventory::slotShoulders)), // deprecated
luabind::value("Shoulders", static_cast<int>(EQEmu::inventory::slotShoulders)),
luabind::value("Arms", static_cast<int>(EQEmu::inventory::slotArms)),
luabind::value("Back", static_cast<int>(EQEmu::inventory::slotBack)),
luabind::value("Bracer1", static_cast<int>(EQEmu::inventory::slotWrist1)), // deprecated
luabind::value("Wrist1", static_cast<int>(EQEmu::inventory::slotWrist1)),
luabind::value("Bracer2", static_cast<int>(EQEmu::inventory::slotWrist2)), // deprecated
luabind::value("Wrist2", static_cast<int>(EQEmu::inventory::slotWrist2)),
luabind::value("Range", static_cast<int>(EQEmu::inventory::slotRange)),
luabind::value("Hands", static_cast<int>(EQEmu::inventory::slotHands)),
luabind::value("Primary", static_cast<int>(EQEmu::inventory::slotPrimary)),
luabind::value("Secondary", static_cast<int>(EQEmu::inventory::slotSecondary)),
luabind::value("Ring1", static_cast<int>(EQEmu::inventory::slotFinger1)), // deprecated
luabind::value("Finger1", static_cast<int>(EQEmu::inventory::slotFinger1)),
luabind::value("Ring2", static_cast<int>(EQEmu::inventory::slotFinger2)), // deprecated
luabind::value("Finger2", static_cast<int>(EQEmu::inventory::slotFinger2)),
luabind::value("Chest", static_cast<int>(EQEmu::inventory::slotChest)),
luabind::value("Legs", static_cast<int>(EQEmu::inventory::slotLegs)),
luabind::value("Feet", static_cast<int>(EQEmu::inventory::slotFeet)),
luabind::value("Waist", static_cast<int>(EQEmu::inventory::slotWaist)),
luabind::value("PowerSource", static_cast<int>(EQEmu::inventory::slotPowerSource)),
luabind::value("Ammo", static_cast<int>(EQEmu::inventory::slotAmmo)),
luabind::value("General1", static_cast<int>(EQEmu::inventory::slotGeneral1)),
luabind::value("General2", static_cast<int>(EQEmu::inventory::slotGeneral2)),
luabind::value("General3", static_cast<int>(EQEmu::inventory::slotGeneral3)),
luabind::value("General4", static_cast<int>(EQEmu::inventory::slotGeneral4)),
luabind::value("General5", static_cast<int>(EQEmu::inventory::slotGeneral5)),
luabind::value("General6", static_cast<int>(EQEmu::inventory::slotGeneral6)),
luabind::value("General7", static_cast<int>(EQEmu::inventory::slotGeneral7)),
luabind::value("General8", static_cast<int>(EQEmu::inventory::slotGeneral8)),
luabind::value("Cursor", static_cast<int>(EQEmu::inventory::slotCursor)),
luabind::value("PersonalBegin", static_cast<int>(EQEmu::legacy::GENERAL_BEGIN)), // deprecated
luabind::value("GeneralBegin", static_cast<int>(EQEmu::legacy::GENERAL_BEGIN)),
luabind::value("PersonalEnd", static_cast<int>(EQEmu::legacy::GENERAL_END)), // deprecated
@@ -1814,19 +1814,19 @@ luabind::scope lua_register_material() {
return luabind::class_<Materials>("Material")
.enum_("constants")
[
luabind::value("Head", static_cast<int>(EQEmu::textures::TextureHead)),
luabind::value("Chest", static_cast<int>(EQEmu::textures::TextureChest)),
luabind::value("Arms", static_cast<int>(EQEmu::textures::TextureArms)),
luabind::value("Bracer", static_cast<int>(EQEmu::textures::TextureWrist)), // deprecated
luabind::value("Wrist", static_cast<int>(EQEmu::textures::TextureWrist)),
luabind::value("Hands", static_cast<int>(EQEmu::textures::TextureHands)),
luabind::value("Legs", static_cast<int>(EQEmu::textures::TextureLegs)),
luabind::value("Feet", static_cast<int>(EQEmu::textures::TextureFeet)),
luabind::value("Primary", static_cast<int>(EQEmu::textures::TexturePrimary)),
luabind::value("Secondary", static_cast<int>(EQEmu::textures::TextureSecondary)),
luabind::value("Max", static_cast<int>(EQEmu::textures::TextureCount)), // deprecated
luabind::value("Count", static_cast<int>(EQEmu::textures::TextureCount)),
luabind::value("Invalid", static_cast<int>(EQEmu::textures::TextureInvalid))
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("Bracer", static_cast<int>(EQEmu::textures::armorWrist)), // deprecated
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("Max", static_cast<int>(EQEmu::textures::materialCount)), // deprecated
luabind::value("Count", static_cast<int>(EQEmu::textures::materialCount)),
luabind::value("Invalid", static_cast<int>(EQEmu::textures::materialInvalid))
];
}
zone/lua_group.cpp
+6
View File
@@ -82,6 +82,11 @@ int Lua_Group::GetHighestLevel() {
return self->GetHighestLevel();
}
int Lua_Group::GetLowestLevel() {
Lua_Safe_Call_Int();
return self->GetLowestLevel();
}
void Lua_Group::TeleportGroup(Lua_Mob sender, uint32 zone_id, uint32 instance_id, float x, float y, float z, float h) {
Lua_Safe_Call_Void();
self->TeleportGroup(sender, zone_id, instance_id, x, y, z, h);
@@ -121,6 +126,7 @@ luabind::scope lua_register_group() {
.def("IsLeader", (bool(Lua_Group::*)(Lua_Mob))&Lua_Group::IsLeader)
.def("GroupCount", (int(Lua_Group::*)(void))&Lua_Group::GroupCount)
.def("GetHighestLevel", (int(Lua_Group::*)(void))&Lua_Group::GetHighestLevel)
.def("GetLowestLevel", (int(Lua_Group::*)(void))&Lua_Group::GetLowestLevel)
.def("TeleportGroup", (void(Lua_Group::*)(Lua_Mob,uint32,uint32,float,float,float,float))&Lua_Group::TeleportGroup)
.def("GetID", (int(Lua_Group::*)(void))&Lua_Group::GetID)
.def("GetMember", (Lua_Mob(Lua_Group::*)(int))&Lua_Group::GetMember);
zone/lua_group.h
+1
View File
@@ -40,6 +40,7 @@ public:
bool IsLeader(Lua_Mob leader);
int GroupCount();
int GetHighestLevel();
int GetLowestLevel();
void TeleportGroup(Lua_Mob sender, uint32 zone_id, uint32 instance_id, float x, float y, float z, float h);
int GetID();
Lua_Mob GetMember(int index);
zone/lua_inventory.cpp
+2 -2
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();
ItemInst *inst = item;
EQEmu::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();
ItemInst *inst = item;
EQEmu::ItemInstance *inst = item;
if(!inst) {
return 0;
}
zone/lua_inventory.h
+10 -6
View File
@@ -4,26 +4,30 @@
#include "lua_ptr.h"
class Inventory;
class Lua_ItemInst;
class Lua_Item;
namespace EQEmu
{
class InventoryProfile;
}
namespace luabind {
struct scope;
}
luabind::scope lua_register_inventory();
class Lua_Inventory : public Lua_Ptr<Inventory>
class Lua_Inventory : public Lua_Ptr<EQEmu::InventoryProfile>
{
typedef Inventory NativeType;
typedef EQEmu::InventoryProfile NativeType;
public:
Lua_Inventory() : Lua_Ptr(nullptr) { }
Lua_Inventory(Inventory *d) : Lua_Ptr(d) { }
Lua_Inventory(EQEmu::InventoryProfile *d) : Lua_Ptr(d) { }
virtual ~Lua_Inventory() { }
operator Inventory*() {
return reinterpret_cast<Inventory*>(GetLuaPtrData());
operator EQEmu::InventoryProfile*() {
return reinterpret_cast<EQEmu::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::ItemBase *t = database.GetItem(item_id);
const EQEmu::ItemData *t = database.GetItem(item_id);
SetLuaPtrData(t);
}
zone/lua_item.h
+6 -6
View File
@@ -6,7 +6,7 @@
namespace EQEmu
{
struct ItemBase;
struct ItemData;
}
namespace luabind {
@@ -15,17 +15,17 @@ namespace luabind {
luabind::scope lua_register_item();
class Lua_Item : public Lua_Ptr<const EQEmu::ItemBase>
class Lua_Item : public Lua_Ptr<const EQEmu::ItemData>
{
typedef const EQEmu::ItemBase NativeType;
typedef const EQEmu::ItemData NativeType;
public:
Lua_Item(uint32 item_id);
Lua_Item() : Lua_Ptr(nullptr) { }
Lua_Item(const EQEmu::ItemBase *d) : Lua_Ptr(d) { }
Lua_Item(const EQEmu::ItemData *d) : Lua_Ptr(d) { }
virtual ~Lua_Item() { }
operator const EQEmu::ItemBase*() {
return reinterpret_cast<const EQEmu::ItemBase*>(GetLuaPtrData());
operator const EQEmu::ItemData*() {
return reinterpret_cast<const EQEmu::ItemData*>(GetLuaPtrData());
}
int GetMinStatus();
zone/lua_iteminst.cpp
+2 -2
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 ItemInst(*o.d_);
d_ = new EQEmu::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 ItemInst(*o.d_);
d_ = new EQEmu::ItemInstance(*o.d_);
} else {
cloned_ = false;
d_ = o.d_;
zone/lua_iteminst.h
+12 -8
View File
@@ -4,30 +4,34 @@
#include "lua_ptr.h"
class ItemInst;
class Lua_Item;
namespace EQEmu
{
class ItemInstance;
}
namespace luabind {
struct scope;
}
luabind::scope lua_register_iteminst();
class Lua_ItemInst : public Lua_Ptr<ItemInst>
class Lua_ItemInst : public Lua_Ptr<EQEmu::ItemInstance>
{
typedef ItemInst NativeType;
typedef EQEmu::ItemInstance NativeType;
public:
Lua_ItemInst(int item_id);
Lua_ItemInst(int item_id, int charges);
Lua_ItemInst() : Lua_Ptr(nullptr), cloned_(false) { }
Lua_ItemInst(ItemInst *d) : Lua_Ptr(d), cloned_(false) { }
Lua_ItemInst(ItemInst *d, bool cloned) : Lua_Ptr(d), cloned_(cloned) { }
Lua_ItemInst(EQEmu::ItemInstance *d) : Lua_Ptr(d), cloned_(false) { }
Lua_ItemInst(EQEmu::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_) { ItemInst *ptr = GetLuaPtrData(); if(ptr) { delete ptr; } } }
virtual ~Lua_ItemInst() { if(cloned_) { EQEmu::ItemInstance *ptr = GetLuaPtrData(); if(ptr) { delete ptr; } } }
operator ItemInst*() {
return reinterpret_cast<ItemInst*>(GetLuaPtrData());
operator EQEmu::ItemInstance*() {
return reinterpret_cast<EQEmu::ItemInstance*>(GetLuaPtrData());
}
bool IsType(int item_class);
zone/lua_npc.cpp
+36
View File
@@ -27,6 +27,36 @@ void Lua_NPC::AddItem(int item_id, int charges, bool equip) {
self->AddItem(item_id, charges, equip);
}
void Lua_NPC::AddItem(int item_id, int charges, bool equip, int aug1) {
Lua_Safe_Call_Void();
self->AddItem(item_id, charges, equip, aug1);
}
void Lua_NPC::AddItem(int item_id, int charges, bool equip, int aug1, int aug2) {
Lua_Safe_Call_Void();
self->AddItem(item_id, charges, equip, aug1, aug2);
}
void Lua_NPC::AddItem(int item_id, int charges, bool equip, int aug1, int aug2, int aug3) {
Lua_Safe_Call_Void();
self->AddItem(item_id, charges, equip, aug1, aug2, aug3);
}
void Lua_NPC::AddItem(int item_id, int charges, bool equip, int aug1, int aug2, int aug3, int aug4) {
Lua_Safe_Call_Void();
self->AddItem(item_id, charges, equip, aug1, aug2, aug3, aug4);
}
void Lua_NPC::AddItem(int item_id, int charges, bool equip, int aug1, int aug2, int aug3, int aug4, int aug5) {
Lua_Safe_Call_Void();
self->AddItem(item_id, charges, equip, aug1, aug2, aug3, aug4, aug5);
}
void Lua_NPC::AddItem(int item_id, int charges, bool equip, int aug1, int aug2, int aug3, int aug4, int aug5, int aug6) {
Lua_Safe_Call_Void();
self->AddItem(item_id, charges, equip, aug1, aug2, aug3, aug4, aug5, aug6);
}
void Lua_NPC::AddLootTable() {
Lua_Safe_Call_Void();
self->AddLootTable();
@@ -475,6 +505,12 @@ luabind::scope lua_register_npc() {
.def("CheckNPCFactionAlly", (int(Lua_NPC::*)(int))&Lua_NPC::CheckNPCFactionAlly)
.def("AddItem", (void(Lua_NPC::*)(int,int))&Lua_NPC::AddItem)
.def("AddItem", (void(Lua_NPC::*)(int,int,bool))&Lua_NPC::AddItem)
.def("AddItem", (void(Lua_NPC::*)(int,int,bool,int))&Lua_NPC::AddItem)
.def("AddItem", (void(Lua_NPC::*)(int,int,bool,int,int))&Lua_NPC::AddItem)
.def("AddItem", (void(Lua_NPC::*)(int,int,bool,int,int,int))&Lua_NPC::AddItem)
.def("AddItem", (void(Lua_NPC::*)(int,int,bool,int,int,int,int))&Lua_NPC::AddItem)
.def("AddItem", (void(Lua_NPC::*)(int,int,bool,int,int,int,int,int))&Lua_NPC::AddItem)
.def("AddItem", (void(Lua_NPC::*)(int,int,bool,int,int,int,int,int,int))&Lua_NPC::AddItem)
.def("AddLootTable", (void(Lua_NPC::*)(void))&Lua_NPC::AddLootTable)
.def("AddLootTable", (void(Lua_NPC::*)(int))&Lua_NPC::AddLootTable)
.def("RemoveItem", (void(Lua_NPC::*)(int))&Lua_NPC::RemoveItem)
zone/lua_npc.h
+6
View File
@@ -31,6 +31,12 @@ public:
int CheckNPCFactionAlly(int faction);
void AddItem(int item_id, int charges);
void AddItem(int item_id, int charges, bool equip);
void AddItem(int item_id, int charges, bool equip, int aug1);
void AddItem(int item_id, int charges, bool equip, int aug1, int aug2);
void AddItem(int item_id, int charges, bool equip, int aug1, int aug2, int aug3);
void AddItem(int item_id, int charges, bool equip, int aug1, int aug2, int aug3, int aug4);
void AddItem(int item_id, int charges, bool equip, int aug1, int aug2, int aug3, int aug4, int aug5);
void AddItem(int item_id, int charges, bool equip, int aug1, int aug2, int aug3, int aug4, int aug5, int aug6);
void AddLootTable();
void AddLootTable(int id);
void RemoveItem(int item_id);
zone/lua_parser.cpp
+5 -5
View File
@@ -422,7 +422,7 @@ int LuaParser::_EventPlayer(std::string package_name, QuestEventID evt, Client *
return 0;
}
int LuaParser::EventItem(QuestEventID evt, Client *client, ItemInst *item, Mob *mob, std::string data, uint32 extra_data,
int LuaParser::EventItem(QuestEventID evt, Client *client, EQEmu::ItemInstance *item, Mob *mob, std::string data, uint32 extra_data,
std::vector<EQEmu::Any> *extra_pointers) {
evt = ConvertLuaEvent(evt);
if(evt >= _LargestEventID) {
@@ -442,7 +442,7 @@ int LuaParser::EventItem(QuestEventID evt, Client *client, ItemInst *item, Mob *
return _EventItem(package_name, evt, client, item, mob, data, extra_data, extra_pointers);
}
int LuaParser::_EventItem(std::string package_name, QuestEventID evt, Client *client, ItemInst *item, Mob *mob,
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) {
const char *sub_name = LuaEvents[evt];
@@ -706,7 +706,7 @@ bool LuaParser::SpellHasQuestSub(uint32 spell_id, QuestEventID evt) {
return HasFunction(subname, package_name);
}
bool LuaParser::ItemHasQuestSub(ItemInst *itm, QuestEventID evt) {
bool LuaParser::ItemHasQuestSub(EQEmu::ItemInstance *itm, QuestEventID evt) {
if (itm == nullptr) {
return false;
}
@@ -752,7 +752,7 @@ void LuaParser::LoadGlobalPlayerScript(std::string filename) {
LoadScript(filename, "global_player");
}
void LuaParser::LoadItemScript(std::string filename, ItemInst *item) {
void LuaParser::LoadItemScript(std::string filename, EQEmu::ItemInstance *item) {
if (item == nullptr)
return;
std::string package_name = "item_";
@@ -1129,7 +1129,7 @@ int LuaParser::DispatchEventPlayer(QuestEventID evt, Client *client, std::string
return ret;
}
int LuaParser::DispatchEventItem(QuestEventID evt, Client *client, ItemInst *item, Mob *mob, std::string data, uint32 extra_data,
int LuaParser::DispatchEventItem(QuestEventID evt, Client *client, EQEmu::ItemInstance *item, Mob *mob, std::string data, uint32 extra_data,
std::vector<EQEmu::Any> *extra_pointers) {
evt = ConvertLuaEvent(evt);
if(evt >= _LargestEventID) {
zone/lua_parser.h
+10 -6
View File
@@ -13,10 +13,14 @@
extern const ZoneConfig *Config;
struct lua_State;
class ItemInst;
class Client;
class NPC;
namespace EQEmu
{
class ItemInstance;
}
#include "lua_parser_events.h"
struct lua_registered_event;
@@ -39,7 +43,7 @@ public:
std::vector<EQEmu::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, ItemInst *item, Mob *mob, std::string data, uint32 extra_data,
virtual int EventItem(QuestEventID evt, Client *client, EQEmu::ItemInstance *item, Mob *mob, std::string data, uint32 extra_data,
std::vector<EQEmu::Any> *extra_pointers);
virtual int EventSpell(QuestEventID evt, NPC* npc, Client *client, uint32 spell_id, uint32 extra_data,
std::vector<EQEmu::Any> *extra_pointers);
@@ -51,14 +55,14 @@ public:
virtual bool PlayerHasQuestSub(QuestEventID evt);
virtual bool GlobalPlayerHasQuestSub(QuestEventID evt);
virtual bool SpellHasQuestSub(uint32 spell_id, QuestEventID evt);
virtual bool ItemHasQuestSub(ItemInst *itm, QuestEventID evt);
virtual bool ItemHasQuestSub(EQEmu::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, ItemInst *item);
virtual void LoadItemScript(std::string filename, EQEmu::ItemInstance *item);
virtual void LoadSpellScript(std::string filename, uint32 spell_id);
virtual void LoadEncounterScript(std::string filename, std::string encounter_name);
@@ -72,7 +76,7 @@ public:
std::vector<EQEmu::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, ItemInst *item, Mob *mob, std::string data, uint32 extra_data,
virtual int DispatchEventItem(QuestEventID evt, Client *client, EQEmu::ItemInstance *item, Mob *mob, std::string data, uint32 extra_data,
std::vector<EQEmu::Any> *extra_pointers);
virtual int DispatchEventSpell(QuestEventID evt, NPC* npc, Client *client, uint32 spell_id, uint32 extra_data,
std::vector<EQEmu::Any> *extra_pointers);
@@ -82,7 +86,7 @@ private:
std::vector<EQEmu::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, ItemInst *item, Mob *mob, std::string data,
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);
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);
zone/lua_parser_events.cpp
+17 -17
View File
@@ -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);
ItemInst *inst = EQEmu::any_cast<ItemInst*>(extra_pointers->at(i));
EQEmu::ItemInstance *inst = EQEmu::any_cast<EQEmu::ItemInstance*>(extra_pointers->at(i));
Lua_ItemInst l_inst = inst;
luabind::adl::object l_inst_o = luabind::adl::object(L, l_inst);
@@ -298,7 +298,7 @@ void handle_player_timer(QuestInterface *parse, lua_State* L, Client* client, st
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::ItemBase *item = database.GetItem(extra_data);
const EQEmu::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);
@@ -314,7 +314,7 @@ 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<ItemInst*>(extra_pointers->at(0)));
Lua_ItemInst l_item(EQEmu::any_cast<EQEmu::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");
@@ -350,7 +350,7 @@ void handle_player_popup_response(QuestInterface *parse, lua_State* L, Client* c
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<ItemInst*>(extra_pointers->at(0)));
Lua_ItemInst l_item(EQEmu::any_cast<EQEmu::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");
@@ -402,7 +402,7 @@ void handle_player_duel_loss(QuestInterface *parse, lua_State* L, Client* client
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<ItemInst*>(extra_pointers->at(0)));
Lua_ItemInst l_item(EQEmu::any_cast<EQEmu::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");
@@ -506,19 +506,19 @@ void handle_player_null(QuestInterface *parse, lua_State* L, Client* client, std
}
//Item
void handle_item_click(QuestInterface *parse, lua_State* L, Client* client, ItemInst* item, Mob *mob, std::string data, uint32 extra_data,
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) {
lua_pushinteger(L, extra_data);
lua_setfield(L, -2, "slot_id");
}
void handle_item_timer(QuestInterface *parse, lua_State* L, Client* client, ItemInst* item, Mob *mob, std::string data, uint32 extra_data,
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) {
lua_pushstring(L, data.c_str());
lua_setfield(L, -2, "timer");
}
void handle_item_proc(QuestInterface *parse, lua_State* L, Client* client, ItemInst* item, Mob *mob, std::string data, uint32 extra_data,
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) {
Lua_Mob l_mob(mob);
@@ -539,7 +539,7 @@ void handle_item_proc(QuestInterface *parse, lua_State* L, Client* client, ItemI
}
}
void handle_item_loot(QuestInterface *parse, lua_State* L, Client* client, ItemInst* item, Mob *mob, std::string data, uint32 extra_data,
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) {
if(mob && mob->IsCorpse()) {
Lua_Corpse l_corpse(mob->CastToCorpse());
@@ -554,15 +554,15 @@ void handle_item_loot(QuestInterface *parse, lua_State* L, Client* client, ItemI
}
}
void handle_item_equip(QuestInterface *parse, lua_State* L, Client* client, ItemInst* item, Mob *mob, std::string data, uint32 extra_data,
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) {
lua_pushinteger(L, extra_data);
lua_setfield(L, -2, "slot_id");
}
void handle_item_augment(QuestInterface *parse, lua_State* L, Client* client, ItemInst* item, Mob *mob, std::string data, uint32 extra_data,
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<ItemInst*>(extra_pointers->at(0)));
Lua_ItemInst l_item(EQEmu::any_cast<EQEmu::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");
@@ -571,9 +571,9 @@ void handle_item_augment(QuestInterface *parse, lua_State* L, Client* client, It
lua_setfield(L, -2, "slot_id");
}
void handle_item_augment_insert(QuestInterface *parse, lua_State* L, Client* client, ItemInst* item, Mob *mob, std::string data, uint32 extra_data,
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<ItemInst*>(extra_pointers->at(0)));
Lua_ItemInst l_item(EQEmu::any_cast<EQEmu::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");
@@ -582,9 +582,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, ItemInst* item, Mob *mob, std::string data, uint32 extra_data,
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<ItemInst*>(extra_pointers->at(0)));
Lua_ItemInst l_item(EQEmu::any_cast<EQEmu::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");
@@ -596,7 +596,7 @@ void handle_item_augment_remove(QuestInterface *parse, lua_State* L, Client* cli
lua_setfield(L, -2, "destroyed");
}
void handle_item_null(QuestInterface *parse, lua_State* L, Client* client, ItemInst* item, Mob *mob, std::string data, uint32 extra_data,
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) {
}
zone/lua_parser_events.h
+10 -10
View File
@@ -4,7 +4,7 @@
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*, ItemInst*, Mob*, 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>*);
@@ -97,23 +97,23 @@ void handle_player_null(QuestInterface *parse, lua_State* L, Client* client, std
std::vector<EQEmu::Any> *extra_pointers);
//Item
void handle_item_click(QuestInterface *parse, lua_State* L, Client* client, ItemInst* item, Mob *mob, std::string data, uint32 extra_data,
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, ItemInst* item, Mob *mob, std::string data, uint32 extra_data,
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, ItemInst* item, Mob *mob, std::string data, uint32 extra_data,
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, ItemInst* item, Mob *mob, std::string data, uint32 extra_data,
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, ItemInst* item, Mob *mob, std::string data, uint32 extra_data,
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, ItemInst* item, Mob *mob, std::string data, uint32 extra_data,
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, ItemInst* item, Mob *mob, std::string data, uint32 extra_data,
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, ItemInst* item, Mob *mob, std::string data, uint32 extra_data,
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, ItemInst* item, Mob *mob, std::string data, uint32 extra_data,
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);
//Spell
zone/map.cpp
+22 -2
View File
@@ -268,12 +268,30 @@ bool Map::CheckLoS(glm::vec3 myloc, glm::vec3 oloc) const {
return !imp->rm->raycast((const RmReal*)&myloc, (const RmReal*)&oloc, nullptr, nullptr, nullptr);
}
inline bool file_exists(const std::string& name) {
std::ifstream f(name.c_str());
return f.good();
}
Map *Map::LoadMapFile(std::string file) {
std::string filename = Config->MapDir;
std::string filename = "";
if (file_exists("maps")) {
filename = "maps";
}
else if (file_exists("Maps")) {
filename = "Maps";
}
else {
filename = Config->MapDir;
}
std::transform(file.begin(), file.end(), file.begin(), ::tolower);
filename += "/";
filename += file;
filename += ".map";
Log.Out(Logs::General, Logs::Status, "Attempting to load Map File :: '%s'", filename.c_str());
auto m = new Map();
if (m->Load(filename)) {
return m;
@@ -287,7 +305,7 @@ Map *Map::LoadMapFile(std::string file) {
bool Map::Load(std::string filename, bool force_mmf_overwrite)
{
if (LoadMMF(filename, force_mmf_overwrite)) {
Log.Out(Logs::General, Logs::Zone_Server, "Zone map mmf found - using it in lieu of '%s'", filename.c_str());
Log.Out(Logs::General, Logs::Status, "Loaded .MMF Map File in place of '%s'", filename.c_str());
return true;
}
#else
@@ -304,6 +322,7 @@ bool Map::Load(std::string filename)
}
if(version == 0x01000000) {
Log.Out(Logs::General, Logs::Status, "Loaded V1 Map File :: '%s'", filename.c_str());
bool v = LoadV1(f);
fclose(f);
@@ -314,6 +333,7 @@ bool Map::Load(std::string filename)
return v;
} else if(version == 0x02000000) {
Log.Out(Logs::General, Logs::Status, "Loaded V2 Map File :: '%s'", filename.c_str());
bool v = LoadV2(f);
fclose(f);
zone/merc.cpp
+25 -25
View File
@@ -214,10 +214,10 @@ void Merc::CalcItemBonuses(StatBonuses* newbon) {
unsigned int i;
//should not include 21 (SLOT_AMMO)
for (i = 0; i < EQEmu::legacy::SlotAmmo; i++) {
for (i = 0; i < EQEmu::inventory::slotAmmo; i++) {
if(equipment[i] == 0)
continue;
const EQEmu::ItemBase * itm = database.GetItem(equipment[i]);
const EQEmu::ItemData * itm = database.GetItem(equipment[i]);
if(itm)
AddItemBonuses(itm, newbon);
}
@@ -225,7 +225,7 @@ void Merc::CalcItemBonuses(StatBonuses* newbon) {
//Power Source Slot
/*if (GetClientVersion() >= EQClientSoF)
{
const ItemInst* inst = m_inv[MainPowerSource];
const EQEmu::ItemInstance* inst = m_inv[MainPowerSource];
if(inst)
AddItemBonuses(inst, newbon);
}*/
@@ -243,7 +243,7 @@ void Merc::CalcItemBonuses(StatBonuses* newbon) {
SetAttackTimer();
}
void Merc::AddItemBonuses(const EQEmu::ItemBase *item, StatBonuses* newbon) {
void Merc::AddItemBonuses(const EQEmu::ItemData *item, StatBonuses* newbon) {
if(GetLevel() < item->ReqLevel)
{
@@ -1221,7 +1221,7 @@ void Merc::FillSpawnStruct(NewSpawn_Struct* ns, Mob* ForWho) {
{
continue;
}
const ItemBase* item = database.GetItem(equipment[i]);
const ItemData* item = database.GetItem(equipment[i]);
if(item)
{
ns->spawn.equipment[i].material = item->Material;
@@ -1559,24 +1559,24 @@ void Merc::AI_Process() {
//try main hand first
if(attack_timer.Check())
{
Attack(GetTarget(), EQEmu::legacy::SlotPrimary);
Attack(GetTarget(), EQEmu::inventory::slotPrimary);
bool tripleSuccess = false;
if(GetOwner() && GetTarget() && CanThisClassDoubleAttack())
{
if(GetOwner()) {
Attack(GetTarget(), EQEmu::legacy::SlotPrimary, true);
Attack(GetTarget(), EQEmu::inventory::slotPrimary, true);
}
if(GetOwner() && GetTarget() && GetSpecialAbility(SPECATK_TRIPLE)) {
tripleSuccess = true;
Attack(GetTarget(), EQEmu::legacy::SlotPrimary, true);
Attack(GetTarget(), EQEmu::inventory::slotPrimary, true);
}
//quad attack, does this belong here??
if(GetOwner() && GetTarget() && GetSpecialAbility(SPECATK_QUAD)) {
Attack(GetTarget(), EQEmu::legacy::SlotPrimary, true);
Attack(GetTarget(), EQEmu::inventory::slotPrimary, true);
}
}
@@ -1588,8 +1588,8 @@ void Merc::AI_Process() {
if(zone->random.Roll(flurrychance))
{
Message_StringID(MT_NPCFlurry, YOU_FLURRY);
Attack(GetTarget(), EQEmu::legacy::SlotPrimary, false);
Attack(GetTarget(), EQEmu::legacy::SlotPrimary, false);
Attack(GetTarget(), EQEmu::inventory::slotPrimary, false);
Attack(GetTarget(), EQEmu::inventory::slotPrimary, false);
}
}
@@ -1598,7 +1598,7 @@ void Merc::AI_Process() {
if (GetTarget() && ExtraAttackChanceBonus) {
if(zone->random.Roll(ExtraAttackChanceBonus))
{
Attack(GetTarget(), EQEmu::legacy::SlotPrimary, false);
Attack(GetTarget(), EQEmu::inventory::slotPrimary, false);
}
}
}
@@ -1634,11 +1634,11 @@ void Merc::AI_Process() {
// Max 78% of DW
if (zone->random.Roll(DualWieldProbability))
{
Attack(GetTarget(), EQEmu::legacy::SlotSecondary); // Single attack with offhand
Attack(GetTarget(), EQEmu::inventory::slotSecondary); // Single attack with offhand
if(CanThisClassDoubleAttack()) {
if(GetTarget() && GetTarget()->GetHP() > -10)
Attack(GetTarget(), EQEmu::legacy::SlotSecondary); // Single attack with offhand
Attack(GetTarget(), EQEmu::inventory::slotSecondary); // Single attack with offhand
}
}
}
@@ -2547,8 +2547,8 @@ int16 Merc::GetFocusEffect(focusType type, uint16 spell_id) {
//Check if item focus effect exists for the client.
if (itembonuses.FocusEffects[type]){
const EQEmu::ItemBase* TempItem = 0;
const EQEmu::ItemBase* UsedItem = 0;
const EQEmu::ItemData* TempItem = 0;
const EQEmu::ItemData* UsedItem = 0;
uint16 UsedFocusID = 0;
int16 Total = 0;
int16 focus_max = 0;
@@ -4428,7 +4428,7 @@ void Merc::DoClassAttacks(Mob *target) {
DoAnim(animKick);
int32 dmg = 0;
if (GetWeaponDamage(target, (const EQEmu::ItemBase*)nullptr) <= 0){
if (GetWeaponDamage(target, (const EQEmu::ItemData*)nullptr) <= 0){
dmg = -5;
}
else{
@@ -4450,7 +4450,7 @@ void Merc::DoClassAttacks(Mob *target) {
DoAnim(animTailRake);
int32 dmg = 0;
if (GetWeaponDamage(target, (const EQEmu::ItemBase*)nullptr) <= 0){
if (GetWeaponDamage(target, (const EQEmu::ItemData*)nullptr) <= 0){
dmg = -5;
}
else{
@@ -5045,13 +5045,13 @@ void Merc::ScaleStats(int scalepercent, bool setmax) {
void Merc::UpdateMercAppearance() {
// Copied from Bot Code:
uint32 itemID = NO_ITEM;
uint8 materialFromSlot = EQEmu::textures::TextureInvalid;
uint32 itemID = 0;
uint8 materialFromSlot = EQEmu::textures::materialInvalid;
for (int i = EQEmu::legacy::EQUIPMENT_BEGIN; i <= EQEmu::legacy::EQUIPMENT_END; ++i) {
itemID = equipment[i];
if(itemID != NO_ITEM) {
materialFromSlot = Inventory::CalcMaterialFromSlot(i);
if (materialFromSlot != EQEmu::textures::TextureInvalid)
if(itemID != 0) {
materialFromSlot = EQEmu::InventoryProfile::CalcMaterialFromSlot(i);
if (materialFromSlot != EQEmu::textures::materialInvalid)
this->SendWearChange(materialFromSlot);
}
}
@@ -5065,8 +5065,8 @@ void Merc::UpdateEquipmentLight()
m_Light.Type[EQEmu::lightsource::LightEquipment] = 0;
m_Light.Level[EQEmu::lightsource::LightEquipment] = 0;
for (int index = SLOT_BEGIN; index < EQEmu::legacy::EQUIPMENT_SIZE; ++index) {
if (index == EQEmu::legacy::SlotAmmo) { continue; }
for (int index = EQEmu::inventory::slotBegin; index < EQEmu::legacy::EQUIPMENT_SIZE; ++index) {
if (index == EQEmu::inventory::slotAmmo) { continue; }
auto item = database.GetItem(equipment[index]);
if (item == nullptr) { continue; }
zone/merc.h
+4 -4
View File
@@ -14,7 +14,7 @@ struct NewSpawn_Struct;
namespace EQEmu
{
struct ItemBase;
struct ItemData;
}
#define MAXMERCS 1
@@ -66,7 +66,7 @@ public:
//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, int special = 0);
virtual bool Attack(Mob* other, int Hand = EQEmu::legacy::SlotPrimary, bool FromRiposte = false, bool IsStrikethrough = false,
virtual bool Attack(Mob* other, int Hand = EQEmu::inventory::slotPrimary, bool FromRiposte = false, bool IsStrikethrough = false,
bool IsFromSpell = false, ExtraAttackOptions *opts = nullptr, int special = 0);
virtual bool HasRaid() { return false; }
virtual bool HasGroup() { return (GetGroup() ? true : false); }
@@ -283,7 +283,7 @@ public:
protected:
void CalcItemBonuses(StatBonuses* newbon);
void AddItemBonuses(const EQEmu::ItemBase *item, StatBonuses* newbon);
void AddItemBonuses(const EQEmu::ItemData *item, StatBonuses* newbon);
int CalcRecommendedLevelBonus(uint8 level, uint8 reclevel, int basestat);
int16 GetFocusEffect(focusType type, uint16 spell_id);
@@ -386,7 +386,7 @@ private:
uint8 _OwnerClientVersion;
uint32 _currentStance;
Inventory m_inv;
EQEmu::InventoryProfile m_inv;
int32 max_end;
int32 cur_end;
bool _medding;
zone/mob.cpp
+31 -29
View File
@@ -108,7 +108,8 @@ Mob::Mob(const char* in_name,
m_TargetLocation(glm::vec3()),
m_TargetV(glm::vec3()),
flee_timer(FLEE_CHECK_TIMER),
m_Position(position)
m_Position(position),
tmHidden(-1)
{
targeted = 0;
tar_ndx=0;
@@ -278,7 +279,7 @@ Mob::Mob(const char* in_name,
RangedProcs[j].level_override = -1;
}
for (i = 0; i < EQEmu::textures::TextureCount; i++)
for (i = EQEmu::textures::textureBegin; i < EQEmu::textures::materialCount; i++)
{
armor_tint.Slot[i].Color = in_armor_tint.Slot[i].Color;
}
@@ -365,6 +366,7 @@ Mob::Mob(const char* in_name,
patrol=0;
follow=0;
follow_dist = 100; // Default Distance for Follow
no_target_hotkey = false;
flee_mode = false;
currently_fleeing = false;
flee_timer.Start();
@@ -1157,8 +1159,8 @@ void Mob::FillSpawnStruct(NewSpawn_Struct* ns, Mob* ForWho)
if (Mob::IsPlayerRace(race) || i > 6)
{
ns->spawn.equipment.Slot[i].Material = GetEquipmentMaterial(i);
ns->spawn.equipment.Slot[i].EliteMaterial = IsEliteMaterialItem(i);
ns->spawn.equipment.Slot[i].HeroForgeModel = GetHerosForgeModel(i);
ns->spawn.equipment.Slot[i].EliteModel = IsEliteMaterialItem(i);
ns->spawn.equipment.Slot[i].HerosForgeModel = GetHerosForgeModel(i);
ns->spawn.equipment_tint.Slot[i].Color = GetEquipmentColor(i);
}
}
@@ -2373,12 +2375,12 @@ bool Mob::CanThisClassDualWield(void) const {
return(GetSkill(EQEmu::skills::SkillDualWield) > 0);
}
else if (CastToClient()->HasSkill(EQEmu::skills::SkillDualWield)) {
const ItemInst* pinst = CastToClient()->GetInv().GetItem(EQEmu::legacy::SlotPrimary);
const ItemInst* sinst = CastToClient()->GetInv().GetItem(EQEmu::legacy::SlotSecondary);
const EQEmu::ItemInstance* pinst = CastToClient()->GetInv().GetItem(EQEmu::inventory::slotPrimary);
const EQEmu::ItemInstance* sinst = CastToClient()->GetInv().GetItem(EQEmu::inventory::slotSecondary);
// 2HS, 2HB, or 2HP
if(pinst && pinst->IsWeapon()) {
const EQEmu::ItemBase* item = pinst->GetItem();
const EQEmu::ItemData* item = pinst->GetItem();
if (item->IsType2HWeapon())
return false;
@@ -2727,7 +2729,7 @@ uint32 NPC::GetEquipment(uint8 material_slot) const
{
if(material_slot > 8)
return 0;
int16 invslot = Inventory::CalcSlotFromMaterial(material_slot);
int16 invslot = EQEmu::InventoryProfile::CalcSlotFromMaterial(material_slot);
if (invslot == INVALID_INDEX)
return 0;
return equipment[invslot];
@@ -2748,7 +2750,7 @@ void Mob::SendArmorAppearance(Client *one_client)
{
if (!IsClient())
{
const EQEmu::ItemBase *item;
const EQEmu::ItemData *item;
for (int i = 0; i < 7; ++i)
{
item = database.GetItem(GetEquipment(i));
@@ -2851,22 +2853,22 @@ int32 Mob::GetEquipmentMaterial(uint8 material_slot) const
{
uint32 equipmaterial = 0;
int32 ornamentationAugtype = RuleI(Character, OrnamentationAugmentType);
const EQEmu::ItemBase *item;
const EQEmu::ItemData *item;
item = database.GetItem(GetEquipment(material_slot));
if (item != 0)
{
// For primary and secondary we need the model, not the material
if (material_slot == EQEmu::textures::TexturePrimary || material_slot == EQEmu::textures::TextureSecondary)
if (material_slot == EQEmu::textures::weaponPrimary || material_slot == EQEmu::textures::weaponSecondary)
{
if (this->IsClient())
{
int16 invslot = Inventory::CalcSlotFromMaterial(material_slot);
int16 invslot = EQEmu::InventoryProfile::CalcSlotFromMaterial(material_slot);
if (invslot == INVALID_INDEX)
{
return 0;
}
const ItemInst* inst = CastToClient()->m_inv[invslot];
const EQEmu::ItemInstance* inst = CastToClient()->m_inv[invslot];
if (inst)
{
if (inst->GetOrnamentationAug(ornamentationAugtype))
@@ -2901,18 +2903,18 @@ int32 Mob::GetEquipmentMaterial(uint8 material_slot) const
int32 Mob::GetHerosForgeModel(uint8 material_slot) const
{
uint32 HeroModel = 0;
if (material_slot >= 0 && material_slot < EQEmu::textures::TexturePrimary)
if (material_slot >= 0 && material_slot < EQEmu::textures::weaponPrimary)
{
uint32 ornamentationAugtype = RuleI(Character, OrnamentationAugmentType);
const EQEmu::ItemBase *item;
const EQEmu::ItemData *item;
item = database.GetItem(GetEquipment(material_slot));
int16 invslot = Inventory::CalcSlotFromMaterial(material_slot);
int16 invslot = EQEmu::InventoryProfile::CalcSlotFromMaterial(material_slot);
if (item != 0 && invslot != INVALID_INDEX)
{
if (IsClient())
{
const ItemInst* inst = CastToClient()->m_inv[invslot];
const EQEmu::ItemInstance* inst = CastToClient()->m_inv[invslot];
if (inst)
{
if (inst->GetOrnamentationAug(ornamentationAugtype))
@@ -2958,7 +2960,7 @@ int32 Mob::GetHerosForgeModel(uint8 material_slot) const
uint32 Mob::GetEquipmentColor(uint8 material_slot) const
{
const EQEmu::ItemBase *item;
const EQEmu::ItemData *item;
if (armor_tint.Slot[material_slot].Color)
{
@@ -2974,7 +2976,7 @@ uint32 Mob::GetEquipmentColor(uint8 material_slot) const
uint32 Mob::IsEliteMaterialItem(uint8 material_slot) const
{
const EQEmu::ItemBase *item;
const EQEmu::ItemData *item;
item = database.GetItem(GetEquipment(material_slot));
if(item != 0)
@@ -3186,7 +3188,7 @@ int32 Mob::GetActSpellCasttime(uint16 spell_id, int32 casttime) {
return casttime;
}
void Mob::ExecWeaponProc(const ItemInst *inst, uint16 spell_id, Mob *on, int level_override) {
void Mob::ExecWeaponProc(const EQEmu::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)) {
@@ -3207,9 +3209,9 @@ void Mob::ExecWeaponProc(const ItemInst *inst, uint16 spell_id, Mob *on, int lev
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 ItemInst floating around anywhere.
//It should be safe as we don't have any truly const EQEmu::ItemInstance floating around anywhere.
//So we'll live with it for now
int i = parse->EventItem(EVENT_WEAPON_PROC, CastToClient(), const_cast<ItemInst*>(inst), on, "", spell_id);
int i = parse->EventItem(EVENT_WEAPON_PROC, CastToClient(), const_cast<EQEmu::ItemInstance*>(inst), on, "", spell_id);
if(i != 0) {
return;
}
@@ -3887,11 +3889,11 @@ void Mob::TrySympatheticProc(Mob *target, uint32 spell_id)
int32 Mob::GetItemStat(uint32 itemid, const char *identifier)
{
const ItemInst* inst = database.CreateItem(itemid);
const EQEmu::ItemInstance* inst = database.CreateItem(itemid);
if (!inst)
return 0;
const EQEmu::ItemBase* item = inst->GetItem();
const EQEmu::ItemData* item = inst->GetItem();
if (!item)
return 0;
@@ -5622,7 +5624,7 @@ int32 Mob::GetSpellStat(uint32 spell_id, const char *identifier, uint8 slot)
bool Mob::CanClassEquipItem(uint32 item_id)
{
const EQEmu::ItemBase* itm = nullptr;
const EQEmu::ItemData* itm = nullptr;
itm = database.GetItem(item_id);
if (!itm)
@@ -5691,9 +5693,9 @@ int32 Mob::GetMeleeMitigation() {
}
/* this is the mob being attacked.
* Pass in the weapon's ItemInst
* Pass in the weapon's EQEmu::ItemInstance
*/
int Mob::ResistElementalWeaponDmg(const ItemInst *item)
int Mob::ResistElementalWeaponDmg(const EQEmu::ItemInstance *item)
{
if (!item)
return 0;
@@ -5843,9 +5845,9 @@ int Mob::ResistElementalWeaponDmg(const ItemInst *item)
}
/* this is the mob being attacked.
* Pass in the weapon's ItemInst
* Pass in the weapon's EQEmu::ItemInstance
*/
int Mob::CheckBaneDamage(const ItemInst *item)
int Mob::CheckBaneDamage(const EQEmu::ItemInstance *item)
{
if (!item)
return 0;
zone/mob.h
+26 -25
View File
@@ -43,7 +43,6 @@ class EGNode;
class Client;
class EQApplicationPacket;
class Group;
class ItemInst;
class NPC;
class Raid;
struct NewSpawn_Struct;
@@ -51,7 +50,8 @@ struct PlayerPositionUpdateServer_Struct;
namespace EQEmu
{
struct ItemBase;
struct ItemData;
class ItemInstance;
}
class Mob : public Entity {
@@ -154,7 +154,7 @@ public:
virtual void ThrowingAttack(Mob* other) { }
uint16 GetThrownDamage(int16 wDmg, int32& TotalDmg, int& minDmg);
// 13 = Primary (default), 14 = secondary
virtual bool Attack(Mob* other, int Hand = EQEmu::legacy::SlotPrimary, bool FromRiposte = false, bool IsStrikethrough = false,
virtual bool Attack(Mob* other, int Hand = EQEmu::inventory::slotPrimary, bool FromRiposte = false, bool IsStrikethrough = false,
bool IsFromSpell = false, ExtraAttackOptions *opts = nullptr, int special = 0) = 0;
int MonkSpecialAttack(Mob* other, uint8 skill_used);
virtual void TryBackstab(Mob *other,int ReuseTime = 10);
@@ -215,7 +215,7 @@ public:
inline bool SeeImprovedHide() const { return see_improved_hide; }
bool IsInvisible(Mob* other = 0) const;
void SetInvisible(uint8 state);
bool AttackAnimation(EQEmu::skills::SkillType &skillinuse, int Hand, const ItemInst* weapon);
bool AttackAnimation(EQEmu::skills::SkillType &skillinuse, int Hand, const EQEmu::ItemInstance* weapon);
//Song
bool UseBardSpellLogic(uint16 spell_id = 0xffff, int slot = -1);
@@ -242,8 +242,8 @@ public:
int resist_override = 0, bool CharismaCheck = false, bool CharmTick = false, bool IsRoot = false,
int level_override = -1);
int ResistPhysical(int level_diff, uint8 caster_level);
int ResistElementalWeaponDmg(const ItemInst *item);
int CheckBaneDamage(const ItemInst *item);
int ResistElementalWeaponDmg(const EQEmu::ItemInstance *item);
int CheckBaneDamage(const EQEmu::ItemInstance *item);
uint16 GetSpecializeSkillValue(uint16 spell_id) const;
void SendSpellBarDisable();
void SendSpellBarEnable(uint16 spellid);
@@ -390,7 +390,7 @@ public:
inline uint8 GetDrakkinHeritage() const { return drakkin_heritage; }
inline uint8 GetDrakkinTattoo() const { return drakkin_tattoo; }
inline uint8 GetDrakkinDetails() const { return drakkin_details; }
inline uint32 GetArmorTint(uint8 i) const { return armor_tint.Slot[(i < EQEmu::textures::TextureCount) ? i : 0].Color; }
inline uint32 GetArmorTint(uint8 i) const { return armor_tint.Slot[(i < EQEmu::textures::materialCount) ? i : 0].Color; }
inline uint8 GetClass() const { return class_; }
inline uint8 GetLevel() const { return level; }
inline uint8 GetOrigLevel() const { return orig_level; }
@@ -577,7 +577,7 @@ public:
bool lookForAftArc = true);
//Procs
void TriggerDefensiveProcs(Mob *on, uint16 hand = EQEmu::legacy::SlotPrimary, bool FromSkillProc = false, int damage = 0);
void TriggerDefensiveProcs(Mob *on, uint16 hand = EQEmu::inventory::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;
@@ -762,6 +762,7 @@ public:
inline const bodyType GetOrigBodyType() const { return orig_bodytype; }
void SetBodyType(bodyType new_body, bool overwrite_orig);
uint32 tmHidden; // timestamp of hide, only valid while hidden == true
uint8 invisible, see_invis;
bool invulnerable, invisible_undead, invisible_animals, sneaking, hidden, improved_hidden;
bool see_invis_undead, see_hide, see_improved_hide;
@@ -774,7 +775,7 @@ public:
virtual int GetHaste();
int32 GetMeleeMitigation();
uint8 GetWeaponDamageBonus(const EQEmu::ItemBase* weapon, bool offhand = false);
uint8 GetWeaponDamageBonus(const EQEmu::ItemData* weapon, bool offhand = false);
uint16 GetDamageTable(EQEmu::skills::SkillType skillinuse);
virtual int GetHandToHandDamage(void);
@@ -799,10 +800,10 @@ public:
int32 ReduceAllDamage(int32 damage);
virtual void DoSpecialAttackDamage(Mob *who, EQEmu::skills::SkillType skill, int32 max_damage, int32 min_damage = 1, int32 hate_override = -1, int ReuseTime = 10, bool CheckHitChance = false, bool CanAvoid = true);
virtual void DoThrowingAttackDmg(Mob* other, const ItemInst* RangeWeapon = nullptr, const EQEmu::ItemBase* AmmoItem = nullptr, uint16 weapon_damage = 0, int16 chance_mod = 0, int16 focus = 0, int ReuseTime = 0, uint32 range_id = 0, int AmmoSlot = 0, float speed = 4.0f);
virtual void 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);
virtual void DoMeleeSkillAttackDmg(Mob* other, uint16 weapon_damage, EQEmu::skills::SkillType skillinuse, int16 chance_mod = 0, int16 focus = 0, bool CanRiposte = false, int ReuseTime = 0);
virtual void DoArcheryAttackDmg(Mob* other, const ItemInst* RangeWeapon = nullptr, const ItemInst* Ammo = nullptr, uint16 weapon_damage = 0, int16 chance_mod = 0, int16 focus = 0, int ReuseTime = 0, uint32 range_id = 0, uint32 ammo_id = 0, const EQEmu::ItemBase *AmmoItem = nullptr, int AmmoSlot = 0, float speed = 4.0f);
bool TryProjectileAttack(Mob* other, const EQEmu::ItemBase *item, EQEmu::skills::SkillType skillInUse, uint16 weapon_dmg, const ItemInst* RangeWeapon, const ItemInst* Ammo, int AmmoSlot, float speed);
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 ProjectileAttack();
inline bool HasProjectileAttack() const { return ActiveProjectileATK; }
inline void SetProjectileAttack(bool value) { ActiveProjectileATK = value; }
@@ -921,7 +922,7 @@ public:
// HP Event
inline int GetNextHPEvent() const { return nexthpevent; }
void SetNextHPEvent( int hpevent );
void SendItemAnimation(Mob *to, const EQEmu::ItemBase *item, EQEmu::skills::SkillType skillInUse, float velocity = 4.0);
void SendItemAnimation(Mob *to, const EQEmu::ItemData *item, EQEmu::skills::SkillType skillInUse, float velocity = 4.0);
inline int& GetNextIncHPEvent() { return nextinchpevent; }
void SetNextIncHPEvent( int inchpevent );
@@ -985,9 +986,9 @@ public:
int32 mod_frenzy_damage(int32 dmg);
int32 mod_monk_special_damage(int32 ndamage, EQEmu::skills::SkillType skill_type);
int32 mod_backstab_damage(int32 ndamage);
int mod_archery_bonus_chance(int bonuschance, const ItemInst* RangeWeapon);
uint32 mod_archery_bonus_damage(uint32 MaxDmg, const ItemInst* RangeWeapon);
int32 mod_archery_damage(int32 TotalDmg, bool hasbonus, const ItemInst* RangeWeapon);
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);
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);
@@ -1158,19 +1159,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::legacy::SlotPrimary);
void TryWeaponProc(const ItemInst* inst, const EQEmu::ItemBase* weapon, Mob *on, uint16 hand = EQEmu::legacy::SlotPrimary);
void TrySpellProc(const ItemInst* inst, const EQEmu::ItemBase* weapon, Mob *on, uint16 hand = EQEmu::legacy::SlotPrimary);
void TryWeaponProc(const ItemInst* weapon, Mob *on, uint16 hand = EQEmu::legacy::SlotPrimary);
void ExecWeaponProc(const ItemInst* weapon, uint16 spell_id, Mob *on, int level_override = -1);
virtual float GetProcChances(float ProcBonus, uint16 hand = EQEmu::legacy::SlotPrimary);
virtual float GetDefensiveProcChances(float &ProcBonus, float &ProcChance, uint16 hand = EQEmu::legacy::SlotPrimary, Mob *on = nullptr);
void TryDefensiveProc(Mob *on, uint16 hand = EQEmu::inventory::slotPrimary);
void TryWeaponProc(const EQEmu::ItemInstance* inst, const EQEmu::ItemData* weapon, Mob *on, uint16 hand = EQEmu::inventory::slotPrimary);
void TrySpellProc(const EQEmu::ItemInstance* inst, const EQEmu::ItemData* weapon, Mob *on, uint16 hand = EQEmu::inventory::slotPrimary);
void TryWeaponProc(const EQEmu::ItemInstance* weapon, Mob *on, uint16 hand = EQEmu::inventory::slotPrimary);
void ExecWeaponProc(const EQEmu::ItemInstance* weapon, uint16 spell_id, Mob *on, int level_override = -1);
virtual float GetProcChances(float ProcBonus, uint16 hand = EQEmu::inventory::slotPrimary);
virtual float GetDefensiveProcChances(float &ProcBonus, float &ProcChance, uint16 hand = EQEmu::inventory::slotPrimary, Mob *on = nullptr);
virtual float GetSpecialProcChances(uint16 hand);
virtual float GetAssassinateProcChances(uint16 ReuseTime);
virtual float GetSkillProcChances(uint16 ReuseTime, uint16 hand = 0); // hand = MainCharm?
uint16 GetWeaponSpeedbyHand(uint16 hand);
int GetWeaponDamage(Mob *against, const EQEmu::ItemBase *weapon_item);
int GetWeaponDamage(Mob *against, const ItemInst *weapon_item, uint32 *hate = nullptr);
int GetWeaponDamage(Mob *against, const EQEmu::ItemData *weapon_item);
int GetWeaponDamage(Mob *against, const EQEmu::ItemInstance *weapon_item, uint32 *hate = nullptr);
int GetKickDamage();
int GetBashDamage();
virtual void ApplySpecialAttackMod(EQEmu::skills::SkillType skill, int32 &dmg, int32 &mindmg);
zone/mob_ai.cpp
+4 -4
View File
@@ -847,7 +847,7 @@ void Client::AI_Process()
if (GetTarget() && !IsStunned() && !IsMezzed() && !GetFeigned()) {
if (attack_timer.Check()) {
// Should charmed clients not be procing?
DoAttackRounds(GetTarget(), EQEmu::legacy::SlotPrimary);
DoAttackRounds(GetTarget(), EQEmu::inventory::slotPrimary);
}
}
@@ -855,7 +855,7 @@ void Client::AI_Process()
if (attack_dw_timer.Check()) {
if (CheckDualWield()) {
// Should charmed clients not be procing?
DoAttackRounds(GetTarget(), EQEmu::legacy::SlotSecondary);
DoAttackRounds(GetTarget(), EQEmu::inventory::slotSecondary);
}
}
}
@@ -1106,7 +1106,7 @@ void Mob::AI_Process() {
//try main hand first
if(attack_timer.Check()) {
DoMainHandAttackRounds(target);
TriggerDefensiveProcs(target, EQEmu::legacy::SlotPrimary, false);
TriggerDefensiveProcs(target, EQEmu::inventory::slotPrimary, false);
bool specialed = false; // NPCs can only do one of these a round
if (GetSpecialAbility(SPECATK_FLURRY)) {
@@ -1952,7 +1952,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::legacy::SlotPrimary, false, false, false, opts);
Attack(target, EQEmu::inventory::slotPrimary, false, false, false, opts);
}
return true;
}
zone/mod_functions.cpp
+13 -9
View File
@@ -5,11 +5,15 @@
#include "worldserver.h"
#include "zone.h"
class ItemInst;
class Spawn2;
struct Consider_Struct;
struct DBTradeskillRecipe_Struct;
namespace EQEmu
{
class ItemInstance;
}
extern EntityList entity_list;
extern Zone* zone;
@@ -25,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::ItemBase* weapon, Mob* other) { return(damage); }
int NPC::mod_npc_damage(int damage, EQEmu::skills::SkillType skillinuse, int hand, const EQEmu::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; }
@@ -34,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 ItemInst* weapon, Mob* other) { return(damage); }
int Client::mod_client_damage(int damage, EQEmu::skills::SkillType skillinuse, int hand, const EQEmu::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:
@@ -87,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 ItemInst* item) { return(pts); }
int32 Client::mod_tribute_item_value(int32 pts, const EQEmu::ItemInstance* item) { return(pts); }
//Death reporting
void Client::mod_client_death_npc(Mob* killerMob) { return; }
@@ -103,8 +107,8 @@ 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::ItemBase *item, int change) { return(change); }
int Client::mod_drink_value(const EQEmu::ItemBase *item, int change) { return(change); }
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); }
//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); }
@@ -148,13 +152,13 @@ int32 Mob::mod_monk_special_damage(int32 ndamage, EQEmu::skills::SkillType skill
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 ItemInst* RangeWeapon) { return(bonuschance); }
int Mob::mod_archery_bonus_chance(int bonuschance, const EQEmu::ItemInstance* RangeWeapon) { return(bonuschance); }
//Archery bonus damage
uint32 Mob::mod_archery_bonus_damage(uint32 MaxDmg, const ItemInst* RangeWeapon) { return(MaxDmg); }
uint32 Mob::mod_archery_bonus_damage(uint32 MaxDmg, const EQEmu::ItemInstance* RangeWeapon) { return(MaxDmg); }
//Final archery damage including bonus if it was applied.
int32 Mob::mod_archery_damage(int32 TotalDmg, bool hasbonus, const ItemInst* RangeWeapon) { return(TotalDmg); }
int32 Mob::mod_archery_damage(int32 TotalDmg, bool hasbonus, const EQEmu::ItemInstance* RangeWeapon) { return(TotalDmg); }
//Thrown weapon damage after all other calcs
uint16 Mob::mod_throwing_damage(uint16 MaxDmg) { return(MaxDmg); }
zone/npc.cpp
+32 -28
View File
@@ -26,8 +26,8 @@
#include "../common/string_util.h"
#include "../common/emu_versions.h"
#include "../common/features.h"
#include "../common/item.h"
#include "../common/item_base.h"
#include "../common/item_instance.h"
#include "../common/item_data.h"
#include "../common/linked_list.h"
#include "../common/servertalk.h"
#include "../common/say_link.h"
@@ -489,8 +489,8 @@ void NPC::CheckMinMaxLevel(Mob *them)
if(themlevel < (*cur)->min_level || themlevel > (*cur)->max_level)
{
material = Inventory::CalcMaterialFromSlot((*cur)->equip_slot);
if (material != EQEmu::textures::TextureInvalid)
material = EQEmu::InventoryProfile::CalcMaterialFromSlot((*cur)->equip_slot);
if (material != EQEmu::textures::materialInvalid)
SendWearChange(material);
cur = itemlist.erase(cur);
@@ -525,19 +525,22 @@ void NPC::QueryLoot(Client* to)
int x = 0;
for (auto cur = itemlist.begin(); cur != itemlist.end(); ++cur, ++x) {
const EQEmu::ItemBase* item = database.GetItem((*cur)->item_id);
if (item == nullptr) {
Log.Out(Logs::General, Logs::Error, "Database error, invalid item");
if (!(*cur)) {
Log.Out(Logs::General, Logs::Error, "NPC::QueryLoot() - ItemList error, null item");
continue;
}
if (!(*cur)->item_id || !database.GetItem((*cur)->item_id)) {
Log.Out(Logs::General, Logs::Error, "NPC::QueryLoot() - Database error, invalid item");
continue;
}
EQEmu::SayLinkEngine linker;
linker.SetLinkType(EQEmu::saylink::SayLinkItemData);
linker.SetItemData(item);
linker.SetLinkType(EQEmu::saylink::SayLinkLootItem);
linker.SetLootData(*cur);
auto item_link = linker.GenerateLink();
to->Message(0, "%s, ID: %u, Level: (min: %u, max: %u)", item_link.c_str(), item->ID, (*cur)->min_level, (*cur)->max_level);
to->Message(0, "%s, ID: %u, Level: (min: %u, max: %u)", item_link.c_str(), (*cur)->item_id, (*cur)->min_level, (*cur)->max_level);
}
to->Message(0, "%i items on %s.", x, GetName());
@@ -750,8 +753,8 @@ void NPC::UpdateEquipmentLight()
m_Light.Type[EQEmu::lightsource::LightEquipment] = 0;
m_Light.Level[EQEmu::lightsource::LightEquipment] = 0;
for (int index = SLOT_BEGIN; index < EQEmu::legacy::EQUIPMENT_SIZE; ++index) {
if (index == EQEmu::legacy::SlotAmmo) { continue; }
for (int index = EQEmu::inventory::slotBegin; index < EQEmu::legacy::EQUIPMENT_SIZE; ++index) {
if (index == EQEmu::inventory::slotAmmo) { continue; }
auto item = database.GetItem(equipment[index]);
if (item == nullptr) { continue; }
@@ -1210,12 +1213,13 @@ uint32 ZoneDatabase::AddNewNPCSpawnGroupCommand(const char *zone, uint32 zone_ve
uint32 ZoneDatabase::UpdateNPCTypeAppearance(Client *client, NPC *spawn)
{
std::string query =
StringFormat("UPDATE npc_types SET name = \"%s\", level = %i, race = %i, class = %i, "
"hp = %i, gender = %i, texture = %i, helmtexture = %i, size = %i, "
"loottable_id = %i, merchant_id = %i, face = %i, WHERE id = %i",
StringFormat("UPDATE npc_types SET name = '%s', level = '%i', race = '%i', class = '%i', "
"hp = '%i', gender = '%i', texture = '%i', helmtexture = '%i', size = '%i', "
"loottable_id = '%i', merchant_id = '%i', face = '%i' "
"WHERE id = '%i'",
spawn->GetName(), spawn->GetLevel(), spawn->GetRace(), spawn->GetClass(), spawn->GetMaxHP(),
spawn->GetGender(), spawn->GetTexture(), spawn->GetHelmTexture(), spawn->GetSize(),
spawn->GetLoottableID(), spawn->MerchantType, spawn->GetNPCTypeID());
spawn->GetLoottableID(), spawn->MerchantType, spawn->GetLuclinFace(), spawn->GetNPCTypeID());
auto results = QueryDatabase(query);
return results.Success() == true ? 1 : 0;
}
@@ -1378,10 +1382,10 @@ uint32 ZoneDatabase::NPCSpawnDB(uint8 command, const char* zone, uint32 zone_ver
int32 NPC::GetEquipmentMaterial(uint8 material_slot) const
{
if (material_slot >= EQEmu::textures::TextureCount)
if (material_slot >= EQEmu::textures::materialCount)
return 0;
int16 invslot = Inventory::CalcSlotFromMaterial(material_slot);
int16 invslot = EQEmu::InventoryProfile::CalcSlotFromMaterial(material_slot);
if (invslot == INVALID_INDEX)
return 0;
@@ -1389,23 +1393,23 @@ int32 NPC::GetEquipmentMaterial(uint8 material_slot) const
{
switch(material_slot)
{
case EQEmu::textures::TextureHead:
case EQEmu::textures::armorHead:
return helmtexture;
case EQEmu::textures::TextureChest:
case EQEmu::textures::armorChest:
return texture;
case EQEmu::textures::TextureArms:
case EQEmu::textures::armorArms:
return armtexture;
case EQEmu::textures::TextureWrist:
case EQEmu::textures::armorWrist:
return bracertexture;
case EQEmu::textures::TextureHands:
case EQEmu::textures::armorHands:
return handtexture;
case EQEmu::textures::TextureLegs:
case EQEmu::textures::armorLegs:
return legtexture;
case EQEmu::textures::TextureFeet:
case EQEmu::textures::armorFeet:
return feettexture;
case EQEmu::textures::TexturePrimary:
case EQEmu::textures::weaponPrimary:
return d_melee_texture1;
case EQEmu::textures::TextureSecondary:
case EQEmu::textures::weaponSecondary:
return d_melee_texture2;
default:
//they have nothing in the slot, and its not a special slot... they get nothing.
@@ -1462,7 +1466,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::ItemBase*, uint16>> loot_selection; // <const ItemBase*, charges>
std::vector<std::pair<const EQEmu::ItemData*, uint16>> loot_selection; // <const ItemData*, charges>
for (auto item_iter : itemlist) {
if (!item_iter || !item_iter->item_id)
continue;
zone/npc.h
+6 -6
View File
@@ -93,7 +93,7 @@ class Spawn2;
namespace EQEmu
{
struct ItemBase;
struct ItemData;
}
class NPC : public Mob
@@ -110,7 +110,7 @@ public:
//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, int special = 0);
virtual bool Attack(Mob* other, int Hand = EQEmu::legacy::SlotPrimary, bool FromRiposte = false, bool IsStrikethrough = false,
virtual bool Attack(Mob* other, int Hand = EQEmu::inventory::slotPrimary, bool FromRiposte = false, bool IsStrikethrough = false,
bool IsFromSpell = false, ExtraAttackOptions *opts = nullptr, int special = 0);
virtual bool HasRaid() { return false; }
virtual bool HasGroup() { return false; }
@@ -178,8 +178,8 @@ public:
virtual void SpellProcess();
virtual void FillSpawnStruct(NewSpawn_Struct* ns, Mob* ForWho);
void AddItem(const EQEmu::ItemBase* item, uint16 charges, bool equipitem = true);
void AddItem(uint32 itemid, uint16 charges, bool equipitem = true);
void AddItem(const EQEmu::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);
void DescribeAggro(Client *towho, Mob *mob, bool verbose);
@@ -270,7 +270,7 @@ public:
bool IsTaunting() const { return taunting; }
void PickPocket(Client* thief);
void StartSwarmTimer(uint32 duration) { swarm_timer.Start(duration); }
void AddLootDrop(const EQEmu::ItemBase*dbitem, ItemList* itemlistconst, int16 charges, uint8 minlevel, uint8 maxlevel, bool equipit, bool wearchange = false);
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);
virtual void DoClassAttacks(Mob *target);
void CheckSignal();
inline bool IsNotTargetableWithHotkey() const { return no_target_hotkey; }
@@ -403,7 +403,7 @@ public:
void SetMerchantProbability(uint8 amt) { probability = amt; }
uint8 GetMerchantProbability() { return probability; }
void mod_prespawn(Spawn2 *sp);
int mod_npc_damage(int damage, EQEmu::skills::SkillType skillinuse, int hand, const EQEmu::ItemBase* weapon, Mob* other);
int mod_npc_damage(int damage, EQEmu::skills::SkillType skillinuse, int hand, const EQEmu::ItemData* weapon, Mob* other);
void mod_npc_killed_merit(Mob* c);
void mod_npc_killed(Mob* oos);
void AISpellsList(Client *c);
zone/object.cpp
+38 -23
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 ItemInst* inst)
Object::Object(uint32 id, uint32 type, uint32 icon, const Object_Struct& object, const EQEmu::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 ItemInst* inst, char* name,float max_x,float min_x,float max_y,float min_y,float z,float heading,uint32 respawntimer)
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)
: respawn_timer(respawntimer), decay_timer(300000)
{
@@ -102,7 +102,7 @@ Object::Object(const ItemInst* inst, char* name,float max_x,float min_x,float ma
}
// Loading object from client dropping item on ground
Object::Object(Client* client, const ItemInst* inst)
Object::Object(Client* client, const EQEmu::ItemInstance* inst)
: respawn_timer(0), decay_timer(300000)
{
user = nullptr;
@@ -141,7 +141,7 @@ Object::Object(Client* client, const ItemInst* inst)
// Set object name
if (inst) {
const EQEmu::ItemBase* item = inst->GetItem();
const EQEmu::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 ItemInst* inst)
}
}
Object::Object(const ItemInst *inst, float x, float y, float z, float heading, uint32 decay_time)
Object::Object(const EQEmu::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 ItemInst *inst, float x, float y, float z, float heading, u
// Set object name
if (inst) {
const EQEmu::ItemBase* item = inst->GetItem();
const EQEmu::ItemData* item = inst->GetItem();
if (item && item->IDFile) {
if (strlen(item->IDFile) == 0) {
strcpy(m_data.object_name, DEFAULT_OBJECT_NAME);
@@ -225,8 +225,8 @@ Object::Object(const char *model, float x, float y, float z, float heading, uint
{
user = nullptr;
last_user = nullptr;
ItemInst* inst = nullptr;
inst = new ItemInst(ItemInstWorldContainer);
EQEmu::ItemInstance* inst = nullptr;
inst = new EQEmu::ItemInstance(ItemInstWorldContainer);
// Initialize members
m_id = 0;
@@ -326,7 +326,7 @@ void Object::Delete(bool reset_state)
}
}
const ItemInst* Object::GetItem(uint8 index) {
const EQEmu::ItemInstance* Object::GetItem(uint8 index) {
if (index < EQEmu::legacy::TYPE_WORLD_SIZE) {
return m_inst->GetItem(index);
}
@@ -335,7 +335,7 @@ const ItemInst* Object::GetItem(uint8 index) {
}
// Add item to object (only logical for world tradeskill containers
void Object::PutItem(uint8 index, const ItemInst* inst)
void Object::PutItem(uint8 index, const EQEmu::ItemInstance* inst)
{
if (index > 9) {
Log.Out(Logs::General, Logs::Error, "Object::PutItem: Invalid index specified (%i)", index);
@@ -362,12 +362,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
ItemInst* container = this->m_inst;
EQEmu::ItemInstance* container = this->m_inst;
if(container != nullptr)
{
for (uint8 i = SUB_INDEX_BEGIN; i < EQEmu::legacy::ITEM_CONTAINER_SIZE; i++)
for (uint8 i = EQEmu::inventory::containerBegin; i < EQEmu::inventory::ContainerCount; i++)
{
ItemInst* inst = container->PopItem(i);
EQEmu::ItemInstance* inst = container->PopItem(i);
if(inst != nullptr)
{
user->MoveItemToInventory(inst, true);
@@ -392,9 +392,9 @@ void Object::DeleteItem(uint8 index)
}
// Pop item out of container
ItemInst* Object::PopItem(uint8 index)
EQEmu::ItemInstance* Object::PopItem(uint8 index)
{
ItemInst* inst = nullptr;
EQEmu::ItemInstance* inst = nullptr;
if (m_inst && m_inst->IsType(EQEmu::item::ItemClassBag)) {
inst = m_inst->PopItem(index);
@@ -451,6 +451,21 @@ void Object::RandomSpawn(bool send_packet) {
m_data.x = zone->random.Real(m_min_x, m_max_x);
m_data.y = zone->random.Real(m_min_y, m_max_y);
if(m_data.z == BEST_Z_INVALID) {
glm::vec3 me;
me.x = m_data.x;
me.y = m_data.y;
me.z = 0;
glm::vec3 hit;
float best_z = zone->zonemap->FindClosestZ(me, &hit);
if (best_z != BEST_Z_INVALID) {
m_data.z = best_z + 0.1f;
}
}
Log.Out(Logs::Detail, Logs::Zone_Server, "Object::RandomSpawn(%s): %d (%.2f, %.2f, %.2f)", m_data.object_name, m_inst->GetID(), m_data.x, m_data.y, m_data.z);
respawn_timer.Disable();
if(send_packet) {
@@ -506,11 +521,11 @@ bool Object::HandleClick(Client* sender, const ClickObject_Struct* click_object)
// Transfer item to client
sender->PutItemInInventory(EQEmu::legacy::SlotCursor, *m_inst, false);
sender->SendItemPacket(EQEmu::legacy::SlotCursor, m_inst, ItemPacketTrade);
sender->PutItemInInventory(EQEmu::inventory::slotCursor, *m_inst, false);
sender->SendItemPacket(EQEmu::inventory::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::legacy::SlotCursor);
sender->DeleteItemInInventory(EQEmu::inventory::slotCursor);
if(!m_ground_spawn)
safe_delete(m_inst);
@@ -587,8 +602,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 = SUB_INDEX_BEGIN; i < EQEmu::legacy::ITEM_CONTAINER_SIZE; i++) {
const ItemInst* inst = m_inst->GetItem(i);
for (uint8 i = EQEmu::inventory::containerBegin; i < EQEmu::inventory::ContainerCount; i++) {
const EQEmu::ItemInstance* inst = m_inst->GetItem(i);
if (inst) {
//sender->GetInv().PutItem(i+4000,inst);
sender->SendItemPacket(i, inst, ItemPacketWorldContainer);
@@ -601,7 +616,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 ItemInst* inst)
uint32 ZoneDatabase::AddObject(uint32 type, uint32 icon, const Object_Struct& object, const EQEmu::ItemInstance* inst)
{
uint32 database_id = 0;
uint32 item_id = 0;
@@ -639,7 +654,7 @@ uint32 ZoneDatabase::AddObject(uint32 type, uint32 icon, const Object_Struct& ob
}
// Update information about existing object in database
void ZoneDatabase::UpdateObject(uint32 id, uint32 type, uint32 icon, const Object_Struct& object, const ItemInst* inst)
void ZoneDatabase::UpdateObject(uint32 id, uint32 type, uint32 icon, const Object_Struct& object, const EQEmu::ItemInstance* inst)
{
uint32 item_id = 0;
int16 charges = 0;
@@ -930,7 +945,7 @@ uint32 Object::GetItemID()
return 0;
}
const EQEmu::ItemBase* item = this->m_inst->GetItem();
const EQEmu::ItemData* item = this->m_inst->GetItem();
if (item == 0)
{
zone/object.h
+13 -9
View File
@@ -29,7 +29,11 @@
class Client;
class EQApplicationPacket;
class ItemInst;
namespace EQEmu
{
class ItemInstance;
}
/*
item icon numbers (showeq)
@@ -89,11 +93,11 @@ class Object: public Entity
{
public:
// Loading object from database
Object(uint32 id, uint32 type, uint32 icon, const Object_Struct& data, const ItemInst* inst);
Object(const ItemInst* 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 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);
// Loading object from client dropping item on ground
Object(Client* client, const ItemInst* inst);
Object(const ItemInst *inst, float x, float y, float z, float heading, uint32 decay_time = 300000);
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(const char *model, float x, float y, float z, float heading, uint8 type, uint32 decay_time = 0);
// Destructor
@@ -120,10 +124,10 @@ public:
void StartDecay() {decay_timer.Start();}
// Container functions
const ItemInst* GetItem(uint8 index);
void PutItem(uint8 index, const ItemInst* inst);
const EQEmu::ItemInstance* GetItem(uint8 index);
void PutItem(uint8 index, const EQEmu::ItemInstance* inst);
void DeleteItem(uint8 index); // Item inside container
ItemInst* PopItem(uint8 index); // Pop item out of container
EQEmu::ItemInstance* PopItem(uint8 index); // Pop item out of container
// Override base class implementations
virtual bool IsObject() const { return true; }
@@ -176,7 +180,7 @@ protected:
void RandomSpawn(bool send_packet = false); //spawn this ground spawn at a random place
Object_Struct m_data; // Packet data
ItemInst* m_inst; // Item representing object
EQEmu::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/perl_client.cpp
+4 -4
View File
@@ -4324,7 +4324,7 @@ XS(XS_Client_GetItemAt)
Perl_croak(aTHX_ "Usage: Client::GetItemAt(THIS, slot)");
{
Client * THIS;
ItemInst * RETVAL;
EQEmu::ItemInstance * RETVAL;
uint32 slot = (int32)SvIV(ST(1));
if (sv_derived_from(ST(0), "Client")) {
@@ -4351,7 +4351,7 @@ XS(XS_Client_GetAugmentAt)
Perl_croak(aTHX_ "Usage: Client::GetAugmentAt(THIS, slot, aug_slot)");
{
Client * THIS;
ItemInst * RETVAL;
EQEmu::ItemInstance * RETVAL;
uint32 slot = (int32)SvIV(ST(1));
uint32 aug_slot = (int32)SvIV(ST(1));
@@ -4364,7 +4364,7 @@ XS(XS_Client_GetAugmentAt)
if(THIS == nullptr)
Perl_croak(aTHX_ "THIS is nullptr, avoiding crash.");
ItemInst * inst = THIS->GetInv().GetItem(slot);
EQEmu::ItemInstance * inst = THIS->GetInv().GetItem(slot);
if(inst)
{
RETVAL = inst->GetAugment(aug_slot);
@@ -5627,7 +5627,7 @@ XS(XS_Client_GetItemInInventory)
{
Client * THIS;
int16 slot_id = (int16)SvIV(ST(1));
ItemInst *RETVAL = nullptr;
EQEmu::ItemInstance *RETVAL = nullptr;
if (sv_derived_from(ST(0), "Client")) {
IV tmp = SvIV((SV*)SvRV(ST(0)));
zone/perl_mob.cpp
+4 -4
View File
@@ -8092,8 +8092,8 @@ XS(XS_Mob_DoArcheryAttackDmg)
{
Mob * THIS;
Mob* target;
ItemInst* RangeWeapon = nullptr;
ItemInst* Ammo = nullptr;
EQEmu::ItemInstance* RangeWeapon = nullptr;
EQEmu::ItemInstance* Ammo = nullptr;
uint16 weapon_damage = (uint16)SvIV(ST(4));
int16 chance_mod = (int16)SvIV(ST(5));
int16 focus = (int16)SvIV(ST(6));
@@ -8130,8 +8130,8 @@ XS(XS_Mob_DoThrowingAttackDmg)
{
Mob * THIS;
Mob* target;
ItemInst* RangeWeapon = nullptr;
EQEmu::ItemBase* item = nullptr;
EQEmu::ItemInstance* RangeWeapon = nullptr;
EQEmu::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_npc.cpp
+22 -4
View File
@@ -98,13 +98,19 @@ XS(XS_NPC_AddItem); /* prototype to pass -Wmissing-prototypes */
XS(XS_NPC_AddItem)
{
dXSARGS;
if (items < 2 || items > 4)
Perl_croak(aTHX_ "Usage: NPC::AddItem(THIS, itemid, charges = 0, equipitem = true)");
if (items < 2 || items > 10)
Perl_croak(aTHX_ "Usage: NPC::AddItem(THIS, itemid, charges = 0, equipitem = true, aug1 = 0, aug2 = 0, aug3 = 0, aug4 = 0, aug5 = 0, aug6 = 0)");
{
NPC * THIS;
uint32 itemid = (uint32)SvUV(ST(1));
uint16 charges = 0;
bool equipitem = true;
uint32 aug1 = 0;
uint32 aug2 = 0;
uint32 aug3 = 0;
uint32 aug4 = 0;
uint32 aug5 = 0;
uint32 aug6 = 0;
if (sv_derived_from(ST(0), "NPC")) {
IV tmp = SvIV((SV*)SvRV(ST(0)));
@@ -119,8 +125,20 @@ XS(XS_NPC_AddItem)
charges = (uint16)SvUV(ST(2));
if (items > 3)
equipitem = (bool)SvTRUE(ST(3));
if (items > 4)
aug1 = (uint32)SvUV(ST(4));
if (items > 5)
aug2 = (uint32)SvUV(ST(5));
if (items > 6)
aug3 = (uint32)SvUV(ST(6));
if (items > 7)
aug4 = (uint32)SvUV(ST(7));
if (items > 8)
aug5 = (uint32)SvUV(ST(8));
if (items > 9)
aug6 = (uint32)SvUV(ST(9));
THIS->AddItem(itemid, charges, equipitem);
THIS->AddItem(itemid, charges, equipitem, aug1, aug2, aug3, aug4, aug5, aug6);
}
XSRETURN_EMPTY;
}
@@ -2577,7 +2595,7 @@ XS(boot_NPC)
newXSproto(strcpy(buf, "SignalNPC"), XS_NPC_SignalNPC, file, "$$");
newXSproto(strcpy(buf, "CheckNPCFactionAlly"), XS_NPC_CheckNPCFactionAlly, file, "$$");
newXSproto(strcpy(buf, "AddItem"), XS_NPC_AddItem, file, "$$;$$");
newXSproto(strcpy(buf, "AddItem"), XS_NPC_AddItem, file, "$$;$$$$$$$$");
newXSproto(strcpy(buf, "AddLootTable"), XS_NPC_AddLootTable, file, "$");
newXSproto(strcpy(buf, "RemoveItem"), XS_NPC_RemoveItem, file, "$$;$$");
newXSproto(strcpy(buf, "ClearItemList"), XS_NPC_ClearItemList, file, "$");
zone/perl_questitem.cpp
+26 -26
View File
@@ -26,7 +26,7 @@
#undef seed
#endif
#include "../common/item.h"
#include "../common/item_instance.h"
#ifdef THIS /* this macro seems to leak out on some systems */
#undef THIS
@@ -38,16 +38,16 @@ XS(XS_QuestItem_GetName) {
if (items != 1)
Perl_croak(aTHX_ "Usage: QuestItem::GetName(THIS)");
{
ItemInst * THIS;
EQEmu::ItemInstance * THIS;
Const_char * RETVAL;
dXSTARG;
if (sv_derived_from(ST(0), "QuestItem")) {
IV tmp = SvIV((SV*)SvRV(ST(0)));
THIS = INT2PTR(ItemInst *,tmp);
THIS = INT2PTR(EQEmu::ItemInstance *,tmp);
}
else
Perl_croak(aTHX_ "THIS is not of type ItemInst");
Perl_croak(aTHX_ "THIS is not of type EQEmu::ItemInstance");
if(THIS == nullptr)
Perl_croak(aTHX_ "THIS is nullptr, avoiding crash.");
@@ -64,15 +64,15 @@ XS(XS_QuestItem_SetScale)
if (items != 2)
Perl_croak(aTHX_ "Usage: QuestItem::SetScale(THIS, scale factor)");
{
ItemInst * THIS;
EQEmu::ItemInstance * THIS;
float Mult;
if (sv_derived_from(ST(0), "QuestItem")) {
IV tmp = SvIV((SV*)SvRV(ST(0)));
THIS = INT2PTR(ItemInst *,tmp);
THIS = INT2PTR(EQEmu::ItemInstance *,tmp);
}
else
Perl_croak(aTHX_ "THIS is not of type ItemInst");
Perl_croak(aTHX_ "THIS is not of type EQEmu::ItemInstance");
if(THIS == nullptr)
Perl_croak(aTHX_ "THIS is nullptr, avoiding crash.");
@@ -92,16 +92,16 @@ XS(XS_QuestItem_ItemSay)
if (items != 2 && items != 3)
Perl_croak(aTHX_ "Usage: QuestItem::ItemSay(THIS, text [, language])");
{
ItemInst* THIS;
EQEmu::ItemInstance* THIS;
Const_char* text;
int lang = 0;
if (sv_derived_from(ST(0), "QuestItem")) {
IV tmp = SvIV((SV*)SvRV(ST(0)));
THIS = INT2PTR(ItemInst *,tmp);
THIS = INT2PTR(EQEmu::ItemInstance *,tmp);
}
else
Perl_croak(aTHX_ "THIS is not of type ItemInst");
Perl_croak(aTHX_ "THIS is not of type EQEmu::ItemInstance");
if(THIS == nullptr)
Perl_croak(aTHX_ "THIS is nullptr, avoiding crash.");
@@ -121,16 +121,16 @@ XS(XS_QuestItem_IsType)
if (items != 2)
Perl_croak(aTHX_ "Usage: QuestItem::IsType(THIS, type)");
{
ItemInst* THIS;
EQEmu::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(ItemInst *,tmp);
THIS = INT2PTR(EQEmu::ItemInstance *,tmp);
}
else
Perl_croak(aTHX_ "THIS is not of type ItemInst");
Perl_croak(aTHX_ "THIS is not of type EQEmu::ItemInstance");
if(THIS == nullptr)
Perl_croak(aTHX_ "THIS is nullptr, avoiding crash.");
@@ -148,15 +148,15 @@ XS(XS_QuestItem_IsAttuned)
if (items != 1)
Perl_croak(aTHX_ "Usage: QuestItem::IsAttuned(THIS)");
{
ItemInst* THIS;
EQEmu::ItemInstance* THIS;
bool RETVAL;
if (sv_derived_from(ST(0), "QuestItem")) {
IV tmp = SvIV((SV*)SvRV(ST(0)));
THIS = INT2PTR(ItemInst *,tmp);
THIS = INT2PTR(EQEmu::ItemInstance *,tmp);
}
else
Perl_croak(aTHX_ "THIS is not of type ItemInst");
Perl_croak(aTHX_ "THIS is not of type EQEmu::ItemInstance");
if(THIS == nullptr)
Perl_croak(aTHX_ "THIS is nullptr, avoiding crash.");
@@ -174,16 +174,16 @@ XS(XS_QuestItem_GetCharges)
if (items != 1)
Perl_croak(aTHX_ "Usage: QuestItem::GetCharges(THIS)");
{
ItemInst* THIS;
EQEmu::ItemInstance* THIS;
int16 RETVAL;
dXSTARG;
if (sv_derived_from(ST(0), "QuestItem")) {
IV tmp = SvIV((SV*)SvRV(ST(0)));
THIS = INT2PTR(ItemInst *,tmp);
THIS = INT2PTR(EQEmu::ItemInstance *,tmp);
}
else
Perl_croak(aTHX_ "THIS is not of type ItemInst");
Perl_croak(aTHX_ "THIS is not of type EQEmu::ItemInstance");
if(THIS == nullptr)
Perl_croak(aTHX_ "THIS is nullptr, avoiding crash.");
@@ -200,16 +200,16 @@ XS(XS_QuestItem_GetAugment)
if (items != 2)
Perl_croak(aTHX_ "Usage: QuestItem::GetAugment(THIS, augment_id)");
{
ItemInst* THIS;
EQEmu::ItemInstance* THIS;
int16 slot_id = (int16)SvIV(ST(1));
ItemInst* RETVAL;
EQEmu::ItemInstance* RETVAL;
if (sv_derived_from(ST(0), "QuestItem")) {
IV tmp = SvIV((SV*)SvRV(ST(0)));
THIS = INT2PTR(ItemInst *,tmp);
THIS = INT2PTR(EQEmu::ItemInstance *,tmp);
}
else
Perl_croak(aTHX_ "THIS is not of type ItemInst");
Perl_croak(aTHX_ "THIS is not of type EQEmu::ItemInstance");
if(THIS == nullptr)
Perl_croak(aTHX_ "THIS is nullptr, avoiding crash.");
@@ -227,16 +227,16 @@ XS(XS_QuestItem_GetID)
if (items != 1)
Perl_croak(aTHX_ "Usage: QuestItem::GetID(THIS)");
{
ItemInst* THIS;
EQEmu::ItemInstance* THIS;
uint32 RETVAL;
dXSTARG;
if (sv_derived_from(ST(0), "QuestItem")) {
IV tmp = SvIV((SV*)SvRV(ST(0)));
THIS = INT2PTR(ItemInst *,tmp);
THIS = INT2PTR(EQEmu::ItemInstance *,tmp);
}
else
Perl_croak(aTHX_ "THIS is not of type ItemInst");
Perl_croak(aTHX_ "THIS is not of type EQEmu::ItemInstance");
if(THIS == nullptr)
Perl_croak(aTHX_ "THIS is nullptr, avoiding crash.");
zone/pets.cpp
+2 -2
View File
@@ -420,7 +420,7 @@ void Mob::MakePoweredPet(uint16 spell_id, const char* pettype, int16 petpower,
// like the special back items some focused pets may receive.
uint32 petinv[EQEmu::legacy::EQUIPMENT_SIZE];
memset(petinv, 0, sizeof(petinv));
const EQEmu::ItemBase *item = 0;
const EQEmu::ItemData *item = 0;
if (database.GetBasePetItems(record.equipmentset, petinv)) {
for (int i = 0; i < EQEmu::legacy::EQUIPMENT_SIZE; i++)
@@ -665,7 +665,7 @@ void NPC::SetPetState(SpellBuff_Struct *pet_buffs, uint32 *items) {
if(items[i] == 0)
continue;
const EQEmu::ItemBase* item2 = database.GetItem(items[i]);
const EQEmu::ItemData* item2 = database.GetItem(items[i]);
if (item2 && item2->NoDrop != 0) {
//dont bother saving item charges for now, NPCs never use them
//and nobody should be able to get them off the corpse..?
zone/quest_interface.h
+9 -5
View File
@@ -23,10 +23,14 @@
#include "../common/any.h"
#include "event_codes.h"
class ItemInst;
class Client;
class NPC;
namespace EQEmu
{
class ItemInstance;
}
class QuestInterface {
public:
virtual int EventNPC(QuestEventID evt, NPC* npc, Mob *init, std::string data, uint32 extra_data,
@@ -37,7 +41,7 @@ public:
std::vector<EQEmu::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, ItemInst *item, Mob *mob, std::string data, uint32 extra_data,
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; }
virtual int EventSpell(QuestEventID evt, NPC* npc, Client *client, uint32 spell_id, uint32 extra_data,
std::vector<EQEmu::Any> *extra_pointers) { return 0; }
@@ -49,14 +53,14 @@ public:
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(ItemInst *itm, QuestEventID evt) { return false; }
virtual bool ItemHasQuestSub(EQEmu::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, ItemInst *item) { }
virtual void LoadItemScript(std::string filename, EQEmu::ItemInstance *item) { }
virtual void LoadSpellScript(std::string filename, uint32 spell_id) { }
virtual void LoadEncounterScript(std::string filename, std::string encounter_name) { }
@@ -64,7 +68,7 @@ public:
std::vector<EQEmu::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, ItemInst *item, Mob *mob, std::string data, uint32 extra_data,
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; }
virtual int DispatchEventSpell(QuestEventID evt, NPC* npc, Client *client, uint32 spell_id, uint32 extra_data,
std::vector<EQEmu::Any> *extra_pointers) { return 0; }
zone/quest_parser_collection.cpp
+3 -3
View File
@@ -200,7 +200,7 @@ bool QuestParserCollection::SpellHasQuestSub(uint32 spell_id, QuestEventID evt)
return false;
}
bool QuestParserCollection::ItemHasQuestSub(ItemInst *itm, QuestEventID evt) {
bool QuestParserCollection::ItemHasQuestSub(EQEmu::ItemInstance *itm, QuestEventID evt) {
if (itm == nullptr)
return false;
@@ -352,7 +352,7 @@ int QuestParserCollection::EventPlayerGlobal(QuestEventID evt, Client *client, s
return 0;
}
int QuestParserCollection::EventItem(QuestEventID evt, Client *client, ItemInst *item, Mob *mob, std::string data, uint32 extra_data,
int QuestParserCollection::EventItem(QuestEventID evt, Client *client, EQEmu::ItemInstance *item, Mob *mob, std::string data, uint32 extra_data,
std::vector<EQEmu::Any> *extra_pointers) {
// needs pointer validation check on 'item' argument
@@ -1013,7 +1013,7 @@ int QuestParserCollection::DispatchEventPlayer(QuestEventID evt, Client *client,
return ret;
}
int QuestParserCollection::DispatchEventItem(QuestEventID evt, Client *client, ItemInst *item, Mob *mob, std::string data,
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 ret = 0;
auto iter = _load_precedence.begin();
zone/quest_parser_collection.h
+9 -5
View File
@@ -44,11 +44,15 @@
extern const ZoneConfig *Config;
class Client;
class ItemInst;
class Mob;
class NPC;
class QuestInterface;
namespace EQEmu { class Any; }
namespace EQEmu
{
class Any;
class ItemInstance;
}
class QuestParserCollection {
public:
@@ -65,13 +69,13 @@ public:
bool HasQuestSub(uint32 npcid, QuestEventID evt);
bool PlayerHasQuestSub(QuestEventID evt);
bool SpellHasQuestSub(uint32 spell_id, QuestEventID evt);
bool ItemHasQuestSub(ItemInst *itm, QuestEventID evt);
bool ItemHasQuestSub(EQEmu::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);
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, ItemInst *item, Mob *mob, std::string data, uint32 extra_data,
int EventItem(QuestEventID evt, Client *client, EQEmu::ItemInstance *item, Mob *mob, std::string data, uint32 extra_data,
std::vector<EQEmu::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);
@@ -124,7 +128,7 @@ private:
std::vector<EQEmu::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, ItemInst *item, Mob *mob, std::string data, uint32 extra_data,
int DispatchEventItem(QuestEventID evt, Client *client, EQEmu::ItemInstance *item, Mob *mob, std::string data, uint32 extra_data,
std::vector<EQEmu::Any> *extra_pointers);
int DispatchEventSpell(QuestEventID evt, NPC* npc, Client *client, uint32 spell_id, uint32 extra_data,
std::vector<EQEmu::Any> *extra_pointers);
zone/questmgr.cpp
+14 -14
View File
@@ -54,7 +54,7 @@ QuestManager quest_manager;
#define QuestManagerCurrentQuestVars() \
Mob *owner = nullptr; \
Client *initiator = nullptr; \
ItemInst* questitem = nullptr; \
EQEmu::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, ItemInst* _questitem, std::string encounter) {
void QuestManager::StartQuest(Mob *_owner, Client *_initiator, EQEmu::ItemInstance* _questitem, std::string encounter) {
running_quest run;
run.owner = _owner;
run.initiator = _initiator;
@@ -375,11 +375,11 @@ void QuestManager::selfcast(int spell_id) {
initiator->SpellFinished(spell_id, initiator, EQEmu::CastingSlot::Item, 0, -1, spells[spell_id].ResistDiff);
}
void QuestManager::addloot(int item_id, int charges, bool equipitem) {
void QuestManager::addloot(int item_id, int charges, bool equipitem, int aug1, int aug2, int aug3, int aug4, int aug5, int aug6) {
QuestManagerCurrentQuestVars();
if(item_id != 0){
if(owner->IsNPC())
owner->CastToNPC()->AddItem(item_id, charges, equipitem);
owner->CastToNPC()->AddItem(item_id, charges, equipitem, aug1, aug2, aug3, aug4, aug5, aug6);
}
}
@@ -450,7 +450,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, ItemInst *inst) {
void QuestManager::settimerMS(const char *timer_name, int milliseconds, EQEmu::ItemInstance *inst) {
if (inst) {
inst->SetTimer(timer_name, milliseconds);
}
@@ -493,7 +493,7 @@ void QuestManager::stoptimer(const char *timer_name) {
}
}
void QuestManager::stoptimer(const char *timer_name, ItemInst *inst) {
void QuestManager::stoptimer(const char *timer_name, EQEmu::ItemInstance *inst) {
if (inst) {
inst->StopTimer(timer_name);
}
@@ -531,7 +531,7 @@ void QuestManager::stopalltimers() {
}
}
void QuestManager::stopalltimers(ItemInst *inst) {
void QuestManager::stopalltimers(EQEmu::ItemInstance *inst) {
if (inst) {
inst->ClearTimers();
}
@@ -814,7 +814,7 @@ void QuestManager::traindisc(int discipline_tome_item_id) {
}
bool QuestManager::isdisctome(int item_id) {
const EQEmu::ItemBase *item = database.GetItem(item_id);
const EQEmu::ItemData *item = database.GetItem(item_id);
if(item == nullptr) {
return(false);
}
@@ -1305,7 +1305,7 @@ void QuestManager::settime(uint8 new_hour, uint8 new_min, bool update_world /*=
void QuestManager::itemlink(int item_id) {
QuestManagerCurrentQuestVars();
if (initiator) {
const EQEmu::ItemBase* item = database.GetItem(item_id);
const EQEmu::ItemData* item = database.GetItem(item_id);
if (item == nullptr)
return;
@@ -2408,7 +2408,7 @@ int QuestManager::collectitems_processSlot(int16 slot_id, uint32 item_id,
bool remove)
{
QuestManagerCurrentQuestVars();
ItemInst *item = nullptr;
EQEmu::ItemInstance *item = nullptr;
int quantity = 0;
item = initiator->GetInv().GetItem(slot_id);
@@ -2497,7 +2497,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::ItemBase* item = nullptr;
const EQEmu::ItemData* item = nullptr;
item = database.GetItem(itemid);
if (!item) return; // if the item id doesn't correspond to a real item, do nothing
@@ -2510,7 +2510,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::ItemBase* item = nullptr;
const EQEmu::ItemData* item = nullptr;
item = database.GetItem(itemid);
if (!item)
return 0; // if it isn't a valid item, the merchant doesn't have any
@@ -2533,7 +2533,7 @@ 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::ItemBase* item = database.GetItem(item_id);
const EQEmu::ItemData* item = database.GetItem(item_id);
if (!item)
return "INVALID ITEM ID IN VARLINK";
@@ -3087,7 +3087,7 @@ Mob *QuestManager::GetOwner() const {
return nullptr;
}
ItemInst *QuestManager::GetQuestItem() const {
EQEmu::ItemInstance *QuestManager::GetQuestItem() const {
if(!quests_running_.empty()) {
running_quest e = quests_running_.top();
return e.questitem;
zone/questmgr.h
+12 -8
View File
@@ -25,15 +25,19 @@
#include <stack>
class Client;
class ItemInst;
class Mob;
class NPC;
namespace EQEmu
{
class ItemInstance;
}
class QuestManager {
struct running_quest {
Mob *owner;
Client *initiator;
ItemInst* questitem;
EQEmu::ItemInstance* questitem;
bool depop_npc;
std::string encounter;
};
@@ -41,7 +45,7 @@ public:
QuestManager();
virtual ~QuestManager();
void StartQuest(Mob *_owner, Client *_initiator = nullptr, ItemInst* _questitem = nullptr, std::string encounter = "");
void StartQuest(Mob *_owner, Client *_initiator = nullptr, EQEmu::ItemInstance* _questitem = nullptr, std::string encounter = "");
void EndQuest();
bool QuestsRunning() { return !quests_running_.empty(); }
@@ -66,17 +70,17 @@ public:
void incstat(int stat, int value);
void castspell(int spell_id, int target_id);
void selfcast(int spell_id);
void addloot(int item_id, int charges = 0, bool equipitem = true);
void addloot(int item_id, int charges = 0, bool equipitem = true, int aug1 = 0, int aug2 = 0, int aug3 = 0, int aug4 = 0, int aug5 = 0, int aug6 = 0);
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, ItemInst *inst);
void settimerMS(const char *timer_name, int milliseconds, EQEmu::ItemInstance *inst);
void settimerMS(const char *timer_name, int milliseconds, Mob *mob);
void stoptimer(const char *timer_name);
void stoptimer(const char *timer_name, ItemInst *inst);
void stoptimer(const char *timer_name, EQEmu::ItemInstance *inst);
void stoptimer(const char *timer_name, Mob *mob);
void stopalltimers();
void stopalltimers(ItemInst *inst);
void stopalltimers(EQEmu::ItemInstance *inst);
void stopalltimers(Mob *mob);
void emote(const char *str);
void shout(const char *str);
@@ -261,7 +265,7 @@ public:
Client *GetInitiator() const;
NPC *GetNPC() const;
Mob *GetOwner() const;
ItemInst *GetQuestItem() const;
EQEmu::ItemInstance *GetQuestItem() const;
std::string GetEncounter() const;
inline bool ProximitySayInUse() { return HaveProximitySays; }
zone/special_attacks.cpp
+110 -116
View File
@@ -68,22 +68,22 @@ void Mob::ApplySpecialAttackMod(EQEmu::skills::SkillType skill, int32 &dmg, int3
case EQEmu::skills::SkillFlyingKick:
case EQEmu::skills::SkillRoundKick:
case EQEmu::skills::SkillKick:
item_slot = EQEmu::legacy::SlotFeet;
item_slot = EQEmu::inventory::slotFeet;
break;
case EQEmu::skills::SkillBash:
item_slot = EQEmu::legacy::SlotSecondary;
item_slot = EQEmu::inventory::slotSecondary;
break;
case EQEmu::skills::SkillDragonPunch:
case EQEmu::skills::SkillEagleStrike:
case EQEmu::skills::SkillTigerClaw:
item_slot = EQEmu::legacy::SlotHands;
item_slot = EQEmu::inventory::slotHands;
break;
default:
break;
}
if (item_slot >= 0){
const ItemInst* itm = nullptr;
const EQEmu::ItemInstance* itm = nullptr;
itm = CastToClient()->GetInv().GetItem(item_slot);
if(itm)
dmg += itm->GetItem()->AC * (RuleI(Combat, SpecialAttackACBonus))/100;
@@ -111,14 +111,14 @@ void Mob::DoSpecialAttackDamage(Mob *who, EQEmu::skills::SkillType skill, int32
if (skill == EQEmu::skills::SkillBash){
if(IsClient()){
ItemInst *item = CastToClient()->GetInv().GetItem(EQEmu::legacy::SlotSecondary);
EQEmu::ItemInstance *item = CastToClient()->GetInv().GetItem(EQEmu::inventory::slotSecondary);
if(item)
{
if (item->GetItem()->ItemType == EQEmu::item::ItemTypeShield)
{
hate += item->GetItem()->AC;
}
const EQEmu::ItemBase *itm = item->GetItem();
const EQEmu::ItemData *itm = item->GetItem();
auto fbash = GetFuriousBash(itm->Focus.Effect);
hate = hate * (100 + fbash) / 100;
if (fbash)
@@ -129,14 +129,14 @@ void Mob::DoSpecialAttackDamage(Mob *who, EQEmu::skills::SkillType skill, int32
min_damage += min_damage * GetMeleeMinDamageMod_SE(skill) / 100;
int hand = EQEmu::legacy::SlotPrimary; // Avoid checks hand for throwing/archery exclusion, primary should work for most
int hand = EQEmu::inventory::slotPrimary; // Avoid checks hand for throwing/archery exclusion, primary should work for most
if (skill == EQEmu::skills::SkillThrowing || skill == EQEmu::skills::SkillArchery)
hand = EQEmu::legacy::SlotRange;
hand = EQEmu::inventory::slotRange;
if (who->AvoidDamage(this, max_damage, hand)) {
if (max_damage == -3)
DoRiposte(who);
} else {
if (!CheckHitChance || (CheckHitChance && who->CheckHitChance(this, skill, EQEmu::legacy::SlotPrimary))) {
if (!CheckHitChance || (CheckHitChance && who->CheckHitChance(this, skill, EQEmu::inventory::slotPrimary))) {
who->MeleeMitigation(this, max_damage, min_damage);
CommonOutgoingHitSuccess(who, max_damage, skill);
} else {
@@ -194,7 +194,7 @@ void Client::OPCombatAbility(const EQApplicationPacket *app) {
//These two are not subject to the combat ability timer, as they
//allready do their checking in conjunction with the attack timer
//throwing weapons
if (ca_atk->m_atk == EQEmu::legacy::SlotRange) {
if (ca_atk->m_atk == EQEmu::inventory::slotRange) {
if (ca_atk->m_skill == EQEmu::skills::SkillThrowing) {
SetAttackTimer();
ThrowingAttack(GetTarget());
@@ -244,8 +244,8 @@ void Client::OPCombatAbility(const EQApplicationPacket *app) {
DoAnim(animTailRake);
int32 ht = 0;
if (GetWeaponDamage(GetTarget(), GetInv().GetItem(EQEmu::legacy::SlotSecondary)) <= 0 &&
GetWeaponDamage(GetTarget(), GetInv().GetItem(EQEmu::legacy::SlotShoulders)) <= 0){
if (GetWeaponDamage(GetTarget(), GetInv().GetItem(EQEmu::inventory::slotSecondary)) <= 0 &&
GetWeaponDamage(GetTarget(), GetInv().GetItem(EQEmu::inventory::slotShoulders)) <= 0){
dmg = -5;
}
else{
@@ -321,7 +321,7 @@ void Client::OPCombatAbility(const EQApplicationPacket *app) {
DoAnim(animKick);
int32 ht = 0;
if (GetWeaponDamage(GetTarget(), GetInv().GetItem(EQEmu::legacy::SlotFeet)) <= 0){
if (GetWeaponDamage(GetTarget(), GetInv().GetItem(EQEmu::inventory::slotFeet)) <= 0){
dmg = -5;
}
else{
@@ -349,7 +349,7 @@ void Client::OPCombatAbility(const EQApplicationPacket *app) {
int wuchance = itembonuses.DoubleSpecialAttack + spellbonuses.DoubleSpecialAttack + aabonuses.DoubleSpecialAttack;
if (wuchance) {
if (wuchance >= 100 || zone->random.Roll(wuchance)) {
int MonkSPA[5] = { EQEmu::skills::SkillFlyingKick, EQEmu::skills::SkillDragonPunch, EQEmu::skills::SkillEagleStrike, EQEmu::skills::SkillTigerClaw, EQEmu::skills::SkillRoundKick };
const int MonkSPA[5] = { EQEmu::skills::SkillFlyingKick, EQEmu::skills::SkillDragonPunch, EQEmu::skills::SkillEagleStrike, EQEmu::skills::SkillTigerClaw, EQEmu::skills::SkillRoundKick };
int extra = 1;
// always 1/4 of the double attack chance, 25% at rank 5 (100/4)
if (zone->random.Roll(wuchance / 4))
@@ -358,8 +358,9 @@ void Client::OPCombatAbility(const EQApplicationPacket *app) {
std::string msg = StringFormat("The spirit of Master Wu fills you! You gain %d additional attack(s).", extra);
// live uses 400 here -- not sure if it's the best for all clients though
SendColoredText(400, msg);
auto classic = RuleB(Combat, ClassicMasterWu);
while (extra) {
MonkSpecialAttack(GetTarget(), MonkSPA[zone->random.Int(0, 4)]);
MonkSpecialAttack(GetTarget(), classic ? MonkSPA[zone->random.Int(0, 4)] : ca_atk->m_skill);
extra--;
}
}
@@ -404,7 +405,7 @@ int Mob::MonkSpecialAttack(Mob* other, uint8 unchecked_type)
int32 min_dmg = 1;
int reuse = 0;
EQEmu::skills::SkillType skill_type; //to avoid casting... even though it "would work"
uint8 itemslot = EQEmu::legacy::SlotFeet;
uint8 itemslot = EQEmu::inventory::slotFeet;
switch(unchecked_type) {
case EQEmu::skills::SkillFlyingKick:
@@ -418,7 +419,7 @@ int Mob::MonkSpecialAttack(Mob* other, uint8 unchecked_type)
case EQEmu::skills::SkillDragonPunch:
skill_type = EQEmu::skills::SkillDragonPunch;
max_dmg = ((GetSTR()+GetSkill(skill_type)) * RuleI(Combat, DragonPunchBonus) / 100) + 26;
itemslot = EQEmu::legacy::SlotHands;
itemslot = EQEmu::inventory::slotHands;
ApplySpecialAttackMod(skill_type, max_dmg, min_dmg);
DoAnim(animTailRake);
reuse = TailRakeReuseTime;
@@ -426,7 +427,7 @@ int Mob::MonkSpecialAttack(Mob* other, uint8 unchecked_type)
case EQEmu::skills::SkillEagleStrike:
skill_type = EQEmu::skills::SkillEagleStrike;
max_dmg = ((GetSTR()+GetSkill(skill_type)) * RuleI(Combat, EagleStrikeBonus) / 100) + 19;
itemslot = EQEmu::legacy::SlotHands;
itemslot = EQEmu::inventory::slotHands;
ApplySpecialAttackMod(skill_type, max_dmg, min_dmg);
DoAnim(animEagleStrike);
reuse = EagleStrikeReuseTime;
@@ -434,7 +435,7 @@ int Mob::MonkSpecialAttack(Mob* other, uint8 unchecked_type)
case EQEmu::skills::SkillTigerClaw:
skill_type = EQEmu::skills::SkillTigerClaw;
max_dmg = ((GetSTR()+GetSkill(skill_type)) * RuleI(Combat, TigerClawBonus) / 100) + 12;
itemslot = EQEmu::legacy::SlotHands;
itemslot = EQEmu::inventory::slotHands;
ApplySpecialAttackMod(skill_type, max_dmg, min_dmg);
DoAnim(animTigerClaw);
reuse = TigerClawReuseTime;
@@ -463,7 +464,7 @@ int Mob::MonkSpecialAttack(Mob* other, uint8 unchecked_type)
}
}
else{
if (GetWeaponDamage(other, (const EQEmu::ItemBase*)nullptr) <= 0){
if (GetWeaponDamage(other, (const EQEmu::ItemData*)nullptr) <= 0){
ndamage = -5;
}
}
@@ -498,7 +499,7 @@ void Mob::TryBackstab(Mob *other, int ReuseTime) {
//make sure we have a proper weapon if we are a client.
if(IsClient()) {
const ItemInst *wpn = CastToClient()->GetInv().GetItem(EQEmu::legacy::SlotPrimary);
const EQEmu::ItemInstance *wpn = CastToClient()->GetInv().GetItem(EQEmu::inventory::slotPrimary);
if (!wpn || (wpn->GetItem()->ItemType != EQEmu::item::ItemType1HPiercing)){
Message_StringID(13, BACKSTAB_WEAPON);
return;
@@ -559,7 +560,7 @@ void Mob::TryBackstab(Mob *other, int ReuseTime) {
CastToClient()->CheckIncreaseSkill(EQEmu::skills::SkillBackstab, other, 10);
}
else { //We do a single regular attack if we attack from the front without chaotic stab
Attack(other, EQEmu::legacy::SlotPrimary);
Attack(other, EQEmu::inventory::slotPrimary);
}
}
@@ -576,33 +577,30 @@ void Mob::RogueBackstab(Mob* other, bool min_damage, int ReuseTime)
int32 primaryweapondamage = 0;
int32 backstab_dmg = 0;
if(IsClient()){
const ItemInst *wpn = nullptr;
wpn = CastToClient()->GetInv().GetItem(EQEmu::legacy::SlotPrimary);
if(wpn) {
if (IsClient()) {
const EQEmu::ItemInstance *wpn = CastToClient()->GetInv().GetItem(EQEmu::inventory::slotPrimary);
if (wpn) {
primaryweapondamage = GetWeaponDamage(other, wpn);
backstab_dmg = wpn->GetItem()->BackstabDmg;
for (int i = 0; i < EQEmu::legacy::ITEM_COMMON_SIZE; ++i)
{
ItemInst *aug = wpn->GetAugment(i);
if(aug)
{
backstab_dmg += aug->GetItem()->BackstabDmg;
}
if (primaryweapondamage) {
backstab_dmg = wpn->GetItemBackstabDamage(true);
backstab_dmg += other->ResistElementalWeaponDmg(wpn);
if (wpn->GetItemBaneDamageBody(true) || wpn->GetItemBaneDamageRace(true))
backstab_dmg += other->CheckBaneDamage(wpn);
}
}
}
else{
primaryweapondamage = (GetLevel()/7)+1; // fallback incase it's a npc without a weapon, 2 dmg at 10, 10 dmg at 65
} else {
primaryweapondamage =
(GetLevel() / 7) + 1; // fallback incase it's a npc without a weapon, 2 dmg at 10, 10 dmg at 65
backstab_dmg = primaryweapondamage;
}
if(primaryweapondamage > 0){
if(level > 25){
// ex. bane can make this false
if (primaryweapondamage > 0) {
// this is very wrong but not worth it until we fix the full dmg
if (level > 25) {
max_hit = (((((2 * backstab_dmg) * GetDamageTable(EQEmu::skills::SkillBackstab) / 100) * 10 * GetSkill(EQEmu::skills::SkillBackstab) / 355) + ((level - 25) / 3) + 1) * ((100 + RuleI(Combat, BackstabBonus)) / 100));
hate = 20 * backstab_dmg * GetSkill(EQEmu::skills::SkillBackstab) / 355;
}
else{
} else {
max_hit = (((((2 * backstab_dmg) * GetDamageTable(EQEmu::skills::SkillBackstab) / 100) * 10 * GetSkill(EQEmu::skills::SkillBackstab) / 355) + 1) * ((100 + RuleI(Combat, BackstabBonus)) / 100));
hate = 20 * backstab_dmg * GetSkill(EQEmu::skills::SkillBackstab) / 355;
}
@@ -610,31 +608,27 @@ void Mob::RogueBackstab(Mob* other, bool min_damage, int ReuseTime)
// determine minimum hits
if (level < 51) {
min_hit = (level*15/10);
}
else {
} else {
// Trumpcard: Replaced switch statement with formula calc. This will give minhit increases all the way to 65.
min_hit = (level * ( level*5 - 105)) / 100;
}
if (!other->CheckHitChance(this, EQEmu::skills::SkillBackstab, 0)) {
if (!other->CheckHitChance(this, EQEmu::skills::SkillBackstab, 0)) {
ndamage = 0;
}
else{
if(min_damage){
} else {
if (min_damage) {
ndamage = min_hit;
}
else {
} else {
if (max_hit < min_hit)
max_hit = min_hit;
if(RuleB(Combat, UseIntervalAC))
if (RuleB(Combat, UseIntervalAC))
ndamage = max_hit;
else
ndamage = zone->random.Int(min_hit, max_hit);
}
}
}
else{
} else {
ndamage = -5;
}
@@ -657,7 +651,7 @@ void Mob::RogueAssassinate(Mob* other)
{
//can you dodge, parry, etc.. an assassinate??
//if so, use DoSpecialAttackDamage(other, BACKSTAB, 32000); instead
if (GetWeaponDamage(other, IsClient() ? CastToClient()->GetInv().GetItem(EQEmu::legacy::SlotPrimary) : (const ItemInst*)nullptr) > 0){
if (GetWeaponDamage(other, IsClient() ? CastToClient()->GetInv().GetItem(EQEmu::inventory::slotPrimary) : (const EQEmu::ItemInstance*)nullptr) > 0){
other->Damage(this, 32000, SPELL_UNKNOWN, EQEmu::skills::SkillBackstab);
}else{
other->Damage(this, -5, SPELL_UNKNOWN, EQEmu::skills::SkillBackstab);
@@ -677,25 +671,25 @@ void Client::RangedAttack(Mob* other, bool CanDoubleAttack) {
//Message(0, "Error: Timer not up. Attack %d, ranged %d", attack_timer.GetRemainingTime(), ranged_timer.GetRemainingTime());
return;
}
const ItemInst* RangeWeapon = m_inv[EQEmu::legacy::SlotRange];
const EQEmu::ItemInstance* RangeWeapon = m_inv[EQEmu::inventory::slotRange];
//locate ammo
int ammo_slot = EQEmu::legacy::SlotAmmo;
const ItemInst* Ammo = m_inv[EQEmu::legacy::SlotAmmo];
int ammo_slot = EQEmu::inventory::slotAmmo;
const EQEmu::ItemInstance* Ammo = m_inv[EQEmu::inventory::slotAmmo];
if (!RangeWeapon || !RangeWeapon->IsClassCommon()) {
Log.Out(Logs::Detail, Logs::Combat, "Ranged attack canceled. Missing or invalid ranged weapon (%d) in slot %d", GetItemIDAt(EQEmu::legacy::SlotRange), EQEmu::legacy::SlotRange);
Message(0, "Error: Rangeweapon: GetItem(%i)==0, you have no bow!", GetItemIDAt(EQEmu::legacy::SlotRange));
Log.Out(Logs::Detail, Logs::Combat, "Ranged attack canceled. Missing or invalid ranged weapon (%d) in slot %d", GetItemIDAt(EQEmu::inventory::slotRange), EQEmu::inventory::slotRange);
Message(0, "Error: Rangeweapon: GetItem(%i)==0, you have no bow!", GetItemIDAt(EQEmu::inventory::slotRange));
return;
}
if (!Ammo || !Ammo->IsClassCommon()) {
Log.Out(Logs::Detail, Logs::Combat, "Ranged attack canceled. Missing or invalid ammo item (%d) in slot %d", GetItemIDAt(EQEmu::legacy::SlotAmmo), EQEmu::legacy::SlotAmmo);
Message(0, "Error: Ammo: GetItem(%i)==0, you have no ammo!", GetItemIDAt(EQEmu::legacy::SlotAmmo));
Log.Out(Logs::Detail, Logs::Combat, "Ranged attack canceled. Missing or invalid ammo item (%d) in slot %d", GetItemIDAt(EQEmu::inventory::slotAmmo), EQEmu::inventory::slotAmmo);
Message(0, "Error: Ammo: GetItem(%i)==0, you have no ammo!", GetItemIDAt(EQEmu::inventory::slotAmmo));
return;
}
const EQEmu::ItemBase* RangeItem = RangeWeapon->GetItem();
const EQEmu::ItemBase* AmmoItem = Ammo->GetItem();
const EQEmu::ItemData* RangeItem = RangeWeapon->GetItem();
const EQEmu::ItemData* AmmoItem = Ammo->GetItem();
if (RangeItem->ItemType != EQEmu::item::ItemTypeBow) {
Log.Out(Logs::Detail, Logs::Combat, "Ranged attack canceled. Ranged item is not a bow. type %d.", RangeItem->ItemType);
@@ -716,17 +710,17 @@ void Client::RangedAttack(Mob* other, bool CanDoubleAttack) {
int r;
bool found = false;
for (r = EQEmu::legacy::GENERAL_BEGIN; r <= EQEmu::legacy::GENERAL_END; r++) {
const ItemInst *pi = m_inv[r];
const EQEmu::ItemInstance *pi = m_inv[r];
if (pi == nullptr || !pi->IsClassBag())
continue;
const EQEmu::ItemBase* bagitem = pi->GetItem();
const EQEmu::ItemData* bagitem = pi->GetItem();
if (!bagitem || bagitem->BagType != EQEmu::item::BagTypeQuiver)
continue;
//we found a quiver, look for the ammo in it
int i;
for (i = 0; i < bagitem->BagSlots; i++) {
ItemInst* baginst = pi->GetItem(i);
EQEmu::ItemInstance* baginst = pi->GetItem(i);
if(!baginst)
continue; //empty
if(baginst->GetID() == Ammo->GetID()) {
@@ -797,8 +791,8 @@ void Client::RangedAttack(Mob* other, bool CanDoubleAttack) {
CommonBreakInvisibleFromCombat();
}
void Mob::DoArcheryAttackDmg(Mob* other, const ItemInst* RangeWeapon, const ItemInst* Ammo, uint16 weapon_damage, int16 chance_mod, int16 focus, int ReuseTime,
uint32 range_id, uint32 ammo_id, const EQEmu::ItemBase *AmmoItem, int AmmoSlot, float speed) {
void Mob::DoArcheryAttackDmg(Mob* other, const EQEmu::ItemInstance* RangeWeapon, const EQEmu::ItemInstance* Ammo, uint16 weapon_damage, int16 chance_mod, int16 focus, int ReuseTime,
uint32 range_id, uint32 ammo_id, const EQEmu::ItemData *AmmoItem, int AmmoSlot, float speed) {
if ((other == nullptr ||
((IsClient() && CastToClient()->dead) ||
@@ -811,9 +805,9 @@ void Mob::DoArcheryAttackDmg(Mob* other, const ItemInst* RangeWeapon, const Ite
return;
}
const ItemInst* _RangeWeapon = nullptr;
const ItemInst* _Ammo = nullptr;
const EQEmu::ItemBase* ammo_lost = nullptr;
const EQEmu::ItemInstance* _RangeWeapon = nullptr;
const EQEmu::ItemInstance* _Ammo = nullptr;
const EQEmu::ItemData* ammo_lost = nullptr;
/*
If LaunchProjectile is false this function will do archery damage on target,
@@ -845,7 +839,7 @@ void Mob::DoArcheryAttackDmg(Mob* other, const ItemInst* RangeWeapon, const Ite
if (IsClient()){
_RangeWeapon = CastToClient()->m_inv[EQEmu::legacy::SlotRange];
_RangeWeapon = CastToClient()->m_inv[EQEmu::inventory::slotRange];
if (_RangeWeapon && _RangeWeapon->GetItem() && _RangeWeapon->GetItem()->ID == range_id)
RangeWeapon = _RangeWeapon;
@@ -861,7 +855,7 @@ void Mob::DoArcheryAttackDmg(Mob* other, const ItemInst* RangeWeapon, const Ite
else if (AmmoItem)
SendItemAnimation(other, AmmoItem, EQEmu::skills::SkillArchery);
if (ProjectileMiss || (!ProjectileImpact && !other->CheckHitChance(this, EQEmu::skills::SkillArchery, EQEmu::legacy::SlotPrimary, chance_mod))) {
if (ProjectileMiss || (!ProjectileImpact && !other->CheckHitChance(this, EQEmu::skills::SkillArchery, EQEmu::inventory::slotPrimary, chance_mod))) {
Log.Out(Logs::Detail, Logs::Combat, "Ranged attack missed %s.", other->GetName());
if (LaunchProjectile){
@@ -959,7 +953,7 @@ void Mob::DoArcheryAttackDmg(Mob* other, const ItemInst* RangeWeapon, const Ite
}
if (!HeadShot)
other->AvoidDamage(this, TotalDmg, EQEmu::legacy::SlotRange);
other->AvoidDamage(this, TotalDmg, EQEmu::inventory::slotRange);
other->MeleeMitigation(this, TotalDmg, minDmg);
if(TotalDmg > 0){
@@ -983,7 +977,7 @@ void Mob::DoArcheryAttackDmg(Mob* other, const ItemInst* RangeWeapon, const Ite
if (ReuseTime)
TrySkillProc(other, EQEmu::skills::SkillArchery, ReuseTime);
else
TrySkillProc(other, EQEmu::skills::SkillArchery, 0, true, EQEmu::legacy::SlotRange);
TrySkillProc(other, EQEmu::skills::SkillArchery, 0, true, EQEmu::inventory::slotRange);
}
}
@@ -992,24 +986,24 @@ void Mob::DoArcheryAttackDmg(Mob* other, const ItemInst* RangeWeapon, const Ite
//Weapon Proc
if(RangeWeapon && other && !other->HasDied())
TryWeaponProc(RangeWeapon, other, EQEmu::legacy::SlotRange);
TryWeaponProc(RangeWeapon, other, EQEmu::inventory::slotRange);
//Ammo Proc
if (ammo_lost)
TryWeaponProc(nullptr, ammo_lost, other, EQEmu::legacy::SlotRange);
TryWeaponProc(nullptr, ammo_lost, other, EQEmu::inventory::slotRange);
else if(Ammo && other && !other->HasDied())
TryWeaponProc(Ammo, other, EQEmu::legacy::SlotRange);
TryWeaponProc(Ammo, other, EQEmu::inventory::slotRange);
//Skill Proc
if (HasSkillProcs() && other && !other->HasDied()){
if (ReuseTime)
TrySkillProc(other, EQEmu::skills::SkillArchery, ReuseTime);
else
TrySkillProc(other, EQEmu::skills::SkillArchery, 0, false, EQEmu::legacy::SlotRange);
TrySkillProc(other, EQEmu::skills::SkillArchery, 0, false, EQEmu::inventory::slotRange);
}
}
bool Mob::TryProjectileAttack(Mob* other, const EQEmu::ItemBase *item, EQEmu::skills::SkillType skillInUse, uint16 weapon_dmg, const ItemInst* RangeWeapon, const ItemInst* Ammo, int AmmoSlot, float speed){
bool Mob::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){
if (!other)
return false;
@@ -1271,7 +1265,7 @@ void NPC::DoRangedAttackDmg(Mob* other, bool Launch, int16 damage_mod, int16 cha
if (!chance_mod)
chance_mod = GetSpecialAbilityParam(SPECATK_RANGED_ATK, 2);
if (!other->CheckHitChance(this, skillInUse, EQEmu::legacy::SlotRange, chance_mod))
if (!other->CheckHitChance(this, skillInUse, EQEmu::inventory::slotRange, chance_mod))
{
other->Damage(this, 0, SPELL_UNKNOWN, skillInUse);
}
@@ -1292,7 +1286,7 @@ void NPC::DoRangedAttackDmg(Mob* other, bool Launch, int16 damage_mod, int16 cha
TotalDmg += TotalDmg * damage_mod / 100;
other->AvoidDamage(this, TotalDmg, EQEmu::legacy::SlotRange);
other->AvoidDamage(this, TotalDmg, EQEmu::inventory::slotRange);
other->MeleeMitigation(this, TotalDmg, MinDmg);
if (TotalDmg > 0)
@@ -1308,15 +1302,15 @@ void NPC::DoRangedAttackDmg(Mob* other, bool Launch, int16 damage_mod, int16 cha
other->Damage(this, TotalDmg, SPELL_UNKNOWN, skillInUse);
if (TotalDmg > 0 && HasSkillProcSuccess() && !other->HasDied())
TrySkillProc(other, skillInUse, 0, true, EQEmu::legacy::SlotRange);
TrySkillProc(other, skillInUse, 0, true, EQEmu::inventory::slotRange);
}
//try proc on hits and misses
if(other && !other->HasDied())
TrySpellProc(nullptr, (const EQEmu::ItemBase*)nullptr, other, EQEmu::legacy::SlotRange);
TrySpellProc(nullptr, (const EQEmu::ItemData*)nullptr, other, EQEmu::inventory::slotRange);
if (HasSkillProcs() && other && !other->HasDied())
TrySkillProc(other, skillInUse, 0, false, EQEmu::legacy::SlotRange);
TrySkillProc(other, skillInUse, 0, false, EQEmu::inventory::slotRange);
}
uint16 Mob::GetThrownDamage(int16 wDmg, int32& TotalDmg, int& minDmg) {
@@ -1358,19 +1352,19 @@ void Client::ThrowingAttack(Mob* other, bool CanDoubleAttack) { //old was 51
return;
}
int ammo_slot = EQEmu::legacy::SlotRange;
const ItemInst* RangeWeapon = m_inv[EQEmu::legacy::SlotRange];
int ammo_slot = EQEmu::inventory::slotRange;
const EQEmu::ItemInstance* RangeWeapon = m_inv[EQEmu::inventory::slotRange];
if (!RangeWeapon || !RangeWeapon->IsClassCommon()) {
Log.Out(Logs::Detail, Logs::Combat, "Ranged attack canceled. Missing or invalid ranged weapon (%d) in slot %d", GetItemIDAt(EQEmu::legacy::SlotRange), EQEmu::legacy::SlotRange);
Message(0, "Error: Rangeweapon: GetItem(%i)==0, you have nothing to throw!", GetItemIDAt(EQEmu::legacy::SlotRange));
Log.Out(Logs::Detail, Logs::Combat, "Ranged attack canceled. Missing or invalid ranged weapon (%d) in slot %d", GetItemIDAt(EQEmu::inventory::slotRange), EQEmu::inventory::slotRange);
Message(0, "Error: Rangeweapon: GetItem(%i)==0, you have nothing to throw!", GetItemIDAt(EQEmu::inventory::slotRange));
return;
}
const EQEmu::ItemBase* item = RangeWeapon->GetItem();
const EQEmu::ItemData* item = RangeWeapon->GetItem();
if (item->ItemType != EQEmu::item::ItemTypeLargeThrowing && item->ItemType != EQEmu::item::ItemTypeSmallThrowing) {
Log.Out(Logs::Detail, Logs::Combat, "Ranged attack canceled. Ranged item %d is not a throwing weapon. type %d.", item->ItemType);
Message(0, "Error: Rangeweapon: GetItem(%i)==0, you have nothing useful to throw!", GetItemIDAt(EQEmu::legacy::SlotRange));
Message(0, "Error: Rangeweapon: GetItem(%i)==0, you have nothing useful to throw!", GetItemIDAt(EQEmu::inventory::slotRange));
return;
}
@@ -1378,11 +1372,11 @@ void Client::ThrowingAttack(Mob* other, bool CanDoubleAttack) { //old was 51
if(RangeWeapon->GetCharges() == 1) {
//first check ammo
const ItemInst* AmmoItem = m_inv[EQEmu::legacy::SlotAmmo];
const EQEmu::ItemInstance* AmmoItem = m_inv[EQEmu::inventory::slotAmmo];
if(AmmoItem != nullptr && AmmoItem->GetID() == RangeWeapon->GetID()) {
//more in the ammo slot, use it
RangeWeapon = AmmoItem;
ammo_slot = EQEmu::legacy::SlotAmmo;
ammo_slot = EQEmu::inventory::slotAmmo;
Log.Out(Logs::Detail, Logs::Combat, "Using ammo from ammo slot, stack at slot %d. %d in stack.", ammo_slot, RangeWeapon->GetCharges());
} else {
//look through our inventory for more
@@ -1428,7 +1422,7 @@ void Client::ThrowingAttack(Mob* other, bool CanDoubleAttack) { //old was 51
CommonBreakInvisibleFromCombat();
}
void Mob::DoThrowingAttackDmg(Mob* other, const ItemInst* RangeWeapon, const EQEmu::ItemBase* AmmoItem, uint16 weapon_damage, int16 chance_mod, int16 focus, int ReuseTime, uint32 range_id, int AmmoSlot, float speed)
void Mob::DoThrowingAttackDmg(Mob* other, const EQEmu::ItemInstance* RangeWeapon, const EQEmu::ItemData* AmmoItem, uint16 weapon_damage, int16 chance_mod, int16 focus, int ReuseTime, uint32 range_id, int AmmoSlot, float speed)
{
if ((other == nullptr ||
((IsClient() && CastToClient()->dead) ||
@@ -1441,8 +1435,8 @@ void Mob::DoThrowingAttackDmg(Mob* other, const ItemInst* RangeWeapon, const EQE
return;
}
const ItemInst* _RangeWeapon = nullptr;
const EQEmu::ItemBase* ammo_lost = nullptr;
const EQEmu::ItemInstance* _RangeWeapon = nullptr;
const EQEmu::ItemData* ammo_lost = nullptr;
/*
If LaunchProjectile is false this function will do archery damage on target,
@@ -1479,7 +1473,7 @@ void Mob::DoThrowingAttackDmg(Mob* other, const ItemInst* RangeWeapon, const EQE
else if (AmmoItem)
SendItemAnimation(other, AmmoItem, EQEmu::skills::SkillThrowing);
if (ProjectileMiss || (!ProjectileImpact && !other->CheckHitChance(this, EQEmu::skills::SkillThrowing, EQEmu::legacy::SlotPrimary, chance_mod))){
if (ProjectileMiss || (!ProjectileImpact && !other->CheckHitChance(this, EQEmu::skills::SkillThrowing, EQEmu::inventory::slotPrimary, chance_mod))){
Log.Out(Logs::Detail, Logs::Combat, "Ranged attack missed %s.", other->GetName());
if (LaunchProjectile){
TryProjectileAttack(other, AmmoItem, EQEmu::skills::SkillThrowing, 0, RangeWeapon, nullptr, AmmoSlot, speed);
@@ -1526,7 +1520,7 @@ void Mob::DoThrowingAttackDmg(Mob* other, const ItemInst* RangeWeapon, const EQE
Log.Out(Logs::Detail, Logs::Combat, "Item DMG %d. Max Damage %d. Hit for damage %d", WDmg, MaxDmg, TotalDmg);
if (!Assassinate_Dmg)
other->AvoidDamage(this, TotalDmg, EQEmu::legacy::SlotRange);
other->AvoidDamage(this, TotalDmg, EQEmu::inventory::slotRange);
other->MeleeMitigation(this, TotalDmg, minDmg);
if(TotalDmg > 0)
@@ -1545,7 +1539,7 @@ void Mob::DoThrowingAttackDmg(Mob* other, const ItemInst* RangeWeapon, const EQE
if (ReuseTime)
TrySkillProc(other, EQEmu::skills::SkillThrowing, ReuseTime);
else
TrySkillProc(other, EQEmu::skills::SkillThrowing, 0, true, EQEmu::legacy::SlotRange);
TrySkillProc(other, EQEmu::skills::SkillThrowing, 0, true, EQEmu::inventory::slotRange);
}
}
@@ -1554,19 +1548,19 @@ void Mob::DoThrowingAttackDmg(Mob* other, const ItemInst* RangeWeapon, const EQE
//Throwing item Proc
if (ammo_lost)
TryWeaponProc(nullptr, ammo_lost, other, EQEmu::legacy::SlotRange);
TryWeaponProc(nullptr, ammo_lost, other, EQEmu::inventory::slotRange);
else if(RangeWeapon && other && !other->HasDied())
TryWeaponProc(RangeWeapon, other, EQEmu::legacy::SlotRange);
TryWeaponProc(RangeWeapon, other, EQEmu::inventory::slotRange);
if (HasSkillProcs() && other && !other->HasDied()){
if (ReuseTime)
TrySkillProc(other, EQEmu::skills::SkillThrowing, ReuseTime);
else
TrySkillProc(other, EQEmu::skills::SkillThrowing, 0, false, EQEmu::legacy::SlotRange);
TrySkillProc(other, EQEmu::skills::SkillThrowing, 0, false, EQEmu::inventory::slotRange);
}
}
void Mob::SendItemAnimation(Mob *to, const EQEmu::ItemBase *item, EQEmu::skills::SkillType skillInUse, float velocity) {
void Mob::SendItemAnimation(Mob *to, const EQEmu::ItemData *item, EQEmu::skills::SkillType skillInUse, float velocity) {
auto outapp = new EQApplicationPacket(OP_SomeItemPacketMaybe, sizeof(Arrow_Struct));
Arrow_Struct *as = (Arrow_Struct *) outapp->pBuffer;
as->type = 1;
@@ -1616,7 +1610,7 @@ void Mob::ProjectileAnimation(Mob* to, int item_id, bool IsArrow, float speed, f
if (!to)
return;
const EQEmu::ItemBase* item = nullptr;
const EQEmu::ItemData* item = nullptr;
uint8 item_type = 0;
if(!item_id) {
@@ -1757,7 +1751,7 @@ void NPC::DoClassAttacks(Mob *target) {
DoAnim(animKick);
int32 dmg = 0;
if (GetWeaponDamage(target, (const EQEmu::ItemBase*)nullptr) <= 0){
if (GetWeaponDamage(target, (const EQEmu::ItemData*)nullptr) <= 0){
dmg = -5;
}
else{
@@ -1778,7 +1772,7 @@ void NPC::DoClassAttacks(Mob *target) {
DoAnim(animTailRake);
int32 dmg = 0;
if (GetWeaponDamage(target, (const EQEmu::ItemBase*)nullptr) <= 0){
if (GetWeaponDamage(target, (const EQEmu::ItemData*)nullptr) <= 0){
dmg = -5;
}
else{
@@ -1831,7 +1825,7 @@ void NPC::DoClassAttacks(Mob *target) {
DoAnim(animKick);
int32 dmg = 0;
if (GetWeaponDamage(target, (const EQEmu::ItemBase*)nullptr) <= 0){
if (GetWeaponDamage(target, (const EQEmu::ItemData*)nullptr) <= 0){
dmg = -5;
}
else{
@@ -1856,7 +1850,7 @@ void NPC::DoClassAttacks(Mob *target) {
DoAnim(animTailRake);
int32 dmg = 0;
if (GetWeaponDamage(target, (const EQEmu::ItemBase*)nullptr) <= 0){
if (GetWeaponDamage(target, (const EQEmu::ItemData*)nullptr) <= 0){
dmg = -5;
}
else{
@@ -1962,7 +1956,7 @@ void Client::DoClassAttacks(Mob *ca_target, uint16 skill, bool IsRiposte)
if (ca_target!=this) {
DoAnim(animTailRake);
if (GetWeaponDamage(ca_target, GetInv().GetItem(EQEmu::legacy::SlotSecondary)) <= 0 && GetWeaponDamage(ca_target, GetInv().GetItem(EQEmu::legacy::SlotShoulders)) <= 0){
if (GetWeaponDamage(ca_target, GetInv().GetItem(EQEmu::inventory::slotSecondary)) <= 0 && GetWeaponDamage(ca_target, GetInv().GetItem(EQEmu::inventory::slotShoulders)) <= 0){
dmg = -5;
}
else{
@@ -2026,7 +2020,7 @@ void Client::DoClassAttacks(Mob *ca_target, uint16 skill, bool IsRiposte)
if(ca_target!=this){
DoAnim(animKick);
if (GetWeaponDamage(ca_target, GetInv().GetItem(EQEmu::legacy::SlotFeet)) <= 0){
if (GetWeaponDamage(ca_target, GetInv().GetItem(EQEmu::inventory::slotFeet)) <= 0){
dmg = -5;
}
else{
@@ -2238,7 +2232,7 @@ uint32 Mob::TryHeadShot(Mob* defender, EQEmu::skills::SkillType skillInUse) {
HeadShot_Level = itembonuses.HSLevel;
if(HeadShot_Dmg && HeadShot_Level && (defender->GetLevel() <= HeadShot_Level)){
float ProcChance = GetSpecialProcChances(EQEmu::legacy::SlotRange);
float ProcChance = GetSpecialProcChances(EQEmu::inventory::slotRange);
if(zone->random.Roll(ProcChance))
return HeadShot_Dmg;
}
@@ -2301,7 +2295,7 @@ uint32 Mob::TryAssassinate(Mob* defender, EQEmu::skills::SkillType skillInUse, u
float ProcChance = 0.0f;
if (skillInUse == EQEmu::skills::SkillThrowing)
ProcChance = GetSpecialProcChances(EQEmu::legacy::SlotRange);
ProcChance = GetSpecialProcChances(EQEmu::inventory::slotRange);
else
ProcChance = GetAssassinateProcChances(ReuseTime);
@@ -2352,7 +2346,7 @@ void Mob::DoMeleeSkillAttackDmg(Mob* other, uint16 weapon_damage, EQEmu::skills:
int damage = 0;
uint32 hate = 0;
int Hand = EQEmu::legacy::SlotPrimary;
int Hand = EQEmu::inventory::slotPrimary;
if (hate == 0 && weapon_damage > 1) hate = weapon_damage;
if(weapon_damage > 0){
@@ -2368,7 +2362,7 @@ void Mob::DoMeleeSkillAttackDmg(Mob* other, uint16 weapon_damage, EQEmu::skills:
int32 max_hit = (2 * weapon_damage*GetDamageTable(skillinuse)) / 100;
if(GetLevel() >= 28 && IsWarriorClass() ) {
int ucDamageBonus = GetWeaponDamageBonus((const EQEmu::ItemBase*) nullptr);
int ucDamageBonus = GetWeaponDamageBonus((const EQEmu::ItemData*) nullptr);
min_hit += (int) ucDamageBonus;
max_hit += (int) ucDamageBonus;
hate += ucDamageBonus;
@@ -2376,12 +2370,12 @@ void Mob::DoMeleeSkillAttackDmg(Mob* other, uint16 weapon_damage, EQEmu::skills:
if (skillinuse == EQEmu::skills::SkillBash){
if(IsClient()){
ItemInst *item = CastToClient()->GetInv().GetItem(EQEmu::legacy::SlotSecondary);
EQEmu::ItemInstance *item = CastToClient()->GetInv().GetItem(EQEmu::inventory::slotSecondary);
if(item){
if (item->GetItem()->ItemType == EQEmu::item::ItemTypeShield) {
hate += item->GetItem()->AC;
}
const EQEmu::ItemBase *itm = item->GetItem();
const EQEmu::ItemData *itm = item->GetItem();
hate = hate * (100 + GetFuriousBash(itm->Focus.Effect)) / 100;
}
}
@@ -2398,7 +2392,7 @@ void Mob::DoMeleeSkillAttackDmg(Mob* other, uint16 weapon_damage, EQEmu::skills:
else
damage = zone->random.Int(min_hit, max_hit);
if (other->AvoidDamage(this, damage, CanRiposte ? EQEmu::legacy::SlotRange : EQEmu::legacy::SlotPrimary)) { // SlotRange excludes ripo, primary doesn't have any extra behavior
if (other->AvoidDamage(this, damage, CanRiposte ? EQEmu::inventory::slotRange : EQEmu::inventory::slotPrimary)) { // SlotRange excludes ripo, primary doesn't have any extra behavior
if (damage == -3) {
DoRiposte(other);
if (HasDied())
zone/spell_effects.cpp
+30 -29
View File
@@ -20,7 +20,7 @@
#include "../common/bodytypes.h"
#include "../common/classes.h"
#include "../common/global_define.h"
#include "../common/item.h"
#include "../common/item_instance.h"
#include "../common/rulesys.h"
#include "../common/skills.h"
#include "../common/spdat.h"
@@ -48,7 +48,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;
ItemInst *SummonedItem=nullptr;
EQEmu::ItemInstance *SummonedItem=nullptr;
#ifdef SPELL_EFFECT_SPAM
#define _EDLEN 200
char effect_desc[_EDLEN];
@@ -61,7 +61,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 ItemInst *inst = caster->CastToClient()->GetInv().GetItem(GetCastedSpellInvSlot());
const EQEmu::ItemInstance *inst = caster->CastToClient()->GetInv().GetItem(GetCastedSpellInvSlot());
if (inst) {
if (inst->GetItem()->Click.Level > 0) {
caster_level = inst->GetItem()->Click.Level;
@@ -622,7 +622,7 @@ bool Mob::SpellEffect(Mob* caster, uint16 spell_id, float partial, int level_ove
snprintf(effect_desc, _EDLEN, "Flesh To Bone");
#endif
if(IsClient()){
ItemInst* transI = CastToClient()->GetInv().GetItem(EQEmu::legacy::SlotCursor);
EQEmu::ItemInstance* transI = CastToClient()->GetInv().GetItem(EQEmu::inventory::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...
@@ -632,7 +632,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::legacy::SlotCursor, fcharges, true);
CastToClient()->DeleteItemInInventory(EQEmu::inventory::slotCursor, fcharges, true);
CastToClient()->SummonItem(13073, fcharges);
}
else{
@@ -1148,7 +1148,7 @@ bool Mob::SpellEffect(Mob* caster, uint16 spell_id, float partial, int level_ove
case SE_SummonItem:
{
const EQEmu::ItemBase *item = database.GetItem(spell.base[i]);
const EQEmu::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]);
@@ -1173,7 +1173,7 @@ bool Mob::SpellEffect(Mob* caster, uint16 spell_id, float partial, int level_ove
if (SummonedItem) {
c->PushItemOnCursor(*SummonedItem);
c->SendItemPacket(EQEmu::legacy::SlotCursor, SummonedItem, ItemPacketLimbo);
c->SendItemPacket(EQEmu::inventory::slotCursor, SummonedItem, ItemPacketLimbo);
safe_delete(SummonedItem);
}
SummonedItem = database.CreateItem(spell.base[i], charges);
@@ -1184,7 +1184,7 @@ bool Mob::SpellEffect(Mob* caster, uint16 spell_id, float partial, int level_ove
}
case SE_SummonItemIntoBag:
{
const EQEmu::ItemBase *item = database.GetItem(spell.base[i]);
const EQEmu::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]);
@@ -1213,7 +1213,7 @@ bool Mob::SpellEffect(Mob* caster, uint16 spell_id, float partial, int level_ove
if (charges < 1)
charges = 1;
ItemInst *SubItem = database.CreateItem(spell.base[i], charges);
EQEmu::ItemInstance *SubItem = database.CreateItem(spell.base[i], charges);
if (SubItem != nullptr) {
SummonedItem->PutItem(slot, *SubItem);
safe_delete(SubItem);
@@ -1445,7 +1445,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 = EQEmu::textures::textureBegin; x <= EQEmu::textures::LastTintableTexture; x++)
SendWearChange(x);
if (caster == this && spell.id != 287 && spell.id != 601 &&
@@ -1471,7 +1471,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 = EQEmu::textures::textureBegin; x <= EQEmu::textures::LastTintableTexture; x++)
caster->SendWearChange(x);
}
}
@@ -1650,6 +1650,7 @@ bool Mob::SpellEffect(Mob* caster, uint16 spell_id, float partial, int level_ove
break;
}
case SE_SummonToCorpse:
case SE_Revive:
{
#ifdef SPELL_EFFECT_SPAM
@@ -2239,7 +2240,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::legacy::SlotPrimary, 0, true); // on live wars dont get a duration ramp, its a one shot deal
entity_list.AEAttack(caster, 30, EQEmu::inventory::slotPrimary, 0, true); // on live wars dont get a duration ramp, its a one shot deal
break;
}
@@ -3037,7 +3038,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::legacy::SlotCursor, SummonedItem, ItemPacketLimbo);
c->SendItemPacket(EQEmu::inventory::slotCursor, SummonedItem, ItemPacketLimbo);
safe_delete(SummonedItem);
}
@@ -3855,7 +3856,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 = EQEmu::textures::textureBegin; x <= EQEmu::textures::LastTintableTexture; x++){
SendWearChange(x);
}
break;
@@ -5172,7 +5173,7 @@ uint16 Client::GetSympatheticFocusEffect(focusType type, uint16 spell_id) {
//item focus
if (itembonuses.FocusEffects[type]){
const EQEmu::ItemBase* TempItem = 0;
const EQEmu::ItemData* TempItem = 0;
for (int x = EQEmu::legacy::EQUIPMENT_BEGIN; x <= EQEmu::legacy::EQUIPMENT_END; x++)
{
@@ -5180,7 +5181,7 @@ uint16 Client::GetSympatheticFocusEffect(focusType type, uint16 spell_id) {
continue;
TempItem = nullptr;
ItemInst* ins = GetInv().GetItem(x);
EQEmu::ItemInstance* ins = GetInv().GetItem(x);
if (!ins)
continue;
TempItem = ins->GetItem();
@@ -5194,16 +5195,16 @@ uint16 Client::GetSympatheticFocusEffect(focusType type, uint16 spell_id) {
}
}
for (int y = AUG_INDEX_BEGIN; y < EQEmu::legacy::ITEM_COMMON_SIZE; ++y)
for (int y = EQEmu::inventory::socketBegin; y < EQEmu::inventory::SocketCount; ++y)
{
if (SympatheticProcList.size() > MAX_SYMPATHETIC_PROCS)
continue;
ItemInst *aug = nullptr;
EQEmu::ItemInstance *aug = nullptr;
aug = ins->GetAugment(y);
if(aug)
{
const EQEmu::ItemBase* TempItemAug = aug->GetItem();
const EQEmu::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)){
@@ -5301,8 +5302,8 @@ int16 Client::GetFocusEffect(focusType type, uint16 spell_id)
//Check if item focus effect exists for the client.
if (itembonuses.FocusEffects[type]){
const EQEmu::ItemBase* TempItem = 0;
const EQEmu::ItemBase* UsedItem = 0;
const EQEmu::ItemData* TempItem = 0;
const EQEmu::ItemData* UsedItem = 0;
uint16 UsedFocusID = 0;
int16 Total = 0;
int16 focus_max = 0;
@@ -5312,7 +5313,7 @@ int16 Client::GetFocusEffect(focusType type, uint16 spell_id)
for (int x = EQEmu::legacy::EQUIPMENT_BEGIN; x <= EQEmu::legacy::EQUIPMENT_END; x++)
{
TempItem = nullptr;
ItemInst* ins = GetInv().GetItem(x);
EQEmu::ItemInstance* ins = GetInv().GetItem(x);
if (!ins)
continue;
TempItem = ins->GetItem();
@@ -5343,13 +5344,13 @@ int16 Client::GetFocusEffect(focusType type, uint16 spell_id)
}
}
for (int y = AUG_INDEX_BEGIN; y < EQEmu::legacy::ITEM_COMMON_SIZE; ++y)
for (int y = EQEmu::inventory::socketBegin; y < EQEmu::inventory::SocketCount; ++y)
{
ItemInst *aug = nullptr;
EQEmu::ItemInstance *aug = nullptr;
aug = ins->GetAugment(y);
if(aug)
{
const EQEmu::ItemBase* TempItemAug = aug->GetItem();
const EQEmu::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);
@@ -5384,7 +5385,7 @@ int16 Client::GetFocusEffect(focusType type, uint16 spell_id)
for (int x = EQEmu::legacy::TRIBUTE_BEGIN; x <= EQEmu::legacy::TRIBUTE_END; ++x)
{
TempItem = nullptr;
ItemInst* ins = GetInv().GetItem(x);
EQEmu::ItemInstance* ins = GetInv().GetItem(x);
if (!ins)
continue;
TempItem = ins->GetItem();
@@ -5573,8 +5574,8 @@ int16 NPC::GetFocusEffect(focusType type, uint16 spell_id) {
if (RuleB(Spells, NPC_UseFocusFromItems) && itembonuses.FocusEffects[type]){
const EQEmu::ItemBase* TempItem = 0;
const EQEmu::ItemBase* UsedItem = 0;
const EQEmu::ItemData* TempItem = 0;
const EQEmu::ItemData* UsedItem = 0;
uint16 UsedFocusID = 0;
int16 Total = 0;
int16 focus_max = 0;
@@ -5582,7 +5583,7 @@ int16 NPC::GetFocusEffect(focusType type, uint16 spell_id) {
//item focus
for (int i = 0; i < EQEmu::legacy::EQUIPMENT_SIZE; i++){
const EQEmu::ItemBase *cur = database.GetItem(equipment[i]);
const EQEmu::ItemData *cur = database.GetItem(equipment[i]);
if(!cur)
continue;
zone/spells.cpp
+97 -64
View File
@@ -70,7 +70,7 @@ Copyright (C) 2001-2002 EQEMu Development Team (http://eqemu.org)
#include "../common/classes.h"
#include "../common/global_define.h"
#include "../common/eqemu_logsys.h"
#include "../common/item.h"
#include "../common/item_instance.h"
#include "../common/rulesys.h"
#include "../common/skills.h"
#include "../common/spdat.h"
@@ -256,7 +256,7 @@ 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))
{
ItemInst *itm = CastToClient()->GetInv().GetItem(item_slot);
EQEmu::ItemInstance *itm = CastToClient()->GetInv().GetItem(item_slot);
int bitmask = 1;
bitmask = bitmask << (CastToClient()->GetClass() - 1);
if( itm && itm->GetItem()->Classes != 65535 ) {
@@ -293,7 +293,7 @@ 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::legacy::SlotAmmo || item_slot == EQEmu::legacy::SlotPowerSource)){
if (itm && (itm->GetItem()->Click.Type == EQEmu::item::ItemEffectEquipClick) && !(item_slot <= EQEmu::inventory::slotAmmo || item_slot == EQEmu::inventory::slotPowerSource)){
if (CastToClient()->ClientVersion() < EQEmu::versions::ClientVersion::SoF) {
// They are attempting to cast a must equip clicky without having it equipped
Log.Out(Logs::General, Logs::Error, "HACKER: %s (account: %s) attempted to click an equip-only effect on item %s (id: %d) without equiping it!", CastToClient()->GetCleanName(), CastToClient()->AccountName(), itm->GetItem()->Name, itm->GetItem()->ID);
@@ -936,7 +936,7 @@ void Mob::CastedSpellFinished(uint16 spell_id, uint32 target_id, CastingSlot slo
if(IsClient() && (slot == CastingSlot::Item || slot == CastingSlot::PotionBelt))
{
IsFromItem = true;
ItemInst *itm = CastToClient()->GetInv().GetItem(inventory_slot);
EQEmu::ItemInstance *itm = CastToClient()->GetInv().GetItem(inventory_slot);
if(itm && itm->GetItem()->RecastDelay > 0)
{
if(!CastToClient()->GetPTimers().Expired(&database, (pTimerItemStart + itm->GetItem()->RecastType), false)) {
@@ -985,17 +985,23 @@ void Mob::CastedSpellFinished(uint16 spell_id, uint32 target_id, CastingSlot slo
if(GetClass() == BARD) // bard's can move when casting any spell...
{
if (IsBardSong(spell_id)) {
if(spells[spell_id].buffduration == 0xFFFF || spells[spell_id].recast_time != 0) {
Log.Out(Logs::Detail, Logs::Spells, "Bard song %d not applying bard logic because duration or recast is wrong: dur=%d, recast=%d", spells[spell_id].buffduration, spells[spell_id].recast_time);
if(spells[spell_id].buffduration == 0xFFFF) {
Log.Out(Logs::Detail, Logs::Spells, "Bard song %d not applying bard logic because duration. dur=%d, recast=%d", spells[spell_id].buffduration);
} else {
bardsong = spell_id;
bardsong_slot = slot;
//NOTE: theres a lot more target types than this to think about...
if (spell_target == nullptr || (spells[spell_id].targettype != ST_Target && spells[spell_id].targettype != ST_AETarget))
bardsong_target_id = GetID();
else
bardsong_target_id = spell_target->GetID();
bardsong_timer.Start(6000);
// So long recast bard songs need special bard logic, although the effects don't repulse like other songs
// This is basically a hack to get that effect
// You can hold down the long recast spells, but you only get the effects once
// TODO fuck bards.
if (spells[spell_id].recast_time == 0) {
bardsong = spell_id;
bardsong_slot = slot;
//NOTE: theres a lot more target types than this to think about...
if (spell_target == nullptr || (spells[spell_id].targettype != ST_Target && spells[spell_id].targettype != ST_AETarget))
bardsong_target_id = GetID();
else
bardsong_target_id = spell_target->GetID();
bardsong_timer.Start(6000);
}
Log.Out(Logs::Detail, Logs::Spells, "Bard song %d started: slot %d, target id %d", bardsong, bardsong_slot, bardsong_target_id);
bard_song_mode = true;
}
@@ -1174,7 +1180,7 @@ void Mob::CastedSpellFinished(uint16 spell_id, uint32 target_id, CastingSlot slo
missingreags=true;
}
const EQEmu::ItemBase *item = database.GetItem(component);
const EQEmu::ItemData *item = database.GetItem(component);
if(item) {
c->Message_StringID(13, MISSING_SPELL_COMP_ITEM, item->Name);
Log.Out(Logs::Detail, Logs::Spells, "Spell %d: Canceled. Missing required reagent %s (%d)", spell_id, item->Name, component);
@@ -1235,8 +1241,8 @@ void Mob::CastedSpellFinished(uint16 spell_id, uint32 target_id, CastingSlot slo
&& inventory_slot != 0xFFFFFFFF) // 10 is an item
{
bool fromaug = false;
const ItemInst* inst = CastToClient()->GetInv()[inventory_slot];
EQEmu::ItemBase* augitem = 0;
const EQEmu::ItemInstance* inst = CastToClient()->GetInv()[inventory_slot];
EQEmu::ItemData* augitem = 0;
uint32 recastdelay = 0;
uint32 recasttype = 0;
@@ -1244,12 +1250,12 @@ void Mob::CastedSpellFinished(uint16 spell_id, uint32 target_id, CastingSlot slo
if (inst == nullptr)
break;
for (int r = AUG_INDEX_BEGIN; r < EQEmu::legacy::ITEM_COMMON_SIZE; r++) {
const ItemInst* aug_i = inst->GetAugment(r);
for (int r = EQEmu::inventory::socketBegin; r < EQEmu::inventory::SocketCount; r++) {
const EQEmu::ItemInstance* aug_i = inst->GetAugment(r);
if (!aug_i)
continue;
const EQEmu::ItemBase* aug = aug_i->GetItem();
const EQEmu::ItemData* aug = aug_i->GetItem();
if (!aug)
continue;
@@ -1285,7 +1291,7 @@ void Mob::CastedSpellFinished(uint16 spell_id, uint32 target_id, CastingSlot slo
if (inst && inst->IsClassCommon() && (inst->GetItem()->Click.Effect == spell_id) && inst->GetCharges() || fromaug)
{
//const ItemBase* item = inst->GetItem();
//const ItemData* item = inst->GetItem();
int16 charges = inst->GetItem()->MaxCharges;
if(fromaug) { charges = -1; } //Don't destroy the parent item
@@ -2385,7 +2391,7 @@ bool Mob::SpellFinished(uint16 spell_id, Mob *spell_target, CastingSlot slot, ui
if(IsClient() && (slot == CastingSlot::Item || slot == CastingSlot::PotionBelt))
{
ItemInst *itm = CastToClient()->GetInv().GetItem(inventory_slot);
EQEmu::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);
@@ -3386,11 +3392,6 @@ bool Mob::SpellOnTarget(uint16 spell_id, Mob *spelltar, bool reflect, bool use_r
if(spelltar->IsClient() && spelltar->CastToClient()->IsHoveringForRespawn())
return false;
if (spells[spell_id].sneak && IsClient() && !CastToClient()->sneaking){
Message_StringID(13, SNEAK_RESTRICT);
return false;//Fail Safe, this can cause a zone crash certain situations if you try to apply sneak effects when not sneaking.
}
if(IsDetrimentalSpell(spell_id) && !IsAttackAllowed(spelltar) && !IsResurrectionEffects(spell_id)) {
if(!IsClient() || !CastToClient()->GetGM()) {
Message_StringID(MT_SpellFailure, SPELL_NO_HOLD);
@@ -5533,12 +5534,12 @@ int Client::GetCurrentBuffSlots() const
numbuffs++;
if (GetLevel() > 74)
numbuffs++;
return EQEmu::ClampUpper(numbuffs, GetMaxBuffSlots());
return EQEmu::ClampUpper(numbuffs, EQEmu::constants::Lookup(m_ClientVersion)->LongBuffs);
}
int Client::GetCurrentSongSlots() const
{
return 12; // AAs dont affect this
return EQEmu::constants::Lookup(m_ClientVersion)->ShortBuffs; // AAs dont affect this
}
void Client::InitializeBuffSlots()
@@ -5619,11 +5620,11 @@ void Mob::BeamDirectional(uint16 spell_id, int16 resist_adjust)
if (IsBeneficialSpell(spell_id) && IsClient())
beneficial_targets = true;
std::list<Mob*> targets_in_range;
std::list<Mob*>::iterator iter;
std::list<Mob *> targets_in_range;
entity_list.GetTargetsForConeArea(this, spells[spell_id].min_range, spells[spell_id].range, spells[spell_id].range / 2, targets_in_range);
iter = targets_in_range.begin();
entity_list.GetTargetsForConeArea(this, spells[spell_id].min_range, spells[spell_id].range,
spells[spell_id].range / 2, targets_in_range);
auto iter = targets_in_range.begin();
float dX = 0;
float dY = 0;
@@ -5632,24 +5633,39 @@ void Mob::BeamDirectional(uint16 spell_id, int16 resist_adjust)
CalcDestFromHeading(GetHeading(), spells[spell_id].range, 5, GetX(), GetY(), dX, dY, dZ);
dZ = GetZ();
//FIND SLOPE: Put it into the form y = mx + b
// FIND SLOPE: Put it into the form y = mx + b
float m = (dY - GetY()) / (dX - GetX());
float b = (GetY() * dX - dY * GetX()) / (dX - GetX());
while(iter != targets_in_range.end())
{
if (!(*iter) || (beneficial_targets && ((*iter)->IsNPC() && !(*iter)->IsPetOwnerClient()))
|| (*iter)->BehindMob(this, (*iter)->GetX(),(*iter)->GetY())){
++iter;
while (iter != targets_in_range.end()) {
if (!(*iter) || (beneficial_targets && ((*iter)->IsNPC() && !(*iter)->IsPetOwnerClient())) ||
(*iter)->BehindMob(this, (*iter)->GetX(), (*iter)->GetY())) {
++iter;
continue;
}
if (IsNPC() && (*iter)->IsNPC()) {
auto fac = (*iter)->GetReverseFactionCon(this);
if (beneficial_targets) {
// only affect mobs we would assist.
if (!(fac <= FACTION_AMIABLE)) {
++iter;
continue;
}
} else {
// affect mobs that are on our hate list, or which have bad faction with us
if (!(CheckAggro(*iter) || fac == FACTION_THREATENLY || fac == FACTION_SCOWLS)) {
++iter;
continue;
}
}
}
//# shortest distance from line to target point
float d = std::abs((*iter)->GetY() - m * (*iter)->GetX() - b) / sqrt(m * m + 1);
if (d <= spells[spell_id].aoerange)
{
if(CheckLosFN((*iter)) || spells[spell_id].npc_no_los) {
if (d <= spells[spell_id].aoerange) {
if (CheckLosFN((*iter)) || spells[spell_id].npc_no_los) {
(*iter)->CalcSpellPowerDistanceMod(spell_id, 0, this);
SpellOnTarget(spell_id, (*iter), false, true, resist_adjust);
maxtarget_count++;
@@ -5673,45 +5689,62 @@ void Mob::ConeDirectional(uint16 spell_id, int16 resist_adjust)
float angle_start = spells[spell_id].directional_start + (GetHeading() * 360.0f / 256.0f);
float angle_end = spells[spell_id].directional_end + (GetHeading() * 360.0f / 256.0f);
while(angle_start > 360.0f)
while (angle_start > 360.0f)
angle_start -= 360.0f;
while(angle_end > 360.0f)
while (angle_end > 360.0f)
angle_end -= 360.0f;
std::list<Mob*> targets_in_range;
std::list<Mob*>::iterator iter;
std::list<Mob *> targets_in_range;
entity_list.GetTargetsForConeArea(this, spells[spell_id].min_range, spells[spell_id].aoerange, spells[spell_id].aoerange / 2, targets_in_range);
iter = targets_in_range.begin();
entity_list.GetTargetsForConeArea(this, spells[spell_id].min_range, spells[spell_id].aoerange,
spells[spell_id].aoerange / 2, targets_in_range);
auto iter = targets_in_range.begin();
while(iter != targets_in_range.end()){
if (!(*iter) || (beneficial_targets && ((*iter)->IsNPC() && !(*iter)->IsPetOwnerClient()))){
++iter;
while (iter != targets_in_range.end()) {
if (!(*iter) || (beneficial_targets && ((*iter)->IsNPC() && !(*iter)->IsPetOwnerClient()))) {
++iter;
continue;
}
float heading_to_target = (CalculateHeadingToTarget((*iter)->GetX(), (*iter)->GetY()) * 360.0f / 256.0f);
float heading_to_target =
(CalculateHeadingToTarget((*iter)->GetX(), (*iter)->GetY()) * 360.0f / 256.0f);
while(heading_to_target < 0.0f)
while (heading_to_target < 0.0f)
heading_to_target += 360.0f;
while(heading_to_target > 360.0f)
while (heading_to_target > 360.0f)
heading_to_target -= 360.0f;
if(angle_start > angle_end){
if((heading_to_target >= angle_start && heading_to_target <= 360.0f) || (heading_to_target >= 0.0f && heading_to_target <= angle_end)){
if(CheckLosFN((*iter)) || spells[spell_id].npc_no_los){
(*iter)->CalcSpellPowerDistanceMod(spell_id, 0, this);
SpellOnTarget(spell_id,(*iter), false, true, resist_adjust);
maxtarget_count++;
if (IsNPC() && (*iter)->IsNPC()) {
auto fac = (*iter)->GetReverseFactionCon(this);
if (beneficial_targets) {
// only affect mobs we would assist.
if (!(fac <= FACTION_AMIABLE)) {
++iter;
continue;
}
} else {
// affect mobs that are on our hate list, or which have bad faction with us
if (!(CheckAggro(*iter) || fac == FACTION_THREATENLY || fac == FACTION_SCOWLS)) {
++iter;
continue;
}
}
}
else{
if(heading_to_target >= angle_start && heading_to_target <= angle_end){
if(CheckLosFN((*iter)) || spells[spell_id].npc_no_los) {
if (angle_start > angle_end) {
if ((heading_to_target >= angle_start && heading_to_target <= 360.0f) ||
(heading_to_target >= 0.0f && heading_to_target <= angle_end)) {
if (CheckLosFN((*iter)) || spells[spell_id].npc_no_los) {
(*iter)->CalcSpellPowerDistanceMod(spell_id, 0, this);
SpellOnTarget(spell_id, (*iter), false, true, resist_adjust);
maxtarget_count++;
}
}
} else {
if (heading_to_target >= angle_start && heading_to_target <= angle_end) {
if (CheckLosFN((*iter)) || spells[spell_id].npc_no_los) {
(*iter)->CalcSpellPowerDistanceMod(spell_id, 0, this);
SpellOnTarget(spell_id, (*iter), false, true, resist_adjust);
maxtarget_count++;
zone/tasks.cpp
+3 -3
View File
@@ -1708,7 +1708,7 @@ void ClientTaskState::UpdateTasksOnExplore(Client *c, int ExploreID) {
return;
}
bool ClientTaskState::UpdateTasksOnDeliver(Client *c, std::list<ItemInst*>& Items, int Cash, int NPCTypeID) {
bool ClientTaskState::UpdateTasksOnDeliver(Client *c, std::list<EQEmu::ItemInstance*>& Items, int Cash, int NPCTypeID) {
bool Ret = false;
@@ -1900,7 +1900,7 @@ void ClientTaskState::RewardTask(Client *c, TaskInformation *Task) {
if(!Task || !c) return;
const EQEmu::ItemBase* Item;
const EQEmu::ItemData* Item;
std::vector<int> RewardList;
switch(Task->RewardMethod) {
@@ -2791,7 +2791,7 @@ void TaskManager::SendActiveTaskDescription(Client *c, int TaskID, int SequenceN
}
if(ItemID) {
const EQEmu::ItemBase* reward_item = database.GetItem(ItemID);
const EQEmu::ItemData* reward_item = database.GetItem(ItemID);
EQEmu::SayLinkEngine linker;
linker.SetLinkType(EQEmu::saylink::SayLinkItemData);
zone/tasks.h
+6 -2
View File
@@ -45,7 +45,11 @@ Copyright (C) 2001-2004 EQEMu Development Team (http://eqemulator.net)
class Client;
class Mob;
class ItemInst;
namespace EQEmu
{
class ItemInstance;
}
struct TaskGoalList_Struct {
int ListID;
@@ -187,7 +191,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<ItemInst*>& Items, int Cash, int NPCTypeID);
bool UpdateTasksOnDeliver(Client *c, std::list<EQEmu::ItemInstance*>& Items, int Cash, int NPCTypeID);
void UpdateTasksOnTouch(Client *c, int ZoneID);
void ProcessTaskProximities(Client *c, float X, float Y, float Z);
bool TaskOutOfTime(int Index);
zone/tradeskills.cpp
+40 -40
View File
@@ -46,7 +46,7 @@ void Object::HandleAugmentation(Client* user, const AugmentItem_Struct* in_augme
return;
}
ItemInst* container = nullptr;
EQEmu::ItemInstance* container = nullptr;
if (worldo)
{
@@ -55,13 +55,13 @@ 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.
Inventory& user_inv = user->GetInv();
ItemInst* inst = nullptr;
EQEmu::InventoryProfile& user_inv = user->GetInv();
EQEmu::ItemInstance* inst = nullptr;
inst = user_inv.GetItem(in_augment->container_slot);
if (inst)
{
const EQEmu::ItemBase* item = inst->GetItem();
const EQEmu::ItemData* item = inst->GetItem();
if (item && inst->IsType(EQEmu::item::ItemClassBag) && item->BagType == 53)
{
// We have found an appropriate inventory augmentation sealer
@@ -69,9 +69,9 @@ void Object::HandleAugmentation(Client* user, const AugmentItem_Struct* in_augme
// Verify that no more than two items are in container to guarantee no inadvertant wipes.
uint8 itemsFound = 0;
for (uint8 i = SLOT_BEGIN; i < EQEmu::legacy::TYPE_WORLD_SIZE; i++)
for (uint8 i = EQEmu::inventory::slotBegin; i < EQEmu::legacy::TYPE_WORLD_SIZE; i++)
{
const ItemInst* inst = container->GetItem(i);
const EQEmu::ItemInstance* inst = container->GetItem(i);
if (inst)
{
itemsFound++;
@@ -94,7 +94,7 @@ void Object::HandleAugmentation(Client* user, const AugmentItem_Struct* in_augme
return;
}
ItemInst *tobe_auged = nullptr, *auged_with = nullptr;
EQEmu::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;
ItemInst *itemOneToPush = nullptr, *itemTwoToPush = nullptr;
EQEmu::ItemInstance *itemOneToPush = nullptr, *itemTwoToPush = nullptr;
// Adding augment
if (in_augment->augment_slot == -1)
@@ -145,7 +145,7 @@ void Object::HandleAugmentation(Client* user, const AugmentItem_Struct* in_augme
{
tobe_auged->PutAugment(slot, *auged_with);
ItemInst *aug = tobe_auged->GetAugment(slot);
EQEmu::ItemInstance *aug = tobe_auged->GetAugment(slot);
if(aug) {
std::vector<EQEmu::Any> args;
args.push_back(aug);
@@ -165,7 +165,7 @@ void Object::HandleAugmentation(Client* user, const AugmentItem_Struct* in_augme
}
else
{
ItemInst *old_aug = nullptr;
EQEmu::ItemInstance *old_aug = nullptr;
bool isSolvent = auged_with->GetItem()->ItemType == EQEmu::item::ItemTypeAugmentationSolvent;
if (!isSolvent && auged_with->GetItem()->ItemType != EQEmu::item::ItemTypeAugmentationDistiller)
{
@@ -175,7 +175,7 @@ void Object::HandleAugmentation(Client* user, const AugmentItem_Struct* in_augme
return;
}
ItemInst *aug = tobe_auged->GetAugment(in_augment->augment_slot);
EQEmu::ItemInstance *aug = tobe_auged->GetAugment(in_augment->augment_slot);
if (aug) {
if (!isSolvent && auged_with->GetItem()->ID != aug->GetItem()->AugDistiller)
{
@@ -222,12 +222,12 @@ void Object::HandleAugmentation(Client* user, const AugmentItem_Struct* in_augme
else
{
// Delete items in our inventory container...
for (uint8 i = SLOT_BEGIN; i < EQEmu::legacy::TYPE_WORLD_SIZE; i++)
for (uint8 i = EQEmu::inventory::slotBegin; i < EQEmu::legacy::TYPE_WORLD_SIZE; i++)
{
const ItemInst* inst = container->GetItem(i);
const EQEmu::ItemInstance* inst = container->GetItem(i);
if (inst)
{
user->DeleteItemInInventory(Inventory::CalcSlotId(in_augment->container_slot,i),0,true);
user->DeleteItemInInventory(EQEmu::InventoryProfile::CalcSlotId(in_augment->container_slot, i), 0, true);
}
}
// Explicitly mark container as cleared.
@@ -256,10 +256,10 @@ void Object::HandleCombine(Client* user, const NewCombine_Struct* in_combine, Ob
return;
}
Inventory& user_inv = user->GetInv();
EQEmu::InventoryProfile& user_inv = user->GetInv();
PlayerProfile_Struct& user_pp = user->GetPP();
ItemInst* container = nullptr;
ItemInst* inst = nullptr;
EQEmu::ItemInstance* container = nullptr;
EQEmu::ItemInstance* inst = nullptr;
uint8 c_type = 0xE8;
uint32 some_id = 0;
bool worldcontainer=false;
@@ -276,7 +276,7 @@ void Object::HandleCombine(Client* user, const NewCombine_Struct* in_combine, Ob
else {
inst = user_inv.GetItem(in_combine->container_slot);
if (inst) {
const EQEmu::ItemBase* item = inst->GetItem();
const EQEmu::ItemData* item = inst->GetItem();
if (item && inst->IsType(EQEmu::item::ItemClassBag)) {
c_type = item->BagType;
some_id = item->ID;
@@ -291,13 +291,13 @@ void Object::HandleCombine(Client* user, const NewCombine_Struct* in_combine, Ob
container = inst;
if (container->GetItem() && container->GetItem()->BagType == EQEmu::item::BagTypeTransformationmold) {
const ItemInst* inst = container->GetItem(0);
const EQEmu::ItemInstance* inst = container->GetItem(0);
bool AllowAll = RuleB(Inventory, AllowAnyWeaponTransformation);
if (inst && ItemInst::CanTransform(inst->GetItem(), container->GetItem(), AllowAll)) {
const EQEmu::ItemBase* new_weapon = inst->GetItem();
user->DeleteItemInInventory(Inventory::CalcSlotId(in_combine->container_slot, 0), 0, true);
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);
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::legacy::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(), EQEmu::inventory::slotCursor, container->GetItem()->Icon, atoi(container->GetItem()->IDFile + 2));
user->Message_StringID(4, TRANSFORM_COMPLETE, inst->GetItem()->Name);
if (RuleB(Inventory, DeleteTransformationMold))
user->DeleteItemInInventory(in_combine->container_slot, 0, true);
@@ -312,12 +312,12 @@ void Object::HandleCombine(Client* user, const NewCombine_Struct* in_combine, Ob
}
if (container->GetItem() && container->GetItem()->BagType == EQEmu::item::BagTypeDetransformationmold) {
const ItemInst* inst = container->GetItem(0);
const EQEmu::ItemInstance* inst = container->GetItem(0);
if (inst && inst->GetOrnamentationIcon() && inst->GetOrnamentationIcon()) {
const EQEmu::ItemBase* new_weapon = inst->GetItem();
user->DeleteItemInInventory(Inventory::CalcSlotId(in_combine->container_slot, 0), 0, true);
const EQEmu::ItemData* new_weapon = inst->GetItem();
user->DeleteItemInInventory(EQEmu::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::legacy::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(), EQEmu::inventory::slotCursor, 0, 0);
user->Message_StringID(4, TRANSFORM_COMPLETE, inst->GetItem()->Name);
}
else if (inst) {
@@ -401,10 +401,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 = SLOT_BEGIN; i < EQEmu::legacy::TYPE_WORLD_SIZE; i++) {
const ItemInst* inst = container->GetItem(i);
for (uint8 i = EQEmu::inventory::slotBegin; i < EQEmu::legacy::TYPE_WORLD_SIZE; i++) {
const EQEmu::ItemInstance* inst = container->GetItem(i);
if (inst) {
user->DeleteItemInInventory(Inventory::CalcSlotId(in_combine->container_slot,i),0,true);
user->DeleteItemInInventory(EQEmu::InventoryProfile::CalcSlotId(in_combine->container_slot, i), 0, true);
}
}
container->Clear();
@@ -501,7 +501,7 @@ void Object::HandleAutoCombine(Client* user, const RecipeAutoCombine_Struct* rac
memset(counts, 0, sizeof(counts));
//search for all the items in their inventory
Inventory& user_inv = user->GetInv();
EQEmu::InventoryProfile& user_inv = user->GetInv();
uint8 count = 0;
uint8 needcount = 0;
@@ -537,7 +537,7 @@ void Object::HandleAutoCombine(Client* user, const RecipeAutoCombine_Struct* rac
user->Message_StringID(MT_Skills, TRADESKILL_MISSING_COMPONENTS);
for (auto it = MissingItems.begin(); it != MissingItems.end(); ++it) {
const EQEmu::ItemBase* item = database.GetItem(*it);
const EQEmu::ItemData* item = database.GetItem(*it);
if(item)
user->Message_StringID(MT_Skills, TRADESKILL_MISSING_ITEM, item->Name);
@@ -566,7 +566,7 @@ void Object::HandleAutoCombine(Client* user, const RecipeAutoCombine_Struct* rac
return;
}
const ItemInst* inst = user_inv.GetItem(slot);
const EQEmu::ItemInstance* inst = user_inv.GetItem(slot);
if (inst && !inst->IsStackable())
user->DeleteItemInInventory(slot, 0, true);
@@ -962,7 +962,7 @@ bool Client::TradeskillExecute(DBTradeskillRecipe_Struct *spec) {
aa_chance = spellbonuses.ReduceTradeskillFail[spec->tradeskill] + itembonuses.ReduceTradeskillFail[spec->tradeskill] + aabonuses.ReduceTradeskillFail[spec->tradeskill];
const EQEmu::ItemBase* item = nullptr;
const EQEmu::ItemData* item = nullptr;
chance = mod_tradeskill_chance(chance, spec);
@@ -1090,7 +1090,7 @@ void Client::CheckIncreaseTradeskill(int16 bonusstat, int16 stat_modifier, float
Log.Out(Logs::Detail, Logs::Tradeskills, "...Stage2 chance was: %f percent. 0 percent means stage1 failed", chance_stage2);
}
bool ZoneDatabase::GetTradeRecipe(const ItemInst* container, uint8 c_type, uint32 some_id,
bool ZoneDatabase::GetTradeRecipe(const EQEmu::ItemInstance* container, uint8 c_type, uint32 some_id,
uint32 char_id, DBTradeskillRecipe_Struct *spec)
{
if (container == nullptr)
@@ -1109,11 +1109,11 @@ bool ZoneDatabase::GetTradeRecipe(const ItemInst* container, uint8 c_type, uint3
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 ItemInst* inst = container->GetItem(i);
const EQEmu::ItemInstance* inst = container->GetItem(i);
if (!inst)
continue;
const EQEmu::ItemBase* item = GetItem(inst->GetItem()->ID);
const EQEmu::ItemData* item = GetItem(inst->GetItem()->ID);
if (!item)
continue;
@@ -1237,12 +1237,12 @@ bool ZoneDatabase::GetTradeRecipe(const ItemInst* container, uint8 c_type, uint3
for (auto row = results.begin(); row != results.end(); ++row) {
int ccnt = 0;
for (int x = SLOT_BEGIN; x < EQEmu::legacy::TYPE_WORLD_SIZE; x++) {
const ItemInst* inst = container->GetItem(x);
for (int x = EQEmu::inventory::slotBegin; x < EQEmu::legacy::TYPE_WORLD_SIZE; x++) {
const EQEmu::ItemInstance* inst = container->GetItem(x);
if(!inst)
continue;
const EQEmu::ItemBase* item = GetItem(inst->GetItem()->ID);
const EQEmu::ItemData* item = GetItem(inst->GetItem()->ID);
if (!item)
continue;
zone/trading.cpp
+80 -80
View File
@@ -98,14 +98,14 @@ void Trade::AddEntity(uint16 trade_slot_id, uint32 stack_size) {
// Item always goes into trade bucket from cursor
Client* client = owner->CastToClient();
ItemInst* inst = client->GetInv().GetItem(EQEmu::legacy::SlotCursor);
EQEmu::ItemInstance* inst = client->GetInv().GetItem(EQEmu::inventory::slotCursor);
if (!inst) {
client->Message(13, "Error: Could not find item on your cursor!");
return;
}
ItemInst* inst2 = client->GetInv().GetItem(trade_slot_id);
EQEmu::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)
@@ -131,7 +131,7 @@ void Trade::AddEntity(uint16 trade_slot_id, uint32 stack_size) {
if (_stack_size > 0)
inst->SetCharges(_stack_size);
else
client->DeleteItemInInventory(EQEmu::legacy::SlotCursor);
client->DeleteItemInInventory(EQEmu::inventory::slotCursor);
SendItemData(inst2, trade_slot_id);
}
@@ -146,7 +146,7 @@ void Trade::AddEntity(uint16 trade_slot_id, uint32 stack_size) {
Log.Out(Logs::Detail, Logs::Trading, "%s added item '%s' to trade slot %i", owner->GetName(), inst->GetItem()->Name, trade_slot_id);
client->PutItemInInventory(trade_slot_id, *inst);
client->DeleteItemInInventory(EQEmu::legacy::SlotCursor);
client->DeleteItemInInventory(EQEmu::inventory::slotCursor);
}
}
@@ -158,7 +158,7 @@ Mob* Trade::With()
}
// Private Method: Send item data for trade item to other person involved in trade
void Trade::SendItemData(const ItemInst* inst, int16 dest_slot_id)
void Trade::SendItemData(const EQEmu::ItemInstance* inst, int16 dest_slot_id)
{
if (inst == nullptr)
return;
@@ -173,9 +173,9 @@ void Trade::SendItemData(const ItemInst* inst, int16 dest_slot_id)
if (with && with->IsClient()) {
with->SendItemPacket(dest_slot_id - EQEmu::legacy::TRADE_BEGIN, inst, ItemPacketTradeView);
if (inst->GetItem()->ItemClass == 1) {
for (uint16 i = SUB_INDEX_BEGIN; i < EQEmu::legacy::ITEM_CONTAINER_SIZE; i++) {
uint16 bagslot_id = Inventory::CalcSlotId(dest_slot_id, i);
const ItemInst* bagitem = trader->GetInv().GetItem(bagslot_id);
for (uint16 i = EQEmu::inventory::containerBegin; i < EQEmu::inventory::ContainerCount; i++) {
uint16 bagslot_id = EQEmu::InventoryProfile::CalcSlotId(dest_slot_id, i);
const EQEmu::ItemInstance* bagitem = trader->GetInv().GetItem(bagslot_id);
if (bagitem) {
with->SendItemPacket(bagslot_id - EQEmu::legacy::TRADE_BEGIN, bagitem, ItemPacketTradeView);
}
@@ -252,7 +252,7 @@ void Trade::LogTrade()
strcat(logtext, "items {");
for (uint16 i = EQEmu::legacy::TRADE_BEGIN; i <= EQEmu::legacy::TRADE_END; i++) {
const ItemInst* inst = trader->GetInv().GetItem(i);
const EQEmu::ItemInstance* inst = trader->GetInv().GetItem(i);
if (!comma)
comma = true;
@@ -267,7 +267,7 @@ void Trade::LogTrade()
strcat(logtext, item_num);
if (inst->IsClassBag()) {
for (uint8 j = SUB_INDEX_BEGIN; j < EQEmu::legacy::ITEM_CONTAINER_SIZE; j++) {
for (uint8 j = EQEmu::inventory::containerBegin; j < EQEmu::inventory::ContainerCount; j++) {
inst = trader->GetInv().GetItem(i, j);
if (inst) {
strcat(logtext, ",");
@@ -304,7 +304,7 @@ void Trade::DumpTrade()
Client* trader = owner->CastToClient();
for (uint16 i = EQEmu::legacy::TRADE_BEGIN; i <= EQEmu::legacy::TRADE_END; i++) {
const ItemInst* inst = trader->GetInv().GetItem(i);
const EQEmu::ItemInstance* inst = trader->GetInv().GetItem(i);
if (inst) {
Log.Out(Logs::Detail, Logs::Trading, "Item %i (Charges=%i, Slot=%i, IsBag=%s)",
@@ -312,12 +312,12 @@ void Trade::DumpTrade()
i, ((inst->IsClassBag()) ? "True" : "False"));
if (inst->IsClassBag()) {
for (uint8 j = SUB_INDEX_BEGIN; j < EQEmu::legacy::ITEM_CONTAINER_SIZE; j++) {
for (uint8 j = EQEmu::inventory::containerBegin; j < EQEmu::inventory::ContainerCount; j++) {
inst = trader->GetInv().GetItem(i, j);
if (inst) {
Log.Out(Logs::Detail, Logs::Trading, "\tBagItem %i (Charges=%i, Slot=%i)",
inst->GetItem()->ID, inst->GetCharges(),
Inventory::CalcSlotId(i, j));
EQEmu::InventoryProfile::CalcSlotId(i, j));
}
}
}
@@ -333,7 +333,7 @@ void Client::ResetTrade() {
// step 1: process bags
for (int16 trade_slot = EQEmu::legacy::TRADE_BEGIN; trade_slot <= EQEmu::legacy::TRADE_END; ++trade_slot) {
const ItemInst* inst = m_inv[trade_slot];
const EQEmu::ItemInstance* inst = m_inv[trade_slot];
if (inst && inst->IsClassBag()) {
int16 free_slot = m_inv.FindFreeSlotForTradeItem(inst);
@@ -352,17 +352,17 @@ void Client::ResetTrade() {
// step 2a: process stackables
for (int16 trade_slot = EQEmu::legacy::TRADE_BEGIN; trade_slot <= EQEmu::legacy::TRADE_END; ++trade_slot) {
ItemInst* inst = GetInv().GetItem(trade_slot);
EQEmu::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::legacy::SlotCursor) || (free_slot == INVALID_INDEX))
if ((free_slot == EQEmu::inventory::slotCursor) || (free_slot == INVALID_INDEX))
break;
ItemInst* partial_inst = GetInv().GetItem(free_slot);
EQEmu::ItemInstance* partial_inst = GetInv().GetItem(free_slot);
if (!partial_inst)
break;
@@ -399,14 +399,14 @@ 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::legacy::TRADE_END; trade_slot >= EQEmu::legacy::TRADE_BEGIN; --trade_slot) {
ItemInst* inst = GetInv().GetItem(trade_slot);
EQEmu::ItemInstance* inst = GetInv().GetItem(trade_slot);
if (inst && inst->IsStackable()) {
for (int16 bias_slot = EQEmu::legacy::TRADE_BEGIN; bias_slot <= EQEmu::legacy::TRADE_END; ++bias_slot) {
if (bias_slot >= trade_slot)
break;
ItemInst* bias_inst = GetInv().GetItem(bias_slot);
EQEmu::ItemInstance* bias_inst = GetInv().GetItem(bias_slot);
if (!bias_inst || (bias_inst->GetID() != inst->GetID()) || (bias_inst->GetCharges() >= bias_inst->GetItem()->StackSize))
continue;
@@ -433,7 +433,7 @@ void Client::ResetTrade() {
// step 3: process everything else
for (int16 trade_slot = EQEmu::legacy::TRADE_BEGIN; trade_slot <= EQEmu::legacy::TRADE_END; ++trade_slot) {
const ItemInst* inst = m_inv[trade_slot];
const EQEmu::ItemInstance* inst = m_inv[trade_slot];
if (inst) {
int16 free_slot = m_inv.FindFreeSlotForTradeItem(inst);
@@ -488,7 +488,7 @@ void Client::FinishTrade(Mob* tradingWith, bool finalizer, void* event_entry, st
// step 1: process bags
for (int16 trade_slot = EQEmu::legacy::TRADE_BEGIN; trade_slot <= EQEmu::legacy::TRADE_END; ++trade_slot) {
const ItemInst* inst = m_inv[trade_slot];
const EQEmu::ItemInstance* inst = m_inv[trade_slot];
if (inst && inst->IsClassBag()) {
Log.Out(Logs::Detail, Logs::Trading, "Giving container %s (%d) in slot %d to %s", 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
qs_audit->char1_count += detail->charges;
//for (uint8 sub_slot = SUB_BEGIN; ((sub_slot < inst->GetItem()->BagSlots) && (sub_slot < EmuConstants::ITEM_CONTAINER_SIZE)); ++sub_slot) {
for (uint8 sub_slot = SUB_INDEX_BEGIN; (sub_slot < EQEmu::legacy::ITEM_CONTAINER_SIZE); ++sub_slot) { // this is to catch ALL items
const ItemInst* bag_inst = inst->GetItem(sub_slot);
for (uint8 sub_slot = EQEmu::inventory::containerBegin; (sub_slot < EQEmu::inventory::ContainerCount); ++sub_slot) { // this is to catch ALL items
const EQEmu::ItemInstance* bag_inst = inst->GetItem(sub_slot);
if (bag_inst) {
detail = new QSTradeItems_Struct;
detail->from_id = this->character_id;
detail->from_slot = Inventory::CalcSlotId(trade_slot, sub_slot);
detail->from_slot = EQEmu::InventoryProfile::CalcSlotId(trade_slot, sub_slot);
detail->to_id = other->CharacterID();
detail->to_slot = Inventory::CalcSlotId(free_slot, sub_slot);
detail->to_slot = EQEmu::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);
@@ -572,17 +572,17 @@ void Client::FinishTrade(Mob* tradingWith, bool finalizer, void* event_entry, st
// step 2a: process stackables
for (int16 trade_slot = EQEmu::legacy::TRADE_BEGIN; trade_slot <= EQEmu::legacy::TRADE_END; ++trade_slot) {
ItemInst* inst = GetInv().GetItem(trade_slot);
EQEmu::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::legacy::SlotCursor) || (partial_slot == INVALID_INDEX))
if ((partial_slot == EQEmu::inventory::slotCursor) || (partial_slot == INVALID_INDEX))
break;
ItemInst* partial_inst = other->GetInv().GetItem(partial_slot);
EQEmu::ItemInstance* partial_inst = other->GetInv().GetItem(partial_slot);
if (!partial_inst)
break;
@@ -654,14 +654,14 @@ 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::legacy::TRADE_END; trade_slot >= EQEmu::legacy::TRADE_BEGIN; --trade_slot) {
ItemInst* inst = GetInv().GetItem(trade_slot);
EQEmu::ItemInstance* inst = GetInv().GetItem(trade_slot);
if (inst && inst->IsStackable()) {
for (int16 bias_slot = EQEmu::legacy::TRADE_BEGIN; bias_slot <= EQEmu::legacy::TRADE_END; ++bias_slot) {
if (bias_slot >= trade_slot)
break;
ItemInst* bias_inst = GetInv().GetItem(bias_slot);
EQEmu::ItemInstance* bias_inst = GetInv().GetItem(bias_slot);
if (!bias_inst || (bias_inst->GetID() != inst->GetID()) || (bias_inst->GetCharges() >= bias_inst->GetItem()->StackSize))
continue;
@@ -707,7 +707,7 @@ void Client::FinishTrade(Mob* tradingWith, bool finalizer, void* event_entry, st
// step 3: process everything else
for (int16 trade_slot = EQEmu::legacy::TRADE_BEGIN; trade_slot <= EQEmu::legacy::TRADE_END; ++trade_slot) {
const ItemInst* inst = m_inv[trade_slot];
const EQEmu::ItemInstance* inst = m_inv[trade_slot];
if (inst) {
Log.Out(Logs::Detail, Logs::Trading, "Giving item %s (%d) in slot %d to %s", inst->GetItem()->Name, inst->GetItem()->ID, trade_slot, other->GetName());
@@ -743,8 +743,8 @@ void Client::FinishTrade(Mob* tradingWith, bool finalizer, void* event_entry, st
// 'step 3' should never really see containers..but, just in case...
//for (uint8 sub_slot = SUB_BEGIN; ((sub_slot < inst->GetItem()->BagSlots) && (sub_slot < EmuConstants::ITEM_CONTAINER_SIZE)); ++sub_slot) {
for (uint8 sub_slot = SUB_INDEX_BEGIN; (sub_slot < EQEmu::legacy::ITEM_CONTAINER_SIZE); ++sub_slot) { // this is to catch ALL items
const ItemInst* bag_inst = inst->GetItem(sub_slot);
for (uint8 sub_slot = EQEmu::inventory::containerBegin; (sub_slot < EQEmu::inventory::ContainerCount); ++sub_slot) { // this is to catch ALL items
const EQEmu::ItemInstance* bag_inst = inst->GetItem(sub_slot);
if (bag_inst) {
detail = new QSTradeItems_Struct;
@@ -821,7 +821,7 @@ 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::legacy::TRADE_BEGIN; trade_slot <= EQEmu::legacy::TRADE_NPC_END; ++trade_slot) {
const ItemInst* trade_inst = m_inv[trade_slot];
const EQEmu::ItemInstance* trade_inst = m_inv[trade_slot];
if(trade_inst) {
auto detail = new QSHandinItems_Struct;
@@ -841,15 +841,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 = SUB_INDEX_BEGIN; sub_slot < trade_inst->GetItem()->BagSlots; ++sub_slot) {
const ItemInst* trade_baginst = trade_inst->GetItem(sub_slot);
for (uint8 sub_slot = EQEmu::inventory::containerBegin; sub_slot < trade_inst->GetItem()->BagSlots; ++sub_slot) {
const EQEmu::ItemInstance* trade_baginst = trade_inst->GetItem(sub_slot);
if(trade_baginst) {
detail = new QSHandinItems_Struct;
strcpy(detail->action_type, "HANDIN");
detail->char_slot = Inventory::CalcSlotId(trade_slot, sub_slot);
detail->char_slot = EQEmu::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);
@@ -874,27 +874,27 @@ void Client::FinishTrade(Mob* tradingWith, bool finalizer, void* event_entry, st
}
std::vector<EQEmu::Any> item_list;
std::list<ItemInst*> items;
std::list<EQEmu::ItemInstance*> items;
for (int i = EQEmu::legacy::TRADE_BEGIN; i <= EQEmu::legacy::TRADE_NPC_END; ++i) {
ItemInst *inst = m_inv.GetItem(i);
EQEmu::ItemInstance *inst = m_inv.GetItem(i);
if(inst) {
items.push_back(inst);
item_list.push_back(inst);
} else {
item_list.push_back((ItemInst*)nullptr);
item_list.push_back((EQEmu::ItemInstance*)nullptr);
continue;
}
const EQEmu::ItemBase* item = inst->GetItem();
const EQEmu::ItemData* item = inst->GetItem();
if(item && quest_npc == false) {
// if it was not a NO DROP or Attuned item (or if a GM is trading), let the NPC have it
if(GetGM() || (item->NoDrop != 0 && inst->IsAttuned() == false)) {
// pets need to look inside bags and try to equip items found there
if (item->IsClassBag() && item->BagSlots > 0) {
for (int16 bslot = SUB_INDEX_BEGIN; bslot < item->BagSlots; bslot++) {
const ItemInst* baginst = inst->GetItem(bslot);
for (int16 bslot = EQEmu::inventory::containerBegin; bslot < item->BagSlots; bslot++) {
const EQEmu::ItemInstance* baginst = inst->GetItem(bslot);
if (baginst) {
const EQEmu::ItemBase* bagitem = baginst->GetItem();
const EQEmu::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);
@@ -947,7 +947,7 @@ void Client::FinishTrade(Mob* tradingWith, bool finalizer, void* event_entry, st
tradingWith->FaceTarget(this);
}
ItemInst *insts[4] = { 0 };
EQEmu::ItemInstance *insts[4] = { 0 };
for (int i = EQEmu::legacy::TRADE_BEGIN; i <= EQEmu::legacy::TRADE_NPC_END; ++i) {
insts[i - EQEmu::legacy::TRADE_BEGIN] = m_inv.PopItem(i);
database.SaveInventory(CharacterID(), nullptr, i);
@@ -969,7 +969,7 @@ bool Client::CheckTradeLoreConflict(Client* other)
return true;
// Move each trade slot into free inventory slot
for (int16 i = EQEmu::legacy::TRADE_BEGIN; i <= EQEmu::legacy::TRADE_END; i++){
const ItemInst* inst = m_inv[i];
const EQEmu::ItemInstance* inst = m_inv[i];
if (inst && inst->GetItem()) {
if (other->CheckLoreConflict(inst->GetItem()))
@@ -978,7 +978,7 @@ bool Client::CheckTradeLoreConflict(Client* other)
}
for (int16 i = EQEmu::legacy::TRADE_BAGS_BEGIN; i <= EQEmu::legacy::TRADE_BAGS_END; i++){
const ItemInst* inst = m_inv[i];
const EQEmu::ItemInstance* inst = m_inv[i];
if (inst && inst->GetItem()) {
if (other->CheckLoreConflict(inst->GetItem()))
@@ -1158,14 +1158,14 @@ void Client::SendTraderItem(uint32 ItemID, uint16 Quantity) {
std::string Packet;
int16 FreeSlotID=0;
const EQEmu::ItemBase* item = database.GetItem(ItemID);
const EQEmu::ItemData* item = database.GetItem(ItemID);
if(!item){
Log.Out(Logs::Detail, Logs::Trading, "Bogus item deleted in Client::SendTraderItem!\n");
return;
}
ItemInst* inst = database.CreateItem(item, Quantity);
EQEmu::ItemInstance* inst = database.CreateItem(item, Quantity);
if (inst)
{
@@ -1183,7 +1183,7 @@ void Client::SendTraderItem(uint32 ItemID, uint16 Quantity) {
void Client::SendSingleTraderItem(uint32 CharID, int SerialNumber) {
ItemInst* inst= database.LoadSingleTraderItem(CharID, SerialNumber);
EQEmu::ItemInstance* inst= database.LoadSingleTraderItem(CharID, SerialNumber);
if(inst) {
SendItemPacket(30, inst, ItemPacketMerchant); // MainCursor?
safe_delete(inst);
@@ -1192,7 +1192,7 @@ void Client::SendSingleTraderItem(uint32 CharID, int SerialNumber) {
}
void Client::BulkSendTraderInventory(uint32 char_id) {
const EQEmu::ItemBase *item;
const EQEmu::ItemData *item;
TraderCharges_Struct* TraderItems = database.LoadTraderItemWithCharges(char_id);
@@ -1204,7 +1204,7 @@ void Client::BulkSendTraderInventory(uint32 char_id) {
item=database.GetItem(TraderItems->ItemID[i]);
if (item && (item->NoDrop!=0)) {
ItemInst* inst = database.CreateItem(item);
EQEmu::ItemInstance* inst = database.CreateItem(item);
if (inst) {
inst->SetSerialNumber(TraderItems->SerialNumber[i]);
if(TraderItems->Charges[i] > 0)
@@ -1230,14 +1230,14 @@ void Client::BulkSendTraderInventory(uint32 char_id) {
uint32 Client::FindTraderItemSerialNumber(int32 ItemID) {
ItemInst* item = nullptr;
EQEmu::ItemInstance* item = nullptr;
uint16 SlotID = 0;
for (int i = EQEmu::legacy::GENERAL_BEGIN; i <= EQEmu::legacy::GENERAL_END; i++){
item = this->GetInv().GetItem(i);
if (item && item->GetItem()->ID == 17899){ //Traders Satchel
for (int x = SUB_INDEX_BEGIN; x < EQEmu::legacy::ITEM_CONTAINER_SIZE; x++) {
for (int x = EQEmu::inventory::containerBegin; x < EQEmu::inventory::ContainerCount; x++) {
// we already have the parent bag and a contents iterator..why not just iterate the bag!??
SlotID = Inventory::CalcSlotId(i, x);
SlotID = EQEmu::InventoryProfile::CalcSlotId(i, x);
item = this->GetInv().GetItem(SlotID);
if (item) {
if (item->GetID() == ItemID)
@@ -1251,16 +1251,16 @@ uint32 Client::FindTraderItemSerialNumber(int32 ItemID) {
return 0;
}
ItemInst* Client::FindTraderItemBySerialNumber(int32 SerialNumber){
EQEmu::ItemInstance* Client::FindTraderItemBySerialNumber(int32 SerialNumber){
ItemInst* item = nullptr;
EQEmu::ItemInstance* item = nullptr;
uint16 SlotID = 0;
for (int i = EQEmu::legacy::GENERAL_BEGIN; i <= EQEmu::legacy::GENERAL_END; i++){
item = this->GetInv().GetItem(i);
if(item && item->GetItem()->ID == 17899){ //Traders Satchel
for (int x = SUB_INDEX_BEGIN; x < EQEmu::legacy::ITEM_CONTAINER_SIZE; x++) {
for (int x = EQEmu::inventory::containerBegin; x < EQEmu::inventory::ContainerCount; x++) {
// we already have the parent bag and a contents iterator..why not just iterate the bag!??
SlotID = Inventory::CalcSlotId(i, x);
SlotID = EQEmu::InventoryProfile::CalcSlotId(i, x);
item = this->GetInv().GetItem(SlotID);
if(item) {
if(item->GetSerialNumber() == SerialNumber)
@@ -1277,7 +1277,7 @@ ItemInst* Client::FindTraderItemBySerialNumber(int32 SerialNumber){
GetItems_Struct* Client::GetTraderItems(){
const ItemInst* item = nullptr;
const EQEmu::ItemInstance* item = nullptr;
uint16 SlotID = 0;
auto gis = new GetItems_Struct;
@@ -1289,8 +1289,8 @@ GetItems_Struct* Client::GetTraderItems(){
for (int i = EQEmu::legacy::GENERAL_BEGIN; i <= EQEmu::legacy::GENERAL_END; i++) {
item = this->GetInv().GetItem(i);
if(item && item->GetItem()->ID == 17899){ //Traders Satchel
for (int x = SUB_INDEX_BEGIN; x < EQEmu::legacy::ITEM_CONTAINER_SIZE; x++) {
SlotID = Inventory::CalcSlotId(i, x);
for (int x = EQEmu::inventory::containerBegin; x < EQEmu::inventory::ContainerCount; x++) {
SlotID = EQEmu::InventoryProfile::CalcSlotId(i, x);
item = this->GetInv().GetItem(SlotID);
@@ -1308,13 +1308,13 @@ GetItems_Struct* Client::GetTraderItems(){
uint16 Client::FindTraderItem(int32 SerialNumber, uint16 Quantity){
const ItemInst* item= nullptr;
const EQEmu::ItemInstance* item= nullptr;
uint16 SlotID = 0;
for (int i = EQEmu::legacy::GENERAL_BEGIN; i <= EQEmu::legacy::GENERAL_END; i++) {
item = this->GetInv().GetItem(i);
if(item && item->GetItem()->ID == 17899){ //Traders Satchel
for (int x = SUB_INDEX_BEGIN; x < EQEmu::legacy::ITEM_CONTAINER_SIZE; x++){
SlotID = Inventory::CalcSlotId(i, x);
for (int x = EQEmu::inventory::containerBegin; x < EQEmu::inventory::ContainerCount; x++){
SlotID = EQEmu::InventoryProfile::CalcSlotId(i, x);
item = this->GetInv().GetItem(SlotID);
@@ -1370,7 +1370,7 @@ void Client::NukeTraderItem(uint16 Slot,int16 Charges,uint16 Quantity,Client* Cu
}
// This updates the trader. Removes it from his trading bags.
//
const ItemInst* Inst = m_inv[Slot];
const EQEmu::ItemInstance* Inst = m_inv[Slot];
database.SaveInventory(CharacterID(), Inst, Slot);
@@ -1412,7 +1412,7 @@ void Client::TraderUpdate(uint16 SlotID,uint32 TraderID){
void Client::FindAndNukeTraderItem(int32 SerialNumber, uint16 Quantity, Client* Customer, uint16 TraderSlot){
const ItemInst* item= nullptr;
const EQEmu::ItemInstance* item= nullptr;
bool Stackable = false;
int16 Charges=0;
@@ -1564,7 +1564,7 @@ void Client::BuyTraderItem(TraderBuy_Struct* tbs, Client* Trader, const EQApplic
outtbs->ItemID = tbs->ItemID;
const ItemInst* BuyItem = nullptr;
const EQEmu::ItemInstance* BuyItem = nullptr;
uint32 ItemID = 0;
if (ClientVersion() >= EQEmu::versions::ClientVersion::RoF)
@@ -2027,11 +2027,11 @@ static void UpdateTraderCustomerItemsAdded(uint32 CustomerID, TraderCharges_Stru
if(!Customer) return;
const EQEmu::ItemBase *item = database.GetItem(ItemID);
const EQEmu::ItemData *item = database.GetItem(ItemID);
if(!item) return;
ItemInst* inst = database.CreateItem(item);
EQEmu::ItemInstance* inst = database.CreateItem(item);
if(!inst) return;
@@ -2071,7 +2071,7 @@ static void UpdateTraderCustomerPriceChanged(uint32 CustomerID, TraderCharges_St
if(!Customer) return;
const EQEmu::ItemBase *item = database.GetItem(ItemID);
const EQEmu::ItemData *item = database.GetItem(ItemID);
if(!item) return;
@@ -2112,7 +2112,7 @@ static void UpdateTraderCustomerPriceChanged(uint32 CustomerID, TraderCharges_St
Log.Out(Logs::Detail, Logs::Trading, "Sending price updates to customer %s", Customer->GetName());
ItemInst* inst = database.CreateItem(item);
EQEmu::ItemInstance* inst = database.CreateItem(item);
if(!inst) return;
@@ -2230,7 +2230,7 @@ void Client::HandleTraderPriceUpdate(const EQApplicationPacket *app) {
}
const EQEmu::ItemBase *item = 0;
const EQEmu::ItemData *item = 0;
if(IDOfItemToAdd)
item = database.GetItem(IDOfItemToAdd);
@@ -2396,7 +2396,7 @@ void Client::SendBuyerResults(char* searchString, uint32 searchID) {
char *buf = (char *)outapp->pBuffer;
const EQEmu::ItemBase* item = database.GetItem(itemID);
const EQEmu::ItemData* item = database.GetItem(itemID);
if(!item) {
safe_delete(outapp);
@@ -2492,7 +2492,7 @@ void Client::ShowBuyLines(const EQApplicationPacket *app) {
char *Buf = (char *)outapp->pBuffer;
const EQEmu::ItemBase* item = database.GetItem(ItemID);
const EQEmu::ItemData* item = database.GetItem(ItemID);
if(!item) {
safe_delete(outapp);
@@ -2536,7 +2536,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::ItemBase *item = database.GetItem(ItemID);
const EQEmu::ItemData *item = database.GetItem(ItemID);
if(!item || !Quantity || !Price || !QtyBuyerWants) return;
@@ -2602,7 +2602,7 @@ void Client::SellToBuyer(const EQApplicationPacket *app) {
return;
}
ItemInst* ItemToTransfer = m_inv.PopItem(SellerSlot);
EQEmu::ItemInstance* ItemToTransfer = m_inv.PopItem(SellerSlot);
if(!ItemToTransfer || !Buyer->MoveItemToInventory(ItemToTransfer, true)) {
Log.Out(Logs::General, Logs::Error, "Unexpected error while moving item from seller to buyer.");
@@ -2648,7 +2648,7 @@ void Client::SellToBuyer(const EQApplicationPacket *app) {
return;
}
ItemInst* ItemToTransfer = m_inv.PopItem(SellerSlot);
EQEmu::ItemInstance* ItemToTransfer = m_inv.PopItem(SellerSlot);
if(!ItemToTransfer) {
Log.Out(Logs::General, Logs::Error, "Unexpected error while moving item from seller to buyer.");
@@ -2927,7 +2927,7 @@ void Client::UpdateBuyLine(const EQApplicationPacket *app) {
/*uint32 UnknownZ =*/ VARSTRUCT_SKIP_TYPE(uint32, Buf); //unused
uint32 ItemCount = VARSTRUCT_DECODE_TYPE(uint32, Buf);
const EQEmu::ItemBase *item = database.GetItem(ItemID);
const EQEmu::ItemData *item = database.GetItem(ItemID);
if(!item) return;
@@ -2991,7 +2991,7 @@ void Client::BuyerItemSearch(const EQApplicationPacket *app) {
BuyerItemSearchResults_Struct* bisr = (BuyerItemSearchResults_Struct*)outapp->pBuffer;
const EQEmu::ItemBase* item = 0;
const EQEmu::ItemData* item = 0;
int Count=0;
zone/tribute.cpp
+2 -2
View File
@@ -161,7 +161,7 @@ void Client::DoTributeUpdate() {
uint32 item_id = tier.tribute_item_id;
//summon the item for them
const ItemInst* inst = database.CreateItem(item_id, 1);
const EQEmu::ItemInstance* inst = database.CreateItem(item_id, 1);
if(inst == nullptr)
continue;
@@ -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 ItemInst*inst = m_inv[slot];
const EQEmu::ItemInstance*inst = m_inv[slot];
if(inst == nullptr)
return(0);
zone/tune.cpp
+25 -25
View File
@@ -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::legacy::SlotPrimary;
int Hand = EQEmu::inventory::slotPrimary;
if (!other)
return 0;
ItemInst* weapon;
weapon = GetInv().GetItem(EQEmu::legacy::SlotPrimary);
EQEmu::ItemInstance* weapon;
weapon = GetInv().GetItem(EQEmu::inventory::slotPrimary);
if(weapon != nullptr) {
if (!weapon->IsWeapon()) {
@@ -628,9 +628,9 @@ int32 Client::GetMeleeDamage(Mob* other, bool GetMinDamage)
int ucDamageBonus = 0;
if (Hand == EQEmu::legacy::SlotPrimary && GetLevel() >= 28 && IsWarriorClass())
if (Hand == EQEmu::inventory::slotPrimary && GetLevel() >= 28 && IsWarriorClass())
{
ucDamageBonus = GetWeaponDamageBonus(weapon ? weapon->GetItem() : (const EQEmu::ItemBase*) nullptr);
ucDamageBonus = GetWeaponDamageBonus(weapon ? weapon->GetItem() : (const EQEmu::ItemData*) nullptr);
min_hit += (int) ucDamageBonus;
max_hit += (int) ucDamageBonus;
@@ -661,25 +661,25 @@ void Mob::Tune_FindAccuaryByHitChance(Mob* defender, Mob *attacker, float hit_ch
EQEmu::skills::SkillType skillinuse = EQEmu::skills::SkillHandtoHand;
if (attacker->IsClient())
{//Will check first equiped weapon for skill. Ie. remove wepaons to assess bow.
ItemInst* weapon;
weapon = attacker->CastToClient()->GetInv().GetItem(EQEmu::legacy::SlotPrimary);
EQEmu::ItemInstance* weapon;
weapon = attacker->CastToClient()->GetInv().GetItem(EQEmu::inventory::slotPrimary);
if(weapon && weapon->IsWeapon()){
attacker->CastToClient()->AttackAnimation(skillinuse, EQEmu::legacy::SlotPrimary, weapon);
attacker->CastToClient()->AttackAnimation(skillinuse, EQEmu::inventory::slotPrimary, weapon);
}
else {
weapon = attacker->CastToClient()->GetInv().GetItem(EQEmu::legacy::SlotSecondary);
weapon = attacker->CastToClient()->GetInv().GetItem(EQEmu::inventory::slotSecondary);
if (weapon && weapon->IsWeapon())
attacker->CastToClient()->AttackAnimation(skillinuse, EQEmu::legacy::SlotSecondary, weapon);
attacker->CastToClient()->AttackAnimation(skillinuse, EQEmu::inventory::slotSecondary, weapon);
else {
weapon = attacker->CastToClient()->GetInv().GetItem(EQEmu::legacy::SlotRange);
weapon = attacker->CastToClient()->GetInv().GetItem(EQEmu::inventory::slotRange);
if (weapon && weapon->IsWeapon())
attacker->CastToClient()->AttackAnimation(skillinuse, EQEmu::legacy::SlotRange, weapon);
attacker->CastToClient()->AttackAnimation(skillinuse, EQEmu::inventory::slotRange, weapon);
}
}
}
tmp_hit_chance = Tune_CheckHitChance(defender, attacker, skillinuse, EQEmu::legacy::SlotPrimary, 0, 0, 0, avoid_override);
tmp_hit_chance = Tune_CheckHitChance(defender, attacker, skillinuse, EQEmu::inventory::slotPrimary, 0, 0, 0, avoid_override);
Message(0, "#Tune - Begin Parse [Interval %i Max Loop Iterations %i]", interval, max_loop);
@@ -691,7 +691,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::legacy::SlotPrimary, 0, false, 0, avoid_override, add_acc);
tmp_hit_chance = Tune_CheckHitChance(defender, attacker, skillinuse, EQEmu::inventory::slotPrimary, 0, false, 0, avoid_override, add_acc);
if (Msg >= 3)
Message(15, "#Tune - Processing... [%i] [ACCURACY %i] Hit Chance %.2f ",j,add_acc,tmp_hit_chance);
@@ -706,7 +706,7 @@ void Mob::Tune_FindAccuaryByHitChance(Mob* defender, Mob *attacker, float hit_ch
if (end){
Tune_CheckHitChance(defender, attacker, skillinuse, EQEmu::legacy::SlotPrimary, 0, Msg, 0, avoid_override);//Display Stat Report
Tune_CheckHitChance(defender, attacker, skillinuse, EQEmu::inventory::slotPrimary, 0, Msg, 0, avoid_override);//Display Stat Report
Message(0, " ");
@@ -741,25 +741,25 @@ void Mob::Tune_FindAvoidanceByHitChance(Mob* defender, Mob *attacker, float hit_
EQEmu::skills::SkillType skillinuse = EQEmu::skills::SkillHandtoHand;
if (attacker->IsClient())
{//Will check first equiped weapon for skill. Ie. remove wepaons to assess bow.
ItemInst* weapon;
weapon = attacker->CastToClient()->GetInv().GetItem(EQEmu::legacy::SlotPrimary);
EQEmu::ItemInstance* weapon;
weapon = attacker->CastToClient()->GetInv().GetItem(EQEmu::inventory::slotPrimary);
if(weapon && weapon->IsWeapon()){
attacker->CastToClient()->AttackAnimation(skillinuse, EQEmu::legacy::SlotPrimary, weapon);
attacker->CastToClient()->AttackAnimation(skillinuse, EQEmu::inventory::slotPrimary, weapon);
}
else {
weapon = attacker->CastToClient()->GetInv().GetItem(EQEmu::legacy::SlotSecondary);
weapon = attacker->CastToClient()->GetInv().GetItem(EQEmu::inventory::slotSecondary);
if (weapon && weapon->IsWeapon())
attacker->CastToClient()->AttackAnimation(skillinuse, EQEmu::legacy::SlotSecondary, weapon);
attacker->CastToClient()->AttackAnimation(skillinuse, EQEmu::inventory::slotSecondary, weapon);
else {
weapon = attacker->CastToClient()->GetInv().GetItem(EQEmu::legacy::SlotRange);
weapon = attacker->CastToClient()->GetInv().GetItem(EQEmu::inventory::slotRange);
if (weapon && weapon->IsWeapon())
attacker->CastToClient()->AttackAnimation(skillinuse, EQEmu::legacy::SlotRange, weapon);
attacker->CastToClient()->AttackAnimation(skillinuse, EQEmu::inventory::slotRange, weapon);
}
}
}
tmp_hit_chance = Tune_CheckHitChance(defender, attacker, skillinuse, EQEmu::legacy::SlotPrimary, 0, 0, acc_override, 0);
tmp_hit_chance = Tune_CheckHitChance(defender, attacker, skillinuse, EQEmu::inventory::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);
@@ -769,7 +769,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::legacy::SlotPrimary, 0, 0, acc_override, 0, 0, add_avoid);
tmp_hit_chance = Tune_CheckHitChance(defender, attacker, skillinuse, EQEmu::inventory::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);
@@ -784,7 +784,7 @@ void Mob::Tune_FindAvoidanceByHitChance(Mob* defender, Mob *attacker, float hit_
if (end){
Tune_CheckHitChance(defender, attacker, skillinuse, EQEmu::legacy::SlotPrimary, 0, Msg, acc_override, 0);//Display Stat Report
Tune_CheckHitChance(defender, attacker, skillinuse, EQEmu::inventory::slotPrimary, 0, Msg, acc_override, 0);//Display Stat Report
Message(0, " ");
zone/worldserver.cpp
+5 -3
View File
@@ -722,10 +722,12 @@ void WorldServer::Process() {
Log.Out(Logs::Detail, Logs::Spells, "OP_RezzComplete received in zone %s for corpse %s",
zone->GetShortName(), srs->rez.corpse_name);
Log.Out(Logs::Detail, Logs::Spells, "Found corpse. Marking corpse as rezzed.");
Log.Out(Logs::Detail, Logs::Spells, "Found corpse. Marking corpse as rezzed if needed.");
// I don't know why Rezzed is not set to true in CompleteRezz().
corpse->IsRezzed(true);
corpse->CompleteResurrection();
if (!IsEffectInSpell(srs->rez.spellid, SE_SummonToCorpse)) {
corpse->IsRezzed(true);
corpse->CompleteResurrection();
}
}
}
zone/zone.cpp
+22 -21
View File
@@ -100,9 +100,6 @@ bool Zone::Bootup(uint32 iZoneID, uint32 iInstanceID, bool iStaticZone) {
worldserver.SetZoneData(0);
return false;
}
zone->zonemap = Map::LoadMapFile(zone->map_name);
zone->watermap = WaterMap::LoadWaterMapfile(zone->map_name);
zone->pathing = PathManager::LoadPathFile(zone->map_name);
std::string tmp;
if (database.GetVariable("loglevel", tmp)) {
@@ -251,12 +248,12 @@ bool Zone::LoadZoneObjects()
data.tilt_y = atof(row[18]);
data.unknown084 = 0;
ItemInst *inst = nullptr;
EQEmu::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 ItemInst(ItemInstWorldContainer);
inst = new EQEmu::ItemInstance(ItemInstWorldContainer);
} else {
// Groundspawn object
inst = database.CreateItem(itemid);
@@ -264,7 +261,7 @@ bool Zone::LoadZoneObjects()
// Father Nitwit's fix... not perfect...
if (inst == nullptr && type != OT_DROPPEDITEM) {
inst = new ItemInst(ItemInstWorldContainer);
inst = new EQEmu::ItemInstance(ItemInstWorldContainer);
}
// Load child objects if container
@@ -297,7 +294,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){
ItemInst* inst = nullptr;
EQEmu::ItemInstance* inst = nullptr;
inst = database.CreateItem(groundspawn.spawn[gsindex].item);
gsnumber=groundspawn.spawn[gsindex].max_allowed;
ix=0;
@@ -877,6 +874,23 @@ Zone::~Zone() {
//Modified for timezones.
bool Zone::Init(bool iStaticZone) {
SetStaticZone(iStaticZone);
//load the zone config file.
if (!LoadZoneCFG(zone->GetShortName(), zone->GetInstanceVersion(), true)) // try loading the zone name...
LoadZoneCFG(zone->GetFileName(), zone->GetInstanceVersion()); // if that fails, try the file name, then load defaults
if(RuleManager::Instance()->GetActiveRulesetID() != default_ruleset)
{
std::string r_name = RuleManager::Instance()->GetRulesetName(&database, default_ruleset);
if(r_name.size() > 0)
{
RuleManager::Instance()->LoadRules(&database, r_name.c_str());
}
}
zone->zonemap = Map::LoadMapFile(zone->map_name);
zone->watermap = WaterMap::LoadWaterMapfile(zone->map_name);
zone->pathing = PathManager::LoadPathFile(zone->map_name);
Log.Out(Logs::General, Logs::Status, "Loading spawn conditions...");
if(!spawn_conditions.LoadSpawnConditions(short_name, instanceid)) {
@@ -969,19 +983,6 @@ bool Zone::Init(bool iStaticZone) {
petition_list.ClearPetitions();
petition_list.ReadDatabase();
//load the zone config file.
if (!LoadZoneCFG(zone->GetShortName(), zone->GetInstanceVersion(), true)) // try loading the zone name...
LoadZoneCFG(zone->GetFileName(), zone->GetInstanceVersion()); // if that fails, try the file name, then load defaults
if(RuleManager::Instance()->GetActiveRulesetID() != default_ruleset)
{
std::string r_name = RuleManager::Instance()->GetRulesetName(&database, default_ruleset);
if(r_name.size() > 0)
{
RuleManager::Instance()->LoadRules(&database, r_name.c_str());
}
}
Log.Out(Logs::General, Logs::Status, "Loading timezone data...");
zone->zone_time.setEQTimeZone(database.GetZoneTZ(zoneid, GetInstanceVersion()));
@@ -1166,7 +1167,7 @@ bool Zone::Process() {
if(spawn2_timer.Check()) {
LinkedListIterator<Spawn2*> iterator(spawn2_list);
Inventory::CleanDirty();
EQEmu::InventoryProfile::CleanDirty();
iterator.Reset();
while (iterator.MoreElements()) {
zone/zonedb.cpp
+23 -22
View File
@@ -1,7 +1,7 @@
#include "../common/eqemu_logsys.h"
#include "../common/extprofile.h"
#include "../common/item.h"
#include "../common/item_instance.h"
#include "../common/rulesys.h"
#include "../common/string_util.h"
@@ -468,7 +468,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, ItemInst* container)
void ZoneDatabase::LoadWorldContainer(uint32 parentid, EQEmu::ItemInstance* container)
{
if (!container) {
Log.Out(Logs::General, Logs::Error, "Programming error: LoadWorldContainer passed nullptr pointer");
@@ -487,7 +487,7 @@ void ZoneDatabase::LoadWorldContainer(uint32 parentid, ItemInst* container)
uint8 index = (uint8)atoi(row[0]);
uint32 item_id = (uint32)atoi(row[1]);
int8 charges = (int8)atoi(row[2]);
uint32 aug[EQEmu::legacy::ITEM_COMMON_SIZE];
uint32 aug[EQEmu::inventory::SocketCount];
aug[0] = (uint32)atoi(row[3]);
aug[1] = (uint32)atoi(row[4]);
aug[2] = (uint32)atoi(row[5]);
@@ -495,9 +495,9 @@ void ZoneDatabase::LoadWorldContainer(uint32 parentid, ItemInst* container)
aug[4] = (uint32)atoi(row[7]);
aug[5] = (uint32)atoi(row[8]);
ItemInst* inst = database.CreateItem(item_id, charges);
EQEmu::ItemInstance* inst = database.CreateItem(item_id, charges);
if (inst && inst->GetItem()->IsClassCommon()) {
for (int i = AUG_INDEX_BEGIN; i < EQEmu::legacy::ITEM_COMMON_SIZE; i++)
for (int i = EQEmu::inventory::socketBegin; i < EQEmu::inventory::SocketCount; i++)
if (aug[i])
inst->PutAugment(&database, i, aug[i]);
// Put item inside world container
@@ -509,7 +509,7 @@ void ZoneDatabase::LoadWorldContainer(uint32 parentid, ItemInst* container)
}
// 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 ItemInst* container)
void ZoneDatabase::SaveWorldContainer(uint32 zone_id, uint32 parent_id, const EQEmu::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
@@ -520,18 +520,18 @@ void ZoneDatabase::SaveWorldContainer(uint32 zone_id, uint32 parent_id, const It
DeleteWorldContainer(parent_id,zone_id);
// Save all 10 items, if they exist
for (uint8 index = SUB_INDEX_BEGIN; index < EQEmu::legacy::ITEM_CONTAINER_SIZE; index++) {
for (uint8 index = EQEmu::inventory::containerBegin; index < EQEmu::inventory::ContainerCount; index++) {
ItemInst* inst = container->GetItem(index);
EQEmu::ItemInstance* inst = container->GetItem(index);
if (!inst)
continue;
uint32 item_id = inst->GetItem()->ID;
uint32 augslot[EQEmu::legacy::ITEM_COMMON_SIZE] = { NO_ITEM, NO_ITEM, NO_ITEM, NO_ITEM, NO_ITEM, NO_ITEM };
uint32 augslot[EQEmu::inventory::SocketCount] = { 0, 0, 0, 0, 0, 0 };
if (inst->IsType(EQEmu::item::ItemClassCommon)) {
for (int i = AUG_INDEX_BEGIN; i < EQEmu::legacy::ITEM_COMMON_SIZE; i++) {
ItemInst *auginst=inst->GetAugment(i);
for (int i = EQEmu::inventory::socketBegin; i < EQEmu::inventory::SocketCount; i++) {
EQEmu::ItemInstance *auginst=inst->GetAugment(i);
augslot[i]=(auginst && auginst->GetItem()) ? auginst->GetItem()->ID : 0;
}
}
@@ -611,7 +611,7 @@ TraderCharges_Struct* ZoneDatabase::LoadTraderItemWithCharges(uint32 char_id)
return loadti;
}
ItemInst* ZoneDatabase::LoadSingleTraderItem(uint32 CharID, int SerialNumber) {
EQEmu::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);
@@ -629,7 +629,7 @@ ItemInst* ZoneDatabase::LoadSingleTraderItem(uint32 CharID, int SerialNumber) {
int Charges = atoi(row[3]);
int Cost = atoi(row[4]);
const EQEmu::ItemBase *item = database.GetItem(ItemID);
const EQEmu::ItemData *item = database.GetItem(ItemID);
if(!item) {
Log.Out(Logs::Detail, Logs::Trading, "Unable to create item\n");
@@ -640,7 +640,7 @@ ItemInst* ZoneDatabase::LoadSingleTraderItem(uint32 CharID, int SerialNumber) {
if (item->NoDrop == 0)
return nullptr;
ItemInst* inst = database.CreateItem(item);
EQEmu::ItemInstance* inst = database.CreateItem(item);
if(!inst) {
Log.Out(Logs::Detail, Logs::Trading, "Unable to create item instance\n");
fflush(stdout);
@@ -684,7 +684,7 @@ void ZoneDatabase::UpdateTraderItemPrice(int CharID, uint32 ItemID, uint32 Charg
Log.Out(Logs::Detail, Logs::Trading, "ZoneDatabase::UpdateTraderPrice(%i, %i, %i, %i)", CharID, ItemID, Charges, NewPrice);
const EQEmu::ItemBase *item = database.GetItem(ItemID);
const EQEmu::ItemData *item = database.GetItem(ItemID);
if(!item)
return;
@@ -1197,7 +1197,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::ItemBase* item_data = database.GetItem(atoi(row[r]));
const EQEmu::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
@@ -1249,7 +1249,7 @@ bool ZoneDatabase::LoadCharacterPotions(uint32 character_id, PlayerProfile_Struc
for (auto row = results.begin(); row != results.end(); ++row) {
i = atoi(row[0]);
const EQEmu::ItemBase *item_data = database.GetItem(atoi(row[1]));
const EQEmu::ItemData *item_data = database.GetItem(atoi(row[1]));
if (!item_data)
continue;
pp->potionbelt.Items[i].ID = item_data->ID;
@@ -2092,7 +2092,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 = EQEmu::textures::textureBegin; index <= EQEmu::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]);
@@ -2102,7 +2102,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::TextureChest; index < EQEmu::textures::TextureCount; index++) {
for (int index = EQEmu::textures::armorChest; index < EQEmu::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...
}
}
@@ -2307,7 +2307,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::TextureChest; index <= EQEmu::textures::LastTexture; index++)
for (int index = EQEmu::textures::armorChest; index <= EQEmu::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, "
@@ -2327,7 +2327,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 = EQEmu::textures::textureBegin; index <= EQEmu::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]);
@@ -3122,7 +3122,8 @@ void ZoneDatabase::LoadBuffs(Client *client)
buffs[slot_id].instrument_mod = instrument_mod;
}
max_slots = client->GetMaxBuffSlots();
// We load up to the most our client supports
max_slots = EQEmu::constants::Lookup(client->ClientVersion())->LongBuffs;
for (int index = 0; index < max_slots; ++index) {
if (!IsValidSpell(buffs[index].spellid))
continue;
zone/zonedb.h
+12 -7
View File
@@ -16,7 +16,6 @@ class NPC;
class Petition;
class Spawn2;
class SpawnGroupList;
class ItemInst;
struct CharacterEventLog_Struct;
struct Door;
struct ExtendedProfile_Struct;
@@ -24,6 +23,12 @@ struct NPCType;
struct PlayerCorpse_Struct;
struct ZonePoint;
struct npcDecayTimes_Struct;
namespace EQEmu
{
class ItemInstance;
}
template <class TYPE> class LinkedList;
//#include "doors.h"
@@ -224,11 +229,11 @@ public:
virtual ~ZoneDatabase();
/* Objects and World Containers */
void LoadWorldContainer(uint32 parentid, ItemInst* container);
void SaveWorldContainer(uint32 zone_id, uint32 parent_id, const ItemInst* container);
void LoadWorldContainer(uint32 parentid, EQEmu::ItemInstance* container);
void SaveWorldContainer(uint32 zone_id, uint32 parent_id, const EQEmu::ItemInstance* container);
void DeleteWorldContainer(uint32 parent_id,uint32 zone_id);
uint32 AddObject(uint32 type, uint32 icon, const Object_Struct& object, const ItemInst* inst);
void UpdateObject(uint32 id, uint32 type, uint32 icon, const Object_Struct& object, const ItemInst* inst);
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);
void DeleteObject(uint32 id);
Ground_Spawns* LoadGroundSpawns(uint32 zone_id, int16 version, Ground_Spawns* gs);
@@ -239,7 +244,7 @@ public:
void DeleteTraderItem(uint32 char_id);
void DeleteTraderItem(uint32 char_id,uint16 slot_id);
ItemInst* LoadSingleTraderItem(uint32 char_id, int uniqueid);
EQEmu::ItemInstance* LoadSingleTraderItem(uint32 char_id, int uniqueid);
Trader_Struct* LoadTraderItem(uint32 char_id);
TraderCharges_Struct* LoadTraderItemWithCharges(uint32 char_id);
@@ -427,7 +432,7 @@ public:
void DeleteMerchantTemp(uint32 npcid, uint32 slot);
/* Tradeskills */
bool GetTradeRecipe(const ItemInst* container, uint8 c_type, uint32 some_id, uint32 char_id, DBTradeskillRecipe_Struct *spec);
bool GetTradeRecipe(const EQEmu::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
+1 -1
View File
@@ -28,7 +28,7 @@ spawn2 mediumblob, npcs mediumblob, npc_loot mediumblob, gmspawntype mediumblob,
#define ZONEDUMP_H
#include "../common/faction.h"
#include "../common/eq_packet_structs.h"
#include "../common/item.h"
#include "../common/inventory_profile.h"
#pragma pack(1)