void DoGate(uint32 id, uint32 state)
{
if (GameObject *go = GameObject::GetGameObject(*me,pInstance->GetData64(id)))
go->SetGoState(GOState(state));
debug_log("TSCR: npc_grimstone, arena gate update state.");
}
void DoGate(uint32 id, uint32 state)
{
if (GameObject* pGo = m_pInstance->instance->GetGameObject(m_pInstance->GetData64(id)))
pGo->SetGoState(GOState(state));
debug_log("SD2: npc_grimstone, arena gate update state.");
}
void SetData(uint32 id, uint32 value) override
{
switch (id)
{
case DATA_GOTHIK_GATE:
if (GameObject* gate = instance->GetGameObject(GothikGateGUID))
gate->SetGoState(GOState(value));
break;
case DATA_ABOMINATION_KILLED:
AbominationCount = value;
break;
case DATA_HAD_ANUBREKHAN_GREET:
hadAnubRekhanGreet = (value == 1u);
break;
case DATA_HAD_FAERLINA_GREET:
hadFaerlinaGreet = (value == 1u);
break;
case DATA_HAD_THADDIUS_GREET:
hadThaddiusGreet = (value == 1u);
break;
case DATA_HAD_SAPPHIRON_BIRTH:
hadSapphironBirth = (value == 1u);
break;
default:
break;
}
}
void SetData(uint32 id, uint32 value)
{
switch (id)
{
case DATA_HEIGAN_ERUPT:
HeiganErupt(value);
break;
case DATA_GOTHIK_GATE:
if (GameObject* gate = instance->GetGameObject(GothikGateGUID))
gate->SetGoState(GOState(value));
break;
case DATA_HORSEMEN0:
case DATA_HORSEMEN1:
case DATA_HORSEMEN2:
case DATA_HORSEMEN3:
if (value == NOT_STARTED)
{
minHorsemenDiedTime = 0;
maxHorsemenDiedTime = 0;
}
else if (value == DONE)
{
time_t now = time(NULL);
if (minHorsemenDiedTime == 0)
minHorsemenDiedTime = now;
maxHorsemenDiedTime = now;
}
break;
case DATA_ABOMINATION_KILLED:
AbominationCount = value;
break;
}
}
void Load(const char * data)
{
std::istringstream loadStream(LoadBossState(data));
uint32 buff;
loadStream >> buff;
gothikDoorState = GOState(buff);
}
void SetData(uint32 type, uint32 data)
{
switch(type)
{
case DATA_COLOSSUS:
if(Encounter[DATA_COLOSSUS])
{
if(Creature* Leviathan = instance->GetCreature(LeviathanGUID))
Leviathan->AI()->DoAction(ACTION_MOVE_TO_CENTER_POSITION);
if(GameObject* gameObject = instance->GetGameObject(LeviathanGateGUID))
gameObject->SetGoState(GO_STATE_ACTIVE_ALTERNATIVE);
SaveToDB();
} else
Encounter[DATA_COLOSSUS] = 1;
break;
case DATA_HODIR_RARE_CACHE:
HodirRareCacheData = data;
if(!HodirRareCacheData)
{
if(Creature* Hodir = instance->GetCreature(HodirGUID))
if(GameObject* gameObject = instance->GetGameObject(HodirRareCacheGUID))
Hodir->RemoveGameObject(gameObject, false);
}
break;
// Mimiron
case DATA_MIMIRON_ELEVATOR:
if(GameObject* go = instance->GetGameObject(MimironElevatorGUID))
go->SetGoState(GOState(data));
break;
// Thorim
case DATA_RUNIC_DOOR:
if(GameObject* go = instance->GetGameObject(RunicDoorGUID))
go->SetGoState(GOState(data));
break;
case DATA_STONE_DOOR:
if(GameObject* go = instance->GetGameObject(StoneDoorGUID))
go->SetGoState(GOState(data));
break;
default:
break;
}
}
void HandleGameObject(uint64 guid, uint32 state)
{
Player *player = GetPlayerInMap();
if (!player || !guid)
return;
if (GameObject *go = GameObject::GetGameObject(*player,guid))
go->SetGoState(GOState(state));
}
void HandleGameObject(uint64 guid, uint32 state)
{
if (!guid)
{
debug_log("TSCR: Shadow Labyrinth: HandleGameObject fail");
return;
}
if (GameObject *go = instance->GetGameObject(guid))
go->SetGoState(GOState(state));
}
void SetData(uint32 type, uint32 data)
{
switch (type)
{
case TYPE_COLOSSUS:
ColossusData = data;
if (data == 2)
{
if (Creature* pBoss = instance->GetCreature(uiLeviathanGUID))
pBoss->AI()->DoAction(10);
if (GameObject* pGate = instance->GetGameObject(uiLeviathanGateGUID))
pGate->SetGoState(GO_STATE_ACTIVE_ALTERNATIVE);
SaveToDB();
}
break;
case DATA_CALL_TRAM:
if (GameObject* go = instance->GetGameObject(uiMimironTrainGUID))
go->UseDoorOrButton();
break;
case DATA_MIMIRON_ELEVATOR:
if (GameObject* go = instance->GetGameObject(uiMimironElevatorGUID))
go->SetGoState(GOState(data));
break;
case DATA_RUNIC_DOOR:
if (GameObject* go = instance->GetGameObject(uiRunicDoorGUID))
go->SetGoState(GOState(data));
break;
case DATA_STONE_DOOR:
if (GameObject* go = instance->GetGameObject(uiStoneDoorGUID))
go->SetGoState(GOState(data));
break;
case DATA_ADD_HELP_FLAG:
uiSupportKeeperFlag |= UlduarKeeperSupport(data);
break;
case DATA_HODIR_RARE_CHEST:
HodirRareCacheData = data;
break;
default:
break;
}
}
void Load(const char* in)
{
if (!in)
{
OUT_LOAD_INST_DATA_FAIL;
return;
}
OUT_LOAD_INST_DATA(in);
char dataHead1, dataHead2;
uint16 data0, data1, data2, data3, data4, data5, data6, data7, data8;
std::istringstream loadStream(in);
loadStream >> dataHead1 >> dataHead2 >> data0 >> data1 >> data2 >> data3
>> data4 >> data5 >> data6 >> data7 >> data8;
if (dataHead1 == 'G' && dataHead2 == 'D')
{
m_auiEncounter[0] = data0;
m_auiEncounter[1] = data1;
m_auiEncounter[2] = data2;
m_auiEncounter[3] = data3;
m_auiEncounter[4] = data4;
uiSladRanStatueState = GOState(data5);
uiMoorabiStatueState = GOState(data6);
uiDrakkariColossusStatueState = GOState(data7);
uiGalDarahStatueState = GOState(data8);
if (uiSladRanStatueState == GO_STATE_ACTIVE_ALTERNATIVE && uiMoorabiStatueState == GO_STATE_ACTIVE_ALTERNATIVE
&& uiDrakkariColossusStatueState == GO_STATE_ACTIVE_ALTERNATIVE && uiGalDarahStatueState == GO_STATE_ACTIVE_ALTERNATIVE)
spawnSupport = true;
for (uint8 i = 0; i < MAX_ENCOUNTER; ++i)
if (m_auiEncounter[i] == IN_PROGRESS)
m_auiEncounter[i] = NOT_STARTED;
} else OUT_LOAD_INST_DATA_FAIL;
OUT_LOAD_INST_DATA_COMPLETE;
}
//if withRestoreTime true, then newState will be ignored and GO should be restored to original state after 10 seconds
void UpdateGoState(uint64 goGuid, uint32 newState, bool withRestoreTime)
{
if (!goGuid)
return;
if (GameObject* pGo = instance->GetGameObject(goGuid))
{
if (withRestoreTime)
pGo->UseDoorOrButton(10);
else
pGo->SetGoState(GOState(newState));
}
}
void SetData(uint32 type, uint32 data)
{
switch (type)
{
case DATA_HEIGAN_ERUPT:
HeiganErupt(data);
break;
case DATA_GOTHIK_GATE:
if (GameObject* gothikGate = instance->GetGameObject(GothikGateGUID))
gothikGate->SetGoState(GOState(data));
gothikDoorState = GOState(data);
break;
case DATA_HORSEMEN0:
case DATA_HORSEMEN1:
case DATA_HORSEMEN2:
case DATA_HORSEMEN3:
if (data == NOT_STARTED)
{
minHorsemenDiedTime = 0;
maxHorsemenDiedTime = 0;
}
else if (data == DONE)
{
time_t now = time(NULL);
if (minHorsemenDiedTime == 0)
minHorsemenDiedTime = now;
maxHorsemenDiedTime = now;
}
break;
case DATA_ABOMINATION_KILLED:
AbominationCount = data;
break;
default:
break;
}
}
void HandleGameObject(uint64 guid, uint32 state)
{
Player *player = GetPlayerInMap();
if (!player || !guid)
{
debug_log("TSCR: Blood Furnace: HandleGameObject fail");
return;
}
if (GameObject *go = GameObject::GetGameObject(*player, guid))
go->SetGoState(GOState(state));
}
void Load(const char * data)
{
std::istringstream loadStream(LoadBossState(data));
uint32 temp, buff, buff2;
for (uint32 i = 0; i < MAX_BOSS_NUMBER; ++i)
loadStream >> temp;
loadStream >> buff;
gothikDoorState = GOState(buff);
loadStream >> buff2;
playerDied = buff2;
}
void HandleGameObject(uint64 guid, uint32 state)
{
Player *player = GetPlayerInMap();
if (!player || !guid)
{
debug_log("SD2: Instance Razorfen Kraul: HandleGameObject fail");
return;
}
if (GameObject *go = GameObject::GetGameObject(*player,guid))
go->SetGoState(GOState(state));
}
void SetData(uint32 id, uint32 value)
{
switch (id)
{
case DATA_HEIGAN_ERUPT:
HeiganErupt(value);
break;
case DATA_GOTHIK_GATE:
if (pGothikGate)
pGothikGate->SetGoState(GOState(value));
break;
}
}
void SetData(uint32 id, uint32 value) override
{
switch (id)
{
case DATA_GOTHIK_GATE:
if (GameObject* gate = instance->GetGameObject(GothikGateGUID))
gate->SetGoState(GOState(value));
break;
case DATA_HAD_SAPPHIRON_BIRTH:
hadSapphironBirth = (value == 1u);
break;
default:
break;
}
}
void SetData(uint32 type, uint32 data)
{
switch (type)
{
case DATA_CHANNELER_COMBAT:
if (GetBossState(TYPE_MAGTHERIDON) != IN_PROGRESS)
if (Creature* magtheridon = instance->GetCreature(_magtheridonGUID))
magtheridon->SetInCombatWithZone();
break;
case DATA_ACTIVATE_CUBES:
for (std::set<uint64>::const_iterator itr = _cubesSet.begin(); itr != _cubesSet.end(); ++itr)
if (GameObject* cube = instance->GetGameObject(*itr))
cube->RemoveFlag(GAMEOBJECT_FLAGS, GO_FLAG_NOT_SELECTABLE);
break;
case DATA_COLLAPSE:
for (std::set<uint64>::const_iterator itr = _columnSet.begin(); itr != _columnSet.end(); ++itr)
if (GameObject* column = instance->GetGameObject(*itr))
column->SetGoState(GOState(data));
break;
}
}
void SetData(uint32 type, uint32 data)
{
switch (type)
{
case DATA_COLOSSUS:
ColossusData = data;
if (data == 2)
{
if (Creature* Leviathan = instance->GetCreature(LeviathanGUID))
Leviathan->AI()->DoAction(ACTION_MOVE_TO_CENTER_POSITION);
if (GameObject* gameObject = instance->GetGameObject(LeviathanGateGUID))
gameObject->SetGoState(GO_STATE_ACTIVE_ALTERNATIVE);
SaveToDB();
}
break;
case DATA_CALL_TRAM:
if (GameObject* go = instance->GetGameObject(MimironTrainGUID))
go->UseDoorOrButton();
break;
case DATA_MIMIRON_ELEVATOR:
if (GameObject* go = instance->GetGameObject(MimironElevatorGUID))
go->SetGoState(GOState(data));
break;
case DATA_RUNIC_DOOR:
if (GameObject* go = instance->GetGameObject(RunicDoorGUID))
go->SetGoState(GOState(data));
break;
case DATA_STONE_DOOR:
if (GameObject* go = instance->GetGameObject(StoneDoorGUID))
go->SetGoState(GOState(data));
break;
case DATA_HODIR_RARE_CACHE:
HodirRareCacheData = data;
if (!HodirRareCacheData)
{
if (Creature* Hodir = instance->GetCreature(HodirGUID))
if (GameObject* gameObject = instance->GetGameObject(HodirRareCacheGUID))
Hodir->RemoveGameObject(gameObject, false);
}
break;
case DATA_UNBROKEN:
Unbroken = bool(data);
break;
case DATA_ADD_HELP_FLAG:
SupportKeeperFlag |= UlduarKeeperSupport(data);
break;
case DATA_ALGALON_INTRO:
AlgalonIntroDone = data;
SaveToDB();
break;
case DATA_ALGALON_TIMER:
{
if (SignalTimerState == data)
break;
switch (data)
{
case IN_PROGRESS:
SignalTimer = 60000;
SignalTimerMinutes = 60;
DoUpdateWorldState(WORLDSTATE_SHOW_TIMER, 1);
DoUpdateWorldState(WORLDSTATE_ALGALON_TIMER , SignalTimerMinutes);
break;
case DONE:
SignalTimer = 0;
SignalTimerMinutes = 0;
DoUpdateWorldState(WORLDSTATE_SHOW_TIMER, 0);
break;
default:
break;
}
SignalTimerState = data;
SaveToDB();
break;
}
default:
break;
}
}
void SetData(uint32 type, uint32 data)
{
switch (type)
{
case TYPE_COLOSSUS:
ColossusData = data;
if (data == 2)
{
if (Creature* pBoss = instance->GetCreature(uiLeviathanGUID))
pBoss->AI()->DoAction(10);
if (GameObject* pGate = instance->GetGameObject(uiLeviathanGateGUID))
pGate->SetGoState(GO_STATE_ACTIVE_ALTERNATIVE);
SaveToDB();
}
break;
case DATA_CALL_TRAM:
if (GameObject* go = instance->GetGameObject(uiMimironTrainGUID))
go->UseDoorOrButton();
break;
case DATA_MIMIRON_ELEVATOR:
if (GameObject* go = instance->GetGameObject(uiMimironElevatorGUID))
go->SetGoState(GOState(data));
break;
case DATA_RUNIC_DOOR:
if (GameObject* go = instance->GetGameObject(uiRunicDoorGUID))
go->SetGoState(GOState(data));
break;
case DATA_STONE_DOOR:
if (GameObject* go = instance->GetGameObject(uiStoneDoorGUID))
go->SetGoState(GOState(data));
break;
case DATA_ADD_HELP_FLAG:
uiSupportKeeperFlag |= UlduarKeeperSupport(data);
break;
case DATA_HODIR_RARE_CHEST:
HodirRareCacheData = data;
break;
case DATA_ALGALON_INTRO:
AlgalonIntroDone = data;
SaveToDB();
break;
case DATA_ALGALON_TIMER:
{
if (SignalTimerState == data)
break;
switch (data)
{
case IN_PROGRESS:
SignalTimer = 60000;
SignalTimerMinutes = 60;
DoUpdateWorldState(WORLDSTATE_SHOW_TIMER, 1);
DoUpdateWorldState(WORLDSTATE_ALGALON_TIMER , SignalTimerMinutes);
break;
case DONE:
SignalTimer = 0;
SignalTimerMinutes = 0;
DoUpdateWorldState(WORLDSTATE_SHOW_TIMER, 0);
break;
default:
break;
}
SignalTimerState = data;
SaveToDB();
break;
}
default:
break;
}
}
void DoGo(uint32 id, uint32 state)
{
if (GameObject* pGo = m_pInstance->GetSingleGameObjectFromStorage(id))
pGo->SetGoState(GOState(state));
}
void DoGo(uint32 id, uint32 state)
{
if (GameObject *go = GameObject::GetGameObject(*me,pInstance->GetData64(id)))
go->SetGoState(GOState(state));
}
void SetData(uint32 type, uint32 data)
{
switch(type)
{
case DATA_ALAREVENT:
if(Encounters[0] != DONE)
Encounters[0] = data;
break;
case DATA_HIGHASTROMANCERSOLARIANEVENT:
if(Encounters[1] != DONE)
{
Encounters[1] = data;
if (data == IN_PROGRESS && !AstromancerTrash.empty())
for(std::list<uint64>::iterator i = AstromancerTrash.begin(); i != AstromancerTrash.end(); ++i)
{
Creature* trashmob = GetCreature(*i);
if (trashmob && trashmob->isAlive())
trashmob->AI()->DoZoneInCombat();
}
}
break;
case DATA_VOIDREAVEREVENT:
if(Encounters[2] != DONE)
{
Encounters[2] = data;
if (data == IN_PROGRESS && !VoidTrash.empty())
for(std::list<uint64>::iterator i = VoidTrash.begin(); i != VoidTrash.end(); ++i)
{
Creature* trashmob = GetCreature(*i);
if (trashmob && trashmob->isAlive())
trashmob->AI()->DoZoneInCombat();
}
}
break;
case DATA_KAELTHASEVENT:
if(data == NOT_STARTED || data == DONE)
{
for(std::set<uint64>::iterator i = DoorGUID.begin(); i != DoorGUID.end(); ++i)
{
if(GameObject *Door = instance->GetGameObject(*i))
Door->SetGoState(GO_STATE_ACTIVE);
}
}
else
for(std::set<uint64>::iterator i = DoorGUID.begin(); i != DoorGUID.end(); ++i)
{
if(GameObject *Door = instance->GetGameObject(*i))
Door->SetGoState(GO_STATE_READY);
}
if(Encounters[3] != DONE)
Encounters[3] = data;
break;
case DATA_EXPLODE:
// true - explode / false - reset
for(std::set<uint64>::iterator i = ExplodeObjectGUID.begin(); i != ExplodeObjectGUID.end(); ++i)
{
if(GameObject *ExplodeObject = instance->GetGameObject(*i))
ExplodeObject->SetGoState(GOState(!data));
}
}
if(data == DONE)
SaveToDB();
}
void SetData(uint32 type, uint32 data)
{
switch (type)
{
case DATA_COLOSSUS:
ColossusData = data;
if (data == 2)
{
if (Creature* Leviathan = instance->GetCreature(LeviathanGUID))
Leviathan->AI()->DoAction(ACTION_MOVE_TO_CENTER_POSITION);
if (GameObject* gameObject = instance->GetGameObject(LeviathanGateGUID))
gameObject->SetGoState(GO_STATE_ACTIVE_ALTERNATIVE);
SaveToDB();
}
break;
case DATA_HODIR_RARE_CACHE:
HodirRareCacheData = data;
if (!HodirRareCacheData)
{
if (Creature* Hodir = instance->GetCreature(HodirGUID))
if (GameObject* gameObject = instance->GetGameObject(HodirRareCacheGUID))
Hodir->RemoveGameObject(gameObject, false);
}
break;
case DATA_UNBROKEN:
Unbroken = bool(data);
break;
case DATA_RUNIC_DOOR:
if (GameObject* pRunicDoor = instance->GetGameObject(uiRunicDoorGUID))
pRunicDoor->SetGoState(GOState(data));
break;
case DATA_STONE_DOOR:
if (GameObject* pStoneDoor = instance->GetGameObject(uiStoneDoorGUID))
pStoneDoor->SetGoState(GOState(data));
break;
case DATA_MIMIRON_ELEVATOR:
if (GameObject* MimironElevator = instance->GetGameObject(uiMimironElevatorGUID))
MimironElevator->SetGoState(GOState(data));
break;
case DATA_CALL_TRAM:
if (GameObject* MimironTram = instance->GetGameObject(uiMimironTramGUID))
{
// Load Mimiron Tram (unfortunally only server side)
instance->LoadGrid(2307, 284.632f);
if (data == 0)
MimironTram->SetGoState(GO_STATE_READY);
if (data == 1)
MimironTram->SetGoState(GO_STATE_ACTIVE);
// Send movement update to players
if (Map* pMap = MimironTram->GetMap())
{
if (pMap->IsDungeon())
{
Map::PlayerList const &PlayerList = pMap->GetPlayers();
if (!PlayerList.isEmpty())
{
for (Map::PlayerList::const_iterator i = PlayerList.begin(); i != PlayerList.end(); ++i)
{
if (i->getSource())
{
UpdateData data;
WorldPacket pkt;
MimironTram->BuildValuesUpdateBlockForPlayer(&data, i->getSource());
data.BuildPacket(&pkt);
i->getSource()->GetSession()->SendPacket(&pkt);
}
}
}
}
}
}
break;
case DATA_ALGALON:
if (data == SPECIAL)
HandleGameObject(uiAlgalonDoor,true);
break;
case DATA_UNIVERSE_GLOBE:
if(data == GO_STATE_READY)
HandleGameObject(UniverseGlobeGUID, false);
if(data == GO_STATE_ACTIVE)
HandleGameObject(UniverseGlobeGUID, true);
break;
case DATA_UNIVERSE_FLOOR_1:
if(data == GO_STATE_READY)
HandleGameObject(UniverseFloor1GUID, false);
if(data == GO_STATE_ACTIVE)
HandleGameObject(UniverseFloor1GUID, true);
break;
case DATA_UNIVERSE_FLOOR_2:
if(data == GO_STATE_READY)
HandleGameObject(UniverseFloor2GUID, false);
if(data == GO_STATE_ACTIVE)
HandleGameObject(UniverseFloor2GUID, true);
break;
default:
break;
}
}
void SetData(uint32 id, uint32 value)
{
switch(id)
{
case DATA_LEVIATHAN_DOOR:
if (GameObject* pLeviathanDoor = instance->GetGameObject(LeviathanDoorGUID))
pLeviathanDoor->SetGoState(GOState(value));
break;
case DATA_TOWER_DESTROYED:
{
if (Creature* pLeviathan = instance->GetCreature(uiLeviathan))
{
switch(value)
{
case 1: // Tower of Storms
pLeviathan->AI()->DoAction(1);
break;
case 2: // Tower of Flames
pLeviathan->AI()->DoAction(2);
break;
case 3: // Tower of Frost
pLeviathan->AI()->DoAction(3);
break;
case 4: // Tower of Life
pLeviathan->AI()->DoAction(4);
break;
default:
break;
}
}
}
break;
case DATA_RUNIC_DOOR:
if (GameObject* pRunicDoor = instance->GetGameObject(RunicDoorGUID))
pRunicDoor->SetGoState(GOState(value));
break;
case DATA_STONE_DOOR:
if (GameObject* pStoneDoor = instance->GetGameObject(StoneDoorGUID))
pStoneDoor->SetGoState(GOState(value));
break;
case DATA_CALL_TRAM:
if (GameObject* MimironTram = instance->GetGameObject(MimironTramGUID))
{
// Load Mimiron Tram (unfortunally only server side)
instance->LoadGrid(2307, 284.632f);
if (value == 0)
MimironTram->SetGoState(GO_STATE_READY);
if (value == 1)
MimironTram->SetGoState(GO_STATE_ACTIVE);
// Send movement update to players
if (Map* pMap = MimironTram->GetMap())
{
if (pMap->IsDungeon())
{
Map::PlayerList const &PlayerList = pMap->GetPlayers();
if (!PlayerList.isEmpty())
{
for (Map::PlayerList::const_iterator i = PlayerList.begin(); i != PlayerList.end(); ++i)
{
if (i->getSource())
{
UpdateData data;
WorldPacket pkt;
MimironTram->BuildValuesUpdateBlockForPlayer(&data, i->getSource());
data.BuildPacket(&pkt);
i->getSource()->GetSession()->SendPacket(&pkt);
}
}
}
}
}
}
break;
case DATA_MIMIRON_ELEVATOR:
if (GameObject* MimironElevator = instance->GetGameObject(MimironElevatorGUID))
MimironElevator->SetGoState(GOState(value));
break;
case DATA_HODIR_RARE_CHEST:
if (GameObject* HodirRareChest = instance->GetGameObject(HodirRareChestGUID))
{
if (value == GO_STATE_READY)
HodirRareChest->RemoveFlag(GAMEOBJECT_FLAGS,GO_FLAG_UNK1);
}
break;
}
}
void SetData(uint32 type, uint32 data)
{
switch(type)
{
case DATA_MARROWGAR_EVENT:
if(data == DONE)
{
HandleGameObject(uiIceWall1, true);
HandleGameObject(uiIceWall2, true);
HandleGameObject(uiMarrowgarEntrance, true);
if (GameObject* FirstTp = instance->GetGameObject(uiFirstTp))
{
FirstTp->RemoveFlag(GAMEOBJECT_FLAGS, GO_FLAG_INTERACT_COND);
FirstTp->SetGoState(GOState(0));
}
if (GameObject* MarrowgarTp = instance->GetGameObject(uiMarrowgarTp))
{
MarrowgarTp->RemoveFlag(GAMEOBJECT_FLAGS, GO_FLAG_INTERACT_COND);
MarrowgarTp->SetGoState(GOState(0));
}
}
if(data == NOT_STARTED)
{
if (GameObject* FirstTp = instance->GetGameObject(uiFirstTp))
FirstTp->SetFlag(GAMEOBJECT_FLAGS, GO_FLAG_INTERACT_COND);
if (GameObject* MarrowgarTp = instance->GetGameObject(uiMarrowgarTp))
MarrowgarTp->SetFlag(GAMEOBJECT_FLAGS, GO_FLAG_INTERACT_COND);
}
if(data == IN_PROGRESS)
HandleGameObject(uiMarrowgarEntrance, false);
uiEncounter[0] = data;
break;
case DATA_DEATHWHISPER_EVENT:
if(data == DONE)
{
HandleGameObject(uiOratoryDoor, true);
if (GameObject* go = instance->GetGameObject(uiLadyDeathwisperTransporter))
{
go->SetUInt32Value(GAMEOBJECT_LEVEL, 0);
go->SetGoState(GO_STATE_READY);
}
if (GameObject* FlightWarTp = instance->GetGameObject(uiFlightWarTp))
{
FlightWarTp->RemoveFlag(GAMEOBJECT_FLAGS, GO_FLAG_INTERACT_COND);
FlightWarTp->SetGoState(GOState(0));
}
if (GameObject* SaurfangTp = instance->GetGameObject(uiSaurfangTp))
{
SaurfangTp->RemoveFlag(GAMEOBJECT_FLAGS, GO_FLAG_INTERACT_COND);
SaurfangTp->SetGoState(GOState(0));
}
}
if(data == NOT_STARTED)
{
if (GameObject* FlightWarTp = instance->GetGameObject(uiFlightWarTp))
FlightWarTp->SetFlag(GAMEOBJECT_FLAGS, GO_FLAG_INTERACT_COND);
if (GameObject* SaurfangTp = instance->GetGameObject(uiSaurfangTp))
SaurfangTp->SetFlag(GAMEOBJECT_FLAGS, GO_FLAG_INTERACT_COND);
}
if(data == IN_PROGRESS)
HandleGameObject(uiOratoryDoor, false);
uiEncounter[1] = data;
break;
/*case DATA_GUNSHIP_BATTLE_EVENT:
switch(data)
{
case DONE:
break;
case NOT_STARTED:
break;
}
uiEncounter[2] = data;
break;*/
case DATA_SAURFANG_EVENT:
if(data == DONE)
{
if (GameObject* pChest = instance->GetGameObject(uiSaurfangCache))
pChest->SetRespawnTime(pChest->GetRespawnDelay());
if (GameObject* CitadelTp = instance->GetGameObject(uiCitadelTp))
{
CitadelTp->RemoveFlag(GAMEOBJECT_FLAGS, GO_FLAG_INTERACT_COND);
CitadelTp->SetGoState(GOState(0));
}
HandleGameObject(uiSaurfangDoor, true);
HandleGameObject(uiBloodwingDoor, true);
HandleGameObject(uiFrostwingDoor, true);
}
if(data == NOT_STARTED)
{
if (GameObject* CitadelTp = instance->GetGameObject(uiCitadelTp))
CitadelTp->SetFlag(GAMEOBJECT_FLAGS, GO_FLAG_INTERACT_COND);
}
uiEncounter[3] = data;
break;
case DATA_FESTERGURT_EVENT:
if(data == DONE)
{
HandleGameObject(uiOrangeMonsterDoor, true);
HandleGameObject(uiOrangePipe, true);
HandleGameObject(uiGasValve, true);
if (uiEncounter[5] == DONE)
{
HandleGameObject(uiProfCollisionDoor, true);
if (GameObject* Oprofessordoor = instance->GetGameObject(uiProfDoorOrange))
{
Oprofessordoor->SetGoState(GOState(2));
}
}
}
if(data == NOT_STARTED)
{
HandleGameObject(uiOrangeMonsterDoor, true);
HandleGameObject(uiOrangePipe, false);
HandleGameObject(uiGasValve, false);
HandleGameObject(uiProfDoorOrange, false);
}
if(data == IN_PROGRESS)
{
HandleGameObject(uiOrangeMonsterDoor, false);
HandleGameObject(uiOrangePipe, false);
HandleGameObject(uiGasValve, false);
HandleGameObject(uiProfDoorOrange, false);
}
uiEncounter[4] = data;
break;
case DATA_ROTFACE_EVENT:
if(data == DONE)
{
HandleGameObject(uiGreenMonsterDoor, true);
HandleGameObject(uiGreenPipe, true);
HandleGameObject(uiOozeValve, true);
if (uiEncounter[4] == DONE)
{
HandleGameObject(uiProfCollisionDoor, true);
if (GameObject* Gprofessordoor = instance->GetGameObject(uiProfDoorGreen))
{
Gprofessordoor->SetGoState(GOState(2));
}
}
}
if(data == NOT_STARTED)
{
HandleGameObject(uiGreenMonsterDoor, true);
HandleGameObject(uiGreenPipe, false);
HandleGameObject(uiOozeValve, false);
HandleGameObject(uiProfDoorGreen, false);
}
if(data == IN_PROGRESS)
{
HandleGameObject(uiGreenMonsterDoor, false);
HandleGameObject(uiGreenPipe, false);
HandleGameObject(uiOozeValve, false);
HandleGameObject(uiProfDoorGreen, false);
}
uiEncounter[5] = data;
break;
case DATA_PROFESSOR_PUTRICIDE_EVENT:
if(data == DONE)
HandleGameObject(uiProffesorDoor, true);
if(data == NOT_STARTED)
HandleGameObject(uiProffesorDoor, true);
if(data == IN_PROGRESS)
HandleGameObject(uiProffesorDoor, false);
uiEncounter[6] = data;
break;
case DATA_BLOOD_PRINCE_COUNCIL_EVENT:
if(data == DONE)
{
HandleGameObject(uiCrimsonHallDoor1, true);
HandleGameObject(uiCrimsonHallDoor2, true);
HandleGameObject(uiCrimsonHallDoor3, true);
}
if(data == NOT_STARTED)
HandleGameObject(uiCrimsonHallDoor1, true);
if(data == IN_PROGRESS)
HandleGameObject(uiCrimsonHallDoor1, false);
uiEncounter[7] = data;
break;
case DATA_BLOOD_QUEEN_LANATHEL_EVENT:
if(data == DONE)
{
if (GameObject* go = instance->GetGameObject(uiBloodQueenTransporter))
{
go->SetUInt32Value(GAMEOBJECT_LEVEL, 0);
go->SetGoState(GO_STATE_READY);
}
}
uiEncounter[8] = data;
break;
case DATA_VALITHRIA_DREAMWALKER_EVENT:
if(data == DONE)
{
if (GameObject* pChest = instance->GetGameObject(uiDreamwalkerCache))
pChest->SetRespawnTime(pChest->GetRespawnDelay());
if (GameObject* SindragossaTp = instance->GetGameObject(uiSindragossaTp))
{
SindragossaTp->RemoveFlag(GAMEOBJECT_FLAGS, GO_FLAG_INTERACT_COND);
SindragossaTp->SetGoState(GOState(0));
}
if (GameObject* go = instance->GetGameObject(uiValithriaTransporter))
{
go->SetUInt32Value(GAMEOBJECT_LEVEL, 0);
go->SetGoState(GO_STATE_READY);
}
if (GameObject* go = instance->GetGameObject(uiSindragossaTransporter))
{
go->SetUInt32Value(GAMEOBJECT_LEVEL, 0);
go->SetGoState(GO_STATE_READY);
}
HandleGameObject(uiDragonDoor1, true);
HandleGameObject(uiDragonDoor2, true);
HandleGameObject(uiDragonDoor3, true);
}
if(data == NOT_STARTED)
{
if (GameObject* SindragossaTp = instance->GetGameObject(uiSindragossaTp))
SindragossaTp->SetFlag(GAMEOBJECT_FLAGS, GO_FLAG_INTERACT_COND);
}
if(data == IN_PROGRESS)
{
HandleGameObject(uiDragonDoor1, false);
HandleGameObject(uiRoostDoor3, true);
HandleGameObject(uiRoostDoor2, true);
if (uiDifficulty == RAID_DIFFICULTY_25MAN_NORMAL || uiDifficulty == RAID_DIFFICULTY_25MAN_HEROIC)
{
HandleGameObject(uiRoostDoor1, true);
HandleGameObject(uiRoostDoor4, true);
}
}
uiEncounter[9] = data;
break;
case DATA_SINDRAGOSA_EVENT:
if(data == DONE)
{
HandleGameObject(uiSindragosaDoor1, true);
HandleGameObject(uiSindragosaDoor2, true);
}
uiEncounter[10] = data;
break;
case DATA_LICH_KING_EVENT:
uiEncounter[11] = data;
break;
case DATA_SPAWN:
if(data >= 2)
Creature* sindragosa = instance->SummonCreature(CREATURE_SINDRAGOSA, SpawnLoc[0]);
break;
}
if (data == DONE)
SaveToDB();
}
