go_firework_show Struct Reference

Inheritance diagram for go_firework_show:

Public Member Functions
	go_firework_show (GameObject *go)
void	InitShow ()
void	StartShow (int minutesOffset)
void	StopShow ()
int32	SpawnNextFirework ()
void	UpdateAI (uint32 diff) override
Public Member Functions inherited from GameObjectAI
	GameObjectAI (GameObject *go)
virtual	~GameObjectAI ()
virtual void	UpdateAI (uint32)
virtual void	InitializeAI ()
virtual void	Reset ()
virtual void	DoAction (int32)
virtual void	SetGUID (ObjectGuid, int32)
virtual ObjectGuid	GetGUID (int32) const
virtual bool	GossipHello (Player *, bool)
virtual bool	GossipSelect (Player *, uint32, uint32)
virtual bool	GossipSelectCode (Player *, uint32, uint32, char const *)
virtual bool	QuestAccept (Player *, Quest const *)
virtual bool	QuestReward (Player *, Quest const *, uint32)
virtual uint32	GetDialogStatus (Player *)
virtual void	Destroyed (Player *, uint32)
virtual uint32	GetData (uint32) const
virtual void	SetData (uint32, uint32)
virtual void	OnGameEvent (bool, uint16)
virtual void	OnStateChanged (uint32, Unit *)
virtual void	EventInform (uint32)
virtual void	SpellHit (Unit *, SpellInfo const *)
virtual bool	CanBeSeen (Player const *)
virtual void	JustSummoned (Creature *)
virtual void	SummonedCreatureDespawn (Creature *)
virtual void	SummonedCreatureDies (Creature *, Unit *)
virtual void	SummonedCreatureEvade (Creature *)

Private Attributes
TaskScheduler	_scheduler
uint32_t	_curIdx
bool	_showRunning
FireworkShow const *	_show

Additional Inherited Members
Static Public Member Functions inherited from GameObjectAI
static int32	Permissible (GameObject const *go)
Protected Attributes inherited from GameObjectAI
GameObject *const	me

Detailed Description

Constructor & Destructor Documentation

go_firework_show()

go_firework_show::go_firework_show ( GameObject *  go )

inline

                                     : GameObjectAI(go)
    {
        _curIdx = 0;
        _showRunning = false;
        _show = nullptr;
 
        InitShow();
    }

References _curIdx, _show, _showRunning, and InitShow().

Member Function Documentation

InitShow()

void go_firework_show::InitShow ( )

inline

    {
        _show = nullptr;
 
        auto itr = FireworkShowStore.find(std::make_pair(me->GetMapId(), me->GetZoneId()));
        if (itr != FireworkShowStore.end() && itr->second)
            _show = itr->second;
 
        StopShow();
 
        _scheduler.Schedule(Milliseconds(4200), [this](TaskContext context)
            {
                // check for show start
                if (!_showRunning)
                {
                    tzset(); // set timezone for localtime_r() -> fix issues due to daylight time
                    tm local_tm = Acore::Time::TimeBreakdown();
 
                    // each show runs approx. 12 minutes
                    // and starts at the full hour
                    if ((local_tm.tm_min >= 0) && (local_tm.tm_min < 12))
                    {
                        StartShow(local_tm.tm_min);
                    }
                }
 
                context.Repeat();
            });
    }

References _scheduler, _show, _showRunning, FireworkShowStore, WorldLocation::GetMapId(), WorldObject::GetZoneId(), GameObjectAI::me, TaskContext::Repeat(), TaskScheduler::Schedule(), StartShow(), StopShow(), and Acore::Time::TimeBreakdown().

Referenced by go_firework_show().

SpawnNextFirework()

int32 go_firework_show::SpawnNextFirework ( )

inline

    {
        if (!_showRunning)
            return -1;
 
        if (!_show || !_show->schedule.entries || !_show->spawns.entries)
            return -2;
 
        if (_curIdx >= _show->schedule.size)
            return -3;
 
        uint32 posIdx = _show->schedule.entries[_curIdx].spawnIndex;
        if (posIdx < _show->spawns.size)
        {
            GameObject* go = me->SummonGameObject(_show->schedule.entries[_curIdx].gameobjectId,
                _show->spawns.entries[posIdx].x,
                _show->spawns.entries[posIdx].y,
                _show->spawns.entries[posIdx].z,
                _show->spawns.entries[posIdx].o,
                _show->spawns.entries[posIdx].rot0,
                _show->spawns.entries[posIdx].rot1,
                _show->spawns.entries[posIdx].rot2,
                _show->spawns.entries[posIdx].rot3,
                0);
 
            // trigger despawn animation for firework explosion
            if (go)
            {
                go->setActive(true);
                go->DespawnOrUnsummon();
                go->AddObjectToRemoveList();
            }
        }
 
        uint32 ts = _show->schedule.entries[_curIdx].timestamp;
 
        if (++_curIdx >= _show->schedule.size)
            return -4;
 
        if (_show->schedule.entries[_curIdx].timestamp < ts)
            return -5;
 
        return (_show->schedule.entries[_curIdx].timestamp - ts);
    }

