void bot_ai::BuffAndHealGroup(Player *gPlayer)
{
if(m_creature->IsNonMeleeSpellCasted(true)) return; // if I'm already casting
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 = ((Player *)master)->GetObjPlayer((*itr)->GetGUID());
if(tPlayer == NULL) continue;
if(tPlayer->isDead()) continue;
if(m_creature->GetAreaId() != gPlayer->GetAreaId()) continue;
//if(tPlayer->GetGUID() == GetPlayerBot()->GetGUID()) continue;
//if(m_creature->GetDistance(tPlayer) > 30) continue;
(HealTarget(tPlayer, tPlayer->GetHealth()*100 / tPlayer->GetMaxHealth()));
BuffTarget(tPlayer);
}
}
}
void PlayerbotDruidAI::DoNonCombatActions()
{
Player * m_bot = GetPlayerBot();
if (!m_bot)
return;
PlayerbotAI* ai = GetAI();
if(m_bot->HasAura(CAT_FORM, EFFECT_INDEX_0))
{
m_bot->RemoveAurasDueToSpell(768);
//ai->TellMaster("FormClearCat");
}
if(m_bot->HasAura(BEAR_FORM, EFFECT_INDEX_0))
{
m_bot->RemoveAurasDueToSpell(5487);
//ai->TellMaster("FormClearBear");
}
if(m_bot->HasAura(DIRE_BEAR_FORM, EFFECT_INDEX_0))
{
m_bot->RemoveAurasDueToSpell(9634);
//ai->TellMaster("FormClearDireBear");
}
if(m_bot->HasAura(MOONKIN_FORM, EFFECT_INDEX_0))
{
m_bot->RemoveAurasDueToSpell(24858);
//ai->TellMaster("FormClearMoonkin");
}
// buff myself with MARK_OF_THE_WILD
if (MARK_OF_THE_WILD > 0 && !m_bot->HasAura(MARK_OF_THE_WILD, EFFECT_INDEX_0))
ai->CastSpell (MARK_OF_THE_WILD, *m_bot);
// Thorns generates aggro for moonkin
if (THORNS > 0 && !m_bot->HasAura(THORNS, EFFECT_INDEX_0))
ai->CastSpell (THORNS, *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);
ai->SetIgnoreUpdateTime(30);
return;
}
else if(pItem == NULL && INNERVATE>0 && !m_bot->HasAura(INNERVATE, EFFECT_INDEX_0) && ai->GetManaPercent() <= 70)
{
ai->CastSpell(INNERVATE, *m_bot);
//ai->TellMaster("casting innervate.");
return;
}
else if(pItem == NULL && MANA_REJUVENATION>0 && !m_bot->HasAura(INNERVATE, EFFECT_INDEX_0) && !m_bot->HasAura(MANA_REJUVENATION, EFFECT_INDEX_0) && ai->GetManaPercent() <= 70)
{
ai->CastSpell(MANA_REJUVENATION, *m_bot);
//ai->TellMaster("casting mana rejuvenation.");
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);
ai->SetIgnoreUpdateTime(30);
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);
ai->SetIgnoreUpdateTime(8);
return;
}
// buff and heal master's group
if (GetMaster()->GetGroup())
{
Group::MemberSlotList const& groupSlot = GetMaster()->GetGroup()->GetMemberSlots();
for (Group::member_citerator itr = groupSlot.begin(); itr != groupSlot.end(); itr++)
{
Player *tPlayer = sObjectMgr.GetPlayer(uint64 (itr->guid));
if( !tPlayer || !tPlayer->isAlive() )
continue;
// buff and heal
(!tPlayer->HasAura(MARK_OF_THE_WILD,EFFECT_INDEX_0) && ai->CastSpell (MARK_OF_THE_WILD, *tPlayer));
//(!tPlayer->HasAura(THORNS,0) && ai->CastSpell (THORNS, *tPlayer));
(HealTarget(*tPlayer, tPlayer->GetHealth()*100 / tPlayer->GetMaxHealth()));
}
}
} // end DoNonCombatActions
/*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);
}
/*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 << 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();
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 mask1 = 0x00040BFF; // common mask, real flags used 0x000040BFF
if(pet)
mask1 = 0x7FFFFFFF; // for hunters and other classes with pets
uint16 online_status = MEMBER_STATUS_ONLINE;
Powers powerType = player->getPowerType();
data << uint32(mask1); // group update mask
data << uint16(online_status); // 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
//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)
{
MAPLOCK_READ(player,MAP_LOCK_TYPE_AURAS);
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 << 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)
{
MAPLOCK_READ(pet,MAP_LOCK_TYPE_AURAS);
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);
data << uint8(0); // only for SMSG_PARTY_MEMBER_STATS_FULL, probably arena/bg related
data.append(player->GetPackGUID());
uint32 mask1 = GROUP_UPDATE_FULL; // common mask, real flags used 0x000040BFF
if (!pet)
mask1 &= ~GROUP_UPDATE_PET; // for hunters and other classes with pets, real flags used 0x7FFFFFFF
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
uint64 auramask = 0;
// 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(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
uint64 petauramask = 0;
// 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(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
{
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 Transporter::TransportPassengers(uint32 mapid, uint32 oldmap, float x, float y, float z)
{
sEventMgr.RemoveEvents(this, EVENT_TRANSPORTER_NEXT_WAYPOINT);
if (mPassengers.size() > 0)
{
PassengerIterator itr = mPassengers.begin();
PassengerIterator it2;
WorldPacket Pending(SMSG_TRANSFER_PENDING, 12);
Pending << mapid << GetEntry() << oldmap;
WorldPacket NewWorld;
LocationVector v;
for (; itr != mPassengers.end();)
{
it2 = itr;
++itr;
Player* plr = objmgr.GetPlayer(it2->first);
if (!plr)
{
// remove all non players from map
mPassengers.erase(it2);
continue;
}
if (!plr->GetSession() || !plr->IsInWorld())
continue;
v.x = x + plr->transporter_info.x;
v.y = y + plr->transporter_info.y;
v.z = z + plr->transporter_info.z;
v.o = plr->GetOrientation();
if (mapid == 530 && !plr->GetSession()->HasFlag(ACCOUNT_FLAG_XPACK_01))
{
// player does not have BC content, repop at graveyard
plr->RepopAtGraveyard(plr->GetPositionX(), plr->GetPositionY(), plr->GetPositionZ(), plr->GetMapId());
continue;
}
if (mapid == 571 && !plr->GetSession()->HasFlag(ACCOUNT_FLAG_XPACK_02))
{
plr->RepopAtGraveyard(plr->GetPositionX(), plr->GetPositionY(), plr->GetPositionZ(), plr->GetMapId());
continue;
}
plr->GetSession()->SendPacket(&Pending);
plr->_Relocate(mapid, v, false, true, 0);
// Lucky bitch. Do it like on official.
if (plr->IsDead())
{
plr->ResurrectPlayer();
plr->SetHealth(plr->GetMaxHealth());
plr->SetPower(POWER_TYPE_MANA, plr->GetMaxPower(POWER_TYPE_MANA));
}
}
}
// Set our position
RemoveFromWorld(false);
SetMapId(mapid);
SetPosition(x, y, z, m_position.o, false);
AddToWorld();
}
/*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);
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(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);
}
/*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");
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;
}
Unit *pet = player->GetCharmOrPet();
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 mask1 = 0x00040BFF; // common mask, real flags used 0x000040BFF
if(pet)
mask1 = 0xFFFFFFFF; // 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 << 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(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
data << (uint32) player->m_movementInfo.GetTransportDBCSeat();
}
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& recv_data)
{
DEBUG_LOG("WORLD: Received opcode 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, 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();
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 mask1 = GROUP_UPDATE_FLAG_STATUS | GROUP_UPDATE_FLAG_CUR_HP | GROUP_UPDATE_FLAG_MAX_HP |
GROUP_UPDATE_FLAG_POWER_TYPE | 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_AURAS |
GROUP_UPDATE_FLAG_PHASE;
if (pet)
mask1 = 0x7FEFFEFF; // full mask & ~(GROUP_UPDATE_FLAG_VEHICLE_SEAT | GROUP_UPDATE_FLAG_UNK)
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
// verify player coordinates and zoneid to send to teammates
uint16 iZoneId = 0;
uint16 iCoordX = 0;
uint16 iCoordY = 0;
uint16 iCoordZ = 0;
if (player->IsInWorld())
{
iZoneId = player->GetZoneId();
iCoordX = player->GetPositionX();
iCoordY = player->GetPositionY();
iCoordZ = player->GetPositionZ();
}
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;
iCoordZ = loc.coord_z;
}
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
data << uint16(iCoordZ); // GROUP_UPDATE_FLAG_POSITION
data << uint8(1); // if true, client clears all auras that are not in auramask and whose index is lower amount sent below
uint64 auramask = 0;
size_t maskPos = data.wpos();
data << uint64(auramask); // placeholder, server sends 0xFFFFFFFFFFFFFFFF here, but with 1 above it seems no difference
data << uint32(MAX_AURAS); // server sends here number of visible auras, but client checks
// if aura is in auramask, so it seems no difference if there will be MAX_AURAS
for (uint8 i = 0; i < MAX_AURAS; ++i)
{
if (SpellAuraHolder* holder = player->GetVisibleAura(i))
{
auramask |= (uint64(1) << i);
data << uint32(holder->GetId());
data << uint16(holder->GetAuraFlags());
if (holder->GetAuraFlags() & AFLAG_EFFECT_AMOUNT_SEND)
for (uint32 i = 0; i < MAX_EFFECT_INDEX; ++i)
if (Aura* aura = holder->GetAuraByEffectIndex(SpellEffectIndex(i)))
data << int32(aura->GetModifier()->m_amount);
else
data << int32(0);
}
}
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
data << uint8(1); // if true, client clears all auras that are not in auramask and whose index is lower amount sent below
uint64 petauramask = 0;
size_t petMaskPos = data.wpos();
data << uint64(petauramask); // placeholder, server sends 0xFFFFFFFFFFFFFFFF here, but with 1 above it seems no difference
data << uint32(MAX_AURAS); // server sends here number of visible auras, but client checks
// if aura is in auramask, so it seems no difference if there will be MAX_AURAS
for (uint8 i = 0; i < MAX_AURAS; ++i)
{
if (SpellAuraHolder* holder = pet->GetVisibleAura(i))
{
petauramask |= (uint64(1) << i);
data << uint32(holder->GetId());
data << uint16(holder->GetAuraFlags());
if (holder->GetAuraFlags() & AFLAG_EFFECT_AMOUNT_SEND)
for (uint32 i = 0; i < MAX_EFFECT_INDEX; ++i)
if (Aura* aura = holder->GetAuraByEffectIndex(SpellEffectIndex(i)))
data << int32(aura->GetModifier()->m_amount);
else
data << int32(0);
}
}
data.put<uint64>(petMaskPos, petauramask); // GROUP_UPDATE_FLAG_PET_AURAS
}
else
{
data << uint8(0); // GROUP_UPDATE_FLAG_PET_NAME
data << uint8(1); // GROUP_UPDATE_FLAG_PET_AURAS
data << uint64(0); // GROUP_UPDATE_FLAG_PET_AURAS
data << uint32(0); // GROUP_UPDATE_FLAG_PET_AURAS
}
data << uint32(8); // GROUP_UPDATE_FLAG_PHASE
data << uint32(0); // GROUP_UPDATE_FLAG_PHASE
data << uint8(0); // GROUP_UPDATE_FLAG_PHASE
SendPacket(&data);
}
void WorldSession::SendLfgUpdateList(uint32 dungeonEntry)
{
if (!sWorld.getConfig(CONFIG_BOOL_LFR_ENABLE))
{
DEBUG_LOG("SendLfgUpdateList %u failed - Raid finder disabled", GetPlayer()->GetObjectGuid().GetCounter());
return;
}
DEBUG_LOG("SMSG_LFG_SEARCH_RESULTS %u dungeonentry: %u ", GetPlayer()->GetObjectGuid().GetCounter(), dungeonEntry);
LFGDungeonEntry const* dungeon = sLFGMgr.GetDungeon(dungeonEntry);
if (!dungeonEntry)
return;
Team team = sWorld.getConfig(CONFIG_BOOL_ALLOW_TWO_SIDE_INTERACTION_GROUP) ? TEAM_NONE : GetPlayer()->GetTeam();
LFGQueueGroupSet groups = sLFGMgr.GetDungeonGroupQueue(dungeon, team);
LFGQueuePlayerSet players = sLFGMgr.GetDungeonPlayerQueue(dungeon, team);
uint32 groupCount = groups.size();
uint32 groupSize = 4+4;
for (LFGQueueGroupSet::const_iterator itr = groups.begin(); itr != groups.end(); ++itr)
{
Player* leader = sObjectMgr.GetPlayer((*itr)->GetLeaderGuid());
if (!leader)
continue;
leader->GetLFGState()->AddFlags(LFG_MEMBER_FLAG_CHARINFO |
LFG_MEMBER_FLAG_COMMENT |
LFG_MEMBER_FLAG_GROUPLEADER |
LFG_MEMBER_FLAG_GROUPGUID |
LFG_MEMBER_FLAG_ROLES |
LFG_MEMBER_FLAG_AREA |
LFG_MEMBER_FLAG_STATUS |
LFG_MEMBER_FLAG_BIND);
uint32 flags = leader->GetLFGState()->GetFlags();
if (flags & LFG_MEMBER_FLAG_COMMENT)
groupSize += leader->GetLFGState()->GetComment().size()+1;
if (flags & LFG_MEMBER_FLAG_ROLES)
groupSize +=3;
if (flags & LFG_MEMBER_FLAG_BIND)
groupSize += (8+4);
players.insert(leader);
for (GroupReference *itr2 = (*itr)->GetFirstMember(); itr2 != NULL; itr2 = itr2->next())
{
Player* player = itr2->getSource();
if (!player || player == leader)
continue;
player->GetLFGState()->AddFlags(LFG_MEMBER_FLAG_GROUPLEADER |
LFG_MEMBER_FLAG_GROUPGUID |
LFG_MEMBER_FLAG_STATUS);
player->GetLFGState()->RemoveFlags(LFG_MEMBER_FLAG_CHARINFO |
LFG_MEMBER_FLAG_COMMENT |
LFG_MEMBER_FLAG_ROLES |
LFG_MEMBER_FLAG_AREA |
LFG_MEMBER_FLAG_BIND);
players.insert(player);
}
}
uint32 playerCount = players.size();
uint32 playerSize = 4+4;
uint32 guidsSize = 0;
LFGQueuePlayerSet playersUpdated;
playersUpdated.clear();
for(LFGQueuePlayerSet::const_iterator itr = players.begin(); itr != players.end(); ++itr)
{
uint32 flags = (*itr)->GetLFGState()->GetFlags();
playerSize += (8+4);
if (flags & LFG_MEMBER_FLAG_CHARINFO)
playerSize += (1+1+1+3+4+4+4+4+4+4+4+4+4+4+4+4+4+4+4+4+4+4+4+4);
if (flags & LFG_MEMBER_FLAG_COMMENT)
playerSize += (*itr)->GetLFGState()->GetComment().size()+1; // comment
if (flags & LFG_MEMBER_FLAG_GROUPLEADER)
playerSize += 1;
if (flags & LFG_MEMBER_FLAG_GROUPGUID)
playerSize += 8;
if (flags & LFG_MEMBER_FLAG_ROLES)
playerSize += 1;
if (flags & LFG_MEMBER_FLAG_AREA)
playerSize += 4;
if (flags & LFG_MEMBER_FLAG_STATUS)
playerSize += 1;
if (flags & LFG_MEMBER_FLAG_BIND)
playerSize += (8+4);
if (flags & LFG_MEMBER_FLAG_UPDATE)
{
(*itr)->GetLFGState()->RemoveFlags(LFG_MEMBER_FLAG_UPDATE);
playersUpdated.insert(*itr);
guidsSize += 8;
}
}
WorldPacket data(SMSG_LFG_SEARCH_RESULTS, 4 + 4 + 1 + groupSize + playerSize + guidsSize);
data << uint32(dungeon->type); // type
data << uint32(dungeon->Entry()); // entry from LFGDungeons.dbc
if (!playersUpdated.empty())
{
data << uint8(playersUpdated.size());
for (LFGQueuePlayerSet::const_iterator itr = playersUpdated.begin(); itr != playersUpdated.end(); ++itr)
{
data << (*itr)->GetObjectGuid(); // player guid
}
}
else
data << uint8(0);
if (!groups.empty())
{
data << uint32(groupCount); // groups count
data << uint32(groupCount); // groups count2
for (LFGQueueGroupSet::const_iterator itr = groups.begin(); itr != groups.end(); ++itr)
{
Group* group = *itr;
Player* leader = sObjectMgr.GetPlayer(group->GetLeaderGuid());
uint32 flags = leader->GetLFGState()->GetFlags();
data << group->GetObjectGuid();
data << flags;
if (flags & LFG_MEMBER_FLAG_COMMENT)
{
data << leader->GetLFGState()->GetComment().c_str();
}
if (flags & LFG_MEMBER_FLAG_ROLES)
{
for (int i = 0; i < 3; ++i)
{
data << uint8(group->GetLFGState()->GetRoles(LFGRoles(i+1)));
}
}
if (flags & LFG_MEMBER_FLAG_BIND)
{
ObjectGuid instanceGuid;
uint32 encounters = 0;
if (InstancePlayerBind* bind = leader->GetBoundInstance(dungeon->map, Difficulty(dungeon->difficulty)))
{
if (DungeonPersistentState* state = bind->state)
{
instanceGuid = state->GetInstanceGuid();
encounters = state->GetCompletedEncountersMask();
}
}
data << instanceGuid;
data << encounters;
}
}
}
else
{
data << uint32(0);
data << uint32(0); // groups count2
}
if (!players.empty())
{
data << uint32(playerCount); // players count
data << uint32(playerCount); // players count 2
for(LFGQueuePlayerSet::const_iterator itr = players.begin(); itr != players.end(); ++itr)
{
Player* player = *itr;
uint32 flags = player->GetLFGState()->GetFlags();
data << player->GetObjectGuid(); // guid
data << flags; // flags
if (flags & LFG_MEMBER_FLAG_CHARINFO) // charinfo
{
data << uint8(player->getLevel());
data << uint8(player->getClass());
data << uint8(player->getRace());
for(int i = 0; i < 3; ++i)
data << uint8(player->GetTalentsCount(i)); // spent talents count in specific tab
data << uint32(player->GetArmor()); // armor
data << uint32(player->SpellBaseDamageBonusDone(SPELL_SCHOOL_MASK_SPELL)); // spd
data << uint32(player->SpellBaseHealingBonusDone(SPELL_SCHOOL_MASK_SPELL)); // heal
data << uint32(player->GetRatingBonusValue(CR_CRIT_MELEE)); // crit rating melee
data << uint32(player->GetRatingBonusValue(CR_CRIT_RANGED)); // crit rating ranged
data << uint32(player->GetRatingBonusValue(CR_CRIT_SPELL)); // crit rating spell
data << float(player->GetFloatValue(UNIT_FIELD_POWER_REGEN_FLAT_MODIFIER)*5); // mp5
data << float(player->GetFloatValue(UNIT_FIELD_POWER_REGEN_INTERRUPTED_FLAT_MODIFIER)*5); // unk
data << uint32(player->GetTotalAttackPowerValue(BASE_ATTACK)); // attack power
data << uint32(player->GetTotalStatValue(STAT_AGILITY)); // agility
data << uint32(player->GetMaxHealth()); // health
data << uint32(player->GetMaxPower(player->getPowerType())); // power
data << uint32(0); // unk
data << float(0); // unk
data << uint32(player->GetRatingBonusValue(CR_DEFENSE_SKILL)); // defence rating
data << uint32(player->GetRatingBonusValue(CR_DODGE)); // dodge rating
data << uint32(player->GetRatingBonusValue(CR_BLOCK)); // block rating
data << uint32(player->GetRatingBonusValue(CR_PARRY)); // parry rating
data << uint32(player->GetRatingBonusValue(CR_HASTE_MELEE)); // crit rating
data << uint32(player->GetRatingBonusValue(CR_EXPERTISE)); // expertize
}
if (flags & LFG_MEMBER_FLAG_COMMENT)
data << player->GetLFGState()->GetComment().c_str(); // comment
if (flags & LFG_MEMBER_FLAG_GROUPLEADER) // Group leader flag
{
bool isLeader = false;
if (Group* group = player->GetGroup())
if (player->GetObjectGuid() == group->GetLeaderGuid())
isLeader = true;
data << uint8(isLeader);
}
if (flags & LFG_MEMBER_FLAG_GROUPGUID) // Group guid
{
ObjectGuid groupGuid = ObjectGuid();
if (Group* group = player->GetGroup())
groupGuid = group->GetObjectGuid();
data << groupGuid;
}
if (flags & LFG_MEMBER_FLAG_ROLES) // rolesMask
data << uint8(player->GetLFGState()->GetRoles());
if (flags & LFG_MEMBER_FLAG_AREA) // Area
data << uint32(player->GetAreaId());
if (flags & LFG_MEMBER_FLAG_STATUS) // status
data << uint8(0);
if (flags & LFG_MEMBER_FLAG_BIND)
{
ObjectGuid instanceGuid;
uint32 encounters = 0;
if (InstancePlayerBind* bind = player->GetBoundInstance(dungeon->map, Difficulty(dungeon->difficulty)))
{
if (DungeonPersistentState* state = bind->state)
{
instanceGuid = state->GetInstanceGuid();
encounters = state->GetCompletedEncountersMask();
}
}
data << instanceGuid;
data << encounters;
}
}
}
else
{
data << uint32(0); // players count
data << uint32(0); // unk
}
SendPacket(&data);
}
void DoNonCombatActions()
{
Feast();
if (isTimerReady(uiGc_Timer) && !me->HasAura(SPELL_LIGHTNING_SHIELD, 0))
doCast(me, SPELL_LIGHTNING_SHIELD);
if (master->GetGroup())
{
RezGroup(SPELL_ANCESTRAL_SPIRIT, master);
BuffAndHealGroup(master);
}
/* TESTING */
Group::MemberSlotList const &a =((Player*)master)->GetGroup()->GetMemberSlots();
for (Group::member_citerator itr = a.begin(); itr != a.end(); itr++)
{
Player* tPlayer = ((Player *)master)->GetObjPlayer(itr->guid);
if (tPlayer == NULL)
continue;
//healing others
if (tPlayer->isAlive() && isTimerReady(uiOthersHeal_Timer) && tPlayer->GetGUID() != master->GetGUID() && tPlayer->GetHealth() * 100 / tPlayer->GetMaxHealth() < 75 && CanCast(tPlayer, GetSpellStore()->LookupEntry(SPELL_CHAIN_HEAL)))
{
doCast(tPlayer, SPELL_CHAIN_HEAL, false);
uiOthersHeal_Timer = 100;
}
//rezzes
if (tPlayer->isDead() && !me->isInCombat() && me->GetDistance(tPlayer) < 40 && isTimerReady(uiRez_Timer))
{
char* str = (char *)malloc(32);
sprintf(str, "Resucitando a %s", tPlayer->GetName());
me->MonsterSay(str, LANG_UNIVERSAL, NULL);
free(str);
doCast(tPlayer, SPELL_ANCESTRAL_SPIRIT, false);
uiRez_Timer = 160;
}
}
/* TESTING */
if ((master->GetHealth() * 100 / master->GetMaxHealth() < 90) && uiLesserHealing_Timer <= 0)
{
doCast(master, SPELL_LESSER_HEALING);
uiLesserHealing_Timer = 90;
uiHeal_Timer = uiHeal_Timer + 5; //wait 5 seconds before casting a real heal
return;
}
else if (uiLesserHealing_Timer >= 0)
--uiLesserHealing_Timer;
if ((master->GetHealth() * 100 / master->GetMaxHealth() < 75) && isTimerReady(uiHeal_Timer))
{
doCast(master, SPELL_CHAIN_HEAL);
uiHeal_Timer = 10;
}
if (me->GetHealth() * 100 / me->GetMaxHealth() < 90)
{
if (uiSelfLesserHealing_Timer <= 0)
{
doCast(me, SPELL_LESSER_HEALING);
uiSelfLesserHealing_Timer = 90;
return;
}
else if (uiSelfLesserHealing_Timer >= 0)
--uiSelfLesserHealing_Timer;
}
}
void WorldSession::HandleMovementOpcodes( WorldPacket & recv_data )
{
uint32 opcode = recv_data.GetOpcode();
DEBUG_LOG("WORLD: Recvd %s (%u, 0x%X) opcode", LookupOpcodeName(opcode), opcode, opcode);
recv_data.hexlike();
Unit *mover = _player->GetMover();
Player *plMover = mover->GetTypeId() == TYPEID_PLAYER ? (Player*)mover : NULL;
// ignore, waiting processing in WorldSession::HandleMoveWorldportAckOpcode and WorldSession::HandleMoveTeleportAck
if(plMover && plMover->IsBeingTeleported())
{
recv_data.rpos(recv_data.wpos()); // prevent warnings spam
return;
}
/* extract packet */
ObjectGuid guid;
MovementInfo movementInfo;
recv_data >> guid.ReadAsPacked();
recv_data >> movementInfo;
/*----------------*/
if (!VerifyMovementInfo(movementInfo, guid))
return;
// fall damage generation (ignore in flight case that can be triggered also at lags in moment teleportation to another map).
if (opcode == MSG_MOVE_FALL_LAND && plMover && !plMover->IsTaxiFlying())
plMover->HandleFall(movementInfo);
/* process position-change */
HandleMoverRelocation(movementInfo);
if (plMover)
plMover->UpdateFallInformationIfNeed(movementInfo, opcode);
/* process position-change */
if (!plMover)
return;
movementInfo.UpdateTime(getMSTime());
if(plMover) // nothing is charmed, or player charmed
{
WorldPacket data(opcode, recv_data.size());
data << mover->GetPackGUID(); // write guid
movementInfo.Write(data); // write data
mover->SendMessageToSetExcept(&data, _player);
plMover->SetPosition(movementInfo.GetPos()->x, movementInfo.GetPos()->y, movementInfo.GetPos()->z, movementInfo.GetPos()->o);
plMover->m_movementInfo = movementInfo;
plMover->UpdateFallInformationIfNeed(movementInfo, opcode);
// after move info set
if (opcode == MSG_MOVE_SET_WALK_MODE || opcode == MSG_MOVE_SET_RUN_MODE)
mover->UpdateWalkMode(mover, false);
if(plMover->isMovingOrTurning())
plMover->RemoveSpellsCausingAura(SPELL_AURA_FEIGN_DEATH);
if(movementInfo.GetPos()->z < -500.0f)
{
if(plMover->InBattleGround()
&& plMover->GetBattleGround()
&& plMover->GetBattleGround()->HandlePlayerUnderMap(_player))
{
// do nothing, the handle already did if returned true
}
else
{
// NOTE: this is actually called many times while falling
// even after the player has been teleported away
// TODO: discard movement packets after the player is rooted
if(plMover->isAlive())
{
plMover->EnvironmentalDamage(DAMAGE_FALL_TO_VOID, plMover->GetMaxHealth());
// pl can be alive if GM/etc
if(!plMover->isAlive())
{
// change the death state to CORPSE to prevent the death timer from
// starting in the next player update
plMover->KillPlayer();
plMover->BuildPlayerRepop();
}
}
// cancel the death timer here if started
plMover->RepopAtGraveyard();
}
}
}
else // creature charmed
{
if(mover->IsInWorld())
mover->GetMap()->CreatureRelocation((Creature*)mover, movementInfo.GetPos()->x, movementInfo.GetPos()->y, movementInfo.GetPos()->z, movementInfo.GetPos()->o);
}
}
void PlayerbotPaladinAI::DoNonCombatActions()
{
PlayerbotAI* ai = GetAI();
Player * m_bot = GetPlayerBot();
if (!m_bot)
return;
// buff myself
if (GREATER_BLESSING_OF_MIGHT > 0 && !m_bot->HasAura(GREATER_BLESSING_OF_MIGHT, EFFECT_INDEX_0))
ai->CastSpell (GREATER_BLESSING_OF_MIGHT, *m_bot);
else if (BLESSING_OF_MIGHT > 0 && !m_bot->HasAura(GREATER_BLESSING_OF_MIGHT, EFFECT_INDEX_0) && !m_bot->HasAura(BLESSING_OF_MIGHT, EFFECT_INDEX_0))
ai->CastSpell (BLESSING_OF_MIGHT, *m_bot);
if (DIVINE_FAVOR > 0 && !m_bot->HasAura(DIVINE_FAVOR, EFFECT_INDEX_0) && ai->GetManaPercent() >= 3)
ai->CastSpell(DIVINE_FAVOR , *m_bot);
/*
if (SEAL_OF_COMMAND > 0)
ai->CastSpell (SEAL_OF_COMMAND, *m_bot); // interferes with drinking/eating
*/
//Select Class buff seq.
///Process Who is my master --> get the player class --> aura already present if not then proced --> cast the spell
//Priest
if (BLESSING_OF_WISDOM > 0 && GetMaster()->getClass() == CLASS_PRIEST && !GetMaster()->HasAura(GREATER_BLESSING_OF_WISDOM, EFFECT_INDEX_0) && !GetMaster()->HasAura(BLESSING_OF_WISDOM, EFFECT_INDEX_0))
ai->CastSpell (BLESSING_OF_WISDOM, *(GetMaster()));
if (GREATER_BLESSING_OF_WISDOM > 0 && GetMaster()->getClass() == CLASS_PRIEST && !GetMaster()->HasAura(GREATER_BLESSING_OF_WISDOM, EFFECT_INDEX_0))
ai->CastSpell (GREATER_BLESSING_OF_WISDOM, *(GetMaster()));
//Mage
if (BLESSING_OF_WISDOM > 0 && GetMaster()->getClass() == CLASS_MAGE && !GetMaster()->HasAura(GREATER_BLESSING_OF_WISDOM, EFFECT_INDEX_0) && !GetMaster()->HasAura(BLESSING_OF_WISDOM, EFFECT_INDEX_0))
ai->CastSpell (BLESSING_OF_WISDOM, *(GetMaster()));
if (GREATER_BLESSING_OF_WISDOM > 0 && GetMaster()->getClass() == CLASS_MAGE && !GetMaster()->HasAura(GREATER_BLESSING_OF_WISDOM, EFFECT_INDEX_0))
ai->CastSpell (GREATER_BLESSING_OF_WISDOM, *(GetMaster()));
//Paladin
if (BLESSING_OF_WISDOM > 0 && GetMaster()->getClass() == CLASS_PALADIN && !GetMaster()->HasAura(GREATER_BLESSING_OF_WISDOM, EFFECT_INDEX_0) && !GetMaster()->HasAura(BLESSING_OF_WISDOM, EFFECT_INDEX_0))
ai->CastSpell (BLESSING_OF_WISDOM, *(GetMaster()));
if (GREATER_BLESSING_OF_WISDOM > 0 && GetMaster()->getClass() == CLASS_PALADIN && !GetMaster()->HasAura(GREATER_BLESSING_OF_WISDOM, EFFECT_INDEX_0))
ai->CastSpell (GREATER_BLESSING_OF_WISDOM, *(GetMaster()));
//Warlock
if (BLESSING_OF_WISDOM > 0 && GetMaster()->getClass() == CLASS_WARLOCK && !GetMaster()->HasAura(GREATER_BLESSING_OF_WISDOM, EFFECT_INDEX_0) && !GetMaster()->HasAura(BLESSING_OF_WISDOM, EFFECT_INDEX_0))
ai->CastSpell (BLESSING_OF_WISDOM, *(GetMaster()));
if (GREATER_BLESSING_OF_WISDOM > 0 && GetMaster()->getClass() == CLASS_WARLOCK && !GetMaster()->HasAura(GREATER_BLESSING_OF_WISDOM, EFFECT_INDEX_0))
ai->CastSpell (GREATER_BLESSING_OF_WISDOM, *(GetMaster()));
//Warrior
if (BLESSING_OF_MIGHT > 0 && GetMaster()->getClass() == CLASS_WARRIOR && !GetMaster()->HasAura(GREATER_BLESSING_OF_MIGHT, EFFECT_INDEX_0) && !GetMaster()->HasAura(BLESSING_OF_MIGHT, EFFECT_INDEX_0) && !GetMaster()->HasAura(DEFENSIVE_STANCE, EFFECT_INDEX_0))
ai->CastSpell (BLESSING_OF_MIGHT, *(GetMaster()));
if (GREATER_BLESSING_OF_MIGHT > 0 && GetMaster()->getClass() == CLASS_WARRIOR && !GetMaster()->HasAura(GREATER_BLESSING_OF_MIGHT, EFFECT_INDEX_0) && !GetMaster()->HasAura(DEFENSIVE_STANCE, EFFECT_INDEX_0))
ai->CastSpell (GREATER_BLESSING_OF_MIGHT, *(GetMaster()));
if (BLESSING_OF_KINGS > 0 && GetMaster()->getClass() == CLASS_WARRIOR && !GetMaster()->HasAura(GREATER_BLESSING_OF_KINGS, EFFECT_INDEX_0) && !GetMaster()->HasAura(BLESSING_OF_KINGS, EFFECT_INDEX_0) && !GetMaster()->HasAura(BERSERKER_STANCE, EFFECT_INDEX_0) && !GetMaster()->HasAura(BATTLE_STANCE, EFFECT_INDEX_0))
ai->CastSpell (BLESSING_OF_KINGS, *(GetMaster()));
if (GREATER_BLESSING_OF_KINGS > 0 && GetMaster()->getClass() == CLASS_WARRIOR && !GetMaster()->HasAura(GREATER_BLESSING_OF_KINGS, EFFECT_INDEX_0) && !GetMaster()->HasAura(BERSERKER_STANCE, EFFECT_INDEX_0) && !GetMaster()->HasAura(BATTLE_STANCE, EFFECT_INDEX_0))
ai->CastSpell (GREATER_BLESSING_OF_KINGS, *(GetMaster()));
//Rogue
if (BLESSING_OF_MIGHT > 0 && GetMaster()->getClass() == CLASS_ROGUE && !GetMaster()->HasAura(GREATER_BLESSING_OF_MIGHT, EFFECT_INDEX_0) && !GetMaster()->HasAura(BLESSING_OF_MIGHT, EFFECT_INDEX_0))
ai->CastSpell (BLESSING_OF_MIGHT, *(GetMaster()));
if (GREATER_BLESSING_OF_MIGHT > 0 && GetMaster()->getClass() == CLASS_ROGUE && !GetMaster()->HasAura(GREATER_BLESSING_OF_MIGHT, EFFECT_INDEX_0))
ai->CastSpell (GREATER_BLESSING_OF_MIGHT, *(GetMaster()));
//Shaman
if (BLESSING_OF_MIGHT > 0 && GetMaster()->getClass() == CLASS_SHAMAN && !GetMaster()->HasAura(GREATER_BLESSING_OF_MIGHT, EFFECT_INDEX_0) && !GetMaster()->HasAura(BLESSING_OF_MIGHT, EFFECT_INDEX_0))
ai->CastSpell (BLESSING_OF_MIGHT, *(GetMaster()));
if (GREATER_BLESSING_OF_MIGHT > 0 && GetMaster()->getClass() == CLASS_SHAMAN && !GetMaster()->HasAura(GREATER_BLESSING_OF_MIGHT, EFFECT_INDEX_0))
ai->CastSpell (GREATER_BLESSING_OF_MIGHT, *(GetMaster()));
// 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() < 40)
{
ai->TellMaster("I could use a drink.");
ai->UseItem(*pItem);
ai->SetIgnoreUpdateTime(30);
return;
}
// hp check original
if (m_bot->getStandState() != UNIT_STAND_STATE_STAND)
m_bot->SetStandState(UNIT_STAND_STATE_STAND);
pItem = ai->FindFood();
if (pItem != NULL && ai->GetHealthPercent() < 40)
{
ai->TellMaster("I could use some food.");
ai->UseItem(*pItem);
ai->SetIgnoreUpdateTime(30);
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);
ai->SetIgnoreUpdateTime(8);
return;
}
// heal group
if (GetMaster()->GetGroup())
{
Group::MemberSlotList const& groupSlot = GetMaster()->GetGroup()->GetMemberSlots();
for (Group::member_citerator itr = groupSlot.begin(); itr != groupSlot.end(); itr++)
{
Player *tPlayer = sObjectMgr.GetPlayer(uint64 (itr->guid));
if( !tPlayer || !tPlayer->isAlive() )
continue;
// heal player
(HealTarget(*tPlayer, tPlayer->GetHealth()*100 / tPlayer->GetMaxHealth()));
}
}
}
void DoNonCombatActions()
{
Feast();
if(isTimerReady(GC_Timer) && !m_creature->HasAura(SPELL_LIGHTNING_SHIELD, 0))
doCast(m_creature, SPELL_LIGHTNING_SHIELD);
//Casts buffs
// if(!m_creature->isInCombat())
// {
//if(!m_creature->HasAura(SPELL_WINDFURY_WEAPON, 0)) doCast(m_creature, SPELL_WINDFURY_WEAPON);
// if(isTimerReady(GC_Timer) && !m_creature->HasAura(SPELL_LIGHTNING_SHIELD, 0))
// doCast(m_creature, SPELL_LIGHTNING_SHIELD);
// }
//Heal/rez others
//
//check group members, this doesn't check bots/pets. They will be done later. Preference
//goes to real players first.
//
//buff and heal group
if(master->GetGroup())
{
RezGroup(SPELL_SHAMAN_REZZ, master);
BuffAndHealGroup(master);
// CureGroup(master);
}
/* TESTING */
Group::MemberSlotList const &a =((Player*)master)->GetGroup()->GetMemberSlots();
for(Group::member_citerator itr = a.begin(); itr != a.end(); itr++)
{
Player *tPlayer = ((Player *)master)->GetObjPlayer(itr->guid);
if(tPlayer == NULL) continue;
//healing others
if(tPlayer->isAlive() &&
isTimerReady(Others_Heal_Timer) &&
tPlayer->GetGUID() != master->GetGUID() &&
tPlayer->GetHealth()*100 / tPlayer->GetMaxHealth() < 75 &&
CanCast(tPlayer, GetSpellStore()->LookupEntry (SPELL_CHAIN_HEAL)))
{
doCast(tPlayer, SPELL_CHAIN_HEAL, false);
Others_Heal_Timer = 100;
}
//rezzes
if(tPlayer->isDead() &&
!m_creature->isInCombat() &&
//CanCast(tPlayer, GetSpellStore()->LookupEntry (SPELL_SHAMAN_REZZ)) &&
m_creature->GetDistance(tPlayer) < 40 &&
isTimerReady(Rez_Timer))
{
char *str = (char *)malloc(32);
sprintf(str, "Rezzing %s", tPlayer->GetName());
m_creature->MonsterSay(str, LANG_UNIVERSAL, NULL);
free(str);
doCast(tPlayer, SPELL_SHAMAN_REZZ, false);
Rez_Timer = 160;
}
}
/* TESTING */
/* TESTING */
if((master->GetHealth()*100 / master->GetMaxHealth() < 90) && Lesser_Healing_Timer <= 0)
{
doCast(master, SPELL_LESSER_HEALING);
Lesser_Healing_Timer = 90;
Heal_Timer = Heal_Timer + 5; //wait 5 seconds before casting a real heal
//if(master->isInCombat()) && master->getVictim() == NULL) return;
return;
} else if(Lesser_Healing_Timer >= 0) --Lesser_Healing_Timer;
if((master->GetHealth()*100 / master->GetMaxHealth() < 75) && isTimerReady(Heal_Timer))
{
doCast(master, SPELL_CHAIN_HEAL);
Heal_Timer = 10;
}
if(m_creature->GetHealth()*100 / m_creature->GetMaxHealth() < 90)
{
if(Self_Lesser_Healing_Timer <= 0)
{
doCast(m_creature, SPELL_LESSER_HEALING);
Self_Lesser_Healing_Timer = 90;
return;
} else if(Self_Lesser_Healing_Timer >= 0)
--Self_Lesser_Healing_Timer;
}
/* TESTING */
}
void RemoveBite()
{
if (!pInstance)
return;
Map::PlayerList const &PlayerList = pInstance->instance->GetPlayers();
if (!PlayerList.isEmpty())
for (Map::PlayerList::const_iterator i = PlayerList.begin(); i != PlayerList.end(); ++i)
{
Player* pPlayer = i->getSource();
if (pPlayer && pPlayer->HasAura(SPELL_GRIEVOUS_BITE) && (pPlayer->GetHealth() == pPlayer->GetMaxHealth()))
pPlayer->RemoveAurasDueToSpell(SPELL_GRIEVOUS_BITE);
}
}
void UpdateAI(const uint32 diff)
{
if(!UpdateVictim())
return;
if(Cleanse_Timer < diff )
{
std::list<Creature*> pList = FindFriendlyCC(30);
if (!pList.empty())
{
Unit* target = *(pList.begin());
DoCast(target,SPELL_CLEANSE_BW_VINDICATOR);
}
Cleanse_Timer = 3000+rand()%1000;
}
else
Cleanse_Timer -= diff;
if(FlashofLight_Timer < diff)
{
Unit* target = SelectLowestHpFriendly(50, 1000);
if(target)
{
DoCast(target,SPELL_FLASHOFLIGHT_BW_VINDICATOR);
if(target->GetHealth() <= target->GetMaxHealth()*0.5)
FlashofLight_Timer = 2000;
else
FlashofLight_Timer = 2000 +rand()%7000;
}
}
else
FlashofLight_Timer -= diff;
if(HammerofJustice_Timer < diff)
{
DoCast(m_creature->getVictim(),SPELL_HAMMEROFJUSTICE_BW_VINDICATOR);
HammerofJustice_Timer = 18000;
}
else
HammerofJustice_Timer -= diff;
if(HammerofWrath_Timer < diff)
{
Map* pMap = m_creature->GetMap();
Map::PlayerList const &PlayerList = pMap->GetPlayers();
if (!PlayerList.isEmpty())
{
for (Map::PlayerList::const_iterator i = PlayerList.begin(); i != PlayerList.end(); ++i)
{
Player *p = i->getSource();
if(p->isAlive() && p->GetHealth() <= p->GetMaxHealth()*0.2)
{
DoCast(p, SPELL_HAMMEROFWRATH_BW_VINDICATOR);
break;
}
}
}
HammerofWrath_Timer = 3000+rand()%2000;
}
else
HammerofWrath_Timer -= diff;
DoMeleeAttackIfReady();
}
//==============================================================================
void GameServer::tick()
{
/*float dt = (time_.elapsed() - lastTime_) * 0.001f;*/
lastTime_ = time_.elapsed();
/*if (actors_.size() < 100 && !testingStageActive_)
{
GenMonsters_();
}*/
auto collideWithGrid = [=](Actor* actor, EActorDirection direction)
{
auto& p = *actor;
float x = p.GetPosition().x;
float y = p.GetPosition().y;
bool collided = false;
if ((levelMap_.GetCell(x + 0.49f, y - 0.51f) != '.'
|| levelMap_.GetCell(x + 0.49f, y + 0.49f) != '.')
&& levelMap_.GetCell(x - slideThreshold_+ 0.5f, y) == '.'
&& (direction == EActorDirection::NORTH
|| direction == EActorDirection::SOUTH))
{
p.SetPosition(Vector2(x - slideThreshold_+ 0.0001f, p.GetPosition().y));
}
if (levelMap_.GetCell(x + slideThreshold_- 0.5f, y) == '.'
&&((levelMap_.GetCell(x - 0.5f, y - 0.51f) != '.'
|| levelMap_.GetCell(x - 0.5f, y + 0.49f) != '.')
&& (direction == EActorDirection::NORTH
|| direction == EActorDirection::SOUTH)))
{
p.SetPosition(Vector2(x + slideThreshold_- 0.0001f, p.GetPosition().y));
}
if (levelMap_.GetCell(x, y - slideThreshold_ + 0.5f) == '.'
&& (levelMap_.GetCell(x - 0.51f, y + 0.49f) != '.'
|| levelMap_.GetCell(x + 0.49f, y + 0.49f) != '.')
&& (direction == EActorDirection::EAST
|| direction == EActorDirection::WEST))
{
p.SetPosition(Vector2(p.GetPosition().x, y - slideThreshold_+ 0.0001f));
}
if ((levelMap_.GetCell(x + 0.49f, y - 0.5f) != '.'
|| levelMap_.GetCell(x - 0.51f, y - 0.5f) != '.')
&& levelMap_.GetCell(x, y + slideThreshold_- 0.5f) == '.'
&& (direction == EActorDirection::EAST
|| direction == EActorDirection::WEST))
{
p.SetPosition(Vector2(p.GetPosition().x, y + slideThreshold_ - 0.001f));
}
if (levelMap_.GetCell(x + 0.5f, y) != '.')
{
p.SetPosition(Vector2(round(x + 0.5f) - 0.5f, p.GetPosition().y));
collided = true;
}
if (levelMap_.GetCell(x - 0.51f, y) != '.')
{
p.SetPosition(Vector2(round(x - 0.5f) + 0.5f, p.GetPosition().y));
collided = true;
}
if (levelMap_.GetCell(x, y + 0.5f) != '.')
{
p.SetPosition(Vector2(p.GetPosition().x, round(y + 0.5f) - 0.5f));
collided = true;
}
if (levelMap_.GetCell(x, y - 0.51f) != '.')
{
p.SetPosition(Vector2(p.GetPosition().x, round(y - 0.5f) + 0.5f));
collided = true;
}
if (collided)
{
actor->OnCollideWorld();
}
};
for (Actor* actor: actors_)
{
if (actor->GetType() == EActorType::MONSTER)
{
Monster* monster = dynamic_cast<Monster*>(actor);
Creature* target = monster->target;
float distance2;
Vector2 m_pos = actor->GetPosition();
if (target && target != nullptr)
{
Vector2 t_pos = target->GetPosition();
distance2 = Sqr(m_pos.x - t_pos.x)
+ Sqr(m_pos.y - t_pos.y);
if (distance2 < 25)
{
if (abs(m_pos.x - t_pos.x - 1.0f) < playerVelocity_
&& m_pos.x - t_pos.x - 1.0f != 0)
{
monster->SetPosition(Vector2(t_pos.x + 1.0f, m_pos.y));
monster->SetDirection(EActorDirection::NONE);
}
if (abs(m_pos.y - t_pos.y + 1.0f) < playerVelocity_
&& m_pos.y - t_pos.y + 1.0f != 0)
{
monster->SetPosition(Vector2(m_pos.x, t_pos.y - 1.0f));
monster->SetDirection(EActorDirection::NONE);
}
if (m_pos.x < t_pos.x - 1.0f)
{
monster->SetDirection(EActorDirection::EAST);
}
else if (m_pos.x > t_pos.x + 1.0f)
{
monster->SetDirection(EActorDirection::WEST);
}
else if (m_pos.y < t_pos.y - 1.0f)
{
monster->SetDirection(EActorDirection::SOUTH);
}
else if (m_pos.y > t_pos.y + 1.0f)
{
monster->SetDirection(EActorDirection::NORTH);
}
}
}
if (!target
|| target == nullptr
|| distance2 >= 5)
{
for (Actor* tar : actors_)
{
if (tar != monster)
{
bool b = false;
if (tar->GetType() != EActorType::ITEM
&& tar->GetType () != EActorType::PROJECTILE)
{
Creature* m = dynamic_cast<Creature*>(tar);
QStringList str = monster->Flags.filter("HATE");
for (QString hate: str)
{
if (Hates[hate] == m->GetRace())
{
b = true;
break;
}
}
if (b)
{
Vector2 t_pos = tar->GetPosition();
distance2 = Sqr(m_pos.x - t_pos.x) + Sqr(m_pos.y - t_pos.y);
// Dasha told 5^2 is a protocol defined const
if (distance2 < 25)
{
monster->target = m;
break;
}
}
}
}
}
}
}
if (actor->GetType() == EActorType::MONSTER
|| actor->GetType() == EActorType::PLAYER)
{
Creature* monster = dynamic_cast<Creature*>(actor);
if (monster->GetHealth() <= 0)
{
KillActor_(actor);
break;
}
}
}
for (Actor* actor: actors_)
{
if (!actor
|| actor == nullptr)
{
break;
}
auto v = directionToVector[static_cast<unsigned>(actor->GetDirection())] ;
actor->SetVelocity(v);
float dt = playerVelocity_;
Vector2 old_pos = actor->GetPosition();
Vector2 new_pos = old_pos + v * (dt + 0.001);
Vector2 old_pos2 = old_pos + v * 0.51;
levelMap_.RemoveActor(actor);
EActorDirection d = actor->GetDirection();
float x = new_pos.x;
float y = new_pos.y;
if (levelMap_.GetCell(old_pos2.x, old_pos2.y) != '#'
&& d != EActorDirection::NONE
&& (((levelMap_.GetCell(x - slideThreshold_+ 0.5f, y) == '.'
&& levelMap_.GetCell(x + slideThreshold_- 0.5f, y) == '.')
&& (d == EActorDirection::NORTH
|| d == EActorDirection::SOUTH))
|| ((levelMap_.GetCell(x, y - slideThreshold_+ 0.5f) == '.'
&& levelMap_.GetCell(x, y + slideThreshold_- 0.5f) == '.')
&& (d == EActorDirection::EAST
|| d == EActorDirection::WEST))))
{
if (levelMap_.GetCell(new_pos.x, new_pos.y) == '.')
{
if (!actor->Update(dt)
&& actor->GetType () == EActorType::PROJECTILE)
{
static_cast<Projectile*>(actor)->death = true;
}
collideWithGrid(actor, d);
}
else if (levelMap_.GetCell(x , y) != '.'
&& playerVelocity_ >= 1)
{
bool b = false;
for (float i = 0.01; i <= dt; i += 0.01)
{
new_pos = old_pos + v * i + v * 0.5f;
if (levelMap_.GetCell(new_pos.x, new_pos.y) == '#' && !b)
{
actor->Update(i - 0.01);
b = true;
}
}
}
else
{
if (actor->GetType () == EActorType::PROJECTILE)
{
static_cast<Projectile*>(actor)->death = true;
}
}
}
else
{
if (actor
&& actor != nullptr)
{
if (actor->GetType () == EActorType::PROJECTILE)
{
static_cast<Projectile*>(actor)->death = true;
}
else
{
actor->OnCollideWorld();
}
}
}
if (actor->GetType() == EActorType::PLAYER)
{
Player* player = dynamic_cast<Player*>(actor);
if (player->GetHealth() < player->GetMaxHealth())
{
player->SetHealth(player->GetHealth() + 1);
}
}
if (actor->GetType() == EActorType::MONSTER)
{
Monster* monster = dynamic_cast<Monster*>(actor);
Creature* target = monster->target;
if (target && target->GetHealth() > 0)
{
Vector2 m_pos = actor->GetPosition();
Vector2 t_pos = target->GetPosition();
float distance2 = Sqr(m_pos.x - t_pos.x)
+ Sqr(m_pos.y - t_pos.y);
if (distance2 <= Sqr(pickUpRadius_))
{
events_ << monster->atack(target);
events_ << target->atack(monster);
}
}
}
for (Actor* neighbour : actors_)
{
if (actor == nullptr
|| neighbour == nullptr
|| actor == neighbour
|| neighbour->GetType() == EActorType::ITEM
|| (actor->GetType() == EActorType::PROJECTILE
&& neighbour->GetType() == EActorType::PROJECTILE))
{
break;
}
Box box0(neighbour->GetPosition(), 0.9f, 0.9f);
Box box1(actor->GetPosition(), 0.9f, 0.9f);
if (box0.Intersect(box1))
{
actor->OnCollideActor(neighbour);
neighbour->OnCollideActor(actor);
if (actor->GetType() == EActorType::PROJECTILE)
{
static_cast<Projectile*>(actor)->death = true;
if (neighbour->GetType () == EActorType::MONSTER)
{
Monster* monster = dynamic_cast<Monster*>(neighbour);
if (monster->GetHealth () <= 0)
{
GetItems(monster);
}
}
}
else if (neighbour->GetType() == EActorType::PROJECTILE)
{
static_cast<Projectile*>(neighbour)->death = true;
if (actor->GetType() == EActorType::MONSTER)
{
Monster* monster = dynamic_cast<Monster*>(actor);
if (monster->GetHealth () <= 0)
{
GetItems(monster);
}
}
}
else if (neighbour->GetType() != EActorType::ITEM)
{
actor->SetPosition(old_pos);
}
}
}
if (actor->GetType() == EActorType::PROJECTILE
&& static_cast<Projectile*>(actor)->death)
{
QVariantMap ans1;
ans1["radius"] = 1.0f;
ans1["x"] = actor->GetPosition ().x;
ans1["y"] = actor->GetPosition ().y;
QVariantMap ans;
ans["explode"] = ans1;
events_ << ans;
idToActor_.erase(actor->GetId());
actors_.erase(std::remove(actors_.begin(), actors_.end(), actor), actors_.end());
delete actor;
actor = nullptr;
}
else
{
levelMap_.IndexActor(actor);
}
}
QVariantMap tickMessage;
tickMessage["tick"] = tick_;
tickMessage["events"] = events_;
events_.clear();
emit broadcastMessage(QString(QJsonDocument::fromVariant(tickMessage).toJson()));
tick_++;
}
void WorldSession::SendPartyMemberStatsChanged(uint64 Guid, uint32 mask)
{
if (mask == GROUP_UPDATE_FLAG_NONE)
return;
Player *player = objmgr.GetPlayer(Guid);
if(!player) //currently do not send update if player is offline
return;
/*if(!player && mask != GROUP_UPDATE_FLAG_ONLINE) //if player is offline - then send nothing, but OFFLINE status
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);
uint32 byteCount = 0;
for (int i=1;i<GROUP_UPDATE_FLAGS_COUNT;++i)
if (mask & 1<<i)
byteCount += GroupUpdateLength[i];
WorldPacket data(SMSG_PARTY_MEMBER_STATS, 8+4+byteCount);
if (player)
data.append(player->GetPackGUID());
else
data.appendPackGUID(Guid);
data << (uint32) mask;
if (mask & GROUP_UPDATE_FLAG_ONLINE)
{
if (player)
{
if (player->IsPvP())
data << uint8(MEMBER_STATUS_ONLINE | MEMBER_STATUS_PVP);
else
data << (uint8) MEMBER_STATUS_ONLINE;
}
else
data << (uint8) MEMBER_STATUS_OFFLINE;
}
if (mask & GROUP_UPDATE_FLAG_CUR_HP)
data << (uint16) player->GetHealth();
if (mask & GROUP_UPDATE_FLAG_MAX_HP)
data << (uint16) 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();
//TODO: add missing group update flags (pets?)
SendPacket(&data);
}
void WorldSession::HandleMovementOpcodes( WorldPacket & recv_data )
{
uint32 opcode = recv_data.GetOpcode();
sLog.outDebug("WORLD: Recvd %s (%u, 0x%X) opcode", LookupOpcodeName(opcode), opcode, opcode);
if(GetPlayer()->GetDontMove())
return;
/* extract packet */
MovementInfo movementInfo;
ReadMovementInfo(recv_data, &movementInfo);
/*----------------*/
if(recv_data.size() != recv_data.rpos())
{
sLog.outError("MovementHandler: player %s (guid %d, account %u) sent a packet (opcode %u) that is %u bytes larger than it should be. Kicked as cheater.", _player->GetName(), _player->GetGUIDLow(), _player->GetSession()->GetAccountId(), recv_data.GetOpcode(), recv_data.size() - recv_data.rpos());
KickPlayer();
return;
}
if (!MaNGOS::IsValidMapCoord(movementInfo.x, movementInfo.y, movementInfo.z, movementInfo.o))
return;
/* handle special cases */
if (movementInfo.flags & MOVEMENTFLAG_ONTRANSPORT)
{
// transports size limited
// (also received at zeppelin leave by some reason with t_* as absolute in continent coordinates, can be safely skipped)
if( movementInfo.t_x > 50 || movementInfo.t_y > 50 || movementInfo.t_z > 50 )
return;
if( !MaNGOS::IsValidMapCoord(movementInfo.x+movementInfo.t_x, movementInfo.y+movementInfo.t_y,
movementInfo.z+movementInfo.t_z, movementInfo.o+movementInfo.t_o) )
return;
// if we boarded a transport, add us to it
if (!GetPlayer()->m_transport)
{
// elevators also cause the client to send MOVEMENTFLAG_ONTRANSPORT - just unmount if the guid can be found in the transport list
for (MapManager::TransportSet::iterator iter = MapManager::Instance().m_Transports.begin(); iter != MapManager::Instance().m_Transports.end(); ++iter)
{
if ((*iter)->GetGUID() == movementInfo.t_guid)
{
GetPlayer()->m_transport = (*iter);
(*iter)->AddPassenger(GetPlayer());
break;
}
}
}
}
else if (GetPlayer()->m_transport) // if we were on a transport, leave
{
GetPlayer()->m_transport->RemovePassenger(GetPlayer());
GetPlayer()->m_transport = NULL;
movementInfo.t_x = 0.0f;
movementInfo.t_y = 0.0f;
movementInfo.t_z = 0.0f;
movementInfo.t_o = 0.0f;
movementInfo.t_time = 0;
movementInfo.t_seat = -1;
}
// fall damage generation (ignore in flight case that can be triggered also at lags in moment teleportation to another map).
if (opcode == MSG_MOVE_FALL_LAND && !GetPlayer()->isInFlight())
{
// calculate total z distance of the fall
float z_diff = GetPlayer()->m_lastFallZ - movementInfo.z;
sLog.outDebug("zDiff = %f", z_diff);
Player *target = GetPlayer();
//Players with low fall distance, Feather Fall or physical immunity (charges used) are ignored
// 14.57 can be calculated by resolving damageperc formular below to 0
if (z_diff >= 14.57f && !target->isDead() && !target->isGameMaster() &&
!target->HasAuraType(SPELL_AURA_HOVER) && !target->HasAuraType(SPELL_AURA_FEATHER_FALL) &&
!target->HasAuraType(SPELL_AURA_FLY) && !target->IsImmunedToDamage(SPELL_SCHOOL_MASK_NORMAL) )
{
//Safe fall, fall height reduction
int32 safe_fall = target->GetTotalAuraModifier(SPELL_AURA_SAFE_FALL);
float damageperc = 0.018f*(z_diff-safe_fall)-0.2426f;
if(damageperc >0 )
{
uint32 damage = (uint32)(damageperc * target->GetMaxHealth()*sWorld.getRate(RATE_DAMAGE_FALL));
float height = movementInfo.z;
target->UpdateGroundPositionZ(movementInfo.x,movementInfo.y,height);
if (damage > 0)
{
//Prevent fall damage from being more than the player maximum health
if (damage > target->GetMaxHealth())
damage = target->GetMaxHealth();
// Gust of Wind
if (target->GetDummyAura(43621))
damage = target->GetMaxHealth()/2;
target->EnvironmentalDamage(target->GetGUID(), DAMAGE_FALL, damage);
// recheck alive, might have died of EnvironmentalDamage
if (target->isAlive())
target->GetAchievementMgr().UpdateAchievementCriteria(ACHIEVEMENT_CRITERIA_TYPE_FALL_WITHOUT_DYING, uint32(z_diff*100));
}
//Z given by moveinfo, LastZ, FallTime, WaterZ, MapZ, Damage, Safefall reduction
DEBUG_LOG("FALLDAMAGE z=%f sz=%f pZ=%f FallTime=%d mZ=%f damage=%d SF=%d" , movementInfo.z, height, target->GetPositionZ(), movementInfo.fallTime, height, damage, safe_fall);
}
}
}
if(((movementInfo.flags & MOVEMENTFLAG_SWIMMING) != 0) != GetPlayer()->IsInWater())
{
// now client not include swimming flag in case jumping under water
GetPlayer()->SetInWater( !GetPlayer()->IsInWater() || GetPlayer()->GetBaseMap()->IsUnderWater(movementInfo.x, movementInfo.y, movementInfo.z) );
}
/*----------------------*/
/* process position-change */
Unit *mover = _player->m_mover;
recv_data.put<uint32>(6, getMSTime()); // fix time, offset flags(4) + unk(2)
WorldPacket data(recv_data.GetOpcode(), (mover->GetPackGUID().size()+recv_data.size()));
data.append(_player->m_mover->GetPackGUID()); // use mover guid
data.append(recv_data.contents(), recv_data.size());
GetPlayer()->SendMessageToSet(&data, false);
if(!_player->GetCharmGUID()) // nothing is charmed
{
_player->SetPosition(movementInfo.x, movementInfo.y, movementInfo.z, movementInfo.o);
_player->m_movementInfo = movementInfo;
_player->SetUnitMovementFlags(movementInfo.flags);
}
else
{
if(mover->GetTypeId() != TYPEID_PLAYER) // unit, creature, pet, vehicle...
{
if(Map *map = mover->GetMap())
map->CreatureRelocation((Creature*)mover, movementInfo.x, movementInfo.y, movementInfo.z, movementInfo.o);
mover->SetUnitMovementFlags(movementInfo.flags);
}
else // player
{
((Player*)mover)->SetPosition(movementInfo.x, movementInfo.y, movementInfo.z, movementInfo.o);
((Player*)mover)->m_movementInfo = movementInfo;
((Player*)mover)->SetUnitMovementFlags(movementInfo.flags);
}
}
if (GetPlayer()->m_lastFallTime >= movementInfo.fallTime || GetPlayer()->m_lastFallZ <=movementInfo.z || recv_data.GetOpcode() == MSG_MOVE_FALL_LAND)
GetPlayer()->SetFallInformation(movementInfo.fallTime, movementInfo.z);
if(GetPlayer()->isMovingOrTurning())
GetPlayer()->RemoveSpellsCausingAura(SPELL_AURA_FEIGN_DEATH);
if(movementInfo.z < -500.0f)
{
if(GetPlayer()->InBattleGround()
&& GetPlayer()->GetBattleGround()
&& GetPlayer()->GetBattleGround()->HandlePlayerUnderMap(_player))
{
// do nothing, the handle already did if returned true
}
else
{
// NOTE: this is actually called many times while falling
// even after the player has been teleported away
// TODO: discard movement packets after the player is rooted
if(GetPlayer()->isAlive())
{
GetPlayer()->EnvironmentalDamage(GetPlayer()->GetGUID(),DAMAGE_FALL_TO_VOID, GetPlayer()->GetMaxHealth());
// change the death state to CORPSE to prevent the death timer from
// starting in the next player update
GetPlayer()->KillPlayer();
GetPlayer()->BuildPlayerRepop();
}
// cancel the death timer here if started
GetPlayer()->RepopAtGraveyard();
}
}
}
/**
* GetHealTarget()
* return Unit* Returns unit to be healed. First checks 'critical' Healer(s), next Tank(s), next Master (if different from:), next DPS.
* If none of the healths are low enough (or multiple valid targets) against these checks, the lowest health is healed. Having a target
* returned does not guarantee it's worth healing, merely that the target does not have 100% health.
*
* return NULL If NULL is returned, no healing is required. At all.
*
* Will need extensive re-write for co-operation amongst multiple healers. As it stands, multiple healers would all pick the same 'ideal'
* healing target.
*/
Player* PlayerbotClassAI::GetHealTarget(JOB_TYPE type)
{
if (!m_ai) return nullptr;
if (!m_bot) return nullptr;
if (!m_bot->isAlive() || m_bot->IsInDuel()) return nullptr;
// define seperately for sorting purposes - DO NOT CHANGE ORDER!
std::vector<heal_priority> targets;
// First, fill the list of targets
if (m_bot->GetGroup())
{
Group::MemberSlotList const& groupSlot = m_bot->GetGroup()->GetMemberSlots();
for (Group::member_citerator itr = groupSlot.begin(); itr != groupSlot.end(); itr++)
{
Player *groupMember = sObjectMgr.GetPlayer(itr->guid);
if (!groupMember || !groupMember->isAlive() || groupMember->IsInDuel())
continue;
JOB_TYPE job = GetTargetJob(groupMember);
if (job & type)
targets.push_back( heal_priority(groupMember, (groupMember->GetHealth() * 100 / groupMember->GetMaxHealth()), job) );
}
}
else
{
targets.push_back( heal_priority(m_bot, m_bot->GetHealthPercent(), GetTargetJob(m_bot)) );
if (m_master && !m_master->IsInDuel())
targets.push_back( heal_priority(m_master, (m_master->GetHealth() * 100 / m_master->GetMaxHealth()), GetTargetJob(m_master)) );
}
// Sorts according to type: Healers first, tanks next, then master followed by DPS, thanks to the order of the TYPE enum
std::sort(targets.begin(), targets.end());
uint8 uCount = 0,i = 0;
// x is used as 'target found' variable; i is used as the targets iterator throughout all 4 types.
int16 x = -1;
// Try to find a healer in need of healing (if multiple, the lowest health one)
while (true)
{
// This works because we sorted it above
if ( (uCount + i) >= targets.size() || !(targets.at(uCount).type & JOB_HEAL)) break;
uCount++;
}
// We have uCount healers in the targets, check if any qualify for priority healing
for (; uCount > 0; uCount--, i++)
{
if (targets.at(i).hp <= m_MinHealthPercentHealer)
if (x == -1 || targets.at(x).hp > targets.at(i).hp)
x = i;
}
if (x > -1) return targets.at(x).p;
// Try to find a tank in need of healing (if multiple, the lowest health one)
while (true)
{
if ( (uCount + i) >= targets.size() || !(targets.at(uCount).type & JOB_TANK)) break;
uCount++;
}
for (; uCount > 0; uCount--, i++)
{
if (targets.at(i).hp <= m_MinHealthPercentTank)
if (x == -1 || targets.at(x).hp > targets.at(i).hp)
x = i;
}
if (x > -1) return targets.at(x).p;
// Try to find master in need of healing (lowest health one first)
if (m_MinHealthPercentMaster != m_MinHealthPercentDPS)
{
while (true)
{
if ( (uCount + i) >= targets.size() || !(targets.at(uCount).type & JOB_MASTER)) break;
uCount++;
}
for (; uCount > 0; uCount--, i++)
{
if (targets.at(i).hp <= m_MinHealthPercentMaster)
if (x == -1 || targets.at(x).hp > targets.at(i).hp)
x = i;
}
if (x > -1) return targets.at(x).p;
}
// Try to find anyone else in need of healing (lowest health one first)
while (true)
{
if ( (uCount + i) >= targets.size() ) break;
uCount++;
}
for (; uCount > 0; uCount--, i++)
{
if (targets.at(i).hp <= m_MinHealthPercentDPS)
if (x == -1 || targets.at(x).hp > targets.at(i).hp)
x = i;
}
if (x > -1) return targets.at(x).p;
// Nobody is critical, find anyone hurt at all, return lowest (let the healer sort out if it's worth healing or not)
for (i = 0, uCount = targets.size(); uCount > 0; uCount--, i++)
{
if (targets.at(i).hp < 100)
if (x == -1 || targets.at(x).hp > targets.at(i).hp)
x = i;
}
if (x > -1) return targets.at(x).p;
return nullptr;
}
void WorldSession::HandleMovementOpcodes( WorldPacket & recv_data )
{
uint32 opcode = recv_data.GetOpcode();
DEBUG_LOG("WORLD: Recvd %s (%u, 0x%X) opcode", LookupOpcodeName(opcode), opcode, opcode);
recv_data.hexlike();
Unit *mover = _player->GetMover();
Player *plMover = mover->GetTypeId() == TYPEID_PLAYER ? (Player*)mover : NULL;
// ignore, waiting processing in WorldSession::HandleMoveWorldportAckOpcode and WorldSession::HandleMoveTeleportAck
if (plMover && plMover->IsBeingTeleported())
{
recv_data.rpos(recv_data.wpos()); // prevent warnings spam
return;
}
/* extract packet */
ObjectGuid guid;
MovementInfo movementInfo;
recv_data >> guid.ReadAsPacked();
recv_data >> movementInfo;
/*----------------*/
if (!Diamond::IsValidMapCoord(movementInfo.GetPos()->x, movementInfo.GetPos()->y, movementInfo.GetPos()->z, movementInfo.GetPos()->o))
{
recv_data.rpos(recv_data.wpos()); // prevent warnings spam
return;
}
/* handle special cases */
if (movementInfo.HasMovementFlag(MOVEFLAG_ONTRANSPORT))
{
// transports size limited
// (also received at zeppelin/lift leave by some reason with t_* as absolute in continent coordinates, can be safely skipped)
if ( movementInfo.GetTransportPos()->x > 50 || movementInfo.GetTransportPos()->y > 50 || movementInfo.GetTransportPos()->z > 100 )
{
recv_data.rpos(recv_data.wpos()); // prevent warnings spam
return;
}
if ( !Diamond::IsValidMapCoord(movementInfo.GetPos()->x + movementInfo.GetTransportPos()->x, movementInfo.GetPos()->y + movementInfo.GetTransportPos()->y,
movementInfo.GetPos()->z + movementInfo.GetTransportPos()->z, movementInfo.GetPos()->o + movementInfo.GetTransportPos()->o) )
{
recv_data.rpos(recv_data.wpos()); // prevent warnings spam
return;
}
// if we boarded a transport, add us to it
if (plMover && !plMover->m_transport)
{
float trans_rad = movementInfo.GetTransportPos()->x*movementInfo.GetTransportPos()->x + movementInfo.GetTransportPos()->y*movementInfo.GetTransportPos()->y + movementInfo.GetTransportPos()->z*movementInfo.GetTransportPos()->z;
if (trans_rad > 3600.0f) // transport radius = 60 yards //cheater with on_transport_flag
{
return;
}
// elevators also cause the client to send MOVEFLAG_ONTRANSPORT - just unmount if the guid can be found in the transport list
for (MapManager::TransportSet::const_iterator iter = sMapMgr.m_Transports.begin(); iter != sMapMgr.m_Transports.end(); ++iter)
{
if ((*iter)->GetObjectGuid() == movementInfo.GetTransportGuid())
{
plMover->m_transport = (*iter);
(*iter)->AddPassenger(plMover);
if (plMover->GetVehicleKit())
plMover->GetVehicleKit()->RemoveAllPassengers();
break;
}
}
}
}
else if (plMover && plMover->m_transport) // if we were on a transport, leave
{
plMover->m_transport->RemovePassenger(plMover);
plMover->m_transport = NULL;
movementInfo.ClearTransportData();
}
// fall damage generation (ignore in flight case that can be triggered also at lags in moment teleportation to another map).
if (opcode == MSG_MOVE_FALL_LAND && plMover && !plMover->IsTaxiFlying())
plMover->HandleFall(movementInfo);
if (plMover && (movementInfo.HasMovementFlag(MOVEFLAG_SWIMMING) != plMover->IsInWater()))
{
// now client not include swimming flag in case jumping under water
plMover->SetInWater( !plMover->IsInWater() || plMover->GetBaseMap()->IsUnderWater(movementInfo.GetPos()->x, movementInfo.GetPos()->y, movementInfo.GetPos()->z) );
if (plMover->GetBaseMap()->IsUnderWater(movementInfo.GetPos()->x, movementInfo.GetPos()->y, movementInfo.GetPos()->z-7.0f))
{
plMover->m_anti_BeginFallZ=INVALID_HEIGHT;
}
}
// ---- anti-cheat features -->>>
uint32 Anti_TeleTimeDiff=plMover ? time(NULL) - plMover->Anti__GetLastTeleTime() : time(NULL);
static const uint32 Anti_TeleTimeIgnoreDiff=sWorld.GetMvAnticheatIgnoreAfterTeleport();
if (plMover && (plMover->m_transport == 0) && sWorld.GetMvAnticheatEnable() &&
GetPlayer()->GetSession()->GetSecurity() <= sWorld.GetMvAnticheatGmLevel() &&
GetPlayer()->GetMotionMaster()->GetCurrentMovementGeneratorType()!=FLIGHT_MOTION_TYPE &&
Anti_TeleTimeDiff>Anti_TeleTimeIgnoreDiff)
{
const uint32 CurTime=getMSTime();
if (getMSTimeDiff(GetPlayer()->m_anti_lastalarmtime,CurTime) > sWorld.GetMvAnticheatAlarmPeriod())
{
GetPlayer()->m_anti_alarmcount = 0;
}
/* I really don't care about movement-type yet (todo)
UnitMoveType move_type;
if (movementInfo.flags & MOVEMENTFLAG_FLYING) move_type = MOVE_FLY;
else if (movementInfo.flags & MOVEMENTFLAG_SWIMMING) move_type = MOVE_SWIM;
else if (movementInfo.flags & MOVEMENTFLAG_WALK_MODE) move_type = MOVE_WALK;
else move_type = MOVE_RUN;*/
float delta_x = GetPlayer()->GetPositionX() - movementInfo.GetPos()->x;
float delta_y = GetPlayer()->GetPositionY() - movementInfo.GetPos()->y;
float delta_z = GetPlayer()->GetPositionZ() - movementInfo.GetPos()->z;
float delta = sqrt(delta_x * delta_x + delta_y * delta_y); // Len of movement-vector via Pythagoras (a^2+b^2=Len^2)
float tg_z = 0.0f; //tangens
float delta_t = getMSTimeDiff(GetPlayer()->m_anti_lastmovetime,CurTime);
GetPlayer()->m_anti_lastmovetime = CurTime;
GetPlayer()->m_anti_MovedLen += delta;
if (delta_t > 15000.0f)
{ delta_t = 15000.0f; }
// Tangens of walking angel
if (!(movementInfo.GetMovementFlags() & (MOVEFLAG_FLYING | MOVEFLAG_SWIMMING)))
{
tg_z = ((delta !=0.0f) && (delta_z > 0.0f)) ? (atan((delta_z*delta_z) / delta) * 180.0f / M_PI) : 0.0f;
}
//antiOFF fall-damage, MOVEMENTFLAG_UNK4 seted by client if player try movement when falling and unset in this case the MOVEMENTFLAG_FALLING flag.
if ((!GetPlayer()->CanFly() && GetPlayer()->m_anti_BeginFallZ == INVALID_HEIGHT) &&
(movementInfo.GetMovementFlags() & (MOVEFLAG_FALLING | MOVEFLAG_FALLINGFAR)) != 0)
{
GetPlayer()->m_anti_BeginFallZ=(float)(movementInfo.GetPos()->z);
}
if (GetPlayer()->m_anti_NextLenCheck <= CurTime)
{
// Check every 500ms is a lot more advisable then 1000ms, because normal movment packet arrives every 500ms
uint32 OldNextLenCheck=GetPlayer()->m_anti_NextLenCheck;
float delta_xyt=GetPlayer()->m_anti_MovedLen/(float)(getMSTimeDiff(OldNextLenCheck-500,CurTime));
GetPlayer()->m_anti_NextLenCheck = CurTime+500;
GetPlayer()->m_anti_MovedLen = 0.0f;
static const float MaxDeltaXYT = sWorld.GetMvAnticheatMaxXYT();
if (delta_xyt > MaxDeltaXYT && delta<=100.0f && GetPlayer()->GetZoneId() != 2257)
{
if (sWorld.GetMvAnticheatSpeedCheck())
Anti__CheatOccurred(CurTime,"Speed hack",delta_xyt,LookupOpcodeName(opcode),
(float)(GetPlayer()->GetMotionMaster()->GetCurrentMovementGeneratorType()),
(float)(getMSTimeDiff(OldNextLenCheck-500,CurTime)));
}
}
if (delta > 100.0f && GetPlayer()->GetZoneId() != 2257)
{
if (sWorld.GetMvAnticheatTeleportCheck())
Anti__ReportCheat("Tele hack",delta,LookupOpcodeName(opcode));
}
// Check for waterwalking . Fix new way of checking for waterwalking by Darky88
if (movementInfo.HasMovementFlag(MOVEFLAG_WATERWALKING) &&
!(GetPlayer()->HasAuraType(SPELL_AURA_WATER_WALK) || GetPlayer()->HasAuraType(SPELL_AURA_GHOST)))
{
if (sWorld.GetMvAnticheatWaterCheck())
Anti__CheatOccurred(CurTime,"Water walking",0.0f,NULL,0.0f,(uint32)(movementInfo.GetMovementFlags()));
}
// Check for walking upwards a mountain while not beeing able to do that, New check by Darky88
if ((delta_z < -2.3f) && (tg_z > 2.37f))
{
if (sWorld.GetMvAnticheatMountainCheck())
Anti__CheatOccurred(CurTime,"Mountain hack",tg_z,NULL,delta,delta_z);
}
static const float DIFF_OVERGROUND = 10.0f;
float Anti__GroundZ = GetPlayer()->GetMap()->GetHeight(GetPlayer()->GetPositionX(),GetPlayer()->GetPositionY(),MAX_HEIGHT);
float Anti__FloorZ = GetPlayer()->GetMap()->GetHeight(GetPlayer()->GetPositionX(),GetPlayer()->GetPositionY(),GetPlayer()->GetPositionZ());
float Anti__MapZ = ((Anti__FloorZ <= (INVALID_HEIGHT+5.0f)) ? Anti__GroundZ : Anti__FloorZ) + DIFF_OVERGROUND;
if (!GetPlayer()->CanFly() &&
!GetPlayer()->GetBaseMap()->IsUnderWater(movementInfo.GetPos()->x, movementInfo.GetPos()->y, movementInfo.GetPos()->z-7.0f) &&
Anti__MapZ < GetPlayer()->GetPositionZ() && Anti__MapZ > (INVALID_HEIGHT+DIFF_OVERGROUND + 5.0f))
{
static const float DIFF_AIRJUMP=25.0f; // 25 is realy high, but to many false positives...
// Air-Jump-Detection definitively needs a better way to be detected...
if ((movementInfo.GetMovementFlags() & (MOVEFLAG_CAN_FLY | MOVEFLAG_FLYING | MOVEFLAG_ROOT)) != 0) // Fly Hack
{
// Fix Aura 55164
if (!GetPlayer()->HasAura(55164) || !GetPlayer()->HasAuraType(SPELL_AURA_FEATHER_FALL))
if (sWorld.GetMvAnticheatFlyCheck())
Anti__CheatOccurred(CurTime,"Fly hack",
((uint8)(GetPlayer()->HasAuraType(SPELL_AURA_FLY))) +
((uint8)(GetPlayer()->HasAuraType(SPELL_AURA_MOD_FLIGHT_SPEED_MOUNTED))*2),
NULL,GetPlayer()->GetPositionZ()-Anti__MapZ);
}
// Need a better way to do that - currently a lot of fake alarms
else if ((Anti__MapZ+DIFF_AIRJUMP < GetPlayer()->GetPositionZ() &&
(movementInfo.GetMovementFlags() & (MOVEFLAG_FALLINGFAR | MOVEFLAG_PENDINGSTOP))==0) ||
(Anti__MapZ < GetPlayer()->GetPositionZ() && opcode==MSG_MOVE_JUMP) &&
!GetPlayer()->HasAuraType(SPELL_AURA_FEATHER_FALL))
{
if (sWorld.GetMvAnticheatJumpCheck())
Anti__CheatOccurred(CurTime,"Possible Air Jump Hack",0.0f,LookupOpcodeName(opcode),0.0f,movementInfo.GetMovementFlags());
}
}
/*if (Anti__FloorZ < -199900.0f && Anti__GroundZ >= -199900.0f &&
GetPlayer()->GetPositionZ()+5.0f < Anti__GroundZ)
{
Anti__CheatOccurred(CurTime,"Teleport2Plane hack",
GetPlayer()->GetPositionZ(),NULL,Anti__GroundZ);
}*/
//Teleport To Plane checks
if (movementInfo.GetPos()->z < 0.0001f && movementInfo.GetPos()->z > -0.0001f && (!movementInfo.HasMovementFlag(MovementFlags(MOVEFLAG_SWIMMING | MOVEFLAG_CAN_FLY | MOVEFLAG_FLYING))))
{
if (sWorld.GetMvAnticheatTeleport2PlaneCheck())
{
// Prevent using TeleportToPlan.
Map *map = GetPlayer()->GetMap();
if (map)
{
float plane_z = map->GetHeight(movementInfo.GetPos()->x, movementInfo.GetPos()->y, MAX_HEIGHT) - movementInfo.GetPos()->z;
plane_z = (plane_z < -500.0f) ? 0 : plane_z; //check holes in heigth map
if (plane_z > 0.1f || plane_z < -0.1f)
{
if (sWorld.GetMvAnticheatTeleport2PlaneCheck())
Anti__CheatOccurred(CurTime,"Teleport2Plane hack",GetPlayer()->GetPositionZ(),NULL,plane_z);
}
}
}
}
}
// <<---- anti-cheat features
/* process position-change */
movementInfo.UpdateTime(getMSTime());
WorldPacket data(opcode, recv_data.size());
data.appendPackGUID(mover->GetGUID()); // write guid
movementInfo.Write(data); // write data
mover->SendMessageToSetExcept(&data, _player);
mover->m_movementInfo = movementInfo;
mover->SetPosition(movementInfo.GetPos()->x, movementInfo.GetPos()->y, movementInfo.GetPos()->z, movementInfo.GetPos()->o);
if (plMover) // nothing is charmed, or player charmed
{
plMover->UpdateFallInformationIfNeed(movementInfo, opcode);
// after move info set
if ((opcode == MSG_MOVE_SET_WALK_MODE || opcode == MSG_MOVE_SET_RUN_MODE))
plMover->UpdateWalkMode(plMover, false);
if (plMover->isMovingOrTurning())
plMover->RemoveSpellsCausingAura(SPELL_AURA_FEIGN_DEATH);
if (movementInfo.GetPos()->z < -500.0f)
{
if (plMover->InBattleGround()
&& plMover->GetBattleGround()
&& plMover->GetBattleGround()->HandlePlayerUnderMap(_player))
{
// do nothing, the handle already did if returned true
}
else
{
// NOTE: this is actually called many times while falling
// even after the player has been teleported away
// TODO: discard movement packets after the player is rooted
if (plMover->isAlive())
{
plMover->EnvironmentalDamage(DAMAGE_FALL_TO_VOID, plMover->GetMaxHealth());
// pl can be alive if GM/etc
if (!plMover->isAlive())
{
// change the death state to CORPSE to prevent the death timer from
// starting in the next player update
plMover->KillPlayer();
plMover->BuildPlayerRepop();
}
}
// cancel the death timer here if started
plMover->RepopAtGraveyard();
}
}
}
}
/*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();
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->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 << 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.t_seat]);
SendPacket(&data);
}
//constructor
ForceOfNature(Creature* pCreature) : CreatureAIScript(pCreature)
{
//only handle spell created mobs
if( pCreature->GetUInt32Value( UNIT_FIELD_CREATEDBY ) == 0 )
return;
// !! not anymore in cattaclysm
//check if difficulty proto has "wrath" as ai_agent. If not then we will add it
/* CreatureProto *proto = pCreature->GetProto();
if( proto->spells.empty() == true )
{
AI_Spell *sp = new AI_Spell;
memset( sp, 0, sizeof( AI_Spell ) );
sp->entryId = 1964;
sp->agent = AGENT_SPELL;
sp->minrange = 2;
sp->procChance = 100;
sp->procCount = MAX_INT;
sp->spell = dbcSpell.LookupEntryForced( 5176 );
sp->maxrange = 30;
sp->spelltargetType = TTYPE_SINGLETARGET;
sp->cooldown = 2000;
sp->min_hp_pct = 0;
sp->autocast_type=AUTOCAST_EVENT_NONE;
sp->max_hp_pct = 100;
sp->initial_cooldown = 0;
sp->global_cooldown = 0; //have this value in milliseconds
sp->difficulty_mask = 0x00FFFFFF; //prev field is shout
proto->spells.push_back( sp );
//also add it to us
pCreature->GetAIInterface()->addSpellToList( sp );
} */
//low dmg
Player *owner = _unit->GetMapMgr()->GetPlayer( _unit->GetUInt32Value( UNIT_FIELD_CREATEDBY ) );
if( owner != NULL )
{
//health from wowhead
// uint32 health_per_level = 300/61;
// pCreature->SetUInt32Value(UNIT_FIELD_MAXHEALTH, health_per_level * pCreature->getLevel() + 100 );
pCreature->SetUInt32Value(UNIT_FIELD_MAXHEALTH, owner->GetMaxHealth() / 5 );
pCreature->SetUInt32Value(UNIT_FIELD_HEALTH,pCreature->GetUInt32Value(UNIT_FIELD_MAXHEALTH));
float base_dmg = 5.0f + owner->GetDamageDoneMod(SCHOOL_NATURE) * 15.0f / 100.0f; //around 800-1000 dmg
if( base_dmg < 150 )
base_dmg = owner->getLevel() * 1000.0f / 80.0f;
/* Aura *a = owner->FindAuraPassiveByNameHash( SPELL_HASH_BRAMBLES );
if( a )
{
// base_dmg += base_dmg * a->m_modList[2] / 100;
base_dmg += base_dmg * (a->GetSpellProto()->eff[0].EffectBasePoints + 1) / 100;
//register spell that will stun target
SpellEntry *sp = dbcSpell.LookupEntryForced( CREATURE_SPELL_TO_DAZE );
ProcTriggerSpell pts( sp );
pts.caster = _unit->GetGUID();
pts.spellId = sp->Id;
pts.procFlags = PROC_ON_MELEE_ATTACK;
pts.created_with_value = sp->eff[0].EffectBasePoints + 1;
pts.procCharges = 0;
pts.procChance = 15;
_unit->RegisterScriptProcStruct(pts);
}*/
pCreature->SetFloatValue( UNIT_FIELD_MINDAMAGE, base_dmg );
pCreature->SetFloatValue( UNIT_FIELD_MAXDAMAGE, base_dmg * 3 / 2 );
}
// pCreature->BaseAttackType = SCHOOL_NATURE;
}
void PlayerbotShamanAI::DoNonCombatActions()
{
PlayerbotAI* ai = GetAI();
Player * m_bot = GetPlayerBot();
if (!m_bot)
return;
SpellSequence = SPELL_ENHANCEMENT;
// buff master with EARTH_SHIELD
if (EARTH_SHIELD > 0)
(!GetMaster()->HasAura(EARTH_SHIELD, EFFECT_INDEX_0) && ai->CastSpell(EARTH_SHIELD, *(GetMaster())));
// buff myself with WATER_SHIELD, LIGHTNING_SHIELD
if (WATER_SHIELD > 0)
(!m_bot->HasAura(WATER_SHIELD, EFFECT_INDEX_0) && !m_bot->HasAura(LIGHTNING_SHIELD, EFFECT_INDEX_0) && ai->CastSpell(WATER_SHIELD, *m_bot));
else if (LIGHTNING_SHIELD > 0)
(!m_bot->HasAura(LIGHTNING_SHIELD, EFFECT_INDEX_0) && !m_bot->HasAura(WATER_SHIELD, EFFECT_INDEX_0) && ai->CastSpell(LIGHTNING_SHIELD, *m_bot));
/*
// buff myself weapon
if (ROCKBITER_WEAPON > 0)
(!m_bot->HasAura(ROCKBITER_WEAPON, EFFECT_INDEX_0) && !m_bot->HasAura(EARTHLIVING_WEAPON, EFFECT_INDEX_0) && !m_bot->HasAura(WINDFURY_WEAPON, EFFECT_INDEX_0) && !m_bot->HasAura(FLAMETONGUE_WEAPON, EFFECT_INDEX_0) && !m_bot->HasAura(FROSTBRAND_WEAPON, EFFECT_INDEX_0) && ai->CastSpell(ROCKBITER_WEAPON,*m_bot) );
else if (EARTHLIVING_WEAPON > 0)
(!m_bot->HasAura(EARTHLIVING_WEAPON, EFFECT_INDEX_0) && !m_bot->HasAura(EARTHLIVING_WEAPON, EFFECT_INDEX_0) && !m_bot->HasAura(FLAMETONGUE_WEAPON, EFFECT_INDEX_0) && !m_bot->HasAura(FROSTBRAND_WEAPON, EFFECT_INDEX_0) && !m_bot->HasAura(ROCKBITER_WEAPON, EFFECT_INDEX_0) && ai->CastSpell(WINDFURY_WEAPON,*m_bot) );
else if (WINDFURY_WEAPON > 0)
(!m_bot->HasAura(WINDFURY_WEAPON, EFFECT_INDEX_0) && !m_bot->HasAura(EARTHLIVING_WEAPON, EFFECT_INDEX_0) && !m_bot->HasAura(FLAMETONGUE_WEAPON, EFFECT_INDEX_0) && !m_bot->HasAura(FROSTBRAND_WEAPON, EFFECT_INDEX_0) && !m_bot->HasAura(ROCKBITER_WEAPON, EFFECT_INDEX_0) && ai->CastSpell(WINDFURY_WEAPON,*m_bot) );
else if (FLAMETONGUE_WEAPON > 0)
(!m_bot->HasAura(FLAMETONGUE_WEAPON, EFFECT_INDEX_0) && !m_bot->HasAura(EARTHLIVING_WEAPON, EFFECT_INDEX_0) && !m_bot->HasAura(WINDFURY_WEAPON, EFFECT_INDEX_0) && !m_bot->HasAura(FROSTBRAND_WEAPON, EFFECT_INDEX_0) && !m_bot->HasAura(ROCKBITER_WEAPON, EFFECT_INDEX_0) && ai->CastSpell(FLAMETONGUE_WEAPON,*m_bot) );
else if (FROSTBRAND_WEAPON > 0)
(!m_bot->HasAura(FROSTBRAND_WEAPON, EFFECT_INDEX_0) && !m_bot->HasAura(EARTHLIVING_WEAPON, EFFECT_INDEX_0) && !m_bot->HasAura(WINDFURY_WEAPON, EFFECT_INDEX_0) && !m_bot->HasAura(FLAMETONGUE_WEAPON, EFFECT_INDEX_0) && !m_bot->HasAura(ROCKBITER_WEAPON, EFFECT_INDEX_0) && ai->CastSpell(FROSTBRAND_WEAPON,*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;
}
// heal master's group
if (GetMaster()->GetGroup())
{
Group::MemberSlotList const& groupSlot = GetMaster()->GetGroup()->GetMemberSlots();
for (Group::member_citerator itr = groupSlot.begin(); itr != groupSlot.end(); itr++)
{
Player *tPlayer = sObjectMgr.GetPlayer(itr->guid);
if (!tPlayer || !tPlayer->isAlive())
continue;
if (tPlayer->IsInDuelWith(GetMaster()))
continue;
// heal
(HealTarget(*tPlayer, tPlayer->GetHealth() * 100 / tPlayer->GetMaxHealth()));
}
}
} // end DoNonCombatActions
/*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 = 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;
size_t maskPos = data.wpos();
data << (uint64) auramask; // placeholder
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;
size_t petMaskPos = data.wpos();
data << (uint64) petauramask; // placeholder
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 << (uint64) 0; // GROUP_UPDATE_FLAG_PET_AURAS
}
SendPacket(&data);
}
void UpdateAI(const uint32 uiDiff) override
{
if (m_uiPossessEndTimer)
{
// Check if the possessed player has been damaged
if (m_uiPossessEndTimer <= uiDiff)
{
// If aura has expired, return to fight
if (!m_creature->HasAura(SPELL_POSSESS_INV))
{
m_uiPossessEndTimer = 0;
return;
}
// Check for possessed player
Player* pPlayer = m_creature->GetMap()->GetPlayer(m_possessedPlayer);
if (!pPlayer || !pPlayer->IsAlive())
{
m_creature->RemoveAurasDueToSpell(SPELL_POSSESS_INV);
m_uiPossessEndTimer = 0;
return;
}
// If possessed player has less than 50% health
if (pPlayer->GetHealth() <= pPlayer->GetMaxHealth() * .5f)
{
m_creature->RemoveAurasDueToSpell(SPELL_POSSESS_INV);
pPlayer->RemoveAurasDueToSpell(SPELL_POSSESSED);
pPlayer->RemoveAurasDueToSpell(SPELL_POSSESS);
m_uiPossessEndTimer = 0;
return;
}
m_uiPossessEndTimer = 1000;
}
else
{
m_uiPossessEndTimer -= uiDiff;
}
}
if (!m_creature->SelectHostileTarget() || !m_creature->getVictim())
{
return;
}
// BansheeWail
if (m_uiBansheeWailTimer < uiDiff)
{
if (Unit* pTarget = m_creature->SelectAttackingTarget(ATTACKING_TARGET_RANDOM, 0))
{
if (DoCastSpellIfCan(pTarget, SPELL_BANSHEE_WAIL) == CAST_OK)
{
m_uiBansheeWailTimer = urand(2000, 3000);
}
}
}
else
{
m_uiBansheeWailTimer -= uiDiff;
}
// BansheeCurse
if (m_uiBansheeCurseTimer < uiDiff)
{
if (DoCastSpellIfCan(m_creature, SPELL_BANSHEE_CURSE) == CAST_OK)
{
m_uiBansheeCurseTimer = 20000;
}
}
else
{
m_uiBansheeCurseTimer -= uiDiff;
}
// Silence
if (m_uiSilenceTimer < uiDiff)
{
if (Unit* pTarget = m_creature->SelectAttackingTarget(ATTACKING_TARGET_RANDOM, 0))
{
if (DoCastSpellIfCan(pTarget, SPELL_SILENCE) == CAST_OK)
{
m_uiSilenceTimer = 25000;
}
}
}
else
{
m_uiSilenceTimer -= uiDiff;
}
// Possess
if (m_uiPossessTimer < uiDiff)
{
if (Unit* pTarget = m_creature->SelectAttackingTarget(ATTACKING_TARGET_RANDOM, 1, SPELL_POSSESS, SELECT_FLAG_PLAYER))
{
if (DoCastSpellIfCan(pTarget, SPELL_POSSESS) == CAST_OK)
{
DoCastSpellIfCan(pTarget, SPELL_POSSESSED, CAST_TRIGGERED);
DoCastSpellIfCan(m_creature, SPELL_POSSESS_INV, CAST_TRIGGERED);
m_possessedPlayer = pTarget->GetObjectGuid();
m_uiPossessEndTimer = 1000;
m_uiPossessTimer = 30000;
}
}
}
else
{
m_uiPossessTimer -= uiDiff;
}
DoMeleeAttackIfReady();
}
void PlayerbotPriestAI::DoNonCombatActions()
{
Player * m_bot = GetPlayerBot();
if (!m_bot)
return;
SpellSequence = SPELL_HOLY;
// buff myself
if (FORTITUDE > 0)
(!m_bot->HasAura(FORTITUDE, 0) && GetAI()->CastSpell (FORTITUDE, *m_bot));
if (INNER_FIRE > 0)
(!m_bot->HasAura(INNER_FIRE, 0) && GetAI()->CastSpell (INNER_FIRE, *m_bot));
if (TOUCH_OF_WEAKNESS > 0)
(m_bot->getRace()==5 /* undead */ && GetAI()->CastSpell (TOUCH_OF_WEAKNESS, *m_bot));
// buff master
if (FORTITUDE > 0)
(!GetMaster()->HasAura(FORTITUDE,0) && GetAI()->CastSpell (FORTITUDE, *(GetMaster())) );
// mana check
if (m_bot->getStandState() != UNIT_STAND_STATE_STAND)
m_bot->SetStandState(UNIT_STAND_STATE_STAND);
Item* pItem = GetAI()->FindDrink();
if (pItem != NULL && GetAI()->GetManaPercent() < 30)
{
GetAI()->TellMaster("I could use a drink.");
GetAI()->UseItem(*pItem);
GetAI()->SetIgnoreUpdateTime(30);
return;
}
// hp check
if (m_bot->getStandState() != UNIT_STAND_STATE_STAND)
m_bot->SetStandState(UNIT_STAND_STATE_STAND);
pItem = GetAI()->FindFood();
if (pItem != NULL && GetAI()->GetHealthPercent() < 30)
{
GetAI()->TellMaster("I could use some food.");
GetAI()->UseItem(*pItem);
GetAI()->SetIgnoreUpdateTime(30);
return;
}
//(!GetMaster()->HasAura(FORTITUDE,0) && GetAI()->CastSpell (FORTITUDE, *(GetMaster())) );
// buff and heal master's group
if (GetMaster()->GetGroup())
{
Group::MemberSlotList const& groupSlot = GetMaster()->GetGroup()->GetMemberSlots();
for (Group::member_citerator itr = groupSlot.begin(); itr != groupSlot.end(); itr++)
{
Player *tPlayer = objmgr.GetPlayer(uint64 (itr->guid));
if( !tPlayer )
continue;
// first rezz em
if ( !tPlayer->isAlive() && !tPlayer->IsPlayerbot() )
{
std::string msg = "rezzing ";
msg += tPlayer->GetName();
GetPlayerBot()->Say(msg, LANG_UNIVERSAL);
GetAI()->CastSpell(REZZ, *tPlayer);
// rez is only 10 sec, but give time for lag
GetAI()->SetIgnoreUpdateTime(17);
}
else if( tPlayer->isAlive() )
{
// buff and heal
(!tPlayer->HasAura(FORTITUDE,0) && GetAI()->CastSpell (FORTITUDE, *tPlayer));
(HealTarget(*tPlayer, tPlayer->GetHealth()*100 / tPlayer->GetMaxHealth()));
}
}
}
} // end DoNonCombatActions
void WorldSession::HandleMovementOpcodes( WorldPacket & recv_data )
{
uint32 opcode = recv_data.GetOpcode();
DEBUG_LOG("WORLD: Recvd %s (%u, 0x%X) opcode", LookupOpcodeName(opcode), opcode, opcode);
recv_data.hexlike();
Unit *mover = _player->GetMover();
Player *plMover = mover->GetTypeId() == TYPEID_PLAYER ? (Player*)mover : NULL;
// ignore, waiting processing in WorldSession::HandleMoveWorldportAckOpcode and WorldSession::HandleMoveTeleportAck
if(plMover && plMover->IsBeingTeleported())
{
recv_data.rpos(recv_data.wpos()); // prevent warnings spam
return;
}
/* extract packet */
ObjectGuid guid;
MovementInfo movementInfo;
recv_data >> guid.ReadAsPacked();
recv_data >> movementInfo;
/*----------------*/
// ignore wrong guid (player attempt cheating own session for not own guid possible...)
if (guid != mover->GetObjectGuid())
return;
if (!MaNGOS::IsValidMapCoord(movementInfo.GetPos()->x, movementInfo.GetPos()->y, movementInfo.GetPos()->z, movementInfo.GetPos()->o))
{
recv_data.rpos(recv_data.wpos()); // prevent warnings spam
return;
}
/* handle special cases */
if (movementInfo.HasMovementFlag(MOVEFLAG_ONTRANSPORT) && !mover->GetVehicleGUID())
{
// transports size limited
// (also received at zeppelin/lift leave by some reason with t_* as absolute in continent coordinates, can be safely skipped)
if( movementInfo.GetTransportPos()->x > 50 || movementInfo.GetTransportPos()->y > 50 || movementInfo.GetTransportPos()->z > 100 )
{
recv_data.rpos(recv_data.wpos()); // prevent warnings spam
return;
}
if( !MaNGOS::IsValidMapCoord(movementInfo.GetPos()->x + movementInfo.GetTransportPos()->x, movementInfo.GetPos()->y + movementInfo.GetTransportPos()->y,
movementInfo.GetPos()->z + movementInfo.GetTransportPos()->z, movementInfo.GetPos()->o + movementInfo.GetTransportPos()->o) )
{
recv_data.rpos(recv_data.wpos()); // prevent warnings spam
return;
}
// if we boarded a transport, add us to it
if (plMover && !plMover->m_transport)
{
// elevators also cause the client to send MOVEFLAG_ONTRANSPORT - just unmount if the guid can be found in the transport list
for (MapManager::TransportSet::const_iterator iter = sMapMgr.m_Transports.begin(); iter != sMapMgr.m_Transports.end(); ++iter)
{
if ((*iter)->GetObjectGuid() == movementInfo.GetTransportGuid())
{
plMover->m_transport = (*iter);
(*iter)->AddPassenger(plMover);
break;
}
}
}
}
else if (plMover && plMover->m_transport) // if we were on a transport, leave
{
plMover->m_transport->RemovePassenger(plMover);
plMover->m_transport = NULL;
movementInfo.ClearTransportData();
}
// fall damage generation (ignore in flight case that can be triggered also at lags in moment teleportation to another map).
if (opcode == MSG_MOVE_FALL_LAND && plMover && !plMover->IsTaxiFlying())
plMover->HandleFall(movementInfo);
if (plMover && (movementInfo.HasMovementFlag(MOVEFLAG_SWIMMING) != plMover->IsInWater()))
{
// now client not include swimming flag in case jumping under water
plMover->SetInWater( !plMover->IsInWater() || plMover->GetBaseMap()->IsUnderWater(movementInfo.GetPos()->x, movementInfo.GetPos()->y, movementInfo.GetPos()->z) );
}
if (movementInfo.HasMovementFlag(MOVEFLAG_SWIMMING))
{
if(mover->GetTypeId() == TYPEID_UNIT)
{
if(((Creature*)mover)->isVehicle() && !((Creature*)mover)->canSwim())
{
// NOTE : we should enter evade mode here, but...
((Vehicle*)mover)->SetSpawnDuration(1);
}
}
}
/*----------------------*/
/* process position-change */
movementInfo.UpdateTime(getMSTime());
WorldPacket data(opcode, recv_data.size());
data.appendPackGUID(mover->GetGUID()); // write guid
movementInfo.Write(data); // write data
mover->SendMessageToSetExcept(&data, _player);
if(plMover) // nothing is charmed, or player charmed
{
plMover->SetPosition(movementInfo.GetPos()->x, movementInfo.GetPos()->y, movementInfo.GetPos()->z, movementInfo.GetPos()->o);
plMover->m_movementInfo = movementInfo;
plMover->UpdateFallInformationIfNeed(movementInfo, opcode);
// after move info set
if ((opcode == MSG_MOVE_SET_WALK_MODE || opcode == MSG_MOVE_SET_RUN_MODE))
plMover->UpdateWalkMode(plMover, false);
if(plMover->isMovingOrTurning())
plMover->RemoveSpellsCausingAura(SPELL_AURA_FEIGN_DEATH);
if(movementInfo.GetPos()->z < -500.0f)
{
if(plMover->InBattleGround()
&& plMover->GetBattleGround()
&& plMover->GetBattleGround()->HandlePlayerUnderMap(_player))
{
// do nothing, the handle already did if returned true
}
else
{
// NOTE: this is actually called many times while falling
// even after the player has been teleported away
// TODO: discard movement packets after the player is rooted
if(plMover->isAlive())
{
plMover->EnvironmentalDamage(DAMAGE_FALL_TO_VOID, plMover->GetMaxHealth());
// pl can be alive if GM/etc
if(!plMover->isAlive())
{
// change the death state to CORPSE to prevent the death timer from
// starting in the next player update
plMover->KillPlayer();
plMover->BuildPlayerRepop();
}
}
// cancel the death timer here if started
plMover->RepopAtGraveyard();
}
}
}
else // creature charmed
{
if(mover->IsInWorld())
{
mover->GetMap()->CreatureRelocation((Creature*)mover, movementInfo.GetPos()->x, movementInfo.GetPos()->y, movementInfo.GetPos()->z, movementInfo.GetPos()->o);
if(((Creature*)mover)->isVehicle())
((Vehicle*)mover)->RellocatePassengers(mover->GetMap());
}
}
}
/*this procedure handles clients CMSG_REQUEST_PARTY_MEMBER_STATS request*/
void WorldSession::HandleRequestPartyMemberStatsOpcode(WorldPacket& recvData)
{
TC_LOG_DEBUG(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();
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->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 << 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()));
uint64 petAuraMask = 0;
maskPos = data.wpos();
data << uint64(petAuraMask); // placeholder
if (pet)
{
// 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)
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);
}
void PlayerbotDruidAI::DoNonCombatActions()
{
PlayerbotAI* ai = GetAI();
Player * m_bot = GetPlayerBot();
if (!m_bot)
return;
if(m_bot->GetAura(CAT_FORM, 0))
{
m_bot->RemoveAurasDueToSpell(768);
ai->TellMaster("FormClearCat");
}
if(m_bot->GetAura(BEAR_FORM, 0))
{
m_bot->RemoveAurasDueToSpell(5487);
ai->TellMaster("FormClearBear");
}
if(m_bot->GetAura(DIRE_BEAR_FORM, 0))
{
m_bot->RemoveAurasDueToSpell(9634);
ai->TellMaster("FormClearDireBear");
}
if(m_bot->GetAura(MOONKIN_FORM, 0))
{
m_bot->RemoveAurasDueToSpell(24858);
ai->TellMaster("FormClearMoonkin");
}
/*
// mana myself with MANA_REJUVENATION (*moved to combat: interferes with drinking/eating)
if (GetAI()->GetManaPercent() < 50 && MANA_REJUVENATION > 0 && !m_bot->HasAura(MANA_REJUVENATION, 0))
GetAI()->CastSpell(MANA_REJUVENATION, *m_bot);
*/
// buff myself with MARK_OF_THE_WILD
if (MARK_OF_THE_WILD > 0 && !m_bot->GetAura(MARK_OF_THE_WILD, 0))
ai->CastSpell (MARK_OF_THE_WILD, *m_bot);
// Thorns generates aggro for moonkin
if (THORNS > 0 && !m_bot->GetAura(THORNS, 0))
ai->CastSpell (THORNS, *m_bot);
/*
// buff master with THORNS
if (THORNS > 0 && !GetMaster()->HasAura(THORNS,0))
ai->CastSpell (THORNS, *(GetMaster()));
*/
// mana check
if (m_bot->getStandState() != UNIT_STAND_STATE_STAND)
m_bot->SetStandState(UNIT_STAND_STATE_STAND);
Item* pItem = ai->FindDrink();
if (pItem != NULL && ai->GetManaPercent() < 50)
{
ai->TellMaster("I could use a drink.");
ai->UseItem(*pItem);
ai->SetIgnoreUpdateTime(30);
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);
ai->SetIgnoreUpdateTime(30);
return;
}
// buff and heal master's group
if (GetMaster()->GetGroup())
{
Group::MemberSlotList const& groupSlot = GetMaster()->GetGroup()->GetMemberSlots();
for (Group::member_citerator itr = groupSlot.begin(); itr != groupSlot.end(); itr++)
{
Player *tPlayer = objmgr.GetPlayer(uint64 (itr->guid));
if( !tPlayer )
continue;
// first rezz em
if ( !tPlayer->isAlive() && !tPlayer->GetPlayerbotAI() )
{
std::string msg = "rezzing ";
msg += tPlayer->GetName();
GetPlayerBot()->Say(msg, LANG_UNIVERSAL);
ai->CastSpell(REVIVE, *tPlayer);
// rez is only 10 sec, but give time for lag
ai->SetIgnoreUpdateTime(17);
}
else if( tPlayer->isAlive() )
{
// buff and heal
(!tPlayer->GetAura(MARK_OF_THE_WILD,0) && ai->CastSpell (MARK_OF_THE_WILD, *tPlayer));
//(!tPlayer->HasAura(THORNS,0) && GetAI()->CastSpell (THORNS, *tPlayer));
(HealTarget(*tPlayer, tPlayer->GetHealth()*100 / tPlayer->GetMaxHealth()));
return;
}
}
}
} // end DoNonCombatActions
