void WorldSession::SendTrainerList( uint64 guid,std::string strTitle )
{
sLog.outDebug( "WORLD: SendTrainerList" );
Creature *unit = ObjectAccessor::GetNPCIfCanInteractWith(*_player, guid,UNIT_NPC_FLAG_TRAINER);
if (!unit)
{
sLog.outDebug( "WORLD: SendTrainerList - Unit (GUID: %u) not found or you can't interact with him.", uint32(GUID_LOPART(guid)) );
return;
}
// remove fake death
if(GetPlayer()->hasUnitState(UNIT_STAT_DIED))
GetPlayer()->RemoveSpellsCausingAura(SPELL_AURA_FEIGN_DEATH);
// Lazy loading at first access
unit->LoadTrainerSpells();
// trainer list loaded at check;
if(!unit->isCanTrainingOf(_player,true))
return;
CreatureInfo const *ci = unit->GetCreatureInfo();
if (!ci)
{
sLog.outDebug( "WORLD: SendTrainerList - (%u) NO CREATUREINFO! (GUID: %u)", uint32(GUID_LOPART(guid)), guid );
return;
}
Creature::SpellsList const& trainer_spells = unit->GetTrainerSpells();
WorldPacket data( SMSG_TRAINER_LIST, 8+4+4+trainer_spells.size()*38 + strTitle.size()+1);
data << guid;
data << uint32(unit->GetTrainerType());
size_t count_pos = data.wpos();
data << uint32(trainer_spells.size());
// reputation discount
float fDiscountMod = _player->GetReputationPriceDiscount(unit);
uint32 count = 0;
for(Creature::SpellsList::const_iterator itr = trainer_spells.begin(); itr != trainer_spells.end(); ++itr)
{
if(!_player->IsSpellFitByClassAndRace(itr->spell->Id))
continue;
++count;
bool primary_prof_first_rank = spellmgr.IsPrimaryProfessionFirstRankSpell(itr->spell->Id);
data << uint32(itr->spell->Id);
data << uint8(_player->GetTrainerSpellState(&*itr));
data << uint32(floor(itr->spellcost * fDiscountMod));
data << uint32(primary_prof_first_rank ? 1 : 0); // primary prof. learn confirmation dialog
data << uint32(primary_prof_first_rank ? 1 : 0); // must be equal prev. field to have learn button in enabled state
data << uint8(itr->reqlevel ? itr->reqlevel : itr->spell->spellLevel);
data << uint32(itr->reqskill);
data << uint32(itr->reqskillvalue);
data << uint32(spellmgr.GetPrevSpellInChain(itr->spell->Id));
data << uint32(0);
data << uint32(0);
}
data << strTitle;
data.put<uint32>(count_pos,count);
SendPacket( &data );
}
void WorldSession::SendTrainerList( uint64 guid, const std::string& strTitle )
{
sLog.outDebug( "WORLD: SendTrainerList" );
Creature *unit = ObjectAccessor::GetNPCIfCanInteractWith(*_player, guid,UNIT_NPC_FLAG_TRAINER);
if (!unit)
{
sLog.outDebug( "WORLD: SendTrainerList - Unit (GUID: %u) not found or you can't interact with him.", uint32(GUID_LOPART(guid)) );
return;
}
// remove fake death
if(GetPlayer()->hasUnitState(UNIT_STAT_DIED))
GetPlayer()->RemoveSpellsCausingAura(SPELL_AURA_FEIGN_DEATH);
// trainer list loaded at check;
if(!unit->isCanTrainingOf(_player,true))
return;
CreatureInfo const *ci = unit->GetCreatureInfo();
if (!ci)
{
sLog.outDebug( "WORLD: SendTrainerList - (GUID: %u) NO CREATUREINFO!",GUID_LOPART(guid) );
return;
}
TrainerSpellData const* trainer_spells = unit->GetTrainerSpells();
if(!trainer_spells)
{
sLog.outDebug( "WORLD: SendTrainerList - Training spells not found for creature (GUID: %u Entry: %u)",
GUID_LOPART(guid), unit->GetEntry());
return;
}
WorldPacket data( SMSG_TRAINER_LIST, 8+4+4+trainer_spells->spellList.size()*38 + strTitle.size()+1);
data << guid;
data << uint32(trainer_spells->trainerType);
size_t count_pos = data.wpos();
data << uint32(trainer_spells->spellList.size());
// reputation discount
float fDiscountMod = _player->GetReputationPriceDiscount(unit);
uint32 count = 0;
for(TrainerSpellList::const_iterator itr = trainer_spells->spellList.begin(); itr != trainer_spells->spellList.end(); ++itr)
{
TrainerSpell const* tSpell = *itr;
if(!_player->IsSpellFitByClassAndRace(tSpell->learned_spell))
continue;
++count;
bool primary_prof_first_rank = spellmgr.IsPrimaryProfessionFirstRankSpell(tSpell->learned_spell);
SpellChainNode const* chain_node = spellmgr.GetSpellChainNode(tSpell->learned_spell);
data << uint32(tSpell->spell); // learned spell (or cast-spell in profession case)
data << uint8(_player->GetTrainerSpellState(tSpell));
data << uint32(floor(tSpell->spellcost * fDiscountMod));
data << uint32(primary_prof_first_rank ? 1 : 0); // primary prof. learn confirmation dialog
data << uint32(primary_prof_first_rank ? 1 : 0); // must be equal prev. field to have learn button in enabled state
data << uint8(tSpell->reqlevel);
data << uint32(tSpell->reqskill);
data << uint32(tSpell->reqskillvalue);
data << uint32(chain_node ? (chain_node->prev ? chain_node->prev : chain_node->req) : 0);
data << uint32(chain_node && chain_node->prev ? chain_node->req : 0);
data << uint32(0);
}
data << strTitle;
data.put<uint32>(count_pos,count);
SendPacket( &data );
}
void WorldSession::SendTrainerList (uint64 guid, const std::string& strTitle)
{
sLog->outDebug(LOG_FILTER_NETWORKIO, "WORLD: SendTrainerList");
Creature *unit = GetPlayer()->GetNPCIfCanInteractWith(guid, UNIT_NPC_FLAG_TRAINER);
if (!unit)
{
sLog->outDebug(LOG_FILTER_NETWORKIO, "WORLD: SendTrainerList - Unit (GUID: %u) not found or you can not interact with him.", uint32(GUID_LOPART(guid)));
return;
}
// remove fake death
if (GetPlayer()->HasUnitState(UNIT_STAT_DIED))
GetPlayer()->RemoveAurasByType(SPELL_AURA_FEIGN_DEATH);
// trainer list loaded at check;
if (!unit->isCanTrainingOf(_player, true))
return;
CreatureInfo const *ci = unit->GetCreatureInfo();
if (!ci)
{
sLog->outDebug(LOG_FILTER_NETWORKIO, "WORLD: SendTrainerList - (GUID: %u) NO CREATUREINFO!", GUID_LOPART(guid));
return;
}
TrainerSpellData const* trainer_spells = unit->GetTrainerSpells();
if (!trainer_spells)
{
sLog->outDebug(LOG_FILTER_NETWORKIO, "WORLD: SendTrainerList - Training spells not found for creature (GUID: %u Entry: %u)", GUID_LOPART(guid), unit->GetEntry());
return;
}
WorldPacket data(SMSG_TRAINER_LIST, 8 + 4 + 4 + trainer_spells->spellList.size() * 38 + strTitle.size() + 1);
data << guid;
data << uint32(trainer_spells->trainerType);
data << uint32(1);
size_t count_pos = data.wpos();
data << uint32(trainer_spells->spellList.size());
// reputation discount
float fDiscountMod = _player->GetReputationPriceDiscount(unit);
uint32 count = 0;
for (TrainerSpellMap::const_iterator itr = trainer_spells->spellList.begin(); itr != trainer_spells->spellList.end(); ++itr)
{
TrainerSpell const* tSpell = &itr->second;
TrainerSpellState state = _player->GetTrainerSpellState(tSpell);
data << uint32(tSpell->spell); // learned spell (or cast-spell in profession case)
data << uint8(state);
data << uint32(floor(tSpell->spellCost * fDiscountMod));
data << uint8(tSpell->reqLevel);
data << uint32(tSpell->reqSkill);
data << uint32(tSpell->reqSkillValue);
data << uint32(0);
data << uint32(0);
data << uint32(0);
data << uint32(0);
++count;
}
data << strTitle;
data.put<uint32>(count_pos, count);
SendPacket(&data);
}
void WorldSession::HandleGossipHelloOpcode( WorldPacket & recv_data )
{
CHECK_INWORLD_RETURN;
uint64 guid;
list<QuestRelation *>::iterator it;
std::set<uint32> ql;
recv_data >> guid;
Creature* TalkingWith = _player->GetMapMgr()->GetCreature(GET_LOWGUID_PART(guid));
if(!TalkingWith)
return;
//stop when talked to for 3 min
if(TalkingWith->GetAIInterface())
TalkingWith->GetAIInterface()->StopMovement(180000);
// unstealth meh
if( _player->InStealth() )
_player->RemoveAllAurasOfType( SPELL_AURA_MOD_STEALTH );
// reputation
_player->Reputation_OnTalk(TalkingWith->m_factionDBC);
DEBUG_LOG( "WORLD"," Received CMSG_GOSSIP_HELLO from %u",GUID_LOPART(guid) );
GossipScript * Script = TalkingWith->GetCreatureInfo() ? TalkingWith->GetCreatureInfo()->gossip_script : NULL;
if(!Script)
return;
if (TalkingWith->isQuestGiver() && TalkingWith->HasQuests())
{
WorldPacket data;
data.SetOpcode(SMSG_GOSSIP_MESSAGE);
Script->GossipHello(TalkingWith, _player, false);
if(!_player->CurrentGossipMenu)
return;
_player->CurrentGossipMenu->BuildPacket(data);
uint32 count=0;//sQuestMgr.ActiveQuestsCount(TalkingWith, GetPlayer());
size_t pos=data.wpos();
data << uint32(count);
for (it = TalkingWith->QuestsBegin(); it != TalkingWith->QuestsEnd(); ++it)
{
uint32 status = sQuestMgr.CalcQuestStatus(TalkingWith, GetPlayer(), *it);
if (status >= QMGR_QUEST_CHAT)
{
if (!ql.count((*it)->qst->id) )
{
ql.insert((*it)->qst->id);
count++;
data << (*it)->qst->id;
switch(status)
{
case QMGR_QUEST_NOT_FINISHED:
data << uint32(4) << uint32(0);
break;
case QMGR_QUEST_FINISHED:
data << uint32(4) << uint32(1);
break;
case QMGR_QUEST_CHAT:
data << QMGR_QUEST_AVAILABLE << uint32(0);
break;
default:
data << status << uint32(0);
break;
}
data << (*it)->qst->title;
}
}
}
data.wpos(pos);
data << count;
SendPacket(&data);
DEBUG_LOG( "WORLD"," Sent SMSG_GOSSIP_MESSAGE" );
}
else
{
Script->GossipHello(TalkingWith, _player, true);
}
}
void WorldSession::SendTrainerList(ObjectGuid guid, const std::string& strTitle)
{
DEBUG_LOG("WORLD: SendTrainerList");
Creature* unit = GetPlayer()->GetNPCIfCanInteractWith(guid, UNIT_NPC_FLAG_TRAINER);
if (!unit)
{
DEBUG_LOG("WORLD: SendTrainerList - %s not found or you can't interact with him.", guid.GetString().c_str());
return;
}
// remove fake death
if (GetPlayer()->hasUnitState(UNIT_STAT_DIED))
GetPlayer()->RemoveSpellsCausingAura(SPELL_AURA_FEIGN_DEATH);
// trainer list loaded at check;
if (!unit->IsTrainerOf(_player, true))
return;
CreatureInfo const* ci = unit->GetCreatureInfo();
if (!ci)
return;
TrainerSpellData const* cSpells = unit->GetTrainerSpells();
TrainerSpellData const* tSpells = unit->GetTrainerTemplateSpells();
if (!cSpells && !tSpells)
{
DEBUG_LOG("WORLD: SendTrainerList - Training spells not found for %s", guid.GetString().c_str());
return;
}
uint32 maxcount = (cSpells ? cSpells->spellList.size() : 0) + (tSpells ? tSpells->spellList.size() : 0);
uint32 trainer_type = cSpells && cSpells->trainerType ? cSpells->trainerType : (tSpells ? tSpells->trainerType : 0);
WorldPacket data(SMSG_TRAINER_LIST, 8 + 4 + 4 + maxcount * 38 + strTitle.size() + 1);
data << ObjectGuid(guid);
data << uint32(trainer_type);
size_t count_pos = data.wpos();
data << uint32(maxcount);
// reputation discount
float fDiscountMod = _player->GetReputationPriceDiscount(unit);
bool can_learn_primary_prof = GetPlayer()->GetFreePrimaryProfessionPoints() > 0;
uint32 count = 0;
if (cSpells)
{
for (TrainerSpellMap::const_iterator itr = cSpells->spellList.begin(); itr != cSpells->spellList.end(); ++itr)
{
TrainerSpell const* tSpell = &itr->second;
uint32 reqLevel = 0;
if (!_player->IsSpellFitByClassAndRace(tSpell->spell, &reqLevel))
continue;
reqLevel = tSpell->isProvidedReqLevel ? tSpell->reqLevel : std::max(reqLevel, tSpell->reqLevel);
TrainerSpellState state = _player->GetTrainerSpellState(tSpell, reqLevel);
SendTrainerSpellHelper(data, tSpell, state, fDiscountMod, can_learn_primary_prof, reqLevel);
++count;
}
}
if (tSpells)
{
for (TrainerSpellMap::const_iterator itr = tSpells->spellList.begin(); itr != tSpells->spellList.end(); ++itr)
{
TrainerSpell const* tSpell = &itr->second;
uint32 reqLevel = 0;
if (!_player->IsSpellFitByClassAndRace(tSpell->spell, &reqLevel))
continue;
reqLevel = tSpell->isProvidedReqLevel ? tSpell->reqLevel : std::max(reqLevel, tSpell->reqLevel);
TrainerSpellState state = _player->GetTrainerSpellState(tSpell, reqLevel);
SendTrainerSpellHelper(data, tSpell, state, fDiscountMod, can_learn_primary_prof, reqLevel);
++count;
}
}
data << strTitle;
data.put<uint32>(count_pos, count);
SendPacket(&data);
}
void PlayerbotMgr::HandleMasterIncomingPacket(const WorldPacket& packet)
{
switch (packet.GetOpcode())
{
case CMSG_ACTIVATETAXI:
{
WorldPacket p(packet);
p.rpos(0); // reset reader
ObjectGuid guid;
std::vector<uint32> nodes;
nodes.resize(2);
uint8 delay = 9;
p >> guid >> nodes[0] >> nodes[1];
DEBUG_LOG("[PlayerbotMgr]: HandleMasterIncomingPacket - Received CMSG_ACTIVATETAXI from %d to %d", nodes[0], nodes[1]);
for (PlayerBotMap::const_iterator it = GetPlayerBotsBegin(); it != GetPlayerBotsEnd(); ++it)
{
delay = delay + 3;
Player* const bot = it->second;
if (!bot)
return;
Group* group = bot->GetGroup();
if (!group)
continue;
Unit* target = ObjectAccessor::GetUnit(*bot, guid);
bot->GetPlayerbotAI()->SetIgnoreUpdateTime(delay);
bot->GetMotionMaster()->Clear(true);
bot->GetMotionMaster()->MoveFollow(target, INTERACTION_DISTANCE, bot->GetOrientation());
bot->GetPlayerbotAI()->GetTaxi(guid, nodes);
}
return;
}
case CMSG_ACTIVATETAXIEXPRESS:
{
WorldPacket p(packet);
p.rpos(0); // reset reader
ObjectGuid guid;
uint32 node_count;
uint8 delay = 9;
p >> guid;
p.read_skip<uint32>();
p >> node_count;
std::vector<uint32> nodes;
for (uint32 i = 0; i < node_count; ++i)
{
uint32 node;
p >> node;
nodes.push_back(node);
}
if (nodes.empty())
return;
DEBUG_LOG("[PlayerbotMgr]: HandleMasterIncomingPacket - Received CMSG_ACTIVATETAXIEXPRESS from %d to %d", nodes.front(), nodes.back());
for (PlayerBotMap::const_iterator it = GetPlayerBotsBegin(); it != GetPlayerBotsEnd(); ++it)
{
delay = delay + 3;
Player* const bot = it->second;
if (!bot)
return;
Group* group = bot->GetGroup();
if (!group)
continue;
Unit* target = ObjectAccessor::GetUnit(*bot, guid);
bot->GetPlayerbotAI()->SetIgnoreUpdateTime(delay);
bot->GetMotionMaster()->Clear(true);
bot->GetMotionMaster()->MoveFollow(target, INTERACTION_DISTANCE, bot->GetOrientation());
bot->GetPlayerbotAI()->GetTaxi(guid, nodes);
}
return;
}
// if master is logging out, log out all bots
case CMSG_LOGOUT_REQUEST:
{
LogoutAllBots();
return;
}
// If master inspects one of his bots, give the master useful info in chat window
// such as inventory that can be equipped
case CMSG_INSPECT:
{
WorldPacket p(packet);
p.rpos(0); // reset reader
ObjectGuid guid;
p >> guid;
Player* const bot = GetPlayerBot(guid);
if (bot) bot->GetPlayerbotAI()->SendNotEquipList(*bot);
return;
}
// handle emotes from the master
//case CMSG_EMOTE:
case CMSG_TEXT_EMOTE:
{
WorldPacket p(packet);
p.rpos(0); // reset reader
uint32 emoteNum;
p >> emoteNum;
/* std::ostringstream out;
out << "emote is: " << emoteNum;
ChatHandler ch(m_master);
ch.SendSysMessage(out.str().c_str()); */
switch (emoteNum)
{
case TEXTEMOTE_BOW:
{
// Buff anyone who bows before me. Useful for players not in bot's group
// How do I get correct target???
//Player* const pPlayer = GetPlayerBot(m_master->GetSelection());
//if (pPlayer->GetPlayerbotAI()->GetClassAI())
// pPlayer->GetPlayerbotAI()->GetClassAI()->BuffPlayer(pPlayer);
return;
}
/*
case TEXTEMOTE_BONK:
{
Player* const pPlayer = GetPlayerBot(m_master->GetSelection());
if (!pPlayer || !pPlayer->GetPlayerbotAI())
return;
PlayerbotAI* const pBot = pPlayer->GetPlayerbotAI();
ChatHandler ch(m_master);
{
std::ostringstream out;
out << "CurrentTime: " << CurrentTime()
<< " m_ignoreAIUpdatesUntilTime: " << pBot->m_ignoreAIUpdatesUntilTime;
ch.SendSysMessage(out.str().c_str());
}
{
std::ostringstream out;
out << "m_TimeDoneEating: " << pBot->m_TimeDoneEating
<< " m_TimeDoneDrinking: " << pBot->m_TimeDoneDrinking;
ch.SendSysMessage(out.str().c_str());
}
{
std::ostringstream out;
out << "m_CurrentlyCastingSpellId: " << pBot->m_CurrentlyCastingSpellId;
ch.SendSysMessage(out.str().c_str());
}
{
std::ostringstream out;
out << "IsBeingTeleported() " << pBot->GetPlayer()->IsBeingTeleported();
ch.SendSysMessage(out.str().c_str());
}
{
std::ostringstream out;
bool tradeActive = (pBot->GetPlayer()->GetTrader()) ? true : false;
out << "tradeActive: " << tradeActive;
ch.SendSysMessage(out.str().c_str());
}
{
std::ostringstream out;
out << "IsCharmed() " << pBot->getPlayer()->isCharmed();
ch.SendSysMessage(out.str().c_str());
}
return;
}
*/
case TEXTEMOTE_EAT:
case TEXTEMOTE_DRINK:
return;
// emote to attack selected target
case TEXTEMOTE_POINT:
{
ObjectGuid attackOnGuid = m_master->GetSelectionGuid();
if (!attackOnGuid)
return;
Unit* thingToAttack = ObjectAccessor::GetUnit(*m_master, attackOnGuid);
if (!thingToAttack) return;
Player* bot = 0;
for (PlayerBotMap::iterator itr = m_playerBots.begin(); itr != m_playerBots.end(); ++itr)
{
bot = itr->second;
if (!bot->IsFriendlyTo(thingToAttack))
{
if (!bot->IsWithinLOSInMap(thingToAttack))
bot->GetPlayerbotAI()->DoTeleport(*m_master);
if (bot->IsWithinLOSInMap(thingToAttack))
bot->GetPlayerbotAI()->Attack(thingToAttack);
}
}
return;
}
// emote to stay
case TEXTEMOTE_STAND:
{
Player* const bot = GetPlayerBot(m_master->GetSelectionGuid());
if (bot)
bot->GetPlayerbotAI()->SetMovementOrder(PlayerbotAI::MOVEMENT_STAY);
else
for (PlayerBotMap::const_iterator it = GetPlayerBotsBegin(); it != GetPlayerBotsEnd(); ++it)
{
Player* const bot = it->second;
bot->GetPlayerbotAI()->SetMovementOrder(PlayerbotAI::MOVEMENT_STAY);
}
return;
}
// 324 is the followme emote (not defined in enum)
// if master has bot selected then only bot follows, else all bots follow
case 324:
case TEXTEMOTE_WAVE:
{
Player* const bot = GetPlayerBot(m_master->GetSelectionGuid());
if (bot)
bot->GetPlayerbotAI()->SetMovementOrder(PlayerbotAI::MOVEMENT_FOLLOW, m_master);
else
for (PlayerBotMap::const_iterator it = GetPlayerBotsBegin(); it != GetPlayerBotsEnd(); ++it)
{
Player* const bot = it->second;
bot->GetPlayerbotAI()->SetMovementOrder(PlayerbotAI::MOVEMENT_FOLLOW, m_master);
}
return;
}
}
return;
} /* EMOTE ends here */
case CMSG_GAMEOBJ_USE: // Used by bots to turn in quest to GameObjects when also used by master
{
DEBUG_LOG("PlayerbotMgr: CMSG_GAMEOBJ_USE");
WorldPacket p(packet);
p.rpos(0); // reset reader
ObjectGuid objGUID;
p >> objGUID;
for (PlayerBotMap::const_iterator it = GetPlayerBotsBegin(); it != GetPlayerBotsEnd(); ++it)
{
Player* const bot = it->second;
// If player and bot are on different maps: then player was teleported by GameObject
// let's return and let playerbot summon do its job by teleporting bots
if (bot->GetMap() != m_master->GetMap())
return;
GameObject* obj = m_master->GetMap()->GetGameObject(objGUID);
if (!obj)
return;
// add other go types here, i.e.:
// GAMEOBJECT_TYPE_CHEST - loot quest items of chest
if (obj->GetGoType() == GAMEOBJECT_TYPE_QUESTGIVER)
{
bot->GetPlayerbotAI()->TurnInQuests(obj);
// auto accept every available quest this NPC has
bot->PrepareQuestMenu(objGUID);
QuestMenu& questMenu = bot->PlayerTalkClass->GetQuestMenu();
for (uint32 iI = 0; iI < questMenu.MenuItemCount(); ++iI)
{
QuestMenuItem const& qItem = questMenu.GetItem(iI);
uint32 questID = qItem.m_qId;
if (!bot->GetPlayerbotAI()->AddQuest(questID, obj))
DEBUG_LOG("Couldn't take quest");
}
}
}
}
break;
case CMSG_QUESTGIVER_HELLO:
{
DEBUG_LOG("PlayerbotMgr: CMSG_QUESTGIVER_HELLO");
WorldPacket p(packet);
p.rpos(0); // reset reader
ObjectGuid npcGUID;
p >> npcGUID;
WorldObject* pNpc = m_master->GetMap()->GetWorldObject(npcGUID);
if (!pNpc)
return;
// for all master's bots
for (PlayerBotMap::const_iterator it = GetPlayerBotsBegin(); it != GetPlayerBotsEnd(); ++it)
{
Player* const bot = it->second;
bot->GetPlayerbotAI()->TurnInQuests(pNpc);
}
return;
}
// if master accepts a quest, bots should also try to accept quest
case CMSG_QUESTGIVER_ACCEPT_QUEST:
{
WorldPacket p(packet);
p.rpos(0); // reset reader
ObjectGuid guid;
uint32 quest;
p >> guid >> quest;
DEBUG_LOG("[PlayerbotMgr]: HandleMasterIncomingPacket - Received CMSG_QUESTGIVER_ACCEPT_QUEST npc = %s, quest = %u", guid.GetString().c_str(), quest);
Quest const* qInfo = sObjectMgr.GetQuestTemplate(quest);
if (qInfo)
for (PlayerBotMap::const_iterator it = GetPlayerBotsBegin(); it != GetPlayerBotsEnd(); ++it)
{
Player* const bot = it->second;
if (bot->GetQuestStatus(quest) == QUEST_STATUS_COMPLETE)
bot->GetPlayerbotAI()->TellMaster("I already completed that quest.");
else if (!bot->CanTakeQuest(qInfo, false))
{
if (!bot->SatisfyQuestStatus(qInfo, false))
bot->GetPlayerbotAI()->TellMaster("I already have that quest.");
else
bot->GetPlayerbotAI()->TellMaster("I can't take that quest.");
}
else if (!bot->SatisfyQuestLog(false))
bot->GetPlayerbotAI()->TellMaster("My quest log is full.");
else if (!bot->CanAddQuest(qInfo, false))
bot->GetPlayerbotAI()->TellMaster("I can't take that quest because it requires that I take items, but my bags are full!");
else
{
p.rpos(0); // reset reader
bot->GetSession()->HandleQuestgiverAcceptQuestOpcode(p);
bot->GetPlayerbotAI()->TellMaster("Got the quest.");
// build needed items if quest contains any
for (int i = 0; i < QUEST_ITEM_OBJECTIVES_COUNT; i++)
if (qInfo->ReqItemCount[i] > 0)
{
bot->GetPlayerbotAI()->SetQuestNeedItems();
break;
}
// build needed creatures if quest contains any
for (int i = 0; i < QUEST_OBJECTIVES_COUNT; i++)
if (qInfo->ReqCreatureOrGOCount[i] > 0)
{
bot->GetPlayerbotAI()->SetQuestNeedCreatures();
break;
}
}
}
return;
}
case CMSG_AREATRIGGER:
{
WorldPacket p(packet);
for (PlayerBotMap::const_iterator it = GetPlayerBotsBegin(); it != GetPlayerBotsEnd(); ++it)
{
Player* const bot = it->second;
p.rpos(0); // reset reader
bot->GetSession()->HandleAreaTriggerOpcode(p);
}
return;
}
case CMSG_QUESTGIVER_COMPLETE_QUEST:
{
WorldPacket p(packet);
p.rpos(0); // reset reader
uint32 quest;
ObjectGuid npcGUID;
p >> npcGUID >> quest;
DEBUG_LOG("[PlayerbotMgr]: HandleMasterIncomingPacket - Received CMSG_QUESTGIVER_COMPLETE_QUEST npc = %s, quest = %u", npcGUID.GetString().c_str(), quest);
WorldObject* pNpc = m_master->GetMap()->GetWorldObject(npcGUID);
if (!pNpc)
return;
// for all master's bots
for (PlayerBotMap::const_iterator it = GetPlayerBotsBegin(); it != GetPlayerBotsEnd(); ++it)
{
Player* const bot = it->second;
bot->GetPlayerbotAI()->TurnInQuests(pNpc);
}
return;
}
case CMSG_LOOT_ROLL:
{
WorldPacket p(packet); //WorldPacket packet for CMSG_LOOT_ROLL, (8+4+1)
ObjectGuid Guid;
uint32 itemSlot;
uint8 rollType;
p.rpos(0); //reset packet pointer
p >> Guid; //guid of the lootable target
p >> itemSlot; //loot index
p >> rollType; //need,greed or pass on roll
for (PlayerBotMap::const_iterator it = GetPlayerBotsBegin(); it != GetPlayerBotsEnd(); ++it)
{
uint32 choice = 0;
Player* const bot = it->second;
if (!bot)
return;
Group* group = bot->GetGroup();
if (!group)
return;
// check that the bot did not already vote
if (rollType >= ROLL_NOT_EMITED_YET)
return;
Loot* loot = sLootMgr.GetLoot(bot, Guid);
if (!loot)
{
sLog.outError("LootMgr::PlayerVote> Error cannot get loot object info!");
return;
}
LootItem* lootItem = loot->GetLootItemInSlot(itemSlot);
ItemPrototype const* pProto = lootItem->itemProto;
if (!pProto)
return;
if (bot->GetPlayerbotAI()->CanStore())
{
if (bot->CanUseItem(pProto) == EQUIP_ERR_OK && bot->GetPlayerbotAI()->IsItemUseful(lootItem->itemId))
choice = 1; // Need
else
choice = 2; // Greed
}
else
choice = 0; // Pass
sLootMgr.PlayerVote(bot, Guid, itemSlot, RollVote(choice));
}
return;
}
// Handle GOSSIP activate actions, prior to GOSSIP select menu actions
case CMSG_GOSSIP_HELLO:
{
DEBUG_LOG("[PlayerbotMgr]: HandleMasterIncomingPacket - Received CMSG_GOSSIP_HELLO");
WorldPacket p(packet); //WorldPacket packet for CMSG_GOSSIP_HELLO, (8)
ObjectGuid guid;
p.rpos(0); //reset packet pointer
p >> guid;
for (PlayerBotMap::const_iterator it = GetPlayerBotsBegin(); it != GetPlayerBotsEnd(); ++it)
{
Player* const bot = it->second;
if (!bot)
return;
Creature* pCreature = bot->GetNPCIfCanInteractWith(guid, UNIT_NPC_FLAG_NONE);
if (!pCreature)
{
DEBUG_LOG("[PlayerbotMgr]: HandleMasterIncomingPacket - Received CMSG_GOSSIP_HELLO %s not found or you can't interact with him.", guid.GetString().c_str());
return;
}
GossipMenuItemsMapBounds pMenuItemBounds = sObjectMgr.GetGossipMenuItemsMapBounds(pCreature->GetCreatureInfo()->GossipMenuId);
for (GossipMenuItemsMap::const_iterator itr = pMenuItemBounds.first; itr != pMenuItemBounds.second; ++itr)
{
uint32 npcflags = pCreature->GetUInt32Value(UNIT_NPC_FLAGS);
if (!(itr->second.npc_option_npcflag & npcflags))
continue;
switch (itr->second.option_id)
{
case GOSSIP_OPTION_TAXIVENDOR:
{
// bot->GetPlayerbotAI()->TellMaster("PlayerbotMgr:GOSSIP_OPTION_TAXIVENDOR");
bot->GetSession()->SendLearnNewTaxiNode(pCreature);
break;
}
case GOSSIP_OPTION_QUESTGIVER:
{
// bot->GetPlayerbotAI()->TellMaster("PlayerbotMgr:GOSSIP_OPTION_QUESTGIVER");
bot->GetPlayerbotAI()->TurnInQuests(pCreature);
break;
}
case GOSSIP_OPTION_VENDOR:
{
// bot->GetPlayerbotAI()->TellMaster("PlayerbotMgr:GOSSIP_OPTION_VENDOR");
if (!botConfig.GetBoolDefault("PlayerbotAI.SellGarbage", true))
return;
bot->GetPlayerbotAI()->SellGarbage();
break;
}
case GOSSIP_OPTION_STABLEPET:
{
// bot->GetPlayerbotAI()->TellMaster("PlayerbotMgr:GOSSIP_OPTION_STABLEPET");
break;
}
case GOSSIP_OPTION_AUCTIONEER:
{
// bot->GetPlayerbotAI()->TellMaster("PlayerbotMgr:GOSSIP_OPTION_AUCTIONEER");
break;
}
case GOSSIP_OPTION_BANKER:
{
// bot->GetPlayerbotAI()->TellMaster("PlayerbotMgr:GOSSIP_OPTION_BANKER");
break;
}
case GOSSIP_OPTION_INNKEEPER:
{
// bot->GetPlayerbotAI()->TellMaster("PlayerbotMgr:GOSSIP_OPTION_INNKEEPER");
break;
}
}
}
}
return;
}
case CMSG_SPIRIT_HEALER_ACTIVATE:
{
// DEBUG_LOG ("[PlayerbotMgr]: HandleMasterIncomingPacket - Received CMSG_SPIRIT_HEALER_ACTIVATE SpiritHealer is resurrecting the Player %s",m_master->GetName());
for (PlayerBotMap::iterator itr = m_playerBots.begin(); itr != m_playerBots.end(); ++itr)
{
Player* const bot = itr->second;
Group* grp = bot->GetGroup();
if (grp)
grp->RemoveMember(bot->GetObjectGuid(), 1);
}
return;
}
case CMSG_LIST_INVENTORY:
{
if (!botConfig.GetBoolDefault("PlayerbotAI.SellGarbage", true))
return;
WorldPacket p(packet);
p.rpos(0); // reset reader
ObjectGuid npcGUID;
p >> npcGUID;
Object* const pNpc = (WorldObject*) m_master->GetObjectByTypeMask(npcGUID, TYPEMASK_CREATURE_OR_GAMEOBJECT);
if (!pNpc)
return;
// for all master's bots
for (PlayerBotMap::const_iterator it = GetPlayerBotsBegin(); it != GetPlayerBotsEnd(); ++it)
{
Player* const bot = it->second;
if (!bot->IsInMap(static_cast<WorldObject*>(pNpc)))
{
bot->GetPlayerbotAI()->TellMaster("I'm too far away to sell items!");
continue;
}
else
bot->GetPlayerbotAI()->SellGarbage();
}
return;
}
/*
case CMSG_NAME_QUERY:
case MSG_MOVE_START_FORWARD:
case MSG_MOVE_STOP:
case MSG_MOVE_SET_FACING:
case MSG_MOVE_START_STRAFE_LEFT:
case MSG_MOVE_START_STRAFE_RIGHT:
case MSG_MOVE_STOP_STRAFE:
case MSG_MOVE_START_BACKWARD:
case MSG_MOVE_HEARTBEAT:
case CMSG_STANDSTATECHANGE:
case CMSG_QUERY_TIME:
case CMSG_CREATURE_QUERY:
case CMSG_GAMEOBJECT_QUERY:
case MSG_MOVE_JUMP:
case MSG_MOVE_FALL_LAND:
return;*/
default:
{
/*const char* oc = LookupOpcodeName(packet.GetOpcode());
// ChatHandler ch(m_master);
// ch.SendSysMessage(oc);
std::ostringstream out;
out << "masterin: " << oc;
sLog.outError(out.str().c_str()); */
}
}
}
bool ChatHandler::HandleNPCFlagCommand(const char* args, WorldSession* m_session)
{
if(!*args)
return false;
uint32 npcFlags = (uint32) atoi((char*)args);
uint64 guid = m_session->GetPlayer()->GetSelection();
if(guid == 0)
{
SystemMessage(m_session, "No selection.");
return true;
}
Creature* pCreature = m_session->GetPlayer()->GetMapMgr()->GetCreature(GET_LOWGUID_PART(guid));
if(!pCreature)
{
SystemMessage(m_session, "You should select a creature.");
return true;
}
pCreature->SetUInt32Value(UNIT_NPC_FLAGS , npcFlags);
WorldDatabase.Execute("UPDATE creature_proto SET npcflags = '%lu' WHERE entry = %lu", npcFlags, pCreature->GetProto()->Id);
SystemMessage(m_session, "Value saved, you may need to rejoin or clean your client cache.");
sGMLog.writefromsession(m_session, "changed npc flags of creature %u [%s] to %u", pCreature->GetEntry(), pCreature->GetCreatureInfo()->Name, npcFlags);
return true;
}
void WorldSession::HandleTextEmoteOpcode(WorldPacket& recv_data)
{
CHECK_INWORLD_RETURN
CHECK_PACKET_SIZE(recv_data, 16);
if (!_player->isAlive())
return;
uint64 guid;
uint32
text_emote,
unk,
namelen = 1;
const char* name = " ";
recv_data >> text_emote;
recv_data >> unk;
recv_data >> guid;
if (m_muted && m_muted >= (uint32)UNIXTIME)
{
SystemMessage("Your voice is currently muted by a moderator.");
return;
}
if (!GetPermissionCount() && sWorld.flood_lines)
{
/* flood detection, wheeee! */
if (UNIXTIME >= floodTime)
{
floodLines = 0;
floodTime = UNIXTIME + sWorld.flood_seconds;
}
if ((++floodLines) > sWorld.flood_lines)
{
return;
}
}
Unit* pUnit = _player->GetMapMgr()->GetUnit(guid);
if (pUnit)
{
if (pUnit->IsPlayer())
{
name = static_cast< Player* >(pUnit)->GetName();
namelen = (uint32)strlen(name) + 1;
}
else if (pUnit->IsPet())
{
name = static_cast< Pet* >(pUnit)->GetName().c_str();
namelen = (uint32)strlen(name) + 1;
}
else
{
Creature* p = static_cast< Creature* >(pUnit);
name = p->GetCreatureInfo()->Name;
namelen = (uint32)strlen(name) + 1;
}
}
emoteentry* em = dbcEmoteEntry.LookupEntryForced(text_emote);
if (em)
{
WorldPacket data(SMSG_EMOTE, 28 + namelen);
sHookInterface.OnEmote(_player, (EmoteType)em->textid, pUnit);
if (pUnit)
CALL_SCRIPT_EVENT(pUnit, OnEmote)(_player, (EmoteType)em->textid);
switch (em->textid)
{
case EMOTE_STATE_SLEEP:
case EMOTE_STATE_SIT:
case EMOTE_STATE_KNEEL:
case EMOTE_STATE_DANCE:
{
_player->SetEmoteState(em->textid);
}
break;
}
data << (uint32)em->textid;
data << (uint64)GetPlayer()->GetGUID();
GetPlayer()->SendMessageToSet(&data, true); //If player receives his own emote, his animation stops.
data.Initialize(SMSG_TEXT_EMOTE);
data << (uint64)GetPlayer()->GetGUID();
data << (uint32)text_emote;
data << unk;
data << (uint32)namelen;
if (namelen > 1) data.append(name, namelen);
else data << (uint8)0x00;
GetPlayer()->SendMessageToSet(&data, true);
#ifdef ENABLE_ACHIEVEMENTS
_player->GetAchievementMgr().UpdateAchievementCriteria(ACHIEVEMENT_CRITERIA_TYPE_DO_EMOTE, text_emote, 0, 0);
#endif
sQuestMgr.OnPlayerEmote(_player, text_emote, guid);
}
}
void PlayerbotMgr::HandleMasterIncomingPacket(const WorldPacket& packet)
{
switch (packet.GetOpcode())
{
case CMSG_OFFER_PETITION:
{
WorldPacket p(packet);
p.rpos(0); // reset reader
ObjectGuid petitionGuid;
ObjectGuid playerGuid;
uint32 junk;
p >> junk; // this is not petition type!
p >> petitionGuid; // petition guid
p >> playerGuid; // player guid
Player* player = ObjectAccessor::FindPlayer(playerGuid);
if (!player)
return;
uint32 petitionLowGuid = petitionGuid.GetCounter();
QueryResult *result = CharacterDatabase.PQuery("SELECT * FROM petition_sign WHERE playerguid = '%u' AND petitionguid = '%u'", player->GetGUIDLow(), petitionLowGuid);
if(result)
{
ChatHandler(m_master).PSendSysMessage("%s has already signed the petition",player->GetName());
delete result;
return;
}
CharacterDatabase.PExecute("INSERT INTO petition_sign (ownerguid,petitionguid, playerguid, player_account) VALUES ('%u', '%u', '%u','%u')",
GetMaster()->GetGUIDLow(), petitionLowGuid, player->GetGUIDLow(), GetMaster()->GetSession()->GetAccountId());
p.Initialize(SMSG_PETITION_SIGN_RESULTS, (8+8+4));
p << ObjectGuid(petitionGuid);
p << ObjectGuid(playerGuid);
p << uint32(PETITION_SIGN_OK);
// close at signer side
GetMaster()->GetSession()->SendPacket(&p);
return;
}
case CMSG_ACTIVATETAXI:
{
WorldPacket p(packet);
p.rpos(0); // reset reader
ObjectGuid guid;
std::vector<uint32> nodes;
nodes.resize(2);
uint8 delay = 9;
p >> guid >> nodes[0] >> nodes[1];
// DEBUG_LOG ("[PlayerbotMgr]: HandleMasterIncomingPacket - Received CMSG_ACTIVATETAXI from %d to %d", nodes[0], nodes[1]);
for (PlayerBotMap::const_iterator it = GetPlayerBotsBegin(); it != GetPlayerBotsEnd(); ++it)
{
delay = delay + 3;
Player* const bot = it->second;
if (!bot)
return;
Group* group = bot->GetGroup();
if (!group)
continue;
Unit *target = ObjectAccessor::GetUnit(*bot, guid);
bot->GetPlayerbotAI()->SetIgnoreUpdateTime(delay);
bot->GetMotionMaster()->Clear(true);
bot->GetMotionMaster()->MoveFollow(target, INTERACTION_DISTANCE, bot->GetOrientation());
bot->GetPlayerbotAI()->GetTaxi(guid, nodes);
}
return;
}
case CMSG_ACTIVATETAXIEXPRESS:
{
WorldPacket p(packet);
p.rpos(0); // reset reader
ObjectGuid guid;
uint32 node_count;
uint8 delay = 9;
p >> guid;
p.read_skip<uint32>();
p >> node_count;
std::vector<uint32> nodes;
for (uint32 i = 0; i < node_count; ++i)
{
uint32 node;
p >> node;
nodes.push_back(node);
}
if (nodes.empty())
return;
// DEBUG_LOG ("[PlayerbotMgr]: HandleMasterIncomingPacket - Received CMSG_ACTIVATETAXIEXPRESS from %d to %d", nodes.front(), nodes.back());
for (PlayerBotMap::const_iterator it = GetPlayerBotsBegin(); it != GetPlayerBotsEnd(); ++it)
{
delay = delay + 3;
Player* const bot = it->second;
if (!bot)
return;
Group* group = bot->GetGroup();
if (!group)
continue;
Unit *target = ObjectAccessor::GetUnit(*bot, guid);
bot->GetPlayerbotAI()->SetIgnoreUpdateTime(delay);
bot->GetMotionMaster()->Clear(true);
bot->GetMotionMaster()->MoveFollow(target, INTERACTION_DISTANCE, bot->GetOrientation());
bot->GetPlayerbotAI()->GetTaxi(guid, nodes);
}
return;
}
case CMSG_MOVE_SPLINE_DONE:
{
// DEBUG_LOG ("[PlayerbotMgr]: HandleMasterIncomingPacket - Received CMSG_MOVE_SPLINE_DONE");
WorldPacket p(packet);
p.rpos(0); // reset reader
ObjectGuid guid; // used only for proper packet read
MovementInfo movementInfo; // used only for proper packet read
p >> guid.ReadAsPacked();
p >> movementInfo;
p >> Unused<uint32>(); // unk
for (PlayerBotMap::const_iterator it = GetPlayerBotsBegin(); it != GetPlayerBotsEnd(); ++it)
{
Player* const bot = it->second;
if (!bot)
return;
// in taxi flight packet received in 2 case:
// 1) end taxi path in far (multi-node) flight
// 2) switch from one map to other in case multi-map taxi path
// we need process only (1)
uint32 curDest = bot->m_taxi.GetTaxiDestination();
if (!curDest)
return;
TaxiNodesEntry const* curDestNode = sTaxiNodesStore.LookupEntry(curDest);
// far teleport case
if (curDestNode && curDestNode->map_id != bot->GetMapId())
{
if (bot->GetMotionMaster()->GetCurrentMovementGeneratorType() == FLIGHT_MOTION_TYPE)
{
// short preparations to continue flight
FlightPathMovementGenerator* flight = (FlightPathMovementGenerator *) (bot->GetMotionMaster()->top());
flight->Interrupt(*bot); // will reset at map landing
flight->SetCurrentNodeAfterTeleport();
TaxiPathNodeEntry const& node = flight->GetPath()[flight->GetCurrentNode()];
flight->SkipCurrentNode();
bot->TeleportTo(curDestNode->map_id, node.x, node.y, node.z, bot->GetOrientation());
}
return;
}
uint32 destinationnode = bot->m_taxi.NextTaxiDestination();
if (destinationnode > 0) // if more destinations to go
{
// current source node for next destination
uint32 sourcenode = bot->m_taxi.GetTaxiSource();
// Add to taximask middle hubs in taxicheat mode (to prevent having player with disabled taxicheat and not having back flight path)
if (bot->isTaxiCheater())
if (bot->m_taxi.SetTaximaskNode(sourcenode))
{
WorldPacket data(SMSG_NEW_TAXI_PATH, 0);
bot->GetSession()->SendPacket(&data);
}
// DEBUG_LOG ("[PlayerbotMgr]: HandleMasterIncomingPacket - Received CMSG_MOVE_SPLINE_DONE Taxi has to go from %u to %u", sourcenode, destinationnode);
uint32 mountDisplayId = sObjectMgr.GetTaxiMountDisplayId(sourcenode, bot->GetTeam());
uint32 path, cost;
sObjectMgr.GetTaxiPath(sourcenode, destinationnode, path, cost);
if (path && mountDisplayId)
bot->GetSession()->SendDoFlight(mountDisplayId, path, 1); // skip start fly node
else
bot->m_taxi.ClearTaxiDestinations(); // clear problematic path and next
}
else
/* std::ostringstream out;
out << "Destination reached" << bot->GetName();
ChatHandler ch(m_master);
ch.SendSysMessage(out.str().c_str()); */
bot->m_taxi.ClearTaxiDestinations(); // Destination, clear source node
}
return;
}
// if master is logging out, log out all bots
case CMSG_LOGOUT_REQUEST:
{
LogoutAllBots();
return;
}
// If master inspects one of his bots, give the master useful info in chat window
// such as inventory that can be equipped
case CMSG_INSPECT:
{
WorldPacket p(packet);
p.rpos(0); // reset reader
ObjectGuid guid;
p >> guid;
Player* const bot = GetPlayerBot(guid);
if (bot) bot->GetPlayerbotAI()->SendNotEquipList(*bot);
return;
}
// handle emotes from the master
//case CMSG_EMOTE:
case CMSG_TEXT_EMOTE:
{
WorldPacket p(packet);
p.rpos(0); // reset reader
uint32 emoteNum;
p >> emoteNum;
/* std::ostringstream out;
out << "emote is: " << emoteNum;
ChatHandler ch(m_master);
ch.SendSysMessage(out.str().c_str()); */
switch (emoteNum)
{
case TEXTEMOTE_BOW:
{
// Buff anyone who bows before me. Useful for players not in bot's group
// How do I get correct target???
//Player* const pPlayer = GetPlayerBot(m_master->GetSelection());
//if (pPlayer->GetPlayerbotAI()->GetClassAI())
// pPlayer->GetPlayerbotAI()->GetClassAI()->BuffPlayer(pPlayer);
return;
}
/*
case TEXTEMOTE_BONK:
{
Player* const pPlayer = GetPlayerBot(m_master->GetSelection());
if (!pPlayer || !pPlayer->GetPlayerbotAI())
return;
PlayerbotAI* const pBot = pPlayer->GetPlayerbotAI();
ChatHandler ch(m_master);
{
std::ostringstream out;
out << "CurrentTime: " << CurrentTime()
<< " m_ignoreAIUpdatesUntilTime: " << pBot->m_ignoreAIUpdatesUntilTime;
ch.SendSysMessage(out.str().c_str());
}
{
std::ostringstream out;
out << "m_TimeDoneEating: " << pBot->m_TimeDoneEating
<< " m_TimeDoneDrinking: " << pBot->m_TimeDoneDrinking;
ch.SendSysMessage(out.str().c_str());
}
{
std::ostringstream out;
out << "m_CurrentlyCastingSpellId: " << pBot->m_CurrentlyCastingSpellId;
ch.SendSysMessage(out.str().c_str());
}
{
std::ostringstream out;
out << "IsBeingTeleported() " << pBot->GetPlayer()->IsBeingTeleported();
ch.SendSysMessage(out.str().c_str());
}
{
std::ostringstream out;
bool tradeActive = (pBot->GetPlayer()->GetTrader()) ? true : false;
out << "tradeActive: " << tradeActive;
ch.SendSysMessage(out.str().c_str());
}
{
std::ostringstream out;
out << "IsCharmed() " << pBot->getPlayer()->isCharmed();
ch.SendSysMessage(out.str().c_str());
}
return;
}
*/
case TEXTEMOTE_EAT:
case TEXTEMOTE_DRINK:
{
for (PlayerBotMap::const_iterator it = GetPlayerBotsBegin(); it != GetPlayerBotsEnd(); ++it)
{
Player* const bot = it->second;
bot->GetPlayerbotAI()->Feast();
}
return;
}
// emote to attack selected target
case TEXTEMOTE_POINT:
{
ObjectGuid attackOnGuid = m_master->GetSelectionGuid();
if (!attackOnGuid)
return;
Unit* thingToAttack = ObjectAccessor::GetUnit(*m_master, attackOnGuid);
if (!thingToAttack) return;
Player* bot = 0;
for (PlayerBotMap::iterator itr = m_playerBots.begin(); itr != m_playerBots.end(); ++itr)
{
bot = itr->second;
if (!bot->IsFriendlyTo(thingToAttack))
{
if (!bot->IsWithinLOSInMap(thingToAttack))
bot->GetPlayerbotAI()->DoTeleport(*m_master);
if (bot->IsWithinLOSInMap(thingToAttack))
bot->GetPlayerbotAI()->Attack(thingToAttack);
}
}
return;
}
// emote to stay
case TEXTEMOTE_STAND:
{
Player* const bot = GetPlayerBot(m_master->GetSelectionGuid());
if (bot)
bot->GetPlayerbotAI()->SetMovementOrder(PlayerbotAI::MOVEMENT_STAY);
else
for (PlayerBotMap::const_iterator it = GetPlayerBotsBegin(); it != GetPlayerBotsEnd(); ++it)
{
Player* const bot = it->second;
bot->GetPlayerbotAI()->SetMovementOrder(PlayerbotAI::MOVEMENT_STAY);
}
return;
}
// 324 is the followme emote (not defined in enum)
// if master has bot selected then only bot follows, else all bots follow
case 324:
case TEXTEMOTE_WAVE:
{
Player* const bot = GetPlayerBot(m_master->GetSelectionGuid());
if (bot)
bot->GetPlayerbotAI()->SetMovementOrder(PlayerbotAI::MOVEMENT_FOLLOW, m_master);
else
for (PlayerBotMap::const_iterator it = GetPlayerBotsBegin(); it != GetPlayerBotsEnd(); ++it)
{
Player* const bot = it->second;
bot->GetPlayerbotAI()->SetMovementOrder(PlayerbotAI::MOVEMENT_FOLLOW, m_master);
}
return;
}
}
return;
} /* EMOTE ends here */
case CMSG_GAMEOBJ_USE: // not sure if we still need this one
case CMSG_GAMEOBJ_REPORT_USE:
{
WorldPacket p(packet);
p.rpos(0); // reset reader
ObjectGuid objGUID;
p >> objGUID;
for (PlayerBotMap::const_iterator it = GetPlayerBotsBegin(); it != GetPlayerBotsEnd(); ++it)
{
Player* const bot = it->second;
bot->GetPlayerbotAI()->FollowAutoReset();
GameObject *obj = m_master->GetMap()->GetGameObject(objGUID);
if (!obj)
return;
// add other go types here, i.e.:
// GAMEOBJECT_TYPE_CHEST - loot quest items of chest
if (obj->GetGoType() == GAMEOBJECT_TYPE_QUESTGIVER)
{
bot->GetPlayerbotAI()->TurnInQuests(obj);
// auto accept every available quest this NPC has
bot->PrepareQuestMenu(objGUID);
QuestMenu& questMenu = bot->PlayerTalkClass->GetQuestMenu();
for (uint32 iI = 0; iI < questMenu.MenuItemCount(); ++iI)
{
QuestMenuItem const& qItem = questMenu.GetItem(iI);
uint32 questID = qItem.m_qId;
if (!bot->GetPlayerbotAI()->AddQuest(questID, obj))
DEBUG_LOG("Couldn't take quest");
}
}
}
}
break;
case CMSG_QUESTGIVER_HELLO:
{
WorldPacket p(packet);
p.rpos(0); // reset reader
ObjectGuid npcGUID;
p >> npcGUID;
WorldObject* pNpc = m_master->GetMap()->GetWorldObject(npcGUID);
if (!pNpc)
return;
// for all master's bots
for (PlayerBotMap::const_iterator it = GetPlayerBotsBegin(); it != GetPlayerBotsEnd(); ++it)
{
Player* const bot = it->second;
bot->GetPlayerbotAI()->FollowAutoReset();
bot->GetPlayerbotAI()->TurnInQuests(pNpc);
}
return;
}
// if master accepts a quest, bots should also try to accept quest
case CMSG_QUESTGIVER_ACCEPT_QUEST:
{
WorldPacket p(packet);
p.rpos(0); // reset reader
ObjectGuid guid;
uint32 quest;
uint32 unk1;
p >> guid >> quest >> unk1;
// DEBUG_LOG ("[PlayerbotMgr]: HandleMasterIncomingPacket - Received CMSG_QUESTGIVER_ACCEPT_QUEST npc = %s, quest = %u, unk1 = %u", guid.GetString().c_str(), quest, unk1);
Quest const* qInfo = sObjectMgr.GetQuestTemplate(quest);
if (qInfo)
for (PlayerBotMap::const_iterator it = GetPlayerBotsBegin(); it != GetPlayerBotsEnd(); ++it)
{
Player* const bot = it->second;
bot->GetPlayerbotAI()->FollowAutoReset();
if (bot->GetQuestStatus(quest) == QUEST_STATUS_COMPLETE)
bot->GetPlayerbotAI()->TellMaster("I already completed that quest.");
else if (!bot->CanTakeQuest(qInfo, false))
{
if (!bot->SatisfyQuestStatus(qInfo, false))
bot->GetPlayerbotAI()->TellMaster("I already have that quest.");
else
bot->GetPlayerbotAI()->TellMaster("I can't take that quest.");
}
else if (!bot->SatisfyQuestLog(false))
bot->GetPlayerbotAI()->TellMaster("My quest log is full.");
else if (!bot->CanAddQuest(qInfo, false))
bot->GetPlayerbotAI()->TellMaster("I can't take that quest because it requires that I take items, but my bags are full!");
else
{
p.rpos(0); // reset reader
bot->GetSession()->HandleQuestgiverAcceptQuestOpcode(p);
bot->GetPlayerbotAI()->TellMaster("Got the quest.");
// build needed items if quest contains any
for (int i = 0; i < QUEST_ITEM_OBJECTIVES_COUNT; i++)
if (qInfo->ReqItemCount[i] > 0)
{
bot->GetPlayerbotAI()->SetQuestNeedItems();
break;
}
// build needed creatures if quest contains any
for (int i = 0; i < QUEST_OBJECTIVES_COUNT; i++)
if (qInfo->ReqCreatureOrGOCount[i] > 0)
{
bot->GetPlayerbotAI()->SetQuestNeedCreatures();
break;
}
}
}
return;
}
case CMSG_AREATRIGGER:
{
WorldPacket p(packet);
for (PlayerBotMap::const_iterator it = GetPlayerBotsBegin(); it != GetPlayerBotsEnd(); ++it)
{
Player* const bot = it->second;
if (!bot)
continue;
if (bot->IsWithinDistInMap(GetMaster(), 50))
{
p.rpos(0); // reset reader
bot->GetSession()->HandleAreaTriggerOpcode(p);
}
}
return;
}
case CMSG_QUESTGIVER_COMPLETE_QUEST:
{
WorldPacket p(packet);
p.rpos(0); // reset reader
uint32 quest;
ObjectGuid npcGUID;
p >> npcGUID >> quest;
// DEBUG_LOG ("[PlayerbotMgr]: HandleMasterIncomingPacket - Received CMSG_QUESTGIVER_COMPLETE_QUEST npc = %s, quest = %u", npcGUID.GetString().c_str(), quest);
WorldObject* pNpc = m_master->GetMap()->GetWorldObject(npcGUID);
if (!pNpc)
return;
// for all master's bots
for (PlayerBotMap::const_iterator it = GetPlayerBotsBegin(); it != GetPlayerBotsEnd(); ++it)
{
Player* const bot = it->second;
bot->GetPlayerbotAI()->FollowAutoReset();
bot->GetPlayerbotAI()->TurnInQuests(pNpc);
}
return;
}
case CMSG_LOOT_ROLL:
{
WorldPacket p(packet); //WorldPacket packet for CMSG_LOOT_ROLL, (8+4+1)
ObjectGuid Guid;
uint32 itemSlot;
uint8 rollType;
p.rpos(0); //reset packet pointer
p >> Guid; //guid of the lootable target
p >> itemSlot; //loot index
p >> rollType; //need,greed or pass on roll
for (PlayerBotMap::const_iterator it = GetPlayerBotsBegin(); it != GetPlayerBotsEnd(); ++it)
{
uint32 choice = 2;
Player* const bot = it->second;
if (!bot)
return;
Group* group = bot->GetGroup();
if (!group)
return;
// check that the bot did not already vote
if (rollType >= ROLL_NOT_EMITED_YET)
return;
Loot* loot = sLootMgr.GetLoot(bot, Guid);
if (!loot)
{
sLog.outError("LootMgr::PlayerVote> Error cannot get loot object info!");
return;
}
LootItem* lootItem = loot->GetLootItemInSlot(itemSlot);
ItemPrototype const *pProto = lootItem->itemProto;
if (!pProto)
return;
if (bot->GetPlayerbotAI()->CanStore())
{
uint8 slots[4];
if (bot->ViableEquipSlots(pProto, &slots[0]))
{
int iSlot = 0;
// First we check what we are currently wearing
while (slots[iSlot] != NULL_SLOT && iSlot < 4)
{
Item* const pItem2 = bot->GetItemByPos(INVENTORY_SLOT_BAG_0, slots[iSlot]);
// Make sure there is something slotted
if (pItem2)
{
if (bot->GetPlayerbotAI()->EquipPrototypeComparison(pItem2->GetProto(), pProto))
{
choice = 1;
break;
}
}
iSlot++;
}
// TODO: Need to add logic for those cases where secondary equipment is
// used. For instance - 2H is used by Tank, but sword and board are in
// inventory for specific encounters. Upgrading thsoe should be taken
// into consideration. Also, more specific logic for 'sets'.
}
else
{
if (bot->HasSkill(SKILL_ENCHANTING))
{
choice = 3; // Disenchant
}
}
}
else
choice = 0; // Pass
sLootMgr.PlayerVote(bot, Guid, itemSlot, RollVote(choice));
switch (choice)
{
case ROLL_NEED:
bot->GetAchievementMgr().UpdateAchievementCriteria(ACHIEVEMENT_CRITERIA_TYPE_ROLL_NEED, 1);
break;
case ROLL_GREED:
case ROLL_DISENCHANT:
bot->GetAchievementMgr().UpdateAchievementCriteria(ACHIEVEMENT_CRITERIA_TYPE_ROLL_GREED, 1);
break;
}
}
return;
}
// Handle GOSSIP activate actions, prior to GOSSIP select menu actions
case CMSG_GOSSIP_HELLO:
{
// DEBUG_LOG ("[PlayerbotMgr]: HandleMasterIncomingPacket - Received CMSG_GOSSIP_HELLO");
WorldPacket p(packet); //WorldPacket packet for CMSG_GOSSIP_HELLO, (8)
ObjectGuid guid;
p.rpos(0); //reset packet pointer
p >> guid;
for (PlayerBotMap::const_iterator it = GetPlayerBotsBegin(); it != GetPlayerBotsEnd(); ++it)
{
Player* const bot = it->second;
if (!bot)
continue;
bot->GetPlayerbotAI()->FollowAutoReset();
Creature *pCreature = bot->GetNPCIfCanInteractWith(guid, UNIT_NPC_FLAG_NONE);
if (!pCreature)
{
DEBUG_LOG ("[PlayerbotMgr]: HandleMasterIncomingPacket - Received CMSG_GOSSIP_HELLO %s not found or you can't interact with him.", guid.GetString().c_str());
continue;
}
GossipMenuItemsMapBounds pMenuItemBounds = sObjectMgr.GetGossipMenuItemsMapBounds(pCreature->GetCreatureInfo()->GossipMenuId);
for (GossipMenuItemsMap::const_iterator itr = pMenuItemBounds.first; itr != pMenuItemBounds.second; ++itr)
{
uint32 npcflags = pCreature->GetUInt32Value(UNIT_NPC_FLAGS);
if (!(itr->second.npc_option_npcflag & npcflags))
continue;
switch (itr->second.option_id)
{
case GOSSIP_OPTION_TAXIVENDOR:
{
// bot->GetPlayerbotAI()->TellMaster("PlayerbotMgr:GOSSIP_OPTION_TAXIVENDOR");
bot->GetSession()->SendLearnNewTaxiNode(pCreature);
break;
}
case GOSSIP_OPTION_QUESTGIVER:
{
// bot->GetPlayerbotAI()->TellMaster("PlayerbotMgr:GOSSIP_OPTION_QUESTGIVER");
bot->GetPlayerbotAI()->TurnInQuests(pCreature);
break;
}
case GOSSIP_OPTION_VENDOR:
{
// bot->GetPlayerbotAI()->TellMaster("PlayerbotMgr:GOSSIP_OPTION_VENDOR");
if (!botConfig.GetBoolDefault("PlayerbotAI.SellGarbage", true))
continue;
// changed the SellGarbage() function to support ch.SendSysMessaage()
bot->GetPlayerbotAI()->SellGarbage(*bot);
break;
}
case GOSSIP_OPTION_STABLEPET:
{
// bot->GetPlayerbotAI()->TellMaster("PlayerbotMgr:GOSSIP_OPTION_STABLEPET");
break;
}
case GOSSIP_OPTION_AUCTIONEER:
{
// bot->GetPlayerbotAI()->TellMaster("PlayerbotMgr:GOSSIP_OPTION_AUCTIONEER");
break;
}
case GOSSIP_OPTION_BANKER:
{
// bot->GetPlayerbotAI()->TellMaster("PlayerbotMgr:GOSSIP_OPTION_BANKER");
break;
}
case GOSSIP_OPTION_INNKEEPER:
{
// bot->GetPlayerbotAI()->TellMaster("PlayerbotMgr:GOSSIP_OPTION_INNKEEPER");
break;
}
}
}
}
return;
}
case CMSG_SPIRIT_HEALER_ACTIVATE:
{
// DEBUG_LOG ("[PlayerbotMgr]: HandleMasterIncomingPacket - Received CMSG_SPIRIT_HEALER_ACTIVATE SpiritHealer is resurrecting the Player %s",m_master->GetName());
for (PlayerBotMap::iterator itr = m_playerBots.begin(); itr != m_playerBots.end(); ++itr)
{
Player* const bot = itr->second;
Group *grp = bot->GetGroup();
if (grp)
grp->RemoveMember(bot->GetObjectGuid(), 1);
}
return;
}
case CMSG_LIST_INVENTORY:
{
if (!botConfig.GetBoolDefault("PlayerbotAI.SellGarbage", true))
return;
WorldPacket p(packet);
p.rpos(0); // reset reader
ObjectGuid npcGUID;
p >> npcGUID;
Object* const pNpc = (WorldObject *) m_master->GetObjectByTypeMask(npcGUID, TYPEMASK_CREATURE_OR_GAMEOBJECT);
if (!pNpc)
return;
// for all master's bots
for (PlayerBotMap::const_iterator it = GetPlayerBotsBegin(); it != GetPlayerBotsEnd(); ++it)
{
Player* const bot = it->second;
if (!bot->IsInMap(static_cast<WorldObject *>(pNpc)))
{
bot->GetPlayerbotAI()->TellMaster("I'm too far away to sell items!");
continue;
}
else
{
// changed the SellGarbage() function to support ch.SendSysMessaage()
bot->GetPlayerbotAI()->FollowAutoReset();
bot->GetPlayerbotAI()->SellGarbage(*bot);
}
}
return;
}
/*
case CMSG_NAME_QUERY:
case MSG_MOVE_START_FORWARD:
case MSG_MOVE_STOP:
case MSG_MOVE_SET_FACING:
case MSG_MOVE_START_STRAFE_LEFT:
case MSG_MOVE_START_STRAFE_RIGHT:
case MSG_MOVE_STOP_STRAFE:
case MSG_MOVE_START_BACKWARD:
case MSG_MOVE_HEARTBEAT:
case CMSG_STANDSTATECHANGE:
case CMSG_QUERY_TIME:
case CMSG_CREATURE_QUERY:
case CMSG_GAMEOBJECT_QUERY:
case MSG_MOVE_JUMP:
case MSG_MOVE_FALL_LAND:
return;*/
default:
{
/*const char* oc = LookupOpcodeName(packet.GetOpcode());
// ChatHandler ch(m_master);
// ch.SendSysMessage(oc);
std::ostringstream out;
out << "masterin: " << oc;
sLog.outError(out.str().c_str()); */
}
}
}
void PlayerbotMgr::HandleMasterIncomingPacket(const WorldPacket& packet)
{
switch (packet.GetOpcode())
{
case CMSG_ACTIVATETAXI:
{
WorldPacket p(packet);
p.rpos(0); // reset reader
ObjectGuid guid;
std::vector<uint32> nodes;
nodes.resize(2);
uint8 delay = 9;
p >> guid >> nodes[0] >> nodes[1];
DEBUG_LOG ("[PlayerbotMgr]: HandleMasterIncomingPacket - Received CMSG_ACTIVATETAXI from %d to %d", nodes[0], nodes[1]);
for (PlayerBotMap::const_iterator it = GetPlayerBotsBegin(); it != GetPlayerBotsEnd(); ++it)
{
delay = delay + 3;
Player* const bot = it->second;
if (!bot)
return;
Group* group = bot->GetGroup();
if (!group)
continue;
Unit *target = ObjectAccessor::GetUnit(*bot, guid);
bot->GetPlayerbotAI()->SetIgnoreUpdateTime(delay);
bot->GetMotionMaster()->Clear(true);
bot->GetMotionMaster()->MoveFollow(target, INTERACTION_DISTANCE, bot->GetOrientation());
bot->GetPlayerbotAI()->GetTaxi(guid, nodes);
}
return;
}
case CMSG_ACTIVATETAXIEXPRESS:
{
WorldPacket p(packet);
p.rpos(0); // reset reader
ObjectGuid guid;
uint32 node_count;
uint8 delay = 9;
p >> guid >> node_count;
std::vector<uint32> nodes;
for (uint32 i = 0; i < node_count; ++i)
{
uint32 node;
p >> node;
nodes.push_back(node);
}
if (nodes.empty())
return;
DEBUG_LOG ("[PlayerbotMgr]: HandleMasterIncomingPacket - Received CMSG_ACTIVATETAXIEXPRESS from %d to %d", nodes.front(), nodes.back());
for (PlayerBotMap::const_iterator it = GetPlayerBotsBegin(); it != GetPlayerBotsEnd(); ++it)
{
delay = delay + 3;
Player* const bot = it->second;
if (!bot)
return;
Group* group = bot->GetGroup();
if (!group)
continue;
Unit *target = ObjectAccessor::GetUnit(*bot, guid);
bot->GetPlayerbotAI()->SetIgnoreUpdateTime(delay);
bot->GetMotionMaster()->Clear(true);
bot->GetMotionMaster()->MoveFollow(target, INTERACTION_DISTANCE, bot->GetOrientation());
bot->GetPlayerbotAI()->GetTaxi(guid, nodes);
}
return;
}
case CMSG_MOVE_SPLINE_DONE:
{
DEBUG_LOG ("[PlayerbotMgr]: HandleMasterIncomingPacket - Received CMSG_MOVE_SPLINE_DONE");
WorldPacket p(packet);
p.rpos(0); // reset reader
ObjectGuid guid; // used only for proper packet read
MovementInfo movementInfo; // used only for proper packet read
p >> guid.ReadAsPacked();
p >> movementInfo;
p >> Unused<uint32>(); // unk
for (PlayerBotMap::const_iterator it = GetPlayerBotsBegin(); it != GetPlayerBotsEnd(); ++it)
{
Player* const bot = it->second;
if (!bot)
return;
// in taxi flight packet received in 2 case:
// 1) end taxi path in far (multi-node) flight
// 2) switch from one map to other in case multi-map taxi path
// we need process only (1)
uint32 curDest = bot->m_taxi.GetTaxiDestination();
if (!curDest)
return;
TaxiNodesEntry const* curDestNode = sTaxiNodesStore.LookupEntry(curDest);
// far teleport case
if (curDestNode && curDestNode->map_id != bot->GetMapId())
{
if (bot->GetMotionMaster()->GetCurrentMovementGeneratorType() == FLIGHT_MOTION_TYPE)
{
// short preparations to continue flight
FlightPathMovementGenerator* flight = (FlightPathMovementGenerator *) (bot->GetMotionMaster()->top());
flight->Interrupt(*bot); // will reset at map landing
flight->SetCurrentNodeAfterTeleport();
TaxiPathNodeEntry const& node = flight->GetPath()[flight->GetCurrentNode()];
flight->SkipCurrentNode();
bot->TeleportTo(curDestNode->map_id, node.x, node.y, node.z, bot->GetOrientation());
}
return;
}
uint32 destinationnode = bot->m_taxi.NextTaxiDestination();
if (destinationnode > 0) // if more destinations to go
{
// current source node for next destination
uint32 sourcenode = bot->m_taxi.GetTaxiSource();
// Add to taximask middle hubs in taxicheat mode (to prevent having player with disabled taxicheat and not having back flight path)
if (bot->isTaxiCheater())
if (bot->m_taxi.SetTaximaskNode(sourcenode))
{
WorldPacket data(SMSG_NEW_TAXI_PATH, 0);
bot->GetSession()->SendPacket(&data);
}
DEBUG_LOG ("[PlayerbotMgr]: HandleMasterIncomingPacket - Received CMSG_MOVE_SPLINE_DONE Taxi has to go from %u to %u", sourcenode, destinationnode);
uint32 mountDisplayId = sObjectMgr.GetTaxiMountDisplayId(sourcenode, bot->GetTeam());
uint32 path, cost;
sObjectMgr.GetTaxiPath(sourcenode, destinationnode, path, cost);
if (path && mountDisplayId)
bot->GetSession()->SendDoFlight(mountDisplayId, path, 1); // skip start fly node
else
bot->m_taxi.ClearTaxiDestinations(); // clear problematic path and next
}
else
/* std::ostringstream out;
out << "Destination reached" << bot->GetName();
ChatHandler ch(m_master);
ch.SendSysMessage(out.str().c_str()); */
bot->m_taxi.ClearTaxiDestinations(); // Destination, clear source node
}
return;
}
// if master is logging out, log out all bots & remove them from group
case CMSG_LOGOUT_REQUEST:
{
LogoutAllBots();
return;
}
// If master inspects one of his bots, give the master useful info in chat window
// such as inventory that can be equipped
case CMSG_INSPECT:
{
WorldPacket p(packet);
p.rpos(0); // reset reader
ObjectGuid guid;
p >> guid;
Player* const bot = GetPlayerBot(guid);
if (bot) bot->GetPlayerbotAI()->SendNotEquipList(*bot);
return;
}
// handle emotes from the master
//case CMSG_EMOTE:
case CMSG_TEXT_EMOTE:
{
WorldPacket p(packet);
p.rpos(0); // reset reader
uint32 emoteNum;
p >> emoteNum;
/* std::ostringstream out;
out << "emote is: " << emoteNum;
ChatHandler ch(m_master);
ch.SendSysMessage(out.str().c_str()); */
switch (emoteNum)
{
case TEXTEMOTE_BOW:
{
// Buff anyone who bows before me. Useful for players not in bot's group
// How do I get correct target???
//Player* const pPlayer = GetPlayerBot(m_master->GetSelection());
//if (pPlayer->GetPlayerbotAI()->GetClassAI())
// pPlayer->GetPlayerbotAI()->GetClassAI()->BuffPlayer(pPlayer);
return;
}
/*
case TEXTEMOTE_BONK:
{
Player* const pPlayer = GetPlayerBot(m_master->GetSelection());
if (!pPlayer || !pPlayer->GetPlayerbotAI())
return;
PlayerbotAI* const pBot = pPlayer->GetPlayerbotAI();
ChatHandler ch(m_master);
{
std::ostringstream out;
out << "time(0): " << time(0)
<< " m_ignoreAIUpdatesUntilTime: " << pBot->m_ignoreAIUpdatesUntilTime;
ch.SendSysMessage(out.str().c_str());
}
{
std::ostringstream out;
out << "m_TimeDoneEating: " << pBot->m_TimeDoneEating
<< " m_TimeDoneDrinking: " << pBot->m_TimeDoneDrinking;
ch.SendSysMessage(out.str().c_str());
}
{
std::ostringstream out;
out << "m_CurrentlyCastingSpellId: " << pBot->m_CurrentlyCastingSpellId;
ch.SendSysMessage(out.str().c_str());
}
{
std::ostringstream out;
out << "IsBeingTeleported() " << pBot->GetPlayer()->IsBeingTeleported();
ch.SendSysMessage(out.str().c_str());
}
{
std::ostringstream out;
bool tradeActive = (pBot->GetPlayer()->GetTrader()) ? true : false;
out << "tradeActive: " << tradeActive;
ch.SendSysMessage(out.str().c_str());
}
{
std::ostringstream out;
out << "IsCharmed() " << pBot->getPlayer()->isCharmed();
ch.SendSysMessage(out.str().c_str());
}
return;
}
*/
case TEXTEMOTE_EAT:
case TEXTEMOTE_DRINK:
{
for (PlayerBotMap::const_iterator it = GetPlayerBotsBegin(); it != GetPlayerBotsEnd(); ++it)
{
Player* const bot = it->second;
bot->GetPlayerbotAI()->Feast();
}
return;
}
// emote to attack selected target
case TEXTEMOTE_POINT:
{
ObjectGuid attackOnGuid = m_master->GetSelectionGuid();
if (attackOnGuid.IsEmpty())
return;
Unit* thingToAttack = ObjectAccessor::GetUnit(*m_master, attackOnGuid);
if (!thingToAttack) return;
Player *bot = 0;
for (PlayerBotMap::iterator itr = m_playerBots.begin(); itr != m_playerBots.end(); ++itr)
{
bot = itr->second;
if (!bot->IsFriendlyTo(thingToAttack) && bot->IsWithinLOSInMap(thingToAttack))
bot->GetPlayerbotAI()->GetCombatTarget(thingToAttack);
}
return;
}
// emote to stay
case TEXTEMOTE_STAND:
{
Player* const bot = GetPlayerBot(m_master->GetSelectionGuid());
if (bot)
bot->GetPlayerbotAI()->SetMovementOrder(PlayerbotAI::MOVEMENT_STAY);
else
for (PlayerBotMap::const_iterator it = GetPlayerBotsBegin(); it != GetPlayerBotsEnd(); ++it)
{
Player* const bot = it->second;
bot->GetPlayerbotAI()->SetMovementOrder(PlayerbotAI::MOVEMENT_STAY);
}
return;
}
// 324 is the followme emote (not defined in enum)
// if master has bot selected then only bot follows, else all bots follow
case 324:
case TEXTEMOTE_WAVE:
{
Player* const bot = GetPlayerBot(m_master->GetSelectionGuid());
if (bot)
bot->GetPlayerbotAI()->SetMovementOrder(PlayerbotAI::MOVEMENT_FOLLOW, m_master);
else
for (PlayerBotMap::const_iterator it = GetPlayerBotsBegin(); it != GetPlayerBotsEnd(); ++it)
{
Player* const bot = it->second;
bot->GetPlayerbotAI()->SetMovementOrder(PlayerbotAI::MOVEMENT_FOLLOW, m_master);
}
return;
}
}
return;
} /* EMOTE ends here */
case CMSG_GAMEOBJ_USE: // not sure if we still need this one
case CMSG_GAMEOBJ_REPORT_USE:
{
WorldPacket p(packet);
p.rpos(0); // reset reader
ObjectGuid objGUID;
p >> objGUID;
for (PlayerBotMap::const_iterator it = GetPlayerBotsBegin(); it != GetPlayerBotsEnd(); ++it)
{
Player* const bot = it->second;
GameObject *obj = m_master->GetMap()->GetGameObject(objGUID);
if (!obj)
return;
// add other go types here, i.e.:
// GAMEOBJECT_TYPE_CHEST - loot quest items of chest
if (obj->GetGoType() == GAMEOBJECT_TYPE_QUESTGIVER)
{
bot->GetPlayerbotAI()->TurnInQuests(obj);
// auto accept every available quest this NPC has
bot->PrepareQuestMenu(objGUID);
QuestMenu& questMenu = bot->PlayerTalkClass->GetQuestMenu();
for (uint32 iI = 0; iI < questMenu.MenuItemCount(); ++iI)
{
QuestMenuItem const& qItem = questMenu.GetItem(iI);
uint32 questID = qItem.m_qId;
if (!bot->GetPlayerbotAI()->AddQuest(questID, obj))
DEBUG_LOG("Couldn't take quest");
}
}
}
}
break;
case CMSG_QUESTGIVER_HELLO:
{
WorldPacket p(packet);
p.rpos(0); // reset reader
ObjectGuid npcGUID;
p >> npcGUID;
WorldObject* pNpc = m_master->GetMap()->GetWorldObject(npcGUID);
if (!pNpc)
return;
// for all master's bots
for (PlayerBotMap::const_iterator it = GetPlayerBotsBegin(); it != GetPlayerBotsEnd(); ++it)
{
Player* const bot = it->second;
bot->GetPlayerbotAI()->TurnInQuests(pNpc);
}
return;
}
// if master accepts a quest, bots should also try to accept quest
case CMSG_QUESTGIVER_ACCEPT_QUEST:
{
WorldPacket p(packet);
p.rpos(0); // reset reader
ObjectGuid guid;
uint32 quest;
uint32 unk1;
p >> guid >> quest >> unk1;
DEBUG_LOG ("[PlayerbotMgr]: HandleMasterIncomingPacket - Received CMSG_QUESTGIVER_ACCEPT_QUEST npc = %s, quest = %u, unk1 = %u", guid.GetString().c_str(), quest, unk1);
Quest const* qInfo = sObjectMgr.GetQuestTemplate(quest);
if (qInfo)
for (PlayerBotMap::const_iterator it = GetPlayerBotsBegin(); it != GetPlayerBotsEnd(); ++it)
{
Player* const bot = it->second;
if (bot->GetQuestStatus(quest) == QUEST_STATUS_COMPLETE)
bot->GetPlayerbotAI()->TellMaster("I already completed that quest.");
else if (!bot->CanTakeQuest(qInfo, false))
{
if (!bot->SatisfyQuestStatus(qInfo, false))
bot->GetPlayerbotAI()->TellMaster("I already have that quest.");
else
bot->GetPlayerbotAI()->TellMaster("I can't take that quest.");
}
else if (!bot->SatisfyQuestLog(false))
bot->GetPlayerbotAI()->TellMaster("My quest log is full.");
else if (!bot->CanAddQuest(qInfo, false))
bot->GetPlayerbotAI()->TellMaster("I can't take that quest because it requires that I take items, but my bags are full!");
else
{
p.rpos(0); // reset reader
bot->GetSession()->HandleQuestgiverAcceptQuestOpcode(p);
bot->GetPlayerbotAI()->TellMaster("Got the quest.");
// build needed items if quest contains any
for (int i = 0; i < QUEST_ITEM_OBJECTIVES_COUNT; i++)
if (qInfo->ReqItemCount[i] > 0)
{
bot->GetPlayerbotAI()->SetQuestNeedItems();
break;
}
// build needed creatures if quest contains any
for (int i = 0; i < QUEST_OBJECTIVES_COUNT; i++)
if (qInfo->ReqCreatureOrGOCount[i] > 0)
{
bot->GetPlayerbotAI()->SetQuestNeedCreatures();
break;
}
}
}
return;
}
case CMSG_AREATRIGGER:
{
WorldPacket p(packet);
for (PlayerBotMap::const_iterator it = GetPlayerBotsBegin(); it != GetPlayerBotsEnd(); ++it)
{
Player* const bot = it->second;
p.rpos(0); // reset reader
bot->GetSession()->HandleAreaTriggerOpcode(p);
}
return;
}
case CMSG_QUESTGIVER_COMPLETE_QUEST:
{
WorldPacket p(packet);
p.rpos(0); // reset reader
uint32 quest;
ObjectGuid npcGUID;
p >> npcGUID >> quest;
DEBUG_LOG ("[PlayerbotMgr]: HandleMasterIncomingPacket - Received CMSG_QUESTGIVER_COMPLETE_QUEST npc = %s, quest = %u", npcGUID.GetString().c_str(), quest);
WorldObject* pNpc = m_master->GetMap()->GetWorldObject(npcGUID);
if (!pNpc)
return;
// for all master's bots
for (PlayerBotMap::const_iterator it = GetPlayerBotsBegin(); it != GetPlayerBotsEnd(); ++it)
{
Player* const bot = it->second;
bot->GetPlayerbotAI()->TurnInQuests(pNpc);
}
return;
}
case CMSG_LOOT_ROLL:
{
WorldPacket p(packet); //WorldPacket packet for CMSG_LOOT_ROLL, (8+4+1)
ObjectGuid Guid;
uint32 NumberOfPlayers;
uint8 rollType;
p.rpos(0); //reset packet pointer
p >> Guid; //guid of the item rolled
p >> NumberOfPlayers; //number of players invited to roll
p >> rollType; //need,greed or pass on roll
for (PlayerBotMap::const_iterator it = GetPlayerBotsBegin(); it != GetPlayerBotsEnd(); ++it)
{
uint32 choice;
Player* const bot = it->second;
if (!bot)
return;
Group* group = bot->GetGroup();
if (!group)
return;
(bot->GetPlayerbotAI()->CanStore()) ? choice = urand(0, 3) : choice = 0; // pass = 0, need = 1, greed = 2, disenchant = 3
group->CountRollVote(bot, Guid, NumberOfPlayers, RollVote(choice));
switch (choice)
{
case ROLL_NEED:
bot->GetAchievementMgr().UpdateAchievementCriteria(ACHIEVEMENT_CRITERIA_TYPE_ROLL_NEED, 1);
break;
case ROLL_GREED:
bot->GetAchievementMgr().UpdateAchievementCriteria(ACHIEVEMENT_CRITERIA_TYPE_ROLL_GREED, 1);
break;
}
}
return;
}
// Handle GOSSIP activate actions, prior to GOSSIP select menu actions
case CMSG_GOSSIP_HELLO:
{
DEBUG_LOG ("[PlayerbotMgr]: HandleMasterIncomingPacket - Received CMSG_GOSSIP_HELLO");
WorldPacket p(packet); //WorldPacket packet for CMSG_GOSSIP_HELLO, (8)
ObjectGuid guid;
p.rpos(0); //reset packet pointer
p >> guid;
for (PlayerBotMap::const_iterator it = GetPlayerBotsBegin(); it != GetPlayerBotsEnd(); ++it)
{
Player* const bot = it->second;
if (!bot)
return;
Creature *pCreature = bot->GetNPCIfCanInteractWith(guid, UNIT_NPC_FLAG_NONE);
if (!pCreature)
{
DEBUG_LOG ("[PlayerbotMgr]: HandleMasterIncomingPacket - Received CMSG_GOSSIP_HELLO %s not found or you can't interact with him.", guid.GetString().c_str());
return;
}
GossipMenuItemsMapBounds pMenuItemBounds = sObjectMgr.GetGossipMenuItemsMapBounds(pCreature->GetCreatureInfo()->GossipMenuId);
for (GossipMenuItemsMap::const_iterator itr = pMenuItemBounds.first; itr != pMenuItemBounds.second; ++itr)
{
uint32 npcflags = pCreature->GetUInt32Value(UNIT_NPC_FLAGS);
if (!(itr->second.npc_option_npcflag & npcflags))
continue;
switch (itr->second.option_id)
{
case GOSSIP_OPTION_TAXIVENDOR:
{
// bot->GetPlayerbotAI()->TellMaster("PlayerbotMgr:GOSSIP_OPTION_TAXIVENDOR");
bot->GetSession()->SendLearnNewTaxiNode(pCreature);
break;
}
case GOSSIP_OPTION_QUESTGIVER:
{
// bot->GetPlayerbotAI()->TellMaster("PlayerbotMgr:GOSSIP_OPTION_QUESTGIVER");
bot->GetPlayerbotAI()->TurnInQuests(pCreature);
break;
}
case GOSSIP_OPTION_VENDOR:
{
// bot->GetPlayerbotAI()->TellMaster("PlayerbotMgr:GOSSIP_OPTION_VENDOR");
break;
}
case GOSSIP_OPTION_STABLEPET:
{
// bot->GetPlayerbotAI()->TellMaster("PlayerbotMgr:GOSSIP_OPTION_STABLEPET");
break;
}
case GOSSIP_OPTION_AUCTIONEER:
{
// bot->GetPlayerbotAI()->TellMaster("PlayerbotMgr:GOSSIP_OPTION_AUCTIONEER");
break;
}
case GOSSIP_OPTION_BANKER:
{
// bot->GetPlayerbotAI()->TellMaster("PlayerbotMgr:GOSSIP_OPTION_BANKER");
break;
}
case GOSSIP_OPTION_INNKEEPER:
{
// bot->GetPlayerbotAI()->TellMaster("PlayerbotMgr:GOSSIP_OPTION_INNKEEPER");
break;
}
}
}
}
return;
}
case CMSG_SPIRIT_HEALER_ACTIVATE:
{
// DEBUG_LOG ("[PlayerbotMgr]: HandleMasterIncomingPacket - Received CMSG_SPIRIT_HEALER_ACTIVATE SpiritHealer is resurrecting the Player %s",m_master->GetName());
for (PlayerBotMap::iterator itr = m_playerBots.begin(); itr != m_playerBots.end(); ++itr)
{
Player* const bot = itr->second;
Group *grp = bot->GetGroup();
if (grp)
grp->RemoveMember(bot->GetObjectGuid(), 1);
}
return;
}
case CMSG_LIST_INVENTORY:
{
if (sWorld.getConfig(CONFIG_BOOL_PLAYERBOT_SELL_TRASH))
return;
WorldPacket p(packet);
p.rpos(0); // reset reader
ObjectGuid npcGUID;
p >> npcGUID;
Object* const pNpc = (WorldObject *) m_master->GetObjectByTypeMask(npcGUID, TYPEMASK_CREATURE_OR_GAMEOBJECT);
if (!pNpc)
return;
// for all master's bots
for (PlayerBotMap::const_iterator it = GetPlayerBotsBegin(); it != GetPlayerBotsEnd(); ++it)
{
Player* const bot = it->second;
if (!bot->IsInMap(static_cast<WorldObject *>(pNpc)))
{
bot->GetPlayerbotAI()->TellMaster("I'm too far away to sell items!");
continue;
}
else
bot->GetPlayerbotAI()->SellGarbage();
}
return;
}
/*
case CMSG_NAME_QUERY:
case MSG_MOVE_START_FORWARD:
case MSG_MOVE_STOP:
case MSG_MOVE_SET_FACING:
case MSG_MOVE_START_STRAFE_LEFT:
case MSG_MOVE_START_STRAFE_RIGHT:
case MSG_MOVE_STOP_STRAFE:
case MSG_MOVE_START_BACKWARD:
case MSG_MOVE_HEARTBEAT:
case CMSG_STANDSTATECHANGE:
case CMSG_QUERY_TIME:
case CMSG_CREATURE_QUERY:
case CMSG_GAMEOBJECT_QUERY:
case MSG_MOVE_JUMP:
case MSG_MOVE_FALL_LAND:
return;
default:
{
const char* oc = LookupOpcodeName(packet.GetOpcode());
// ChatHandler ch(m_master);
// ch.SendSysMessage(oc);
std::ostringstream out;
out << "masterin: " << oc;
sLog.outError(out.str().c_str());
}
*/
}
}
bool ChatHandler::HandleDeleteCommand(const char* args, WorldSession *m_session)
{
uint64 guid = m_session->GetPlayer()->GetSelection();
if (guid == 0)
{
SystemMessage(m_session, "No selection.");
return true;
}
Creature* unit = NULL;
if(m_session->GetPlayer()->GetMapMgr()->GetVehicle(GET_LOWGUID_PART(guid)))
unit = m_session->GetPlayer()->GetMapMgr()->GetVehicle(GET_LOWGUID_PART(guid));
else
unit = m_session->GetPlayer()->GetMapMgr()->GetCreature(GET_LOWGUID_PART(guid));
if(!unit)
{
SystemMessage(m_session, "You should select a creature.");
return true;
}
if( unit->m_spawn != NULL && !m_session->CanUseCommand('z') )
{
SystemMessage(m_session, "You do not have permission to do that. Please contact higher staff for removing of saved spawns.");
return true;
}
if(unit->GetAIInterface())
unit->GetAIInterface()->StopMovement(10000);
if(unit->IsVehicle())
{
Vehicle* veh = TO_VEHICLE(unit);
for(int i = 0; i < 8; i++)
{
if(!veh->GetPassenger(i))
continue;
// Remove any players
if(veh->GetPassenger(i)->IsPlayer())
veh->RemovePassenger(veh->GetPassenger(i));
else // Remove any units.
veh->GetPassenger(i)->RemoveFromWorld(true);
}
}
sGMLog.writefromsession(m_session, "used npc delete, sqlid %u, creature %s, pos %f %f %f",
unit->m_spawn ? unit->m_spawn : 0, unit->GetCreatureInfo() ? unit->GetCreatureInfo()->Name : "wtfbbqhax", unit->GetPositionX(), unit->GetPositionY(),
unit->GetPositionZ());
BlueSystemMessage(m_session, "Deleted creature ID %u", unit->spawnid);
MapMgr* unitMgr = unit->GetMapMgr();
unit->DeleteFromDB();
if(!unit->IsInWorld())
return true;
if(unit->m_spawn)
{
uint32 cellx=float2int32(((_maxX-unit->m_spawn->x)/_cellSize));
uint32 celly=float2int32(((_maxY-unit->m_spawn->y)/_cellSize));
if(cellx <= _sizeX && celly <= _sizeY && unitMgr != NULL)
{
CellSpawns * c = unitMgr->GetBaseMap()->GetSpawnsList(cellx, celly);
if( c != NULL )
{
CreatureSpawnList::iterator itr, itr2;
for(itr = c->CreatureSpawns.begin(); itr != c->CreatureSpawns.end();)
{
itr2 = itr;
++itr;
if((*itr2) == unit->m_spawn)
{
c->CreatureSpawns.erase(itr2);
delete unit->m_spawn;
break;
}
}
}
}
}
unit->RemoveFromWorld(false,true);
if(unit->IsVehicle())
TO_VEHICLE(unit)->Destructor();
else
unit->Destructor();
return true;
}
bool ChatHandler::HandleDeleteCommand(const char* args, WorldSession *m_session)
{
Creature* unit = getSelectedCreature(m_session, false);
if(!unit)
{
SystemMessage(m_session, "You should select a creature.");
return true;
}
else if(unit->IsPet() || unit->IsSummon())
{
SystemMessage(m_session, "You can't delete playerpets.");
return true;
}
if( unit->m_spawn != NULL && !m_session->CanUseCommand('z') )
{
SystemMessage(m_session, "You do not have permission to do that. Please contact higher staff for removing of saved spawns.");
return true;
}
if(unit->IsVehicle())
{
Vehicle* veh = TO_VEHICLE(unit);
for(int i = 0; i < 8; i++)
{
if(!veh->GetPassenger(i))
continue;
// Remove any players
if(veh->GetPassenger(i)->IsPlayer())
veh->RemovePassenger(veh->GetPassenger(i));
else // Remove any units.
veh->GetPassenger(i)->RemoveFromWorld(true);
}
}
sWorld.LogGM(m_session, "used npc delete, sqlid %u, creature %s, pos %f %f %f",
unit->m_spawn ? unit->m_spawn->id : 0, unit->GetCreatureInfo() ? unit->GetCreatureInfo()->Name : "wtfbbqhax", unit->GetPositionX(), unit->GetPositionY(),
unit->GetPositionZ());
BlueSystemMessage(m_session, "Deleted creature ID %u", unit->spawnid);
unit->DeleteFromDB();
if(!unit->IsInWorld())
return true;
MapMgr* unitMgr = unit->GetMapMgr();
if(unit->m_spawn)
{
uint32 cellx = unitMgr->GetPosX(unit->m_spawn->x);
uint32 celly = unitMgr->GetPosX(unit->m_spawn->y);
if(cellx <= _sizeX && celly <= _sizeY )
{
CellSpawns *c = unitMgr->GetBaseMap()->GetSpawnsList(cellx, celly);
if( c != NULL )
{
CreatureSpawnList::iterator itr, itr2;
for(itr = c->CreatureSpawns.begin(); itr != c->CreatureSpawns.end();)
{
itr2 = itr++;
if((*itr2) == unit->m_spawn)
{
c->CreatureSpawns.erase(itr2);
delete unit->m_spawn;
break;
}
}
}
}
}
unit->RemoveFromWorld(false, true);
if(unit->IsVehicle())
TO_VEHICLE(unit)->Destruct();
else
unit->Destruct();
m_session->GetPlayer()->SetSelection(NULL);
return true;
}
void WorldSession::HandleTextEmoteOpcode( WorldPacket & recv_data )
{
CHECK_PACKET_SIZE(recv_data,4+4+8);
uint32 text_emote, emoteNum;
uint64 guid;
recv_data >> text_emote;
recv_data >> emoteNum;
recv_data >> guid;
const char *nam = 0;
uint32 namlen = 1;
Unit* unit = ObjectAccessor::Instance().GetUnit(*_player, guid);
Creature *pCreature = dynamic_cast<Creature *>(unit);
if( pCreature != NULL )
{
nam = pCreature->GetCreatureInfo()->Name;
namlen = (nam ? strlen(nam) : 0) + 1;
}
{
Player *pChar = dynamic_cast<Player *>(unit);
if( pChar != NULL )
{
nam = pChar->GetName();
namlen = (nam ? strlen(nam) : 0) + 1;
}
}
EmotesTextEntry const *em = sEmotesTextStore.LookupEntry(text_emote);
if (em)
{
uint32 emote_anim = em->textid;
WorldPacket data;
switch(emote_anim)
{
case EMOTE_STATE_SLEEP:
case EMOTE_STATE_SIT:
case EMOTE_STATE_KNEEL:
break;
default:
data.Initialize(SMSG_EMOTE, 12);
data << (uint32)emote_anim;
data << GetPlayer()->GetGUID();
WPAssert(data.size() == 12);
GetPlayer()->SendMessageToSet( &data, true );
break;
}
data.Initialize(SMSG_TEXT_EMOTE, (20+namlen));
data << GetPlayer()->GetGUID();
data << (uint32)text_emote;
data << emoteNum;
data << (uint32)namlen;
if( namlen > 1 )
{
data.append(nam, namlen);
}
else
{
data << (uint8)0x00;
}
GetPlayer()->SendMessageToSet( &data, true );
//Send scripted event call
if (pCreature && Script)
Script->ReceiveEmote(GetPlayer(),pCreature,emote_anim);
}
}
void WorldSession::HandleTextEmoteOpcode( WorldPacket & recv_data )
{
CHECK_PACKET_SIZE(recv_data, 16);
if(!_player->IsInWorld() || !_player->isAlive())
return;
uint64 guid;
uint32
text_emote,
unk,
namelen =1;
const char* name =" ";
recv_data >> text_emote;
recv_data >> unk;
recv_data >> guid;
Unit * pUnit = _player->GetMapMgr()->GetUnit(guid);
if(pUnit)
{
if( pUnit->IsPlayer() )
{
name = static_cast< Player* >( pUnit )->GetName();
namelen = (uint32)strlen(name) + 1;
}
else if ( pUnit->IsPet() )
{
name = static_cast< Pet* >( pUnit )->GetName().c_str();
namelen = (uint32)strlen(name) + 1;
}
else if(pUnit->GetTypeId() == TYPEID_UNIT)
{
Creature * p = static_cast<Creature*>(pUnit);
if(p->GetCreatureInfo())
{
name = p->GetCreatureInfo()->Name;
namelen = (uint32)strlen(name) + 1;
}
else
{
name = 0;
namelen = 0;
}
}
}
emoteentry *em = dbcEmoteEntry.LookupEntry(text_emote);
if(em)
{
WorldPacket data(SMSG_EMOTE, 28 + namelen);
sHookInterface.OnEmote(_player, (EmoteType)em->textid, pUnit);
if(pUnit)
CALL_SCRIPT_EVENT(pUnit,OnEmote)(_player,(EmoteType)em->textid);
switch(em->textid)
{
case EMOTE_STATE_SLEEP:
case EMOTE_STATE_SIT:
case EMOTE_STATE_KNEEL:
case EMOTE_STATE_DANCE:
{
_player->SetUInt32Value(UNIT_NPC_EMOTESTATE, em->textid);
}break;
}
data << (uint32)em->textid;
data << (uint64)GetPlayer()->GetGUID();
GetPlayer()->SendMessageToSet(&data, true); //If player receives his own emote, his animation stops.
data.Initialize(SMSG_TEXT_EMOTE);
data << (uint64)GetPlayer()->GetGUID();
data << (uint32)text_emote;
data << unk;
data << (uint32)namelen;
if( namelen > 1 ) data.append(name, namelen);
else data << (uint8)0x00;
GetPlayer()->SendMessageToSet(&data, true);
}
}
bool ChatHandler::HandleQuestAddFinishCommand(const char * args, WorldSession * m_session)
{
if(!*args)
return false;
uint64 guid = m_session->GetPlayer()->GetSelection();
if (guid == 0)
{
SystemMessage(m_session, "You must target an npc.");
return false;
}
Creature *unit = m_session->GetPlayer()->GetMapMgr()->GetCreature(GET_LOWGUID_PART(guid));
if(!unit)
{
SystemMessage(m_session, "You must target an npc.");
return false;
}
if (!unit->isQuestGiver())
{
SystemMessage(m_session, "Unit is not a valid quest giver.");
return false;
}
uint32 quest_id = atol(args);
if(quest_id== 0)
{
quest_id = GetQuestIDFromLink(args);
if(quest_id== 0)
return false;
}
Quest * qst = QuestStorage.LookupEntry(quest_id);
if (qst == NULL)
{
SystemMessage(m_session, "Invalid quest selected, unable to add quest to the specified NPC.");
return false;
}
std::string quest_giver = MyConvertIntToString(unit->GetEntry());
std::string my_query1 = "SELECT id FROM creature_quest_finisher WHERE id = " + quest_giver + " AND quest = " + string(args);
QueryResult *selectResult1 = WorldDatabase.Query(my_query1.c_str());
if (selectResult1)
{
delete selectResult1;
SystemMessage(m_session, "Quest was already found for the specified NPC.");
}
else
{
std::string my_insert1 = "INSERT INTO creature_quest_finisher (id, quest) VALUES (" + quest_giver + "," + string(args) + ")";
QueryResult *insertResult1 = WorldDatabase.Query(my_insert1.c_str());
if (insertResult1)
delete insertResult1;
}
sQuestMgr.LoadExtraQuestStuff();
QuestRelation *qstrel = new QuestRelation;
qstrel->qst = qst;
qstrel->type = QUESTGIVER_QUEST_END;
uint8 qstrelid;
if ( unit->HasQuests() )
{
qstrelid = (uint8)unit->GetQuestRelation(quest_id);
unit->DeleteQuest(qstrel);
}
unit->_LoadQuests();
const char * qname = qst->title;
std::string recout = "|cff00ff00Added Quest to NPC as finisher: ";
recout += "|cff00ccff";
recout += qname;
recout += "\n\n";
SendMultilineMessage(m_session, recout.c_str());
sGMLog.writefromsession( m_session, "added finisher of quest %u [%s] to NPC %u [%s]", qst->id, qst->title, unit->GetEntry(), unit->GetCreatureInfo()->Name );
delete qstrel;
return true;
}
void WorldSession::SendTrainerList(ObjectGuid guid, const std::string& strTitle)
{
DEBUG_LOG( "WORLD: SendTrainerList" );
Creature *unit = GetPlayer()->GetNPCIfCanInteractWith(guid,UNIT_NPC_FLAG_TRAINER);
if (!unit)
{
DEBUG_LOG("WORLD: SendTrainerList - %s not found or you can't interact with him.", guid.GetString().c_str());
return;
}
// remove fake death
if (GetPlayer()->hasUnitState(UNIT_STAT_DIED))
GetPlayer()->RemoveSpellsCausingAura(SPELL_AURA_FEIGN_DEATH);
// trainer list loaded at check;
if (!unit->IsTrainerOf(_player,true))
return;
CreatureInfo const *ci = unit->GetCreatureInfo();
if (!ci)
return;
TrainerSpellData const* trainer_spells = unit->GetTrainerSpells();
if (!trainer_spells)
{
DEBUG_LOG("WORLD: SendTrainerList - Training spells not found for %s", guid.GetString().c_str());
return;
}
WorldPacket data( SMSG_TRAINER_LIST, 8+4+4+trainer_spells->spellList.size()*38 + strTitle.size()+1);
data << ObjectGuid(guid);
data << uint32(trainer_spells->trainerType);
size_t count_pos = data.wpos();
data << uint32(trainer_spells->spellList.size());
// reputation discount
float fDiscountMod = _player->GetReputationPriceDiscount(unit);
bool can_learn_primary_prof = GetPlayer()->GetFreePrimaryProfessionPoints() > 0;
uint32 count = 0;
for(TrainerSpellMap::const_iterator itr = trainer_spells->spellList.begin(); itr != trainer_spells->spellList.end(); ++itr)
{
TrainerSpell const* tSpell = &itr->second;
if(!_player->IsSpellFitByClassAndRace(tSpell->learnedSpell))
continue;
bool primary_prof_first_rank = sSpellMgr.IsPrimaryProfessionFirstRankSpell(tSpell->learnedSpell);
SpellChainNode const* chain_node = sSpellMgr.GetSpellChainNode(tSpell->learnedSpell);
TrainerSpellState state = _player->GetTrainerSpellState(tSpell);
data << uint32(tSpell->spell); // learned spell (or cast-spell in profession case)
data << uint8(state==TRAINER_SPELL_GREEN_DISABLED ? TRAINER_SPELL_GREEN : state);
data << uint32(floor(tSpell->spellCost * fDiscountMod));
data << uint32(primary_prof_first_rank && can_learn_primary_prof ? 1 : 0);
// primary prof. learn confirmation dialog
data << uint32(primary_prof_first_rank ? 1 : 0); // must be equal prev. field to have learn button in enabled state
data << uint8(tSpell->reqLevel);
data << uint32(tSpell->reqSkill);
data << uint32(tSpell->reqSkillValue);
data << uint32(!tSpell->IsCastable() && chain_node ? (chain_node->prev ? chain_node->prev : chain_node->req) : 0);
data << uint32(!tSpell->IsCastable() && chain_node && chain_node->prev ? chain_node->req : 0);
data << uint32(0);
++count;
}
data << strTitle;
data.put<uint32>(count_pos,count);
SendPacket( &data );
}
// Check if the paladin bot needs to cast/refresh a seal on him/herself
// also check if the paladin bot needs to judge its target and first buff
// him/herself with the relevant seal
// TODO: handle other paladins in group/raid, for example to cast Seal/Judgement of Light
bool PlayerbotPaladinAI::CheckSealAndJudgement(Unit* pTarget)
{
if (!m_ai) return false;
if (!m_bot) return false;
if (!pTarget) return false;
Creature * pCreature = (Creature*) pTarget;
// Prevent low health humanoid from fleeing by judging them with Seal of Justice
if (pCreature && pCreature->GetCreatureInfo()->CreatureType == CREATURE_TYPE_HUMANOID && pTarget->GetHealthPercent() < 20 && !pCreature->IsWorldBoss())
{
if (SEAL_OF_JUSTICE > 0 && !m_bot->HasAura(SEAL_OF_JUSTICE, EFFECT_INDEX_0) && m_ai->CastSpell(SEAL_OF_JUSTICE, *m_bot))
{
m_CurrentSeal = SEAL_OF_JUSTICE;
m_CurrentJudgement = 0;
return true;
}
}
// Bot already defined a seal and a judgement and each is active on bot and target: don't waste time to go further
if (m_CurrentSeal > 0 && m_bot->HasAura(m_CurrentSeal, EFFECT_INDEX_0) && m_CurrentJudgement > 0 && pTarget->HasAura(m_CurrentJudgement, EFFECT_INDEX_0))
return false;
// Refresh judgement if needed by forcing paladin bot to cast seal and judgement anew
// But first, unleash current seal if bot can do extra damage to the target in the process
if (m_CurrentJudgement > 0 && !pTarget->HasAura(m_CurrentJudgement, EFFECT_INDEX_0))
{
if (m_bot->HasAura(SEAL_OF_COMMAND, EFFECT_INDEX_0) || m_bot->HasAura(SEAL_OF_RIGHTEOUSNESS, EFFECT_INDEX_0))
if (JUDGEMENT > 0 && !m_bot->HasSpellCooldown(JUDGEMENT) && m_ai->In_Reach(pTarget, JUDGEMENT))
m_ai->CastSpell(JUDGEMENT, *pTarget);
m_CurrentJudgement = 0;
m_CurrentSeal = 0;
return false;
}
// Judgement is still active on target: refresh seal on bot if needed
if (m_CurrentJudgement > 0 && m_CurrentSeal > 0 && !m_bot->HasAura(m_CurrentSeal, EFFECT_INDEX_0))
if (m_CurrentSeal > 0 && !m_bot->HasAura(m_CurrentSeal, EFFECT_INDEX_0) && m_ai->CastSpell(m_CurrentSeal, *m_bot))
return true;
// No judgement on target but bot has seal active: time to judge the target
if (m_CurrentJudgement == 0 && m_CurrentSeal > 0 && m_bot->HasAura(m_CurrentSeal, EFFECT_INDEX_0))
{
if (JUDGEMENT > 0 && !m_bot->HasSpellCooldown(JUDGEMENT) && m_ai->In_Reach(pTarget, JUDGEMENT) && m_ai->CastSpell(JUDGEMENT, *pTarget))
{
if (m_CurrentSeal == SEAL_OF_JUSTICE)
m_CurrentJudgement = JUDGEMENT_OF_JUSTICE;
else if (m_CurrentSeal == SEAL_OF_WISDOM)
m_CurrentJudgement = JUDGEMENT_OF_WISDOM;
else if (m_CurrentSeal == SEAL_OF_THE_CRUSADER)
m_CurrentJudgement = JUDGEMENT_OF_THE_CRUSADER;
else
return false;
// Set current seal to 0 to force the bot to seal him/herself for combat now that the target is judged
m_CurrentSeal = 0;
return true;
}
return false;
}
// Now bot casts seal on him/herself
// No judgement on target: look for best seal to judge target next
// Target already judged: bot will buff him/herself for combat according to spec/orders
uint32 spec = m_bot->GetSpec();
// Bypass spec if combat orders were given
if (m_ai->GetCombatOrder() & PlayerbotAI::ORDERS_HEAL) spec = PALADIN_SPEC_HOLY;
if (m_ai->GetCombatOrder() & PlayerbotAI::ORDERS_TANK) spec = PALADIN_SPEC_PROTECTION;
if (m_ai->GetCombatOrder() & PlayerbotAI::ORDERS_ASSIST) spec = PALADIN_SPEC_RETRIBUTION;
if (m_CurrentJudgement == 0)
{
if (spec == PALADIN_SPEC_HOLY || m_ai->IsHealer())
m_CurrentSeal = SEAL_OF_WISDOM;
else
m_CurrentSeal = SEAL_OF_THE_CRUSADER;
}
else
{
if (spec == PALADIN_SPEC_HOLY)
m_CurrentSeal = SEAL_OF_WISDOM;
else if (spec == PALADIN_SPEC_PROTECTION)
m_CurrentSeal = SEAL_OF_RIGHTEOUSNESS;
else if (spec == PALADIN_SPEC_RETRIBUTION && SEAL_OF_COMMAND > 0)
m_CurrentSeal = SEAL_OF_COMMAND;
// no spec: try Seal of Righteouness
else
m_CurrentSeal = SEAL_OF_RIGHTEOUSNESS;
}
if (m_CurrentSeal > 0 && !m_bot->HasAura(m_CurrentSeal, EFFECT_INDEX_0) && m_ai->CastSpell(m_CurrentSeal, *m_bot))
return true;
return false;
}
CombatManeuverReturns PlayerbotWarriorAI::DoNextCombatManeuverPVE(Unit *pTarget)
{
if (!m_ai) return RETURN_NO_ACTION_ERROR;
if (!m_bot) return RETURN_NO_ACTION_ERROR;
//Unit* pVictim = pTarget->getVictim();
//float fTargetDist = m_bot->GetCombatDistance(pTarget, true);
uint32 spec = m_bot->GetSpec();
//Used to determine if this bot is highest on threat
Unit* newTarget = m_ai->FindAttacker((PlayerbotAI::ATTACKERINFOTYPE) (PlayerbotAI::AIT_VICTIMSELF | PlayerbotAI::AIT_HIGHESTTHREAT), m_bot);
// do shouts, berserker rage, etc...
if (BERSERKER_RAGE > 0 && !m_bot->HasAura(BERSERKER_RAGE, EFFECT_INDEX_0))
m_ai->CastSpell(BERSERKER_RAGE);
else if (BLOODRAGE > 0 && m_ai->GetRageAmount() <= 10)
m_ai->CastSpell(BLOODRAGE);
Creature * pCreature = (Creature*) pTarget;
// Prevent low health humanoid from fleeing with Hamstring
if (pCreature && (m_bot->HasAura(BATTLE_STANCE, EFFECT_INDEX_0) || m_bot->HasAura(BERSERKER_STANCE, EFFECT_INDEX_0)) && pCreature->GetCreatureInfo()->CreatureType == CREATURE_TYPE_HUMANOID && pTarget->GetHealthPercent() < 20 && !pCreature->IsWorldBoss())
{
if (HAMSTRING > 0 && !pTarget->HasAura(HAMSTRING, EFFECT_INDEX_0) && m_ai->CastSpell(HAMSTRING, *pTarget))
return RETURN_CONTINUE;
}
CheckShouts();
switch (spec)
{
case WARRIOR_SPEC_ARMS:
// Execute doesn't scale too well with extra rage and uses up *all* rage preventing use of other skills
if (EXECUTE > 0 && pTarget->GetHealthPercent() < 20 && m_ai->CastSpell (EXECUTE, *pTarget))
return RETURN_CONTINUE;
if (REND > 0 && !pTarget->HasAura(REND, EFFECT_INDEX_0) && m_ai->CastSpell(REND, *pTarget))
return RETURN_CONTINUE;
if (MORTAL_STRIKE > 0 && !m_bot->HasSpellCooldown(MORTAL_STRIKE) && m_ai->CastSpell(MORTAL_STRIKE, *pTarget))
return RETURN_CONTINUE;
// No way to tell if overpower is active (yet), however taste for blood works
if (OVERPOWER > 0 && m_ai->CastSpell(OVERPOWER, *pTarget))
return RETURN_CONTINUE;
if (THUNDER_CLAP > 0 && !pTarget->HasAura(THUNDER_CLAP) && m_ai->CastSpell(THUNDER_CLAP, *pTarget))
return RETURN_CONTINUE;
if (HEROIC_STRIKE > 0 && m_ai->CastSpell(HEROIC_STRIKE, *pTarget))
return RETURN_CONTINUE;
if (SLAM > 0 && m_ai->CastSpell(SLAM, *pTarget))
{
m_ai->SetIgnoreUpdateTime(1.5); // TODO: SetIgnoreUpdateTime takes a uint8 - how will 1.5 work as a value?
return RETURN_CONTINUE;
}
case WARRIOR_SPEC_FURY:
if (EXECUTE > 0 && pTarget->GetHealthPercent() < 20 && m_ai->CastSpell (EXECUTE, *pTarget))
return RETURN_CONTINUE;
if (BLOODTHIRST > 0 && !m_bot->HasSpellCooldown(BLOODTHIRST) && m_ai->CastSpell(BLOODTHIRST, *pTarget))
return RETURN_CONTINUE;
if (WHIRLWIND > 0 && !m_bot->HasSpellCooldown(WHIRLWIND) && m_ai->CastSpell(WHIRLWIND, *pTarget))
return RETURN_CONTINUE;
if (HEROIC_STRIKE > 0 && m_ai->CastSpell(HEROIC_STRIKE, *pTarget))
return RETURN_CONTINUE;
case WARRIOR_SPEC_PROTECTION:
// First check: is bot's target targeting bot?
if (!newTarget)
{
// Cast taunt on bot current target if the mob is targeting someone else
if (m_ai->GetCombatOrder() & PlayerbotAI::ORDERS_TANK && TAUNT > 0 && !m_bot->HasSpellCooldown(TAUNT) && m_ai->CastSpell(TAUNT, *pTarget))
return RETURN_CONTINUE;
}
// If tank is on the verge of dying but "I DON'T WANT TO DIE !!! :'-(("
// TODO: should behaviour (or treshold) be different between elite and normal mobs? We don't want bots to burn such precious cooldown needlessly
if (m_bot->GetHealthPercent() < 10)
{
// Cast Last Stand first because it has lower cooldown
if (LAST_STAND > 0 && !m_bot->HasAura(LAST_STAND, EFFECT_INDEX_0) && m_ai->CastSpell(LAST_STAND, *m_bot))
{
m_ai->TellMaster("I'm using LAST STAND");
return RETURN_CONTINUE;
}
// Cast Shield Wall only if Last Stand is on cooldown and not active
if (SHIELD_WALL > 0 && (m_bot->HasSpellCooldown(LAST_STAND) || LAST_STAND == 0) && !m_bot->HasAura(LAST_STAND, EFFECT_INDEX_0) && !m_bot->HasAura(SHIELD_WALL, EFFECT_INDEX_0) && m_ai->CastSpell(SHIELD_WALL, *m_bot))
{
m_ai->TellMaster("I'm using SHIELD WALL");
return RETURN_CONTINUE;
}
}
if (REVENGE > 0 && !m_bot->HasSpellCooldown(REVENGE))
{
uint8 base = pTarget->RollMeleeOutcomeAgainst(m_bot, BASE_ATTACK);
uint8 off = pTarget->RollMeleeOutcomeAgainst(m_bot, OFF_ATTACK);
if (base == MELEE_HIT_PARRY || base == MELEE_HIT_DODGE || base == MELEE_HIT_BLOCK || off == MELEE_HIT_PARRY || off == MELEE_HIT_DODGE || off == MELEE_HIT_BLOCK)
if (m_ai->CastSpell(REVENGE, *pTarget))
return RETURN_CONTINUE;
}
if (REND > 0 && !pTarget->HasAura(REND, EFFECT_INDEX_0) && m_ai->CastSpell(REND, *pTarget))
return RETURN_CONTINUE;
//Do not waste rage applying Sunder Armor if it is already stacked 5 times
if (SUNDER_ARMOR > 0)
{
if (!pTarget->HasAura(SUNDER_ARMOR) && m_ai->CastSpell(SUNDER_ARMOR, *pTarget)) // no stacks: cast it
return RETURN_CONTINUE;
else
{
SpellAuraHolder* holder = pTarget->GetSpellAuraHolder(SUNDER_ARMOR);
if (holder && (holder->GetStackAmount() < 5) && m_ai->CastSpell(SUNDER_ARMOR, *pTarget))
return RETURN_CONTINUE;
}
}
if (DEMORALIZING_SHOUT > 0 && !pTarget->HasAura(DEMORALIZING_SHOUT, EFFECT_INDEX_0) && m_ai->CastSpell(DEMORALIZING_SHOUT, *pTarget))
return RETURN_CONTINUE;
// TODO: only cast disarm if target has equipment?
if (DISARM > 0 && !pTarget->HasAura(DISARM, EFFECT_INDEX_0) && m_ai->CastSpell(DISARM, *pTarget))
return RETURN_CONTINUE;
// check that target is dangerous (elite) before casting shield block: preserve bot cooldowns
if (SHIELD_BLOCK > 0 && m_ai->IsElite(pTarget) && !m_bot->HasAura(SHIELD_BLOCK, EFFECT_INDEX_0) && m_ai->CastSpell(SHIELD_BLOCK, *m_bot))
return RETURN_CONTINUE;
if (CONCUSSION_BLOW > 0 && !m_bot->HasSpellCooldown(CONCUSSION_BLOW) && m_ai->CastSpell(CONCUSSION_BLOW, *pTarget))
return RETURN_CONTINUE;
if (SHIELD_SLAM > 0 && !m_bot->HasSpellCooldown(SHIELD_SLAM) && m_ai->CastSpell(SHIELD_SLAM, *pTarget))
return RETURN_CONTINUE;
if (HEROIC_STRIKE > 0 && m_ai->CastSpell(HEROIC_STRIKE, *pTarget))
return RETURN_CONTINUE;
/*case WarriorSpellPreventing:
if (SHIELD_BASH > 0 && m_ai->CastSpell(SHIELD_BASH, *pTarget))
return RETURN_CONTINUE;
if (PUMMEL > 0 && m_ai->CastSpell(PUMMEL, *pTarget))
return RETURN_CONTINUE;
break;
case WarriorBattle:
if (DEATH_WISH > 0 && !m_bot->HasAura(DEATH_WISH, EFFECT_INDEX_0) && m_ai->CastSpell(DEATH_WISH, *m_bot))
return RETURN_CONTINUE;
if (RETALIATION > 0 && pVictim == m_bot && m_ai->GetAttackerCount() >= 2 && !m_bot->HasAura(RETALIATION, EFFECT_INDEX_0) && m_ai->CastSpell(RETALIATION, *m_bot))
return RETURN_CONTINUE;
if (SWEEPING_STRIKES > 0 && m_ai->GetAttackerCount() >= 2 && !m_bot->HasAura(SWEEPING_STRIKES, EFFECT_INDEX_0) && m_ai->CastSpell(SWEEPING_STRIKES, *m_bot))
return RETURN_CONTINUE;
if (INTIMIDATING_SHOUT > 0 && m_ai->GetAttackerCount() > 5 && m_ai->CastSpell(INTIMIDATING_SHOUT, *pTarget))
return RETURN_CONTINUE;
if (CHALLENGING_SHOUT > 0 && pVictim != m_bot && m_ai->GetHealthPercent() > 25 && !pTarget->HasAura(MOCKING_BLOW, EFFECT_INDEX_0) && !pTarget->HasAura(CHALLENGING_SHOUT, EFFECT_INDEX_0) && m_ai->CastSpell(CHALLENGING_SHOUT, *pTarget))
return RETURN_CONTINUE;
if (CLEAVE > 0 && m_ai->CastSpell(CLEAVE, *pTarget))
return RETURN_CONTINUE;
if (PIERCING_HOWL > 0 && && m_ai->GetAttackerCount() >= 3 && !pTarget->HasAura(WAR_STOMP, EFFECT_INDEX_0) && !pTarget->HasAura(PIERCING_HOWL, EFFECT_INDEX_0) && !pTarget->HasAura(SHOCKWAVE, EFFECT_INDEX_0) && !pTarget->HasAura(CONCUSSION_BLOW, EFFECT_INDEX_0) && m_ai->CastSpell(PIERCING_HOWL, *pTarget))
return RETURN_CONTINUE;
if (MOCKING_BLOW > 0 && pVictim != m_bot && m_ai->GetHealthPercent() > 25 && !pTarget->HasAura(MOCKING_BLOW, EFFECT_INDEX_0) && !pTarget->HasAura(CHALLENGING_SHOUT, EFFECT_INDEX_0) && m_ai->CastSpell(MOCKING_BLOW, *pTarget))
return RETURN_CONTINUE;
if (m_bot->getRace() == RACE_TAUREN && !pTarget->HasAura(WAR_STOMP, EFFECT_INDEX_0) && !pTarget->HasAura(PIERCING_HOWL, EFFECT_INDEX_0) && !pTarget->HasAura(CONCUSSION_BLOW, EFFECT_INDEX_0) && m_ai->CastSpell(WAR_STOMP, *pTarget))
return RETURN_CONTINUE;
if (m_bot->getRace() == RACE_HUMAN && m_bot->hasUnitState(UNIT_STAT_STUNNED) || m_bot->HasAuraType(SPELL_AURA_MOD_FEAR) || m_bot->HasAuraType(SPELL_AURA_MOD_DECREASE_SPEED) || m_bot->HasAuraType(SPELL_AURA_MOD_CHARM) && m_ai->CastSpell(EVERY_MAN_FOR_HIMSELF, *m_bot))
return RETURN_CONTINUE;
if (m_bot->getRace() == RACE_UNDEAD && m_bot->HasAuraType(SPELL_AURA_MOD_FEAR) || m_bot->HasAuraType(SPELL_AURA_MOD_CHARM) && m_ai->CastSpell(WILL_OF_THE_FORSAKEN, *m_bot))
return RETURN_CONTINUE;
if (m_bot->getRace() == RACE_DWARF && m_bot->HasAuraState(AURA_STATE_DEADLY_POISON) && m_ai->CastSpell(STONEFORM, *m_bot))
return RETURN_CONTINUE;
if (m_bot->getRace() == RACE_GNOME && m_bot->hasUnitState(UNIT_STAT_STUNNED) || m_bot->HasAuraType(SPELL_AURA_MOD_DECREASE_SPEED) && m_ai->CastSpell(ESCAPE_ARTIST, *m_bot))
return RETURN_CONTINUE;
if (m_bot->getRace() == RACE_NIGHTELF && pVictim == m_bot && m_ai->GetHealthPercent() < 25 && !m_bot->HasAura(SHADOWMELD, EFFECT_INDEX_0) && m_ai->CastSpell(SHADOWMELD, *m_bot))
return RETURN_CONTINUE;
if (m_bot->getRace() == RACE_ORC && !m_bot->HasAura(BLOOD_FURY, EFFECT_INDEX_0) && m_ai->CastSpell(BLOOD_FURY, *m_bot))
return RETURN_CONTINUE;
if (m_bot->getRace() == RACE_TROLL && !m_bot->HasAura(BERSERKING, EFFECT_INDEX_0) && m_ai->CastSpell(BERSERKING, *m_bot))
return RETURN_CONTINUE;
break;*/
}
return RETURN_NO_ACTION_OK;
}
bool ChatHandler::HandleDeleteCommand(const char* args, WorldSession* m_session)
{
uint64 guid = m_session->GetPlayer()->GetSelection();
if(guid == 0)
{
SystemMessage(m_session, "No selection.");
return true;
}
Creature* unit = m_session->GetPlayer()->GetMapMgr()->GetCreature(GET_LOWGUID_PART(guid));
if(!unit)
{
SystemMessage(m_session, "You should select a creature.");
return true;
}
if(unit->IsPet())
{
SystemMessage(m_session, "You can't delete a pet.");
return true;
}
sGMLog.writefromsession(m_session, "used npc delete, sqlid %u, creature %s, pos %f %f %f", unit->GetSQL_id(), unit->GetCreatureInfo()->Name, unit->GetPositionX(), unit->GetPositionY(), unit->GetPositionZ());
unit->GetAIInterface()->hideWayPoints(m_session->GetPlayer());
unit->DeleteFromDB();
if(unit->IsSummon())
{
unit->Delete();
}
else
{
if(unit->m_spawn)
{
uint32 cellx = uint32(((_maxX - unit->m_spawn->x) / _cellSize));
uint32 celly = uint32(((_maxY - unit->m_spawn->y) / _cellSize));
if(cellx <= _sizeX && celly <= _sizeY)
{
CellSpawns* sp = unit->GetMapMgr()->GetBaseMap()->GetSpawnsList(cellx, celly);
if(sp != NULL)
{
for(CreatureSpawnList::iterator itr = sp->CreatureSpawns.begin(); itr != sp->CreatureSpawns.end(); ++itr)
if((*itr) == unit->m_spawn)
{
sp->CreatureSpawns.erase(itr);
break;
}
}
delete unit->m_spawn;
unit->m_spawn = NULL;
}
}
unit->RemoveFromWorld(false, true);
}
BlueSystemMessage(m_session, "Creature deleted");
return true;
}
void WorldSession::SendTrainerList(ObjectGuid guid, const std::string& strTitle)
{
DEBUG_LOG("WORLD: SendTrainerList");
Creature* unit = GetPlayer()->GetNPCIfCanInteractWith(guid, UNIT_NPC_FLAG_TRAINER);
if (!unit)
{
DEBUG_LOG("WORLD: SendTrainerList - %s not found or you can't interact with him.", guid.GetString().c_str());
return;
}
// remove fake death
if (GetPlayer()->hasUnitState(UNIT_STAT_DIED))
{ GetPlayer()->RemoveSpellsCausingAura(SPELL_AURA_FEIGN_DEATH); }
// trainer list loaded at check;
if (!unit->IsTrainerOf(_player, true))
{ return; }
CreatureInfo const* ci = unit->GetCreatureInfo();
if (!ci)
{ return; }
TrainerSpellData const* cSpells = unit->GetTrainerSpells();
TrainerSpellData const* tSpells = unit->GetTrainerTemplateSpells();
if (!cSpells && !tSpells)
{
DEBUG_LOG("WORLD: SendTrainerList - Training spells not found for %s", guid.GetString().c_str());
return;
}
uint32 maxcount = (cSpells ? cSpells->spellList.size() : 0) + (tSpells ? tSpells->spellList.size() : 0);
uint32 trainer_type = cSpells && cSpells->trainerType ? cSpells->trainerType : (tSpells ? tSpells->trainerType : 0);
WorldPacket data(SMSG_TRAINER_LIST, 8 + 4 + 4 + maxcount * 38 + strTitle.size() + 1);
data << ObjectGuid(guid);
data << uint32(trainer_type);
size_t count_pos = data.wpos();
data << uint32(maxcount);
// reputation discount
float fDiscountMod = _player->GetReputationPriceDiscount(unit);
bool can_learn_primary_prof = GetPlayer()->GetFreePrimaryProfessionPoints() > 0;
uint32 count = 0;
if (cSpells)
{
for (TrainerSpellMap::const_iterator itr = cSpells->spellList.begin(); itr != cSpells->spellList.end(); ++itr)
{
TrainerSpell const* tSpell = &itr->second;
uint32 triggerSpell = sSpellStore.LookupEntry(tSpell->spell)->EffectTriggerSpell[0];
uint32 reqLevel = 0;
if (!_player->IsSpellFitByClassAndRace(tSpell->spell, &reqLevel))
{ continue; }
// for riding spells, override the levels with the levels from the configuration file
switch (tSpell->spell) {
case 33389: // Apprentice Riding
reqLevel = AccountTypes(sWorld.getConfig(CONFIG_UINT32_MIN_TRAIN_MOUNT_LEVEL));
break;
case 33392: // Journeyman Riding
reqLevel = AccountTypes(sWorld.getConfig(CONFIG_UINT32_MIN_TRAIN_EPIC_MOUNT_LEVEL));
break;
default: // any other spell requirement is read from DBC and the database
reqLevel = tSpell->isProvidedReqLevel ? tSpell->reqLevel : std::max(reqLevel, tSpell->reqLevel);
break;
}
TrainerSpellState state = _player->GetTrainerSpellState(tSpell, reqLevel);
SendTrainerSpellHelper(data, tSpell, triggerSpell, state, fDiscountMod, can_learn_primary_prof, reqLevel);
++count;
}
}
if (tSpells)
{
for (TrainerSpellMap::const_iterator itr = tSpells->spellList.begin(); itr != tSpells->spellList.end(); ++itr)
{
TrainerSpell const* tSpell = &itr->second;
uint32 triggerSpell = sSpellStore.LookupEntry(tSpell->spell)->EffectTriggerSpell[0];
uint32 reqLevel = 0;
if (!_player->IsSpellFitByClassAndRace(tSpell->spell, &reqLevel))
{ continue; }
reqLevel = tSpell->isProvidedReqLevel ? tSpell->reqLevel : std::max(reqLevel, tSpell->reqLevel);
TrainerSpellState state = _player->GetTrainerSpellState(tSpell, reqLevel);
SendTrainerSpellHelper(data, tSpell, triggerSpell, state, fDiscountMod, can_learn_primary_prof, reqLevel);
++count;
}
}
data << strTitle;
data.put<uint32>(count_pos, count);
SendPacket(&data);
}
//////////////////////////////////////////////////////////////
/// This function handles CMSG_GOSSIP_SELECT_OPTION:
//////////////////////////////////////////////////////////////
void WorldSession::HandleGossipSelectOptionOpcode( WorldPacket & recv_data )
{
if(!_player->IsInWorld()) return;
//WorldPacket data;
uint32 option;
uint32 unk24;
uint64 guid;
int8 extra=0;
recv_data >> guid >> unk24 >> option;
sLog.outDetail("WORLD: CMSG_GOSSIP_SELECT_OPTION Option %i Guid %.8X", option, guid );
GossipScript * Script= NULL;
Object * qst_giver= NULL;
uint32 guidtype = GET_TYPE_FROM_GUID(guid);
if(guidtype==HIGHGUID_TYPE_UNIT)
{
Creature *crt = _player->GetMapMgr()->GetCreature(GET_LOWGUID_PART(guid));
if(!crt)
return;
qst_giver=crt;
Script=crt->GetCreatureInfo()?crt->GetCreatureInfo()->gossip_script:NULL;
}
else if(guidtype==HIGHGUID_TYPE_ITEM)
{
Item * pitem = _player->GetItemInterface()->GetItemByGUID(guid);
if(pitem== NULL)
return;
qst_giver=pitem;
Script=pitem->GetProto()->gossip_script;
}
else if(guidtype==HIGHGUID_TYPE_GAMEOBJECT)
{
GameObject *gobj = _player->GetMapMgr()->GetGameObject(GET_LOWGUID_PART(guid));
if(!gobj)
return;
qst_giver=gobj;
Script=gobj->GetInfo()->gossip_script;
}
if(!Script||!qst_giver)
return;
uint32 IntId = 1;
if(_player->CurrentGossipMenu)
{
GossipMenuItem item = _player->CurrentGossipMenu->GetItem(option);
IntId = item.IntId;
extra = item.Extra;
}
if(extra)
{
string str;
if(recv_data.rpos()!=recv_data.wpos())
recv_data >> str;
Script->GossipSelectOption(qst_giver, _player, option, IntId, str.c_str());
}
else
void WorldSession::HandleSpellClick(WorldPacket & recvPacket)
{
CHECK_INWORLD_RETURN
LOG_DETAIL("WORLD: got CMSG_SPELLCLICK packet, data length = %i", recvPacket.size());
if(_player->getDeathState() == CORPSE)
return;
uint64 target_guid; // this will store the guid of the object we are going to use it's spell. There must be a dbc that indicates what spells a unit has
recvPacket >> target_guid;
//we have only 1 example atm for entry : 28605
Unit* target_unit = _player->GetMapMgr()->GetUnit(target_guid);
if(!target_unit)
return;
if( !_player->isInRange( target_unit, MAX_INTERACTION_RANGE ) )
return;
if( target_unit->IsVehicle() ){
if( target_unit->GetVehicleComponent() != NULL )
target_unit->GetVehicleComponent()->AddPassenger( _player );
return;
}
uint32 creature_id = target_unit->GetEntry();
uint32 cast_spell_id = 0;
if(!_player->HasAurasWithNameHash(SPELL_HASH_LIGHTWELL_RENEW) && target_unit->RemoveAura(59907))
{
SpellClickSpell *sp = SpellClickSpellStorage.LookupEntry( creature_id );
if( sp == NULL ){
if( target_unit->IsCreature() ){
Creature *c = TO< Creature* >( target_unit );
sChatHandler.BlueSystemMessage( this, "NPC Id %u ( %s ) has no spellclick spell associated with it.", c->GetProto()->Id, c->GetCreatureInfo()->Name );
LOG_DETAIL("ERROR: Spellclick packet received for creature %u but there is no spell associated with it.", creature_id );
return;
}
}
cast_spell_id = sp->SpellID;
target_unit->CastSpell(_player, cast_spell_id, true);
if(!target_unit->HasAura(59907))
TO_CREATURE(target_unit)->Despawn(0, 0); //IsCreature() check is not needed, refer to r2387 and r3230
return;
}
SpellClickSpell *sp = SpellClickSpellStorage.LookupEntry( creature_id );
if( sp == NULL ){
if( target_unit->IsCreature() ){
Creature *c = TO< Creature* >( target_unit );
sChatHandler.BlueSystemMessage( this, "NPC Id %u ( %s ) has no spellclick spell associated with it.", c->GetProto()->Id, c->GetCreatureInfo()->Name );
LOG_DETAIL("ERROR: Spellclick packet received for creature %u but there is no spell associated with it.", creature_id );
return;
}
}
cast_spell_id = sp->SpellID;
if(cast_spell_id == 0)
return;
SpellEntry* spellInfo = dbcSpell.LookupEntryForced(cast_spell_id);
if(spellInfo == NULL)
return;
Spell* spell = sSpellFactoryMgr.NewSpell(_player, spellInfo, false, NULL);
SpellCastTargets targets(target_guid);
spell->prepare(&targets);
}
void WorldSession::HandleGossipSelectOptionOpcode( WorldPacket & recv_data )
{
CHECK_INWORLD_RETURN;
//WorldPacket data;
uint32 option;
uint32 unk24;
uint64 guid;
bool Coded = false;
uint32 BoxMoney = 0;
std::string BoxMessage;
recv_data >> guid >> unk24 >> option;
DEBUG_LOG("WORLD","CMSG_GOSSIP_SELECT_OPTION Option %i Guid %.8X", option, guid );
GossipScript * Script = NULL;
Object* qst_giver = NULL;
uint32 guidtype = GET_TYPE_FROM_GUID(guid);
if(guidtype==HIGHGUID_TYPE_UNIT)
{
Creature* crt = _player->GetMapMgr()->GetCreature(GET_LOWGUID_PART(guid));
if(!crt)
return;
qst_giver=crt;
Script=crt->GetCreatureInfo()?crt->GetCreatureInfo()->gossip_script:NULL;
}
else if(guidtype==HIGHGUID_TYPE_ITEM)
{
Item* pitem = _player->GetItemInterface()->GetItemByGUID(guid);
if(pitem==NULL)
return;
qst_giver=pitem;
Script=pitem->GetProto()->gossip_script;
}
else if(guidtype==HIGHGUID_TYPE_GAMEOBJECT)
{
GameObject* gobj = _player->GetMapMgr()->GetGameObject(GET_LOWGUID_PART(guid));
if(!gobj)
return;
qst_giver=gobj;
Script=gobj->GetInfo()->gossip_script;
}
if(!Script||!qst_giver)
return;
uint32 IntId = 1;
if(_player->CurrentGossipMenu)
{
GossipMenuItem item = _player->CurrentGossipMenu->GetItem(option);
IntId = item.IntId;
Coded = item.Coded;
}
if(Coded)
{
if(recv_data.rpos()!=recv_data.wpos())
recv_data >> BoxMessage;
Script->GossipSelectOption(qst_giver, _player, option, IntId, BoxMessage.c_str());
}
else
void WorldSession::SendTrainerList( uint64 guid, const std::string& strTitle )
{
DEBUG_LOG( "WORLD: SendTrainerList" );
Creature *unit = GetPlayer()->GetNPCIfCanInteractWith(guid,UNIT_NPC_FLAG_TRAINER);
if (!unit)
{
DEBUG_LOG( "WORLD: SendTrainerList - Unit (GUID: %u) not found or you can't interact with him.", uint32(GUID_LOPART(guid)) );
return;
}
// remove fake death
if(GetPlayer()->hasUnitState(UNIT_STAT_DIED))
GetPlayer()->RemoveSpellsCausingAura(SPELL_AURA_FEIGN_DEATH);
// trainer list loaded at check;
if(!unit->isCanTrainingOf(_player,true))
return;
CreatureInfo const *ci = unit->GetCreatureInfo();
if (!ci)
{
DEBUG_LOG( "WORLD: SendTrainerList - (GUID: %u) NO CREATUREINFO!",GUID_LOPART(guid) );
return;
}
TrainerSpellData const* trainer_spells = unit->GetTrainerSpells();
if(!trainer_spells)
{
DEBUG_LOG( "WORLD: SendTrainerList - Training spells not found for creature (GUID: %u Entry: %u)",
GUID_LOPART(guid), unit->GetEntry());
return;
}
TrainerSpellMap Tspells;
TrainerSpellMap::const_iterator itr;
uint32 id = 0;
for (itr = trainer_spells->spellList.begin(); itr != trainer_spells->spellList.end();itr++)
{
if(!itr->second.spell || _player->HasSpell(itr->second.spell))
continue;
const SpellEntry *spell = sSpellStore.LookupEntry(itr->second.spell);
if(spell && sSpellStore.LookupEntry(spell->EffectTriggerSpell[0]))
{
Tspells[id] = itr->second;
id++;
}
}
WorldPacket data( SMSG_TRAINER_LIST, 8+4+4+Tspells.size()*38 + strTitle.size()+1);
data << uint64(guid);
data << uint32(trainer_spells->trainerType);
size_t count_pos = data.wpos();
data << uint32(Tspells.size());
// reputation discount
float fDiscountMod = _player->GetReputationPriceDiscount(unit);
uint32 count = 0;
for(TrainerSpellMap::const_iterator itr = Tspells.begin(); itr != Tspells.end(); ++itr)
{
TrainerSpell const* tSpell = &itr->second;
uint32 triggerSpell = sSpellStore.LookupEntry(tSpell->spell)->EffectTriggerSpell[0];
if(!_player->IsSpellFitByClassAndRace(triggerSpell))
continue;
++count;
bool primary_prof_first_rank = sSpellMgr.IsPrimaryProfessionFirstRankSpell(triggerSpell);
SpellChainNode const* chain_node = sSpellMgr.GetSpellChainNode(triggerSpell);
//uint32 req_spell = spellmgr.GetSpellChainNode(tSpell->spell)->req;
data << uint32(tSpell->spell);
data << uint8(_player->GetTrainerSpellState(tSpell));
data << uint32(floor(tSpell->spellCost * fDiscountMod));
data << uint32(primary_prof_first_rank ? 1 : 0); // primary prof. learn confirmation dialog [-ZERO] seems it not works in 1.12
data << uint32(primary_prof_first_rank ? 1 : 0); // must be equal prev. field to have learn button in enabled state
data << uint8(tSpell->reqLevel);
data << uint32(tSpell->reqSkill);
data << uint32(tSpell->reqSkillValue);
data << uint32(chain_node ? (chain_node->prev ? chain_node->prev : chain_node->req) : 0);
data << uint32(chain_node && chain_node->prev ? chain_node->req : 0);
data << uint32(0);
}
data << strTitle;
data.put<uint32>(count_pos,count);
SendPacket( &data );
Tspells.clear();
}
void WorldSession::SendTrainerList(uint64 guid, const std::string& strTitle)
{
sLog->outDebug(LOG_FILTER_NETWORKIO, "WORLD: SendTrainerList");
Creature *unit = GetPlayer()->GetNPCIfCanInteractWith(guid,UNIT_NPC_FLAG_TRAINER);
if (!unit)
{
sLog->outDebug(LOG_FILTER_NETWORKIO, "WORLD: SendTrainerList - Unit (GUID: %u) not found or you can not interact with him.", uint32(GUID_LOPART(guid)));
return;
}
// remove fake death
if (GetPlayer()->HasUnitState(UNIT_STAT_DIED))
GetPlayer()->RemoveAurasByType(SPELL_AURA_FEIGN_DEATH);
// trainer list loaded at check;
if (!unit->isCanTrainingOf(_player,true))
return;
CreatureInfo const *ci = unit->GetCreatureInfo();
if (!ci)
{
sLog->outDebug(LOG_FILTER_NETWORKIO, "WORLD: SendTrainerList - (GUID: %u) NO CREATUREINFO!",GUID_LOPART(guid));
return;
}
TrainerSpellData const* trainer_spells = unit->GetTrainerSpells();
if (!trainer_spells)
{
sLog->outDebug(LOG_FILTER_NETWORKIO, "WORLD: SendTrainerList - Training spells not found for creature (GUID: %u Entry: %u)",
GUID_LOPART(guid), unit->GetEntry());
return;
}
WorldPacket data(SMSG_TRAINER_LIST, 8 + 4 + 4 + trainer_spells->spellList.size() * 38 + strTitle.size() + 1);
data << guid;
data << uint32(trainer_spells->trainerType);
data << uint32(0xF);
size_t count_pos = data.wpos();
data << uint32(trainer_spells->spellList.size());
// reputation discount
float fDiscountMod = _player->GetReputationPriceDiscount(unit);
bool can_learn_primary_prof = GetPlayer()->GetFreePrimaryProfessionPoints() > 0;
uint32 count = 0;
for (TrainerSpellMap::const_iterator itr = trainer_spells->spellList.begin(); itr != trainer_spells->spellList.end(); ++itr)
{
TrainerSpell const* tSpell = &itr->second;
bool valid = true;
if (!valid)
continue;
TrainerSpellState state = _player->GetTrainerSpellState(tSpell);
SpellChainNode const* chain_node = sSpellMgr->GetSpellChainNode(tSpell->learnedSpell[1]);
data << uint32(tSpell->spell); // learned spell (or cast-spell in profession case)
data << uint8(state);
data << uint32(floor(tSpell->spellCost * fDiscountMod));
data << uint8(tSpell->reqLevel);
data << uint32(tSpell->reqSkill);
data << uint32(tSpell->reqSkillValue);
data << uint32(0); // 4.0.3
data << uint32(0);
data << uint32(0);
data << uint32(0);
//prev + req or req + 0
uint8 maxReq = 0;
for (uint8 i = 0; i < MAX_SPELL_EFFECTS ; ++i)
{
if (!tSpell->learnedSpell[i])
continue;
if (SpellChainNode const* chain_node = sSpellMgr->GetSpellChainNode(tSpell->learnedSpell[i]))
{
if (chain_node->prev)
{
data << uint32(chain_node->prev);
++maxReq;
}
}
if (maxReq == 3)
break;
SpellsRequiringSpellMapBounds spellsRequired = sSpellMgr->GetSpellsRequiredForSpellBounds(tSpell->learnedSpell[i]);
for (SpellsRequiringSpellMap::const_iterator itr2 = spellsRequired.first; itr2 != spellsRequired.second && maxReq < 3; ++itr2)
{
data << uint32(itr2->second);
++maxReq;
}
if (maxReq == 3)
break;
}
while (maxReq < 3)
{
data << uint32(0);
++maxReq;
}
++count;
}
data << strTitle;
data.put<uint32>(count_pos,count);
SendPacket(&data);
}
//npc tame handling
static bool HandleNpcTameCommand (ChatHandler* handler, const char* /*args*/)
{
Creature *creatureTarget = handler->getSelectedCreature();
if (!creatureTarget || creatureTarget->isPet())
{
handler->PSendSysMessage(LANG_SELECT_CREATURE);
handler->SetSentErrorMessage(true);
return false;
}
Player *player = handler->GetSession()->GetPlayer();
if (player->GetPetGUID())
{
handler->SendSysMessage(LANG_YOU_ALREADY_HAVE_PET);
handler->SetSentErrorMessage(true);
return false;
}
CreatureInfo const* cInfo = creatureTarget->GetCreatureInfo();
if (!cInfo->isTameable(player->CanTameExoticPets()))
{
handler->PSendSysMessage(LANG_CREATURE_NON_TAMEABLE, cInfo->Entry);
handler->SetSentErrorMessage(true);
return false;
}
// Everything looks OK, create new pet
Pet* pet = player->CreateTamedPetFrom(creatureTarget);
if (!pet)
{
handler->PSendSysMessage(LANG_CREATURE_NON_TAMEABLE, cInfo->Entry);
handler->SetSentErrorMessage(true);
return false;
}
// place pet before player
float x, y, z;
player->GetClosePoint(x, y, z, creatureTarget->GetObjectSize(), CONTACT_DISTANCE);
pet->Relocate(x, y, z, M_PI - player->GetOrientation());
// set pet to defensive mode by default (some classes can't control controlled pets in fact).
pet->SetReactState(REACT_DEFENSIVE);
// calculate proper level
uint8 level = (creatureTarget->getLevel() < (player->getLevel() - 5)) ? (player->getLevel() - 5) : creatureTarget->getLevel();
// prepare visual effect for levelup
pet->SetUInt32Value(UNIT_FIELD_LEVEL, level - 1);
// add to world
pet->GetMap()->Add(pet->ToCreature());
// visual effect for levelup
pet->SetUInt32Value(UNIT_FIELD_LEVEL, level);
// caster have pet now
player->SetMinion(pet, true, PET_SLOT_UNK_SLOT);
pet->SavePetToDB(PET_SLOT_ACTUAL_PET_SLOT);
player->PetSpellInitialize();
return true;
}
CombatManeuverReturns PlayerbotRogueAI::DoNextCombatManeuverPVE(Unit *pTarget)
{
if (!pTarget) return RETURN_NO_ACTION_ERROR;
if (!m_ai) return RETURN_NO_ACTION_ERROR;
if (!m_bot) return RETURN_NO_ACTION_ERROR;
Unit* pVictim = pTarget->getVictim();
bool meleeReach = m_bot->CanReachWithMeleeAttack(pTarget);
// TODO: make this work better...
/*if (pVictim)
{
if( pVictim!=m_bot && !m_bot->hasUnitState(UNIT_STAT_FOLLOW) && !pTarget->isInBackInMap(m_bot,10) ) {
m_ai->TellMaster( "getting behind target" );
m_bot->GetMotionMaster()->Clear( true );
m_bot->GetMotionMaster()->MoveFollow( pTarget, 1, 2*M_PI );
}
else if( pVictim==m_bot && m_bot->hasUnitState(UNIT_STAT_FOLLOW) )
{
m_ai->TellMaster( "chasing attacking target" );
m_bot->GetMotionMaster()->Clear( true );
m_bot->GetMotionMaster()->MoveChase( pTarget );
}
}*/
// If bot is stealthed: pre-combat actions
if (m_bot->HasAura(STEALTH, EFFECT_INDEX_0))
{
if (PICK_POCKET > 0 && m_ai->In_Reach(pTarget,PICK_POCKET) && (pTarget->GetCreatureTypeMask() & CREATURE_TYPEMASK_HUMANOID_OR_UNDEAD) != 0 && m_ai->PickPocket(pTarget))
return RETURN_CONTINUE;
if (PREMEDITATION > 0 && m_ai->CastSpell(PREMEDITATION, *pTarget))
return RETURN_CONTINUE;
if (AMBUSH > 0 && !pTarget->HasInArc(M_PI_F, m_bot) && m_ai->CastSpell(AMBUSH, *pTarget))
return RETURN_CONTINUE;
if (CHEAP_SHOT > 0 && !pTarget->HasAura(CHEAP_SHOT, EFFECT_INDEX_0) && m_ai->CastSpell(CHEAP_SHOT, *pTarget))
return RETURN_CONTINUE;
if (GARROTE > 0 && !pTarget->HasInArc(M_PI_F, m_bot) && m_ai->CastSpell(GARROTE, *pTarget))
return RETURN_CONTINUE;
// No appropriate action found, remove stealth
m_bot->RemoveSpellsCausingAura(SPELL_AURA_MOD_STEALTH);
return RETURN_CONTINUE;
}
//Used to determine if this bot has highest threat
Unit* newTarget = m_ai->FindAttacker((PlayerbotAI::ATTACKERINFOTYPE) (PlayerbotAI::AIT_VICTIMSELF | PlayerbotAI::AIT_HIGHESTTHREAT), m_bot);
if (newTarget && !(m_ai->GetCombatOrder() & PlayerbotAI::ORDERS_TANK) && !m_ai->IsNeutralized(newTarget)) // TODO: && party has a tank
{
// Aggroed by an elite
if (m_ai->IsElite(newTarget))
{
if (VANISH > 0 && m_ai->GetHealthPercent() <= 20 && !m_bot->HasSpellCooldown(VANISH) && !m_bot->HasAura(FEINT, EFFECT_INDEX_0) && m_ai->CastSpell(VANISH))
{
m_ai->SetIgnoreUpdateTime(11);
return RETURN_CONTINUE;
}
if (BLIND > 0 && m_ai->GetHealthPercent() <= 30 && m_ai->HasSpellReagents(BLIND) && !newTarget->HasAura(BLIND, EFFECT_INDEX_0) && m_ai->CastSpell(BLIND, *newTarget))
return RETURN_CONTINUE;
if (EVASION > 0 && m_ai->GetHealthPercent() <= 35 && !m_bot->HasSpellCooldown(EVASION) && !m_bot->HasAura(EVASION, EFFECT_INDEX_0) && m_ai->CastSpell(EVASION))
return RETURN_CONTINUE;
if (FEINT > 0 && !m_bot->HasSpellCooldown(FEINT) && m_ai->CastSpell(FEINT, *newTarget))
return RETURN_CONTINUE;
if (PREPARATION > 0 && !m_bot->HasSpellCooldown(PREPARATION) && (m_bot->HasSpellCooldown(EVASION) || m_bot->HasSpellCooldown(VANISH)) && m_ai->CastSpell(PREPARATION))
return RETURN_CONTINUE;
}
// Default: Gouge the target
if (GOUGE > 0 && !pTarget->HasAura(GOUGE, EFFECT_INDEX_0) && m_ai->CastSpell(GOUGE, *newTarget))
return RETURN_CONTINUE;
}
// Buff bot with cold blood if available
// This buff is done after the stealth and aggro management code because we don't want to give starting extra damage (= extra threat) to a bot
// as it is obviously not soloing his/her target
if (COLD_BLOOD > 0 && !m_bot->HasAura(COLD_BLOOD, EFFECT_INDEX_0) && !m_bot->HasSpellCooldown(COLD_BLOOD) && m_ai->CastSpell(COLD_BLOOD, *m_bot))
return RETURN_CONTINUE;
// Rogue like behaviour ^^
/*if (VANISH > 0 && GetMaster()->isDead()) { //Causes the server to crash :( removed for now.
m_bot->AttackStop();
m_bot->RemoveAllAttackers();
m_ai->CastSpell(VANISH);
//m_bot->RemoveAllSpellCooldown();
m_ai->TellMaster("AttackStop, CombatStop, Vanish");
}*/
// we fight in melee, target is not in range, skip the next part!
if (!meleeReach)
return RETURN_CONTINUE;
// If target is elite and wounded: use adrenaline rush to finish it quicker
if (ADRENALINE_RUSH > 0 && m_ai->IsElite(pTarget) && pTarget->GetHealthPercent() < 50 && !m_bot->HasAura(ADRENALINE_RUSH, EFFECT_INDEX_0) && !m_bot->HasSpellCooldown(ADRENALINE_RUSH) && m_ai->CastSpell(ADRENALINE_RUSH, *m_bot))
return RETURN_CONTINUE;
// Bot's target is casting a spell: try to interrupt it
if (pTarget->IsNonMeleeSpellCasted(true))
{
if (KIDNEY_SHOT > 0 && !m_bot->HasSpellCooldown(KIDNEY_SHOT) && m_bot->GetComboPoints() >= 1 && m_ai->CastSpell(KIDNEY_SHOT, *pTarget))
return RETURN_CONTINUE;
else if (KICK > 0 && !m_bot->HasSpellCooldown(KICK) && m_ai->CastSpell(KICK, *pTarget))
return RETURN_CONTINUE;
}
// Finishing moves
// Bot will try to activate finishing move at 4 combos points (5 combos points case will be bonus)
// TODO : define combo points treshold depending on target rank and HP
if (m_bot->GetComboPoints() >= 4)
{
Creature * pCreature = (Creature*) pTarget;
// wait for energy
if (m_ai->GetEnergyAmount() < 25 && (KIDNEY_SHOT || SLICE_DICE || EXPOSE_ARMOR || RUPTURE))
return RETURN_NO_ACTION_OK;
// If target is elite Slice & Dice is a must have
if (SLICE_DICE > 0 && m_ai->IsElite(pTarget) && !m_bot->HasAura(SLICE_DICE, EFFECT_INDEX_1) && m_ai->CastSpell(SLICE_DICE, *pTarget)) // 25 energy (checked above)
return RETURN_CONTINUE;
// If target is a warrior or paladin type (high armor): expose its armor
if (EXPOSE_ARMOR > 0 && pCreature && pCreature->GetCreatureInfo()->UnitClass != 8 && !pTarget->HasAura(EXPOSE_ARMOR, EFFECT_INDEX_0) && m_ai->CastSpell(EXPOSE_ARMOR, *pTarget)) // 25 energy (checked above)
return RETURN_CONTINUE;
if (RUPTURE > 0 && !pTarget->HasAura(RUPTURE, EFFECT_INDEX_0) && m_ai->CastSpell(RUPTURE, *pTarget)) // 25 energy (checked above)
return RETURN_CONTINUE;
// default combo action or if other combo action is unavailable/failed
// wait for energy
if (m_ai->GetEnergyAmount() < 35 && EVISCERATE > 0)
return RETURN_NO_ACTION_OK;
if (EVISCERATE > 0 && m_ai->CastSpell(EVISCERATE, *pTarget))
return RETURN_CONTINUE;
// failed for some (non-energy related) reason, fall through to normal attacks to maximize DPS
}
// Combo generating or damage increasing attacks
if (HEMORRHAGE > 0 && !pTarget->HasAura(HEMORRHAGE, EFFECT_INDEX_2) && m_ai->CastSpell(HEMORRHAGE, *pTarget))
return RETURN_CONTINUE;
if (BACKSTAB > 0 && !pTarget->HasInArc(M_PI_F, m_bot) && m_ai->CastSpell(BACKSTAB, *pTarget))
return RETURN_CONTINUE;
if (GHOSTLY_STRIKE > 0 && !m_bot->HasSpellCooldown(GHOSTLY_STRIKE) && m_ai->CastSpell(GHOSTLY_STRIKE, *pTarget))
return RETURN_CONTINUE;
if (SINISTER_STRIKE > 0 && m_ai->CastSpell(SINISTER_STRIKE, *pTarget))
return RETURN_CONTINUE;
return RETURN_NO_ACTION_OK;
} // end DoNextCombatManeuver
/*
CLASS TRAINER
*/
void Arcemu::Gossip::ClassTrainer::OnHello(Object* pObject, Player* Plr)
{
Creature* trainer = TO_CREATURE(pObject);
uint32 Text = objmgr.GetGossipTextForNpc(trainer->GetEntry());
if(NpcTextStorage.LookupEntry(Text) == NULL)
Text = Gossip::DEFAULT_TXTINDEX;
Gossip::Menu menu(pObject->GetGUID(), Text, Plr->GetSession()->language);
uint8 playerclass = Plr->getClass();
::Trainer* traininfo = trainer->GetTrainer();
if(traininfo != NULL) //Seems to happen
{
if(traininfo->RequiredClass != playerclass)
menu.setTextID(traininfo->Cannot_Train_GossipTextId);
else
{
menu.setTextID(traininfo->Can_Train_Gossip_TextId);
string itemname = Plr->GetSession()->LocalizedWorldSrv(Gossip::ISEEK);
string name = trainer->GetCreatureInfo()->Name;
string::size_type pos = name.find(" "); // only take first name
if(pos != string::npos)
name = name.substr(0, pos);
switch(playerclass)
{
case ::MAGE:
itemname += string(Plr->GetSession()->LocalizedWorldSrv(Gossip::MAGE));
break;
case ::SHAMAN:
itemname += string(Plr->GetSession()->LocalizedWorldSrv(Gossip::SHAMAN));
break;
case ::WARRIOR:
itemname += string(Plr->GetSession()->LocalizedWorldSrv(Gossip::WARRIOR));
break;
case ::PALADIN:
itemname += string(Plr->GetSession()->LocalizedWorldSrv(Gossip::PALADIN));
break;
case ::WARLOCK:
itemname += string(Plr->GetSession()->LocalizedWorldSrv(Gossip::WARLOCK));
break;
case ::HUNTER:
itemname += string(Plr->GetSession()->LocalizedWorldSrv(Gossip::HUNTER));
break;
case ::ROGUE:
itemname += string(Plr->GetSession()->LocalizedWorldSrv(Gossip::ROGUE));
break;
case ::DRUID:
itemname += string(Plr->GetSession()->LocalizedWorldSrv(Gossip::DRUID));
break;
case ::PRIEST:
itemname += string(Plr->GetSession()->LocalizedWorldSrv(Gossip::PRIEST));
break;
case ::DEATHKNIGHT:
itemname += string(Plr->GetSession()->LocalizedWorldSrv(Gossip::DEATHKNIGHT));
break;
default:
break;
}
itemname += " ";
itemname += string(Plr->GetSession()->LocalizedWorldSrv(Gossip::TRAINING)) + ", " + name + ".";
menu.AddItem(Gossip::ICON_TRAINER, itemname.c_str(), 1);
//talent reset option.
if(trainer->getLevel() > Gossip::TRAINER_TALENTRESET_LVLIMIT && Plr->getLevel() > Gossip::PLAYER_TALENTRESET_LVLIMIT && trainer->GetTrainer()->RequiredClass == playerclass)
{
menu.AddItem(Gossip::ICON_CHAT, Plr->GetSession()->LocalizedWorldSrv(Gossip::CLASSTRAINER_TALENTRESET), 2);
//dual speciliazation option.
if(Plr->getLevel() >= Gossip::PLAYER_DUALTALENT_LVLIMIT && Plr->m_talentSpecsCount < 2)
menu.AddItem(Gossip::ICON_CHAT, "Learn about Dual Talent Specialization.", 4);
}
}
}
sQuestMgr.FillQuestMenu(trainer, Plr, menu);
menu.StackSend<256>(Plr);
}
// Spell Target Handling for type 6 and 77: Single Target Enemy (grep thinks 77 fits in 6)
void Spell::SpellTargetSingleTargetEnemy(uint32 i, uint32 j)
{
if(!m_caster->IsInWorld())
return;
Unit* pTarget = m_caster->GetMapMgr()->GetUnit(m_targets.m_unitTarget);
if(!pTarget)
return;
if(m_spellInfo->TargetCreatureType && pTarget->GetTypeId()==TYPEID_UNIT)
{
Creature* cr = TO_CREATURE( pTarget );
if( cr == NULL )
return;
if( cr->GetCreatureInfo() )
if(!(1<<(cr->GetCreatureInfo()->Type-1) & m_spellInfo->TargetCreatureType))
return;
}
if(p_caster && pTarget != p_caster)
{
// this is mostly used for things like duels
if(pTarget->IsPlayer() && !isAttackable(p_caster, pTarget, false))
{
cancastresult = SPELL_FAILED_BAD_TARGETS;
return;
}
}
// magnet!!!!!
if( pTarget->IsPlayer() && TO_PLAYER(pTarget)->m_magnetAura != NULL && m_magnetTarget == NULL )
{
if(!m_spellInfo->is_melee_spell && GetType() == SPELL_DMG_TYPE_MAGIC )
{
// redirect it to the magnet
m_magnetTarget = TO_PLAYER(pTarget)->m_magnetAura->GetUnitCaster();
// clear the magnet aura
TO_PLAYER(pTarget)->m_magnetAura->Remove();
}
}
if( m_magnetTarget != NULL )
{
// if the target exists, shoot it at him.
if( m_magnetTarget != NULL && m_magnetTarget->IsInWorld() && !m_magnetTarget->isDead() )
pTarget = m_magnetTarget;
}
_AddTarget(pTarget, i);
if(m_spellInfo->EffectChainTarget[i])
{
uint32 jumps=m_spellInfo->EffectChainTarget[i]-1;
float range=GetMaxRange(dbcSpellRange.LookupEntry(m_spellInfo->rangeIndex));//this is probably wrong
range*=range;
unordered_set<Object*>::iterator itr;
for( itr = m_caster->GetInRangeSetBegin(); itr != m_caster->GetInRangeSetEnd(); ++itr )
{
if((*itr)->GetGUID()==m_targets.m_unitTarget)
continue;
if( !((*itr)->IsUnit()) || !TO_UNIT(*itr)->isAlive())
continue;
if(IsInrange(m_caster->GetPositionX(),m_caster->GetPositionY(),m_caster->GetPositionZ(),(*itr),range))
{
if(isAttackable(u_caster,TO_UNIT(*itr)))
{
_AddTarget(TO_UNIT(*itr), i);
if(!--jumps)
return;
}
}
}
}
}
void PetAI::UpdateAI(const uint32 diff)
{
if (!m_unit->isAlive())
return;
Creature* creature = (m_unit->GetTypeId() == TYPEID_UNIT) ? static_cast<Creature*>(m_unit) : nullptr;
Pet* pet = (creature && creature->IsPet()) ? static_cast<Pet*>(m_unit) : nullptr;
Unit* owner = m_unit->GetCharmerOrOwner();
if (!owner)
return;
Unit* victim = (pet && pet->GetModeFlags() & PET_MODE_DISABLE_ACTIONS) ? nullptr : m_unit->getVictim();
if (m_updateAlliesTimer <= diff)
// UpdateAllies self set update timer
UpdateAllies();
else
m_updateAlliesTimer -= diff;
if (inCombat && !victim)
{
m_unit->AttackStop(true, true);
inCombat = false;
}
CharmInfo* charminfo = m_unit->GetCharmInfo();
MANGOS_ASSERT(charminfo);
if (charminfo->GetIsRetreating())
{
if (!owner->IsWithinDistInMap(m_unit, (PET_FOLLOW_DIST * 2)))
{
if (!m_unit->hasUnitState(UNIT_STAT_FOLLOW))
m_unit->GetMotionMaster()->MoveFollow(owner, PET_FOLLOW_DIST, PET_FOLLOW_ANGLE);
return;
}
else
charminfo->SetIsRetreating();
}
else if (charminfo->GetSpellOpener() != 0) // have opener stored
{
uint32 minRange = charminfo->GetSpellOpenerMinRange();
if (!(victim = m_unit->getVictim())
|| (minRange != 0 && m_unit->IsWithinDistInMap(victim, minRange)))
charminfo->SetSpellOpener();
else if (m_unit->IsWithinDistInMap(victim, charminfo->GetSpellOpenerMaxRange())
&& m_unit->IsWithinLOSInMap(victim))
{
// stop moving
m_unit->clearUnitState(UNIT_STAT_MOVING);
// auto turn to target
m_unit->SetInFront(victim);
if (victim->GetTypeId() == TYPEID_PLAYER)
m_unit->SendCreateUpdateToPlayer((Player*)victim);
if (owner->GetTypeId() == TYPEID_PLAYER)
m_unit->SendCreateUpdateToPlayer((Player*)owner);
uint32 spell_id = charminfo->GetSpellOpener();
SpellEntry const* spellInfo = sSpellTemplate.LookupEntry<SpellEntry>(spell_id);
Spell* spell = new Spell(m_unit, spellInfo, false);
SpellCastResult result = spell->CheckPetCast(victim);
if (result == SPELL_CAST_OK)
{
if (creature)
creature->AddCreatureSpellCooldown(spell_id);
spell->SpellStart(&(spell->m_targets));
}
else
delete spell;
charminfo->SetSpellOpener();
}
else
return;
}
// Auto cast (casted only in combat or persistent spells in any state)
else if (!m_unit->IsNonMeleeSpellCasted(false))
{
typedef std::vector<std::pair<Unit*, Spell*> > TargetSpellList;
TargetSpellList targetSpellStore;
if (pet)
{
for (uint8 i = 0; i < pet->GetPetAutoSpellSize(); ++i)
{
uint32 spellID = pet->GetPetAutoSpellOnPos(i);
if (!spellID)
continue;
SpellEntry const* spellInfo = sSpellTemplate.LookupEntry<SpellEntry>(spellID);
if (!spellInfo)
continue;
if (m_unit->GetCharmInfo() && m_unit->GetCharmInfo()->GetGlobalCooldownMgr().HasGlobalCooldown(spellInfo))
continue;
// ignore some combinations of combat state and combat/non combat spells
if (!inCombat)
{
// ignore attacking spells, and allow only self/around spells
if (!IsPositiveSpell(spellInfo->Id))
continue;
// non combat spells allowed
// only pet spells have IsNonCombatSpell and not fit this requirements:
// Consume Shadows, Lesser Invisibility, so ignore checks for its
if (!IsNonCombatSpell(spellInfo))
{
int32 duration = GetSpellDuration(spellInfo);
int32 cooldown = GetSpellRecoveryTime(spellInfo);
// allow only spell not on cooldown
if (cooldown != 0 && duration < cooldown)
continue;
// not allow instant kill auto casts as full health cost
if (IsSpellHaveEffect(spellInfo, SPELL_EFFECT_INSTAKILL))
continue;
}
}
// just ignore non-combat spells
else if (IsNonCombatSpell(spellInfo))
continue;
Spell* spell = new Spell(m_unit, spellInfo, false);
if (inCombat && !m_unit->hasUnitState(UNIT_STAT_FOLLOW) && spell->CanAutoCast(victim))
{
targetSpellStore.push_back(TargetSpellList::value_type(victim, spell));
continue;
}
else
{
bool spellUsed = false;
for (GuidSet::const_iterator tar = m_AllySet.begin(); tar != m_AllySet.end(); ++tar)
{
Unit* Target = m_unit->GetMap()->GetUnit(*tar);
// only buff targets that are in combat, unless the spell can only be cast while out of combat
if (!Target)
continue;
if (spell->CanAutoCast(Target))
{
targetSpellStore.push_back(TargetSpellList::value_type(Target, spell));
spellUsed = true;
break;
}
}
if (!spellUsed)
delete spell;
}
}
}
// found units to cast on to
if (!targetSpellStore.empty())
{
uint32 index = urand(0, targetSpellStore.size() - 1);
Spell* spell = targetSpellStore[index].second;
Unit* target = targetSpellStore[index].first;
targetSpellStore.erase(targetSpellStore.begin() + index);
SpellCastTargets targets;
targets.setUnitTarget(target);
if (!m_unit->HasInArc(M_PI_F, target))
{
m_unit->SetInFront(target);
if (target->GetTypeId() == TYPEID_PLAYER)
m_unit->SendCreateUpdateToPlayer((Player*)target);
if (owner && owner->GetTypeId() == TYPEID_PLAYER)
m_unit->SendCreateUpdateToPlayer((Player*)owner);
}
if (creature)
creature->AddCreatureSpellCooldown(spell->m_spellInfo->Id);
spell->SpellStart(&targets);
}
// deleted cached Spell objects
for (TargetSpellList::const_iterator itr = targetSpellStore.begin(); itr != targetSpellStore.end(); ++itr)
delete itr->second;
}
// Stop here if casting spell (No melee and no movement)
if (m_unit->IsNonMeleeSpellCasted(false))
return;
// we may get our actions disabled during spell casting, so do entire recheck for victim
victim = (pet && pet->GetModeFlags() & PET_MODE_DISABLE_ACTIONS) ? nullptr : m_unit->getVictim();
if (victim)
{
// i_pet.getVictim() can't be used for check in case stop fighting, i_pet.getVictim() clear at Unit death etc.
// This is needed for charmed creatures, as once their target was reset other effects can trigger threat
if (!victim->isTargetableForAttack())
{
DEBUG_FILTER_LOG(LOG_FILTER_AI_AND_MOVEGENSS, "PetAI (guid = %u) is stopping attack.", m_unit->GetGUIDLow());
m_unit->CombatStop();
inCombat = false;
return;
}
// if pet misses its target, it will also be the first in threat list
if ((!creature || !(creature->GetCreatureInfo()->ExtraFlags & CREATURE_EXTRA_FLAG_NO_MELEE))
&& m_unit->CanReachWithMeleeAttack(victim))
{
if (!m_unit->HasInArc(2 * M_PI_F / 3, victim))
{
m_unit->SetInFront(victim);
if (victim->GetTypeId() == TYPEID_PLAYER)
m_unit->SendCreateUpdateToPlayer((Player*)victim);
if (owner && owner->GetTypeId() == TYPEID_PLAYER)
m_unit->SendCreateUpdateToPlayer((Player*)owner);
}
DoMeleeAttackIfReady();
}
else if (!m_unit->hasUnitState(UNIT_STAT_MOVING))
AttackStart(victim);
}
else if (owner)
{
CharmInfo* charmInfo = m_unit->GetCharmInfo();
if (owner->isInCombat() && !(charmInfo && charmInfo->HasReactState(REACT_PASSIVE)))
AttackStart(owner->getAttackerForHelper());
else
{
if (charmInfo && charmInfo->HasCommandState(COMMAND_STAY))
{
//if stay command is set but we don't have stay pos set then we need to establish current pos as stay position
if (!charminfo->IsStayPosSet())
charminfo->SetStayPosition(true);
float stayPosX = charminfo->GetStayPosX();
float stayPosY = charminfo->GetStayPosY();
float stayPosZ = charminfo->GetStayPosZ();
if (m_unit->GetPositionX() == stayPosX
&& m_unit->GetPositionY() == stayPosY
&& m_unit->GetPositionZ() == stayPosZ)
{
float StayPosO = charminfo->GetStayPosO();
if (m_unit->hasUnitState(UNIT_STAT_MOVING))
{
m_unit->GetMotionMaster()->Clear(false);
m_unit->GetMotionMaster()->MoveIdle();
}
else if (m_unit->GetOrientation() != StayPosO)
m_unit->SetOrientation(StayPosO);
}
else
m_unit->GetMotionMaster()->MovePoint(0, stayPosX, stayPosY, stayPosZ, false);
}
else if (m_unit->hasUnitState(UNIT_STAT_FOLLOW))
{
if (owner->IsWithinDistInMap(m_unit, PET_FOLLOW_DIST))
{
m_unit->GetMotionMaster()->Clear(false);
m_unit->GetMotionMaster()->MoveIdle();
}
}
else if (charmInfo && charmInfo->HasCommandState(COMMAND_FOLLOW)
&& !owner->IsWithinDistInMap(m_unit, (PET_FOLLOW_DIST * 2)))
m_unit->GetMotionMaster()->MoveFollow(owner, PET_FOLLOW_DIST, PET_FOLLOW_ANGLE);
}
}
}
