void AuctionHouseMgr::SendAuctionSalePendingMail(AuctionEntry * auction,
SQLTransaction& trans) {
uint64 owner_guid = MAKE_NEW_GUID(auction->owner, 0, HIGHGUID_PLAYER);
Player *owner = sObjectMgr->GetPlayer(owner_guid);
uint32 owner_accId = sObjectMgr->GetPlayerAccountIdByGUID(owner_guid);
// owner exist (online or offline)
if (owner || owner_accId) {
std::ostringstream msgAuctionSalePendingSubject;
msgAuctionSalePendingSubject << auction->item_template << ":0:"
<< AUCTION_SALE_PENDING;
std::ostringstream msgAuctionSalePendingBody;
uint32 auctionCut = auction->GetAuctionCut();
time_t distrTime = time(NULL)
+ sWorld->getIntConfig(CONFIG_MAIL_DELIVERY_DELAY);
msgAuctionSalePendingBody.width(16);
msgAuctionSalePendingBody << std::right << std::hex << auction->bidder;
msgAuctionSalePendingBody << std::dec << ":" << auction->bid << ":"
<< auction->buyout;
msgAuctionSalePendingBody << ":" << auction->deposit << ":"
<< auctionCut << ":0:";
msgAuctionSalePendingBody << secsToTimeBitFields(distrTime);
sLog->outDebug(LOG_FILTER_AUCTIONHOUSE,
"AuctionSalePending body string : %s",
msgAuctionSalePendingBody.str().c_str());
MailDraft(msgAuctionSalePendingSubject.str(),
msgAuctionSalePendingBody.str()).SendMailTo(trans,
MailReceiver(owner, auction->owner), auction,
MAIL_CHECK_MASK_COPIED);
}
}
void CalendarMgr::SendCalendarEventStatus(CalendarInvite const* invite)
{
DEBUG_FILTER_LOG(LOG_FILTER_CALENDAR, "SMSG_CALENDAR_EVENT_STATUS");
WorldPacket data(SMSG_CALENDAR_EVENT_STATUS, 8 + 8 + 4 + 4 + 1 + 1 + 4);
CalendarEvent const* event = invite->GetCalendarEvent();
data << invite->InviteeGuid.WriteAsPacked();
data << uint64(event->EventId);
data << secsToTimeBitFields(event->EventTime);
data << uint32(event->Flags);
data << uint8(invite->Status);
data << uint8(invite->Rank);
data << secsToTimeBitFields(invite->LastUpdateTime);
//data.hexlike();
SendPacketToAllEventRelatives(data, event);
}
void AuctionHouseMgr::SendAuctionSalePendingMail(AuctionEntry * auction)
{
uint64 owner_guid = MAKE_NEW_GUID(auction->owner, 0, HIGHGUID_PLAYER);
Player *owner = objmgr.GetPlayer(owner_guid);
uint32 owner_accId = objmgr.GetPlayerAccountIdByGUID(owner_guid);
// owner exist (online or offline)
if (owner || owner_accId)
{
std::ostringstream msgAuctionSalePendingSubject;
msgAuctionSalePendingSubject << auction->item_template << ":0:" << AUCTION_SALE_PENDING;
std::ostringstream msgAuctionSalePendingBody;
uint32 auctionCut = auction->GetAuctionCut();
time_t distrTime = time(NULL) + sWorld.getConfig(CONFIG_MAIL_DELIVERY_DELAY);
msgAuctionSalePendingBody.width(16);
msgAuctionSalePendingBody << std::right << std::hex << auction->bidder;
msgAuctionSalePendingBody << std::dec << ":" << auction->bid << ":" << auction->buyout;
msgAuctionSalePendingBody << ":" << auction->deposit << ":" << auctionCut << ":0:";
msgAuctionSalePendingBody << secsToTimeBitFields(distrTime);
sLog.outDebug("AuctionSalePending body string : %s", msgAuctionSalePendingBody.str().c_str());
uint32 itemTextId = objmgr.CreateItemText(msgAuctionSalePendingBody.str());
WorldSession::SendMailTo(owner, MAIL_AUCTION, MAIL_STATIONERY_AUCTION, auction->GetHouseId(), auction->owner, msgAuctionSalePendingSubject.str(), itemTextId, NULL, 0, 0, MAIL_CHECK_MASK_AUCTION);
}
}
void AuctionHouseMgr::SendAuctionSalePendingMail(AuctionEntry* auction)
{
ObjectGuid owner_guid = ObjectGuid(HIGHGUID_PLAYER, auction->owner);
Player* owner = sObjectMgr.GetPlayer(owner_guid);
// owner exist (online or offline)
if (owner || owner_guid && sObjectMgr.GetPlayerAccountIdByGUID(owner_guid))
{
std::ostringstream msgAuctionSalePendingSubject;
msgAuctionSalePendingSubject << auction->itemTemplate << ":" << auction->itemRandomPropertyId << ":" << AUCTION_SALE_PENDING;
std::ostringstream msgAuctionSalePendingBody;
uint32 auctionCut = auction->GetAuctionCut();
time_t distrTime = time(nullptr) + HOUR;
msgAuctionSalePendingBody.width(16);
msgAuctionSalePendingBody << std::right << std::hex << auction->bidder;
msgAuctionSalePendingBody << std::dec << ":" << auction->bid << ":" << auction->buyout;
msgAuctionSalePendingBody << ":" << auction->deposit << ":" << auctionCut << ":0:";
msgAuctionSalePendingBody << secsToTimeBitFields(distrTime);
DEBUG_LOG("AuctionSalePending body string : %s", msgAuctionSalePendingBody.str().c_str());
MailDraft(msgAuctionSalePendingSubject.str(), msgAuctionSalePendingBody.str())
.SendMailTo(MailReceiver(owner, owner_guid), auction, MAIL_CHECK_MASK_COPIED);
}
}
void CalendarMgr::SendCalendarEventInviteAlert(CalendarInvite const* invite)
{
DEBUG_LOG("WORLD: SMSG_CALENDAR_EVENT_INVITE_ALERT");
CalendarEvent const* event = invite->GetCalendarEvent();
if (!event)
return;
WorldPacket data(SMSG_CALENDAR_EVENT_INVITE_ALERT);
data << uint64(event->EventId);
data << event->Title;
data << secsToTimeBitFields(event->EventTime);
data << uint32(event->Flags);
data << uint32(event->Type);
data << int32(event->DungeonId);
data << uint64(invite->InviteId);
data << uint8(invite->Status);
data << uint8(invite->Rank);
data << event->CreatorGuid.WriteAsPacked();
data << invite->SenderGuid.WriteAsPacked();
//data.hexlike();
DEBUG_FILTER_LOG(LOG_FILTER_CALENDAR, "SendCalendarInviteAlert> senderGuid[%s], inviteeGuid[%s], EventId["UI64FMTD"], Status[%u], InviteId["UI64FMTD"]",
invite->SenderGuid.GetString().c_str(), invite->InviteeGuid.GetString().c_str(), event->EventId, uint32(invite->Status), invite->InviteId);
if (event->IsGuildEvent() || event->IsGuildAnnouncement())
{
if (Guild* guild = sGuildMgr.GetGuildById(event->GuildId))
guild->BroadcastPacket(&data);
}
else if (Player* player = sObjectMgr.GetPlayer(invite->InviteeGuid))
player->SendDirectMessage(&data);
}
void AuctionHouseMgr::SendAuctionSalePendingMail( AuctionEntry * auction )
{
uint64 owner_guid = MAKE_NEW_GUID(auction->owner, 0, HIGHGUID_PLAYER);
Player *owner = sObjectMgr.GetPlayer(owner_guid);
// owner exist (online or offline)
if(owner || sObjectMgr.GetPlayerAccountIdByGUID(owner_guid))
{
std::ostringstream msgAuctionSalePendingSubject;
msgAuctionSalePendingSubject << auction->item_template << ":0:" << AUCTION_SALE_PENDING;
std::ostringstream msgAuctionSalePendingBody;
uint32 auctionCut = auction->GetAuctionCut();
time_t distrTime = time(NULL) + HOUR;
msgAuctionSalePendingBody.width(16);
msgAuctionSalePendingBody << std::right << std::hex << auction->bidder;
msgAuctionSalePendingBody << std::dec << ":" << auction->bid << ":" << auction->buyout;
msgAuctionSalePendingBody << ":" << auction->deposit << ":" << auctionCut << ":0:";
msgAuctionSalePendingBody << secsToTimeBitFields(distrTime);
sLog.outDebug("AuctionSalePending body string : %s", msgAuctionSalePendingBody.str().c_str());
MailDraft(msgAuctionSalePendingSubject.str(), msgAuctionSalePendingBody.str())
.SendMailTo(MailReceiver(owner,auction->owner), auction, MAIL_CHECK_MASK_AUCTION);
}
}
void WorldSession::HandleCalendarGetCalendar(WorldPacket &/*recv_data*/)
{
DEBUG_LOG("WORLD: CMSG_CALENDAR_GET_CALENDAR"); // empty
time_t cur_time = time(NULL);
WorldPacket data(SMSG_CALENDAR_SEND_CALENDAR, 500);
// TODO: calendar invite event output
data << (uint32) 0; //invite node count
// TODO: calendar event output
data << (uint32) 0; //event count
data << (uint32) cur_time; // server time
data << (uint32) secsToTimeBitFields(cur_time); // current client time
uint32 counter = 0;
size_t p_counter = data.wpos();
data << uint32(counter); // instance save count
for(int i = 0; i < MAX_DIFFICULTY; ++i)
{
for (Player::BoundInstancesMap::const_iterator itr = _player->m_boundInstances[i].begin(); itr != _player->m_boundInstances[i].end(); ++itr)
{
if (itr->second->IsPermanent())
{
InstanceSave *save = itr->second;
data << uint32(save->GetMapId());
data << uint32(save->GetDifficulty());
data << uint32(save->GetResetTime() - cur_time);
data << uint64(save->GetObjectGuid().GetRawValue());
++counter;
}
}
}
data.put<uint32>(p_counter,counter);
data << (uint32) sWorld.getConfig(CONFIG_UINT32_INSTANCE_RESET_CONSTANT); //Raid reset time is computed from this unix time, 1135753200 on offi
p_counter = data.wpos();
counter = 0;
data << (uint32) counter; // raid resets
MapEntry const *entry = NULL;
for(uint32 i = 0; i < sMapStore.GetNumRows(); ++i)
{
entry = sMapStore.LookupEntry(i);
if(!entry || !entry->IsRaid())
continue;
data << uint32(entry->MapID);
data << uint32(GetMapDifficultyData(entry->MapID, Difficulty(0))->resetTime);
data << uint32(entry->unkTime);
++counter;
}
data.put<uint32>(p_counter,counter);
data << (uint32) 0; // holidays
SendPacket(&data);
}
void GuildAchievementMgr::SendAllAchievementData()
{
// handler at 0x8C30 (not rebased)
// Looks like only completed achievements data is sent in this packet
WorldPacket data(SMSG_GUILD_ACHIEVEMENT_DATA, m_completedAchievements.size() * 4 * 4);
data << uint32(m_completedAchievements.size());
for (CompletedAchievementMap::const_iterator iter = m_completedAchievements.begin(); iter != m_completedAchievements.end(); ++iter)
data << uint32(secsToTimeBitFields(iter->second.date));
for (CompletedAchievementMap::const_iterator iter = m_completedAchievements.begin(); iter != m_completedAchievements.end(); ++iter)
data << uint32(iter->first);
SendDirectMessageToAll(&data);
WorldPacket data2(SMSG_GUILD_CRITERIA_DATA);
data2 << uint32(m_criteriaProgress.size());
for (CriteriaProgressMap::const_iterator iter = m_criteriaProgress.begin(); iter != m_criteriaProgress.end(); ++iter)
data2 << uint64(iter->second.counter);
time_t now = time(NULL);
for (CriteriaProgressMap::const_iterator iter = m_criteriaProgress.begin(); iter != m_criteriaProgress.end(); ++iter)
data2 << uint32(now - iter->second.date);
for (CriteriaProgressMap::const_iterator iter = m_criteriaProgress.begin(); iter != m_criteriaProgress.end(); ++iter)
data2 << uint32(secsToTimeBitFields(iter->second.date));
for (CriteriaProgressMap::const_iterator iter = m_criteriaProgress.begin(); iter != m_criteriaProgress.end(); ++iter)
data2 << uint64(iter->second.counter);
for (CriteriaProgressMap::const_iterator iter = m_criteriaProgress.begin(); iter != m_criteriaProgress.end(); ++iter)
data2 << uint32(now - iter->second.date);
for (CriteriaProgressMap::const_iterator iter = m_criteriaProgress.begin(); iter != m_criteriaProgress.end(); ++iter)
data2 << uint32(iter->first);
for (CriteriaProgressMap::const_iterator iter = m_criteriaProgress.begin(); iter != m_criteriaProgress.end(); ++iter)
data2 << uint32(0); // Unk
SendDirectMessageToAll(&data2);
}
void CalendarMgr::SendCalendarEventRemovedAlert(CalendarEvent const* event)
{
DEBUG_FILTER_LOG(LOG_FILTER_CALENDAR, "SMSG_CALENDAR_EVENT_REMOVED_ALERT");
WorldPacket data(SMSG_CALENDAR_EVENT_REMOVED_ALERT, 1 + 8 + 1);
data << uint8(1); // show pending alert?
data << uint64(event->EventId);
data << secsToTimeBitFields(event->EventTime);
//data.hexlike();
SendPacketToAllEventRelatives(data, event);
}
void CalendarMgr::SendCalendarEventUpdateAlert(CalendarEvent const* event, time_t oldEventTime)
{
DEBUG_FILTER_LOG(LOG_FILTER_CALENDAR, "SMSG_CALENDAR_EVENT_UPDATED_ALERT");
WorldPacket data(SMSG_CALENDAR_EVENT_UPDATED_ALERT, 1 + 8 + 4 + 4 + 4 + 1 + 4 +
event->Title.size() + event->Description.size() + 1 + 4 + 4);
data << uint8(1); // show pending alert?
data << uint64(event->EventId);
data << secsToTimeBitFields(oldEventTime);
data << uint32(event->Flags);
data << secsToTimeBitFields(event->EventTime);
data << uint8(event->Type);
data << int32(event->DungeonId);
data << event->Title;
data << event->Description;
data << uint8(event->Repeatable);
data << uint32(CALENDAR_MAX_INVITES);
data << secsToTimeBitFields(event->UnknownTime);
//data.hexlike();
SendPacketToAllEventRelatives(data, event);
}
std::string AuctionEntry::BuildAuctionMailBody(uint32 lowGuid, uint32 bid, uint32 buyout, uint32 deposit, uint32 cut)
{
time_t distrTime = sWorld->GetGameTime() + sWorld->getIntConfig(CONFIG_MAIL_DELIVERY_DELAY);
std::ostringstream strm;
strm.width(16);
strm << std::right << std::hex << MAKE_NEW_GUID(lowGuid, 0, HIGHGUID_PLAYER); // HIGHGUID_PLAYER always present, even for empty guids
strm << std::dec << ':' << bid << ':' << buyout;
strm << ':' << deposit << ':' << cut << ":0:";
strm << secsToTimeBitFields(distrTime);
return strm.str();
}
void AchievementMgr::SendAchievementEarned(AchievementEntry const* achievement)
{
sLog.outString("AchievementMgr::SendAchievementEarned(%u)", achievement->ID);
const char *msg = "|Hplayer:$N|h[$N]|h has earned the achievement $a!";
if(Guild* guild = objmgr.GetGuildById(GetPlayer()->GetGuildId()))
{
WorldPacket data(SMSG_MESSAGECHAT, 200);
data << uint8(CHAT_MSG_ACHIEVEMENT);
data << uint8(CHAT_MSG_GUILD_ACHIEVEMENT);
data << uint32(LANG_UNIVERSAL);
data << uint64(GetPlayer()->GetGUID());
data << uint32(5);
data << uint64(GetPlayer()->GetGUID());
data << uint32(strlen(msg)+1);
data << msg;
data << uint8(0);
data << uint32(achievement->ID);
guild->BroadcastPacket(&data);
}
if(achievement->flags & (ACHIEVEMENT_FLAG_REALM_FIRST_KILL|ACHIEVEMENT_FLAG_REALM_FIRST_REACH))
{
// broadcast realm first reached
WorldPacket data(SMSG_SERVER_FIRST_ACHIEVEMENT, strlen(GetPlayer()->GetName())+1+8+4+4);
data << GetPlayer()->GetName();
data << uint64(GetPlayer()->GetGUID());
data << uint32(achievement->ID);
data << uint32(0); // 1=link supplied string as player name, 0=display plain string
sWorld.SendGlobalMessage(&data);
}
else
{
WorldPacket data(SMSG_MESSAGECHAT, 200);
data << uint8(CHAT_MSG_ACHIEVEMENT);
data << uint32(LANG_UNIVERSAL);
data << uint64(GetPlayer()->GetGUID());
data << uint32(5);
data << uint64(GetPlayer()->GetGUID());
data << uint32(strlen(msg)+1);
data << msg;
data << uint8(0);
data << uint32(achievement->ID);
GetPlayer()->SendMessageToSet(&data, true);
}
WorldPacket data(SMSG_ACHIEVEMENT_EARNED, 8+4+8);
data.append(GetPlayer()->GetPackGUID());
data << uint32(achievement->ID);
data << uint32(secsToTimeBitFields(time(NULL)));
data << uint32(0);
GetPlayer()->SendMessageToSet(&data, true);
}
void AchievementMgr::SendAchievementEarned(AchievementEntry const* achievement) const
{
if (GetPlayer()->GetSession()->PlayerLoading())
return;
// Don't send for achievements with ACHIEVEMENT_FLAG_TRACKING
if (achievement->flags & ACHIEVEMENT_FLAG_HIDDEN)
return;
#ifdef TRINITY_DEBUG
sLog->outDebug(LOG_FILTER_ACHIEVEMENTSYS, "AchievementMgr::SendAchievementEarned(%u)", achievement->ID);
#endif
if (Guild* guild = sGuildMgr->GetGuildById(GetPlayer()->GetGuildId()))
{
Trinity::AchievementChatBuilder say_builder(*GetPlayer(), CHAT_MSG_GUILD_ACHIEVEMENT, LANG_ACHIEVEMENT_EARNED, achievement->ID);
Trinity::LocalizedPacketDo<Trinity::AchievementChatBuilder> say_do(say_builder);
guild->BroadcastWorker(say_do, GetPlayer());
}
if (achievement->flags & (ACHIEVEMENT_FLAG_REALM_FIRST_KILL|ACHIEVEMENT_FLAG_REALM_FIRST_REACH))
{
// broadcast realm first reached
WorldPacket data(SMSG_SERVER_FIRST_ACHIEVEMENT, strlen(GetPlayer()->GetName())+1+8+4+4);
data << GetPlayer()->GetName();
data << uint64(GetPlayer()->GetGUID());
data << uint32(achievement->ID);
data << uint32(0); // 1=link supplied string as player name, 0=display plain string
sWorld->SendGlobalMessage(&data);
}
// if player is in world he can tell his friends about new achievement
else if (GetPlayer()->IsInWorld())
{
CellCoord p = Trinity::ComputeCellCoord(GetPlayer()->GetPositionX(), GetPlayer()->GetPositionY());
Cell cell(p);
cell.SetNoCreate();
Trinity::AchievementChatBuilder say_builder(*GetPlayer(), CHAT_MSG_ACHIEVEMENT, LANG_ACHIEVEMENT_EARNED, achievement->ID);
Trinity::LocalizedPacketDo<Trinity::AchievementChatBuilder> say_do(say_builder);
Trinity::PlayerDistWorker<Trinity::LocalizedPacketDo<Trinity::AchievementChatBuilder> > say_worker(GetPlayer(), sWorld->getFloatConfig(CONFIG_LISTEN_RANGE_SAY), say_do);
TypeContainerVisitor<Trinity::PlayerDistWorker<Trinity::LocalizedPacketDo<Trinity::AchievementChatBuilder> >, WorldTypeMapContainer > message(say_worker);
cell.Visit(p, message, *GetPlayer()->GetMap(), *GetPlayer(), sWorld->getFloatConfig(CONFIG_LISTEN_RANGE_SAY));
}
WorldPacket data(SMSG_ACHIEVEMENT_EARNED, 8+4+8);
data.append(GetPlayer()->GetPackGUID());
data << uint32(achievement->ID);
data << uint32(secsToTimeBitFields(time(NULL)));
data << uint32(0);
GetPlayer()->SendMessageToSetInRange(&data, sWorld->getFloatConfig(CONFIG_LISTEN_RANGE_SAY), true);
}
/**
* used by both SMSG_ALL_ACHIEVEMENT_DATA and SMSG_RESPOND_INSPECT_ACHIEVEMENT
*/
void AchievementMgr::BuildAllDataPacket(WorldPacket *data)
{
for(CompletedAchievementMap::const_iterator iter = m_completedAchievements.begin(); iter!=m_completedAchievements.end(); ++iter)
{
*data << uint32(iter->first);
*data << uint32(secsToTimeBitFields(iter->second.date));
}
*data << int32(-1);
for(CriteriaProgressMap::const_iterator iter = m_criteriaProgress.begin(); iter!=m_criteriaProgress.end(); ++iter)
{
*data << uint32(iter->first);
data->appendPackGUID(iter->second.counter);
data->append(GetPlayer()->GetPackGUID());
*data << uint32(0);
*data << uint32(secsToTimeBitFields(iter->second.date));
*data << uint32(0);
*data << uint32(0);
}
*data << int32(-1);
}
void AchievementMgr::SendRespondInspectAchievements(Player* player)
{
uint32 criterias = m_criteriaProgress.size();
uint32 achievements = m_completedAchievements.size();
// 2 is flag count, 8 is bits in byte
uint32 flagBytesCount = uint32(ceil(float(criterias) * 2.0f / 8.0f));
// since we don't know the exact size of the packed GUIDs this is just an approximation
WorldPacket data(SMSG_RESPOND_INSPECT_ACHIEVEMENTS, 4 + criterias * (8 + 4 + 4 + 8) + 8 + 4 + achievements * (4 + 4 + 4) + flagBytesCount);
data << uint32(criterias);
for (CriteriaProgressMap::const_iterator iter = m_criteriaProgress.begin(); iter!=m_criteriaProgress.end(); ++iter)
data << uint64(iter->second.counter);
for (CriteriaProgressMap::const_iterator iter = m_criteriaProgress.begin(); iter!=m_criteriaProgress.end(); ++iter)
data << uint32(iter->second.date);
for (CriteriaProgressMap::const_iterator iter = m_criteriaProgress.begin(); iter!=m_criteriaProgress.end(); ++iter)
data << uint32(iter->first);
data.append(GetPlayer()->GetPackGUID());
for (uint32 i = 0; i < criterias; ++i)
data.append(GetPlayer()->GetPackGUID());
data << uint32(achievements);
for (CompletedAchievementMap::const_iterator iter = m_completedAchievements.begin(); iter!=m_completedAchievements.end(); ++iter)
data << uint32(iter->first);
for (CompletedAchievementMap::const_iterator iter = m_completedAchievements.begin(); iter!=m_completedAchievements.end(); ++iter)
data << uint32(secsToTimeBitFields(iter->second.date));
for (uint32 i = 0; i < flagBytesCount; ++i)
data << uint8(0);
for (CompletedAchievementMap::const_iterator iter = m_completedAchievements.begin(); iter!=m_completedAchievements.end(); ++iter)
data << uint32(secsToTimeBitFields(iter->second.date));
player->GetSession()->SendPacket(&data);
}
void CalendarMgr::SendCalendarEventInviteRemoveAlert(Player* player, CalendarEvent const* event, CalendarInviteStatus status)
{
if (player)
{
DEBUG_FILTER_LOG(LOG_FILTER_CALENDAR, "SMSG_CALENDAR_EVENT_INVITE_REMOVED_ALERT");
WorldPacket data(SMSG_CALENDAR_EVENT_INVITE_REMOVED_ALERT, 8 + 4 + 4 + 1);
data << uint64(event->EventId);
data << secsToTimeBitFields(event->EventTime);
data << uint32(event->Flags);
data << uint8(status);
//data.hexlike();
player->SendDirectMessage(&data);
}
}
void AchievementMgr::SendCriteriaUpdate(uint32 id, CriteriaProgress const* progress)
{
WorldPacket data(SMSG_CRITERIA_UPDATE, 8+4+8);
data << uint32(id);
// the counter is packed like a packed Guid
data.appendPackGUID(progress->counter);
data.append(GetPlayer()->GetPackGUID());
data << uint32(0);
data << uint32(secsToTimeBitFields(progress->date));
data << uint32(0); // timer 1
data << uint32(0); // timer 2
GetPlayer()->SendMessageToSet(&data, true);
}
/**
* used by SMSG_RESPOND_INSPECT_ACHIEVEMENT and SMSG_ALL_ACHIEVEMENT_DATA
*/
void AchievementMgr::BuildAllDataPacket(WorldPacket *data) const
{
uint32 criterias = m_criteriaProgress.size();
uint32 achievements = m_completedAchievements.size();
// 2 is flag count, 8 is bits in byte
uint32 flagBytesCount = uint32(ceil(float(criterias) * 2.0f / 8.0f));
*data << uint32(achievements);
*data << uint32(criterias);
for (CompletedAchievementMap::const_iterator iter = m_completedAchievements.begin(); iter != m_completedAchievements.end(); ++iter)
*data << uint32(iter->first);
for (CompletedAchievementMap::const_iterator iter = m_completedAchievements.begin(); iter != m_completedAchievements.end(); ++iter)
*data << uint32(secsToTimeBitFields(iter->second.date));
for (CriteriaProgressMap::const_iterator iter = m_criteriaProgress.begin(); iter != m_criteriaProgress.end(); ++iter)
*data << uint64(iter->second.counter);
time_t now = time(NULL);
for (CriteriaProgressMap::const_iterator iter = m_criteriaProgress.begin(); iter!=m_criteriaProgress.end(); ++iter)
*data << uint32(now - iter->second.date);
for (CriteriaProgressMap::const_iterator iter = m_criteriaProgress.begin(); iter!=m_criteriaProgress.end(); ++iter)
*data << uint32(secsToTimeBitFields(iter->second.date));
/*for (uint32 i = 0; i < criterias; ++i)
data->append(GetPlayer()->GetPackGUID());*/
for (CriteriaProgressMap::const_iterator iter = m_criteriaProgress.begin(); iter!=m_criteriaProgress.end(); ++iter)
*data << uint64(iter->second.counter);
for (CriteriaProgressMap::const_iterator iter = m_criteriaProgress.begin(); iter!=m_criteriaProgress.end(); ++iter)
*data << uint32(now - iter->second.date);
for (uint32 i = 0; i < flagBytesCount; ++i)
*data << uint8(0);
for (CriteriaProgressMap::const_iterator iter = m_criteriaProgress.begin(); iter!=m_criteriaProgress.end(); ++iter)
*data << uint32(iter->first);
}
void GuildAchievementMgr::SendAchievementEarned(AchievementEntry const* achievement)
{
if (achievement->flags & ACHIEVEMENT_FLAG_HIDDEN)
return;
if (!(achievement->flags & ACHIEVEMENT_FLAG_GUILD_ACHIEVEMENT))
return;
sLog->outString("Guild %u earned achievement %u", _guild->GetId(), achievement->ID);
WorldPacket data(SMSG_GUILD_ACHIEVEMENT_EARNED, 8+4+8);
data << uint32(achievement->ID);
data << uint64(MAKE_NEW_GUID(_guild->GetId(), 0, HIGHGUID_GUILD));
data << uint32(secsToTimeBitFields(time(NULL)));
SendDirectMessageToAll(&data);
}
void CalendarMgr::SendCalendarRaidLockoutAdd(Player* player, DungeonPersistentState const* save)
{
if (!save || !player)
return;
DEBUG_LOG("SMSG_CALENDAR_RAID_LOCKOUT_ADDED [%s]", player->GetObjectGuid().GetString().c_str());
time_t currTime = time(nullptr);
WorldPacket data(SMSG_CALENDAR_RAID_LOCKOUT_ADDED, 4 + 4 + 4 + 4 + 8);
data << secsToTimeBitFields(currTime);
data << uint32(save->GetMapId());
data << uint32(save->GetDifficulty());
data << uint32(save->GetResetTime() - currTime);
data << uint64(save->GetInstanceId());
//data.hexlike();
player->SendDirectMessage(&data);
}
void WorldSession::HandleCalendarGetCalendar(WorldPacket &recv_data)
{
sLog.outDebug("WORLD: CMSG_CALENDAR_GET_CALENDAR");
recv_data.hexlike();
time_t cur_time = time(NULL);
WorldPacket data(SMSG_CALENDAR_SEND_CALENDAR,4+4*0+4+4*0+4+4);
// TODO: calendar invite event output
data << (uint32) 0; //invite node count
// TODO: calendar event output
data << (uint32) 0; //event count
data << (uint32) 0; //wtf??
data << (uint32) secsToTimeBitFields(cur_time); // current time
uint32 counter = 0;
size_t p_counter = data.wpos();
data << uint32(counter); // instance save count
for(int i = 0; i < TOTAL_DIFFICULTIES; ++i)
{
for (Player::BoundInstancesMap::const_iterator itr = _player->m_boundInstances[i].begin(); itr != _player->m_boundInstances[i].end(); ++itr)
{
if(itr->second.perm)
{
InstanceSave *save = itr->second.save;
data << uint32(save->GetMapId());
data << uint32(save->GetDifficulty());
data << uint32(save->GetResetTime() - cur_time);
data << uint64(save->GetInstanceId()); // instance save id as unique instance copy id
++counter;
}
}
}
data.put<uint32>(p_counter,counter);
data << (uint32) 1135753200; //wtf?? (28.12.2005 12:00)
data << (uint32) 0; // unk counter 4
data << (uint32) 0; // unk counter 5
//sLog.outDebug("Sending calendar");
//data.hexlike();
SendPacket(&data);
}
void WorldSession::HandleGuildInfoOpcode(WorldPacket& /*recvPacket*/)
{
DEBUG_LOG("WORLD: Received opcode CMSG_GUILD_INFO");
Guild* guild = sGuildMgr.GetGuildById(GetPlayer()->GetGuildId());
if (!guild)
{
SendGuildCommandResult(GUILD_CREATE_S, "", ERR_GUILD_PLAYER_NOT_IN_GUILD);
return;
}
WorldPacket data(SMSG_GUILD_INFO, (guild->GetName().size() + 4 + 4 + 4));
data << guild->GetName();
data << uint32(secsToTimeBitFields(guild->GetCreatedDate())); // 3.x (prev. day + month + year)
data << uint32(guild->GetMemberSize()); // amount of chars
data << uint32(guild->GetAccountsNumber()); // amount of accounts
SendPacket(&data);
}
// remove all invite sending ingame mail
void CalendarEvent::RemoveAllInvite(ObjectGuid const& removerGuid)
{
// build mail title
std::ostringstream title;
title << removerGuid << ':' << Title;
// build mail body
std::ostringstream body;
body << secsToTimeBitFields(time(NULL));
// creating mail draft
MailDraft draft(title.str(), body.str());
CalendarInviteMap::iterator itr = m_Invitee.begin();
while (itr != m_Invitee.end())
{
if (removerGuid != itr->second->InviteeGuid)
draft.SendMailTo(MailReceiver(itr->second->InviteeGuid), this, MAIL_CHECK_MASK_COPIED);
RemoveInviteByItr(itr++);
}
}
void CalendarMgr::SendCalendarEventInvite(CalendarInvite const* invite)
{
CalendarEvent const* event = invite->GetCalendarEvent();
time_t statusTime = invite->LastUpdateTime;
bool preInvite = true;
uint64 eventId = 0;
if (event != nullptr)
{
preInvite = false;
eventId = event->EventId;
}
Player* player = sObjectMgr.GetPlayer(invite->InviteeGuid);
uint8 level = player ? player->getLevel() : Player::GetLevelFromDB(invite->InviteeGuid);
DEBUG_FILTER_LOG(LOG_FILTER_CALENDAR, "SMSG_CALENDAR_EVENT_INVITE");
WorldPacket data(SMSG_CALENDAR_EVENT_INVITE, 8 + 8 + 8 + 1 + 1 + 1 + (preInvite ? 0 : 4) + 1);
data << invite->InviteeGuid.WriteAsPacked();
data << uint64(eventId);
data << uint64(invite->InviteId);
data << uint8(level);
data << uint8(invite->Status);
data << uint8(!preInvite);
if (!preInvite)
data << secsToTimeBitFields(statusTime);
data << uint8(invite->SenderGuid != invite->InviteeGuid); // false only if the invite is sign-up (invitee create himself his invite)
DEBUG_FILTER_LOG(LOG_FILTER_CALENDAR, "SendCalendarInvit> %s senderGuid[%s], inviteeGuid[%s], EventId[" UI64FMTD "], Status[%u], InviteId[" UI64FMTD "]",
preInvite ? "is PreInvite," : "", invite->SenderGuid.GetString().c_str(), invite->InviteeGuid.GetString().c_str(), eventId, uint32(invite->Status), invite->InviteId);
//data.hexlike();
if (preInvite)
{
if (Player* sender = sObjectMgr.GetPlayer(invite->SenderGuid))
sender->SendDirectMessage(&data);
}
else
SendPacketToAllEventRelatives(data, event);
}
void WorldSession::HandleCalendarGetCalendar(WorldPacket& recv_data)
{
time_t cur_time = time(NULL);
WorldPacket data(SMSG_CALENDAR_SEND_CALENDAR, 4+4*0+4+4*0+4+4);
// TODO: calendar invite event output
// TODO: calendar event output
data << uint32(0); // invite node count
data << uint32(0); // event count
data << uint32(0);
data << uint32(secsToTimeBitFields(cur_time)); // current time
uint32 count = 0;
size_t p_count = data.wpos();
data << uint32(count); // Calender shit.
data.put<uint32>(p_count,count);
data << uint32(1135753200); // Unix Time for when calendars started?
data << uint32(0); // unk counter 4
data << uint32(0); // unk counter 5
SendPacket(&data);
}
void WorldSession::HandleCalendarGetCalendar(WorldPacket& /*recvData*/)
{
uint64 guid = _player->GetGUID();
sLog->outDebug(LOG_FILTER_NETWORKIO, "CMSG_CALENDAR_GET_CALENDAR [" UI64FMTD "]", guid);
time_t cur_time = time_t(time(NULL));
sLog->outDebug(LOG_FILTER_NETWORKIO, "SMSG_CALENDAR_SEND_CALENDAR [" UI64FMTD "]", guid);
WorldPacket data(SMSG_CALENDAR_SEND_CALENDAR, 1000); // Impossible to get the correct size without doing a double iteration of some elements
CalendarInviteIdList const& invites = sCalendarMgr->GetPlayerInvites(guid);
data << uint32(invites.size());
for (CalendarInviteIdList::const_iterator it = invites.begin(); it != invites.end(); ++it)
{
CalendarInvite* invite = sCalendarMgr->GetInvite(*it);
CalendarEvent* calendarEvent = invite ? sCalendarMgr->GetEvent(invite->GetEventId()) : NULL;
if (calendarEvent)
{
data << uint64(invite->GetEventId());
data << uint64(invite->GetInviteId());
data << uint8(invite->GetStatus());
data << uint8(invite->GetRank());
data << uint8(calendarEvent->GetGuildId() != 0);
data.appendPackGUID(calendarEvent->GetCreatorGUID());
}
else
{
sLog->outError("SMSG_CALENDAR_SEND_CALENDAR: No Invite found with id [" UI64FMTD "]", *it);
data << uint64(0) << uint64(0) << uint8(0) << uint8(0);
data.appendPackGUID(0);
}
}
CalendarEventIdList const& events = sCalendarMgr->GetPlayerEvents(guid);
data << uint32(events.size());
for (CalendarEventIdList::const_iterator it = events.begin(); it != events.end(); ++it)
{
if (CalendarEvent* calendarEvent = sCalendarMgr->GetEvent(*it))
{
data << uint64(*it);
data << calendarEvent->GetTitle().c_str();
data << uint32(calendarEvent->GetType());
data << uint32(calendarEvent->GetTime());
data << uint32(calendarEvent->GetFlags());
data << uint32(calendarEvent->GetDungeonId());
data.appendPackGUID(calendarEvent->GetCreatorGUID());
}
else
{
sLog->outError("SMSG_CALENDAR_SEND_CALENDAR: No Event found with id [" UI64FMTD "]", *it);
data << uint64(0) << uint8(0) << uint32(0)
<< uint32(0) << uint32(0) << uint32(0);
data.appendPackGUID(0);
}
}
data << uint32(cur_time); // server time
data << uint32(secsToTimeBitFields(cur_time)); // server time
uint32 counter = 0;
size_t p_counter = data.wpos();
data << uint32(counter); // instance save count
for (uint8 i = 0; i < MAX_DIFFICULTY; ++i)
for (Player::BoundInstancesMap::const_iterator itr = _player->_boundInstances[i].begin(); itr != _player->_boundInstances[i].end(); ++itr)
if (itr->second.perm)
{
InstanceSave const* save = itr->second.save;
data << uint32(save->GetMapId());
data << uint32(save->GetDifficulty());
data << uint32(save->GetResetTime() - cur_time);
data << uint64(save->GetInstanceId()); // instance save id as unique instance copy id
++counter;
}
data.put<uint32>(p_counter, counter);
data << uint32(1135753200); // unk (28.12.2005 07:00)
counter = 0;
p_counter = data.wpos();
data << uint32(counter); // raid reset count
std::set<uint32> sentMaps;
ResetTimeByMapDifficultyMap const& resets = sInstanceSaveMgr->GetResetTimeMap();
for (ResetTimeByMapDifficultyMap::const_iterator itr = resets.begin(); itr != resets.end(); ++itr)
{
uint32 mapId = PAIR32_LOPART(itr->first);
if (sentMaps.find(mapId) != sentMaps.end())
continue;
MapEntry const* mapEntry = sMapStore.LookupEntry(mapId);
if (!mapEntry || !mapEntry->IsRaid())
continue;
sentMaps.insert(mapId);
data << uint32(mapId);
data << uint32(itr->second - cur_time);
data << uint32(mapEntry->unk_time);
++counter;
}
data.put<uint32>(p_counter, counter);
// TODO: Fix this, how we do know how many and what holidays to send?
uint32 holidayCount = 0;
data << uint32(holidayCount);
for (uint32 i = 0; i < holidayCount; ++i)
{
HolidaysEntry const* holiday = sHolidaysStore.LookupEntry(666);
data << uint32(holiday->Id); // m_ID
data << uint32(holiday->Region); // m_region, might be looping
data << uint32(holiday->Looping); // m_looping, might be region
data << uint32(holiday->Priority); // m_priority
data << uint32(holiday->CalendarFilterType); // m_calendarFilterType
for (uint8 j = 0; j < MAX_HOLIDAY_DATES; ++j)
data << uint32(holiday->Date[j]); // 26 * m_date
for (uint8 j = 0; j < MAX_HOLIDAY_DURATIONS; ++j)
data << uint32(holiday->Duration[j]); // 10 * m_duration
for (uint8 j = 0; j < MAX_HOLIDAY_FLAGS; ++j)
data << uint32(holiday->CalendarFlags[j]); // 10 * m_calendarFlags
data << holiday->TextureFilename; // m_textureFilename (holiday name)
}
SendPacket(&data);
}
void WorldSession::HandleCalendarGetCalendar(WorldPacket & /*recv_data*/)
{
sLog->outDebug(LOG_FILTER_NETWORKIO, "WORLD: CMSG_CALENDAR_GET_CALENDAR"); // empty
time_t cur_time = time(NULL);
WorldPacket data(SMSG_CALENDAR_SEND_CALENDAR, 4+4*0+4+4*0+4+4);
data << uint32(0); // invite count
/*
for (;;)
{
uint64 inviteId;
uint64 unkGuid0;
uint8 unk1, unk2, unk3;
uint64 creatorGuid;
}
*/
data << uint32(0); // event count
/*
for (;;)
{
uint64 eventId;
std::string title; // 128 chars
uint32 type;
uint32 occurrenceTime;
uint32 flags;
uint32 unk4; -- possibly mapid for dungeon/raid
uint64 creatorGuid;
}
*/
data << uint32(0); // unk
data << uint32(secsToTimeBitFields(cur_time)); // current time
uint32 counter = 0;
size_t p_counter = data.wpos();
data << uint32(counter); // instance save count
for (int i = 0; i < MAX_DIFFICULTY; ++i)
{
for (Player::BoundInstancesMap::const_iterator itr = _player->m_boundInstances[i].begin(); itr != _player->m_boundInstances[i].end(); ++itr)
{
if (itr->second.perm)
{
InstanceSave *save = itr->second.save;
data << uint32(save->GetMapId());
data << uint32(save->GetDifficulty());
data << uint32(save->GetResetTime() - cur_time);
data << uint64(save->GetInstanceId()); // instance save id as unique instance copy id
++counter;
}
}
}
data.put<uint32>(p_counter, counter);
data << uint32(1135753200); // unk (28.12.2005 12:00)
counter = 0;
p_counter = data.wpos();
data << uint32(counter); // raid reset count
ResetTimeByMapDifficultyMap const& resets = sInstanceSaveMgr->GetResetTimeMap();
for (ResetTimeByMapDifficultyMap::const_iterator itr = resets.begin(); itr != resets.end(); ++itr)
{
uint32 mapid = PAIR32_LOPART(itr->first);
MapEntry const* mapEnt = sMapStore.LookupEntry(mapid);
if (!mapEnt || !mapEnt->IsRaid())
continue;
data << uint32(mapid);
data << uint32(itr->second - cur_time);
data << uint32(mapEnt->unk_time);
++counter;
}
data.put<uint32>(p_counter, counter);
data << uint32(0); // holiday count?
/*
for (;;)
{
uint32 unk5, unk6, unk7, unk8, unk9;
for (uint32 j = 0; j < 26; ++j)
{
uint32 unk10;
}
for (uint32 j = 0; j < 10; ++j)
{
uint32 unk11;
}
for (uint32 j = 0; j < 10; ++j)
{
uint32 unk12;
}
std::string holidayName; // 64 chars
}
*/
sLog->outDebug(LOG_FILTER_NETWORKIO, "Sending calendar");
data.hexlike();
SendPacket(&data);
}
void WorldSession::HandleCalendarGetCalendar(WorldPacket& /*recv_data*/)
{
ObjectGuid guid = _player->GetObjectGuid();
DEBUG_LOG("WORLD: Received opcode CMSG_CALENDAR_GET_CALENDAR [%s]", guid.GetString().c_str());
time_t currTime = time(nullptr);
WorldPacket data(SMSG_CALENDAR_SEND_CALENDAR);
CalendarInvitesList invites;
sCalendarMgr.GetPlayerInvitesList(guid, invites);
data << uint32(invites.size());
DEBUG_FILTER_LOG(LOG_FILTER_CALENDAR, "Sending > %u invites", uint32(invites.size()));
for (CalendarInvitesList::const_iterator itr = invites.begin(); itr != invites.end(); ++itr)
{
CalendarEvent const* event = (*itr)->GetCalendarEvent();
MANGOS_ASSERT(event); // TODO: be sure no way to have a null event
data << uint64(event->EventId);
data << uint64((*itr)->InviteId);
data << uint8((*itr)->Status);
data << uint8((*itr)->Rank);
data << uint8(event->IsGuildEvent());
data << event->CreatorGuid.WriteAsPacked();
DEBUG_FILTER_LOG(LOG_FILTER_CALENDAR, "invite> EventId[" UI64FMTD "], InviteId[" UI64FMTD "], status[%u], rank[%u]",
event->EventId, (*itr)->InviteId, uint32((*itr)->Status), uint32((*itr)->Rank));
}
CalendarEventsList events;
sCalendarMgr.GetPlayerEventsList(guid, events);
data << uint32(events.size());
DEBUG_FILTER_LOG(LOG_FILTER_CALENDAR, "Sending > %u events", uint32(events.size()));
for (CalendarEventsList::const_iterator itr = events.begin(); itr != events.end(); ++itr)
{
CalendarEvent const* event = *itr;
data << uint64(event->EventId);
data << event->Title;
data << uint32(event->Type);
data << secsToTimeBitFields(event->EventTime);
data << uint32(event->Flags);
data << int32(event->DungeonId);
data << event->CreatorGuid.WriteAsPacked();
std::string timeStr = TimeToTimestampStr(event->EventTime);
DEBUG_FILTER_LOG(LOG_FILTER_CALENDAR, "Events> EventId[" UI64FMTD "], Title[%s], Time[%s], Type[%u], Flag[%u], DungeonId[%d], CreatorGuid[%s]",
event->EventId, event->Title.c_str(), timeStr.c_str(), uint32(event->Type),
uint32(event->Flags), event->DungeonId, event->CreatorGuid.GetString().c_str());
}
data << uint32(currTime); // server time
data << secsToTimeBitFields(currTime); // zone time ??
ByteBuffer dataBuffer;
uint32 boundCounter = 0;
for (uint8 i = 0; i < MAX_DIFFICULTY; ++i)
{
Player::BoundInstancesMap boundInstances = _player->GetBoundInstances(Difficulty(i));
for (Player::BoundInstancesMap::const_iterator itr = boundInstances.begin(); itr != boundInstances.end(); ++itr)
{
if (itr->second.perm)
{
DungeonPersistentState const* state = itr->second.state;
dataBuffer << uint32(state->GetMapId());
dataBuffer << uint32(state->GetDifficulty());
dataBuffer << uint32(state->GetResetTime() - currTime);
dataBuffer << uint64(state->GetInstanceId()); // instance save id as unique instance copy id
++boundCounter;
}
}
}
data << uint32(boundCounter);
data.append(dataBuffer);
data << uint32(1135753200); // Constant date, unk (28.12.2005 07:00)
// Reuse variables
boundCounter = 0;
std::set<uint32> sentMaps;
dataBuffer.clear();
for (MapDifficultyMap::const_iterator itr = sMapDifficultyMap.begin(); itr != sMapDifficultyMap.end(); ++itr)
{
uint32 map_diff_pair = itr->first;
uint32 mapId = PAIR32_LOPART(map_diff_pair);
MapDifficultyEntry const* mapDiff = itr->second;
// skip mapDiff without global reset time
if (!mapDiff->resetTime)
continue;
// skip non raid map
MapEntry const* mapEntry = sMapStore.LookupEntry(mapId);
if (!mapEntry || !mapEntry->IsRaid())
continue;
// skip already sent map (not same difficulty?)
if (sentMaps.find(mapId) != sentMaps.end())
continue;
uint32 resetTime = sMapPersistentStateMgr.GetScheduler().GetMaxResetTimeFor(mapDiff);
sentMaps.insert(mapId);
dataBuffer << mapId;
dataBuffer << resetTime;
DEBUG_FILTER_LOG(LOG_FILTER_CALENDAR, "MapId [%u] -> Reset Time: %u", mapId, resetTime);
dataBuffer << int32(0); // showed 68400 on map 509 must investigate more
++boundCounter;
}
DEBUG_FILTER_LOG(LOG_FILTER_CALENDAR, "Map sent [%u]", boundCounter);
data << uint32(boundCounter);
data.append(dataBuffer);
// TODO: Fix this, how we do know how many and what holidays to send?
uint32 holidayCount = 0;
data << uint32(holidayCount);
/*for (uint32 i = 0; i < holidayCount; ++i)
{
HolidaysEntry const* holiday = sHolidaysStore.LookupEntry(666);
data << uint32(holiday->Id); // m_ID
data << uint32(holiday->Region); // m_region, might be looping
data << uint32(holiday->Looping); // m_looping, might be region
data << uint32(holiday->Priority); // m_priority
data << uint32(holiday->CalendarFilterType); // m_calendarFilterType
for (uint8 j = 0; j < MAX_HOLIDAY_DATES; ++j)
data << uint32(holiday->Date[j]); // 26 * m_date -- WritePackedTime ?
for (uint8 j = 0; j < MAX_HOLIDAY_DURATIONS; ++j)
data << uint32(holiday->Duration[j]); // 10 * m_duration
for (uint8 j = 0; j < MAX_HOLIDAY_FLAGS; ++j)
data << uint32(holiday->CalendarFlags[j]); // 10 * m_calendarFlags
data << holiday->TextureFilename; // m_textureFilename (holiday name)
}*/
SendPacket(&data);
}
void WorldSession::HandleCalendarGetCalendar(WorldPacket &/*recv_data*/)
{
DEBUG_LOG("WORLD: CMSG_CALENDAR_GET_CALENDAR"); // empty
time_t cur_time = time(NULL);
WorldPacket data(SMSG_CALENDAR_SEND_CALENDAR,4+4*0+4+4*0+4+4);
// TODO: calendar invite event output
data << (uint32) 0; //invite node count
// TODO: calendar event output
data << (uint32) 0; //event count
data << uint32(cur_time); // current time, unix timestamp
data << uint32(secsToTimeBitFields(cur_time)); // current time, time bit fields
uint32 counter = 0;
size_t p_counter = data.wpos();
data << uint32(counter); // instance state count
for(int i = 0; i < MAX_DIFFICULTY; ++i)
{
for (Player::BoundInstancesMap::const_iterator itr = _player->m_boundInstances[i].begin(); itr != _player->m_boundInstances[i].end(); ++itr)
{
if(itr->second.perm)
{
DungeonPersistentState *state = itr->second.state;
data << uint32(state->GetMapId());
data << uint32(state->GetDifficulty());
data << uint32(state->GetResetTime() - cur_time);
data << ObjectGuid(state->GetInstanceGuid());
++counter;
}
}
}
data.put<uint32>(p_counter,counter);
data << uint32(INSTANCE_RESET_SCHEDULE_START_TIME + sWorld.getConfig(CONFIG_UINT32_INSTANCE_RESET_TIME_HOUR) * HOUR);
counter = 0;
p_counter = data.wpos();
data << uint32(counter); // Instance reset intervals
for(MapDifficultyMap::const_iterator itr = sMapDifficultyMap.begin(); itr != sMapDifficultyMap.end(); ++itr)
{
MapDifficultyEntry const* mapDiff = itr->second;
if(!mapDiff || mapDiff->resetTime == 0)
continue;
const MapEntry* map = sMapStore.LookupEntry(mapDiff->MapId);
if(!map || !map->IsRaid())
continue;
uint32 period = uint32(mapDiff->resetTime / DAY * sWorld.getConfig(CONFIG_FLOAT_RATE_INSTANCE_RESET_TIME)) * DAY;
if (period < DAY)
period = DAY;
data << uint32(mapDiff->MapId);
data << uint32(period);
data << uint32(mapDiff->resetTime);
++counter;
}
data.put<uint32>(p_counter,counter);
data << (uint32) 0; // unk counter 5
//DEBUG_LOG("Sending calendar");
//data.hexlike();
SendPacket(&data);
}
void WorldSession::HandleCalendarGetCalendar(WorldPacket &/*recv_data*/)
{
DEBUG_LOG("WORLD: CMSG_CALENDAR_GET_CALENDAR"); // empty
time_t cur_time = time(NULL);
WorldPacket data(SMSG_CALENDAR_SEND_CALENDAR, 4+4*0+4+4*0+4+4);
// TODO: calendar invite event output
data << (uint32) 0; // invite node count
// TODO: calendar event output
data << (uint32) 0; // event count
data << (uint32) 0; // Current Unix Time?
data << (uint32) secsToTimeBitFields(cur_time); // current packed time
uint32 counter = 0;
size_t p_counter = data.wpos();
data << uint32(counter); // instance state count
for(int i = 0; i < MAX_DIFFICULTY; ++i)
{
for (Player::BoundInstancesMap::const_iterator itr = _player->m_boundInstances[i].begin(); itr != _player->m_boundInstances[i].end(); ++itr)
{
if(itr->second.perm)
{
DungeonPersistentState *state = itr->second.state;
data << uint32(state->GetMapId());
data << uint32(state->GetDifficulty());
data << uint32(state->GetResetTime() - cur_time);
data << ObjectGuid(state->GetInstanceGuid());
++counter;
}
}
}
data.put<uint32>(p_counter,counter);
data << (uint32) 1135753200; // base date (28.12.2005 12:00)
data << (uint32) 0; // raid reset count
data << (uint32) 0; // holidays count
/*
for(uint32 i = 0; i < holidays_count; ++i)
{
data << uint32(0); // Holidays.dbc ID
data << uint32(0); // Holidays.dbc region
data << uint32(0); // Holidays.dbc looping
data << uint32(0); // Holidays.dbc priority
data << uint32(0); // Holidays.dbc calendarFilterType
for(uint32 j = 0; j < 26; j++)
data << uint32(0); // Holidays.dbc date
for(uint32 j = 0; j < 10; j++)
data << uint32(0); // Holidays.dbc duration
for(uint32 j = 0; j < 10; j++)
data << uint32(0); // Holidays.dbc calendarFlags
data << ""; // Holidays.dbc textureFilename
}
*/
//DEBUG_LOG("Sending calendar");
//data.hexlike();
SendPacket(&data);
}