References _curIdx, _show, _showRunning, WorldObject::AddObjectToRemoveList(), GameObject::DespawnOrUnsummon(), FireworkShow::entries, FireworkShowScheduleEntry::gameobjectId, GameObjectAI::me, FireworkShow::schedule, WorldObject::setActive(), FireworkShow::size, FireworkShowScheduleEntry::spawnIndex, FireworkShow::spawns, WorldObject::SummonGameObject(), and FireworkShowScheduleEntry::timestamp.

Referenced by StartShow().

StartShow()

void go_firework_show::StartShow ( int  minutesOffset )

inline

    {
        if (!_show || !_show->schedule.entries || !_show->schedule.size || !_show->spawns.entries || !_show->spawns.size)
            return;
 
        _curIdx = 0;
        _showRunning = true;
        me->setActive(true);
 
        // fast-forward show if we've got a late start
        if (minutesOffset > 0)
        {
            int ts = 0;
            do {
                ts = _show->schedule.entries[_curIdx].timestamp;
            } while ((ts <= (minutesOffset * MINUTE * IN_MILLISECONDS)) && (++_curIdx < _show->schedule.size));
        }
 
        _scheduler.Schedule(0s, [this](TaskContext context)
            {
                int32 dt = 0;
                do {
                    dt = SpawnNextFirework();
                } while (dt == 0);
 
                if (0 < dt)
                    context.Repeat(Milliseconds(dt));
                else
                    StopShow();
            });
    }

References _curIdx, _scheduler, _show, _showRunning, FireworkShow::entries, IN_MILLISECONDS, GameObjectAI::me, MINUTE, TaskContext::Repeat(), TaskScheduler::Schedule(), FireworkShow::schedule, WorldObject::setActive(), FireworkShow::size, SpawnNextFirework(), FireworkShow::spawns, StopShow(), and FireworkShowScheduleEntry::timestamp.

Referenced by InitShow().

StopShow()

void go_firework_show::StopShow ( )

inline

    {
        if (_showRunning)
        {
            // Trigger SAI to spawn 'Toasting Goblets' on show end
            std::list<GameObject*> _goList;
            me->GetGameObjectListWithEntryInGrid(_goList, GO_TOASTING_GOBLET, 1420.0f);
 
            for (std::list<GameObject*>::const_iterator itr = _goList.begin(); itr != _goList.end(); ++itr)
            {
                if (GameObjectAI* ai = (*itr)->AI())
                    ai->SetData(0, 1);
            }
 
            // Trigger SAI to make Revelers cheer on show end
            for (uint32 i = 0; i < COUNT_REVELER_ID; i++)
            {
                std::list<Creature*> _crList;
                me->GetCreatureListWithEntryInGrid(_crList, _show->revelerId[i], 1420.0f);
 
                for (std::list<Creature*>::const_iterator itr = _crList.begin(); itr != _crList.end(); ++itr)
                {
                    if (CreatureAI* ai = (*itr)->AI())
                        ai->SetData(0, 1);
                }
            }
        }
 
        _showRunning = false;
        me->setActive(false);
    }

References _show, _showRunning, COUNT_REVELER_ID, WorldObject::GetCreatureListWithEntryInGrid(), WorldObject::GetGameObjectListWithEntryInGrid(), GO_TOASTING_GOBLET, GameObjectAI::me, FireworkShow::revelerId, and WorldObject::setActive().

Referenced by InitShow(), and StartShow().

UpdateAI()

void go_firework_show::UpdateAI ( uint32  diff )

inlineoverridevirtual

Reimplemented from GameObjectAI.

    {
        _scheduler.Update(diff);
    }

References _scheduler, and TaskScheduler::Update().

Member Data Documentation

_curIdx

uint32_t go_firework_show::_curIdx

private

Referenced by go_firework_show(), SpawnNextFirework(), and StartShow().

_scheduler

TaskScheduler go_firework_show::_scheduler

private

Referenced by InitShow(), StartShow(), and UpdateAI().

_show

FireworkShow const* go_firework_show::_show

private

Referenced by go_firework_show(), InitShow(), SpawnNextFirework(), StartShow(), and StopShow().

_showRunning

bool go_firework_show::_showRunning

private

Referenced by go_firework_show(), InitShow(), SpawnNextFirework(), StartShow(), and StopShow().