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	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().

---

The documentation for this struct was generated from the following file:

• azerothcore-wotlk/src/server/scripts/Events/firework_show/firework_show.cpp