bool ChatHandler::HandleWPStandStateCommand(const char* args, WorldSession *m_session)
{
uint64 guid = m_session->GetPlayer()->GetSelection();
if (guid == 0)
{
SystemMessage(m_session, "No selection.");
return true;
}
if(GET_TYPE_FROM_GUID(guid) != HIGHGUID_TYPE_WAYPOINT)
{
SystemMessage(m_session, "You should select a Waypoint.");
return true;
}
Player* pPlayer = m_session->GetPlayer();
AIInterface* ai = pPlayer->waypointunit;
if(!ai || !ai->GetUnit())
{
SystemMessage(m_session, "Invalid Creature, please select another one.");
return true;
}
uint32 StandState = 0;
std::stringstream ss;
uint32 wpid = GUID_LOPART(guid);
if(wpid)
{
WayPoint* wp = ai->getWayPoint(wpid);
if(wp)
{
char* pBackwards = strtok((char*)args, " ");
uint32 Backwards = (pBackwards)? atoi(pBackwards) : 0;
char* pStandState = strtok(NULL, " ");
StandState = (pStandState)? atoi(pStandState) : 0;
StandState = StandState > 8 ? 0 : StandState;
if(Backwards)
{
if(wp->backwardInfo == NULL)
wp->backwardInfo = new ConditionalData();
wp->backwardInfo->StandState = StandState;
ss << "Backward StandState for Waypoint " << wpid << " is now " << StandState;
}
else
{
if(wp->forwardInfo == NULL)
wp->forwardInfo = new ConditionalData();
wp->forwardInfo->StandState = StandState;
ss << "Forward StandState for Waypoint " << wpid << " is now " << StandState;
}
//save wp
ai->saveWayPoints();
}
SystemMessage(m_session, ss.str().c_str());
}
else
SystemMessage(m_session, "Invalid Waypoint.");
return true;
}
Object* MapMgr::_GetObject(const uint64 & guid)
{
if(!guid)
return NULL;
switch(GET_TYPE_FROM_GUID(guid))
{
case HIGHGUID_TYPE_GAMEOBJECT:
return GetGameObject(GET_LOWGUID_PART(guid));
break;
case HIGHGUID_TYPE_UNIT:
case HIGHGUID_TYPE_VEHICLE:
return GetCreature(GET_LOWGUID_PART(guid));
break;
case HIGHGUID_TYPE_DYNAMICOBJECT:
return GetDynamicObject((uint32)guid);
break;
case HIGHGUID_TYPE_TRANSPORTER:
return objmgr.GetTransporter(Arcemu::Util::GUID_LOPART(guid));
break;
default:
return GetUnit(guid);
break;
}
}
bool ChatHandler::HandleWPSkinCommand(const char* args, WorldSession *m_session)
{
uint64 guid = m_session->GetPlayer()->GetSelection();
if (guid == 0)
{
SystemMessage(m_session, "No selection.");
return true;
}
if(GET_TYPE_FROM_GUID(guid) != HIGHGUID_TYPE_WAYPOINT)
{
SystemMessage(m_session, "You should select a Waypoint.");
return true;
}
Player* pPlayer = m_session->GetPlayer();
AIInterface* ai = pPlayer->waypointunit;
if(!ai || !ai->GetUnit())
{
SystemMessage(m_session, "Invalid Creature, please select another one.");
return true;
}
uint32 SkinId = 0;
std::stringstream ss;
uint32 wpid = GUID_LOPART(guid);
if(wpid)
{
WayPoint* wp = ai->getWayPoint(wpid);
if(wp)
{
char* pBackwards = strtok((char*)args, " ");
uint32 Backwards = (pBackwards)? atoi(pBackwards) : 0;
char* pSkinId = strtok(NULL, " ");
SkinId = (pSkinId)? atoi(pSkinId) : 0;
if(Backwards)
{
wp->backwardskinid = SkinId;
}
else
{
wp->forwardskinid = SkinId;
}
//save wp
ai->saveWayPoints();
}
ss << "SkinID for Waypoint " << wpid << " is now " << SkinId;
SystemMessage(m_session, ss.str().c_str());
}
else
{
SystemMessage(m_session, "Invalid Waypoint.");
return true;
}
return true;
}
bool ChatHandler::HandleWPInfoCommand(const char* args, WorldSession *m_session)
{
uint64 guid = m_session->GetPlayer()->GetSelection();
if (guid == 0)
{
SystemMessage(m_session, "No selection.");
return true;
}
if(GET_TYPE_FROM_GUID(guid) != HIGHGUID_TYPE_WAYPOINT)
{
SystemMessage(m_session, "You should select a Waypoint.");
return true;
}
Player* pPlayer = m_session->GetPlayer();
AIInterface* ai = pPlayer->waypointunit;
if(!ai || !ai->GetUnit())
{
SystemMessage(m_session, "Invalid Creature, please select another one.");
return true;
}
std::stringstream ss;
uint32 wpid = GUID_LOPART(guid);
if((wpid > 0) && (wpid <= ai->GetWayPointsCount()))
{
WayPoint* wp = ai->getWayPoint(wpid);
if(wp)
{
ss << "Waypoint Number " << wp->id << ":\n";
ss << "WaitTime: " << wp->waittime << "\n";
ss << "Flags: " << wp->flags;
if(wp->flags == 768)
ss << " (Fly)\n";
else if(wp->flags == 256)
ss << " (Run)\n";
else
ss << " (Walk)\n";
ss << "Backwards\n";
ss << " emoteid: " << wp->backwardemoteid << "\n";
ss << " oneshot: " << ((wp->backwardemoteoneshot == 1)? "Yes" : "No") << "\n";
ss << " skinid: " << wp->backwardskinid << "\n";
ss << "Forwards\n";
ss << " emoteid: " << wp->forwardemoteid << "\n";
ss << " oneshot: " << ((wp->forwardemoteoneshot == 1)? "Yes" : "No") << "\n";
ss << " skinid: " << wp->forwardskinid << "\n";
SendMultilineMessage(m_session, ss.str().c_str());
}
}
else
{
SystemMessage(m_session, "Invalid Waypoint.");
return true;
}
return true;
}
bool ChatHandler::HandleWPChangeNoCommand(const char* args, WorldSession *m_session)
{
uint64 guid = m_session->GetPlayer()->GetSelection();
if (guid == 0)
{
SystemMessage(m_session, "No selection.");
return true;
}
if(GET_TYPE_FROM_GUID(guid) != HIGHGUID_TYPE_WAYPOINT)
{
SystemMessage(m_session, "You should select a Waypoint.");
return true;
}
Player* pPlayer = m_session->GetPlayer();
AIInterface* ai = pPlayer->waypointunit;
if(!ai || !ai->GetUnit())
{
SystemMessage(m_session, "Invalid Creature, please select another one.");
return true;
}
std::stringstream ss;
//get newid
char* pNewID = strtok((char*)args, " ");
uint32 NewID = (pNewID)? atoi(pNewID) : 0;
uint32 wpid = GUID_LOPART(guid);
if(NewID == wpid) return false;
if(wpid)
{
//Refresh client
//Hide all
bool show = ai->m_WayPointsShowing;
if(show == true)
ai->hideWayPoints(pPlayer);
//update to new id
ai->changeWayPointID(wpid,NewID);
//Show All again after update
if(show == true)
ai->showWayPoints(pPlayer,ai->m_WayPointsShowBackwards);
ss << "Waypoint " << wpid << " changed to Waypoint " << NewID << ".";
SystemMessage(m_session, ss.str().c_str());
}
else
{
SystemMessage(m_session, "Invalid Waypoint.");
return true;
}
return true;
}
bool ChatHandler::HandleWPMoveHereCommand(const char* args, WorldSession *m_session)
{
uint64 guid = m_session->GetPlayer()->GetSelection();
if (guid == 0)
{
SystemMessage(m_session, "No selection.");
return true;
}
if(GET_TYPE_FROM_GUID(guid) != HIGHGUID_TYPE_WAYPOINT)
{
SystemMessage(m_session, "You should select a Waypoint.");
return true;
}
Player* pPlayer = m_session->GetPlayer();
AIInterface* ai = pPlayer->waypointunit;
if(!ai || !ai->GetUnit())
{
SystemMessage(m_session, "Invalid Creature, please select another one.");
return true;
}
std::stringstream ss;
uint32 wpid = GUID_LOPART(guid);
if(wpid)
{
WayPoint* wp = ai->getWayPoint(wpid);
if(wp)
{
wp->x = pPlayer->GetPositionX();
wp->y = pPlayer->GetPositionY();
wp->z = pPlayer->GetPositionZ();
wp->o = pPlayer->GetOrientation();
//save wp
ai->saveWayPoints();
}
//Refresh client
if(ai->m_WayPointsShowing == true)
{
ai->hideWayPoints(pPlayer);
ai->showWayPoints(pPlayer,ai->m_WayPointsShowBackwards);
}
ss << "Waypoint " << wpid << " has been moved.";
SystemMessage(m_session, ss.str().c_str());
}
else
{
SystemMessage(m_session, "Invalid Waypoint.");
return true;
}
return true;
}
bool ChatHandler::HandleWPWaitCommand(const char* args, WorldSession *m_session)
{
uint64 guid = m_session->GetPlayer()->GetSelection();
if (guid == 0)
{
SystemMessage(m_session, "No selection.");
return true;
}
if(GET_TYPE_FROM_GUID(guid) != HIGHGUID_TYPE_WAYPOINT)
{
SystemMessage(m_session, "You should select a Waypoint.");
return true;
}
Player* pPlayer = m_session->GetPlayer();
AIInterface* ai = pPlayer->waypointunit;
if(!ai || !ai->GetUnit())
{
SystemMessage(m_session, "Invalid Creature, please select another one.");
return true;
}
uint32 Wait = 10000;
std::stringstream ss;
uint32 wpid = GUID_LOPART(guid);
if(wpid)
{
WayPoint* wp = ai->getWayPoint(wpid);
if(wp)
{
char* pWait = strtok((char*)args, " ");
Wait = (pWait)? atoi(pWait) : 10000;
if(Wait < 5000)
{
SystemMessage(m_session, "A Wait Time of less then 5000ms can cause lag, consider extending it.");
}
wp->waittime = Wait;
//save wp
ai->saveWayPoints();
}
ss << "Wait Time for Waypoint " << wpid << " is now " << Wait << "ms.";
SystemMessage(m_session, ss.str().c_str());
}
else
{
SystemMessage(m_session, "Invalid Waypoint.");
return true;
}
return true;
}
//////////////////////////////////////////////////////////////
/// 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;
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->GetCreatureName()?crt->GetCreatureName()->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;
}
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::HandleQuestgiverStatusQueryOpcode(WorldPacket & recv_data)
{
CHECK_INWORLD_RETURN
LOG_DEBUG("WORLD: Received CMSG_QUESTGIVER_STATUS_QUERY.");
if(_player->IsInBg())
return; //Added in 3.0.2, quests can be shared anywhere besides a BG
uint64 guid;
WorldPacket data(SMSG_QUESTGIVER_STATUS, 12);
Object* qst_giver = NULL;
recv_data >> guid;
uint32 guidtype = GET_TYPE_FROM_GUID(guid);
if(guidtype == HIGHGUID_TYPE_UNIT)
{
Creature* quest_giver = _player->GetMapMgr()->GetCreature(GET_LOWGUID_PART(guid));
if(quest_giver)
qst_giver = quest_giver;
else
return;
if(!quest_giver->isQuestGiver())
{
LOG_DEBUG("WORLD: Creature is not a questgiver.");
return;
}
}
else if(guidtype == HIGHGUID_TYPE_ITEM)
{
Item* quest_giver = GetPlayer()->GetItemInterface()->GetItemByGUID(guid);
if(quest_giver)
qst_giver = quest_giver;
else
return;
}
else if(guidtype == HIGHGUID_TYPE_GAMEOBJECT)
{
GameObject* quest_giver = _player->GetMapMgr()->GetGameObject(GET_LOWGUID_PART(guid));
if(quest_giver)
qst_giver = quest_giver;
else
return;
}
if(!qst_giver)
{
LOG_DEBUG("WORLD: Invalid questgiver GUID " I64FMT ".", guid);
return;
}
data << guid << sQuestMgr.CalcStatus(qst_giver, GetPlayer());
SendPacket(&data);
}
bool ChatHandler::HandleWPFlagsCommand(const char* args, WorldSession* m_session)
{
uint64 guid = m_session->GetPlayer()->GetSelection();
if(guid == 0)
{
SystemMessage(m_session, "No selection.");
return true;
}
if(GET_TYPE_FROM_GUID(guid) != HIGHGUID_TYPE_WAYPOINT)
{
SystemMessage(m_session, "You should select a Waypoint.");
return true;
}
Player* pPlayer = m_session->GetPlayer();
AIInterface* ai = pPlayer->waypointunit;
if(!ai || !ai->GetUnit())
{
SystemMessage(m_session, "Invalid Creature, please select another one.");
return true;
}
std::stringstream ss;
uint32 wpid = Arcemu::Util::GUID_LOPART(guid);
if(wpid)
{
WayPoint* wp = ai->getWayPoint(wpid);
if(wp == NULL)
{
SystemMessage(m_session, "Invalid Waypoint.");
return true;
}
uint32 flags = wp->flags;
char* pNewFlags = strtok((char*)args, " ");
uint32 NewFlags = (pNewFlags) ? atoi(pNewFlags) : 0;
wp->flags = NewFlags;
//save wp
ai->saveWayPoints();
ss << "Waypoint " << wpid << " flags changed from " << flags << " to " << NewFlags;
SystemMessage(m_session, ss.str().c_str());
}
else
{
SystemMessage(m_session, "Invalid Waypoint.");
return true;
}
return true;
}
void WorldSession::HandleQuestgiverStatusQueryOpcode( WorldPacket & recv_data )
{
DEBUG_LOG( "WORLD"," Received CMSG_QUESTGIVER_STATUS_QUERY." );
CHECK_INWORLD_RETURN;
uint64 guid;
WorldPacket data(SMSG_QUESTGIVER_STATUS, 9);
Object* qst_giver = NULLOBJ;
recv_data >> guid;
uint32 guidtype = GET_TYPE_FROM_GUID(guid);
if(guidtype == HIGHGUID_TYPE_CREATURE)
{
Creature* quest_giver = _player->GetMapMgr()->GetCreature(GET_LOWGUID_PART(guid));
if(quest_giver)
qst_giver = quest_giver;
else
return;
if (!quest_giver->isQuestGiver())
{
OUT_DEBUG("WORLD: Creature is not a questgiver.");
return;
}
}
else if(guidtype==HIGHGUID_TYPE_ITEM)
{
Item* quest_giver = GetPlayer()->GetItemInterface()->GetItemByGUID(guid);
if(quest_giver)
qst_giver = TO_OBJECT(quest_giver);
else
return;
}
else if(guidtype==HIGHGUID_TYPE_GAMEOBJECT)
{
GameObject* quest_giver = _player->GetMapMgr()->GetGameObject(GET_LOWGUID_PART(guid));
if(quest_giver)
qst_giver = TO_OBJECT(quest_giver);
else
return;
}
if (!qst_giver)
{
OUT_DEBUG("WORLD: Invalid questgiver GUID "I64FMT".", guid);
return;
}
data << guid << sQuestMgr.CalcStatus(qst_giver, GetPlayer());
SendPacket( &data );
}
void WorldSession::HandleQuestgiverStatusQueryOpcode( WorldPacket & recv_data )
{
sLog.outDebug( "WORLD: Received CMSG_QUESTGIVER_STATUS_QUERY." );
if(!_player) return;
if(!_player->IsInWorld()) return;
uint64 guid;
WorldPacket data(SMSG_QUESTGIVER_STATUS, 12);
Object *qst_giver = NULL;
recv_data >> guid;
uint32 guidtype = GET_TYPE_FROM_GUID(guid);
if(guidtype==HIGHGUID_TYPE_UNIT)
{
Creature *quest_giver = _player->GetMapMgr()->GetCreature(GET_LOWGUID_PART(guid));
if(quest_giver)
qst_giver = (Object*)quest_giver;
else
return;
if (!quest_giver->isQuestGiver())
{
sLog.outDebug("WORLD: Creature is not a questgiver.");
return;
}
}
else if(guidtype==HIGHGUID_TYPE_ITEM)
{
Item *quest_giver = GetPlayer()->GetItemInterface()->GetItemByGUID(guid);
if(quest_giver)
qst_giver = (Object*)quest_giver;
else
return;
}
else if(guidtype==HIGHGUID_TYPE_GAMEOBJECT)
{
GameObject *quest_giver = _player->GetMapMgr()->GetGameObject(GET_LOWGUID_PART(guid));
if(quest_giver)
qst_giver = (Object*)quest_giver;
else
return;
}
if (!qst_giver)
{
sLog.outDebug("WORLD: Invalid questgiver GUID "I64FMT".", guid);
return;
}
data << guid << sQuestMgr.CalcStatus(qst_giver, GetPlayer());
SendPacket( &data );
}
bool ChatHandler::HandleWaypointGettextCommand(const char* args, WorldSession *m_session)
{
uint64 guid = m_session->GetPlayer()->GetSelection();
if (guid == 0)
{
SystemMessage(m_session, "No selection.");
return true;
}
if(GET_TYPE_FROM_GUID(guid) != HIGHGUID_TYPE_WAYPOINT)
{
SystemMessage(m_session, "You should select a Waypoint.");
return true;
}
Player* pPlayer = m_session->GetPlayer();
AIInterface* ai = pPlayer->waypointunit;
if(!ai || !ai->GetUnit())
{
SystemMessage(m_session, "Invalid Creature, please select another one.");
return true;
}
std::stringstream ss;
uint32 wpid = GUID_LOPART(guid);
if((wpid > 0) && (wpid <= ai->GetWayPointsCount()))
{
WayPoint* wp = ai->getWayPoint(wpid);
if(wp)
{
ss << "Waypoint Number " << wp->id << ":\n";
if(wp->backwardInfo)
{
ss << "Backward:\n";
ss << wp->backwardInfo->SayText << "\n";
}
if(wp->forwardInfo)
{
ss << "Forward:\n";
ss << wp->forwardInfo->SayText << "\n";
}
SendMultilineMessage(m_session, ss.str().c_str());
}
}
else
{
SystemMessage(m_session, "Invalid Waypoint.");
return true;
}
return true;
}
bool ChatHandler::HandleWaypointForwardTextCommand(const char* args, WorldSession *m_session)
{
uint64 guid = m_session->GetPlayer()->GetSelection();
if (guid == 0)
{
SystemMessage(m_session, "No selection.");
return true;
}
if(GET_TYPE_FROM_GUID(guid) != HIGHGUID_TYPE_WAYPOINT)
{
SystemMessage(m_session, "You should select a Waypoint.");
return true;
}
Player* pPlayer = m_session->GetPlayer();
AIInterface* ai = pPlayer->waypointunit;
if(!ai || !ai->GetUnit())
{
SystemMessage(m_session, "Invalid Creature, please select another one.");
return true;
}
std::stringstream ss;
uint32 wpid = GUID_LOPART(guid);
if(wpid)
{
WayPoint* wp = ai->getWayPoint(wpid);
if(wp)
{
char pAnnounce[1024];
snprintf(pAnnounce, 1024, "%s", args);
if(wp->forwardInfo == NULL)
wp->forwardInfo = new ConditionalData();
wp->forwardInfo->SayText = ((const char*)(pAnnounce));
ss << "Forward SayText for Waypoint " << wpid << " is now " << string(pAnnounce);
//save wp
ai->saveWayPoints();
}
SystemMessage(m_session, ss.str().c_str());
} else
{
SystemMessage(m_session, "Invalid Waypoint.");
return true;
}
return true;
}
bool ChatHandler::HandleWPDeleteCommand(const char* args, WorldSession *m_session)
{
uint64 guid = m_session->GetPlayer()->GetSelection();
if (guid == 0)
{
SystemMessage(m_session, "No selection.");
return true;
}
if(GET_TYPE_FROM_GUID(guid) != HIGHGUID_TYPE_WAYPOINT)
{
SystemMessage(m_session, "You should select a Waypoint.");
return true;
}
Player* pPlayer = m_session->GetPlayer();
AIInterface* ai = pPlayer->waypointunit;
if(!ai || !ai->GetUnit())
{
SystemMessage(m_session, "Invalid Creature, please select another one.");
return true;
}
std::stringstream ss;
uint32 wpid = GUID_LOPART(guid);
if(wpid)
{
//Refresh client
//Hide all
bool show = ai->WayPointsShowing();
if(show == true)
ai->hideWayPoints(pPlayer);
ai->deleteWayPoint(wpid);
//Show All again after delete
if(show == true)
ai->showWayPoints(pPlayer, ai->WayPointsShowingBackwards());
SystemMessage(m_session, "Waypoint %u deleted.", wpid);
}
else
{
SystemMessage(m_session, "Invalid Waypoint.");
return true;
}
return true;
}
Unit* MapMgr::GetUnit(const uint64 & guid)
{
/*#ifdef USING_BIG_ENDIAN
switch (((uint32*)&guid)[0])
#else
switch (((uint32*)&guid)[1])
#endif
{
case HIGHGUID_PLAYER:
return GetPlayer((uint32)guid);
break;
case HIGHGUID_UNIT:
return GetCreature((uint32)guid);
break;
case HIGHGUID_PET:
return GetPet((uint32)guid);
break;
default:
return NULL;
}*/
/*uint32 highguid = GUID_HIPART(guid);
if( highguid & HIGHGUID_UNIT )
return GetCreature( ((uint32)guid&LOWGUID_UNIT_MASK) );
else if( highguid == HIGHGUID_PLAYER ) // players are always zero
return GetPlayer( (uint32)guid );
else if( highguid & HIGHGUID_PET )
return GetPet( (uint32)guid );
else
return NULL;*/
switch(GET_TYPE_FROM_GUID(guid))
{
case HIGHGUID_TYPE_UNIT:
return GetCreature( GET_LOWGUID_PART(guid) );
break;
case HIGHGUID_TYPE_PLAYER:
return GetPlayer( (uint32)guid );
break;
case HIGHGUID_TYPE_PET:
return GetPet( (uint32)guid );
break;
}
return NULL;
}
bool ChatHandler::HandleWaypointSetOrientationCommand(const char* args, WorldSession *m_session)
{
uint64 guid = m_session->GetPlayer()->GetSelection();
if (guid == 0)
{
SystemMessage(m_session, "No selection.");
return true;
}
if(GET_TYPE_FROM_GUID(guid) != HIGHGUID_TYPE_WAYPOINT)
{
SystemMessage(m_session, "You should select a Waypoint.");
return true;
}
Player* pPlayer = m_session->GetPlayer();
AIInterface* ai = pPlayer->waypointunit;
if(!ai || !ai->GetUnit())
{
SystemMessage(m_session, "Invalid Creature, please select another one.");
return true;
}
bool showing = ai->WayPointsShowing();
uint32 wpid = GUID_LOPART(guid);
if(wpid)
{
WayPoint* wp = ai->getWayPoint(wpid);
if(wp)
{
if(showing)
ai->hideWayPoints(pPlayer);
wp->orientation = pPlayer->GetOrientation();
//save wp
ai->saveWayPoints();
}
else return false;
}
else return false;
if(showing)
ai->showWayPoints(pPlayer, ai->WayPointsShowingBackwards());
return true;
}
void WorldSession::HandlePetAction(WorldPacket & recv_data)
{
CHECK_INWORLD_RETURN
//WorldPacket data;
uint64 petGuid = 0;
uint16 misc = 0;
uint16 action = 0;
uint64 targetguid = 0;
recv_data >> petGuid >> misc >> action;
//recv_data.hexlike();
//printf("Pet_Action: 0x%.4X 0x%.4X\n", misc, action);
if(GET_TYPE_FROM_GUID(petGuid) == HIGHGUID_TYPE_UNIT)
{
Creature* pCharm = GetPlayer()->GetMapMgr()->GetCreature(GET_LOWGUID_PART(petGuid));
if(!pCharm)
return;
// must be a mind controlled creature..
if(action == PET_ACTION_ACTION)
{
recv_data >> targetguid;
switch(misc)
{
case PET_ACTION_ATTACK:
{
if(!sEventMgr.HasEvent(_player, EVENT_PLAYER_CHARM_ATTACK))
{
uint32 timer = pCharm->GetBaseAttackTime(MELEE);
if(!timer) timer = 2000;
sEventMgr.AddEvent(_player, &Player::_EventCharmAttack, EVENT_PLAYER_CHARM_ATTACK, timer, 0, EVENT_FLAG_DO_NOT_EXECUTE_IN_WORLD_CONTEXT);
_player->_EventCharmAttack();
}
}
break;
}
}
//////////////////////////////////////////////////////////////
/// This function handles CMSG_GOSSIP_SELECT_OPTION:
//////////////////////////////////////////////////////////////
void WorldSession::HandleGossipSelectOptionOpcode(WorldPacket & recv_data)
{
CHECK_INWORLD_RETURN
uint32 option;
uint32 unk24;
uint64 guid;
recv_data >> guid >> unk24 >> option;
LOG_DETAIL("WORLD: CMSG_GOSSIP_SELECT_OPTION Option %i Guid %.8X", option, guid);
Arcemu::Gossip::Script* script = NULL;
uint32 guidtype = GET_TYPE_FROM_GUID(guid);
Object* qst_giver;
if(guidtype == HIGHGUID_TYPE_ITEM) //Item objects are retrieved differently.
{
qst_giver = GetPlayer()->GetItemInterface()->GetItemByGUID(guid);
if(qst_giver != NULL)
script = Arcemu::Gossip::Script::GetInterface(TO_ITEM(qst_giver));
}
else
qst_giver = GetPlayer()->GetMapMgr()->_GetObject(guid);
if(qst_giver != NULL)
{
if(guidtype == HIGHGUID_TYPE_UNIT)
script = Arcemu::Gossip::Script::GetInterface(TO_CREATURE(qst_giver));
else if(guidtype == HIGHGUID_TYPE_GAMEOBJECT)
script = Arcemu::Gossip::Script::GetInterface(TO_GAMEOBJECT(qst_giver));
}
if(script != NULL)
{
string str;
if(recv_data.rpos() != recv_data.wpos())
recv_data >> str;
if(str.length() > 0)
script->OnSelectOption(qst_giver, GetPlayer() , option, str.c_str());
else
script->OnSelectOption(qst_giver, GetPlayer() , option, NULL);
}
void WorldSession::HandlePetAction(WorldPacket & recv_data)
{
if(!_player->IsInWorld()) return;
//WorldPacket data;
uint64 petGuid = 0;
uint16 misc = 0;
uint16 action = 0;
uint64 targetguid = 0;
recv_data >> petGuid >> misc >> action;
//recv_data.hexlike();
//printf("Pet_Action: 0x%.4X 0x%.4X\n", misc, action);
if(GET_TYPE_FROM_GUID(petGuid) == HIGHGUID_TYPE_UNIT)
{
Creature *pCharm = GetPlayer()->GetMapMgr()->GetCreature(GET_LOWGUID_PART(petGuid));
if(!pCharm)
return;
// must be a mind controled creature..
if(action == PET_ACTION_ACTION)
{
recv_data >> targetguid;
switch(misc)
{
case PET_ACTION_ATTACK:
{
if(!sEventMgr.HasEvent(_player, EVENT_PLAYER_CHARM_ATTACK))
{
uint32 timer = pCharm->GetUInt32Value(UNIT_FIELD_BASEATTACKTIME);
if(!timer) timer = 2000;
sEventMgr.AddEvent(_player, &Player::_EventCharmAttack, EVENT_PLAYER_CHARM_ATTACK, timer, 0,0);
_player->_EventCharmAttack();
}
}break;
}
}
Unit* MapMgr::GetUnit(const uint64 & guid)
{
if(guid == 0)
return NULL;
switch(GET_TYPE_FROM_GUID(guid))
{
case HIGHGUID_TYPE_UNIT:
case HIGHGUID_TYPE_VEHICLE:
return GetCreature(GET_LOWGUID_PART(guid));
break;
case HIGHGUID_TYPE_PLAYER:
return GetPlayer(Arcemu::Util::GUID_LOPART(guid));
break;
case HIGHGUID_TYPE_PET:
return GetPet(GET_LOWGUID_PART(guid));
break;
}
return NULL;
}
/*Loot type MUST be
1-corpse, go
2-skinning/herbalism/minning
3-Fishing
*/
void Player::SendLoot(uint64 guid,uint8 loot_type, uint32 mapid)
{
Group * m_Group = m_playerInfo->m_Group;
if( !IsInWorld() )
return;
Loot * pLoot = NULL;
uint32 guidtype = GET_TYPE_FROM_GUID(guid);
int8 loot_method;
if( m_Group != NULL )
loot_method = m_Group->GetMethod();
else
loot_method = PARTY_LOOT_FFA;
if(guidtype == HIGHGUID_TYPE_UNIT)
{
Creature* pCreature = GetMapMgr()->GetCreature(GET_LOWGUID_PART(guid));
if(!pCreature)return;
pLoot=&pCreature->loot;
m_currentLoot = pCreature->GetGUID();
}else if(guidtype == HIGHGUID_TYPE_GAMEOBJECT)
{
GameObject* pGO = GetMapMgr()->GetGameObject(GET_LOWGUID_PART(guid));
if(!pGO)return;
pGO->SetByte(GAMEOBJECT_BYTES_1, 0,0);
pLoot=&pGO->loot;
m_currentLoot = pGO->GetGUID();
}
else if((guidtype == HIGHGUID_TYPE_PLAYER) )
{
Player *p=GetMapMgr()->GetPlayer((uint32)guid);
if(!p)return;
pLoot=&p->loot;
m_currentLoot = p->GetGUID();
}
else if( (guidtype == HIGHGUID_TYPE_CORPSE))
{
Corpse *pCorpse = objmgr.GetCorpse((uint32)guid);
if(!pCorpse)return;
pLoot=&pCorpse->loot;
m_currentLoot = pCorpse->GetGUID();
}
else if( (guidtype == HIGHGUID_TYPE_ITEM) )
{
Item *pItem = GetItemInterface()->GetItemByGUID(guid);
if(!pItem)
return;
pLoot = pItem->loot;
m_currentLoot = pItem->GetGUID();
}
if(!pLoot)
{
// something whack happened.. damn cheaters..
return;
}
// add to looter set
pLoot->looters.insert( GetLowGUID() );
WorldPacket data, data2(32);
data.SetOpcode( SMSG_LOOT_RESPONSE );
m_lootGuid = guid;
data << uint64( guid );
data << uint8( loot_type );//loot_type;
data << uint32( pLoot->gold );
data << uint8( 0 ); //loot size reserve
std::vector<__LootItem>::iterator iter=pLoot->items.begin();
uint32 count= 0;
uint8 slottype = 0;
for(uint32 x= 0;iter!=pLoot->items.end();iter++,x++)
{
if (iter->iItemsCount == 0)
continue;
LooterSet::iterator itr = iter->has_looted.find(GetLowGUID());
if (iter->has_looted.end() != itr)
continue;
ItemPrototype* itemProto =iter->item.itemproto;
if (!itemProto)
continue;
// check if it's on ML if so only quest items and ffa loot should be shown based on mob
if ( loot_method == PARTY_LOOT_MASTER && m_Group && m_Group->GetLooter() != m_playerInfo )
// pass on all ffa_loot and the grey / white items
if ( !iter->ffa_loot && !(itemProto->Quality < m_Group->GetThreshold()) )
continue;
//quest items check. type 4/5
//quest items that don't start quests.
if((itemProto->Bonding == ITEM_BIND_QUEST) && !(itemProto->QuestId) && !HasQuestForItem(itemProto->ItemId))
continue;
if((itemProto->Bonding == ITEM_BIND_QUEST2) && !(itemProto->QuestId) && !HasQuestForItem(itemProto->ItemId))
continue;
//quest items that start quests need special check to avoid drops all the time.
if((itemProto->Bonding == ITEM_BIND_QUEST) && (itemProto->QuestId) && GetQuestLogForEntry(itemProto->QuestId))
continue;
if((itemProto->Bonding == ITEM_BIND_QUEST2) && (itemProto->QuestId) && GetQuestLogForEntry(itemProto->QuestId))
continue;
if((itemProto->Bonding == ITEM_BIND_QUEST) && (itemProto->QuestId) && HasFinishedQuest(itemProto->QuestId))
continue;
if((itemProto->Bonding == ITEM_BIND_QUEST2) && (itemProto->QuestId) && HasFinishedQuest(itemProto->QuestId))
continue;
//check for starting item quests that need questlines.
if((itemProto->QuestId && itemProto->Bonding != ITEM_BIND_QUEST && itemProto->Bonding != ITEM_BIND_QUEST2))
{
bool HasRequiredQuests = true;
Quest * pQuest = QuestStorage.LookupEntry(itemProto->QuestId);
if(pQuest)
{
uint32 finishedCount = 0;
//check if its a questline.
for(uint32 i = 0; i < pQuest->count_requiredquests; i++)
{
if(pQuest->required_quests[i])
{
if(!HasFinishedQuest(pQuest->required_quests[i]) || GetQuestLogForEntry(pQuest->required_quests[i]))
{
if (!(pQuest->quest_flags & QUEST_FLAG_ONLY_ONE_REQUIRED)) {
HasRequiredQuests = false;
break;
}
}
else
{
finishedCount++;
}
}
}
if (pQuest->quest_flags & QUEST_FLAG_ONLY_ONE_REQUIRED) {
if (finishedCount == 0) continue;
} else {
if(!HasRequiredQuests)
continue;
}
}
}
slottype = 0;
if(m_Group != NULL && loot_type < 2)
{
switch(loot_method)
{
case PARTY_LOOT_MASTER:
slottype = 2;
break;
case PARTY_LOOT_GROUP:
case PARTY_LOOT_RR:
case PARTY_LOOT_NBG:
slottype = 1;
break;
default:
slottype = 0;
break;
}
// only quality items are distributed
if(itemProto->Quality < m_Group->GetThreshold())
{
slottype = 0;
}
// if all people passed anyone can loot it? :P
if(iter->passed)
slottype = 0; // All players passed on the loot
//if it is ffa loot and not an masterlooter
if(iter->ffa_loot)
slottype = 0;
}
data << uint8( x );
data << uint32( itemProto->ItemId );
data << uint32( iter->iItemsCount );//nr of items of this type
data << uint32( iter->item.displayid );
if(iter->iRandomSuffix)
{
data << uint32( Item::GenerateRandomSuffixFactor( itemProto ) );
data << uint32( -int32( iter->iRandomSuffix->id ) );
}
else if(iter->iRandomProperty)
{
data << uint32( 0 );
data << uint32( iter->iRandomProperty->ID );
}
else
{
data << uint32( 0 );
data << uint32( 0 );
}
data << slottype; // "still being rolled for" flag
if(slottype == 1)
{
if(iter->roll == NULL && !iter->passed)
{
int32 ipid = 0;
uint32 factor= 0;
if(iter->iRandomProperty)
ipid=iter->iRandomProperty->ID;
else if(iter->iRandomSuffix)
{
ipid = -int32(iter->iRandomSuffix->id);
factor=Item::GenerateRandomSuffixFactor(iter->item.itemproto);
}
if(iter->item.itemproto)
{
iter->roll = new LootRoll(60000, (m_Group != NULL ? m_Group->MemberCount() : 1), guid, x, itemProto->ItemId, factor, uint32(ipid), GetMapMgr());
data2.Initialize(SMSG_LOOT_START_ROLL);
data2 << guid;
data2 << uint32( mapid );
data2 << uint32( x );
data2 << uint32( itemProto->ItemId );
data2 << uint32( factor );
if(iter->iRandomProperty)
data2 << uint32(iter->iRandomProperty->ID);
else if(iter->iRandomSuffix)
data2 << uint32( ipid );
else
data2 << uint32( 0 );
data2 << uint32( iter->iItemsCount );
data2 << uint32( 60000 ); // countdown
data2 << uint8( 7 ); // some sort of flags that require research
}
Group * pGroup = m_playerInfo->m_Group;
if(pGroup)
{
pGroup->Lock();
for(uint32 i = 0; i < pGroup->GetSubGroupCount(); ++i)
{
for(GroupMembersSet::iterator itr2 = pGroup->GetSubGroup(i)->GetGroupMembersBegin(); itr2 != pGroup->GetSubGroup(i)->GetGroupMembersEnd(); ++itr2)
{
PlayerInfo *pinfo = *itr2;
if( pinfo->m_loggedInPlayer && pinfo->m_loggedInPlayer->GetItemInterface()->CanReceiveItem( itemProto, iter->iItemsCount ) == 0 )
{
if( pinfo->m_loggedInPlayer->m_passOnLoot )
iter->roll->PlayerRolled( pinfo->m_loggedInPlayer, 3 ); // passed
else
pinfo->m_loggedInPlayer->SendPacket( &data2 );
}
}
}
pGroup->Unlock();
}
else
{
m_session->SendPacket(&data2);
}
}
}
count++;
}
data.wpos(13);
data << uint8( count );
m_session->SendPacket(&data);
SetFlag( UNIT_FIELD_FLAGS, UNIT_FLAG_LOOTING );
}
void LootRoll::Finalize()
{
sEventMgr.RemoveEvents(this);
// this we will have to finalize with groups types.. for now
// we'll just assume need before greed. person with highest roll
// in need gets the item.
uint32 highest = 0;
int8 hightype = -1;
uint64 player = 0;
WorldPacket data(34);
/*
Player * gplr = NULL;
for(std::map<uint64, uint32>::iterator itr = NeedRolls.begin(); itr != NeedRolls.end(); ++itr)
{
gplr = _mgr->GetPlayer((uint32)itr->first);
if(gplr) break;
}
if(!gplr)
{
for(std::map<uint64, uint32>::iterator itr = GreedRolls.begin(); itr != GreedRolls.end(); ++itr)
{
gplr = _mgr->GetPlayer((uint32)itr->first);
if(gplr) break;
}
}
*/
for (std::map<uint32, uint32>::iterator itr = m_NeedRolls.begin(); itr != m_NeedRolls.end(); ++itr)
{
if (itr->second > highest)
{
highest = itr->second;
player = itr->first;
hightype = NEED;
}
/*
data.Initialize(SMSG_LOOT_ROLL);
data << _guid << _slotid << itr->first;
data << _itemid << _itemunk1 << _itemunk2;
data << uint8(itr->second) << uint8(NEED);
if(gplr && gplr->GetGroup())
gplr->GetGroup()->SendPacketToAll(&data);
*/
}
if (!highest)
{
for (std::map<uint32, uint32>::iterator itr = m_GreedRolls.begin(); itr != m_GreedRolls.end(); ++itr)
{
if (itr->second > highest)
{
highest = itr->second;
player = itr->first;
hightype = GREED;
}
/*
data.Initialize(SMSG_LOOT_ROLL);
data << _guid << _slotid << itr->first;
data << _itemid << _itemunk1 << _itemunk2;
data << uint8(itr->second) << uint8(GREED);
if(gplr && gplr->GetGroup())
gplr->GetGroup()->SendPacketToAll(&data);
*/
}
}
Loot * pLoot = 0;
uint32 guidtype = GET_TYPE_FROM_GUID(_guid);
if (guidtype == HIGHGUID_TYPE_UNIT)
{
Creature * pc = _mgr->GetCreature(GET_LOWGUID_PART(_guid));
if (pc) pLoot = &pc->loot;
}
else if (guidtype == HIGHGUID_TYPE_GAMEOBJECT)
{
GameObject * go = _mgr->GetGameObject(GET_LOWGUID_PART(_guid));
if (go) pLoot = &go->loot;
}
if (!pLoot)
{
delete this;
return;
}
if (_slotid >= pLoot->items.size())
{
delete this;
return;
}
pLoot->items.at(_slotid).roll = NULL;
uint32 itemid = pLoot->items.at(_slotid).item.itemproto->ItemId;
uint32 amt = pLoot->items.at(_slotid).iItemsCount;
if (!amt)
{
delete this;
return;
}
Player * _player = (player) ? _mgr->GetPlayer((uint32)player) : 0;
if (!player || !_player)
{
/* all passed */
data.Initialize(SMSG_LOOT_ALL_PASSED);
data << _guid << _groupcount << _itemid << _itemunk1 << _itemunk2;
std::set<uint32>::iterator pitr = m_passRolls.begin();
while (_player == NULL && pitr != m_passRolls.end())
_player = _mgr->GetPlayer((*(pitr++)));
if (_player != NULL)
{
if (_player->InGroup())
_player->GetGroup()->SendPacketToAll(&data);
else
_player->GetSession()->SendPacket(&data);
}
/* item can now be looted by anyone :) */
pLoot->items.at(_slotid).passed = true;
delete this;
return;
}
pLoot->items.at(_slotid).roll = 0;
data.Initialize(SMSG_LOOT_ROLL_WON);
data << _guid << _slotid << _itemid << _itemunk1 << _itemunk2;
data << _player->GetGUID() << uint8(highest) << uint8(hightype);
if (_player->InGroup())
_player->GetGroup()->SendPacketToAll(&data);
else
_player->GetSession()->SendPacket(&data);
ItemPrototype* it = ItemPrototypeStorage.LookupEntry(itemid);
int8 error;
if ((error = _player->GetItemInterface()->CanReceiveItem(it, 1)) != 0)
{
_player->GetItemInterface()->BuildInventoryChangeError(NULL, NULL, error);
return;
}
Item * add = _player->GetItemInterface()->FindItemLessMax(itemid, amt, false);
if (!add)
{
SlotResult slotresult = _player->GetItemInterface()->FindFreeInventorySlot(it);
if (!slotresult.Result)
{
_player->GetItemInterface()->BuildInventoryChangeError(NULL, NULL, INV_ERR_INVENTORY_FULL);
return;
}
sLog.outDebug("AutoLootItem MISC");
Item *item = objmgr.CreateItem(itemid, _player);
item->SetUInt32Value(ITEM_FIELD_STACK_COUNT, amt);
if (pLoot->items.at(_slotid).iRandomProperty != NULL)
{
item->SetRandomProperty(pLoot->items.at(_slotid).iRandomProperty->ID);
item->ApplyRandomProperties(false);
}
else if (pLoot->items.at(_slotid).iRandomSuffix != NULL)
{
item->SetRandomSuffix(pLoot->items.at(_slotid).iRandomSuffix->id);
item->ApplyRandomProperties(false);
}
if (_player->GetItemInterface()->SafeAddItem(item, slotresult.ContainerSlot, slotresult.Slot))
{
_player->GetSession()->SendItemPushResult(item, false, true, true, true, slotresult.ContainerSlot, slotresult.Slot, 1);
sQuestMgr.OnPlayerItemPickup(_player, item);
}
else
item->DeleteMe();
}
else
{
add->SetCount(add->GetUInt32Value(ITEM_FIELD_STACK_COUNT) + amt);
add->m_isDirty = true;
sQuestMgr.OnPlayerItemPickup(_player, add);
_player->GetSession()->SendItemPushResult(add, false, true, true, false, _player->GetItemInterface()->GetBagSlotByGuid(add->GetGUID()), 0xFFFFFFFF, 1);
}
pLoot->items.at(_slotid).iItemsCount = 0;
// this gets sent to all looters
data.Initialize(SMSG_LOOT_REMOVED);
data << uint8(_slotid);
Player * plr;
for (LooterSet::iterator itr = pLoot->looters.begin(); itr != pLoot->looters.end(); ++itr)
{
if ((plr = _player->GetMapMgr()->GetPlayer(*itr)) != 0)
plr->GetSession()->SendPacket(&data);
}
/*WorldPacket idata(45);
_player->GetSession()->BuildItemPushResult(&idata, _player->GetGUID(), ITEM_PUSH_TYPE_LOOT, amt, itemid, pLoot->items.at(_slotid).iRandomProperty ? pLoot->items.at(_slotid).iRandomProperty->ID : 0);
if(_player->InGroup())
_player->GetGroup()->SendPacketToAll(&idata);
else
_player->GetSession()->SendPacket(&idata);*/
delete this;
}
void WorldSession::HandleQuestgiverChooseRewardOpcode(WorldPacket& recvPacket)
{
CHECK_INWORLD_RETURN;
DEBUG_LOG( "WORLD"," Received CMSG_QUESTGIVER_CHOOSE_REWARD." );
uint64 guid;
uint32 quest_id;
uint32 reward_slot;
recvPacket >> guid;
recvPacket >> quest_id;
recvPacket >> reward_slot;
if( reward_slot >= 6 )
return;
bool bValid = false;
Quest *qst = NULL;
Object* qst_giver = NULLOBJ;
uint32 guidtype = GET_TYPE_FROM_GUID(guid);
if(guidtype == HIGHGUID_TYPE_CREATURE)
{
Creature* quest_giver = _player->GetMapMgr()->GetCreature(GET_LOWGUID_PART(guid));
if(quest_giver)
qst_giver = quest_giver;
else
return;
bValid = quest_giver->isQuestGiver();
if(bValid)
qst = QuestStorage.LookupEntry(quest_id);
}
else if(guidtype==HIGHGUID_TYPE_GAMEOBJECT)
{
GameObject* quest_giver = _player->GetMapMgr()->GetGameObject(GET_LOWGUID_PART(guid));
if(quest_giver)
qst_giver = TO_OBJECT(quest_giver);
else
return;
//bValid = quest_giver->isQuestGiver();
//if(bValid)
bValid = true;
qst = QuestStorage.LookupEntry(quest_id);
}
if (!qst_giver)
{
OUT_DEBUG("WORLD: Invalid questgiver GUID.");
return;
}
if (!bValid || qst == NULL)
{
OUT_DEBUG("WORLD: Creature is not a questgiver.");
return;
}
//FIXME: Some Quest givers talk in the end of the quest.
// qst_giver->SendChatMessage(CHAT_MSG_MONSTER_SAY,LANG_UNIVERSAL,qst->GetQuestEndMessage().c_str());
QuestLogEntry *qle = _player->GetQuestLogForEntry(quest_id);
if (!qle && !qst->is_repeatable)
{
OUT_DEBUG("WORLD: QuestLogEntry not found.");
return;
}
if (qle && !qle->CanBeFinished())
{
OUT_DEBUG("WORLD: Quest not finished.");
return;
}
//check for room in inventory for all items
if(!sQuestMgr.CanStoreReward(_player,qst,reward_slot))
{
sQuestMgr.SendQuestFailed(FAILED_REASON_INV_FULL, qst, _player);
return;
}
sQuestMgr.OnQuestFinished(_player, qst, qst_giver, reward_slot);
//if(qst_giver->GetTypeId() == TYPEID_UNIT) qst->LUA_SendEvent(TO_CREATURE( qst_giver ),GetPlayer(),ON_QUEST_COMPLETEQUEST);
if(qst->next_quest_id)
{
WorldPacket data(12);
data.Initialize(CMSG_QUESTGIVER_QUERY_QUEST);
data << guid;
data << qst->next_quest_id;
HandleQuestGiverQueryQuestOpcode(data);
}
_player->SaveToDB(false);
}
bool ChatHandler::HandleWPEmoteCommand(const char* args, WorldSession *m_session)
{
uint64 guid = m_session->GetPlayer()->GetSelection();
if (guid == 0)
{
SystemMessage(m_session, "No selection.");
return true;
}
if(GET_TYPE_FROM_GUID(guid) != HIGHGUID_TYPE_WAYPOINT)
{
SystemMessage(m_session, "You should select a Waypoint.");
return true;
}
Player* pPlayer = m_session->GetPlayer();
AIInterface* ai = pPlayer->waypointunit;
if(!ai || !ai->GetUnit())
{
SystemMessage(m_session, "Invalid Creature, please select another one.");
return true;
}
uint32 EmoteId = 0;
bool OneShot = true;
std::stringstream ss;
uint32 wpid = GUID_LOPART(guid);
if(wpid)
{
WayPoint* wp = ai->getWayPoint(wpid);
if(wp)
{
char* pBackwards = strtok((char*)args, " ");
uint32 Backwards = (pBackwards)? atoi(pBackwards) : 0;
char* pEmoteId = strtok(NULL, " ");
EmoteId = (pEmoteId)? atoi(pEmoteId) : 0;
char* pOneShot = strtok(NULL, " ");
OneShot = (pOneShot)? ((atoi(pOneShot)>0)?true:false) : 1;
if(Backwards)
{
wp->backwardemoteid = EmoteId;
wp->backwardemoteoneshot = OneShot;
}
else
{
wp->forwardemoteid = EmoteId;
wp->forwardemoteoneshot = OneShot;
}
//save wp
ai->saveWayPoints();
}
ss << "EmoteID for Waypoint " << wpid << " is now " << EmoteId << " and oneshot is " << ((OneShot == true)? "Enabled." : "Disabled.");
SystemMessage(m_session, ss.str().c_str());
}
else
{
SystemMessage(m_session, "Invalid Waypoint.");
return true;
}
return true;
}
void WorldSession::HandleQuestgiverCompleteQuestOpcode( WorldPacket & recvPacket )
{
CHECK_INWORLD_RETURN;
DEBUG_LOG( "WORLD"," Received CMSG_QUESTGIVER_COMPLETE_QUEST." );
uint64 guid;
uint32 quest_id;
recvPacket >> guid;
recvPacket >> quest_id;
bool bValid = false;
Quest *qst = NULL;
Object* qst_giver = NULLOBJ;
uint32 status = 0;
uint32 guidtype = GET_TYPE_FROM_GUID(guid);
if(guidtype == HIGHGUID_TYPE_CREATURE)
{
Creature* quest_giver = _player->GetMapMgr()->GetCreature(GET_LOWGUID_PART(guid));
if(quest_giver)
qst_giver = TO_OBJECT(quest_giver);
else
return;
bValid = quest_giver->isQuestGiver();
if(bValid)
{
qst = quest_giver->FindQuest(quest_id, QUESTGIVER_QUEST_END);
/*if(!qst)
sQuestMgr.FindQuest(quest_id);*/
if(!qst)
{
OUT_DEBUG("WARNING: Cannot complete quest, as it doesnt exist.");
return;
}
status = sQuestMgr.CalcQuestStatus(GetPlayer(), qst, (uint8)quest_giver->GetQuestRelation(qst->id),false);
}
}
else if(guidtype==HIGHGUID_TYPE_GAMEOBJECT)
{
GameObject* quest_giver = _player->GetMapMgr()->GetGameObject(GET_LOWGUID_PART(guid));
if(quest_giver)
qst_giver = TO_OBJECT(quest_giver);
else
return; // oops..
bValid = quest_giver->isQuestGiver();
if(bValid)
{
qst = quest_giver->FindQuest(quest_id, QUESTGIVER_QUEST_END);
/*if(!qst) sQuestMgr.FindQuest(quest_id);*/
if(!qst)
{
OUT_DEBUG("WARNING: Cannot complete quest, as it doesnt exist.");
return;
}
status = sQuestMgr.CalcQuestStatus(GetPlayer(), qst, (uint8)quest_giver->GetQuestRelation(qst->id),false);
}
}
if (!qst_giver)
{
OUT_DEBUG("WORLD: Invalid questgiver GUID.");
return;
}
if (!bValid || qst == NULL)
{
OUT_DEBUG("WORLD: Creature is not a questgiver.");
return;
}
if (status == QMGR_QUEST_NOT_FINISHED || status == QMGR_QUEST_REPEATABLE)
{
WorldPacket data;
sQuestMgr.BuildRequestItems(&data, qst, qst_giver, status, language);
SendPacket(&data);
DEBUG_LOG( "WORLD"," Sent SMSG_QUESTGIVER_REQUEST_ITEMS." );
}
if (status == QMGR_QUEST_FINISHED)
{
WorldPacket data;
sQuestMgr.BuildOfferReward(&data, qst, qst_giver, 1, language, _player);
SendPacket(&data);
DEBUG_LOG( "WORLD"," Sent SMSG_QUESTGIVER_REQUEST_ITEMS." );
}
sHookInterface.OnQuestFinished(_player, qst, qst_giver);
}
void WorldSession::HandleQuestgiverRequestRewardOpcode( WorldPacket & recv_data )
{
CHECK_INWORLD_RETURN;
DEBUG_LOG( "WORLD","Received CMSG_QUESTGIVER_REQUESTREWARD_QUEST." );
uint64 guid;
uint32 quest_id;
recv_data >> guid;
recv_data >> quest_id;
bool bValid = false;
Quest *qst = NULL;
Object* qst_giver = NULL;
uint32 status = 0;
uint32 guidtype = GET_TYPE_FROM_GUID(guid);
if(guidtype==HIGHGUID_TYPE_UNIT)
{
Creature* quest_giver = _player->GetMapMgr()->GetCreature(GET_LOWGUID_PART(guid));
if(quest_giver)
qst_giver = TO_OBJECT(quest_giver);
else
return;
bValid = quest_giver->isQuestGiver();
if(bValid)
{
qst = quest_giver->FindQuest(quest_id, QUESTGIVER_QUEST_END);
if(!qst)
qst = quest_giver->FindQuest(quest_id, QUESTGIVER_QUEST_START);
if(!qst)
{
OUT_DEBUG("WARNING: Cannot complete quest, as it doesnt exist.");
return;
}
status = sQuestMgr.CalcQuestStatus(qst_giver, GetPlayer(), qst, (uint8)quest_giver->GetQuestRelation(qst->id),false);
}
}
else if(guidtype==HIGHGUID_TYPE_GAMEOBJECT)
{
GameObject* quest_giver = _player->GetMapMgr()->GetGameObject(GET_LOWGUID_PART(guid));
if(quest_giver)
qst_giver = TO_OBJECT(quest_giver);
else
return; // oops..
bValid = quest_giver->isQuestGiver();
if(bValid)
{
qst = quest_giver->FindQuest(quest_id, QUESTGIVER_QUEST_END);
if(!qst)
{
OUT_DEBUG("WARNING: Cannot complete quest, as it doesnt exist.");
return;
}
status = sQuestMgr.CalcQuestStatus(qst_giver, GetPlayer(), qst, (uint8)quest_giver->GetQuestRelation(qst->id),false);
}
}
if (!qst_giver)
{
OUT_DEBUG("WORLD: Invalid questgiver GUID.");
return;
}
if (!bValid || qst == NULL)
{
OUT_DEBUG("WORLD: Creature is not a questgiver.");
return;
}
if (status == QMGR_QUEST_FINISHED)
{
WorldPacket data;
sQuestMgr.BuildOfferReward(&data, qst, qst_giver, 1, language, _player);
SendPacket(&data);
DEBUG_LOG( "WORLD","Sent SMSG_QUESTGIVER_REQUEST_ITEMS." );
}
// if we got here it means we're cheating
}
void WorldSession::HandleQuestgiverAcceptQuestOpcode( WorldPacket & recv_data )
{
DEBUG_LOG( "WORLD"," Received CMSG_QUESTGIVER_ACCEPT_QUEST" );
CHECK_INWORLD_RETURN;
//WorldPacket data;
uint64 guid;
uint32 quest_id;
uint32 unk;
recv_data >> guid;
recv_data >> quest_id;
recv_data >> unk;
bool bValid = false;
bool hasquest = true;
bool bSkipLevelCheck = false;
Quest *qst = NULL;
Object* qst_giver = NULLOBJ;
uint32 guidtype = GET_TYPE_FROM_GUID(guid);
if(guidtype == HIGHGUID_TYPE_CREATURE)
{
Creature* quest_giver = _player->GetMapMgr()->GetCreature(GET_LOWGUID_PART(guid));
if(quest_giver)
qst_giver = TO_OBJECT(quest_giver);
else
return;
bValid = quest_giver->isQuestGiver();
hasquest = quest_giver->HasQuest(quest_id, 1);
if(bValid)
qst = QuestStorage.LookupEntry(quest_id);
}
else if(guidtype==HIGHGUID_TYPE_GAMEOBJECT)
{
GameObject* quest_giver = _player->GetMapMgr()->GetGameObject(GET_LOWGUID_PART(guid));
if(quest_giver)
qst_giver = TO_OBJECT(quest_giver);
else
return;
//bValid = quest_giver->isQuestGiver();
//if(bValid)
bValid = true;
qst = QuestStorage.LookupEntry(quest_id);
}
else if(guidtype==HIGHGUID_TYPE_ITEM)
{
Item* quest_giver = GetPlayer()->GetItemInterface()->GetItemByGUID(guid);
if(quest_giver)
qst_giver = TO_OBJECT(quest_giver);
else
return;
bValid = true;
bSkipLevelCheck=true;
qst = QuestStorage.LookupEntry(quest_id);
if( qst && qst->id != quest_giver->GetProto()->QuestId )
return;
}
else if(guidtype==HIGHGUID_TYPE_PLAYER)
{
Player* quest_giver = _player->GetMapMgr()->GetPlayer((uint32)guid);
if(quest_giver)
qst_giver = TO_OBJECT(quest_giver);
else
return;
bValid = true;
qst = QuestStorage.LookupEntry(quest_id);
}
if (!qst_giver)
{
OUT_DEBUG("WORLD: Invalid questgiver GUID.");
return;
}
if( !bValid || qst == NULL )
{
OUT_DEBUG("WORLD: Creature is not a questgiver.");
return;
}
if( _player->GetQuestLogForEntry( qst->id ) )
return;
if( qst_giver->GetTypeId() == TYPEID_UNIT && TO_CREATURE( qst_giver )->m_escorter != NULL )
{
SystemMessage("You cannot accept this quest at this time.");
return;
}
// Check the player hasn't already taken this quest, or
// it isn't available.
uint32 status = sQuestMgr.CalcQuestStatus(_player,qst,3, bSkipLevelCheck);
if((!sQuestMgr.IsQuestRepeatable(qst) && _player->HasFinishedQuest(qst->id)) || ( status != QMGR_QUEST_AVAILABLE && status != QMGR_QUEST_REPEATABLE && status != QMGR_QUEST_CHAT )
|| !hasquest)
{
// We've got a hacker. Disconnect them.
//sWorld.LogCheater(this, "tried to accept incompatible quest %u from %u.", qst->id, qst_giver->GetEntry());
//Disconnect();
return;
}
int32 log_slot = _player->GetOpenQuestSlot();
if (log_slot == -1)
{
sQuestMgr.SendQuestLogFull(GetPlayer());
return;
}
//FIXME
/*if(Player Has Timed quest && qst->HasFlag(QUEST_FLAG_TIMED))
sQuestMgr.SendQuestInvalid(INVALID_REASON_HAVE_TIMED_QUEST);*/
if(qst->count_receiveitems || qst->srcitem)
{
uint32 slots_required = qst->count_receiveitems;
if(_player->GetItemInterface()->CalculateFreeSlots(NULL) < slots_required)
{
_player->GetItemInterface()->BuildInventoryChangeError(NULLITEM, NULLITEM, INV_ERR_BAG_FULL);
sQuestMgr.SendQuestFailed(FAILED_REASON_INV_FULL, qst, _player);
return;
}
}
/* if(qst_giver->GetTypeId() == TYPEID_UNIT && !ScriptSystem->OnQuestRequireEvent(qst, TO_CREATURE( qst_giver ), _player, QUEST_EVENT_CAN_ACCEPT))
return;*/
QuestLogEntry *qle = new QuestLogEntry();
qle->Init(qst, _player, log_slot);
qle->UpdatePlayerFields();
// If the quest should give any items on begin, give them the items.
for(uint32 i = 0; i < 4; i++)
{
if(qst->receive_items[i])
{
Item* item = objmgr.CreateItem( qst->receive_items[i], GetPlayer());
if(item)
{
if(!_player->GetItemInterface()->AddItemToFreeSlot(item))
{
item->DeleteMe();
item = NULLITEM;
}
else
SendItemPushResult(item, false, true, false, true,
_player->GetItemInterface()->LastSearchItemBagSlot(), _player->GetItemInterface()->LastSearchItemSlot(),
1);
}
}
}
if(qst->srcitem && qst->srcitem != qst->receive_items[0])
{
Item* item = objmgr.CreateItem( qst->srcitem, _player );
if(item)
{
item->SetUInt32Value(ITEM_FIELD_STACK_COUNT, qst->srcitemcount ? qst->srcitemcount : 1);
if(!_player->GetItemInterface()->AddItemToFreeSlot(item))
{
item->DeleteMe();
item = NULLITEM;
}
}
}
if(qst->count_required_item || qst_giver->GetTypeId() == TYPEID_GAMEOBJECT) // gameobject quests deactivate
_player->UpdateNearbyGameObjects();
CALL_QUESTSCRIPT_EVENT(qst->id, OnQuestStart)(_player, qle);
sQuestMgr.OnQuestAccepted(_player,qst,qst_giver);
if(qst->start_phase != 0 )
_player->SetPhaseMask(qst->start_phase, true);
sHookInterface.OnQuestAccept(_player, qst, qst_giver);
}
void WorldSession::HandleQuestGiverQueryQuestOpcode( WorldPacket & recv_data )
{
DEBUG_LOG( "WORLD"," Received CMSG_QUESTGIVER_QUERY_QUEST." );
CHECK_INWORLD_RETURN;
WorldPacket data;
uint64 guid;
uint32 quest_id;
uint32 status = 0;
recv_data >> guid;
recv_data >> quest_id;
Object* qst_giver = NULLOBJ;
bool bValid = false;
Quest* qst = QuestStorage.LookupEntry(quest_id);
if (!qst)
{
OUT_DEBUG("WORLD: Invalid quest ID.");
return;
}
uint32 guidtype = GET_TYPE_FROM_GUID(guid);
if(guidtype == HIGHGUID_TYPE_CREATURE)
{
Creature* quest_giver = _player->GetMapMgr()->GetCreature(GET_LOWGUID_PART(guid));
if(quest_giver)
qst_giver = quest_giver;
else
return;
bValid = quest_giver->isQuestGiver();
if(bValid)
status = sQuestMgr.CalcQuestStatus(GetPlayer(), qst, (uint8)quest_giver->GetQuestRelation(qst->id), false);
}
else if(guidtype == HIGHGUID_TYPE_GAMEOBJECT)
{
GameObject* quest_giver = _player->GetMapMgr()->GetGameObject(GET_LOWGUID_PART(guid));
if(quest_giver)
qst_giver = TO_OBJECT(quest_giver);
else
return;
bValid = quest_giver->isQuestGiver();
if(bValid)
status = sQuestMgr.CalcQuestStatus(GetPlayer(), qst, (uint8)quest_giver->GetQuestRelation(qst->id), false);
}
else if(guidtype==HIGHGUID_TYPE_ITEM)
{
Item* quest_giver = GetPlayer()->GetItemInterface()->GetItemByGUID(guid);
if(quest_giver)
qst_giver = TO_OBJECT(quest_giver);
else
return;
bValid = true;
if( qst->id != quest_giver->GetProto()->QuestId )
return;
status = sQuestMgr.CalcQuestStatus(GetPlayer(), qst, 1, false);
}
if (!qst_giver)
{
OUT_DEBUG("WORLD: Invalid questgiver GUID.");
return;
}
if (!bValid)
{
OUT_DEBUG("WORLD: object is not a questgiver.");
return;
}
/*if (!qst_giver->FindQuest(quest_id, QUESTGIVER_QUEST_START | QUESTGIVER_QUEST_END))
{
OUT_DEBUG("WORLD: QuestGiver doesn't have that quest.");
return;
}*/ // bleh.. not needed.. maybe for antihack later on would be a good idea though
if ((status == QMGR_QUEST_AVAILABLE) || (status == QMGR_QUEST_REPEATABLE) || (status == QMGR_QUEST_CHAT))
{
sQuestMgr.BuildQuestDetails(&data, qst, qst_giver, 1, language, _player); // 0 because we want goodbye to function
SendPacket(&data);
OUT_DEBUG( "WORLD: Sent SMSG_QUESTGIVER_QUEST_DETAILS." );
}
/*else if (status == QMGR_QUEST_FINISHED)
{
sQuestMgr.BuildOfferReward(&data, qst, qst_giver, 1);
SendPacket(&data);
DEBUG_LOG( "WORLD"," Sent SMSG_QUESTGIVER_OFFER_REWARD." );
}*/
else if (status == QMGR_QUEST_NOT_FINISHED || status == QMGR_QUEST_FINISHED)
{
sQuestMgr.BuildRequestItems(&data, qst, qst_giver, status, language);
SendPacket(&data);
DEBUG_LOG( "WORLD"," Sent SMSG_QUESTGIVER_REQUEST_ITEMS." );
}
}
initialiseSingleton(QuestMgr);
void WorldSession::HandleQuestgiverStatusQueryOpcode(WorldPacket& recv_data)
{
CHECK_INWORLD_RETURN
if (_player->IsInBg())
return; //Added in 3.0.2, quests can be shared anywhere besides a BG
uint64 guid;
WorldPacket data(SMSG_QUESTGIVER_STATUS, 12);
Object* qst_giver = NULL;
recv_data >> guid;
uint32 guidtype = GET_TYPE_FROM_GUID(guid);
if (guidtype == HIGHGUID_TYPE_UNIT)
{
Creature* quest_giver = _player->GetMapMgr()->GetCreature(GET_LOWGUID_PART(guid));
if (quest_giver)
qst_giver = quest_giver;
else
return;
if (!quest_giver->isQuestGiver())
{
LOG_DEBUG("WORLD: Creature is not a questgiver.");
return;
}
}
else if (guidtype == HIGHGUID_TYPE_ITEM)
