void WorldSession::BuildPartyMemberStatsChangedPacket(Player* player, WorldPacket& data)
{
uint32 mask = player->GetGroupUpdateFlag();
if (mask & GROUP_UPDATE_FLAG_POWER_TYPE) // if update power type, update current/max power also
mask |= (GROUP_UPDATE_FLAG_CUR_POWER | GROUP_UPDATE_FLAG_MAX_POWER);
if (mask & GROUP_UPDATE_FLAG_PET_POWER_TYPE) // same for pets
mask |= (GROUP_UPDATE_FLAG_PET_CUR_POWER | GROUP_UPDATE_FLAG_PET_MAX_POWER);
uint32 byteCount = 0;
for (int i = 1; i < GROUP_UPDATE_FLAGS_COUNT; ++i)
if (mask & (1 << i))
byteCount += GroupUpdateLength[i];
data.Initialize(SMSG_PARTY_MEMBER_STATS, 8 + 4 + byteCount);
data << player->GetPackGUID();
data << uint32(mask);
if (mask & GROUP_UPDATE_FLAG_STATUS)
data << uint16(GetGroupMemberStatus(player));
if (mask & GROUP_UPDATE_FLAG_CUR_HP)
data << uint32(player->GetHealth());
if (mask & GROUP_UPDATE_FLAG_MAX_HP)
data << uint32(player->GetMaxHealth());
Powers powerType = player->GetPowerType();
if (mask & GROUP_UPDATE_FLAG_POWER_TYPE)
data << uint8(powerType);
if (mask & GROUP_UPDATE_FLAG_CUR_POWER)
data << uint16(player->GetPower(powerType));
if (mask & GROUP_UPDATE_FLAG_MAX_POWER)
data << uint16(player->GetMaxPower(powerType));
if (mask & GROUP_UPDATE_FLAG_LEVEL)
data << uint16(player->getLevel());
if (mask & GROUP_UPDATE_FLAG_ZONE)
data << uint16(player->GetZoneId());
if (mask & GROUP_UPDATE_FLAG_POSITION)
data << uint16(player->GetPositionX()) << uint16(player->GetPositionY());
if (mask & GROUP_UPDATE_FLAG_AURAS)
{
const uint64& auramask = player->GetAuraUpdateMask();
data << uint64(auramask);
for (uint32 i = 0; i < MAX_AURAS; ++i)
{
if (auramask & (uint64(1) << i))
{
data << uint32(player->GetVisibleAura(i));
data << uint8(1);
}
}
}
Pet* pet = player->GetPet();
if (mask & GROUP_UPDATE_FLAG_PET_GUID)
data << (pet ? pet->GetObjectGuid() : ObjectGuid());
if (mask & GROUP_UPDATE_FLAG_PET_NAME)
{
if (pet)
data << pet->GetName();
else
data << uint8(0);
}
if (mask & GROUP_UPDATE_FLAG_PET_MODEL_ID)
{
if (pet)
data << uint16(pet->GetDisplayId());
else
data << uint16(0);
}
if (mask & GROUP_UPDATE_FLAG_PET_CUR_HP)
{
if (pet)
data << uint32(pet->GetHealth());
else
data << uint32(0);
}
if (mask & GROUP_UPDATE_FLAG_PET_MAX_HP)
{
if (pet)
data << uint32(pet->GetMaxHealth());
else
data << uint32(0);
}
if (mask & GROUP_UPDATE_FLAG_PET_POWER_TYPE)
{
if (pet)
data << uint8(pet->GetPowerType());
else
data << uint8(0);
}
if (mask & GROUP_UPDATE_FLAG_PET_CUR_POWER)
{
if (pet)
data << uint16(pet->GetPower(pet->GetPowerType()));
else
data << uint16(0);
}
if (mask & GROUP_UPDATE_FLAG_PET_MAX_POWER)
{
if (pet)
data << uint16(pet->GetMaxPower(pet->GetPowerType()));
else
data << uint16(0);
}
if (mask & GROUP_UPDATE_FLAG_PET_AURAS)
{
if (pet)
{
const uint64& auramask = pet->GetAuraUpdateMask();
data << uint64(auramask);
for (uint32 i = 0; i < MAX_AURAS; ++i)
{
if (auramask & (uint64(1) << i))
{
data << uint32(pet->GetVisibleAura(i));
data << uint8(1);
}
}
}
else
data << uint64(0);
}
if (mask & GROUP_UPDATE_FLAG_VEHICLE_SEAT)
{
if (player->GetTransportInfo())
data << uint32(((Unit*)player->GetTransportInfo()->GetTransport())->GetVehicleInfo()->GetVehicleEntry()->m_seatID[player->GetTransportInfo()->GetTransportSeat()]);
else
data << uint32(0);
}
}
/*this procedure handles clients CMSG_REQUEST_PARTY_MEMBER_STATS request*/
void WorldSession::HandleRequestPartyMemberStatsOpcode(WorldPacket &recv_data)
{
sLog->outDebug(LOG_FILTER_NETWORKIO, "WORLD: Received CMSG_REQUEST_PARTY_MEMBER_STATS");
uint64 Guid;
recv_data >> Guid;
Player* player = HashMapHolder<Player>::Find(Guid);
if (!player)
{
WorldPacket data(SMSG_PARTY_MEMBER_STATS_FULL, 3+4+2);
data << uint8(0); // only for SMSG_PARTY_MEMBER_STATS_FULL, probably arena/bg related
data.appendPackGUID(Guid);
data << (uint32) GROUP_UPDATE_FLAG_STATUS;
data << (uint16) MEMBER_STATUS_OFFLINE;
SendPacket(&data);
return;
}
Pet* pet = player->GetPet();
WorldPacket data(SMSG_PARTY_MEMBER_STATS_FULL, 4+2+2+2+1+2*6+8+1+8);
data << uint8(0); // only for SMSG_PARTY_MEMBER_STATS_FULL, probably arena/bg related
data.append(player->GetPackGUID());
uint32 mask1 = 0x00040BFF; // common mask, real flags used 0x000040BFF
if (pet)
mask1 = 0x7FFFFFFF; // for hunters and other classes with pets
Powers powerType = player->getPowerType();
data << (uint32) mask1; // group update mask
data << (uint16) MEMBER_STATUS_ONLINE; // member's online status
data << (uint32) player->GetHealth(); // GROUP_UPDATE_FLAG_CUR_HP
data << (uint32) player->GetMaxHealth(); // GROUP_UPDATE_FLAG_MAX_HP
data << (uint8) powerType; // GROUP_UPDATE_FLAG_POWER_TYPE
data << (uint16) player->GetPower(powerType); // GROUP_UPDATE_FLAG_CUR_POWER
data << (uint16) player->GetMaxPower(powerType); // GROUP_UPDATE_FLAG_MAX_POWER
data << (uint16) player->getLevel(); // GROUP_UPDATE_FLAG_LEVEL
data << (uint16) player->GetZoneId(); // GROUP_UPDATE_FLAG_ZONE
data << (uint16) player->GetPositionX(); // GROUP_UPDATE_FLAG_POSITION
data << (uint16) player->GetPositionY(); // GROUP_UPDATE_FLAG_POSITION
uint64 auramask = 0;
data << uint8(0); // if true client clears auras that are not covered by auramask
// TODO: looks like now client requires all active auras to be in the beginning of the auramask
// e.g. if you have holes in the aura mask the values after are ignored.
size_t maskPos = data.wpos();
data << (uint64) auramask; // placeholder
data << uint32(64); // how many bits client reads from auramask
for (uint8 i = 0; i < MAX_AURAS; ++i)
{
if (AuraApplication * aurApp = player->GetVisibleAura(i))
{
auramask |= (uint64(1) << i);
data << (uint32) aurApp->GetBase()->GetId();
data << (uint8) 1;
}
}
data.put<uint64>(maskPos, auramask); // GROUP_UPDATE_FLAG_AURAS
if (pet)
{
Powers petpowertype = pet->getPowerType();
data << (uint64) pet->GetGUID(); // GROUP_UPDATE_FLAG_PET_GUID
data << pet->GetName(); // GROUP_UPDATE_FLAG_PET_NAME
data << (uint16) pet->GetDisplayId(); // GROUP_UPDATE_FLAG_PET_MODEL_ID
data << (uint32) pet->GetHealth(); // GROUP_UPDATE_FLAG_PET_CUR_HP
data << (uint32) pet->GetMaxHealth(); // GROUP_UPDATE_FLAG_PET_MAX_HP
data << (uint8) petpowertype; // GROUP_UPDATE_FLAG_PET_POWER_TYPE
data << (uint16) pet->GetPower(petpowertype); // GROUP_UPDATE_FLAG_PET_CUR_POWER
data << (uint16) pet->GetMaxPower(petpowertype); // GROUP_UPDATE_FLAG_PET_MAX_POWER
uint64 petauramask = 0;
data << uint8(0); // if true client clears auras that are not covered by auramask
// TODO: looks like now client requires all active auras to be in the beginning of the auramask
// e.g. if you have holes in the aura mask the values after are ignored.
size_t petMaskPos = data.wpos();
data << (uint64) petauramask; // placeholder
data << uint32(64); // how many bits client reads from auramask
for (uint8 i = 0; i < MAX_AURAS; ++i)
{
if (AuraApplication * auraApp = pet->GetVisibleAura(i))
{
petauramask |= (uint64(1) << i);
data << (uint32) auraApp->GetBase()->GetId();
data << (uint8) 1;
}
}
data.put<uint64>(petMaskPos, petauramask); // GROUP_UPDATE_FLAG_PET_AURAS
}
else
{
data << (uint8) 0; // GROUP_UPDATE_FLAG_PET_NAME
data << (uint8) 0; // GROUP_UPDATE_FLAG_PET_AURAS
data << (uint64) 0; // GROUP_UPDATE_FLAG_PET_AURAS
data << (uint32) 0;
}
SendPacket(&data);
}
void WorldSession::BuildPartyMemberStatsChangedPacket(Player* player, WorldPacket* data)
{
uint32 mask = player->GetGroupUpdateFlag();
if (mask == GROUP_UPDATE_FLAG_NONE)
return;
std::set<uint32> const& phases = player->GetPhases();
if (mask & GROUP_UPDATE_FLAG_POWER_TYPE) // if update power type, update current/max power also
mask |= (GROUP_UPDATE_FLAG_CUR_POWER | GROUP_UPDATE_FLAG_MAX_POWER);
if (mask & GROUP_UPDATE_FLAG_PET_POWER_TYPE) // same for pets
mask |= (GROUP_UPDATE_FLAG_PET_CUR_POWER | GROUP_UPDATE_FLAG_PET_MAX_POWER);
data->Initialize(SMSG_PARTY_MEMBER_STATS, 80); // average value
*data << player->GetPackGUID();
*data << uint32(mask);
if (mask & GROUP_UPDATE_FLAG_STATUS)
{
uint16 playerStatus = MEMBER_STATUS_ONLINE;
if (player->IsPvP())
playerStatus |= MEMBER_STATUS_PVP;
if (!player->IsAlive())
{
if (player->HasFlag(PLAYER_FLAGS, PLAYER_FLAGS_GHOST))
playerStatus |= MEMBER_STATUS_GHOST;
else
playerStatus |= MEMBER_STATUS_DEAD;
}
if (player->IsFFAPvP())
playerStatus |= MEMBER_STATUS_PVP_FFA;
if (player->isAFK())
playerStatus |= MEMBER_STATUS_AFK;
if (player->isDND())
playerStatus |= MEMBER_STATUS_DND;
*data << uint16(playerStatus);
}
if (mask & GROUP_UPDATE_FLAG_CUR_HP)
*data << uint32(player->GetHealth());
if (mask & GROUP_UPDATE_FLAG_MAX_HP)
*data << uint32(player->GetMaxHealth());
Powers powerType = player->getPowerType();
if (mask & GROUP_UPDATE_FLAG_POWER_TYPE)
*data << uint8(powerType);
if (mask & GROUP_UPDATE_FLAG_CUR_POWER)
*data << uint16(player->GetPower(powerType));
if (mask & GROUP_UPDATE_FLAG_MAX_POWER)
*data << uint16(player->GetMaxPower(powerType));
if (mask & GROUP_UPDATE_FLAG_LEVEL)
*data << uint16(player->getLevel());
if (mask & GROUP_UPDATE_FLAG_ZONE)
*data << uint16(player->GetZoneId());
if (mask & GROUP_UPDATE_FLAG_UNK100)
*data << uint16(0);
if (mask & GROUP_UPDATE_FLAG_POSITION)
{
*data << uint16(player->GetPositionX());
*data << uint16(player->GetPositionY());
*data << uint16(player->GetPositionZ());
}
if (mask & GROUP_UPDATE_FLAG_AURAS)
{
*data << uint8(0);
uint64 auramask = player->GetAuraUpdateMaskForRaid();
*data << uint64(auramask);
*data << uint32(MAX_AURAS); // count
for (uint32 i = 0; i < MAX_AURAS; ++i)
{
if (auramask & (uint64(1) << i))
{
AuraApplication const* aurApp = player->GetVisibleAura(i);
if (!aurApp)
{
*data << uint32(0);
*data << uint16(0);
continue;
}
*data << uint32(aurApp->GetBase()->GetId());
*data << uint16(aurApp->GetFlags());
if (aurApp->GetFlags() & AFLAG_ANY_EFFECT_AMOUNT_SENT)
{
for (uint32 i = 0; i < MAX_SPELL_EFFECTS; ++i)
{
if (AuraEffect const* eff = aurApp->GetBase()->GetEffect(i))
*data << int32(eff->GetAmount());
else
*data << int32(0);
}
}
}
}
}
Pet* pet = player->GetPet();
if (mask & GROUP_UPDATE_FLAG_PET_GUID)
{
if (pet)
*data << uint64(pet->GetGUID());
else
*data << uint64(0);
}
if (mask & GROUP_UPDATE_FLAG_PET_NAME)
{
if (pet)
*data << pet->GetName();
else
*data << uint8(0);
}
if (mask & GROUP_UPDATE_FLAG_PET_MODEL_ID)
{
if (pet)
*data << uint16(pet->GetDisplayId());
else
*data << uint16(0);
}
if (mask & GROUP_UPDATE_FLAG_PET_CUR_HP)
{
if (pet)
*data << uint32(pet->GetHealth());
else
*data << uint32(0);
}
if (mask & GROUP_UPDATE_FLAG_PET_MAX_HP)
{
if (pet)
*data << uint32(pet->GetMaxHealth());
else
*data << uint32(0);
}
if (mask & GROUP_UPDATE_FLAG_PET_POWER_TYPE)
{
if (pet)
*data << uint8(pet->getPowerType());
else
*data << uint8(0);
}
if (mask & GROUP_UPDATE_FLAG_PET_CUR_POWER)
{
if (pet)
*data << uint16(pet->GetPower(pet->getPowerType()));
else
*data << uint16(0);
}
if (mask & GROUP_UPDATE_FLAG_PET_MAX_POWER)
{
if (pet)
*data << uint16(pet->GetMaxPower(pet->getPowerType()));
else
*data << uint16(0);
}
if (mask & GROUP_UPDATE_FLAG_PET_AURAS)
{
if (pet)
{
*data << uint8(0);
uint64 auramask = pet->GetAuraUpdateMaskForRaid();
*data << uint64(auramask);
*data << uint32(MAX_AURAS); // count
for (uint32 i = 0; i < MAX_AURAS; ++i)
{
if (auramask & (uint64(1) << i))
{
AuraApplication const* aurApp = pet->GetVisibleAura(i);
if (!aurApp)
{
*data << uint32(0);
*data << uint16(0);
continue;
}
*data << uint32(aurApp->GetBase()->GetId());
*data << uint16(aurApp->GetFlags());
if (aurApp->GetFlags() & AFLAG_ANY_EFFECT_AMOUNT_SENT)
{
for (uint32 i = 0; i < MAX_SPELL_EFFECTS; ++i)
{
if (AuraEffect const* eff = aurApp->GetBase()->GetEffect(i))
*data << int32(eff->GetAmount());
else
*data << int32(0);
}
}
}
}
}
else
{
*data << uint8(0);
*data << uint64(0);
}
}
if (mask & GROUP_UPDATE_FLAG_VEHICLE_SEAT)
{
if (Vehicle* veh = player->GetVehicle())
*data << uint32(veh->GetVehicleInfo()->m_seatID[player->m_movementInfo.transport.seat]);
else
*data << uint32(0);
}
if (mask & GROUP_UPDATE_FLAG_PHASE)
{
*data << uint32(phases.empty() ? 8 : 0);
*data << uint32(phases.size());
for (std::set<uint32>::const_iterator itr = phases.begin(); itr != phases.end(); ++itr)
*data << uint16(*itr);
}
}
void WorldSession::BuildPartyMemberStatsChangedPacket(Player *player, WorldPacket *data)
{
uint32 mask = player->GetGroupUpdateFlag();
if (mask == GROUP_UPDATE_FLAG_NONE)
return;
if (mask & GROUP_UPDATE_FLAG_POWER_TYPE) // if update power type, update current/max power also
mask |= (GROUP_UPDATE_FLAG_CUR_POWER | GROUP_UPDATE_FLAG_MAX_POWER);
if (mask & GROUP_UPDATE_FLAG_PET_POWER_TYPE) // same for pets
mask |= (GROUP_UPDATE_FLAG_PET_CUR_POWER | GROUP_UPDATE_FLAG_PET_MAX_POWER);
uint32 byteCount = 0;
for (int i = 1; i < GROUP_UPDATE_FLAGS_COUNT; ++i)
if (mask & (1 << i))
byteCount += GroupUpdateLength[i];
data->Initialize(SMSG_PARTY_MEMBER_STATS, 8 + 4 + byteCount);
data->append(player->GetPackGUID());
*data << (uint32) mask;
if (mask & GROUP_UPDATE_FLAG_STATUS)
{
if (player)
{
if (player->IsPvP())
*data << (uint16) (MEMBER_STATUS_ONLINE | MEMBER_STATUS_PVP);
else
*data << (uint16) MEMBER_STATUS_ONLINE;
}
else
*data << (uint16) MEMBER_STATUS_OFFLINE;
}
if (mask & GROUP_UPDATE_FLAG_CUR_HP)
*data << (uint32) player->GetHealth();
if (mask & GROUP_UPDATE_FLAG_MAX_HP)
*data << (uint32) player->GetMaxHealth();
Powers powerType = player->getPowerType();
if (mask & GROUP_UPDATE_FLAG_POWER_TYPE)
*data << (uint8) powerType;
if (mask & GROUP_UPDATE_FLAG_CUR_POWER)
*data << (uint16) player->GetPower(powerType);
if (mask & GROUP_UPDATE_FLAG_MAX_POWER)
*data << (uint16) player->GetMaxPower(powerType);
if (mask & GROUP_UPDATE_FLAG_LEVEL)
*data << (uint16) player->getLevel();
if (mask & GROUP_UPDATE_FLAG_ZONE)
*data << (uint16) player->GetZoneId();
if (mask & GROUP_UPDATE_FLAG_POSITION)
*data << (uint16) player->GetPositionX() << (uint16) player->GetPositionY();
if (mask & GROUP_UPDATE_FLAG_AURAS)
{
const uint64& auramask = player->GetAuraUpdateMask();
*data << uint64(auramask);
for(uint32 i = 0; i < MAX_AURAS; ++i)
{
if(auramask & (uint64(1) << i))
{
*data << uint32(player->GetVisibleAura(i));
*data << uint8(1);
}
}
}
Pet *pet = player->GetPet();
if (mask & GROUP_UPDATE_FLAG_PET_GUID)
{
if(pet)
*data << (uint64) pet->GetGUID();
else
*data << (uint64) 0;
}
if (mask & GROUP_UPDATE_FLAG_PET_NAME)
{
if(pet)
*data << pet->GetName();
else
*data << (uint8) 0;
}
if (mask & GROUP_UPDATE_FLAG_PET_MODEL_ID)
{
if(pet)
*data << (uint16) pet->GetDisplayId();
else
*data << (uint16) 0;
}
if (mask & GROUP_UPDATE_FLAG_PET_CUR_HP)
{
if(pet)
*data << (uint32) pet->GetHealth();
else
*data << (uint32) 0;
}
if (mask & GROUP_UPDATE_FLAG_PET_MAX_HP)
{
if(pet)
*data << (uint32) pet->GetMaxHealth();
else
*data << (uint32) 0;
}
if (mask & GROUP_UPDATE_FLAG_PET_POWER_TYPE)
{
if(pet)
*data << (uint8) pet->getPowerType();
else
*data << (uint8) 0;
}
if (mask & GROUP_UPDATE_FLAG_PET_CUR_POWER)
{
if(pet)
*data << (uint16) pet->GetPower(pet->getPowerType());
else
*data << (uint16) 0;
}
if (mask & GROUP_UPDATE_FLAG_PET_MAX_POWER)
{
if(pet)
*data << (uint16) pet->GetMaxPower(pet->getPowerType());
else
*data << (uint16) 0;
}
if (mask & GROUP_UPDATE_FLAG_PET_AURAS)
{
if(pet)
{
const uint64& auramask = pet->GetAuraUpdateMask();
*data << uint64(auramask);
for(uint32 i = 0; i < MAX_AURAS; ++i)
{
if(auramask & (uint64(1) << i))
{
*data << uint32(pet->GetVisibleAura(i));
*data << uint8(1);
}
}
}
else
*data << (uint64) 0;
}
}
void WorldSession::HandleDuelAcceptedOpcode(WorldPacket& recvPacket)
{
ObjectGuid guid;
recvPacket >> guid;
if(!GetPlayer()->duel) // ignore accept from duel-sender
return;
Player *pl = GetPlayer();
Player *plTarget = pl->duel->opponent;
if(pl == pl->duel->initiator || !plTarget || pl == plTarget || pl->duel->startTime != 0 || plTarget->duel->startTime != 0)
return;
DEBUG_FILTER_LOG(LOG_FILTER_COMBAT, "WORLD: received CMSG_DUEL_ACCEPTED" );
DEBUG_FILTER_LOG(LOG_FILTER_COMBAT, "Player 1 is: %u (%s)", pl->GetGUIDLow(), pl->GetName());
DEBUG_FILTER_LOG(LOG_FILTER_COMBAT, "Player 2 is: %u (%s)", plTarget->GetGUIDLow(), plTarget->GetName());
time_t now = time(NULL);
pl->duel->startTimer = now;
plTarget->duel->startTimer = now;
pl->SendDuelCountdown(3000);
plTarget->SendDuelCountdown(3000);
/**
* Duel reset script
*
*/
uint32 areaId = pl->GetAreaId();
if(sWorld.getConfig(CONFIG_BOOL_RESET_DUEL_AREA_ENABLED) && sWorld.IsAreaIdEnabledDuelReset(areaId)){
//remove arena cds
pl->RemoveArenaSpellCooldowns();
plTarget->RemoveArenaSpellCooldowns();
//remove negative arena auras
pl->RemoveArenaAuras(true);
plTarget->RemoveArenaAuras(true);
//set max mana and hp
pl->SetHealth(pl->GetMaxHealth());
pl->SetPower(POWER_MANA, pl->GetMaxPower(POWER_MANA));
plTarget->SetHealth(plTarget->GetMaxHealth());
plTarget->SetPower(POWER_MANA, plTarget->GetMaxPower(POWER_MANA));
// set max hp, mana and remove buffs of players' pet if they have
Pet* plPet = pl->GetPet();
if(plPet != NULL)
{
plPet->SetHealth(plPet->GetMaxHealth());
plPet->SetPower(plPet->getPowerType(), plPet->GetMaxPower(plPet->getPowerType()));
plPet->RemoveArenaAuras(true);
}
Pet* plPetTarget = plTarget->GetPet();
if(plPetTarget != NULL)
{
plPetTarget->SetHealth(plPetTarget->GetMaxHealth());
plPetTarget->SetPower(plPetTarget->getPowerType(), plPetTarget->GetMaxPower(plPetTarget->getPowerType()));
plPetTarget->RemoveArenaAuras(true);
}
}
}
void WorldSession::BuildPartyMemberStatsChangedPacket(Player* player, WorldPacket* data)
{
uint32 mask = player->GetGroupUpdateFlag();
if (mask == GROUP_UPDATE_FLAG_NONE)
return;
if (mask & GROUP_UPDATE_FLAG_POWER_TYPE) // if update power type, update current/max power also
mask |= (GROUP_UPDATE_FLAG_CUR_POWER | GROUP_UPDATE_FLAG_MAX_POWER);
if (mask & GROUP_UPDATE_FLAG_PET_POWER_TYPE) // same for pets
mask |= (GROUP_UPDATE_FLAG_PET_CUR_POWER | GROUP_UPDATE_FLAG_PET_MAX_POWER);
data->Initialize(SMSG_PARTY_MEMBER_STATS);
data->append(player->GetPackGUID());
*data << uint32(mask);
if (mask & GROUP_UPDATE_FLAG_STATUS)
{
if (player->IsPvP())
*data << uint16(MEMBER_STATUS_ONLINE | MEMBER_STATUS_PVP);
else
*data << uint16(MEMBER_STATUS_ONLINE);
}
if (mask & GROUP_UPDATE_FLAG_CUR_HP)
*data << uint32(player->GetHealth());
if (mask & GROUP_UPDATE_FLAG_MAX_HP)
*data << uint32(player->GetMaxHealth());
Powers powerType = player->getPowerType();
if (mask & GROUP_UPDATE_FLAG_POWER_TYPE)
*data << uint8(powerType);
if (mask & GROUP_UPDATE_FLAG_CUR_POWER)
*data << uint16(player->GetPower(powerType));
if (mask & GROUP_UPDATE_FLAG_MAX_POWER)
*data << uint16(player->GetMaxPower(powerType));
if (mask & GROUP_UPDATE_FLAG_LEVEL)
*data << uint16(player->getLevel());
if (mask & GROUP_UPDATE_FLAG_ZONE)
*data << uint16(player->GetZoneId());
if (mask & GROUP_UPDATE_FLAG_UNK100)
*data << uint16(0);
if (mask & GROUP_UPDATE_FLAG_POSITION)
*data << uint16(player->GetPositionX()) << uint16(player->GetPositionY()) << uint16(player->GetPositionZ());
if (mask & GROUP_UPDATE_FLAG_AURAS)
{
*data << uint8(0);
uint64 auramask = player->GetAuraUpdateMaskForRaid();
*data << uint64(auramask);
*data << uint32(MAX_AURAS); // count
for (uint32 i = 0; i < MAX_AURAS; ++i)
{
if (auramask & (uint64(1) << i))
{
AuraApplication const* aurApp = player->GetVisibleAura(i);
if (!aurApp)
{
*data << uint32(0);
*data << uint16(0);
continue;
}
*data << uint32(aurApp->GetBase()->GetId());
*data << uint16(aurApp->GetFlags());
if (aurApp->GetFlags() & AFLAG_ANY_EFFECT_AMOUNT_SENT)
{
for (uint32 i = 0; i < MAX_SPELL_EFFECTS; ++i)
{
if (AuraEffect const* eff = aurApp->GetBase()->GetEffect(i))
*data << int32(eff->GetAmount());
else
*data << int32(0);
}
}
}
}
}
Pet* pet = player->GetPet();
if (mask & GROUP_UPDATE_FLAG_PET_GUID)
{
if (pet)
*data << uint64(pet->GetGUID());
else
*data << uint64(0);
}
if (mask & GROUP_UPDATE_FLAG_PET_NAME)
{
if (pet)
*data << pet->GetName();
else
*data << uint8(0);
}
if (mask & GROUP_UPDATE_FLAG_PET_MODEL_ID)
{
if (pet)
*data << uint16(pet->GetDisplayId());
else
*data << uint16(0);
}
if (mask & GROUP_UPDATE_FLAG_PET_CUR_HP)
{
if (pet)
*data << uint32(pet->GetHealth());
else
*data << uint32(0);
}
if (mask & GROUP_UPDATE_FLAG_PET_MAX_HP)
{
if (pet)
*data << uint32(pet->GetMaxHealth());
else
*data << uint32(0);
}
if (mask & GROUP_UPDATE_FLAG_PET_POWER_TYPE)
{
if (pet)
*data << uint8(pet->getPowerType());
else
*data << uint8(0);
}
if (mask & GROUP_UPDATE_FLAG_PET_CUR_POWER)
{
if (pet)
*data << uint16(pet->GetPower(pet->getPowerType()));
else
*data << uint16(0);
}
if (mask & GROUP_UPDATE_FLAG_PET_MAX_POWER)
{
if (pet)
*data << uint16(pet->GetMaxPower(pet->getPowerType()));
else
*data << uint16(0);
}
if (mask & GROUP_UPDATE_FLAG_PET_AURAS)
{
if (pet)
{
*data << uint8(0);
uint64 auramask = pet->GetAuraUpdateMaskForRaid();
*data << uint64(auramask);
*data << uint32(MAX_AURAS); // count
for (uint32 i = 0; i < MAX_AURAS; ++i)
{
if (auramask & (uint64(1) << i))
{
AuraApplication const* aurApp = pet->GetVisibleAura(i);
if (!aurApp)
{
*data << uint32(0);
*data << uint16(0);
continue;
}
*data << uint32(aurApp->GetBase()->GetId());
*data << uint16(aurApp->GetFlags());
if (aurApp->GetFlags() & AFLAG_ANY_EFFECT_AMOUNT_SENT)
{
for (uint32 i = 0; i < MAX_SPELL_EFFECTS; ++i)
{
if (AuraEffect const* eff = aurApp->GetBase()->GetEffect(i))
*data << int32(eff->GetAmount());
else
*data << int32(0);
}
}
}
}
}
else
{
*data << uint8(0);
*data << uint64(0);
*data << uint32(0);
}
}
if (mask & GROUP_UPDATE_FLAG_VEHICLE_SEAT)
{
if (Vehicle* veh = player->GetVehicle())
*data << uint32(veh->GetVehicleInfo()->m_seatID[player->m_movementInfo.t_seat]);
else
*data << uint32(0);
}
if (mask & GROUP_UPDATE_FLAG_PHASE)
{
*data << uint32(8); // either 0 or 8, same unk found in SMSG_PHASESHIFT
*data << uint32(0); // count
// for (count) *data << uint16(phaseId)
}
}
void WorldSession::HandleDuelAcceptedOpcode(WorldPacket& recvPacket)
{
uint64 guid;
Player* player;
Player* plTarget;
recvPacket >> guid;
if (!GetPlayer()->duel) // ignore accept from duel-sender
return;
player = GetPlayer();
plTarget = player->duel->opponent;
if (player == player->duel->initiator || !plTarget || player == plTarget || player->duel->startTime != 0 || plTarget->duel->startTime != 0)
return;
//TC_LOG_DEBUG("network", "WORLD: Received CMSG_DUEL_ACCEPTED");
TC_LOG_DEBUG("network", "Player 1 is: %u (%s)", player->GetGUIDLow(), player->GetName().c_str());
TC_LOG_DEBUG("network", "Player 2 is: %u (%s)", plTarget->GetGUIDLow(), plTarget->GetName().c_str());
time_t now = time(NULL);
player->duel->startTimer = now;
plTarget->duel->startTimer = now;
// Reiniciar Cooldowns, vida y mana en una zona especifica.
if (player->GetAreaId() == 4570 || player->GetAreaId() == 14 || player->GetAreaId() == 12)
{
player->SetHealth(player->GetMaxHealth());
plTarget->SetHealth(plTarget->GetMaxHealth());
player->RemoveArenaSpellCooldowns(true);
plTarget->RemoveArenaSpellCooldowns(true);
// Debuffs
player->RemoveAura(57723);
player->RemoveAura(57724);
player->RemoveAura(25771);
player->RemoveAura(41425);
player->RemoveAura(61987);
player->RemoveAura(66233);
player->RemoveAura(11196);
player->RemoveAura(47986);
plTarget->RemoveAura(57723);
plTarget->RemoveAura(57724);
plTarget->RemoveAura(25771);
plTarget->RemoveAura(41425);
plTarget->RemoveAura(61987);
plTarget->RemoveAura(66233);
plTarget->RemoveAura(11196);
plTarget->RemoveAura(47986);
if (player->getPowerType() == POWER_MANA)
player->SetPower(POWER_MANA, player->GetMaxPower(POWER_MANA));
if (plTarget->getPowerType() == POWER_MANA)
plTarget->SetPower(POWER_MANA, plTarget->GetMaxPower(POWER_MANA));
if (player->getPowerType() == POWER_RAGE)
player->SetPower(POWER_RAGE, 0);
if (plTarget->getPowerType() == POWER_RAGE)
plTarget->SetPower(POWER_RAGE, 0);
if (player->getPowerType() == POWER_RUNIC_POWER)
player->SetPower(POWER_RUNIC_POWER, 0);
if (plTarget->getPowerType() == POWER_RUNIC_POWER)
plTarget->SetPower(POWER_RUNIC_POWER, 0);
// Reset Pet Cooldown HP, Power, and Summon.
if (player->getClass() == CLASS_HUNTER)
player->CastSpell(player, 883, true);
Pet* plPet = player->GetPet();
if(plPet != NULL)
{
if (plPet->isDead())
player->CastSpell(player, 35182, true);
player->CastSpell(player, 982, true);
player->RemoveAura(35182);
plPet->SetHealth(plPet->GetMaxHealth());
plPet->SetPower(plPet->getPowerType(), plPet->GetMaxPower(plPet->getPowerType()));
plPet->RemoveArenaAuras();
plPet->m_CreatureSpellCooldowns.clear();
plPet->RemoveAura(55711);
}
if (plTarget->getClass() == CLASS_HUNTER)
plTarget->CastSpell(plTarget, 883, true);
Pet* plPetTarget = plTarget->GetPet();
if(plPetTarget != NULL)
{
if (plPetTarget->isDead())
plTarget->CastSpell(plTarget, 35182, true);
plTarget->CastSpell(plTarget, 982, true);
plTarget->RemoveAura(35182);
plPetTarget->SetHealth(plPetTarget->GetMaxHealth());
plPetTarget->SetPower(plPetTarget->getPowerType(), plPetTarget->GetMaxPower(plPetTarget->getPowerType()));
plPetTarget->RemoveArenaAuras();
plPetTarget->m_CreatureSpellCooldowns.clear();
plPetTarget->RemoveAura(55711);
}
}
player->SendDuelCountdown(3000);
plTarget->SendDuelCountdown(3000);
}
void PlayerbotHunterAI::DoNonCombatActions()
{
PlayerbotAI *ai = GetAI();
if (!ai)
return;
Player * m_bot = GetPlayerBot();
if (!m_bot)
return;
// reset ranged combat state
if (!m_rangedCombat)
m_rangedCombat = true;
// buff group
if (TRUESHOT_AURA > 0)
(!m_bot->HasAura(TRUESHOT_AURA, EFFECT_INDEX_0) && ai->CastSpell (TRUESHOT_AURA, *m_bot));
// buff myself
if (ASPECT_OF_THE_HAWK > 0)
(!m_bot->HasAura(ASPECT_OF_THE_HAWK, EFFECT_INDEX_0) && ai->CastSpell (ASPECT_OF_THE_HAWK, *m_bot));
// mana check
if (m_bot->getStandState() != UNIT_STAND_STATE_STAND)
m_bot->SetStandState(UNIT_STAND_STATE_STAND);
Item* pItem = ai->FindDrink();
Item* fItem = ai->FindBandage();
if (pItem != NULL && ai->GetManaPercent() < 30)
{
ai->TellMaster("I could use a drink.");
ai->UseItem(pItem);
return;
}
// hp check
if (m_bot->getStandState() != UNIT_STAND_STATE_STAND)
m_bot->SetStandState(UNIT_STAND_STATE_STAND);
pItem = ai->FindFood();
if (pItem != NULL && ai->GetHealthPercent() < 30)
{
ai->TellMaster("I could use some food.");
ai->UseItem(pItem);
return;
}
else if (pItem == NULL && fItem != NULL && !m_bot->HasAura(RECENTLY_BANDAGED, EFFECT_INDEX_0) && ai->GetHealthPercent() < 70)
{
ai->TellMaster("I could use first aid.");
ai->UseItem(fItem);
return;
}
else if (pItem == NULL && fItem == NULL && m_bot->getRace() == RACE_DRAENEI && !m_bot->HasAura(GIFT_OF_THE_NAARU, EFFECT_INDEX_0) && ai->GetHealthPercent() < 70)
{
ai->TellMaster("I'm casting gift of the naaru.");
ai->CastSpell(GIFT_OF_THE_NAARU, *m_bot);
return;
}
// check for pet
if (PET_SUMMON > 0 && !m_petSummonFailed && HasPet(m_bot))
{
// we can summon pet, and no critical summon errors before
Pet *pet = m_bot->GetPet();
if (!pet)
{
// summon pet
if (PET_SUMMON > 0 && ai->CastSpell(PET_SUMMON, *m_bot))
ai->TellMaster("summoning pet.");
else
{
m_petSummonFailed = true;
ai->TellMaster("summon pet failed!");
}
}
else if (pet->getDeathState() != ALIVE)
{
// revive pet
if (PET_REVIVE > 0 && ai->GetManaPercent() >= 80 && ai->CastSpell(PET_REVIVE, *m_bot))
ai->TellMaster("reviving pet.");
}
else if (((float) pet->GetHealth() / (float) pet->GetMaxHealth()) < 0.5f)
{
// heal pet when health lower 50%
if (PET_MEND > 0 && !pet->getDeathState() != ALIVE && !pet->HasAura(PET_MEND, EFFECT_INDEX_0) && ai->GetManaPercent() >= 13 && ai->CastSpell(PET_MEND, *m_bot))
ai->TellMaster("healing pet.");
}
else if (pet->GetHappinessState() != HAPPY) // if pet is hungry
{
Unit *caster = (Unit *) m_bot;
// list out items in main backpack
for (uint8 slot = INVENTORY_SLOT_ITEM_START; slot < INVENTORY_SLOT_ITEM_END; slot++)
{
Item* const pItem = m_bot->GetItemByPos(INVENTORY_SLOT_BAG_0, slot);
if (pItem)
{
const ItemPrototype* const pItemProto = pItem->GetProto();
if (!pItemProto)
continue;
if (pet->HaveInDiet(pItemProto)) // is pItem in pets diet
{
//sLog.outDebug("Food for pet: %s",pItemProto->Name1);
caster->CastSpell(caster, 51284, true); // pet feed visual
uint32 count = 1; // number of items used
int32 benefit = pet->GetCurrentFoodBenefitLevel(pItemProto->ItemLevel); // nutritional value of food
m_bot->DestroyItemCount(pItem, count, true); // remove item from inventory
m_bot->CastCustomSpell(m_bot, PET_FEED, &benefit, NULL, NULL, true); // feed pet
ai->TellMaster("feeding pet.");
ai->SetIgnoreUpdateTime(10);
return;
}
}
}
// list out items in other removable backpacks
for (uint8 bag = INVENTORY_SLOT_BAG_START; bag < INVENTORY_SLOT_BAG_END; ++bag)
{
const Bag* const pBag = (Bag *) m_bot->GetItemByPos(INVENTORY_SLOT_BAG_0, bag);
if (pBag)
for (uint8 slot = 0; slot < pBag->GetBagSize(); ++slot)
{
Item* const pItem = m_bot->GetItemByPos(bag, slot);
if (pItem)
{
const ItemPrototype* const pItemProto = pItem->GetProto();
if (!pItemProto)
continue;
if (pet->HaveInDiet(pItemProto)) // is pItem in pets diet
{
//sLog.outDebug("Food for pet: %s",pItemProto->Name1);
caster->CastSpell(caster, 51284, true); // pet feed visual
uint32 count = 1; // number of items used
int32 benefit = pet->GetCurrentFoodBenefitLevel(pItemProto->ItemLevel); // nutritional value of food
m_bot->DestroyItemCount(pItem, count, true); // remove item from inventory
m_bot->CastCustomSpell(m_bot, PET_FEED, &benefit, NULL, NULL, true); // feed pet
ai->TellMaster("feeding pet.");
ai->SetIgnoreUpdateTime(10);
return;
}
}
}
}
if (pet->HasAura(PET_MEND, EFFECT_INDEX_0) && !pet->HasAura(PET_FEED, EFFECT_INDEX_0))
ai->TellMaster("..no pet food!");
ai->SetIgnoreUpdateTime(7);
}
}
} // end DoNonCombatActions
void WorldSession::HandleLoadPetFromDBSecondCallback(LoadPetFromDBQueryHolder* holder)
{
if (!GetPlayer())
return;
Player* owner = GetPlayer();
Pet* pet = owner->GetPet();
if (!pet)
return;
pet->_LoadAuras(holder->GetPreparedResult(PET_LOAD_QUERY_LOADAURAS), holder->GetDiffTime());
bool current = holder->GetCurrent();
uint32 summon_spell_id = pet->GetUInt32Value(UNIT_CREATED_BY_SPELL);
SpellInfo const* spellInfo = sSpellMgr->GetSpellInfo(summon_spell_id); // CANT BE NULL
bool is_temporary_summoned = spellInfo && spellInfo->GetDuration() > 0;
// load action bar, if data broken will fill later by default spells.
if (!is_temporary_summoned)
{
pet->_LoadSpells(holder->GetPreparedResult(PET_LOAD_QUERY_LOADSPELLS));
pet->InitTalentForLevel(); // re-init to check talent count
pet->_LoadSpellCooldowns(holder->GetPreparedResult(PET_LOAD_QUERY_LOADSPELLCOOLDOWN));
pet->LearnPetPassives();
pet->InitLevelupSpellsForLevel();
pet->CastPetAuras(current);
pet->GetCharmInfo()->LoadPetActionBar(holder->GetActionBar()); // action bar stored in already read string
}
pet->CleanupActionBar(); // remove unknown spells from action bar after load
owner->PetSpellInitialize();
owner->SendTalentsInfoData(true);
if (owner->GetGroup())
owner->SetGroupUpdateFlag(GROUP_UPDATE_PET);
//set last used pet number (for use in BG's)
if (owner->GetTypeId() == TYPEID_PLAYER && pet->isControlled() && !pet->isTemporarySummoned() && (pet->getPetType() == SUMMON_PET || pet->getPetType() == HUNTER_PET))
{
owner->ToPlayer()->SetLastPetNumber(holder->GetPetNumber());
owner->SetLastPetSpell(pet->GetUInt32Value(UNIT_CREATED_BY_SPELL));
}
if (pet->getPetType() == SUMMON_PET && !current) //all (?) summon pets come with full health when called, but not when they are current
{
pet->SetPower(POWER_MANA, pet->GetMaxPower(POWER_MANA));
pet->SetHealth(pet->GetMaxHealth());
}
else
{
if (!holder->GetSavedHealth() && pet->getPetType() == HUNTER_PET && pet->GetAsynchLoadType() != PET_LOAD_SUMMON_DEAD_PET)
pet->setDeathState(JUST_DIED);
else
{
pet->SetHealth(holder->GetSavedHealth() > pet->GetMaxHealth() ? pet->GetMaxHealth() : holder->GetSavedHealth());
pet->SetPower(POWER_MANA, holder->GetSavedMana() > pet->GetMaxPower(POWER_MANA) ? pet->GetMaxPower(POWER_MANA) : holder->GetSavedMana());
}
}
pet->SetLoading(false);
owner->SetTemporaryUnsummonedPetNumber(0); // clear this only if pet is loaded successfuly
// current
if (current && owner->IsPetNeedBeTemporaryUnsummoned())
{
owner->UnsummonPetTemporaryIfAny();
return;
}
pet->HandleAsynchLoadSucceed();
return;
}
uint8 WorldSession::HandleLoadPetFromDBFirstCallback(PreparedQueryResult result, uint8 asynchLoadType)
{
if (!GetPlayer() || GetPlayer()->GetPet() || GetPlayer()->GetVehicle() || GetPlayer()->IsSpectator())
return PET_LOAD_ERROR;
if (!result)
return PET_LOAD_NO_RESULT;
Field* fields = result->Fetch();
// Xinef: this can happen if fetch is called twice, impossibru.
if (!fields)
return PET_LOAD_ERROR;
Player* owner = GetPlayer();
// update for case of current pet "slot = 0"
uint32 petentry = fields[1].GetUInt32();
if (!petentry)
return PET_LOAD_NO_RESULT;
uint8 petSlot = fields[7].GetUInt8();
bool current = petSlot == PET_SAVE_AS_CURRENT;
uint32 summon_spell_id = fields[15].GetUInt32();
SpellInfo const* spellInfo = sSpellMgr->GetSpellInfo(summon_spell_id); // CANT BE NULL
bool is_temporary_summoned = spellInfo && spellInfo->GetDuration() > 0;
uint32 pet_number = fields[0].GetUInt32();
uint32 savedhealth = fields[10].GetUInt32();
uint32 savedmana = fields[11].GetUInt32();
PetType pet_type = PetType(fields[16].GetUInt8());
// xinef: BG resurrect, overwrite saved value
if (asynchLoadType == PET_LOAD_BG_RESURRECT)
savedhealth = 1;
if (pet_type == HUNTER_PET && savedhealth == 0 && asynchLoadType != PET_LOAD_SUMMON_DEAD_PET)
{
WorldPacket data(SMSG_CAST_FAILED, 1+4+1+4);
data << uint8(0);
data << uint32(883);
data << uint8(SPELL_FAILED_TARGETS_DEAD);
SendPacket(&data);
owner->RemoveSpellCooldown(883, false);
return PET_LOAD_ERROR;
}
// check temporary summoned pets like mage water elemental
if (current && is_temporary_summoned)
return PET_LOAD_ERROR;
if (pet_type == HUNTER_PET)
{
CreatureTemplate const* creatureInfo = sObjectMgr->GetCreatureTemplate(petentry);
if (!creatureInfo || !creatureInfo->IsTameable(owner->CanTameExoticPets()))
return PET_LOAD_ERROR;
}
Map* map = owner->GetMap();
uint32 guid = sObjectMgr->GenerateLowGuid(HIGHGUID_PET);
Pet* pet = new Pet(owner, pet_type);
LoadPetFromDBQueryHolder* holder = new LoadPetFromDBQueryHolder(pet_number, current, uint32(time(NULL) - fields[14].GetUInt32()), fields[13].GetString(), savedhealth, savedmana);
if (!pet->Create(guid, map, owner->GetPhaseMask(), petentry, pet_number) || !holder->Initialize())
{
delete pet;
delete holder;
return PET_LOAD_ERROR;
}
float px, py, pz;
owner->GetClosePoint(px, py, pz, pet->GetObjectSize(), PET_FOLLOW_DIST, pet->GetFollowAngle());
if (!pet->IsPositionValid())
{
sLog->outError("Pet (guidlow %d, entry %d) not loaded. Suggested coordinates isn't valid (X: %f Y: %f)", pet->GetGUIDLow(), pet->GetEntry(), pet->GetPositionX(), pet->GetPositionY());
delete pet;
delete holder;
return PET_LOAD_ERROR;
}
pet->SetLoading(true);
pet->Relocate(px, py, pz, owner->GetOrientation());
pet->setPetType(pet_type);
pet->setFaction(owner->getFaction());
pet->SetUInt32Value(UNIT_CREATED_BY_SPELL, summon_spell_id);
if (pet->IsCritter())
{
map->AddToMap(pet->ToCreature(), true);
pet->SetLoading(false); // xinef, mine
delete holder;
return PET_LOAD_OK;
}
pet->GetCharmInfo()->SetPetNumber(pet_number, pet->IsPermanentPetFor(owner));
pet->SetDisplayId(fields[3].GetUInt32());
pet->SetNativeDisplayId(fields[3].GetUInt32());
uint32 petlevel = fields[4].GetUInt8();
pet->SetUInt32Value(UNIT_NPC_FLAGS, UNIT_NPC_FLAG_NONE);
pet->SetName(fields[8].GetString());
switch (pet->getPetType())
{
case SUMMON_PET:
petlevel = owner->getLevel();
if (pet->IsPetGhoul())
pet->SetUInt32Value(UNIT_FIELD_BYTES_0, 0x400); // class = rogue
else
pet->SetUInt32Value(UNIT_FIELD_BYTES_0, 0x800); // class = mage
pet->SetUInt32Value(UNIT_FIELD_FLAGS, UNIT_FLAG_PVP_ATTACKABLE);
// this enables popup window (pet dismiss, cancel)
break;
case HUNTER_PET:
pet->SetUInt32Value(UNIT_FIELD_BYTES_0, 0x02020100); // class = warrior, gender = none, power = focus
pet->SetSheath(SHEATH_STATE_MELEE);
pet->SetByteFlag(UNIT_FIELD_BYTES_2, 2, fields[9].GetBool() ? UNIT_CAN_BE_ABANDONED : UNIT_CAN_BE_RENAMED | UNIT_CAN_BE_ABANDONED);
pet->SetUInt32Value(UNIT_FIELD_FLAGS, UNIT_FLAG_PVP_ATTACKABLE);
// this enables popup window (pet abandon, cancel)
pet->SetMaxPower(POWER_HAPPINESS, pet->GetCreatePowers(POWER_HAPPINESS));
pet->SetPower(POWER_HAPPINESS, fields[12].GetUInt32());
pet->setPowerType(POWER_FOCUS);
break;
default:
if (!pet->IsPetGhoul())
sLog->outError("Pet have incorrect type (%u) for pet loading.", pet->getPetType());
break;
}
pet->SetUInt32Value(UNIT_FIELD_PET_NAME_TIMESTAMP, uint32(time(NULL))); // cast can't be helped here
pet->SetCreatorGUID(owner->GetGUID());
owner->SetMinion(pet, true);
pet->InitStatsForLevel(petlevel);
pet->SetUInt32Value(UNIT_FIELD_PETEXPERIENCE, fields[5].GetUInt32());
pet->SynchronizeLevelWithOwner();
pet->SetReactState(ReactStates(fields[6].GetUInt8()));
pet->SetCanModifyStats(true);
// 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 (petSlot)
{
SQLTransaction trans = CharacterDatabase.BeginTransaction();
PreparedStatement* stmt = CharacterDatabase.GetPreparedStatement(CHAR_UDP_CHAR_PET_SLOT_BY_SLOT_EXCLUDE_ID);
stmt->setUInt8(0, uint8(PET_SAVE_NOT_IN_SLOT));
stmt->setUInt32(1, owner->GetGUIDLow());
stmt->setUInt8(2, uint8(PET_SAVE_AS_CURRENT));
stmt->setUInt32(3, pet_number);
trans->Append(stmt);
stmt = CharacterDatabase.GetPreparedStatement(CHAR_UPD_CHAR_PET_SLOT_BY_ID);
stmt->setUInt8(0, uint8(PET_SAVE_AS_CURRENT));
stmt->setUInt32(1, owner->GetGUIDLow());
stmt->setUInt32(2, pet_number);
trans->Append(stmt);
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);
}
// do it as early as possible!
pet->InitTalentForLevel(); // set original talents points before spell loading
if (!is_temporary_summoned)
pet->GetCharmInfo()->InitPetActionBar();
map->AddToMap(pet->ToCreature(), true);
if (pet->getPetType() == SUMMON_PET && !current) //all (?) summon pets come with full health when called, but not when they are current
pet->SetPower(POWER_MANA, pet->GetMaxPower(POWER_MANA));
else
{
pet->SetHealth(savedhealth > pet->GetMaxHealth() ? pet->GetMaxHealth() : savedhealth);
pet->SetPower(POWER_MANA, savedmana > pet->GetMaxPower(POWER_MANA) ? pet->GetMaxPower(POWER_MANA) : savedmana);
}
pet->SetAsynchLoadType(asynchLoadType);
// xinef: clear any old result
if (_loadPetFromDBSecondCallback.ready())
{
SQLQueryHolder* param;
_loadPetFromDBSecondCallback.get(param);
delete param;
}
_loadPetFromDBSecondCallback.cancel();
_loadPetFromDBSecondCallback = CharacterDatabase.DelayQueryHolder((SQLQueryHolder*)holder);
return PET_LOAD_OK;
}
// this procedure handles clients CMSG_REQUEST_PARTY_MEMBER_STATS request
void WorldSession::HandleRequestPartyMemberStatsOpcode(WorldPacket& recv_data)
{
DEBUG_LOG("WORLD: Received CMSG_REQUEST_PARTY_MEMBER_STATS");
ObjectGuid guid;
recv_data >> guid;
Player* player = ObjectAccessor::FindPlayer(guid, false);
if (!player)
{
WorldPacket data(SMSG_PARTY_MEMBER_STATS_FULL, 1 + 8 + 4 + 2);
data << uint8(0); // only for SMSG_PARTY_MEMBER_STATS_FULL, probably arena/bg related
data << guid.WriteAsPacked();
data << uint32(GROUP_UPDATE_FLAG_STATUS);
data << uint16(MEMBER_STATUS_OFFLINE);
SendPacket(&data);
return;
}
Powers powerType = player->getPowerType();
uint32 updateFlags = GROUP_UPDATE_FLAG_STATUS | GROUP_UPDATE_FLAG_CUR_HP | GROUP_UPDATE_FLAG_MAX_HP |
GROUP_UPDATE_FLAG_CUR_POWER | GROUP_UPDATE_FLAG_MAX_POWER | GROUP_UPDATE_FLAG_LEVEL |
GROUP_UPDATE_FLAG_ZONE | GROUP_UPDATE_FLAG_POSITION | GROUP_UPDATE_FLAG_AURAS |
GROUP_UPDATE_FLAG_PET_NAME | GROUP_UPDATE_FLAG_PET_MODEL_ID | GROUP_UPDATE_FLAG_PET_AURAS;
if (powerType != POWER_MANA)
updateFlags |= GROUP_UPDATE_FLAG_POWER_TYPE;
Pet* pet = player->GetPet();
if (pet)
updateFlags |= GROUP_UPDATE_FLAG_PET_GUID | GROUP_UPDATE_FLAG_PET_CUR_HP | GROUP_UPDATE_FLAG_PET_MAX_HP |
GROUP_UPDATE_FLAG_PET_POWER_TYPE | GROUP_UPDATE_FLAG_PET_CUR_POWER | GROUP_UPDATE_FLAG_PET_MAX_POWER;
if (player->GetVehicle())
updateFlags |= GROUP_UPDATE_FLAG_VEHICLE_SEAT;
uint16 playerStatus = player->IsReferAFriendLinked(player) ? (MEMBER_STATUS_ONLINE | MEMBER_STATUS_RAF) : MEMBER_STATUS_ONLINE;
if (player->IsPvP())
playerStatus |= MEMBER_STATUS_PVP;
if (!player->isAlive())
{
if (player->HasFlag(PLAYER_FLAGS, PLAYER_FLAGS_GHOST))
playerStatus |= MEMBER_STATUS_GHOST;
else
playerStatus |= MEMBER_STATUS_DEAD;
}
if (player->HasByteFlag(UNIT_FIELD_BYTES_2, 1, UNIT_BYTE2_FLAG_FFA_PVP))
playerStatus |= MEMBER_STATUS_PVP_FFA;
if (player->isAFK())
playerStatus |= MEMBER_STATUS_AFK;
if (player->isDND())
playerStatus |= MEMBER_STATUS_DND;
WorldPacket data(SMSG_PARTY_MEMBER_STATS_FULL, 255);
data << uint8(0); // only for SMSG_PARTY_MEMBER_STATS_FULL, probably arena/bg related
data << player->GetPackGUID();
data << uint32(updateFlags);
data << uint16(playerStatus); // GROUP_UPDATE_FLAG_STATUS
data << uint32(player->GetHealth()); // GROUP_UPDATE_FLAG_CUR_HP
data << uint32(player->GetMaxHealth()); // GROUP_UPDATE_FLAG_MAX_HP
if (updateFlags & GROUP_UPDATE_FLAG_POWER_TYPE)
data << uint8(powerType);
data << uint16(player->GetPower(powerType)); // GROUP_UPDATE_FLAG_CUR_POWER
data << uint16(player->GetMaxPower(powerType)); // GROUP_UPDATE_FLAG_MAX_POWER
data << uint16(player->getLevel()); // GROUP_UPDATE_FLAG_LEVEL
// verify player coordinates and zoneid to send to teammates
uint16 iZoneId = 0;
uint16 iCoordX = 0;
uint16 iCoordY = 0;
if (player->IsInWorld())
{
iZoneId = player->GetZoneId();
iCoordX = player->GetPositionX();
iCoordY = player->GetPositionY();
}
else if (player->IsBeingTeleported()) // Player is in teleportation
{
WorldLocation& loc = player->GetTeleportDest(); // So take teleportation destination
iZoneId = sTerrainMgr.GetZoneId(loc.GetMapId(), loc.x, loc.y, loc.z);
iCoordX = loc.x;
iCoordY = loc.y;
}
data << uint16(iZoneId); // GROUP_UPDATE_FLAG_ZONE
data << uint16(iCoordX); // GROUP_UPDATE_FLAG_POSITION
data << uint16(iCoordY); // GROUP_UPDATE_FLAG_POSITION
uint64 auramask = 0;
size_t maskPos = data.wpos();
data << uint64(auramask); // placeholder
for (uint8 i = 0; i < MAX_AURAS; ++i)
{
if (SpellAuraHolderPtr holder = player->GetVisibleAura(i))
{
auramask |= (uint64(1) << i);
data << uint32(holder->GetId());
data << uint8(holder->GetAuraFlags());
}
}
data.put<uint64>(maskPos, auramask); // GROUP_UPDATE_FLAG_AURAS
if(pet)
{
Powers petPowerType = pet->getPowerType();
data << pet->GetObjectGuid(); // GROUP_UPDATE_FLAG_PET_GUID
data << pet->GetName(); // GROUP_UPDATE_FLAG_PET_NAME
data << uint16(pet->GetDisplayId()); // GROUP_UPDATE_FLAG_PET_MODEL_ID
data << uint32(pet->GetHealth()); // GROUP_UPDATE_FLAG_PET_CUR_HP
data << uint32(pet->GetMaxHealth()); // GROUP_UPDATE_FLAG_PET_MAX_HP
data << uint8(petPowerType); // GROUP_UPDATE_FLAG_PET_POWER_TYPE
data << uint16(pet->GetPower(petPowerType)); // GROUP_UPDATE_FLAG_PET_CUR_POWER
data << uint16(pet->GetMaxPower(petPowerType)); // GROUP_UPDATE_FLAG_PET_MAX_POWER
uint64 petAuraMask = 0;
size_t petMaskPos = data.wpos();
data << uint64(petAuraMask); // placeholder
for (uint8 i = 0; i < MAX_AURAS; ++i)
{
if (SpellAuraHolderPtr holder = pet->GetVisibleAura(i))
{
petAuraMask |= (uint64(1) << i);
data << uint32(holder->GetId());
data << uint8(holder->GetAuraFlags());
}
}
data.put<uint64>(petMaskPos, petAuraMask); // GROUP_UPDATE_FLAG_PET_AURAS
}
else
{
data << uint8(0); // GROUP_UPDATE_FLAG_PET_NAME
data << uint16(0); // GROUP_UPDATE_FLAG_PET_MODEL_ID
data << uint64(0); // GROUP_UPDATE_FLAG_PET_AURAS
}
if (updateFlags & GROUP_UPDATE_FLAG_VEHICLE_SEAT)
data << uint32(player->m_movementInfo.GetTransportDBCSeat());
SendPacket(&data);
}
void WorldSession::BuildPartyMemberStatsChangedPacket(Player* player, WorldPacket* data)
{
uint32 mask = player->GetGroupUpdateFlag();
if (mask & GROUP_UPDATE_FLAG_POWER_TYPE) // if update power type, update current/max power also
mask |= (GROUP_UPDATE_FLAG_CUR_POWER | GROUP_UPDATE_FLAG_MAX_POWER);
if (mask & GROUP_UPDATE_FLAG_PET_POWER_TYPE) // same for pets
mask |= (GROUP_UPDATE_FLAG_PET_CUR_POWER | GROUP_UPDATE_FLAG_PET_MAX_POWER);
uint32 byteCount = 0;
for (int i = 1; i < GROUP_UPDATE_FLAGS_COUNT; ++i)
{
if (mask & (1 << i))
byteCount += GroupUpdateLength[i];
}
data->Initialize(SMSG_PARTY_MEMBER_STATS, 8 + 4 + byteCount);
*data << player->GetPackGUID();
*data << uint32(mask);
if (mask & GROUP_UPDATE_FLAG_STATUS)
{
uint16 playerStatus = MEMBER_STATUS_ONLINE;
if (player->IsPvP())
playerStatus |= MEMBER_STATUS_PVP;
if (!player->isAlive())
{
if (player->HasFlag(PLAYER_FLAGS, PLAYER_FLAGS_GHOST))
playerStatus |= MEMBER_STATUS_GHOST;
else
playerStatus |= MEMBER_STATUS_DEAD;
}
if (player->HasByteFlag(UNIT_FIELD_BYTES_2, 1, UNIT_BYTE2_FLAG_FFA_PVP))
playerStatus |= MEMBER_STATUS_PVP_FFA;
if (player->isAFK())
playerStatus |= MEMBER_STATUS_AFK;
if (player->isDND())
playerStatus |= MEMBER_STATUS_DND;
*data << uint16(playerStatus);
}
if (mask & GROUP_UPDATE_FLAG_CUR_HP)
*data << uint32(player->GetHealth());
if (mask & GROUP_UPDATE_FLAG_MAX_HP)
*data << uint32(player->GetMaxHealth());
Powers powerType = player->getPowerType();
if (mask & GROUP_UPDATE_FLAG_POWER_TYPE)
*data << uint8(powerType);
if (mask & GROUP_UPDATE_FLAG_CUR_POWER)
*data << uint16(player->GetPower(powerType));
if (mask & GROUP_UPDATE_FLAG_MAX_POWER)
*data << uint16(player->GetMaxPower(powerType));
if (mask & GROUP_UPDATE_FLAG_LEVEL)
*data << uint16(player->getLevel());
if (mask & GROUP_UPDATE_FLAG_ZONE)
*data << uint16(player->GetZoneId());
if (mask & GROUP_UPDATE_FLAG_POSITION)
*data << uint16(player->GetPositionX()) << uint16(player->GetPositionY());
if (mask & GROUP_UPDATE_FLAG_AURAS)
{
const uint64& auraMask = player->GetAuraUpdateMask();
*data << uint64(auraMask);
for (uint32 i = 0; i < MAX_AURAS; ++i)
{
if (auraMask & (uint64(1) << i))
{
SpellAuraHolderPtr holder = player->GetVisibleAura(i);
*data << uint32(holder ? holder->GetId() : 0);
*data << uint8(holder ? holder->GetAuraFlags() : 0);
}
}
}
Pet* pet = player->GetPet();
if (mask & GROUP_UPDATE_FLAG_PET_GUID)
*data << (pet ? pet->GetObjectGuid() : ObjectGuid());
if (mask & GROUP_UPDATE_FLAG_PET_NAME)
*data << (pet ? pet->GetName() : uint8(0));
if (mask & GROUP_UPDATE_FLAG_PET_MODEL_ID)
*data << uint16(pet ? pet->GetDisplayId() : 0);
if (mask & GROUP_UPDATE_FLAG_PET_CUR_HP)
*data << uint32(pet ? pet->GetHealth() : 0);
if (mask & GROUP_UPDATE_FLAG_PET_MAX_HP)
*data << uint32(pet ? pet->GetMaxHealth() : 0);
if (mask & GROUP_UPDATE_FLAG_PET_POWER_TYPE)
*data << uint8(pet ? pet->getPowerType() : 0);
if (mask & GROUP_UPDATE_FLAG_PET_CUR_POWER)
*data << uint16(pet ? pet->GetPower(pet->getPowerType()) : 0);
if (mask & GROUP_UPDATE_FLAG_PET_MAX_POWER)
*data << uint16(pet ? pet->GetMaxPower(pet->getPowerType()) : 0);
if (mask & GROUP_UPDATE_FLAG_PET_AURAS)
{
if (pet)
{
MAPLOCK_READ(pet, MAP_LOCK_TYPE_AURAS);
const uint64& auramask = pet->GetAuraUpdateMask();
*data << uint64(auramask);
for (uint32 i = 0; i < MAX_AURAS; ++i)
{
if (auramask & (uint64(1) << i))
{
SpellAuraHolderPtr holder = pet->GetVisibleAura(i);
*data << uint32(holder ? holder->GetId() : 0);
*data << uint8(holder ? holder->GetAuraFlags() : 0);
}
}
}
else
*data << uint64(0);
}
if (mask & GROUP_UPDATE_FLAG_VEHICLE_SEAT)
*data << uint32(player->m_movementInfo.GetTransportDBCSeat());
}
void WorldSession::BuildPartyMemberStatsChangedPacket(Player *player, WorldPacket *data)
{
uint32 mask = player->GetGroupUpdateFlag();
if (mask & GROUP_UPDATE_FLAG_POWER_TYPE) // if update power type, update current/max power also
mask |= (GROUP_UPDATE_FLAG_CUR_POWER | GROUP_UPDATE_FLAG_MAX_POWER);
if (mask & GROUP_UPDATE_FLAG_PET_POWER_TYPE) // same for pets
mask |= (GROUP_UPDATE_FLAG_PET_CUR_POWER | GROUP_UPDATE_FLAG_PET_MAX_POWER);
uint32 byteCount = 0;
for (int i = 1; i < GROUP_UPDATE_FLAGS_COUNT; ++i)
if (mask & (1 << i))
byteCount += GroupUpdateLength[i];
data->Initialize(SMSG_PARTY_MEMBER_STATS, 8 + 4 + byteCount);
*data << player->GetPackGUID();
*data << uint32(mask);
if (mask & GROUP_UPDATE_FLAG_STATUS)
{
if (player)
{
if (player->IsPvP())
*data << uint16(MEMBER_STATUS_ONLINE | MEMBER_STATUS_PVP);
else
*data << uint16(MEMBER_STATUS_ONLINE);
}
else
*data << uint16(MEMBER_STATUS_OFFLINE);
}
if (mask & GROUP_UPDATE_FLAG_CUR_HP)
*data << uint32(player->GetHealth());
if (mask & GROUP_UPDATE_FLAG_MAX_HP)
*data << uint32(player->GetMaxHealth());
Powers powerType = player->getPowerType();
if (mask & GROUP_UPDATE_FLAG_POWER_TYPE)
*data << uint8(powerType);
if (mask & GROUP_UPDATE_FLAG_CUR_POWER)
*data << uint16(player->GetPower(powerType));
if (mask & GROUP_UPDATE_FLAG_MAX_POWER)
*data << uint16(player->GetMaxPower(powerType));
if (mask & GROUP_UPDATE_FLAG_LEVEL)
*data << uint16(player->getLevel());
if (mask & GROUP_UPDATE_FLAG_ZONE)
*data << uint16(player->GetZoneId());
if (mask & GROUP_UPDATE_FLAG_POSITION)
*data << uint16(player->GetPositionX()) << uint16(player->GetPositionY());
if (mask & GROUP_UPDATE_FLAG_AURAS)
{
MAPLOCK_READ(player,MAP_LOCK_TYPE_AURAS);
const uint64& auramask = player->GetAuraUpdateMask();
*data << uint64(auramask);
for(uint32 i = 0; i < MAX_AURAS; ++i)
{
if(auramask & (uint64(1) << i))
{
*data << uint32(player->GetVisibleAura(i));
*data << uint8(1);
}
}
}
Pet *pet = player->GetPet();
if (mask & GROUP_UPDATE_FLAG_PET_GUID)
*data << (pet ? pet->GetObjectGuid() : ObjectGuid());
if (mask & GROUP_UPDATE_FLAG_PET_NAME)
{
if(pet)
*data << pet->GetName();
else
*data << uint8(0);
}
if (mask & GROUP_UPDATE_FLAG_PET_MODEL_ID)
{
if(pet)
*data << uint16(pet->GetDisplayId());
else
*data << uint16(0);
}
if (mask & GROUP_UPDATE_FLAG_PET_CUR_HP)
{
if(pet)
*data << uint32(pet->GetHealth());
else
*data << uint32(0);
}
if (mask & GROUP_UPDATE_FLAG_PET_MAX_HP)
{
if(pet)
*data << uint32(pet->GetMaxHealth());
else
*data << uint32(0);
}
if (mask & GROUP_UPDATE_FLAG_PET_POWER_TYPE)
{
if(pet)
*data << uint8(pet->getPowerType());
else
*data << uint8(0);
}
if (mask & GROUP_UPDATE_FLAG_PET_CUR_POWER)
{
if(pet)
*data << uint16(pet->GetPower(pet->getPowerType()));
else
*data << uint16(0);
}
if (mask & GROUP_UPDATE_FLAG_PET_MAX_POWER)
{
if(pet)
*data << uint16(pet->GetMaxPower(pet->getPowerType()));
else
*data << uint16(0);
}
if (mask & GROUP_UPDATE_FLAG_PET_AURAS)
{
if(pet)
{
MAPLOCK_READ(pet,MAP_LOCK_TYPE_AURAS);
const uint64& auramask = pet->GetAuraUpdateMask();
*data << uint64(auramask);
for(uint32 i = 0; i < MAX_AURAS; ++i)
{
if(auramask & (uint64(1) << i))
{
*data << uint32(pet->GetVisibleAura(i));
*data << uint8(1);
}
}
}
else
*data << uint64(0);
}
if (mask & GROUP_UPDATE_FLAG_VEHICLE_SEAT)
*data << uint32(player->m_movementInfo.GetTransportDBCSeat());
}
void PlayerbotHunterAI::DoNextCombatManeuver(Unit *pTarget)
{
if (!pTarget || pTarget->isDead()) return;
PlayerbotAI *ai = GetAI();
if (!ai) return;
Player *m_bot = GetPlayerBot();
if (!m_bot || m_bot->isDead()) return;
Unit *pVictim = pTarget->getVictim();
Unit *m_tank = FindMainTankInRaid(GetMaster());
if (!m_tank && m_bot->GetGroup() && GetMaster()->GetGroup() != m_bot->GetGroup()) { FindMainTankInRaid(m_bot); }
if (!m_tank) { m_tank = m_bot; }
uint32 masterHP = GetMaster()->GetHealth()*100 / GetMaster()->GetMaxHealth();
float pDist = m_bot->GetDistance(pTarget);
uint8 pThreat = GetThreatPercent(pTarget);
Pet *pet = m_bot->GetPet();
if (m_tank->GetGUID() == m_bot->GetGUID() && pet && pet->isAlive() && pet->isInCombat()) { m_tank = pet; }
uint8 petThreat = 0;
if (pet) { GetThreatPercent(pTarget,pet); }
// switch (ai->GetScenarioType())
// {
// case PlayerbotAI::SCENARIO_DUEL:
// ai->CastSpell(RAPTOR_STRIKE);
// return;
// }
// ------- Non Duel combat ----------
#pragma region Choose Target
// Choose Target
if (isUnderAttack()) // I am under attack
{
if (pVictim && pVictim->GetGUID() == m_bot->GetGUID() && pDist <= 2) { } // My target is almost up to me, no need to search
else //Have to select nearest target
{
Unit *curAtt = GetNearestAttackerOf(m_bot);
if (curAtt && curAtt->GetGUID() != pTarget->GetGUID())
{
m_bot->SetSelection(curAtt->GetGUID());
//ai->AddLootGUID(curAtt->GetGUID());
DoNextCombatManeuver(curAtt); //Restart new update to get variables fixed..
return;
}
}
//my target is attacking me
}
#pragma endregion
#pragma region Pet Actions
// Pet's own Actions
if( pet && pet->isAlive() )
{
// Setup pet
if (pet->GetCharmInfo()->IsAtStay()) {pet->GetCharmInfo()->SetCommandState(COMMAND_FOLLOW); }
//Heal pet
if ( ( ((float)pet->GetHealth()/(float)pet->GetMaxHealth()) < 0.5f )
&& ( PET_MEND>0 && !pet->getDeathState() != ALIVE && pVictim != m_bot
&& CastSpell(PET_MEND,m_bot) )) { return; }
// Set pet to attack hunter's attacker > its own attackers > hunter's target
if (!pet->getVictim()) { pet->AI()->AttackStart(pTarget); }
else if (isUnderAttack(m_bot)) { pet->AI()->AttackStart(pTarget); } //Always help hunter if she's under attack
else if (pet->getVictim()->GetGUID() != pTarget->GetGUID() && !isUnderAttack(pet)) { pet->AI()->AttackStart(pTarget); }
else if (isUnderAttack(pet)) // Pet is under attack and hunter has no attackers
{
if ( pet->getVictim()->getVictim() && pet->getVictim()->getVictim()->GetGUID() == pet->GetGUID() && pDist <= 2) { } // My target is almost up to me, no need to search
else //Have to select nearest target
{
Unit *curAtt = GetNearestAttackerOf(pet,true);
if (curAtt && (!pet->getVictim() || curAtt->GetGUID() != pet->getVictim()->GetGUID()))
{
pet->AI()->AttackStart(curAtt); //Attack nearest attacker
}
}
//Actions to do under attack (Always tank it, and try to kill it, until someone (!= hunter) takes aggro back)
//Hunter should help her pet whether main tank or not, unless she's being attacked (BEWARE Targeting Loop possibility)
if (pet->getVictim() && !isUnderAttack(m_bot) && pet->getVictim()->GetGUID() != pTarget->GetGUID())
{
m_bot->SetSelection(pet->getVictim()->GetGUID());
DoNextCombatManeuver(pet->getVictim()); //Restart new update to get variables fixed..
return;
}
}
// Pet tanking behaviour
if (pet->GetGUID() == m_tank->GetGUID() || isUnderAttack(m_bot) || isUnderAttack(pet))
{
if (GROWL) pet->GetCharmInfo()->SetSpellAutocast(GROWL,true); //Autocast growl
if (BAD_ATTITUDE) pet->GetCharmInfo()->SetSpellAutocast(BAD_ATTITUDE,true);
if (COWER) pet->GetCharmInfo()->SetSpellAutocast(COWER,false);
if (CastSpell(INTIMIDATION,m_bot)) { return; }
}
else
{
if (GROWL) pet->GetCharmInfo()->SetSpellAutocast(GROWL,false); //Do not try to get aggro
if (BAD_ATTITUDE) pet->GetCharmInfo()->SetSpellAutocast(BAD_ATTITUDE,false);
if (COWER) pet->GetCharmInfo()->SetSpellAutocast(COWER,true); //Autocast cower
}
// NORMAL PET dps attacks
if (petThreat < threatThreshold || pet->GetGUID() == m_tank->GetGUID() || isUnderAttack(m_bot))
{
if (CastSpell(KILL_COMMAND,m_bot)) { }
else if (CastSpell(BESTIAL_WRATH,m_bot)) { }
}
// NETHERSHOCK DEMORALIZINGSCREECH
}
#pragma endregion
// If there's a cast stop
if(m_bot->HasUnitState(UNIT_STAT_CASTING)) return;
// Cast CC breakers if any match found (does not work yet)
// uint32 ccSpells[4] = { R_ESCAPE_ARTIST, R_EVERY_MAN_FOR_HIMSELF, R_WILL_OF_FORSAKEN, R_STONEFORM };
// if (castSelfCCBreakers(ccSpells)) { } //most of them dont have gcd
#pragma region Evasive manuevers
// Do evasive manuevers if under attack
if (isUnderAttack())
{
if (m_tank->GetGUID() == m_bot->GetGUID()) { } // i am tank and my pet is probably dead, so i have to face the attackers
else if (CastSpell(FEIGN_DEATH,m_bot)) { return; } //avoid attack
//else if (m_bot->getRace() == (uint8) RACE_NIGHTELF && CastSpell(R_SHADOWMELD,m_bot) ) { return; }
else if (CastSpell(CONCUSSIVE_SHOT,pTarget)) { return; }
else if (CastSpell(WYVERN_STING,pTarget)) { return; }
else if (CastSpell(SCATTER_SHOT,pTarget)) { return; }
else if (CastSpell(FREEZING_ARROW,pTarget)) { return; }
else if (CastSpell(MISDIRECTION,m_tank)) { return; }
else if (m_bot->getRace() == (uint8) RACE_TAUREN && pDist < 8 && CastSpell(R_WAR_STOMP, pTarget) ) { return; } //no gcd but is cast
else if (pTarget->GetCreatureType() == (uint32) CREATURE_TYPE_BEAST && CastSpell(SCARE_BEAST,pTarget)) { return; }
else if (pDist <= 2 && CastSpell(FREEZING_TRAP,pTarget)) { return; }
}
#pragma endregion
//Select combat mode
m_role = BOT_ROLE_DPS_RANGED;
if ((isUnderAttack() && pDist <= ATTACK_DISTANCE) || !m_bot->GetUInt32Value(PLAYER_AMMO_ID) ) { m_role = BOT_ROLE_DPS_MELEE; }
TakePosition(pTarget);
#pragma region Buff / Protect
//Buff UP
if (m_bot->getRace() == (uint8) RACE_TROLL && CastSpell(R_BERSERKING,m_bot) ) { } //no GCD
if (m_bot->getRace() == (uint8) RACE_ORC && CastSpell(R_BLOOD_FURY,m_bot) ) { } //no GCD
if (CastSpell(TRUESHOT_AURA, m_bot)) { return; }
if (CastSpell(RAPID_FIRE,m_bot)) { return; }
if (CastSpell(HUNTERS_MARK,pTarget)) { return; }
if ((ai->GetHealthPercent() < 80 || ai->GetManaPercent() < 60 ) && CastSpell(READINESS,m_bot)) { } //no gcd
//Protect yourself if needed
if (m_bot->getRace() == (uint8) RACE_DWARF && ai->GetHealthPercent() < 75 && CastSpell(R_STONEFORM,m_bot) ) { } //no gcd
if (ai->GetHealthPercent() < 20 && CastSpell(DETERRENCE,m_bot)) {} //No GCD
if (m_bot->getRace() == (uint8) RACE_DRAENEI && ai->GetHealthPercent() < 55 && CastSpell(R_GIFT_OF_NAARU,m_bot)) { return; }
//Break Spells
if (m_bot->getRace() == (uint8) RACE_BLOODELF && pDist < 8 && ( pTarget->IsNonMeleeSpellCasted(true) || ai->GetManaPercent() < 20 ) && CastSpell(R_ARCANE_TORRENT, pTarget) ) { } //no gcd
if (pTarget->IsNonMeleeSpellCasted(true) && CastSpell(SILENCING_SHOT, pTarget) ) { return; }
if (pTarget->IsNonMeleeSpellCasted(true) && CastSpell(SCATTER_SHOT, pTarget) ) { return; }
//Catch
if (pTarget->HasUnitMovementFlag(UNIT_FLAG_FLEEING))
{
if (CastSpell(WING_CLIP,pTarget)) return;
if (CastSpell(CONCUSSIVE_SHOT,pTarget)) return;
if (CastSpell(SCATTER_SHOT, pTarget) ) { return; }
}
#pragma endregion
//Do combat
switch (m_role)
{
#pragma region BOT_ROLE_DPS_MELEE
case BOT_ROLE_DPS_MELEE:
if (AUTO_SHOT) { m_bot->InterruptNonMeleeSpells( true, AUTO_SHOT ); } //Stop autoshot
if (CastSpell(ASPECT_OF_THE_MONKEY,m_bot)) { return; } //Get Monkey aspect
if (m_bot->getRace() == (uint8) RACE_TAUREN && pDist < 8 && CastSpell(R_WAR_STOMP, pTarget)) { return; } //no gcd but is cast
// Threat control
if (pThreat < threatThreshold || m_tank->GetGUID() == m_bot->GetGUID() || m_bot->HasAura(MISDIRECTION) ) { } //Continue attack
else
{
if (pet && isUnderAttack(pet) && pet->getVictim() && pet->getVictim()->GetGUID() != pTarget->GetGUID()) //Should be helping pet
{
m_bot->SetSelection(pet->getVictim()->GetGUID());
return;
}
else if (m_tank->getVictim() && m_tank->getVictim()->GetGUID() != pTarget->GetGUID()) // I am attacking wrong target!!
{
m_bot->SetSelection(m_tank->getVictim()->GetGUID());
return;
}
else if (CastSpell(FEIGN_DEATH,m_bot)) { return; }
else { return; } // No more threat reducing spells, just slow down
}
if (CastSpell(RAPTOR_STRIKE,pTarget,true,true)) {} //No gcd
if (CastSpell(MONGOOSE_BITE,pTarget,true,true)) { return; } // Cannot be sure if casted or not
else if (CastSpell(COUNTERATTACK,pTarget,true,true)) { return; } // Cannot be sure if casted or not
if (CastSpell(WING_CLIP,pTarget)) { return; }
if (isUnderAttack(m_tank,6) && CastSpell(SNAKE_TRAP,m_bot)) { return; }
if (isUnderAttack(m_tank,4) && CastSpell(EXPLOSIVE_TRAP,m_bot)) { return; }
if (CastSpell(IMMOLATION_TRAP,m_bot)) { return; }
break;
#pragma endregion
#pragma region BOT_ROLE_DPS_RANGED
case BOT_ROLE_DPS_RANGED:
if (m_pulling) {
if (GetAI()->CastSpell(CONCUSSIVE_SHOT,pTarget) ||
GetAI()->CastSpell(AUTO_SHOT,pTarget)) {
m_pulling = false;
GetAI()->SetCombatOrder(ORDERS_NONE);
GetAI()->Follow(*GetMaster());
GetAI()->SetIgnoreUpdateTime(2);
if(HasPet(GetPlayerBot()))
m_bot->GetPet()->SetReactState(REACT_DEFENSIVE);
}
return;
}
if (AUTO_SHOT && !m_bot->FindCurrentSpellBySpellId(AUTO_SHOT)) { ai->CastSpell(AUTO_SHOT,pTarget); } //Start autoshot
if (!(ai->GetManaPercent() < 85 && m_bot->HasAura(ASPECT_OF_THE_VIPER)) && CastSpell(ASPECT_OF_THE_HAWK,m_bot)) { return; } //Get Hawk aspect
if ((ai->GetManaPercent() < 25) && CastSpell(ASPECT_OF_THE_VIPER,m_bot,true,false,true)) { return; } //Build up mana
// if i am main tank, protect master by taunt
if(m_tank->GetGUID() == m_bot->GetGUID())
{
// Taunt if needed (Only for master)
Unit *curAtt = GetAttackerOf(GetMaster());
if (curAtt && CastSpell(DISTRACTING_SHOT, curAtt)) { return; }
// My target is not attacking me, taunt..
if (pVictim && pVictim->GetGUID() != m_bot->GetGUID() && CastSpell(DISTRACTING_SHOT, pTarget) ) { return; }
}
// If i am not tank, transfer threat to tank or pet..
else
{
if (CastSpell(MISDIRECTION,m_tank)) { return; }
if (pet && pet->isAlive() && CastSpell(MISDIRECTION,pet)) { return; }
// Threat control
if (pThreat < threatThreshold || m_bot->HasAura(MISDIRECTION) ) { } //Continue attack
else
{
if (pet && isUnderAttack(pet) && pet->getVictim() && pet->getVictim()->GetGUID() != pTarget->GetGUID()) //Should be helping pet
{
m_bot->SetSelection(pet->getVictim()->GetGUID());
return;
}
else if (m_tank->getVictim() && m_tank->getVictim()->GetGUID() != pTarget->GetGUID()) // I am attacking wrong target!!
{
m_bot->SetSelection(m_tank->getVictim()->GetGUID());
return;
}
else if (CastSpell(FEIGN_DEATH,m_bot)) { return; }
else { return; } // No more threat reducing spells, just slow down
}
}
// DO dps
if (ai->GetHealthPercent(*pTarget) < 20 && CastSpell(KILL_SHOT,pTarget)) { return; }
if (isUnderAttack(m_tank,4) && CastSpell(MULTI_SHOT,pTarget)) { return; }
if (isUnderAttack(m_tank,4) && CastSpell(VOLLEY,pTarget)) { GetAI()->SetIgnoreUpdateTime(7); return; }
if (CanCast(CHIMERA_SHOT,pTarget) &&
(pTarget->HasAura(VIPER_STING,m_bot->GetGUID()) || pTarget->HasAura(SERPENT_STING,m_bot->GetGUID()) )
&& CastSpell(CHIMERA_SHOT,pTarget,false) ) { return; }
if (ai->GetManaPercent() < 60 && ai->GetManaPercent(*pTarget) > 4 && CastSpell(VIPER_STING,pTarget)) { return; }
if (!pTarget->HasAura(VIPER_STING,m_bot->GetGUID()) && CastSpell(SERPENT_STING,pTarget)) { return; }
if (CastSpell(ARCANE_SHOT,pTarget)) { return; }
if (CastSpell(BLACK_ARROW,pTarget)) { return; }
if (CastSpell(EXPLOSIVE_SHOT,pTarget)) { return; }
if (CastSpell(STEADY_SHOT,pTarget)) { return; }
break;
#pragma endregion
}
/*// drink potion if support / healer (Other builds simply overuse mana and waste mana pots)
if(ai->GetManaPercent() < 5 && (m_role == BOT_ROLE_SUPPORT || m_role == BOT_ROLE_HEALER) )
{
Item *pItem = ai->FindPotion();
if(pItem != NULL)
{
if (pItem->GetSpell() && m_bot->HasSpellCooldown(pItem->GetSpell()) ) { return; } //pot is in cooldown
ai->UseItem(*pItem);
}
}*/
} // end DoNextCombatManeuver
// is Resource heavy, do not spam or use heavily in loop
Unit *PlayerbotClassAI::FindMainTankInRaid(Player *gPlayer)
{
// check if original main tank is still alive. No point regetting main
// tank b/c chances are slim that it will not get reset in the middle of a fight.
// But if main tank dies, try to find next best canidate
if (mainTank!=NULL && mainTank->isAlive()) {
return mainTank;
}
if (!gPlayer) return NULL;
Group *pGroup = gPlayer->GetGroup();
if (!pGroup) return NULL;
uint64 pLeaderGuid = pGroup->GetLeaderGUID();
Unit *pPlayer = NULL;
// Check if set in raid
if (pGroup->isRaidGroup())
{
QueryResult result = CharacterDatabase.PQuery("SELECT memberGuid FROM group_member WHERE memberFlags='%u' AND guid = '%u'",MEMBER_FLAG_MAINTANK, pGroup->GetGUID());
if(result)
{
uint64 pGuid = MAKE_NEW_GUID(result->Fetch()->GetInt32(),0,HIGHGUID_PLAYER);
pPlayer = ObjectAccessor::FindPlayer(pGuid);
if (pPlayer && pGroup->IsMember(pGuid) && pPlayer->isAlive()){
mainTank = pPlayer;
return pPlayer;
}
}
}
// if could not find tank try assuming
// Assume the one with highest health is the main tank
uint32 maxhpfound=0;
std::list<Unit*> unitList;
gPlayer->GetRaidMember(unitList,30);
if (!unitList.empty()){
for (std::list<Unit*>::iterator itr = unitList.begin() ; itr!=unitList.end();++itr) {
//Player *tPlayer = GetPlayerBot()->GetObjPlayer((*itr)->GetGUID());
Unit *tPlayer = ObjectAccessor::FindPlayer((*itr)->GetGUID());
if (tPlayer == NULL) continue;
if (tPlayer->isDead()) continue;
if (GetPlayerBot()->GetAreaId() != tPlayer->GetAreaId()) continue;
//if(tPlayer->GetGUID() == GetPlayerBot()->GetGUID()) continue;
if (GetPlayerBot()->GetDistance(tPlayer) > 50) continue;
if (tPlayer->GetMaxHealth() > maxhpfound) { maxhpfound = tPlayer->GetMaxHealth(); pPlayer=tPlayer; }
// Also check pets
if ( (tPlayer->getClass() == (uint8) CLASS_HUNTER || tPlayer->getClass() == (uint8) CLASS_WARLOCK) && IS_PET_GUID(tPlayer->GetPetGUID()) )
{
Pet* tpet = ObjectAccessor::GetPet(*tPlayer, tPlayer->GetPetGUID());
if (!tpet || !tpet->IsInWorld() || !tpet->isDead()) continue;
if (tpet->GetArmor() > tPlayer->GetArmor()) //Probably a tanking capable pet..
{
if (tpet->GetMaxHealth() > maxhpfound) { maxhpfound = tpet->GetMaxHealth(); pPlayer=tpet; }
else if (tPlayer->GetGUID() == pPlayer->GetGUID()) {pPlayer = tpet;} //set pet as tank instead of owner
}
}
}
}
mainTank = pPlayer;
return pPlayer;
}
void PlayerbotHunterAI::DoNonCombatActions()
{
PlayerbotAI *ai = GetAI();
Player *m_bot = GetPlayerBot();
if (!m_bot || !ai || m_bot->isDead()) { return; }
//If Casting or Eating/Drinking return
if (m_bot->HasUnitState(UNIT_STAT_CASTING)) { return; }
if (m_bot->getStandState() == UNIT_STAND_STATE_SIT) { return; }
// buff group
if (CastSpell(TRUESHOT_AURA, m_bot)) { return; }
//mana/hp check
//Don't bother with eating, if low on hp, just let it heal themself
if (m_bot->getRace() == (uint8) RACE_UNDEAD_PLAYER && ai->GetHealthPercent() < 75 && CastSpell(R_CANNIBALIZE,m_bot)) { return; }
if (ai->GetManaPercent() < 20 || ai->GetHealthPercent() < 30) { ai->Feast(); }
#pragma region Check Pet
// check for pet
if( PET_SUMMON>0 && !m_petSummonFailed && HasPet(m_bot) )
{
// we can summon pet, and no critical summon errors before
Pet *pet = m_bot->GetPet();
if( !pet )
{
// summon pet
if( PET_SUMMON>0 && ai->CastSpell(PET_SUMMON,m_bot) )
ai->TellMaster( "summoning pet." );
else
{
m_petSummonFailed = true;
ai->TellMaster( "summon pet failed!" );
}
}
else if( pet->getDeathState() != ALIVE )
{
// revive pet
if( PET_REVIVE>0 && ai->GetManaPercent()>=80 && ai->CastSpell(PET_REVIVE,m_bot) )
ai->TellMaster( "reviving pet." );
}
else if( ((float)pet->GetHealth()/(float)pet->GetMaxHealth()) < 0.5f )
{
// heal pet when health lower 50%
if( PET_MEND>0 && !pet->getDeathState() != ALIVE && !pet->HasAura(PET_MEND,0) && ai->GetManaPercent()>=13 && ai->CastSpell(PET_MEND,m_bot) )
ai->TellMaster( "healing pet." );
}
else if(pet->GetHappinessState() != HAPPY) // if pet is hungry
{
Unit *caster = (Unit*)m_bot;
// list out items in main backpack
for (uint8 slot = INVENTORY_SLOT_ITEM_START; slot < INVENTORY_SLOT_ITEM_END; slot++)
{
Item* const pItem = m_bot->GetItemByPos(INVENTORY_SLOT_BAG_0, slot);
if (pItem)
{
const ItemTemplate* const pItemProto = pItem->GetTemplate();
if (!pItemProto )
continue;
if(pet->HaveInDiet(pItemProto)) // is pItem in pets diet
{
//sLog.outDebug("Food for pet: %s",pItemProto->Name1);
caster->CastSpell(caster,51284,true); // pet feed visual
uint32 count = 1; // number of items used
int32 benefit = pet->GetCurrentFoodBenefitLevel(pItemProto->ItemLevel); // nutritional value of food
m_bot->DestroyItemCount(pItem,count,true); // remove item from inventory
m_bot->CastCustomSpell(m_bot,PET_FEED,&benefit,NULL,NULL,true); // feed pet
ai->TellMaster( "feeding pet." );
ai->SetIgnoreUpdateTime(10);
return;
}
}
}
// list out items in other removable backpacks
for (uint8 bag = INVENTORY_SLOT_BAG_START; bag < INVENTORY_SLOT_BAG_END; ++bag)
{
const Bag* const pBag = (Bag*) m_bot->GetItemByPos(INVENTORY_SLOT_BAG_0, bag);
if (pBag)
{
for (uint8 slot = 0; slot < pBag->GetBagSize(); ++slot)
{
Item* const pItem = m_bot->GetItemByPos(bag, slot);
if (pItem)
{
const ItemTemplate* const pItemProto = pItem->GetTemplate();
if (!pItemProto )
continue;
if(pet->HaveInDiet(pItemProto)) // is pItem in pets diet
{
//sLog.outDebug("Food for pet: %s",pItemProto->Name1);
caster->CastSpell(caster,51284,true); // pet feed visual
uint32 count = 1; // number of items used
int32 benefit = pet->GetCurrentFoodBenefitLevel(pItemProto->ItemLevel); // nutritional value of food
m_bot->DestroyItemCount(pItem,count,true); // remove item from inventory
m_bot->CastCustomSpell(m_bot,PET_FEED,&benefit,NULL,NULL,true); // feed pet
ai->TellMaster( "feeding pet." );
ai->SetIgnoreUpdateTime(10);
return;
}
}
}
}
}
if( pet->HasAura(PET_MEND, 0) && !pet->HasAura(PET_FEED, 0))
ai->TellMaster( "..no pet food!" );
ai->SetIgnoreUpdateTime(7);
}
#pragma endregion
}
} // end DoNonCombatActions
void CPlayer::CreatePet(uint32 entry, bool classcheck)
{
if (classcheck && getClass() != CLASS_HUNTER)
return;
CreatureInfo const *cinfo = sObjectMgr.GetCreatureTemplate(entry);
if (!cinfo)
{
BoxChat << MSG_COLOR_WHITE << " This pet doesn't exist in our database. Please report that creature " << entry << " is missing." << std::endl;
return;
}
CreatureCreatePos pos(GetSession()->GetPlayer(), GetOrientation());
Creature* pCreature = new Creature;
// used guids from specially reserved range (can be 0 if no free values)
uint32 lowguid = sObjectMgr.GenerateStaticCreatureLowGuid();
if (!lowguid)
return;
if (!pCreature->Create(lowguid, pos, cinfo))
{
delete pCreature;
return;
}
//--------------------------------------------------
if (GetPetGuid())
UnsummonPetTemporaryIfAny();
Pet* pet = new Pet(HUNTER_PET);
if (!pet->CreateBaseAtCreature(pCreature))
{
delete pet;
return;
}
pet->SetOwnerGuid(GetObjectGuid());
pet->SetCreatorGuid(GetObjectGuid());
pet->setFaction(getFaction());
pet->SetUInt32Value(UNIT_CREATED_BY_SPELL, 13481);
if (IsPvP())
pet->SetPvP(true);
if (!pet->InitStatsForLevel(pCreature->getLevel()))
{
sLog.outError("Pet::InitStatsForLevel() failed for creature (Entry: %u)!", pCreature->GetEntry());
delete pet;
return;
}
pet->GetCharmInfo()->SetPetNumber(sObjectMgr.GeneratePetNumber(), true);
// this enables pet details window (Shift+P)
pet->AIM_Initialize();
pet->InitPetCreateSpells();
pet->SetHealth(pet->GetMaxHealth());
// add to world
pet->GetMap()->Add((Creature*)pet);
// visual effect for levelup
pet->SetUInt32Value(UNIT_FIELD_LEVEL, 70);
for (auto x = 0; x < 6; x++)
{
pet->SetPower(POWER_HAPPINESS, 66600000);
pet->ModifyLoyalty(150000);
pet->TickLoyaltyChange();
pet->SetTP(350);
}
// caster have pet now
SetPet(pet);
pet->SavePetToDB(PET_SAVE_AS_CURRENT);
PetSpellInitialize();
pet->learnSpell(27052);
pet->learnSpell(35698);
pet->learnSpell(25076);
pet->learnSpell(27048);
pet->learnSpell(27053);
pet->learnSpell(27054);
pet->learnSpell(27062);
pet->learnSpell(27047);
pet->learnSpell(24551);
delete pCreature;
}
void PlayerbotHunterAI::DoNextCombatManeuver(Unit *pTarget)
{
PlayerbotAI* ai = GetAI();
if (!ai)
return;
switch (ai->GetScenarioType())
{
case PlayerbotAI::SCENARIO_DUEL:
ai->CastSpell(RAPTOR_STRIKE);
return;
default:
break;
}
// ------- Non Duel combat ----------
// Hunter
ai->SetInFront(pTarget);
Player *m_bot = GetPlayerBot();
Unit* pVictim = pTarget->getVictim();
// check for pet and heal if neccessary
Pet *pet = m_bot->GetPet();
if ((pet)
&& (((float) pet->GetHealth() / (float) pet->GetMaxHealth()) < 0.5f)
&& (PET_MEND > 0 && !pet->getDeathState() != ALIVE && pVictim != m_bot && !pet->HasAura(PET_MEND, EFFECT_INDEX_0) && ai->GetManaPercent() >= 13 && ai->CastSpell(PET_MEND, *m_bot)))
{
ai->TellMaster("healing pet.");
return;
}
else if ((pet)
&& (INTIMIDATION > 0 && pVictim == pet && !pet->HasAura(INTIMIDATION, EFFECT_INDEX_0) && ai->CastSpell(INTIMIDATION, *m_bot)))
//ai->TellMaster( "casting intimidation." ); // if pet has aggro :)
return;
// racial traits
if (m_bot->getRace() == RACE_ORC && !m_bot->HasAura(BLOOD_FURY, EFFECT_INDEX_0))
ai->CastSpell(BLOOD_FURY, *m_bot);
//ai->TellMaster( "Blood Fury." );
else if (m_bot->getRace() == RACE_TROLL && !m_bot->HasAura(BERSERKING, EFFECT_INDEX_0))
ai->CastSpell(BERSERKING, *m_bot);
//ai->TellMaster( "Berserking." );
// check if ranged combat is possible (set m_rangedCombat and switch auras
float dist = m_bot->GetDistance(pTarget);
if ((dist <= ATTACK_DISTANCE || !m_bot->GetUInt32Value(PLAYER_AMMO_ID)) && m_rangedCombat)
{
// switch to melee combat (target in melee range, out of ammo)
m_rangedCombat = false;
if (!m_bot->GetUInt32Value(PLAYER_AMMO_ID))
ai->TellMaster("Out of ammo!");
// become monkey (increases dodge chance)...
(ASPECT_OF_THE_MONKEY > 0 && !m_bot->HasAura(ASPECT_OF_THE_MONKEY, EFFECT_INDEX_0) && ai->CastSpell(ASPECT_OF_THE_MONKEY, *m_bot));
}
else if (dist > ATTACK_DISTANCE && !m_rangedCombat)
{
// switch to ranged combat
m_rangedCombat = true;
// increase ranged attack power...
(ASPECT_OF_THE_HAWK > 0 && !m_bot->HasAura(ASPECT_OF_THE_HAWK, EFFECT_INDEX_0) && ai->CastSpell(ASPECT_OF_THE_HAWK, *m_bot));
}
else if (m_rangedCombat && !m_bot->HasAura(ASPECT_OF_THE_HAWK, EFFECT_INDEX_0))
// check if we have hawk aspect in ranged combat
(ASPECT_OF_THE_HAWK > 0 && ai->CastSpell(ASPECT_OF_THE_HAWK, *m_bot));
else if (!m_rangedCombat && !m_bot->HasAura(ASPECT_OF_THE_MONKEY, EFFECT_INDEX_0))
// check if we have monkey aspect in melee combat
(ASPECT_OF_THE_MONKEY > 0 && ai->CastSpell(ASPECT_OF_THE_MONKEY, *m_bot));
// activate auto shot
if (AUTO_SHOT > 0 && m_rangedCombat && !m_bot->FindCurrentSpellBySpellId(AUTO_SHOT))
ai->CastSpell(AUTO_SHOT, *pTarget);
//ai->TellMaster( "started auto shot." );
else if (AUTO_SHOT > 0 && m_bot->FindCurrentSpellBySpellId(AUTO_SHOT))
m_bot->InterruptNonMeleeSpells(true, AUTO_SHOT);
//ai->TellMaster( "stopped auto shot." );
// damage spells
std::ostringstream out;
if (m_rangedCombat)
{
out << "Case Ranged";
if (HUNTERS_MARK > 0 && ai->GetManaPercent() >= 3 && !pTarget->HasAura(HUNTERS_MARK, EFFECT_INDEX_0) && ai->CastSpell(HUNTERS_MARK, *pTarget))
out << " > Hunter's Mark";
else if (RAPID_FIRE > 0 && ai->GetManaPercent() >= 3 && !m_bot->HasAura(RAPID_FIRE, EFFECT_INDEX_0) && ai->CastSpell(RAPID_FIRE, *m_bot))
out << " > Rapid Fire";
else if (MULTI_SHOT > 0 && ai->GetManaPercent() >= 13 && ai->GetAttackerCount() >= 3 && ai->CastSpell(MULTI_SHOT, *pTarget))
out << " > Multi-Shot";
else if (ARCANE_SHOT > 0 && ai->GetManaPercent() >= 7 && ai->CastSpell(ARCANE_SHOT, *pTarget))
out << " > Arcane Shot";
else if (CONCUSSIVE_SHOT > 0 && ai->GetManaPercent() >= 6 && !pTarget->HasAura(CONCUSSIVE_SHOT, EFFECT_INDEX_0) && ai->CastSpell(CONCUSSIVE_SHOT, *pTarget))
out << " > Concussive Shot";
else if (EXPLOSIVE_SHOT > 0 && ai->GetManaPercent() >= 10 && !pTarget->HasAura(EXPLOSIVE_SHOT, EFFECT_INDEX_0) && ai->CastSpell(EXPLOSIVE_SHOT, *pTarget))
out << " > Explosive Shot";
else if (VIPER_STING > 0 && ai->GetManaPercent() >= 8 && pTarget->GetPower(POWER_MANA) > 0 && ai->GetManaPercent() < 70 && !pTarget->HasAura(VIPER_STING, EFFECT_INDEX_0) && ai->CastSpell(VIPER_STING, *pTarget))
out << " > Viper Sting";
else if (SERPENT_STING > 0 && ai->GetManaPercent() >= 13 && !pTarget->HasAura(SERPENT_STING, EFFECT_INDEX_0) && !pTarget->HasAura(SCORPID_STING, EFFECT_INDEX_0) && !pTarget->HasAura(VIPER_STING, EFFECT_INDEX_0) && ai->CastSpell(SERPENT_STING, *pTarget))
out << " > Serpent Sting";
else if (SCORPID_STING > 0 && ai->GetManaPercent() >= 11 && !pTarget->HasAura(WYVERN_STING, EFFECT_INDEX_0) && !pTarget->HasAura(SCORPID_STING, EFFECT_INDEX_0) && !pTarget->HasAura(SERPENT_STING, EFFECT_INDEX_0) && !pTarget->HasAura(VIPER_STING, EFFECT_INDEX_0) && ai->CastSpell(SCORPID_STING, *pTarget))
out << " > Scorpid Sting";
else if (CHIMERA_SHOT > 0 && ai->GetManaPercent() >= 12 && ai->CastSpell(CHIMERA_SHOT, *pTarget))
out << " > Chimera Shot";
else if (VOLLEY > 0 && ai->GetManaPercent() >= 24 && ai->GetAttackerCount() >= 3 && ai->CastSpell(VOLLEY, *pTarget))
out << " > Volley";
else if (BLACK_ARROW > 0 && ai->GetManaPercent() >= 6 && !pTarget->HasAura(BLACK_ARROW, EFFECT_INDEX_0) && ai->CastSpell(BLACK_ARROW, *pTarget))
out << " > Black Arrow";
else if (AIMED_SHOT > 0 && ai->GetManaPercent() >= 12 && ai->CastSpell(AIMED_SHOT, *pTarget))
out << " > Aimed Shot";
else if (STEADY_SHOT > 0 && ai->GetManaPercent() >= 5 && ai->CastSpell(STEADY_SHOT, *pTarget))
out << " > Steady Shot";
else if (KILL_SHOT > 0 && ai->GetManaPercent() >= 7 && pTarget->GetHealth() < pTarget->GetMaxHealth() * 0.2 && ai->CastSpell(KILL_SHOT, *pTarget))
out << " > Kill Shot!";
else
out << " NONE!";
}
else
{
out << "Case Melee";
if (RAPTOR_STRIKE > 0 && ai->GetManaPercent() >= 6 && ai->CastSpell(RAPTOR_STRIKE, *pTarget))
out << " > Raptor Strike";
else if (EXPLOSIVE_TRAP > 0 && ai->GetManaPercent() >= 27 && !pTarget->HasAura(EXPLOSIVE_TRAP, EFFECT_INDEX_0) && !pTarget->HasAura(ARCANE_TRAP, EFFECT_INDEX_0) && !pTarget->HasAura(IMMOLATION_TRAP, EFFECT_INDEX_0) && !pTarget->HasAura(FROST_TRAP, EFFECT_INDEX_0) && !pTarget->HasAura(BEAR_TRAP, EFFECT_INDEX_0) && ai->CastSpell(EXPLOSIVE_TRAP, *pTarget))
out << " > Explosive Trap";
else if (WING_CLIP > 0 && ai->GetManaPercent() >= 6 && !pTarget->HasAura(WING_CLIP, EFFECT_INDEX_0) && ai->CastSpell(WING_CLIP, *pTarget))
out << " > Wing Clip";
else if (IMMOLATION_TRAP > 0 && ai->GetManaPercent() >= 13 && !pTarget->HasAura(IMMOLATION_TRAP, EFFECT_INDEX_0) && !pTarget->HasAura(ARCANE_TRAP, EFFECT_INDEX_0) && !pTarget->HasAura(EXPLOSIVE_TRAP, EFFECT_INDEX_0) && !pTarget->HasAura(FROST_TRAP, EFFECT_INDEX_0) && !pTarget->HasAura(BEAR_TRAP, EFFECT_INDEX_0) && ai->CastSpell(IMMOLATION_TRAP, *pTarget))
out << " > Immolation Trap";
else if (MONGOOSE_BITE > 0 && ai->GetManaPercent() >= 4 && ai->CastSpell(MONGOOSE_BITE, *pTarget))
out << " > Mongoose Bite";
else if (FROST_TRAP > 0 && ai->GetManaPercent() >= 2 && !pTarget->HasAura(FROST_TRAP, EFFECT_INDEX_0) && !pTarget->HasAura(ARCANE_TRAP, EFFECT_INDEX_0) && !pTarget->HasAura(IMMOLATION_TRAP, EFFECT_INDEX_0) && !pTarget->HasAura(EXPLOSIVE_TRAP, EFFECT_INDEX_0) && !pTarget->HasAura(BEAR_TRAP, EFFECT_INDEX_0) && ai->CastSpell(FROST_TRAP, *pTarget))
out << " > Frost Trap";
else if (ARCANE_TRAP > 0 && !pTarget->HasAura(ARCANE_TRAP, EFFECT_INDEX_0) && !pTarget->HasAura(BEAR_TRAP, EFFECT_INDEX_0) && !pTarget->HasAura(EXPLOSIVE_TRAP, EFFECT_INDEX_0) && !pTarget->HasAura(IMMOLATION_TRAP, EFFECT_INDEX_0) && !pTarget->HasAura(FROST_TRAP, EFFECT_INDEX_0) && ai->CastSpell(ARCANE_TRAP, *pTarget))
out << " > Arcane Trap";
else if (DETERRENCE > 0 && pVictim == m_bot && m_bot->GetHealth() < m_bot->GetMaxHealth() * 0.5 && !m_bot->HasAura(DETERRENCE, EFFECT_INDEX_0) && ai->CastSpell(DETERRENCE, *m_bot))
out << " > Deterrence";
else if (m_bot->getRace() == RACE_TAUREN && !pTarget->HasAura(WAR_STOMP, EFFECT_INDEX_0) && ai->CastSpell(WAR_STOMP, *pTarget))
out << " > War Stomp";
else if (m_bot->getRace() == RACE_BLOODELF && !pTarget->HasAura(ARCANE_TORRENT, EFFECT_INDEX_0) && ai->CastSpell(ARCANE_TORRENT, *pTarget))
out << " > Arcane Torrent";
else if (m_bot->getRace() == RACE_DWARF && m_bot->HasAuraState(AURA_STATE_DEADLY_POISON) && ai->CastSpell(STONEFORM, *m_bot))
out << " > Stoneform";
else if (m_bot->getRace() == RACE_NIGHTELF && pVictim == m_bot && ai->GetHealthPercent() < 25 && !m_bot->HasAura(SHADOWMELD, EFFECT_INDEX_0) && ai->CastSpell(SHADOWMELD, *m_bot))
out << " > Shadowmeld";
else if (m_bot->getRace() == RACE_DRAENEI && ai->GetHealthPercent() < 25 && !m_bot->HasAura(GIFT_OF_THE_NAARU, EFFECT_INDEX_0) && ai->CastSpell(GIFT_OF_THE_NAARU, *m_bot))
out << " > Gift of the Naaru";
else if ((pet && !pet->getDeathState() != ALIVE)
&& (MISDIRECTION > 0 && pVictim == m_bot && !m_bot->HasAura(MISDIRECTION, EFFECT_INDEX_0) && ai->GetManaPercent() >= 9 && ai->CastSpell(MISDIRECTION, *pet)))
out << " > Misdirection"; // give threat to pet
/*else if( FREEZING_TRAP>0 && ai->GetManaPercent()>=5 && !pTarget->HasAura(FREEZING_TRAP, EFFECT_INDEX_0) && !pTarget->HasAura(ARCANE_TRAP, EFFECT_INDEX_0) && !pTarget->HasAura(EXPLOSIVE_TRAP, EFFECT_INDEX_0) && !pTarget->HasAura(BEAR_TRAP, EFFECT_INDEX_0) && !pTarget->HasAura(IMMOLATION_TRAP, EFFECT_INDEX_0) && !pTarget->HasAura(FROST_TRAP, EFFECT_INDEX_0) && ai->CastSpell(FREEZING_TRAP,*pTarget) )
out << " > Freezing Trap"; // this can trap your bots too
else if( BEAR_TRAP>0 && !pTarget->HasAura(BEAR_TRAP, EFFECT_INDEX_0) && !pTarget->HasAura(ARCANE_TRAP, EFFECT_INDEX_0) && !pTarget->HasAura(EXPLOSIVE_TRAP, EFFECT_INDEX_0) && !pTarget->HasAura(IMMOLATION_TRAP, EFFECT_INDEX_0) && !pTarget->HasAura(FROST_TRAP, EFFECT_INDEX_0) && ai->CastSpell(BEAR_TRAP,*pTarget) )
out << " > Bear Trap"; // this was just too annoying :)
else if( DISENGAGE>0 && pVictim && ai->GetManaPercent()>=5 && ai->CastSpell(DISENGAGE,*pTarget) )
out << " > Disengage!"; // attempt to return to ranged combat*/
else
out << " NONE!";
}
if (ai->GetManager()->m_confDebugWhisper)
ai->TellMaster(out.str().c_str());
} // end DoNextCombatManeuver
/*this procedure handles clients CMSG_REQUEST_PARTY_MEMBER_STATS request*/
void WorldSession::HandleRequestPartyMemberStatsOpcode(WorldPacket &recvData)
{
TC_LOG_DEBUG("network", "WORLD: Received CMSG_REQUEST_PARTY_MEMBER_STATS");
uint64 Guid;
recvData >> Guid;
Player* player = HashMapHolder<Player>::Find(Guid);
if (!player)
{
WorldPacket data(SMSG_PARTY_MEMBER_STATS_FULL, 3+4+2);
data << uint8(0); // only for SMSG_PARTY_MEMBER_STATS_FULL, probably arena/bg related
data.appendPackGUID(Guid);
data << uint32(GROUP_UPDATE_FLAG_STATUS);
data << uint16(MEMBER_STATUS_OFFLINE);
SendPacket(&data);
return;
}
Pet* pet = player->GetPet();
Powers powerType = player->getPowerType();
WorldPacket data(SMSG_PARTY_MEMBER_STATS_FULL, 4+2+2+2+1+2*6+8+1+8);
data << uint8(0); // only for SMSG_PARTY_MEMBER_STATS_FULL, probably arena/bg related
data.append(player->GetPackGUID());
uint32 updateFlags = GROUP_UPDATE_FLAG_STATUS | GROUP_UPDATE_FLAG_CUR_HP | GROUP_UPDATE_FLAG_MAX_HP
| GROUP_UPDATE_FLAG_CUR_POWER | GROUP_UPDATE_FLAG_MAX_POWER | GROUP_UPDATE_FLAG_LEVEL
| GROUP_UPDATE_FLAG_ZONE | GROUP_UPDATE_FLAG_POSITION | GROUP_UPDATE_FLAG_AURAS
| GROUP_UPDATE_FLAG_PET_NAME | GROUP_UPDATE_FLAG_PET_MODEL_ID | GROUP_UPDATE_FLAG_PET_AURAS;
if (powerType != POWER_MANA)
updateFlags |= GROUP_UPDATE_FLAG_POWER_TYPE;
if (pet)
updateFlags |= GROUP_UPDATE_FLAG_PET_GUID | GROUP_UPDATE_FLAG_PET_CUR_HP | GROUP_UPDATE_FLAG_PET_MAX_HP
| GROUP_UPDATE_FLAG_PET_POWER_TYPE | GROUP_UPDATE_FLAG_PET_CUR_POWER | GROUP_UPDATE_FLAG_PET_MAX_POWER;
if (player->GetVehicle())
updateFlags |= GROUP_UPDATE_FLAG_VEHICLE_SEAT;
uint16 playerStatus = MEMBER_STATUS_ONLINE;
if (player->IsPvP())
playerStatus |= MEMBER_STATUS_PVP;
if (!player->IsAlive())
{
if (player->HasFlag(PLAYER_FLAGS, PLAYER_FLAGS_GHOST))
playerStatus |= MEMBER_STATUS_GHOST;
else
playerStatus |= MEMBER_STATUS_DEAD;
}
if (player->IsFFAPvP())
playerStatus |= MEMBER_STATUS_PVP_FFA;
if (player->isAFK())
playerStatus |= MEMBER_STATUS_AFK;
if (player->isDND())
playerStatus |= MEMBER_STATUS_DND;
data << uint32(updateFlags);
data << uint16(playerStatus); // GROUP_UPDATE_FLAG_STATUS
data << uint32(player->GetHealth()); // GROUP_UPDATE_FLAG_CUR_HP
data << uint32(player->GetMaxHealth()); // GROUP_UPDATE_FLAG_MAX_HP
if (updateFlags & GROUP_UPDATE_FLAG_POWER_TYPE)
data << uint8(powerType);
data << uint16(player->GetPower(powerType)); // GROUP_UPDATE_FLAG_CUR_POWER
data << uint16(player->GetMaxPower(powerType)); // GROUP_UPDATE_FLAG_MAX_POWER
data << uint16(player->getLevel()); // GROUP_UPDATE_FLAG_LEVEL
data << uint16(player->GetZoneId()); // GROUP_UPDATE_FLAG_ZONE
data << uint16(player->GetPositionX()); // GROUP_UPDATE_FLAG_POSITION
data << uint16(player->GetPositionY()); // GROUP_UPDATE_FLAG_POSITION
uint64 auraMask = 0;
size_t maskPos = data.wpos();
data << uint64(auraMask); // placeholder
for (uint8 i = 0; i < MAX_AURAS; ++i)
{
if (AuraApplication const* aurApp = player->GetVisibleAura(i))
{
auraMask |= uint64(1) << i;
data << uint32(aurApp->GetBase()->GetId());
data << uint8(aurApp->GetFlags());
}
}
data.put<uint64>(maskPos, auraMask); // GROUP_UPDATE_FLAG_AURAS
if (updateFlags & GROUP_UPDATE_FLAG_PET_GUID)
data << uint64(pet->GetGUID());
data << std::string(pet ? pet->GetName() : ""); // GROUP_UPDATE_FLAG_PET_NAME
data << uint16(pet ? pet->GetDisplayId() : 0); // GROUP_UPDATE_FLAG_PET_MODEL_ID
if (updateFlags & GROUP_UPDATE_FLAG_PET_CUR_HP)
data << uint32(pet->GetHealth());
if (updateFlags & GROUP_UPDATE_FLAG_PET_MAX_HP)
data << uint32(pet->GetMaxHealth());
if (updateFlags & GROUP_UPDATE_FLAG_PET_POWER_TYPE)
data << (uint8)pet->getPowerType();
if (updateFlags & GROUP_UPDATE_FLAG_PET_CUR_POWER)
data << uint16(pet->GetPower(pet->getPowerType()));
if (updateFlags & GROUP_UPDATE_FLAG_PET_MAX_POWER)
data << uint16(pet->GetMaxPower(pet->getPowerType()));
uint64 petAuraMask = 0;
maskPos = data.wpos();
data << uint64(petAuraMask); // placeholder
if (pet)
{
for (uint8 i = 0; i < MAX_AURAS; ++i)
{
if (AuraApplication const* aurApp = pet->GetVisibleAura(i))
{
petAuraMask |= uint64(1) << i;
data << uint32(aurApp->GetBase()->GetId());
data << uint8(aurApp->GetFlags());
}
}
}
data.put<uint64>(maskPos, petAuraMask); // GROUP_UPDATE_FLAG_PET_AURAS
if (updateFlags & GROUP_UPDATE_FLAG_VEHICLE_SEAT)
data << uint32(player->GetVehicle()->GetVehicleInfo()->m_seatID[player->m_movementInfo.transport.seat]);
SendPacket(&data);
}
/*this procedure handles clients CMSG_REQUEST_PARTY_MEMBER_STATS request*/
void WorldSession::HandleRequestPartyMemberStatsOpcode(WorldPacket& recvData)
{
sLog->outDebug(LOG_FILTER_NETWORKIO, "WORLD: Received CMSG_REQUEST_PARTY_MEMBER_STATS");
uint64 guid;
recvData >> guid;
Player* player = HashMapHolder<Player>::Find(guid);
if (!player)
{
WorldPacket data(SMSG_PARTY_MEMBER_STATS_FULL, 3+4+2);
data << uint8(0); // only for SMSG_PARTY_MEMBER_STATS_FULL, probably arena/bg related
data.appendPackGUID(guid);
data << (uint32) GROUP_UPDATE_FLAG_STATUS;
data << (uint16) MEMBER_STATUS_OFFLINE;
SendPacket(&data);
return;
}
Pet* pet = player->GetPet();
WorldPacket data(SMSG_PARTY_MEMBER_STATS_FULL);
data << uint8(0); // only for SMSG_PARTY_MEMBER_STATS_FULL, probably arena/bg related
data.append(player->GetPackGUID());
uint32 mask1 = GROUP_UPDATE_FULL;
if (pet)
mask1 |= GROUP_UPDATE_PET;
Powers powerType = player->getPowerType();
data << uint32(mask1); // group update mask
data << uint16(MEMBER_STATUS_ONLINE); // member's online status, GROUP_UPDATE_FLAG_STATUS
data << uint32(player->GetHealth()); // GROUP_UPDATE_FLAG_CUR_HP
data << uint32(player->GetMaxHealth()); // GROUP_UPDATE_FLAG_MAX_HP
data << uint8 (powerType); // GROUP_UPDATE_FLAG_POWER_TYPE
data << uint16(player->GetPower(powerType)); // GROUP_UPDATE_FLAG_CUR_POWER
data << uint16(player->GetMaxPower(powerType)); // GROUP_UPDATE_FLAG_MAX_POWER
data << uint16(player->getLevel()); // GROUP_UPDATE_FLAG_LEVEL
data << uint16(player->GetZoneId()); // GROUP_UPDATE_FLAG_ZONE
data << uint16(0); // GROUP_UPDATE_FLAG_UNK100
data << uint16(player->GetPositionX()); // GROUP_UPDATE_FLAG_POSITION
data << uint16(player->GetPositionY()); // GROUP_UPDATE_FLAG_POSITION
data << uint16(player->GetPositionZ()); // GROUP_UPDATE_FLAG_POSITION
// GROUP_UPDATE_FLAG_AURAS
data << uint8(1);
uint64 auramask = 0;
size_t maskPos = data.wpos();
data << uint64(auramask); // placeholder
data << uint32(MAX_AURAS); // count
for (uint8 i = 0; i < MAX_AURAS; ++i)
{
if (AuraApplication const* aurApp = player->GetVisibleAura(i))
{
auramask |= (uint64(1) << i);
data << uint32(aurApp->GetBase()->GetId());
data << uint16(aurApp->GetFlags());
if (aurApp->GetFlags() & AFLAG_ANY_EFFECT_AMOUNT_SENT)
{
for (uint32 i = 0; i < MAX_SPELL_EFFECTS; ++i)
{
if (AuraEffect const* eff = aurApp->GetBase()->GetEffect(i))
data << int32(eff->GetAmount());
else
data << int32(0);
}
}
}
}
data.put<uint64>(maskPos, auramask); // GROUP_UPDATE_FLAG_AURAS
if (pet)
{
Powers petpowertype = pet->getPowerType();
data << uint64(pet->GetGUID()); // GROUP_UPDATE_FLAG_PET_GUID
data << pet->GetName(); // GROUP_UPDATE_FLAG_PET_NAME
data << uint16(pet->GetDisplayId()); // GROUP_UPDATE_FLAG_PET_MODEL_ID
data << uint32(pet->GetHealth()); // GROUP_UPDATE_FLAG_PET_CUR_HP
data << uint32(pet->GetMaxHealth()); // GROUP_UPDATE_FLAG_PET_MAX_HP
data << uint8 (petpowertype); // GROUP_UPDATE_FLAG_PET_POWER_TYPE
data << uint16(pet->GetPower(petpowertype)); // GROUP_UPDATE_FLAG_PET_CUR_POWER
data << uint16(pet->GetMaxPower(petpowertype)); // GROUP_UPDATE_FLAG_PET_MAX_POWER
// GROUP_UPDATE_FLAG_PET_AURAS
data << uint8(1);
uint64 petauramask = 0;
size_t petMaskPos = data.wpos();
data << uint64(petauramask); // placeholder
data << uint32(MAX_AURAS); // count
for (uint8 i = 0; i < MAX_AURAS; ++i)
{
if (AuraApplication const* aurApp = pet->GetVisibleAura(i))
{
petauramask |= (uint64(1) << i);
data << uint32(aurApp->GetBase()->GetId());
data << uint16(aurApp->GetFlags());
if (aurApp->GetFlags() & AFLAG_ANY_EFFECT_AMOUNT_SENT)
{
for (uint32 i = 0; i < MAX_SPELL_EFFECTS; ++i)
{
if (AuraEffect const* eff = aurApp->GetBase()->GetEffect(i))
data << int32(eff->GetAmount());
else
data << int32(0);
}
}
}
}
data.put<uint64>(petMaskPos, petauramask); // GROUP_UPDATE_FLAG_PET_AURAS
}
// else not needed, flags do not include any PET_ update
// GROUP_UPDATE_FLAG_PHASE
data << uint32(8); // either 0 or 8, same unk found in SMSG_PHASESHIFT
data << uint32(0); // count
// for (count) *data << uint16(phaseId)
SendPacket(&data);
}
void WorldSession::BuildPartyMemberStatsChangedPacket(Player* player, WorldPacket* data)
{
uint32 mask = player->GetGroupUpdateFlag();
if (mask == GROUP_UPDATE_FLAG_NONE)
return;
if (mask & GROUP_UPDATE_FLAG_POWER_TYPE) // if update power type, update current/max power also
mask |= (GROUP_UPDATE_FLAG_CUR_POWER | GROUP_UPDATE_FLAG_MAX_POWER);
if (mask & GROUP_UPDATE_FLAG_PET_POWER_TYPE) // same for pets
mask |= (GROUP_UPDATE_FLAG_PET_CUR_POWER | GROUP_UPDATE_FLAG_PET_MAX_POWER);
uint32 byteCount = 0;
for (int i = 1; i < GROUP_UPDATE_FLAGS_COUNT; ++i)
if (mask & (1 << i))
byteCount += GroupUpdateLength[i];
data->Initialize(SMSG_PARTY_MEMBER_STATS, 8 + 4 + byteCount);
*data << player->GetPackGUID();
*data << uint32(mask);
if (mask & GROUP_UPDATE_FLAG_STATUS)
{
uint16 playerStatus = MEMBER_STATUS_ONLINE;
if (player->IsPvP())
playerStatus |= MEMBER_STATUS_PVP;
if (!player->IsAlive())
{
if (player->HasFlag(PLAYER_FLAGS, PLAYER_FLAGS_GHOST))
playerStatus |= MEMBER_STATUS_GHOST;
else
playerStatus |= MEMBER_STATUS_DEAD;
}
if (player->IsFFAPvP())
playerStatus |= MEMBER_STATUS_PVP_FFA;
if (player->isAFK())
playerStatus |= MEMBER_STATUS_AFK;
if (player->isDND())
playerStatus |= MEMBER_STATUS_DND;
*data << uint16(playerStatus);
}
if (mask & GROUP_UPDATE_FLAG_CUR_HP)
*data << uint32(player->GetHealth());
if (mask & GROUP_UPDATE_FLAG_MAX_HP)
*data << uint32(player->GetMaxHealth());
Powers powerType = player->getPowerType();
if (mask & GROUP_UPDATE_FLAG_POWER_TYPE)
*data << uint8(powerType);
if (mask & GROUP_UPDATE_FLAG_CUR_POWER)
*data << uint16(player->GetPower(powerType));
if (mask & GROUP_UPDATE_FLAG_MAX_POWER)
*data << uint16(player->GetMaxPower(powerType));
if (mask & GROUP_UPDATE_FLAG_LEVEL)
*data << uint16(player->getLevel());
if (mask & GROUP_UPDATE_FLAG_ZONE)
*data << uint16(player->GetZoneId());
if (mask & GROUP_UPDATE_FLAG_POSITION)
{
*data << uint16(player->GetPositionX());
*data << uint16(player->GetPositionY());
}
if (mask & GROUP_UPDATE_FLAG_AURAS)
{
uint64 auramask = player->GetAuraUpdateMaskForRaid();
*data << uint64(auramask);
for (uint32 i = 0; i < MAX_AURAS; ++i)
{
if (auramask & (uint64(1) << i))
{
AuraApplication const* aurApp = player->GetVisibleAura(i);
*data << uint32(aurApp ? aurApp->GetBase()->GetId() : 0);
*data << uint8(1);
}
}
}
Pet* pet = player->GetPet();
if (mask & GROUP_UPDATE_FLAG_PET_GUID)
{
if (pet)
*data << (uint64) pet->GetGUID();
else
*data << (uint64) 0;
}
if (mask & GROUP_UPDATE_FLAG_PET_NAME)
{
if (pet)
*data << pet->GetName();
else
*data << uint8(0);
}
if (mask & GROUP_UPDATE_FLAG_PET_MODEL_ID)
{
if (pet)
*data << uint16(pet->GetDisplayId());
else
*data << uint16(0);
}
if (mask & GROUP_UPDATE_FLAG_PET_CUR_HP)
{
if (pet)
*data << uint32(pet->GetHealth());
else
*data << uint32(0);
}
if (mask & GROUP_UPDATE_FLAG_PET_MAX_HP)
{
if (pet)
*data << uint32(pet->GetMaxHealth());
else
*data << uint32(0);
}
if (mask & GROUP_UPDATE_FLAG_PET_POWER_TYPE)
{
if (pet)
*data << uint8(pet->getPowerType());
else
*data << uint8(0);
}
if (mask & GROUP_UPDATE_FLAG_PET_CUR_POWER)
{
if (pet)
*data << uint16(pet->GetPower(pet->getPowerType()));
else
*data << uint16(0);
}
if (mask & GROUP_UPDATE_FLAG_PET_MAX_POWER)
{
if (pet)
*data << uint16(pet->GetMaxPower(pet->getPowerType()));
else
*data << uint16(0);
}
if (mask & GROUP_UPDATE_FLAG_PET_AURAS)
{
if (pet)
{
uint64 auramask = pet->GetAuraUpdateMaskForRaid();
*data << uint64(auramask);
for (uint32 i = 0; i < MAX_AURAS; ++i)
{
if (auramask & (uint64(1) << i))
{
AuraApplication const* aurApp = pet->GetVisibleAura(i);
*data << uint32(aurApp ? aurApp->GetBase()->GetId() : 0);
*data << uint8(aurApp ? aurApp->GetFlags() : 0);
}
}
}
else
*data << uint64(0);
}
if (mask & GROUP_UPDATE_FLAG_VEHICLE_SEAT)
{
if (Vehicle* veh = player->GetVehicle())
*data << uint32(veh->GetVehicleInfo()->m_seatID[player->m_movementInfo.transport.seat]);
else
*data << uint32(0);
}
}
/*this procedure handles clients CMSG_REQUEST_PARTY_MEMBER_STATS request*/
void WorldSession::HandleRequestPartyMemberStatsOpcode(WorldPacket& recvData)
{
TC_LOG_DEBUG("network", "WORLD: Received CMSG_REQUEST_PARTY_MEMBER_STATS");
ObjectGuid Guid;
recvData >> Guid;
Player* player = ObjectAccessor::FindConnectedPlayer(Guid);
if (!player)
{
WorldPacket data(SMSG_PARTY_MEMBER_STATS_FULL, 3+4+2);
data << uint8(0); // only for SMSG_PARTY_MEMBER_STATS_FULL, probably arena/bg related
data << Guid.WriteAsPacked();
data << uint32(GROUP_UPDATE_FLAG_STATUS);
data << uint16(MEMBER_STATUS_OFFLINE);
SendPacket(&data);
return;
}
Pet* pet = player->GetPet();
Powers powerType = player->getPowerType();
std::set<uint32> const& phases = player->GetPhases();
WorldPacket data(SMSG_PARTY_MEMBER_STATS_FULL, 4+2+2+2+1+2*6+8+1+8);
data << uint8(0); // only for SMSG_PARTY_MEMBER_STATS_FULL, probably arena/bg related
data << player->GetPackGUID();
uint32 updateFlags = GROUP_UPDATE_FLAG_STATUS | GROUP_UPDATE_FLAG_CUR_HP | GROUP_UPDATE_FLAG_MAX_HP
| GROUP_UPDATE_FLAG_CUR_POWER | GROUP_UPDATE_FLAG_MAX_POWER | GROUP_UPDATE_FLAG_LEVEL
| GROUP_UPDATE_FLAG_ZONE | GROUP_UPDATE_FLAG_POSITION | GROUP_UPDATE_FLAG_AURAS
| GROUP_UPDATE_FLAG_PET_NAME | GROUP_UPDATE_FLAG_PET_MODEL_ID | GROUP_UPDATE_FLAG_PET_AURAS;
if (powerType != POWER_MANA)
updateFlags |= GROUP_UPDATE_FLAG_POWER_TYPE;
if (pet)
updateFlags |= GROUP_UPDATE_FLAG_PET_GUID | GROUP_UPDATE_FLAG_PET_CUR_HP | GROUP_UPDATE_FLAG_PET_MAX_HP
| GROUP_UPDATE_FLAG_PET_POWER_TYPE | GROUP_UPDATE_FLAG_PET_CUR_POWER | GROUP_UPDATE_FLAG_PET_MAX_POWER;
if (player->GetVehicle())
updateFlags |= GROUP_UPDATE_FLAG_VEHICLE_SEAT;
if (!phases.empty())
updateFlags |= GROUP_UPDATE_FLAG_PHASE;
uint16 playerStatus = MEMBER_STATUS_ONLINE;
if (player->IsPvP())
playerStatus |= MEMBER_STATUS_PVP;
if (!player->IsAlive())
{
if (player->HasFlag(PLAYER_FLAGS, PLAYER_FLAGS_GHOST))
playerStatus |= MEMBER_STATUS_GHOST;
else
playerStatus |= MEMBER_STATUS_DEAD;
}
if (player->IsFFAPvP())
playerStatus |= MEMBER_STATUS_PVP_FFA;
if (player->isAFK())
playerStatus |= MEMBER_STATUS_AFK;
if (player->isDND())
playerStatus |= MEMBER_STATUS_DND;
data << uint32(updateFlags);
data << uint16(playerStatus); // GROUP_UPDATE_FLAG_STATUS
data << uint32(player->GetHealth()); // GROUP_UPDATE_FLAG_CUR_HP
data << uint32(player->GetMaxHealth()); // GROUP_UPDATE_FLAG_MAX_HP
if (updateFlags & GROUP_UPDATE_FLAG_POWER_TYPE)
data << uint8(powerType);
data << uint16(player->GetPower(powerType)); // GROUP_UPDATE_FLAG_CUR_POWER
data << uint16(player->GetMaxPower(powerType)); // GROUP_UPDATE_FLAG_MAX_POWER
data << uint16(player->getLevel()); // GROUP_UPDATE_FLAG_LEVEL
data << uint16(player->GetZoneId()); // GROUP_UPDATE_FLAG_ZONE
data << uint16(player->GetPositionX()); // GROUP_UPDATE_FLAG_POSITION
data << uint16(player->GetPositionY()); // GROUP_UPDATE_FLAG_POSITION
data << uint16(player->GetPositionZ()); // GROUP_UPDATE_FLAG_POSITION
// GROUP_UPDATE_FLAG_AURAS
data << uint8(1);
uint64 auramask = 0;
size_t maskPos = data.wpos();
data << uint64(auramask); // placeholder
data << uint32(MAX_AURAS); // count
for (uint8 i = 0; i < MAX_AURAS; ++i)
{
if (AuraApplication const* aurApp = player->GetVisibleAura(i))
{
auramask |= (uint64(1) << i);
data << uint32(aurApp->GetBase()->GetId());
data << uint16(aurApp->GetFlags());
if (aurApp->GetFlags() & AFLAG_ANY_EFFECT_AMOUNT_SENT)
{
for (uint32 i = 0; i < MAX_SPELL_EFFECTS; ++i)
{
if (AuraEffect const* eff = aurApp->GetBase()->GetEffect(i))
data << int32(eff->GetAmount());
else
data << int32(0);
}
}
}
}
data.put<uint64>(maskPos, auramask); // GROUP_UPDATE_FLAG_AURAS
if (updateFlags & GROUP_UPDATE_FLAG_PET_GUID)
data << uint64(pet->GetGUID());
data << std::string(pet ? pet->GetName() : ""); // GROUP_UPDATE_FLAG_PET_NAME
data << uint16(pet ? pet->GetDisplayId() : 0); // GROUP_UPDATE_FLAG_PET_MODEL_ID
if (updateFlags & GROUP_UPDATE_FLAG_PET_CUR_HP)
data << uint32(pet->GetHealth());
if (updateFlags & GROUP_UPDATE_FLAG_PET_MAX_HP)
data << uint32(pet->GetMaxHealth());
if (updateFlags & GROUP_UPDATE_FLAG_PET_POWER_TYPE)
data << (uint8)pet->getPowerType();
if (updateFlags & GROUP_UPDATE_FLAG_PET_CUR_POWER)
data << uint16(pet->GetPower(pet->getPowerType()));
if (updateFlags & GROUP_UPDATE_FLAG_PET_MAX_POWER)
data << uint16(pet->GetMaxPower(pet->getPowerType()));
// GROUP_UPDATE_FLAG_PET_AURAS
uint64 petAuraMask = 0;
data << uint8(1);
maskPos = data.wpos();
data << uint64(petAuraMask); // placeholder
data << uint32(MAX_AURAS); // count
if (pet)
{
for (uint8 i = 0; i < MAX_AURAS; ++i)
{
if (AuraApplication const* aurApp = pet->GetVisibleAura(i))
{
petAuraMask |= (uint64(1) << i);
data << uint32(aurApp->GetBase()->GetId());
data << uint16(aurApp->GetFlags());
if (aurApp->GetFlags() & AFLAG_ANY_EFFECT_AMOUNT_SENT)
{
for (uint32 i = 0; i < MAX_SPELL_EFFECTS; ++i)
{
if (AuraEffect const* eff = aurApp->GetBase()->GetEffect(i))
data << int32(eff->GetAmount());
else
data << int32(0);
}
}
}
}
}
data.put<uint64>(maskPos, petAuraMask); // GROUP_UPDATE_FLAG_PET_AURAS
if (updateFlags & GROUP_UPDATE_FLAG_VEHICLE_SEAT)
data << uint32(player->GetVehicle()->GetVehicleInfo()->m_seatID[player->m_movementInfo.transport.seat]);
if (updateFlags & GROUP_UPDATE_FLAG_PHASE)
{
data << uint32(phases.empty() ? 8 : 0);
data << uint32(phases.size());
for (std::set<uint32>::const_iterator itr = phases.begin(); itr != phases.end(); ++itr)
data << uint16(*itr);
}
SendPacket(&data);
}
void WorldSession::BuildPartyMemberStatsChangedPacket(Player* player, WorldPacket* data, uint32 mask, ObjectGuid guid, bool full /*= false*/)
{
// Prevent sending an empty packet
if (mask == GROUP_UPDATE_FLAG_NONE)
return;
std::set<uint32> phases;
if (player)
player->GetPhaseMgr().GetActivePhases(phases);
ByteBuffer dataBuffer;
if (mask & GROUP_UPDATE_FLAG_POWER_TYPE) // if update power type, update current/max power also
mask |= (GROUP_UPDATE_FLAG_CUR_POWER | GROUP_UPDATE_FLAG_MAX_POWER);
if (mask & GROUP_UPDATE_FLAG_PET_POWER_TYPE) // same for pets
mask |= (GROUP_UPDATE_FLAG_PET_CUR_POWER | GROUP_UPDATE_FLAG_PET_MAX_POWER);
Pet* pet = NULL;
if (!player)
mask &= ~GROUP_UPDATE_FULL;
else if (!(pet = player->GetPet()))
mask &= ~GROUP_UPDATE_PET;
mask |= GROUP_UPDATE_FLAG_STATUS;
//if (player && (mask & GROUP_UPDATE_FLAG_STATUS))
// mask |= GROUP_UPDATE_PLAYER_BASE;
data->Initialize(SMSG_PARTY_MEMBER_STATS, 200); // average value
data->WriteBit(guid[5]);
data->WriteBit(guid[2]);
data->WriteBit(false);
data->WriteBit(guid[6]);
data->WriteBit(guid[4]);
data->WriteBit(guid[7]);
data->WriteBit(guid[3]);
data->WriteBit(false);
data->WriteBit(guid[0]);
data->WriteBit(guid[1]);
data->FlushBits();
data->WriteByteSeq(guid[4]);
data->WriteByteSeq(guid[6]);
if (mask & GROUP_UPDATE_FLAG_STATUS)
{
uint16 status = MEMBER_STATUS_OFFLINE;
if (player)
{
status |= MEMBER_STATUS_ONLINE;
if (player->IsPvP())
status |= MEMBER_STATUS_PVP;
if (player->isDead())
status |= MEMBER_STATUS_DEAD;
if (player->HasFlag(PLAYER_FLAGS, PLAYER_FLAGS_GHOST))
status |= MEMBER_STATUS_GHOST;
if (player->IsFFAPvP())
status |= MEMBER_STATUS_PVP_FFA;
if (player->isAFK())
status |= MEMBER_STATUS_AFK;
if (player->isDND())
status |= MEMBER_STATUS_DND;
}
dataBuffer << uint16(status);
}
if (mask & GROUP_UPDATE_FLAG_MOP_UNK)
{
dataBuffer << uint8(1); // Same realms ?
dataBuffer << uint8(0); // in lfg
}
if (mask & GROUP_UPDATE_FLAG_CUR_HP)
dataBuffer << uint32(player->GetHealth());
if (mask & GROUP_UPDATE_FLAG_MAX_HP)
dataBuffer << uint32(player->GetMaxHealth());
Powers powerType = POWER_MANA;
if (player)
powerType = player->getPowerType();
if (mask & GROUP_UPDATE_FLAG_POWER_TYPE)
dataBuffer << uint8(powerType);
if (mask & GROUP_UPDATE_FLAG_UNK_20)
dataBuffer << uint16(0);
if (mask & GROUP_UPDATE_FLAG_CUR_POWER)
dataBuffer << uint16(player->GetPower(powerType));
if (mask & GROUP_UPDATE_FLAG_MAX_POWER)
dataBuffer << uint16(player->GetMaxPower(powerType));
if (mask & GROUP_UPDATE_FLAG_LEVEL)
dataBuffer << uint16(player->getLevel());
if (mask & GROUP_UPDATE_FLAG_ZONE)
dataBuffer << uint16(player->GetZoneId());
if (mask & GROUP_UPDATE_FLAG_UNK400)
dataBuffer << uint16(player->GetAreaId());
if (mask & GROUP_UPDATE_FLAG_POSITION)
dataBuffer << uint16(player->GetPositionX()) << uint16(player->GetPositionY()) << uint16(player->GetPositionZ());
if (mask & GROUP_UPDATE_FLAG_AURAS)
{
uint64 auramask = player->GetAuraUpdateMaskForRaid();
dataBuffer << uint8(1);
dataBuffer << uint64(auramask);
dataBuffer << uint32(MAX_AURAS);
for (uint32 i = 0; i < MAX_AURAS; ++i)
{
if (!(auramask & (UI64LIT(1) << i)))
continue;
AuraApplication const* aurApp = player->GetVisibleAura(i);
if (!aurApp)
{
dataBuffer << uint32(0);
dataBuffer << uint8(0);
dataBuffer << uint32(0);
continue;
}
dataBuffer << uint32(aurApp->GetBase()->GetId());
dataBuffer << uint8(aurApp->GetFlags());
dataBuffer << uint32(aurApp->GetBase()->GetEffectMask());
if (aurApp->GetFlags() & AFLAG_ANY_EFFECT_AMOUNT_SENT)
{
uint32 auraEffectMask = aurApp->GetBase()->GetEffectMask();
size_t pos = dataBuffer.wpos();
uint8 amount_count = 0;
dataBuffer << uint8(0);
for (uint32 j = 0; j < MAX_SPELL_EFFECTS; ++j)
{
if (!(auraEffectMask & (1 << j)))
continue;
if (constAuraEffectPtr eff = aurApp->GetBase()->GetEffect(j)) // NULL if effect flag not set
dataBuffer << float(eff->GetAmount());
else
dataBuffer << float(0.0f);
++amount_count;
}
dataBuffer.put(pos, amount_count);
}
}
}
if (mask & GROUP_UPDATE_FLAG_PET_GUID)
{
if (pet)
dataBuffer << uint64(pet->GetGUID());
else
dataBuffer << uint64(0);
}
if (mask & GROUP_UPDATE_FLAG_PET_NAME)
{
if (pet)
dataBuffer << pet->GetName();
else
dataBuffer << uint8(0);
}
if (mask & GROUP_UPDATE_FLAG_PET_MODEL_ID)
{
if (pet)
dataBuffer << uint16(pet->GetDisplayId());
else
dataBuffer << uint16(0);
}
if (mask & GROUP_UPDATE_FLAG_PET_CUR_HP)
{
if (pet)
dataBuffer << uint32(pet->GetHealth());
else
dataBuffer << uint32(0);
}
if (mask & GROUP_UPDATE_FLAG_PET_MAX_HP)
{
if (pet)
dataBuffer << uint32(pet->GetMaxHealth());
else
dataBuffer << uint32(0);
}
if (mask & GROUP_UPDATE_FLAG_PET_POWER_TYPE)
{
if (pet)
dataBuffer << uint8(pet->getPowerType());
else
dataBuffer << uint8(0);
}
if (mask & GROUP_UPDATE_FLAG_MOP_UNK_2)
dataBuffer << uint16(0); // Unk
if (mask & GROUP_UPDATE_FLAG_PET_CUR_POWER)
{
if (pet)
dataBuffer << uint16(pet->GetPower(pet->getPowerType()));
else
dataBuffer << uint16(0);
}
if (mask & GROUP_UPDATE_FLAG_PET_MAX_POWER)
{
if (pet)
dataBuffer << uint16(pet->GetMaxPower(pet->getPowerType()));
else
dataBuffer << uint16(0);
}
if (mask & GROUP_UPDATE_FLAG_PET_AURAS)
{
if (pet)
{
uint64 auramask = pet->GetAuraUpdateMaskForRaid();
dataBuffer << uint8(1);
dataBuffer << uint64(auramask);
dataBuffer << uint32(MAX_AURAS);
for (uint32 i = 0; i < MAX_AURAS; ++i)
{
if (!(auramask & (UI64LIT(1) << i)))
continue;
AuraApplication const* aurApp = pet->GetVisibleAura(i);
if (!aurApp)
{
dataBuffer << uint32(0);
dataBuffer << uint8(0);
dataBuffer << uint32(0);
continue;
}
dataBuffer << uint32(aurApp->GetBase()->GetId());
dataBuffer << uint8(aurApp->GetFlags());
dataBuffer << uint32(aurApp->GetBase()->GetEffectMask());
if (aurApp->GetFlags() & AFLAG_ANY_EFFECT_AMOUNT_SENT)
{
uint32 auraEffectMask = aurApp->GetBase()->GetEffectMask();
size_t pos = dataBuffer.wpos();
uint8 count = 0;
dataBuffer << uint8(0);
for (uint32 j = 0; j < MAX_SPELL_EFFECTS; ++j)
{
if (!(auraEffectMask & (1 << j)))
continue;
if (constAuraEffectPtr eff = aurApp->GetBase()->GetEffect(j)) // NULL if effect flag not set
dataBuffer << float(eff->GetAmount());
else
dataBuffer << float(0.0f);
++count;
}
dataBuffer.put(pos, count);
}
}
}
else
{
dataBuffer << uint8(0);
dataBuffer << uint64(0);
dataBuffer << uint32(0);
}
}
if (mask & GROUP_UPDATE_FLAG_VEHICLE_SEAT)
{
if (Vehicle* veh = player->GetVehicle())
dataBuffer << uint32(veh->GetVehicleInfo()->m_seatID[player->m_movementInfo.t_seat]);
else
dataBuffer << uint32(0);
}
if (mask & GROUP_UPDATE_FLAG_PHASE)
{
dataBuffer << uint32(phases.empty() ? 0x8 : 0x10); // Same as found in SMSG_SET_PHASE_SHIFT.
dataBuffer.WriteBits(phases.size(), 23); // Phases Count.
dataBuffer.FlushBits();
for (std::set<uint32>::const_iterator itr = phases.begin(); itr != phases.end(); ++itr)
*data << uint16(*itr);
}
if (mask & GROUP_UPDATE_FLAG_UNK_2000000)
dataBuffer << uint16(0);
if (mask & GROUP_UPDATE_FLAG_UNK_4000000)
dataBuffer << uint32(0);
/* this flags are not handled by client */
/*if (mask & GROUP_UPDATE_FLAG_UNK_8000000)
dataBuffer << uint8(0);
if (mask & GROUP_UPDATE_FLAG_UNK_10000000)
dataBuffer << uint8(0);
if (mask & GROUP_UPDATE_FLAG_UNK_20000000)
dataBuffer << uint8(253);
if (mask & GROUP_UPDATE_FLAG_UNK_40000000)
dataBuffer << uint8(0);*/
*data << uint32(dataBuffer.size());
data->append(dataBuffer);
data->WriteByteSeq(guid[3]);
data->WriteByteSeq(guid[5]);
*data << uint32(mask);
data->WriteByteSeq(guid[0]);
data->WriteByteSeq(guid[1]);
data->WriteByteSeq(guid[2]);
data->WriteByteSeq(guid[7]);
}
/*this procedure handles clients CMSG_REQUEST_PARTY_MEMBER_STATS request*/
void WorldSession::HandleRequestPartyMemberStatsOpcode( WorldPacket &recv_data )
{
DEBUG_LOG("WORLD: Received CMSG_REQUEST_PARTY_MEMBER_STATS");
ObjectGuid guid;
recv_data >> guid;
Player * player = HashMapHolder<Player>::Find(guid);
if(!player)
{
WorldPacket data(SMSG_PARTY_MEMBER_STATS_FULL, 3+4+2);
data << guid.WriteAsPacked();
data << uint32(GROUP_UPDATE_FLAG_STATUS);
data << uint16(MEMBER_STATUS_OFFLINE);
SendPacket(&data);
return;
}
Pet *pet = player->GetPet();
WorldPacket data(SMSG_PARTY_MEMBER_STATS_FULL, 4+2+2+2+1+2*6+8+1+8);
data << player->GetPackGUID();
uint32 mask1 = 0x00040BFF; // common mask, real flags used 0x000040BFF
if(pet)
mask1 = 0x7FFFFFFF; // for hunters and other classes with pets
Powers powerType = player->getPowerType();
data << uint32(mask1); // group update mask
data << uint16(MEMBER_STATUS_ONLINE); // member's online status
data << uint16(player->GetHealth()); // GROUP_UPDATE_FLAG_CUR_HP
data << uint16(player->GetMaxHealth()); // GROUP_UPDATE_FLAG_MAX_HP
data << uint8(powerType); // GROUP_UPDATE_FLAG_POWER_TYPE
data << uint16(player->GetPower(powerType)); // GROUP_UPDATE_FLAG_CUR_POWER
data << uint16(player->GetMaxPower(powerType)); // GROUP_UPDATE_FLAG_MAX_POWER
data << uint16(player->getLevel()); // GROUP_UPDATE_FLAG_LEVEL
//verify player coordinates and zoneid to send to teammates
uint16 iZoneId = 0;
uint16 iCoordX = 0;
uint16 iCoordY = 0;
if (player->IsInWorld())
{
iZoneId = player->GetZoneId();
iCoordX = player->GetPositionX();
iCoordY = player->GetPositionY();
}
else if (player->IsBeingTeleported()) // Player is in teleportation
{
WorldLocation& loc = player->GetTeleportDest(); // So take teleportation destination
iZoneId = sTerrainMgr.GetZoneId(loc.mapid, loc.coord_x, loc.coord_y, loc.coord_z);
iCoordX = loc.coord_x;
iCoordY = loc.coord_y;
}
else
{
//unknown player status.
}
data << uint16(iZoneId); // GROUP_UPDATE_FLAG_ZONE
data << uint16(iCoordX); // GROUP_UPDATE_FLAG_POSITION
data << uint16(iCoordY); // GROUP_UPDATE_FLAG_POSITION
uint64 auramask = 0;
size_t maskPos = data.wpos();
data << uint64(auramask); // placeholder
for(uint8 i = 0; i < MAX_AURAS; ++i)
{
if(uint32 aura = player->GetUInt32Value(UNIT_FIELD_AURA + i))
{
auramask |= (uint64(1) << i);
data << uint16(aura);
data << uint8(1);
}
}
data.put<uint64>(maskPos, auramask); // GROUP_UPDATE_FLAG_AURAS
if(pet)
{
Powers petpowertype = pet->getPowerType();
data << pet->GetObjectGuid(); // GROUP_UPDATE_FLAG_PET_GUID
data << pet->GetName(); // GROUP_UPDATE_FLAG_PET_NAME
data << uint16(pet->GetDisplayId()); // GROUP_UPDATE_FLAG_PET_MODEL_ID
data << uint16(pet->GetHealth()); // GROUP_UPDATE_FLAG_PET_CUR_HP
data << uint16(pet->GetMaxHealth()); // GROUP_UPDATE_FLAG_PET_MAX_HP
data << uint8(petpowertype); // GROUP_UPDATE_FLAG_PET_POWER_TYPE
data << uint16(pet->GetPower(petpowertype)); // GROUP_UPDATE_FLAG_PET_CUR_POWER
data << uint16(pet->GetMaxPower(petpowertype)); // GROUP_UPDATE_FLAG_PET_MAX_POWER
uint64 petauramask = 0;
size_t petMaskPos = data.wpos();
data << uint64(petauramask); // placeholder
for(uint8 i = 0; i < MAX_AURAS; ++i)
{
if(uint32 petaura = pet->GetUInt32Value(UNIT_FIELD_AURA + i))
{
petauramask |= (uint64(1) << i);
data << uint16(petaura);
data << uint8(1);
}
}
data.put<uint64>(petMaskPos, petauramask); // GROUP_UPDATE_FLAG_PET_AURAS
}
else
{
data << uint8(0); // GROUP_UPDATE_FLAG_PET_NAME
data << uint64(0); // GROUP_UPDATE_FLAG_PET_AURAS
}
SendPacket(&data);
}
void WorldSession::BuildPartyMemberStatsChangedPacket(Player* player, WorldPacket* data)
{
uint32 mask = player->GetGroupUpdateFlag();
if (mask == GROUP_UPDATE_FLAG_NONE)
return;
if (mask & GROUP_UPDATE_FLAG_POWER_TYPE) // if update power type, update current/max power also
mask |= (GROUP_UPDATE_FLAG_CUR_POWER | GROUP_UPDATE_FLAG_MAX_POWER);
if (mask & GROUP_UPDATE_FLAG_PET_POWER_TYPE) // same for pets
mask |= (GROUP_UPDATE_FLAG_PET_CUR_POWER | GROUP_UPDATE_FLAG_PET_MAX_POWER);
uint32 byteCount = 0;
for (int i = 1; i < GROUP_UPDATE_FLAGS_COUNT; ++i)
if (mask & (1 << i))
byteCount += GroupUpdateLength[i];
data->Initialize(SMSG_PARTY_MEMBER_STATS, 8 + 4 + byteCount);
data->append(player->GetPackGUID());
*data << (uint32) mask;
if (mask & GROUP_UPDATE_FLAG_STATUS)
{
if (player)
{
if (player->IsPvP())
*data << (uint16) (MEMBER_STATUS_ONLINE | MEMBER_STATUS_PVP);
else
*data << (uint16) MEMBER_STATUS_ONLINE;
}
else
*data << (uint16) MEMBER_STATUS_OFFLINE;
}
if (mask & GROUP_UPDATE_FLAG_CUR_HP)
*data << (uint32) player->GetHealth();
if (mask & GROUP_UPDATE_FLAG_MAX_HP)
*data << (uint32) player->GetMaxHealth();
Powers powerType = player->getPowerType();
if (mask & GROUP_UPDATE_FLAG_POWER_TYPE)
*data << (uint8) powerType;
if (mask & GROUP_UPDATE_FLAG_CUR_POWER)
*data << (uint16) player->GetPower(powerType);
if (mask & GROUP_UPDATE_FLAG_MAX_POWER)
*data << (uint16) player->GetMaxPower(powerType);
if (mask & GROUP_UPDATE_FLAG_LEVEL)
*data << (uint16) player->getLevel();
if (mask & GROUP_UPDATE_FLAG_ZONE)
*data << (uint16) player->GetZoneId();
if (mask & GROUP_UPDATE_FLAG_POSITION)
*data << (uint16) player->GetPositionX() << (uint16) player->GetPositionY();
if (mask & GROUP_UPDATE_FLAG_AURAS)
{
uint64 auramask = player->GetAuraUpdateMaskForRaid();
*data << uint8(0); // if true client clears auras that are not covered by auramask
// TODO: looks like now client requires all active auras to be in the beginning of the auramask
// e.g. if you have holes in the aura mask the values after are ignored.
*data << uint64(auramask);
*data << uint32(64); // how many bits client reads from auramask
for (uint32 i = 0; i < MAX_AURAS; ++i)
{
if (auramask & (uint64(1) << i))
{
AuraApplication const* aurApp = player->GetVisibleAura(i);
*data << uint32(aurApp ? aurApp->GetBase()->GetId() : 0);
*data << uint8(1);
}
}
}
Pet* pet = player->GetPet();
if (mask & GROUP_UPDATE_FLAG_PET_GUID)
{
if (pet)
*data << (uint64) pet->GetGUID();
else
*data << (uint64) 0;
}
if (mask & GROUP_UPDATE_FLAG_PET_NAME)
{
if (pet)
*data << pet->GetName();
else
*data << (uint8) 0;
}
if (mask & GROUP_UPDATE_FLAG_PET_MODEL_ID)
{
if (pet)
*data << (uint16) pet->GetDisplayId();
else
*data << (uint16) 0;
}
if (mask & GROUP_UPDATE_FLAG_PET_CUR_HP)
{
if (pet)
*data << (uint32) pet->GetHealth();
else
*data << (uint32) 0;
}
if (mask & GROUP_UPDATE_FLAG_PET_MAX_HP)
{
if (pet)
*data << (uint32) pet->GetMaxHealth();
else
*data << (uint32) 0;
}
if (mask & GROUP_UPDATE_FLAG_PET_POWER_TYPE)
{
if (pet)
*data << (uint8) pet->getPowerType();
else
*data << (uint8) 0;
}
if (mask & GROUP_UPDATE_FLAG_PET_CUR_POWER)
{
if (pet)
*data << (uint16) pet->GetPower(pet->getPowerType());
else
*data << (uint16) 0;
}
if (mask & GROUP_UPDATE_FLAG_PET_MAX_POWER)
{
if (pet)
*data << (uint16) pet->GetMaxPower(pet->getPowerType());
else
*data << (uint16) 0;
}
if (mask & GROUP_UPDATE_FLAG_VEHICLE_SEAT)
{
if (Vehicle* veh = player->GetVehicle())
*data << (uint32) veh->GetVehicleInfo()->m_seatID[player->_movementInfo.t_seat];
}
if (mask & GROUP_UPDATE_FLAG_PET_AURAS)
{
if (pet)
{
uint64 auramask = pet->GetAuraUpdateMaskForRaid();
*data << uint64(auramask);
for (uint32 i = 0; i < MAX_AURAS; ++i)
{
if (auramask & (uint64(1) << i))
{
AuraApplication const* aurApp = player->GetVisibleAura(i);
*data << uint32(aurApp ? aurApp->GetBase()->GetId() : 0);
*data << uint8(1);
}
}
}
else
*data << (uint64) 0;
}
if (mask & GROUP_UPDATE_FLAG_PHASE) // 4.0.6 unk
{
*data << (uint32) 0;
*data << (uint32) 0;
// string
}
}
/*this procedure handles clients CMSG_REQUEST_PARTY_MEMBER_STATS request*/
void WorldSession::HandleRequestPartyMemberStatsOpcode( WorldPacket &recv_data )
{
sLog.outDebug("WORLD: Received CMSG_REQUEST_PARTY_MEMBER_STATS");
uint64 Guid;
recv_data >> Guid;
Player *player = sObjectMgr.GetPlayer(Guid);
if(!player)
{
WorldPacket data(SMSG_PARTY_MEMBER_STATS_FULL, 3+4+2);
data << uint8(0); // only for SMSG_PARTY_MEMBER_STATS_FULL, probably arena/bg related
data.appendPackGUID(Guid);
data << (uint32) GROUP_UPDATE_FLAG_STATUS;
data << (uint16) MEMBER_STATUS_OFFLINE;
SendPacket(&data);
return;
}
Pet *pet = player->GetPet();
WorldPacket data(SMSG_PARTY_MEMBER_STATS_FULL, 4+2+2+2+1+2*6+8+1+8);
data << uint8(0); // only for SMSG_PARTY_MEMBER_STATS_FULL, probably arena/bg related
data.append(player->GetPackGUID());
uint32 mask1 = 0x00040BFF; // common mask, real flags used 0x000040BFF
if(pet)
mask1 = 0x7FFFFFFF; // for hunters and other classes with pets
Powers powerType = player->getPowerType();
data << (uint32) mask1; // group update mask
data << (uint16) MEMBER_STATUS_ONLINE; // member's online status
data << (uint32) player->GetHealth(); // GROUP_UPDATE_FLAG_CUR_HP
data << (uint32) player->GetMaxHealth(); // GROUP_UPDATE_FLAG_MAX_HP
data << (uint8) powerType; // GROUP_UPDATE_FLAG_POWER_TYPE
data << (uint16) player->GetPower(powerType); // GROUP_UPDATE_FLAG_CUR_POWER
data << (uint16) player->GetMaxPower(powerType); // GROUP_UPDATE_FLAG_MAX_POWER
data << (uint16) player->getLevel(); // GROUP_UPDATE_FLAG_LEVEL
data << (uint16) player->GetZoneId(); // GROUP_UPDATE_FLAG_ZONE
data << (uint16) player->GetPositionX(); // GROUP_UPDATE_FLAG_POSITION
data << (uint16) player->GetPositionY(); // GROUP_UPDATE_FLAG_POSITION
uint64 auramask = 0;
size_t maskPos = data.wpos();
data << (uint64) auramask; // placeholder
for(uint8 i = 0; i < MAX_AURAS; ++i)
{
if(uint32 aura = player->GetVisibleAura(i))
{
auramask |= (uint64(1) << i);
data << (uint32) aura;
data << (uint8) 1;
}
}
data.put<uint64>(maskPos,auramask); // GROUP_UPDATE_FLAG_AURAS
if(pet)
{
Powers petpowertype = pet->getPowerType();
data << (uint64) pet->GetGUID(); // GROUP_UPDATE_FLAG_PET_GUID
data << pet->GetName(); // GROUP_UPDATE_FLAG_PET_NAME
data << (uint16) pet->GetDisplayId(); // GROUP_UPDATE_FLAG_PET_MODEL_ID
data << (uint32) pet->GetHealth(); // GROUP_UPDATE_FLAG_PET_CUR_HP
data << (uint32) pet->GetMaxHealth(); // GROUP_UPDATE_FLAG_PET_MAX_HP
data << (uint8) petpowertype; // GROUP_UPDATE_FLAG_PET_POWER_TYPE
data << (uint16) pet->GetPower(petpowertype); // GROUP_UPDATE_FLAG_PET_CUR_POWER
data << (uint16) pet->GetMaxPower(petpowertype); // GROUP_UPDATE_FLAG_PET_MAX_POWER
uint64 petauramask = 0;
size_t petMaskPos = data.wpos();
data << (uint64) petauramask; // placeholder
for(uint8 i = 0; i < MAX_AURAS; ++i)
{
if(uint32 petaura = pet->GetVisibleAura(i))
{
petauramask |= (uint64(1) << i);
data << (uint32) petaura;
data << (uint8) 1;
}
}
data.put<uint64>(petMaskPos,petauramask); // GROUP_UPDATE_FLAG_PET_AURAS
}
else
{
data << (uint8) 0; // GROUP_UPDATE_FLAG_PET_NAME
data << (uint64) 0; // GROUP_UPDATE_FLAG_PET_AURAS
}
SendPacket(&data);
}
/*this procedure handles clients CMSG_REQUEST_PARTY_MEMBER_STATS request*/
void WorldSession::HandleRequestPartyMemberStatsOpcode(WorldPacket& recvData)
{
sLog->outDebug(LOG_FILTER_NETWORKIO, "WORLD: Received CMSG_REQUEST_PARTY_MEMBER_STATS");
uint64 guid;
recvData >> guid;
Player* player = HashMapHolder<Player>::Find(guid);
if (!player)
{
WorldPacket data(SMSG_PARTY_MEMBER_STATS_FULL, 3+4+2);
data << uint8(0); // only for SMSG_PARTY_MEMBER_STATS_FULL, probably arena/bg related
data.appendPackGUID(guid);
data << (uint32) GROUP_UPDATE_FLAG_STATUS;
data << (uint16) MEMBER_STATUS_OFFLINE;
SendPacket(&data);
return;
}
Pet* pet = player->GetPet();
WorldPacket data(SMSG_PARTY_MEMBER_STATS_FULL, 4+2+2+2+1+2*6+8+1+8); // Needs checked for 406a
data << uint8(0); // only for SMSG_PARTY_MEMBER_STATS_FULL, probably arena/bg related
data.append(player->GetPackGUID());
/*
* uint32 mask1 = 0x00040BFF; // common mask, real flags used 0x000040BFF
* if (pet)
* mask1 = 0x7FFFFFFF; // for hunters and other classes with pets
*/
uint32 mask1 = GROUP_UPDATE_FULL;
if (!pet)
mask1 &= ~GROUP_UPDATE_PET;
Powers powerType = player->getPowerType();
data << uint32(mask1); // group update mask
data << uint16(MEMBER_STATUS_ONLINE); // member's online status, GROUP_UPDATE_FLAG_STATUS
data << uint32(player->GetHealth()); // GROUP_UPDATE_FLAG_CUR_HP
data << uint32(player->GetMaxHealth()); // GROUP_UPDATE_FLAG_MAX_HP
data << uint8 (powerType); // GROUP_UPDATE_FLAG_POWER_TYPE
data << uint16(player->GetPower(powerType)); // GROUP_UPDATE_FLAG_CUR_POWER
data << uint16(player->GetMaxPower(powerType)); // GROUP_UPDATE_FLAG_MAX_POWER
data << uint16(player->getLevel()); // GROUP_UPDATE_FLAG_LEVEL
data << uint16(player->GetZoneId()); // GROUP_UPDATE_FLAG_ZONE
data << uint16(player->GetPositionX()); // GROUP_UPDATE_FLAG_POSITION
data << uint16(player->GetPositionY()); // GROUP_UPDATE_FLAG_POSITION
data << uint16(player->GetPositionZ()); // GROUP_UPDATE_FLAG_POSITION
// GROUP_UPDATE_FLAG_AURAS
// if true client clears auras that are not covered by auramask
// TODO: looks like now client requires all active auras to be in the beginning of the auramask
// e.g. if you have holes in the aura mask the values after are ignored.
data << uint8(1);
uint64 auramask = 0;
size_t maskPos = data.wpos();
data << uint64(auramask); // placeholder
data << uint32(MAX_AURAS); // if true client clears auras that are not covered by auramask
for (uint8 i = 0; i < MAX_AURAS; ++i)
{
if (AuraApplication const* aurApp = player->GetVisibleAura(i))
{
auramask |= (uint64(1) << i);
data << uint32(aurApp->GetBase()->GetId());
data << uint16(aurApp->GetFlags());
if (aurApp->GetFlags() & AFLAG_ANY_EFFECT_AMOUNT_SENT)
{
for (uint32 i = 0; i < MAX_SPELL_EFFECTS; ++i)
{
if (AuraEffect const* eff = aurApp->GetBase()->GetEffect(i))
data << int32(eff->GetAmount());
else
data << int32(0);
}
}
}
}
data.put<uint64>(maskPos, auramask); // GROUP_UPDATE_FLAG_AURAS
if (pet)
{
Powers petpowertype = pet->getPowerType();
data << uint64(pet->GetGUID()); // GROUP_UPDATE_FLAG_PET_GUID
data << pet->GetName(); // GROUP_UPDATE_FLAG_PET_NAME
data << uint16(pet->GetDisplayId()); // GROUP_UPDATE_FLAG_PET_MODEL_ID
data << uint32(pet->GetHealth()); // GROUP_UPDATE_FLAG_PET_CUR_HP
data << uint32(pet->GetMaxHealth()); // GROUP_UPDATE_FLAG_PET_MAX_HP
data << uint8 (petpowertype); // GROUP_UPDATE_FLAG_PET_POWER_TYPE
data << uint16(pet->GetPower(petpowertype)); // GROUP_UPDATE_FLAG_PET_CUR_POWER
data << uint16(pet->GetMaxPower(petpowertype)); // GROUP_UPDATE_FLAG_PET_MAX_POWER
// GROUP_UPDATE_FLAG_PET_AURAS
// if true client clears auras that are not covered by auramask
// TODO: looks like now client requires all active auras to be in the beginning of the auramask
// e.g. if you have holes in the aura mask the values after are ignored.
data << uint8(1);
uint64 petauramask = 0;
size_t petMaskPos = data.wpos();
data << uint64(petauramask); // placeholder
data << uint32(MAX_AURAS); // client reads (64) Bits from auramask
for (uint8 i = 0; i < MAX_AURAS; ++i)
{
if (AuraApplication const* aurApp = pet->GetVisibleAura(i))
{
petauramask |= (uint64(1) << i);
data << uint32(aurApp->GetBase()->GetId());
data << uint16(aurApp->GetFlags());
if (aurApp->GetFlags() & AFLAG_ANY_EFFECT_AMOUNT_SENT)
{
for (uint32 i = 0; i < MAX_SPELL_EFFECTS; ++i)
{
if (AuraEffect const* eff = aurApp->GetBase()->GetEffect(i))
data << int32(eff->GetAmount());
else
data << int32(0);
}
}
}
}
data.put<uint64>(petMaskPos, petauramask); // GROUP_UPDATE_FLAG_PET_AURAS
}
// else not needed, flags do not include any PET_ update
// GROUP_UPDATE_FLAG_PHASE
data << uint32(8); // either 0 or 8, same unk found in SMSG_PHASESHIFT
data << uint32(0); // count
// for (count) *data << uint16(phaseId)
SendPacket(&data);
}