scummvm/engines/icb/event_timer.h

/* ResidualVM - A 3D game interpreter
 *
 * ResidualVM is the legal property of its developers, whose names
 * are too numerous to list here. Please refer to the AUTHORS
 * file distributed with this source distribution.
 *
 * Additional copyright for this file:
 * Copyright (C) 1999-2000 Revolution Software Ltd.
 * This code is based on source code created by Revolution Software,
 * used with permission.
 *
 * 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, write to the Free Software
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
 *
 */

#ifndef ICB_EVENTTIMER_H_INCLUDED
#define ICB_EVENTTIMER_H_INCLUDED

#include "common/stream.h"

#include "engines/icb/string_vest.h"
#include "engines/icb/common/px_string.h"
#include "engines/icb/event_list.h"

namespace ICB {

// class _event_timer
// This structure holds timing information for events that are posted into the future or have
// to happen repeatedly.
class _event_timer {
public:
	// Default constructor and destructor.
	inline _event_timer();
	~_event_timer() {}

	// Copy constructor.
	inline _event_timer(const _event_timer &oX);

	// Operator '='.
	inline const _event_timer &operator=(const _event_timer &oOpB);

	// Gets and sets.
	void SetObjectID(int32 nObjectID) { m_nObjectID = nObjectID; }
	void SetStart(uint32 nStart) { m_nStart = nStart; }
	void SetEnd(uint32 nEnd) { m_nEnd = nEnd; }
	void SetInterval(uint32 nInterval) { m_nInterval = nInterval; }
	void SetEventTime(uint32 nTime) { m_nCurrentTime = nTime; }
	inline void SetEventName(const char *pcEventName);

	int32 GetObjectID() const { return (m_nObjectID); }
	uint32 GetStart() const { return (m_nStart); }
	uint32 GetEnd() const { return (m_nEnd); }
	uint32 GetInterval() const { return (m_nInterval); }
	uint32 GetEventTime() const { return (m_nCurrentTime); }
	const char *GetEventName() const { return (m_pcEventName); }

	void Save(Common::WriteStream *stream) const {
		stream->writeSint32LE(m_nObjectID);
		stream->writeUint32LE(m_nStart);
		stream->writeUint32LE(m_nEnd);
		stream->writeUint32LE(m_nInterval);
		stream->writeUint32LE(m_nCurrentTime);
		stream->write(m_pcEventName, MAXLEN_EVENT_NAME);
	}
	void Restore(Common::SeekableReadStream *stream) {
		m_nObjectID = stream->readSint32LE();
		m_nStart = stream->readUint32LE();
		m_nEnd = stream->readUint32LE();
		m_nInterval = stream->readUint32LE();
		m_nCurrentTime = stream->readUint32LE();
		stream->read(m_pcEventName, MAXLEN_EVENT_NAME);
	}

private:
	int32 m_nObjectID;                     // ID of object initiating this timer.
	uint32 m_nStart;                       // When the event should start, relative to the time the event was placed.
	uint32 m_nEnd;                         // When the event should end, relative to the time the event was placed.
	uint32 m_nInterval;                    // Interval between occurrences of the event.
	uint32 m_nCurrentTime;                 // Relative to the reference time.
	char m_pcEventName[MAXLEN_EVENT_NAME]; // Name of the event.
};

inline _event_timer::_event_timer() {
	m_nObjectID = EVENT_INVALID_SENDER_ID;
	m_nStart = 0;
	m_nEnd = 0;
	m_nInterval = 0;
	m_nCurrentTime = 0;
	m_pcEventName[0] = '\0';
}

inline _event_timer::_event_timer(const _event_timer &oX) {
	m_nObjectID = oX.m_nObjectID;
	m_nStart = oX.m_nStart;
	m_nEnd = oX.m_nEnd;
	m_nInterval = oX.m_nInterval;
	m_nCurrentTime = oX.m_nCurrentTime;
	strcpy(m_pcEventName, oX.m_pcEventName);
}

inline const _event_timer &_event_timer::operator=(const _event_timer &oOpB) {
	m_nObjectID = oOpB.m_nObjectID;
	m_nStart = oOpB.m_nStart;
	m_nEnd = oOpB.m_nEnd;
	m_nInterval = oOpB.m_nInterval;
	m_nCurrentTime = oOpB.m_nCurrentTime;
	strcpy(m_pcEventName, oOpB.m_pcEventName);

	return (*this);
}

inline void _event_timer::SetEventName(const char *pcEventName) {
	if (strlen(pcEventName) >= MAXLEN_EVENT_NAME)
		Fatal_error("Event name [%s] too long (max %d) in _event_timer::SetEventName()", pcEventName, MAXLEN_EVENT_NAME - 1);

	strcpy(m_pcEventName, pcEventName);
}

} // End of namespace ICB

#endif // #if !defined( EVENTTIMER_H_INCLUDED )