void
ObjectAccessor::AddCorpse(Corpse* corpse)
{
BLIZZLIKE_ASSERT(corpse && corpse->GetType() != CORPSE_BONES);
Guard guard(i_corpseGuard);
BLIZZLIKE_ASSERT(i_player2corpse.find(corpse->GetOwnerGuid()) == i_player2corpse.end());
i_player2corpse[corpse->GetOwnerGuid()] = corpse;
// build mapid*cellid -> guid_set map
CellPair cell_pair = BlizzLike::ComputeCellPair(corpse->GetPositionX(), corpse->GetPositionY());
uint32 cell_id = (cell_pair.y_coord * TOTAL_NUMBER_OF_CELLS_PER_MAP) + cell_pair.x_coord;
sObjectMgr.AddCorpseCellData(corpse->GetMapId(), cell_id, corpse->GetOwnerGuid().GetCounter(), corpse->GetInstanceId());
}
MovementGenerator* selectMovementGenerator(Creature* creature)
{
MovementGeneratorRegistry& mv_registry(MovementGeneratorRepository::Instance());
BLIZZLIKE_ASSERT(creature->GetCreatureInfo() != NULL);
MovementGeneratorCreator const* mv_factory = mv_registry.GetRegistryItem(
creature->GetOwnerGuid().IsPlayer() ? FOLLOW_MOTION_TYPE : creature->GetDefaultMovementType());
/* if( mv_factory == NULL )
{
int best_val = -1;
std::vector<std::string> l;
mv_registry.GetRegisteredItems(l);
for( std::vector<std::string>::iterator iter = l.begin(); iter != l.end(); ++iter)
{
const MovementGeneratorCreator *factory = mv_registry.GetRegistryItem((*iter).c_str());
const SelectableMovement *p = dynamic_cast<const SelectableMovement *>(factory);
ASSERT( p != NULL );
int val = p->Permit(creature);
if( val > best_val )
{
best_val = val;
mv_factory = p;
}
}
}*/
return (mv_factory == NULL ? NULL : mv_factory->Create(creature));
}
TransportInfo::TransportInfo(WorldObject* owner, TransportBase* transport, float lx, float ly, float lz, float lo) :
m_owner(owner),
m_transport(transport),
m_localPosition(lx, ly, lz, lo)
{
BLIZZLIKE_ASSERT(owner && m_transport);
}
void SqlPlainPreparedStatement::bind(const SqlStmtParameters& holder)
{
// verify if we bound all needed input parameters
if (m_nParams != holder.boundParams())
{
BLIZZLIKE_ASSERT(false);
return;
}
// reset resulting plain SQL request
m_szPlainRequest = m_szFmt;
size_t nLastPos = 0;
SqlStmtParameters::ParameterContainer const& _args = holder.params();
SqlStmtParameters::ParameterContainer::const_iterator iter_last = _args.end();
for (SqlStmtParameters::ParameterContainer::const_iterator iter = _args.begin(); iter != iter_last; ++iter)
{
// bind parameter
const SqlStmtFieldData& data = (*iter);
std::ostringstream fmt;
DataToString(data, fmt);
nLastPos = m_szPlainRequest.find('?', nLastPos);
if (nLastPos != std::string::npos)
{
std::string tmp = fmt.str();
m_szPlainRequest.replace(nLastPos, 1, tmp);
nLastPos += tmp.length();
}
}
}
void WaypointMovementGenerator<Creature>::OnArrived(Creature& creature)
{
if (!i_path || i_path->empty())
return;
m_lastReachedWaypoint = i_currentNode;
if (m_isArrivalDone)
return;
creature.clearUnitState(UNIT_STAT_ROAMING_MOVE);
m_isArrivalDone = true;
WaypointPath::const_iterator currPoint = i_path->find(i_currentNode);
BLIZZLIKE_ASSERT(currPoint != i_path->end());
WaypointNode const& node = currPoint->second;
if (node.script_id)
{
DEBUG_FILTER_LOG(LOG_FILTER_AI_AND_MOVEGENSS, "Creature movement start script %u at point %u for %s.", node.script_id, i_currentNode, creature.GetGuidStr().c_str());
creature.GetMap()->ScriptsStart(sCreatureMovementScripts, node.script_id, &creature, &creature);
}
// We have reached the destination and can process behavior
if (WaypointBehavior* behavior = node.behavior)
{
if (behavior->emote != 0)
creature.HandleEmote(behavior->emote);
if (behavior->spell != 0)
creature.CastSpell(&creature, behavior->spell, false);
if (behavior->model1 != 0)
creature.SetDisplayId(behavior->model1);
if (behavior->textid[0])
{
// Not only one text is set
if (behavior->textid[1])
{
// Select one from max 5 texts (0 and 1 already checked)
int i = 2;
for (; i < MAX_WAYPOINT_TEXT; ++i)
{
if (!behavior->textid[i])
break;
}
creature.MonsterSay(behavior->textid[rand() % i], LANG_UNIVERSAL);
}
else
creature.MonsterSay(behavior->textid[0], LANG_UNIVERSAL);
}
}
// Inform script
MovementInform(creature);
Stop(node.delay);
}
TransportBase::TransportBase(WorldObject* owner) :
m_owner(owner),
m_lastPosition(owner->GetPositionX(), owner->GetPositionY(), owner->GetPositionZ(), owner->GetOrientation()),
m_sinO(sin(m_lastPosition.o)),
m_cosO(cos(m_lastPosition.o)),
m_updatePositionsTimer(500)
{
BLIZZLIKE_ASSERT(m_owner);
}
void Bag::RemoveItem(uint8 slot, bool /*update*/)
{
BLIZZLIKE_ASSERT(slot < MAX_BAG_SIZE);
if (m_bagslot[slot])
m_bagslot[slot]->SetContainer(NULL);
m_bagslot[slot] = NULL;
SetGuidValue(CONTAINER_FIELD_SLOT_1 + (slot * 2), ObjectGuid());
}
CreatureAI* selectAI(Creature* creature)
{
// Allow scripting AI for normal creatures and not controlled pets (guardians and mini-pets)
if ((!creature->IsPet() || !((Pet*)creature)->isControlled()) && !creature->isCharmed())
if (CreatureAI* scriptedAI = sScriptMgr.GetCreatureAI(creature))
return scriptedAI;
CreatureAIRegistry& ai_registry(CreatureAIRepository::Instance());
const CreatureAICreator* ai_factory = NULL;
std::string ainame = creature->GetAIName();
// select by NPC flags _first_ - otherwise EventAI might be choosen for pets/totems
// excplicit check for isControlled() and owner type to allow guardian, mini-pets and pets controlled by NPCs to be scripted by EventAI
Unit* owner = NULL;
if ((creature->IsPet() && ((Pet*)creature)->isControlled() &&
((owner = creature->GetOwner()) && owner->GetTypeId() == TYPEID_PLAYER)) || creature->isCharmed())
ai_factory = ai_registry.GetRegistryItem("PetAI");
else if (creature->IsTotem())
ai_factory = ai_registry.GetRegistryItem("TotemAI");
// select by script name
if (!ai_factory && !ainame.empty())
ai_factory = ai_registry.GetRegistryItem(ainame.c_str());
if (!ai_factory && creature->IsGuard())
ai_factory = ai_registry.GetRegistryItem("GuardAI");
// select by permit check
if (!ai_factory)
{
int best_val = PERMIT_BASE_NO;
typedef CreatureAIRegistry::RegistryMapType RMT;
RMT const& l = ai_registry.GetRegisteredItems();
for (RMT::const_iterator iter = l.begin(); iter != l.end(); ++iter)
{
const CreatureAICreator* factory = iter->second;
const SelectableAI* p = dynamic_cast<const SelectableAI*>(factory);
BLIZZLIKE_ASSERT(p != NULL);
int val = p->Permit(creature);
if (val > best_val)
{
best_val = val;
ai_factory = p;
}
}
}
// select NullCreatureAI if not another cases
ainame = (ai_factory == NULL) ? "NullCreatureAI" : ai_factory->key();
DEBUG_FILTER_LOG(LOG_FILTER_AI_AND_MOVEGENSS, "Creature %u used AI is %s.", creature->GetGUIDLow(), ainame.c_str());
return (ai_factory == NULL ? new NullCreatureAI(creature) : ai_factory->Create(creature));
}
Corpse*
ObjectAccessor::GetCorpseForPlayerGUID(ObjectGuid guid)
{
Guard guard(i_corpseGuard);
Player2CorpsesMapType::iterator iter = i_player2corpse.find(guid);
if (iter == i_player2corpse.end())
return NULL;
BLIZZLIKE_ASSERT(iter->second->GetType() != CORPSE_BONES);
return iter->second;
}
int WorldSocket::handle_input_payload(void)
{
// set errno properly here on error !!!
// now have a header and payload
BLIZZLIKE_ASSERT(m_RecvPct.space() == 0);
BLIZZLIKE_ASSERT(m_Header.space() == 0);
BLIZZLIKE_ASSERT(m_RecvWPct != NULL);
const int ret = ProcessIncoming(m_RecvWPct);
m_RecvPct.base(NULL, 0);
m_RecvPct.reset();
m_RecvWPct = NULL;
m_Header.reset();
if (ret == -1)
errno = EINVAL;
return ret;
}
int WorldSocket::handle_input_header(void)
{
BLIZZLIKE_ASSERT(m_RecvWPct == NULL);
BLIZZLIKE_ASSERT(m_Header.length() == sizeof(ClientPktHeader));
m_Crypt.DecryptRecv((uint8*) m_Header.rd_ptr(), sizeof(ClientPktHeader));
ClientPktHeader& header = *((ClientPktHeader*) m_Header.rd_ptr());
EndianConvertReverse(header.size);
EndianConvert(header.cmd);
if ((header.size < 4) || (header.size > 10240) || (header.cmd > 10240))
{
sLog.outError("WorldSocket::handle_input_header: client sent malformed packet size = %d , cmd = %d",
header.size, header.cmd);
errno = EINVAL;
return -1;
}
header.size -= 4;
ACE_NEW_RETURN(m_RecvWPct, WorldPacket(Opcodes(header.cmd), header.size), -1);
if (header.size > 0)
{
m_RecvWPct->resize(header.size);
m_RecvPct.base((char*) m_RecvWPct->contents(), m_RecvWPct->size());
}
else
{
BLIZZLIKE_ASSERT(m_RecvPct.space() == 0);
}
return 0;
}
void Bag::StoreItem(uint8 slot, Item* pItem, bool /*update*/)
{
BLIZZLIKE_ASSERT(slot < MAX_BAG_SIZE);
if (pItem)
{
m_bagslot[slot] = pItem;
SetGuidValue(CONTAINER_FIELD_SLOT_1 + (slot * 2), pItem->GetObjectGuid());
pItem->SetGuidValue(ITEM_FIELD_CONTAINED, GetObjectGuid());
pItem->SetGuidValue(ITEM_FIELD_OWNER, GetOwnerGuid());
pItem->SetContainer(this);
pItem->SetSlot(slot);
}
}
int32 BattleGroundAB::_GetNodeNameId(uint8 node)
{
switch (node)
{
case BG_AB_NODE_STABLES: return LANG_BG_AB_NODE_STABLES;
case BG_AB_NODE_BLACKSMITH: return LANG_BG_AB_NODE_BLACKSMITH;
case BG_AB_NODE_FARM: return LANG_BG_AB_NODE_FARM;
case BG_AB_NODE_LUMBER_MILL:return LANG_BG_AB_NODE_LUMBER_MILL;
case BG_AB_NODE_GOLD_MINE: return LANG_BG_AB_NODE_GOLD_MINE;
default:
BLIZZLIKE_ASSERT(0);
}
return 0;
}
bool SqlStatement::DirectExecute()
{
SqlStmtParameters* args = detach();
// verify amount of bound parameters
if (args->boundParams() != arguments())
{
sLog.outError("SQL ERROR: wrong amount of parameters (%i instead of %i)", args->boundParams(), arguments());
sLog.outError("SQL ERROR: statement: %s", m_pDB->GetStmtString(ID()).c_str());
BLIZZLIKE_ASSERT(false);
return false;
}
return m_pDB->DirectExecuteStmt(m_index, args);
}
bool WaypointMovementGenerator<Creature>::GetResetPosition(Creature&, float& x, float& y, float& z) const
{
// prevent a crash at empty waypoint path.
if (!i_path || i_path->empty())
return false;
WaypointPath::const_iterator lastPoint = i_path->find(m_lastReachedWaypoint);
// Special case: Before the first waypoint is reached, m_lastReachedWaypoint is set to 0 (which may not be contained in i_path)
if (!m_lastReachedWaypoint && lastPoint == i_path->end())
return false;
BLIZZLIKE_ASSERT(lastPoint != i_path->end());
x = lastPoint->second.x; y = lastPoint->second.y; z = lastPoint->second.z;
return true;
}
void WaypointMovementGenerator<Creature>::StartMove(Creature& creature)
{
if (!i_path || i_path->empty())
return;
if (Stopped(creature))
return;
if (!creature.isAlive() || creature.hasUnitState(UNIT_STAT_NOT_MOVE))
return;
WaypointPath::const_iterator currPoint = i_path->find(i_currentNode);
BLIZZLIKE_ASSERT(currPoint != i_path->end());
if (WaypointBehavior* behavior = currPoint->second.behavior)
{
if (behavior->model2 != 0)
creature.SetDisplayId(behavior->model2);
creature.SetUInt32Value(UNIT_NPC_EMOTESTATE, 0);
}
if (m_isArrivalDone)
{
++currPoint;
if (currPoint == i_path->end())
currPoint = i_path->begin();
i_currentNode = currPoint->first;
}
m_isArrivalDone = false;
creature.addUnitState(UNIT_STAT_ROAMING_MOVE);
WaypointNode const& nextNode = currPoint->second;;
Movement::MoveSplineInit init(creature);
init.MoveTo(nextNode.x, nextNode.y, nextNode.z, true);
if (nextNode.orientation != 100 && nextNode.delay != 0)
init.SetFacing(nextNode.orientation);
creature.SetWalk(!creature.hasUnitState(UNIT_STAT_RUNNING_STATE) && !creature.IsLevitating(), false);
init.Launch();
}
void
ObjectAccessor::RemoveCorpse(Corpse* corpse)
{
BLIZZLIKE_ASSERT(corpse && corpse->GetType() != CORPSE_BONES);
Guard guard(i_corpseGuard);
Player2CorpsesMapType::iterator iter = i_player2corpse.find(corpse->GetOwnerGuid());
if (iter == i_player2corpse.end())
return;
// build mapid*cellid -> guid_set map
CellPair cell_pair = BlizzLike::ComputeCellPair(corpse->GetPositionX(), corpse->GetPositionY());
uint32 cell_id = (cell_pair.y_coord * TOTAL_NUMBER_OF_CELLS_PER_MAP) + cell_pair.x_coord;
sObjectMgr.DeleteCorpseCellData(corpse->GetMapId(), cell_id, corpse->GetOwnerGuid().GetCounter());
corpse->RemoveFromWorld();
i_player2corpse.erase(iter);
}
/**
* What - if any - kind of explanation mark or question-mark should a quest-giver display for a player
* @param pPlayer - for whom
* @param questgiver - from whom
* @param defstatus - initial set status (usually it will be called with DIALOG_STATUS_NONE) - must not be DIALOG_STATUS_UNDEFINED
*/
uint32 WorldSession::getDialogStatus(Player* pPlayer, Object* questgiver, uint32 defstatus)
{
BLIZZLIKE_ASSERT(defstatus != DIALOG_STATUS_UNDEFINED);
uint32 dialogStatus = defstatus;
QuestRelationsMapBounds rbounds; // QuestRelations (quest-giver)
QuestRelationsMapBounds irbounds; // InvolvedRelations (quest-finisher)
switch (questgiver->GetTypeId())
{
case TYPEID_UNIT:
{
rbounds = sObjectMgr.GetCreatureQuestRelationsMapBounds(questgiver->GetEntry());
irbounds = sObjectMgr.GetCreatureQuestInvolvedRelationsMapBounds(questgiver->GetEntry());
break;
}
case TYPEID_GAMEOBJECT:
{
rbounds = sObjectMgr.GetGOQuestRelationsMapBounds(questgiver->GetEntry());
irbounds = sObjectMgr.GetGOQuestInvolvedRelationsMapBounds(questgiver->GetEntry());
break;
}
default:
// it's impossible, but check ^)
sLog.outError("Warning: GetDialogStatus called for unexpected type %u", questgiver->GetTypeId());
return DIALOG_STATUS_NONE;
}
// Check markings for quest-finisher
for (QuestRelationsMap::const_iterator itr = irbounds.first; itr != irbounds.second; ++itr)
{
uint32 dialogStatusNew = DIALOG_STATUS_NONE;
uint32 quest_id = itr->second;
Quest const* pQuest = sObjectMgr.GetQuestTemplate(quest_id);
if (!pQuest || !pQuest->IsActive())
continue;
QuestStatus status = pPlayer->GetQuestStatus(quest_id);
if ((status == QUEST_STATUS_COMPLETE && !pPlayer->GetQuestRewardStatus(quest_id)) ||
(pQuest->IsAutoComplete() && pPlayer->CanTakeQuest(pQuest, false)))
{
if (pQuest->IsAutoComplete() && pQuest->IsRepeatable())
dialogStatusNew = DIALOG_STATUS_REWARD_REP;
else
dialogStatusNew = DIALOG_STATUS_REWARD;
}
else if (status == QUEST_STATUS_INCOMPLETE)
dialogStatusNew = DIALOG_STATUS_INCOMPLETE;
if (dialogStatusNew > dialogStatus)
dialogStatus = dialogStatusNew;
}
// check markings for quest-giver
for (QuestRelationsMap::const_iterator itr = rbounds.first; itr != rbounds.second; ++itr)
{
uint32 dialogStatusNew = DIALOG_STATUS_NONE;
uint32 quest_id = itr->second;
Quest const* pQuest = sObjectMgr.GetQuestTemplate(quest_id);
if (!pQuest || !pQuest->IsActive())
continue;
QuestStatus status = pPlayer->GetQuestStatus(quest_id);
if (status == QUEST_STATUS_NONE) // For all other cases the mark is handled either at some place else, or with involved-relations already
{
if (pPlayer->CanSeeStartQuest(pQuest))
{
if (pPlayer->SatisfyQuestLevel(pQuest, false))
{
int32 lowLevelDiff = sWorld.getConfig(CONFIG_INT32_QUEST_LOW_LEVEL_HIDE_DIFF);
if (pQuest->IsAutoComplete() || (pQuest->IsRepeatable() && pPlayer->getQuestStatusMap()[quest_id].m_rewarded))
{
dialogStatusNew = DIALOG_STATUS_REWARD_REP;
}
else if (lowLevelDiff < 0 || pPlayer->getLevel() <= pPlayer->GetQuestLevelForPlayer(pQuest) + uint32(lowLevelDiff))
{
if (pQuest->HasQuestFlag(QUEST_FLAGS_DAILY))
dialogStatusNew = DIALOG_STATUS_AVAILABLE_REP;
else
dialogStatusNew = DIALOG_STATUS_AVAILABLE;
}
else
dialogStatusNew = DIALOG_STATUS_CHAT;
}
else
dialogStatusNew = DIALOG_STATUS_UNAVAILABLE;
}
}
if (dialogStatusNew > dialogStatus)
dialogStatus = dialogStatusNew;
}
return dialogStatus;
}
TransportBase::~TransportBase()
{
BLIZZLIKE_ASSERT(m_passengers.size() == 0);
}
int WorldSocket::ProcessIncoming(WorldPacket* new_pct)
{
BLIZZLIKE_ASSERT(new_pct);
// manage memory ;)
ACE_Auto_Ptr<WorldPacket> aptr(new_pct);
const ACE_UINT16 opcode = new_pct->GetOpcode();
if (opcode >= NUM_MSG_TYPES)
{
sLog.outError("SESSION: received nonexistent opcode 0x%.4X", opcode);
return -1;
}
if (closing_)
return -1;
// Dump received packet.
sLog.outWorldPacketDump(uint32(get_handle()), new_pct->GetOpcode(), new_pct->GetOpcodeName(), new_pct, true);
try
{
switch (opcode)
{
case CMSG_PING:
return HandlePing(*new_pct);
case CMSG_AUTH_SESSION:
if (m_Session)
{
sLog.outError("WorldSocket::ProcessIncoming: Player send CMSG_AUTH_SESSION again");
return -1;
}
return HandleAuthSession(*new_pct);
case CMSG_KEEP_ALIVE:
DEBUG_LOG("CMSG_KEEP_ALIVE ,size: " SIZEFMTD " ", new_pct->size());
return 0;
default:
{
ACE_GUARD_RETURN(LockType, Guard, m_SessionLock, -1);
if (m_Session != NULL)
{
// OK ,give the packet to WorldSession
aptr.release();
// WARNING here we call it with locks held.
// Its possible to cause deadlock if QueuePacket calls back
m_Session->QueuePacket(new_pct);
return 0;
}
else
{
sLog.outError("WorldSocket::ProcessIncoming: Client not authed opcode = %u", uint32(opcode));
return -1;
}
}
}
}
catch (ByteBufferException&)
{
sLog.outError("WorldSocket::ProcessIncoming ByteBufferException occured while parsing an instant handled packet (opcode: %u) from client %s, accountid=%i.",
opcode, GetRemoteAddress().c_str(), m_Session ? m_Session->GetAccountId() : -1);
if (sLog.HasLogLevelOrHigher(LOG_LVL_DEBUG))
{
DEBUG_LOG("Dumping error-causing packet:");
new_pct->hexlike();
}
if (sWorld.getConfig(CONFIG_BOOL_KICK_PLAYER_ON_BAD_PACKET))
{
DETAIL_LOG("Disconnecting session [account id %i / address %s] for badly formatted packet.",
m_Session ? m_Session->GetAccountId() : -1, GetRemoteAddress().c_str());
return -1;
}
else
return 0;
}
ACE_NOTREACHED(return 0);
}
int WorldSocket::handle_input_missing_data(void)
{
char buf [4096];
ACE_Data_Block db(sizeof(buf),
ACE_Message_Block::MB_DATA,
buf,
0,
0,
ACE_Message_Block::DONT_DELETE,
0);
ACE_Message_Block message_block(&db,
ACE_Message_Block::DONT_DELETE,
0);
const size_t recv_size = message_block.space();
const ssize_t n = peer().recv(message_block.wr_ptr(),
recv_size);
if (n <= 0)
return (int)n;
message_block.wr_ptr(n);
while (message_block.length() > 0)
{
if (m_Header.space() > 0)
{
// need to receive the header
const size_t to_header = (message_block.length() > m_Header.space() ? m_Header.space() : message_block.length());
m_Header.copy(message_block.rd_ptr(), to_header);
message_block.rd_ptr(to_header);
if (m_Header.space() > 0)
{
// Couldn't receive the whole header this time.
BLIZZLIKE_ASSERT(message_block.length() == 0);
errno = EWOULDBLOCK;
return -1;
}
// We just received nice new header
if (handle_input_header() == -1)
{
BLIZZLIKE_ASSERT((errno != EWOULDBLOCK) && (errno != EAGAIN));
return -1;
}
}
// Its possible on some error situations that this happens
// for example on closing when epoll receives more chunked data and stuff
// hope this is not hack ,as proper m_RecvWPct is asserted around
if (!m_RecvWPct)
{
sLog.outError("Forcing close on input m_RecvWPct = NULL");
errno = EINVAL;
return -1;
}
// We have full read header, now check the data payload
if (m_RecvPct.space() > 0)
{
// need more data in the payload
const size_t to_data = (message_block.length() > m_RecvPct.space() ? m_RecvPct.space() : message_block.length());
m_RecvPct.copy(message_block.rd_ptr(), to_data);
message_block.rd_ptr(to_data);
if (m_RecvPct.space() > 0)
{
// Couldn't receive the whole data this time.
BLIZZLIKE_ASSERT(message_block.length() == 0);
errno = EWOULDBLOCK;
return -1;
}
}
// just received fresh new payload
if (handle_input_payload() == -1)
{
BLIZZLIKE_ASSERT((errno != EWOULDBLOCK) && (errno != EAGAIN));
return -1;
}
}
return size_t(n) == recv_size ? 1 : 2;
}
BarGoLink::BarGoLink(uint64 row_count)
{
BLIZZLIKE_ASSERT(row_count < (uint64)ACE_INT32_MAX);
init((int)row_count);
}
void AuctionHouseMgr::AddAItem(Item* it)
{
BLIZZLIKE_ASSERT(it);
BLIZZLIKE_ASSERT(mAitems.find(it->GetGUIDLow()) == mAitems.end());
mAitems[it->GetGUIDLow()] = it;
}