void Container::LoadFromDB(Field* fields)
{
uint32 itemid = fields[2].GetUInt32();
m_itemProto = ItemPrototypeStorage.LookupEntry(itemid);
ARCEMU_ASSERT(m_itemProto != NULL);
SetEntry(itemid);
SetCreatorGUID(fields[5].GetUInt32());
SetStackCount(1);
SetUInt32Value(ITEM_FIELD_FLAGS, fields[8].GetUInt32());
SetItemRandomPropertyId(fields[9].GetUInt32());
SetDurabilityMax(m_itemProto->MaxDurability);
SetDurability(fields[12].GetUInt32());
SetNumSlots(m_itemProto->ContainerSlots);
m_Slot = new Item*[m_itemProto->ContainerSlots];
memset(m_Slot, 0, sizeof(Item*) * (m_itemProto->ContainerSlots));
}
void Totem::SetOwner(Unit* owner)
{
SetCreatorGUID(owner->GetGUID());
SetOwnerGUID(owner->GetGUID());
setFaction(owner->getFaction());
SetLevel(owner->getLevel());
}
void Minion::InitStats(uint32 duration) {
TempSummon::InitStats(duration);
SetReactState(REACT_PASSIVE);
SetCreatorGUID(m_owner->GetGUID());
setFaction(m_owner->getFaction());
m_owner->SetMinion(this, true, PET_SLOT_UNK_SLOT);
}
void Totem::SetOwner(uint64 guid)
{
SetCreatorGUID(guid);
SetOwnerGUID(guid);
if (Unit *owner = GetOwner())
{
this->setFaction(owner->getFaction());
this->SetLevel(owner->getLevel());
}
}
void Minion::InitStats(uint32 duration)
{
TempSummon::InitStats(duration);
SetReactState(REACT_PASSIVE);
SetCreatorGUID(GetOwner()->GetGUID());
setFaction(GetOwner()->getFaction());
GetOwner()->SetMinion(this, true);
}
bool Pet::LoadPetFromDB(Player* owner, uint32 petentry, uint32 petnumber, bool current)
{
m_loading = true;
uint32 ownerid = owner->GetGUIDLow();
QueryResult result;
if (petnumber)
// known petnumber entry 0 1 2(?) 3 4 5 6 7 8 9 10 11 12 13 14 15 16
result = CharacterDatabase.PQuery("SELECT id, entry, owner, modelid, level, exp, Reactstate, slot, name, renamed, curhealth, curmana, curhappiness, abdata, savetime, CreatedBySpell, PetType "
"FROM character_pet WHERE owner = '%u' AND id = '%u'",
ownerid, petnumber);
else if (current)
// current pet (slot 0) 0 1 2(?) 3 4 5 6 7 8 9 10 11 12 13 14 15 16
result = CharacterDatabase.PQuery("SELECT id, entry, owner, modelid, level, exp, Reactstate, slot, name, renamed, curhealth, curmana, curhappiness, abdata, savetime, CreatedBySpell, PetType "
"FROM character_pet WHERE owner = '%u' AND slot = '%u'",
ownerid, PET_SAVE_AS_CURRENT);
else if (petentry)
// known petentry entry (unique for summoned pet, but non unique for hunter pet (only from current or not stabled pets)
// 0 1 2(?) 3 4 5 6 7 8 9 10 11 12 13 14 15 16
result = CharacterDatabase.PQuery("SELECT id, entry, owner, modelid, level, exp, Reactstate, slot, name, renamed, curhealth, curmana, curhappiness, abdata, savetime, CreatedBySpell, PetType "
"FROM character_pet WHERE owner = '%u' AND entry = '%u' AND (slot = '%u' OR slot > '%u') ",
ownerid, petentry, PET_SAVE_AS_CURRENT, PET_SAVE_LAST_STABLE_SLOT);
else
// any current or other non-stabled pet (for hunter "call pet")
// 0 1 2(?) 3 4 5 6 7 8 9 10 11 12 13 14 15 16
result = CharacterDatabase.PQuery("SELECT id, entry, owner, modelid, level, exp, Reactstate, slot, name, renamed, curhealth, curmana, curhappiness, abdata, savetime, CreatedBySpell, PetType "
"FROM character_pet WHERE owner = '%u' AND (slot = '%u' OR slot > '%u') ",
ownerid, PET_SAVE_AS_CURRENT, PET_SAVE_LAST_STABLE_SLOT);
if (!result)
{
m_loading = false;
return false;
}
Field* fields = result->Fetch();
// update for case of current pet "slot = 0"
petentry = fields[1].GetUInt32();
if (!petentry)
return false;
uint32 summon_spell_id = fields[15].GetUInt32();
SpellInfo const* spellInfo = sSpellMgr->GetSpellInfo(summon_spell_id);
bool is_temporary_summoned = spellInfo && spellInfo->GetDuration() > 0;
// check temporary summoned pets like mage water elemental
if (current && is_temporary_summoned)
return false;
PetType pet_type = PetType(fields[16].GetUInt8());
if (pet_type == HUNTER_PET)
{
CreatureTemplate const* creatureInfo = sObjectMgr->GetCreatureTemplate(petentry);
if (!creatureInfo || !creatureInfo->isTameable(owner->CanTameExoticPets()))
return false;
}
uint32 pet_number = fields[0].GetUInt32();
if (current && owner->IsPetNeedBeTemporaryUnsummoned())
{
owner->SetTemporaryUnsummonedPetNumber(pet_number);
return false;
}
Map* map = owner->GetMap();
uint32 guid = sObjectMgr->GenerateLowGuid(HIGHGUID_PET);
if (!Create(guid, map, owner->GetPhaseMask(), petentry, pet_number))
return false;
float px, py, pz;
owner->GetClosePoint(px, py, pz, GetObjectSize(), PET_FOLLOW_DIST, GetFollowAngle());
Relocate(px, py, pz, owner->GetOrientation());
if (!IsPositionValid())
{
sLog->outError("Pet (guidlow %d, entry %d) not loaded. Suggested coordinates isn't valid (X: %f Y: %f)",
GetGUIDLow(), GetEntry(), GetPositionX(), GetPositionY());
return false;
}
setPetType(pet_type);
setFaction(owner->getFaction());
SetUInt32Value(UNIT_CREATED_BY_SPELL, summon_spell_id);
CreatureTemplate const* cinfo = GetCreatureInfo();
if (cinfo->type == CREATURE_TYPE_CRITTER)
{
map->AddToMap(this->ToCreature());
return true;
}
m_charmInfo->SetPetNumber(pet_number, IsPermanentPetFor(owner));
SetDisplayId(fields[3].GetUInt32());
SetNativeDisplayId(fields[3].GetUInt32());
uint32 petlevel = fields[4].GetUInt16();
SetUInt32Value(UNIT_NPC_FLAGS, UNIT_NPC_FLAG_NONE);
SetName(fields[8].GetString());
switch (getPetType())
{
case SUMMON_PET:
petlevel = owner->getLevel();
SetUInt32Value(UNIT_FIELD_BYTES_0, 0x800); // class = mage
SetUInt32Value(UNIT_FIELD_FLAGS, UNIT_FLAG_PVP_ATTACKABLE);
// this enables popup window (pet dismiss, cancel)
break;
case HUNTER_PET:
SetUInt32Value(UNIT_FIELD_BYTES_0, 0x02020100); // class = warrior, gender = none, power = focus
SetSheath(SHEATH_STATE_MELEE);
SetByteFlag(UNIT_FIELD_BYTES_2, 2, fields[9].GetBool() ? UNIT_CAN_BE_ABANDONED : UNIT_CAN_BE_RENAMED | UNIT_CAN_BE_ABANDONED);
SetUInt32Value(UNIT_FIELD_FLAGS, UNIT_FLAG_PVP_ATTACKABLE);
// this enables popup window (pet abandon, cancel)
SetMaxPower(POWER_HAPPINESS, GetCreatePowers(POWER_HAPPINESS));
SetPower(POWER_HAPPINESS, fields[12].GetUInt32());
setPowerType(POWER_FOCUS);
break;
default:
if (!IsPetGhoul())
sLog->outError("Pet have incorrect type (%u) for pet loading.", getPetType());
break;
}
SetUInt32Value(UNIT_FIELD_PET_NAME_TIMESTAMP, uint32(time(NULL))); // cast can't be helped here
SetCreatorGUID(owner->GetGUID());
InitStatsForLevel(petlevel);
SetUInt32Value(UNIT_FIELD_PETEXPERIENCE, fields[5].GetUInt32());
SynchronizeLevelWithOwner();
SetReactState(ReactStates(fields[6].GetUInt8()));
SetCanModifyStats(true);
if (getPetType() == SUMMON_PET && !current) //all (?) summon pets come with full health when called, but not when they are current
SetPower(POWER_MANA, GetMaxPower(POWER_MANA));
else
{
uint32 savedhealth = fields[10].GetUInt32();
uint32 savedmana = fields[11].GetUInt32();
if (!savedhealth && getPetType() == HUNTER_PET)
setDeathState(JUST_DIED);
else
{
SetHealth(savedhealth > GetMaxHealth() ? GetMaxHealth() : savedhealth);
SetPower(POWER_MANA, savedmana > GetMaxPower(POWER_MANA) ? GetMaxPower(POWER_MANA) : savedmana);
}
}
// set current pet as current
// 0=current
// 1..MAX_PET_STABLES in stable slot
// PET_SAVE_NOT_IN_SLOT(100) = not stable slot (summoning))
if (fields[7].GetUInt8())
{
SQLTransaction trans = CharacterDatabase.BeginTransaction();
trans->PAppend("UPDATE character_pet SET slot = '%u' WHERE owner = '%u' AND slot = '%u' AND id <> '%u'",
PET_SAVE_NOT_IN_SLOT, ownerid, PET_SAVE_AS_CURRENT, m_charmInfo->GetPetNumber());
trans->PAppend("UPDATE character_pet SET slot = '%u' WHERE owner = '%u' AND id = '%u'",
PET_SAVE_AS_CURRENT, ownerid, m_charmInfo->GetPetNumber());
CharacterDatabase.CommitTransaction(trans);
}
// Send fake summon spell cast - this is needed for correct cooldown application for spells
// Example: 46584 - without this cooldown (which should be set always when pet is loaded) isn't set clientside
// TODO: pets should be summoned from real cast instead of just faking it?
if (summon_spell_id)
{
WorldPacket data(SMSG_SPELL_GO, (8+8+4+4+2));
data.append(owner->GetPackGUID());
data.append(owner->GetPackGUID());
data << uint8(0);
data << uint32(summon_spell_id);
data << uint32(256); // CAST_FLAG_UNKNOWN3
data << uint32(0);
owner->SendMessageToSet(&data, true);
}
owner->SetMinion(this, true);
map->AddToMap(this->ToCreature());
InitTalentForLevel(); // set original talents points before spell loading
uint32 timediff = uint32(time(NULL) - fields[14].GetUInt32());
_LoadAuras(timediff);
// load action bar, if data broken will fill later by default spells.
if (!is_temporary_summoned)
{
m_charmInfo->LoadPetActionBar(fields[13].GetString());
_LoadSpells();
InitTalentForLevel(); // re-init to check talent count
_LoadSpellCooldowns();
LearnPetPassives();
InitLevelupSpellsForLevel();
CastPetAuras(current);
}
CleanupActionBar(); // remove unknown spells from action bar after load
sLog->outDebug(LOG_FILTER_PETS, "New Pet has guid %u", GetGUIDLow());
owner->PetSpellInitialize();
if (owner->GetGroup())
owner->SetGroupUpdateFlag(GROUP_UPDATE_PET);
owner->SendTalentsInfoData(true);
if (getPetType() == HUNTER_PET)
{
result = CharacterDatabase.PQuery("SELECT genitive, dative, accusative, instrumental, prepositional FROM character_pet_declinedname WHERE owner = '%u' AND id = '%u'", owner->GetGUIDLow(), GetCharmInfo()->GetPetNumber());
if (result)
{
delete m_declinedname;
m_declinedname = new DeclinedName;
Field* fields2 = result->Fetch();
for (uint8 i = 0; i < MAX_DECLINED_NAME_CASES; ++i)
{
m_declinedname->name[i] = fields2[i].GetString();
}
}
}
//set last used pet number (for use in BG's)
if (owner->GetTypeId() == TYPEID_PLAYER && isControlled() && !isTemporarySummoned() && (getPetType() == SUMMON_PET || getPetType() == HUNTER_PET))
owner->ToPlayer()->SetLastPetNumber(pet_number);
m_loading = false;
return true;
}
void Item::LoadFromDB(Field* fields, Player* plr, bool light)
{
uint32 itemid = fields[2].GetUInt32();
uint32 random_prop, random_suffix;
uint32 count;
m_itemProto = ItemPrototypeStorage.LookupEntry(itemid);
ARCEMU_ASSERT(m_itemProto != NULL);
locked = m_itemProto->LockId ? true : false;
SetEntry(itemid);
m_owner = plr;
wrapped_item_id = fields[3].GetUInt32();
SetGiftCreatorGUID(fields[4].GetUInt32());
SetCreatorGUID(fields[5].GetUInt32());
count = fields[6].GetUInt32();
if (count > m_itemProto->MaxCount && (m_owner && !m_owner->ItemStackCheat))
count = m_itemProto->MaxCount;
SetStackCount(count);
SetChargesLeft(fields[7].GetUInt32());
SetUInt32Value(ITEM_FIELD_FLAGS, fields[8].GetUInt32());
random_prop = fields[9].GetUInt32();
random_suffix = fields[10].GetUInt32();
SetItemRandomPropertyId(random_prop);
int32 rprop = int32(random_prop);
// If random properties point is negative that means the item uses random suffix as random enchantment
if (rprop < 0)
SetItemRandomSuffixFactor(random_suffix);
else
SetItemRandomSuffixFactor(0);
//SetTextId( fields[11].GetUInt32() );
SetDurabilityMax(m_itemProto->MaxDurability);
SetDurability(fields[12].GetUInt32());
if (light)
return;
string enchant_field = fields[15].GetString();
vector< string > enchants = StrSplit(enchant_field, ";");
uint32 enchant_id;
EnchantEntry* entry;
uint32 time_left;
uint32 enchslot;
for (vector<string>::iterator itr = enchants.begin(); itr != enchants.end(); ++itr)
{
if (sscanf((*itr).c_str(), "%u,%u,%u", (unsigned int*)&enchant_id, (unsigned int*)&time_left, (unsigned int*)&enchslot) == 3)
{
entry = dbcEnchant.LookupEntryForced(enchant_id);
if (entry && entry->Id == enchant_id && m_itemProto->SubClass != ITEM_SUBCLASS_WEAPON_THROWN)
{
AddEnchantment(entry, time_left, (time_left == 0), false, false, enchslot);
//(enchslot != 2) ? false : true, false);
}
else
{
/*
EnchantEntry *pEnchant = new EnchantEntry;
memset(pEnchant,0,sizeof(EnchantEntry));
pEnchant->Id = enchant_id;
if(enchslot != 2)
AddEnchantment(pEnchant,0,true, false);
else
AddEnchantment(pEnchant,0,false,false);
*/
}
}
}
ItemExpiresOn = fields[16].GetUInt32();
///////////////////////////////////////////////////// Refund stuff ////////////////////////
std::pair< time_t, uint32 > refundentry;
refundentry.first = fields[17].GetUInt32();
refundentry.second = fields[18].GetUInt32();
if (refundentry.first != 0 && refundentry.second != 0 && GetOwner() != NULL)
{
uint32* played = GetOwner()->GetPlayedtime();
if (played[1] < uint32(refundentry.first + 60 * 60 * 2))
m_owner->GetItemInterface()->AddRefundable(this, refundentry.second, refundentry.first);
}
///////////////////////////////////////////////////////////////////////////////////////////
text = fields[19].GetString();
ApplyRandomProperties(false);
// Charter stuff
if (GetEntry() == ITEM_ENTRY_GUILD_CHARTER)
{
SoulBind();
SetStackCount(1);
SetItemRandomSuffixFactor(57813883);
if (plr != NULL && plr->m_charters[CHARTER_TYPE_GUILD])
SetEnchantmentId(0, plr->m_charters[CHARTER_TYPE_GUILD]->GetID());
}
if (GetEntry() == ARENA_TEAM_CHARTER_2v2)
{
SoulBind();
SetStackCount(1);
SetItemRandomSuffixFactor(57813883);
if (plr != NULL && plr->m_charters[CHARTER_TYPE_ARENA_2V2])
SetEnchantmentId(0, plr->m_charters[CHARTER_TYPE_ARENA_2V2]->GetID());
}
if (GetEntry() == ARENA_TEAM_CHARTER_3v3)
{
SoulBind();
SetStackCount(1);
SetItemRandomSuffixFactor(57813883);
if (plr != NULL && plr->m_charters[CHARTER_TYPE_ARENA_3V3])
SetEnchantmentId(0, plr->m_charters[CHARTER_TYPE_ARENA_3V3]->GetID());
}
if (GetEntry() == ARENA_TEAM_CHARTER_5v5)
{
SoulBind();
SetStackCount(1);
SetItemRandomSuffixFactor(57813883);
if (plr != NULL && plr->m_charters[CHARTER_TYPE_ARENA_5V5])
SetEnchantmentId(0, plr->m_charters[CHARTER_TYPE_ARENA_5V5]->GetID());
}
}