EventMap.h

Go to the documentation of this file.

/*
 * Copyright (C) 2008-2016 TrinityCore <http://www.trinitycore.org/>
 *
 * This program is free software; you can redistribute it and/or modify it
 * under the terms of the GNU General Public License as published by the
 * Free Software Foundation; either version 2 of the License, or (at your
 * option) any later version.
 *
 * This program is distributed in the hope that it will be useful, but WITHOUT
 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
 * more details.
 *
 * You should have received a copy of the GNU General Public License along
 * with this program. If not, see <http://www.gnu.org/licenses/>.
 */

#ifndef _EVENT_MAP_H_
#define _EVENT_MAP_H_

#include "Common.h"
#include "Duration.h"
#include "Util.h"

class TC_COMMON_API EventMap
{
 typedef std::multimap<uint32, uint32> EventStore;

public:
 EventMap() : _time(0), _phase(0), _lastEvent(0) { }

 void Reset();

 void Update(uint32 time)
 {
 _time += time;
 }

 uint32 GetTimer() const
 {
 return _time;
 }

 uint8 GetPhaseMask() const
 {
 return _phase;
 }

 bool Empty() const
 {
 return _eventMap.empty();
 }

 void SetPhase(uint8 phase);

 void AddPhase(uint8 phase)
 {
 if (phase && phase <= 8)
 _phase |= uint8(1 << (phase - 1));
 }

 void RemovePhase(uint8 phase)
 {
 if (phase && phase <= 8)
 _phase &= uint8(~(1 << (phase - 1)));
 }

 void ScheduleEvent(uint32 eventId, Milliseconds const& time, uint32 group = 0, uint8 phase = 0)
 {
 ScheduleEvent(eventId, uint32(time.count()), group, phase);
 }

 void ScheduleEvent(uint32 eventId, uint32 time, uint32 group = 0, uint8 phase = 0);

 void RescheduleEvent(uint32 eventId, Milliseconds const& time, uint32 group = 0, uint8 phase = 0)
 {
 RescheduleEvent(eventId, uint32(time.count()), group, phase);
 }

 void RescheduleEvent(uint32 eventId, uint32 time, uint32 group = 0, uint8 phase = 0)
 {
 CancelEvent(eventId);
 ScheduleEvent(eventId, time, group, phase);
 }

 void Repeat(Milliseconds const& time)
 {
 Repeat(uint32(time.count()));
 }

 void Repeat(uint32 time)
 {
 _eventMap.insert(EventStore::value_type(_time + time, _lastEvent));
 }

 void Repeat(Milliseconds const& minTime, Milliseconds const& maxTime)
 {
 Repeat(uint32(minTime.count()), uint32(maxTime.count()));
 }

 void Repeat(uint32 minTime, uint32 maxTime)
 {
 Repeat(urand(minTime, maxTime));
 }

 uint32 ExecuteEvent();

 void DelayEvents(Milliseconds const& delay)
 {
 DelayEvents(uint32(delay.count()));
 }

 void DelayEvents(uint32 delay)
 {
 _time = delay < _time ? _time - delay : 0;
 }

 void DelayEvents(Milliseconds const& delay, uint32 group)
 {
 DelayEvents(uint32(delay.count()), group);
 }

 void DelayEvents(uint32 delay, uint32 group);

 void CancelEvent(uint32 eventId);

 void CancelEventGroup(uint32 group);

 uint32 GetNextEventTime(uint32 eventId) const;

 uint32 GetNextEventTime() const
 {
 return Empty() ? 0 : _eventMap.begin()->first;
 }

 bool IsInPhase(uint8 phase) const
 {
 return phase <= 8 && (!phase || _phase & (1 << (phase - 1)));
 }

 uint32 GetTimeUntilEvent(uint32 eventId) const;

private:
 uint32 _time;

 uint8 _phase;

 EventStore _eventMap;

 uint32 _lastEvent;
};

#endif // _EVENT_MAP_H_