event_list.h

/* ScummVM - Graphic Adventure Engine
 *
 * ScummVM is the legal property of its developers, whose names
 * are too numerous to list here. Please refer to the COPYRIGHT
 * 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 3 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 ICB_EVENTLIST_H_INCLUDED
#define ICB_EVENTLIST_H_INCLUDED

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

namespace ICB {

// Use globals to save on rdata storage and having repeated strings therein
extern const char *global_event_deleted_placeholder;
extern const char *global_event_generic;
extern const char *global_event_line_of_sight;
extern const char *global_event_sound;
extern const char *global_event_on_camera;
extern const char *global_event_off_camera;
extern const char *global_event_logic_rerun;
extern const char *global_event_out_of_sight;
extern const char *global_event_lift_ascend;
extern const char *global_event_lift_descend;

// This is used to mark deleted objects to save reallocating all the time.
#define EVENT_DELETED_PLACEHOLDER global_event_deleted_placeholder

// This string is used to identify a generic, anonymous event, which all objects respond to all the time.
#define EVENT_LINE_OF_SIGHT global_event_line_of_sight
#define EVENT_OUT_OF_SIGHT global_event_out_of_sight

#define EVENT_ON_CAMERA global_event_on_camera
#define EVENT_OFF_CAMERA global_event_off_camera

#define EVENT_LIFT_ASCEND global_event_lift_ascend
#define EVENT_LIFT_DESCEND global_event_lift_descend

#define EVENT_LOGIC_RERUN global_event_logic_rerun

// Primarily for PSX speed variable data structures are history.
#define EVENT_MAX_EVENTS_REGISTERED 20

// This marks an invalid object ID as the sender of an event.
#define EVENT_INVALID_SENDER_ID (-1)

struct _event {
    const char *s_pcEventName;
    int32 s_nLastSenderID;
    bool8 s_bPending;
    uint8 s_nPadding[3];

    // Initialisation.
    _event() {
        s_pcEventName = EVENT_DELETED_PLACEHOLDER;
        s_nLastSenderID = EVENT_INVALID_SENDER_ID;
        s_bPending = FALSE8;
    }

    // Copy constructor and assignment.
    _event(const _event &oX) {
        s_pcEventName = oX.s_pcEventName;
        s_nLastSenderID = oX.s_nLastSenderID;
        s_bPending = oX.s_bPending;
    }

    const _event &operator=(const _event &oOpB) {
        s_pcEventName = oOpB.s_pcEventName;
        s_nLastSenderID = oOpB.s_nLastSenderID;
        s_bPending = oOpB.s_bPending;
        return (*this);
    }
};

// class _event_list
// Holds the list of events an object is currently interested in and counts of which ones are pending.  Events
// with handlers are held in a separate list and take precedence over generic events, which simply cause the
// logic context for the object to be rerun.
class _event_list {
public:
    // Default constructor and destructor.
    inline _event_list();
    ~_event_list() {}

    // Copy constructor.
    _event_list(const _event_list &oX);

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

    // This sets a new object name for the event list, and resets everything else.
    void SetNewObjectName(const char *pcObjectName);

    // This gets the name of the object that the event list is for.
    const char *GetObjectName() const { return (m_pcObjectName); }

    // This determines whether or not an object requires any event processing.
    inline bool8 HasEventPending();

    // Checks if the named event is waiting for the object.
    bool8 CheckEventWaiting(const char *pcEventName);

    // This determines whether or not the named event is in the list of registered events.
    bool8 IsEventInList(const char *pcEventName) const;

    // These functions have direct script equivalents, but may also get used directly from the engine.
    void AddEventForObject(const char *pcEventName);
    void RemoveEventForObject(const char *pcEventName);
    inline void RemoveAllEventsForObject();
    bool8 DidObjectSendLastNamedEvent(uint32 nObjectID, const char *pcEventName) const;
    int32 GetIDOfLastObjectToPostEvent(const char *pcEventName) const;
    bool8 PostNamedEvent(const char *pcEventName, int32 nSenderID);
    void ClearAllOutstandingEvents();

private:
    const char *m_pcObjectName;                            // Name of the object.
    _event m_pNamedEventList[EVENT_MAX_EVENTS_REGISTERED]; // Named events this object is interested in.
    uint8 m_nNumNamedEventsPending;                        // Number of named events pending.
    uint8 m_nNumRegisteredEvents;                          // Number of events object is currently interested in.
    bool8 m_bEventPending;                                 // If true, at least one event is pending.
    uint8 m_nPad1;

    // Private functions used only inside this class.
    void Initialise();
};

inline _event_list::_event_list() {
    Initialise();
    m_pcObjectName = EVENT_DELETED_PLACEHOLDER;
}

inline void _event_list::SetNewObjectName(const char *pcObjectName) {
    Initialise();
    m_pcObjectName = pcObjectName;
}

inline bool8 _event_list::HasEventPending() {
    bool8 bRetVal;

    // This function has no choice but to clear this flag, for two reasons: firstly, line-of-sight events don't
    // get explicitly handled by a particular piece of code and so there is nowhere to clear the event if we
    // don't do it here; secondly, even if named events are outstanding, I can't leave the event flag set because
    // the script writer might not be making any calls to CheckEventWaiting(), in which case the event flag again
    // would never get cleared.
    bRetVal = m_bEventPending;
    m_bEventPending = FALSE8;
    return (bRetVal);
}

inline void _event_list::RemoveAllEventsForObject() { Initialise(); }

} // End of namespace ICB

#endif // #ifndef EVENTLIST_H_INCLUDED