void MoveInLineOfSight(Unit* pWho) override
{
// Cosmetic spell
if (m_sWretchedGuids.find(pWho->GetObjectGuid()) == m_sWretchedGuids.end() && pWho->IsWithinDist(m_creature, 5.0f) && pWho->isAlive() &&
(pWho->GetEntry() == NPC_SKULER || pWho->GetEntry() == NPC_BRUISER || pWho->GetEntry() == NPC_HUSK))
{
pWho->CastSpell(m_creature, SPELL_FEL_CRYSTAL_COSMETIC, false);
m_sWretchedGuids.insert(pWho->GetObjectGuid());
}
}
void MoveInLineOfSight(Unit* pWho) override
{
// Note: this implementation is not the best; It should be better handled by the guard script
if (m_bCanGuardSalute && (pWho->GetEntry() == NPC_GUARD_CITY || pWho->GetEntry() == NPC_GUARD_ROYAL ||
pWho->GetEntry() == NPC_GUARD_PATROLLER) && pWho->IsWithinDistInMap(m_creature, 15.0f) &&
m_sGuardsSalutedGuidSet.find(pWho->GetObjectGuid()) == m_sGuardsSalutedGuidSet.end() && pWho->IsWithinLOSInMap(m_creature))
{
DoScriptText(aGuardSalute[urand(0, MAX_GUARD_SALUTES - 1)], pWho);
m_sGuardsSalutedGuidSet.insert(pWho->GetObjectGuid());
}
}
void OnCreatureCreate(Creature* creature) override
{
switch (creature->GetEntry())
{
case 17257:
MagtheridonGUID = creature->GetGUID();
break;
case 17256:
ChannelerGUID.insert(creature->GetGUID());
break;
}
}
void CLogSerializer::loadAckedLogs(GuidSet& ackedLogs)//
{
try
{
Close(); //release old file io, if any
m_file = createIFile(m_FilePath.str());
m_fileio = m_file->open(IFOread);
if (m_fileio == 0)
throw MakeStringException(-1, "Unable to open logging file %s",m_FilePath.str());
offset_t finger = 0;
m_ItemCount = 0;
while(true)
{
char dataSize[9];
memset(dataSize, 0, 9);
size32_t bytesRead = m_fileio->read(finger,8,dataSize);
if(bytesRead==0)
break;
MemoryBuffer data;
int dataLen = atoi(dataSize);
finger+=9;
bytesRead = m_fileio->read(finger,dataLen,data.reserveTruncate(dataLen));
if(bytesRead==0)
break;
StringBuffer GUID, line;
splitLogRecord(data, GUID, line);
ackedLogs.insert(GUID.str());
m_ItemCount++;
finger+=dataLen;
}
fileSize = finger;
DBGLOG("Total acks loaded %lu", m_ItemCount);
}
catch(IException* ex)
{
StringBuffer errorStr;
ex->errorMessage(errorStr);
ERRLOG("Exception caught within CLogSerializer::loadAckedLogs: %s",errorStr.str());
ex->Release();
}
catch(...)
{
DBGLOG("Unknown Exception thrown in CLogSerializer::loadAckedLogs");
}
Close();
}
void JustSummoned(Creature* pSummoned) override
{
switch (pSummoned->GetEntry())
{
case NPC_GUARDIAN:
{
DoScriptText(EMOTE_GUARDIAN, m_creature);
m_lAddsSet.insert(pSummoned->GetObjectGuid());
++m_uiGuardiansCount;
pSummoned->SetInCombatWithZone();
break;
}
case NPC_SOLDIER_FROZEN:
case NPC_UNSTOPPABLE_ABOM:
case NPC_SOUL_WEAVER:
{
if (m_uiIntroPackCount < 7)
m_lIntroMobsSet.insert(pSummoned->GetObjectGuid());
else
{
m_lAddsSet.insert(pSummoned->GetObjectGuid());
if (m_pInstance)
{
float fX, fY, fZ;
m_pInstance->GetChamberCenterCoords(fX, fY, fZ);
pSummoned->GetMotionMaster()->MovePoint(0, fX, fY, fZ);
}
}
break;
}
}
}
void OnGameObjectCreate(GameObject* go) override
{
switch (go->GetEntry())
{
case 181713:
go->SetUInt32Value(GAMEOBJECT_FLAGS, 0);
break;
case 183847:
DoorGUID = go->GetGUID();
break;
case 184653: // hall
case 184634: // six columns
case 184635:
case 184636:
case 184637:
case 184638:
case 184639:
ColumnGUID.insert(go->GetGUID());
break;
}
}
void UpdateAI(uint32 diff) override
{
//Return since we have no target
if (!UpdateVictim())
return;
//Earthquake_Timer
if (Earthquake_Timer <= diff)
{
if (!Earthquake)
{
DoCastVictim(SPELL_EARTHQUAKE);
Earthquake = true;
Earthquake_Timer = 10000;
}
else
{
Talk(SAY_SUMMON);
for (uint8 i = 0; i < 10; ++i)
{
if (Unit* target = SelectTarget(SELECT_TARGET_RANDOM, 0))
if (Creature* Murloc = me->SummonCreature(NPC_TIDEWALKER_LURKER, MurlocCords[i][0], MurlocCords[i][1], MurlocCords[i][2], MurlocCords[i][3], TEMPSUMMON_TIMED_DESPAWN_OUT_OF_COMBAT, 10000))
Murloc->AI()->AttackStart(target);
}
Talk(EMOTE_EARTHQUAKE);
Earthquake = false;
Earthquake_Timer = 40000 + rand32() % 5000;
}
} else Earthquake_Timer -= diff;
//TidalWave_Timer
if (TidalWave_Timer <= diff)
{
DoCastVictim(SPELL_TIDAL_WAVE);
TidalWave_Timer = 20000;
} else TidalWave_Timer -= diff;
if (!Phase2)
{
//WateryGrave_Timer
if (WateryGrave_Timer <= diff)
{
//Teleport 4 players under the waterfalls
GuidSet targets;
GuidSet::const_iterator itr;
for (uint8 i = 0; i < 4; ++i)
{
counter = 0;
Unit* target;
do
{
target = SelectTarget(SELECT_TARGET_RANDOM, 1, 50, true); //target players only
if (counter < Playercount)
break;
if (target)
itr = targets.find(target->GetGUID());
++counter;
} while (itr != targets.end());
if (target)
{
targets.insert(target->GetGUID());
ApplyWateryGrave(target, i);
}
}
Talk(SAY_SUMMON_BUBL);
Talk(EMOTE_WATERY_GRAVE);
WateryGrave_Timer = 30000;
} else WateryGrave_Timer -= diff;
//Start Phase2
if (HealthBelowPct(25))
Phase2 = true;
}
else
{
//WateryGlobules_Timer
if (WateryGlobules_Timer <= diff)
{
GuidSet globules;
GuidSet::const_iterator itr;
for (uint8 g = 0; g < 4; g++) //one unit can't cast more than one spell per update, so some players have to cast for us XD
{
counter = 0;
Unit* pGlobuleTarget;
do
{
pGlobuleTarget = SelectTarget(SELECT_TARGET_RANDOM, 0, 50, true);
if (pGlobuleTarget)
itr = globules.find(pGlobuleTarget->GetGUID());
if (counter > Playercount)
break;
++counter;
} while (itr != globules.end());
if (pGlobuleTarget)
{
globules.insert(pGlobuleTarget->GetGUID());
pGlobuleTarget->CastSpell(pGlobuleTarget, globulespell[g], true);
}
}
Talk(EMOTE_WATERY_GLOBULES);
WateryGlobules_Timer = 25000;
} else WateryGlobules_Timer -= diff;
}
DoMeleeAttackIfReady();
}
void SetGUID(ObjectGuid guid, int32 type) override
{
if (type == DATA_SNAKES_WHYD_IT_HAVE_TO_BE_SNAKES)
lWrappedPlayers.insert(guid);
}
void JustSummoned(Creature* pSummoned) override
{
pSummoned->GetMotionMaster()->MoveFollow(m_creature, 0, 0);
m_sSpiritsGuidsSet.insert(pSummoned->GetObjectGuid());
}
void WorldSession::SendLfgUpdateList(uint32 dungeonID)
{
if (!sWorld.getConfig(CONFIG_BOOL_LFR_ENABLE))
{
DEBUG_LOG("SendLfgUpdateList %u failed - Raid finder disabled", GetPlayer()->GetObjectGuid().GetCounter());
return;
}
DEBUG_LOG("SMSG_LFG_SEARCH_RESULTS %u dungeonentry: %u ", GetPlayer()->GetObjectGuid().GetCounter(), dungeonID);
LFGDungeonEntry const* dungeon = sLFGMgr.GetDungeon(dungeonID);
if (!dungeon)
return;
Team team = sWorld.getConfig(CONFIG_BOOL_ALLOW_TWO_SIDE_INTERACTION_GROUP) ? TEAM_NONE : GetPlayer()->GetTeam();
GuidSet groups = sLFGMgr.GetDungeonGroupQueue(dungeon, team);
GuidSet players = sLFGMgr.GetDungeonPlayerQueue(dungeon, team);
uint32 groupCount = groups.size();
uint32 groupSize = 4+4;
for (GuidSet::const_iterator itr = groups.begin(); itr != groups.end(); ++itr)
{
Group* pGroup = sObjectMgr.GetGroup(*itr);
if (!pGroup)
continue;
Player* pLeader = sObjectMgr.GetPlayer(pGroup->GetLeaderGuid());
if (!pLeader)
continue;
sLFGMgr.GetLFGPlayerState(pLeader->GetObjectGuid())->AddFlags(LFG_MEMBER_FLAG_CHARINFO |
LFG_MEMBER_FLAG_COMMENT |
LFG_MEMBER_FLAG_GROUPLEADER |
LFG_MEMBER_FLAG_GROUPGUID |
LFG_MEMBER_FLAG_ROLES |
LFG_MEMBER_FLAG_AREA |
LFG_MEMBER_FLAG_STATUS |
LFG_MEMBER_FLAG_BIND);
uint32 flags = sLFGMgr.GetLFGPlayerState(pLeader->GetObjectGuid())->GetFlags();
if (flags & LFG_MEMBER_FLAG_COMMENT)
groupSize += sLFGMgr.GetLFGPlayerState(pLeader->GetObjectGuid())->GetComment().size()+1;
if (flags & LFG_MEMBER_FLAG_ROLES)
groupSize +=3;
if (flags & LFG_MEMBER_FLAG_BIND)
groupSize += (8+4);
players.insert(*itr);
for (GroupReference *itr2 = pGroup->GetFirstMember(); itr2 != NULL; itr2 = itr2->next())
{
Player* player = itr2->getSource();
if (!player || player == pLeader)
continue;
sLFGMgr.GetLFGPlayerState(player->GetObjectGuid())->AddFlags(LFG_MEMBER_FLAG_GROUPLEADER |
LFG_MEMBER_FLAG_GROUPGUID |
LFG_MEMBER_FLAG_STATUS);
sLFGMgr.GetLFGPlayerState(player->GetObjectGuid())->RemoveFlags(LFG_MEMBER_FLAG_CHARINFO |
LFG_MEMBER_FLAG_COMMENT |
LFG_MEMBER_FLAG_ROLES |
LFG_MEMBER_FLAG_AREA |
LFG_MEMBER_FLAG_BIND);
players.insert(player->GetObjectGuid());
}
}
uint32 playerCount = players.size();
uint32 playerSize = 4+4;
uint32 guidsSize = 0;
GuidSet playersUpdated;
playersUpdated.clear();
for(GuidSet::const_iterator itr = players.begin(); itr != players.end(); ++itr)
{
Player* player = sObjectMgr.GetPlayer(*itr);
if (!player || !player->IsInWorld())
continue;
uint32 flags = sLFGMgr.GetLFGPlayerState(player->GetObjectGuid())->GetFlags();
playerSize += (8+4);
if (flags & LFG_MEMBER_FLAG_CHARINFO)
playerSize += (1+1+1+3+4+4+4+4+4+4+4+4+4+4+4+4+4+4+4+4+4+4+4+4);
if (flags & LFG_MEMBER_FLAG_COMMENT)
playerSize += sLFGMgr.GetLFGPlayerState(player->GetObjectGuid())->GetComment().size()+1; // comment
if (flags & LFG_MEMBER_FLAG_GROUPLEADER)
playerSize += 1;
if (flags & LFG_MEMBER_FLAG_GROUPGUID)
playerSize += 8;
if (flags & LFG_MEMBER_FLAG_ROLES)
playerSize += 1;
if (flags & LFG_MEMBER_FLAG_AREA)
playerSize += 4;
if (flags & LFG_MEMBER_FLAG_STATUS)
playerSize += 1;
if (flags & LFG_MEMBER_FLAG_BIND)
playerSize += (8+4);
if (flags & LFG_MEMBER_FLAG_UPDATE)
{
sLFGMgr.GetLFGPlayerState(player->GetObjectGuid())->RemoveFlags(LFG_MEMBER_FLAG_UPDATE);
playersUpdated.insert(player->GetObjectGuid());
guidsSize += 8;
}
}
WorldPacket data(SMSG_LFG_SEARCH_RESULTS, 4 + 4 + 1 + groupSize + playerSize + guidsSize);
data << uint32(dungeon->type); // type
data << uint32(dungeon->Entry()); // entry from LFGDungeons.dbc
if (!playersUpdated.empty())
{
data << uint8(playersUpdated.size());
for (GuidSet::const_iterator itr = playersUpdated.begin(); itr != playersUpdated.end(); ++itr)
{
data << *itr; // player guid
}
}
else
data << uint8(0);
if (!groups.empty())
{
data << uint32(groupCount); // groups count
data << uint32(groupCount); // groups count2
for (GuidSet::const_iterator itr = groups.begin(); itr != groups.end(); ++itr)
{
Group* group = sObjectMgr.GetGroup(*itr);
if (!group)
continue;
Player* leader = sObjectMgr.GetPlayer(group->GetLeaderGuid());
uint32 flags = sLFGMgr.GetLFGPlayerState(leader->GetObjectGuid())->GetFlags();
data << group->GetObjectGuid();
data << flags;
if (flags & LFG_MEMBER_FLAG_COMMENT)
{
data << sLFGMgr.GetLFGPlayerState(leader->GetObjectGuid())->GetComment().c_str();
}
if (flags & LFG_MEMBER_FLAG_ROLES)
{
for (int i = 0; i < 3; ++i)
{
// need implement function for roles count calculation. or not need?
data << uint8(0);
}
}
if (flags & LFG_MEMBER_FLAG_BIND)
{
ObjectGuid instanceGuid;
uint32 encounters = 0;
if (InstancePlayerBind* bind = leader->GetBoundInstance(dungeon->map, Difficulty(dungeon->difficulty)))
{
if (DungeonPersistentState* state = bind->state)
{
instanceGuid = state->GetInstanceGuid();
encounters = state->GetCompletedEncountersMask();
}
}
data << instanceGuid;
data << encounters;
}
}
}
else
{
data << uint32(0);
data << uint32(0); // groups count2
}
if (!players.empty())
{
data << uint32(playerCount); // players count
data << uint32(playerCount); // players count 2
for(GuidSet::const_iterator itr = players.begin(); itr != players.end(); ++itr)
{
Player* player = sObjectMgr.GetPlayer(*itr);
if (!player || !player->IsInWorld())
continue;
uint32 flags = sLFGMgr.GetLFGPlayerState(player->GetObjectGuid())->GetFlags();
data << *itr; // guid
data << flags; // flags
if (flags & LFG_MEMBER_FLAG_CHARINFO) // charinfo
{
data << uint8(player->getLevel());
data << uint8(player->getClass());
data << uint8(player->getRace());
for(int i = 0; i < 3; ++i)
data << uint8(player->GetTalentsCount(i)); // spent talents count in specific tab
data << uint32(player->GetArmor()); // armor
data << uint32(player->SpellBaseDamageBonusDone(SPELL_SCHOOL_MASK_SPELL)); // spd
data << uint32(player->SpellBaseHealingBonusDone(SPELL_SCHOOL_MASK_SPELL)); // heal
data << uint32(player->GetRatingBonusValue(CR_CRIT_MELEE)); // crit rating melee
data << uint32(player->GetRatingBonusValue(CR_CRIT_RANGED)); // crit rating ranged
data << uint32(player->GetRatingBonusValue(CR_CRIT_SPELL)); // crit rating spell
data << float(player->GetFloatValue(UNIT_FIELD_POWER_REGEN_FLAT_MODIFIER)*5); // mp5
data << float(player->GetFloatValue(UNIT_FIELD_POWER_REGEN_INTERRUPTED_FLAT_MODIFIER)*5); // unk
data << uint32(player->GetTotalAttackPowerValue(BASE_ATTACK)); // attack power
data << uint32(player->GetTotalStatValue(STAT_AGILITY)); // agility
data << uint32(player->GetMaxHealth()); // health
data << uint32(player->GetMaxPower(player->GetPowerType())); // power
data << uint32(player->GetFreeTalentPoints()); // free talent points (TOM_RUS)
data << float(0); // unk
data << uint32(player->GetRatingBonusValue(CR_DEFENSE_SKILL)); // defence rating
data << uint32(player->GetRatingBonusValue(CR_DODGE)); // dodge rating
data << uint32(player->GetRatingBonusValue(CR_BLOCK)); // block rating
data << uint32(player->GetRatingBonusValue(CR_PARRY)); // parry rating
data << uint32(player->GetRatingBonusValue(CR_HASTE_MELEE)); // crit rating
data << uint32(player->GetRatingBonusValue(CR_EXPERTISE)); // expertize
}
if (flags & LFG_MEMBER_FLAG_COMMENT)
data << sLFGMgr.GetLFGPlayerState(player->GetObjectGuid())->GetComment().c_str(); // comment
if (flags & LFG_MEMBER_FLAG_GROUPLEADER) // Group leader flag
{
bool isLeader = false;
if (Group* group = player->GetGroup())
if (player->GetObjectGuid() == group->GetLeaderGuid())
isLeader = true;
data << uint8(isLeader);
}
if (flags & LFG_MEMBER_FLAG_GROUPGUID) // Group guid
{
ObjectGuid groupGuid = ObjectGuid();
if (Group* group = player->GetGroup())
groupGuid = group->GetObjectGuid();
data << groupGuid;
}
if (flags & LFG_MEMBER_FLAG_ROLES) // rolesMask
data << uint8(sLFGMgr.GetLFGPlayerState(player->GetObjectGuid())->GetRoles());
if (flags & LFG_MEMBER_FLAG_AREA) // Area
data << uint32(player->GetAreaId());
if (flags & LFG_MEMBER_FLAG_STATUS) // status
data << uint8(0);
if (flags & LFG_MEMBER_FLAG_BIND)
{
ObjectGuid instanceGuid;
uint32 encounters = 0;
if (InstancePlayerBind* bind = player->GetBoundInstance(dungeon->map, Difficulty(dungeon->difficulty)))
{
if (DungeonPersistentState* state = bind->state)
{
instanceGuid = state->GetInstanceGuid();
encounters = state->GetCompletedEncountersMask();
}
}
data << instanceGuid;
data << encounters;
}
}
}
else
{
data << uint32(0); // players count
data << uint32(0); // unk
}
SendPacket(&data);
}
