SpellEvent Class Reference

Inheritance diagram for SpellEvent:

Public Member Functions
	SpellEvent (Spell *spell)
	~SpellEvent ()
bool	Execute (uint64 e_time, uint32 p_time)
void	Abort (uint64 e_time)
bool	IsDeletable () const
Public Member Functions inherited from BasicEvent
	BasicEvent ()=default
virtual	~BasicEvent ()=default
virtual bool	Execute (uint64, uint32)
virtual bool	IsDeletable () const
virtual void	Abort (uint64)
void	ScheduleAbort ()

Protected Attributes
Spell *	m_Spell

Detailed Description

Constructor & Destructor Documentation

SpellEvent()

SpellEvent::SpellEvent

(

Spell *

spell

)

                                   : BasicEvent()
{
    m_Spell = spell;
}

References m_Spell.

~SpellEvent()

SpellEvent::~SpellEvent

(

)

{
    if (m_Spell->getState() != SPELL_STATE_FINISHED)
        m_Spell->cancel();
 
    if (m_Spell->IsDeletable())
    {
        delete m_Spell;
    }
    else
    {
        LOG_ERROR("spells", "~SpellEvent: {} {} tried to delete non-deletable spell {}. Was not deleted, causes memory leak.",
                       (m_Spell->GetCaster()->IsPlayer() ? "Player" : "Creature"), m_Spell->GetCaster()->GetGUID().ToString(), m_Spell->m_spellInfo->Id);
        ABORT();
    }
}

References ABORT, Spell::cancel(), Spell::GetCaster(), Object::GetGUID(), Spell::getState(), SpellInfo::Id, Spell::IsDeletable(), Object::IsPlayer(), LOG_ERROR, m_Spell, Spell::m_spellInfo, SPELL_STATE_FINISHED, and ObjectGuid::ToString().

Member Function Documentation

Abort()

void SpellEvent::Abort ( uint64  e_time )

virtual

Reimplemented from BasicEvent.

{
    // oops, the spell we try to do is aborted
    if (m_Spell->getState() != SPELL_STATE_FINISHED)
        m_Spell->cancel();
}

References Spell::cancel(), Spell::getState(), m_Spell, and SPELL_STATE_FINISHED.

Execute()

bool SpellEvent::Execute ( uint64  e_time, uint32  p_time  )

virtual

Reimplemented from BasicEvent.

{
    // update spell if it is not finished
    if (m_Spell->getState() != SPELL_STATE_FINISHED)
        m_Spell->update(p_time);
 
    // check spell state to process
    switch (m_Spell->getState())
    {
        case SPELL_STATE_FINISHED:
            {
                // spell was finished, check deletable state
                if (m_Spell->IsDeletable())
                {
                    // check, if we do have unfinished triggered spells
                    return true;                                // spell is deletable, finish event
                }
                // event will be re-added automatically at the end of routine)
            }
            break;
 
        case SPELL_STATE_DELAYED:
            {
                // first, check, if we have just started
                if (m_Spell->GetDelayStart() != 0)
                {
                    {
                        // run the spell handler and think about what we can do next
                        uint64 t_offset = e_time - m_Spell->GetDelayStart();
                        uint64 n_offset = m_Spell->handle_delayed(t_offset);
                        if (n_offset)
                        {
                            // re-add us to the queue
                            m_Spell->GetCaster()->m_Events.AddEvent(this, m_Spell->GetDelayStart() + n_offset, false);
                            return false;                       // event not complete
                        }
                        // event complete
                        // finish update event will be re-added automatically at the end of routine)
                    }
                }
                else
                {
                    // delaying had just started, record the moment
                    m_Spell->SetDelayStart(e_time);
                    // re-plan the event for the delay moment
                    m_Spell->GetCaster()->m_Events.AddEvent(this, e_time + m_Spell->GetDelayMoment(), false);
                    return false;                               // event not complete
                }
            }
            break;
 
        default:
            {
                // all other states
                // event will be re-added automatically at the end of routine)
            } break;
    }
 
    // spell processing not complete, plan event on the next update interval
    m_Spell->GetCaster()->m_Events.AddEvent(this, e_time + 1, false);
    return false;                                           // event not complete
}

References EventProcessor::AddEvent(), Spell::GetCaster(), Spell::GetDelayMoment(), Spell::GetDelayStart(), Spell::getState(), Spell::handle_delayed(), Spell::IsDeletable(), Unit::m_Events, m_Spell, Spell::SetDelayStart(), SPELL_STATE_DELAYED, SPELL_STATE_FINISHED, and Spell::update().

IsDeletable()

bool SpellEvent::IsDeletable ( ) const

virtual

Reimplemented from BasicEvent.

{
    return m_Spell->IsDeletable();
}

References Spell::IsDeletable(), and m_Spell.

Member Data Documentation

m_Spell

Spell* SpellEvent::m_Spell

protected

Referenced by Abort(), Execute(), IsDeletable(), SpellEvent(), and ~SpellEvent().