runtime.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.
 *
 * 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 MTROPOLIS_RUNTIME_H
#define MTROPOLIS_RUNTIME_H
 
#include "common/archive.h"
#include "common/array.h"
#include "common/events.h"
#include "common/language.h"
#include "common/platform.h"
#include "common/ptr.h"
#include "common/stream.h"
#include "common/hashmap.h"
#include "common/hash-str.h"
 
#include "graphics/pixelformat.h"
 
#include "mtropolis/actions.h"
#include "mtropolis/core.h"
#include "mtropolis/coroutine_protos.h"
#include "mtropolis/data.h"
#include "mtropolis/debug.h"
#include "mtropolis/hacks.h"
#include "mtropolis/miniscript_protos.h"
#include "mtropolis/subtitles.h"
#include "mtropolis/vthread.h"
 
class OSystem;
 
namespace Audio {
 
class Mixer;
 
} // End of namespace Audio
 
namespace Common {
 
class RandomSource;
 
} // End of namespace Common
 
namespace Graphics {
 
struct WinCursorGroup;
class MacCursor;
class MacFontManager;
class ManagedSurface;
class Cursor;
struct PixelFormat;
struct Surface;
 
} // End of namespace Graphics
 
namespace MTropolis {
 
class Asset;
class AssetManagerInterface;
class CoroutineManager;
class CursorGraphic;
class CursorGraphicCollection;
class Element;
class GraphicModifier;
class KeyboardInputEvent;
class MessageDispatch;
class MiniscriptThread;
class Modifier;
class ObjectLinkingScope;
class PlugInModifier;
class RuntimeObject;
class PlugIn;
class Project;
class Runtime;
class Structural;
class SystemInterface;
class VisualElement;
class Window;
class WorldManagerInterface;
struct DynamicValue;
struct DynamicValueWriteProxy;
struct IBoundaryDetector;
struct ICollider;
struct ILoadUIProvider;
struct IMessageConsumer;
struct IModifierContainer;
struct IPlugInModifierFactory;
struct IPlugInModifierFactoryAndDataFactory;
struct IPostEffect;
struct ISaveUIProvider;
struct ISaveWriter;
struct IStructuralReferenceVisitor;
struct MessageProperties;
struct ModifierLoaderContext;
struct PlugInModifierLoaderContext;
struct SIModifierFactory;
template<typename TElement, typename TElementData> class ElementFactory;
 
#ifdef MTROPOLIS_DEBUG_ENABLE
class DebugPrimaryTaskList;
#endif
 
char invariantToLower(char c);
Common::String toCaseInsensitive(const Common::String &str);
bool caseInsensitiveEqual(const Common::String &str1, const Common::String &str2);
size_t caseInsensitiveFind(const Common::String &stringToSearch, const Common::String &stringToFind);
 
enum ColorDepthMode {
    kColorDepthMode1Bit,
    kColorDepthMode2Bit,
    kColorDepthMode4Bit,
    kColorDepthMode8Bit,
    kColorDepthMode16Bit,
    kColorDepthMode32Bit,
 
    kColorDepthModeCount,
 
    kColorDepthModeInvalid,
};
 
namespace SceneTransitionTypes {
 
enum SceneTransitionType {
    kNone,
    kPatternDissolve,
    kRandomDissolve, // No steps
    kFade,
    kSlide, // Directional
    kPush,  // Directional
    kZoom,
    kWipe, // Directional
};
 
bool loadFromData(SceneTransitionType &transType, int32 data);
 
} // End of namespace SceneTransitionTypes
 
namespace SceneTransitionDirections {
 
enum SceneTransitionDirection {
    kUp,
    kDown,
    kLeft,
    kRight,
};
 
bool loadFromData(SceneTransitionDirection &transDir, int32 data);
 
} // End of namespace SceneTransitionDirections
 
enum ConstraintDirection {
    kConstraintDirectionNone,
    kConstraintDirectionHorizontal,
    kConstraintDirectionVertical,
};
 
enum MouseInteractivityTestType {
    kMouseInteractivityTestAnything,
    kMouseInteractivityTestMouseClick,
};
 
namespace DynamicValueSourceTypes {
    enum DynamicValueSourceType {
        kInvalid,
 
        kConstant,
        kVariableReference,
        kIncomingData,
    };
}
 
namespace DynamicValueTypes {
 
// These values are stored in the saved game format, so they must be stable
enum DynamicValueType {
    kInvalid = 0,
 
    kNull = 1,
    kInteger = 2,
    kFloat = 3,
    kPoint = 4,
    kIntegerRange = 5,
    kBoolean = 6,
    kVector = 7,
    kLabel = 8,
    kEvent = 9,
 
    kString = 12,
    kList = 13,
    kObject = 14,
    kWriteProxy = 15,
 
    kUnspecified = 16,
};
 
} // End of namespace DynamicValuesTypes
 
namespace AttributeIDs {
 
enum AttributeID {
    kAttribCache = 55,
    kAttribDirect = 56,
    kAttribVisible = 58,
    kAttribLayer = 24,
    kAttribPaused = 25,
    kAttribLoop = 57,
    kAttribPosition = 1,
    kAttribWidth = 2,
    kAttribHeight = 3,
    kAttribRate = 4,
    kAttribRange = 5,
    kAttribCel = 6,
    kAttribLoopBackForth = 59,
    kAttribPlayEveryFrame = 60,
    kAttribTimeValue = 16,
    kAttribTrackDisable = 51,
    kAttribTrackEnable = 50,
    kAttribVolume = 13,
    kAttribBalance = 26,
    kAttribText = 7,
    kAttribMasterVolume = 18,
    kAttribUserTimeout = 19,
};
 
} // End of namespace AttributeIDs
 
namespace EventIDs {
 
enum EventID {
    kNothing = 0,
 
    kElementEnableEdit = 207,
    kElementDisableEdit = 220,
    kElementSelect = 209,
    kElementDeselect = 210,
    kElementToggleSelect = 213,
    kElementUpdatedCalculated = 219,
    kElementShow = 222,
    kElementHide = 223,
 
    kElementScrollUp = 1001,
    kElementScrollDown = 1002,
    kElementScrollRight = 1005,
    kElementScrollLeft = 1006,
 
    kMotionStarted = 501,
    kMotionEnded = 502,
 
    kTransitionStarted = 503,
    kTransitionEnded = 504,
 
    kMouseDown = 301,
    kMouseUp = 302,
    kMouseOver = 303,
    kMouseOutside = 304,
    kMouseTrackedInside = 305,
    kMouseTrackedOutside = 306,
    kMouseTracking = 307,
    kMouseUpInside = 309,
    kMouseUpOutside = 310,
 
    kSceneStarted = 101,
    kSceneEnded = 102,
    kSceneDeactivated = 103,
    kSceneReactivated = 104,
    kSceneTransitionEnded = 506,
 
    kSharedSceneReturnedToScene = 401,
    kSharedSceneSceneChanged = 402,
    kSharedSceneNoNextScene = 403,
    kSharedSceneNoPrevScene = 404,
 
    kParentEnabled = 2001,
    kParentDisabled = 2002,
    kParentChanged = 227,
 
    kPreloadMedia = 1701,
    kFlushMedia = 1703,
    kPrerollMedia = 1704,
 
    kCloseProject = 1601,
 
    kUserTimeout = 1801,
    kProjectStarted = 1802,
    kProjectEnded = 1803,
    kFlushAllMedia = 1804,
 
    kAttribGet = 1300,
    kAttribSet = 1200,
 
    kClone = 226,
    kKill = 228,
 
    kPlay = 201,
    kStop = 202,
    kPause = 801,
    kUnpause = 802,
    kTogglePause = 803,
    kAtFirstCel = 804,
    kAtLastCel = 805,
 
 
    kAuthorMessage = 900,
};
 
bool isCommand(EventID eventID);
 
} // End of namespace EventIDs
 
MiniscriptInstructionOutcome pointWriteRefAttrib(Common::Point &point, MiniscriptThread *thread, DynamicValueWriteProxy &proxy, const Common::String &attrib);
Common::String pointToString(const Common::Point &point);
 
struct IntRange {
    IntRange();
    IntRange(int32 pmin, int32 pmax);
 
    int32 min;
    int32 max;
 
    bool load(const Data::IntRange &range);
 
    inline bool operator==(const IntRange &other) const {
        return min == other.min && max == other.max;
    }
 
    inline bool operator!=(const IntRange &other) const {
        return !((*this) == other);
    }
 
    MiniscriptInstructionOutcome refAttrib(MiniscriptThread *thread, DynamicValueWriteProxy &proxy, const Common::String &attrib);
    Common::String toString() const;
};
 
struct Label {
    Label();
    Label(int32 psuperGroupID, int32 pid);
 
    uint32 superGroupID;
    uint32 id;
 
    bool load(const Data::Label &label);
 
    inline bool operator==(const Label &other) const {
        return superGroupID == other.superGroupID && id == other.id;
    }
 
    inline bool operator!=(const Label &other) const {
        return !((*this) == other);
    }
};
 
struct Event {
    Event();
    Event(EventIDs::EventID peventType, uint32 peventInfo);
 
    EventIDs::EventID eventType;
    uint32 eventInfo;
 
    // Returns true if this event, interpreted as a filter, recognizes another event.
    // Handles cases where eventInfo is ignored (hopefully).
    bool respondsTo(const Event &otherEvent) const;
 
    bool load(const Data::Event &data);
 
    inline bool operator==(const Event &other) const {
        return eventType == other.eventType && eventInfo == other.eventInfo;
    }
 
    inline bool operator!=(const Event &other) const {
        return !((*this) == other);
    }
};
 
struct VarReference {
    VarReference();
    VarReference(uint32 pguid, const Common::String &psource);
 
    uint32 guid;
    Common::String source;
    Common::WeakPtr<Modifier> resolution;   // NOTE: This may not be a variable
 
    inline bool operator==(const VarReference &other) const {
        return guid == other.guid && source == other.source;
    }
 
    inline bool operator!=(const VarReference &other) const {
        return !((*this) == other);
    }
 
    bool resolve(Structural *structuralScope, Common::WeakPtr<RuntimeObject> &outObject) const;
    bool resolve(Modifier *modifierScope, Common::WeakPtr<RuntimeObject> &outObject) const;
 
    void linkInternalReferences(ObjectLinkingScope *scope);
    void visitInternalReferences(IStructuralReferenceVisitor *visitor);
 
private:
    bool resolveContainer(IModifierContainer *modifierContainer, Common::WeakPtr<RuntimeObject> &outObject) const;
    bool resolveSingleModifier(Modifier *modifier, Common::WeakPtr<RuntimeObject> &outObject) const;
};
 
struct ObjectReference {
    Common::WeakPtr<RuntimeObject> object;
 
    inline ObjectReference() {
    }
 
    inline explicit ObjectReference(const Common::WeakPtr<RuntimeObject> &objectPtr) : object(objectPtr) {
    }
 
    inline bool operator==(const ObjectReference &other) const {
        return !object.owner_before(other.object) && !other.object.owner_before(object);
    }
 
    inline bool operator!=(const ObjectReference &other) const {
        return !((*this) == other);
    }
 
    inline void reset() {
        object.reset();
    }
};
 
struct AngleMagVector {
    AngleMagVector();
 
    double angleDegrees; // These are stored as radians in the data but scripts treat them as degrees so it's just pointless constantly doing conversion...
    double magnitude;
 
    inline bool operator==(const AngleMagVector &other) const {
        return angleDegrees == other.angleDegrees && magnitude == other.magnitude;
    }
 
    inline bool operator!=(const AngleMagVector &other) const {
        return !((*this) == other);
    }
 
    inline static AngleMagVector createRadians(double angleRadians, double magnitude) {
        return AngleMagVector(angleRadians * (180.0 / M_PI), magnitude);
    }
 
    inline static AngleMagVector createDegrees(double angleDegrees, double magnitude) {
        return AngleMagVector(angleDegrees, magnitude);
    }
 
    MiniscriptInstructionOutcome refAttrib(MiniscriptThread *thread, DynamicValueWriteProxy &proxy, const Common::String &attrib);
    Common::String toString() const;
 
private:
    AngleMagVector(double angleDegrees, double magnitude);
};
 
struct ColorRGB8 {
    ColorRGB8();
    ColorRGB8(uint8 pr, uint8 pg, uint8 pb);
 
    uint8 r;
    uint8 g;
    uint8 b;
 
    bool load(const Data::ColorRGB16 &color);
 
    inline bool operator==(const ColorRGB8 &other) const {
        return r == other.r && g == other.g && b == other.b;
    }
 
    inline bool operator!=(const ColorRGB8 &other) const {
        return !((*this) == other);
    }
};
 
struct MessageFlags {
    MessageFlags();
 
    bool relay : 1;
    bool cascade : 1;
    bool immediate : 1;
};
 
struct DynamicValue;
struct DynamicList;
 
// This should be an interface, but since this exists to make global singletons that JUST supply a vtable,
// GCC complains about there being a global destructor, unless we delete the destructor, in which case
// it complains about a class having virtual functions but not having a virtual destructor, so we have to
// do this dispatch table stuff just to make GCC be quiet.
struct DynamicValueWriteInterface {
    typedef MiniscriptInstructionOutcome (*writeFunc_t)(MiniscriptThread *thread, const DynamicValue &dest, void *objectRef, uintptr ptrOrOffset);
    typedef MiniscriptInstructionOutcome (*refAttribFunc_t)(MiniscriptThread *thread, DynamicValueWriteProxy &proxy, void *objectRef, uintptr ptrOrOffset, const Common::String &attrib);
    typedef MiniscriptInstructionOutcome (*refAttribIndexedFunc_t)(MiniscriptThread *thread, DynamicValueWriteProxy &proxy, void *objectRef, uintptr ptrOrOffset, const Common::String &attrib, const DynamicValue &index);
 
    writeFunc_t write;
    refAttribFunc_t refAttrib;
    refAttribIndexedFunc_t refAttribIndexed;
};
 
template<class T>
class DynamicValueWriteInterfaceGlue {
public:
    static const DynamicValueWriteInterface *getInstance();
 
private:
    static DynamicValueWriteInterface _instance;
};
 
template<class T>
inline const DynamicValueWriteInterface *DynamicValueWriteInterfaceGlue<T>::getInstance() {
    return &_instance;
}
 
template<class T>
DynamicValueWriteInterface DynamicValueWriteInterfaceGlue<T>::_instance = {
    static_cast<DynamicValueWriteInterface::writeFunc_t>(T::write),
    static_cast<DynamicValueWriteInterface::refAttribFunc_t>(T::refAttrib),
    static_cast<DynamicValueWriteInterface::refAttribIndexedFunc_t>(T::refAttribIndexed),
};
 
 
 
struct DynamicValueWriteProxyPOD {
    uintptr ptrOrOffset;
    void *objectRef;
    const DynamicValueWriteInterface *ifc;
 
    static DynamicValueWriteProxyPOD createDefault();
};
 
struct DynamicValueWriteProxy {
    DynamicValueWriteProxy();
 
    DynamicValueWriteProxyPOD pod;
    Common::SharedPtr<DynamicList> containerList;
};
 
struct Point16POD {
    int16 x;
    int16 y;
 
    Common::Point toScummVMPoint() const;
};
 
 
class DynamicListContainerBase {
public:
    virtual ~DynamicListContainerBase();
    virtual bool setAtIndex(size_t index, const DynamicValue &dynValue) = 0;
    virtual bool getAtIndex(size_t index, DynamicValue &dynValue) const = 0;
    virtual void truncateToSize(size_t sz) = 0;
    virtual bool expandToMinimumSize(size_t sz) = 0;
    virtual void setFrom(const DynamicListContainerBase &other) = 0; // Only supports setting same type!
    virtual const void *getConstArrayPtr() const = 0;
    virtual void *getArrayPtr() = 0;
    virtual size_t getSize() const = 0;
    virtual bool compareEqual(const DynamicListContainerBase &other) const = 0;
    virtual DynamicListContainerBase *clone() const = 0;
};
 
struct DynamicListDefaultSetter {
    static void defaultSet(int32 &value);
    static void defaultSet(double &value);
    static void defaultSet(Common::Point &value);
    static void defaultSet(IntRange &value);
    static void defaultSet(bool &value);
    static void defaultSet(AngleMagVector &value);
    static void defaultSet(Label &value);
    static void defaultSet(Event &value);
    static void defaultSet(Common::String &value);
    static void defaultSet(Common::SharedPtr<DynamicList> &value);
    static void defaultSet(ObjectReference &value);
};
 
template<class T>
struct DynamicListValueConverter {
    typedef T DynamicValuePODType_t;
 
    static const T &dereference(const T *source) { return *source; }
};
 
struct DynamicListValueImporter {
    static bool importValue(const DynamicValue &dynValue, const int32 *&outPtr);
    static bool importValue(const DynamicValue &dynValue, const double *&outPtr);
    static bool importValue(const DynamicValue &dynValue, const Common::Point *&outPtr);
    static bool importValue(const DynamicValue &dynValue, const IntRange *&outPtr);
    static bool importValue(const DynamicValue &dynValue, const bool *&outPtr);
    static bool importValue(const DynamicValue &dynValue, const AngleMagVector *&outPtr);
    static bool importValue(const DynamicValue &dynValue, const Label *&outPtr);
    static bool importValue(const DynamicValue &dynValue, const Event *&outPtr);
    static bool importValue(const DynamicValue &dynValue, const Common::String *&outPtr);
    static bool importValue(const DynamicValue &dynValue, const Common::SharedPtr<DynamicList> *&outPtr);
    static bool importValue(const DynamicValue &dynValue, const ObjectReference *&outPtr);
};
 
struct DynamicListValueExporter {
    static void exportValue(DynamicValue &dynValue, const int32 &value);
    static void exportValue(DynamicValue &dynValue, const double &value);
    static void exportValue(DynamicValue &dynValue, const Common::Point &value);
    static void exportValue(DynamicValue &dynValue, const IntRange &value);
    static void exportValue(DynamicValue &dynValue, const bool &value);
    static void exportValue(DynamicValue &dynValue, const AngleMagVector &value);
    static void exportValue(DynamicValue &dynValue, const Label &value);
    static void exportValue(DynamicValue &dynValue, const Event &value);
    static void exportValue(DynamicValue &dynValue, const Common::String &value);
    static void exportValue(DynamicValue &dynValue, const Common::SharedPtr<DynamicList> &value);
    static void exportValue(DynamicValue &dynValue, const ObjectReference &value);
};
 
template<class T>
class DynamicListContainer : public DynamicListContainerBase {
public:
    bool setAtIndex(size_t index, const DynamicValue &dynValue) override;
    bool getAtIndex(size_t index, DynamicValue &dynValue) const override;
    void truncateToSize(size_t sz) override;
    bool expandToMinimumSize(size_t sz) override;
    void setFrom(const DynamicListContainerBase &other) override;
    const void *getConstArrayPtr() const override;
    void *getArrayPtr() override;
    size_t getSize() const override;
    bool compareEqual(const DynamicListContainerBase &other) const override;
    DynamicListContainerBase *clone() const override;
 
private:
    Common::Array<T> _array;
};
 
template<>
class DynamicListContainer<void> : public DynamicListContainerBase {
public:
    DynamicListContainer();
 
    bool setAtIndex(size_t index, const DynamicValue &dynValue) override;
    bool getAtIndex(size_t index, DynamicValue &dynValue) const override;
    void truncateToSize(size_t sz) override;
    bool expandToMinimumSize(size_t sz) override;
    void setFrom(const DynamicListContainerBase &other) override;
    const void *getConstArrayPtr() const override;
    void *getArrayPtr() override;
    size_t getSize() const override;
    bool compareEqual(const DynamicListContainerBase &other) const override;
    DynamicListContainerBase *clone() const override;
 
public:
    size_t _size;
};
 
template<class T>
bool DynamicListContainer<T>::setAtIndex(size_t index, const DynamicValue &dynValue) {
    const typename DynamicListValueConverter<T>::DynamicValuePODType_t *valuePtr = nullptr;
    if (!DynamicListValueImporter::importValue(dynValue, valuePtr))
        return false;
 
    _array.reserve(index + 1);
    if (_array.size() <= index) {
        if (_array.size() < index) {
            T defaultValue;
            DynamicListDefaultSetter::defaultSet(defaultValue);
            while (_array.size() < index) {
                _array.push_back(defaultValue);
            }
        }
        _array.push_back(DynamicListValueConverter<T>::dereference(valuePtr));
    } else {
        _array[index] = DynamicListValueConverter<T>::dereference(valuePtr);
    }
 
    return true;
}
 
template<class T>
void DynamicListContainer<T>::truncateToSize(size_t sz) {
    if (_array.size() > sz)
        _array.resize(sz);
}
 
template<class T>
bool DynamicListContainer<T>::expandToMinimumSize(size_t sz) {
    _array.reserve(sz);
    if (_array.size() < sz) {
        T defaultValue;
        DynamicListDefaultSetter::defaultSet(defaultValue);
        while (_array.size() < sz) {
            _array.push_back(defaultValue);
        }
    }
 
    return true;
}
 
template<class T>
bool DynamicListContainer<T>::getAtIndex(size_t index, DynamicValue &dynValue) const {
    if (index >= _array.size())
        return false;
 
    DynamicListValueExporter::exportValue(dynValue, _array[index]);
    return true;
}
 
template<class T>
void DynamicListContainer<T>::setFrom(const DynamicListContainerBase &other) {
    _array = static_cast<const DynamicListContainer<T> &>(other)._array;
}
 
template<class T>
const void *DynamicListContainer<T>::getConstArrayPtr() const {
    return &_array;
}
 
template<class T>
void *DynamicListContainer<T>::getArrayPtr() {
    return &_array;
}
 
template<class T>
size_t DynamicListContainer<T>::getSize() const {
    return _array.size();
}
 
template<class T>
bool DynamicListContainer<T>::compareEqual(const DynamicListContainerBase &other) const {
    const DynamicListContainer<T> &otherTyped = static_cast<const DynamicListContainer<T> &>(other);
    return _array == otherTyped._array;
}
 
template<class T>
DynamicListContainerBase *DynamicListContainer<T>::clone() const {
    return new DynamicListContainer<T>(*this);
}
 
struct DynamicList {
    DynamicList();
    DynamicList(const DynamicList &other);
    ~DynamicList();
 
    DynamicValueTypes::DynamicValueType getType() const;
 
    const Common::Array<int32> &getInt() const;
    const Common::Array<double> &getFloat() const;
    const Common::Array<Common::Point> &getPoint() const;
    const Common::Array<IntRange> &getIntRange() const;
    const Common::Array<AngleMagVector> &getVector() const;
    const Common::Array<Label> &getLabel() const;
    const Common::Array<Event> &getEvent() const;
    const Common::Array<Common::String> &getString() const;
    const Common::Array<bool> &getBool() const;
    const Common::Array<Common::SharedPtr<DynamicList> > &getList() const;
    const Common::Array<ObjectReference> &getObjectReference() const;
 
    Common::Array<int32> &getInt();
    Common::Array<double> &getFloat();
    Common::Array<Common::Point> &getPoint();
    Common::Array<IntRange> &getIntRange();
    Common::Array<AngleMagVector> &getVector();
    Common::Array<Label> &getLabel();
    Common::Array<Event> &getEvent();
    Common::Array<Common::String> &getString();
    Common::Array<bool> &getBool();
    Common::Array<Common::SharedPtr<DynamicList> > &getList();
    Common::Array<ObjectReference> &getObjectReference();
 
    bool getAtIndex(size_t index, DynamicValue &value) const;
    bool setAtIndex(size_t index, const DynamicValue &value);
    void deleteAtIndex(size_t index);
    void truncateToSize(size_t sz);
    void expandToMinimumSize(size_t sz);
    size_t getSize() const;
 
    void forceType(DynamicValueTypes::DynamicValueType type);
 
    static bool dynamicValueToIndex(size_t &outIndex, const DynamicValue &value);
 
    DynamicList &operator=(const DynamicList &other);
 
    bool operator==(const DynamicList &other) const;
    inline bool operator!=(const DynamicList &other) const {
        return !((*this) == other);
    }
 
    void swap(DynamicList &other);
 
    Common::SharedPtr<DynamicList> clone() const;
 
    void createWriteProxyForIndex(size_t index, DynamicValueWriteProxy &proxy);
 
private:
    struct WriteProxyInterface {
        static MiniscriptInstructionOutcome write(MiniscriptThread *thread, const DynamicValue &dest, void *objectRef, uintptr ptrOrOffset);
        static MiniscriptInstructionOutcome refAttrib(MiniscriptThread *thread, DynamicValueWriteProxy &proxy, void *objectRef, uintptr ptrOrOffset, const Common::String &attrib);
        static MiniscriptInstructionOutcome refAttribIndexed(MiniscriptThread *thread, DynamicValueWriteProxy &proxy, void *objectRef, uintptr ptrOrOffset, const Common::String &attrib, const DynamicValue &index);
    };
 
    void initFromOther(const DynamicList &other);
    void destroyContainer();
    bool createContainerAndSetType(DynamicValueTypes::DynamicValueType type);
 
    DynamicValueTypes::DynamicValueType _type;
    DynamicListContainerBase *_container;
};
 
// Dynamic value container.  Somewhat importantly, lists stored in dynamic values
// are BY REFERENCE and must be cloned as necessary.
struct DynamicValue {
    DynamicValue();
    DynamicValue(const DynamicValue &other);
    ~DynamicValue();
 
    bool loadConstant(const Data::InternalTypeTaggedValue &data, const Common::String &varString);
    bool loadConstant(const Data::PlugInTypeTaggedValue &data);
 
    DynamicValueTypes::DynamicValueType getType() const;
 
    const int32 &getInt() const;
    const double &getFloat() const;
    const Common::Point &getPoint() const;
    const IntRange &getIntRange() const;
    const AngleMagVector &getVector() const;
    const Label &getLabel() const;
    const Event &getEvent() const;
    const Common::String &getString() const;
    const bool &getBool() const;
    const Common::SharedPtr<DynamicList> &getList() const;
    const ObjectReference &getObject() const;
    const DynamicValueWriteProxy &getWriteProxy() const;
 
    void clear();
 
    void setInt(int32 value);
    void setFloat(double value);
    void setPoint(const Common::Point &value);
    void setIntRange(const IntRange &value);
    void setVector(const AngleMagVector &value);
    void setLabel(const Label &value);
    void setEvent(const Event &value);
    void setString(const Common::String &value);
    void setBool(bool value);
    void setList(const Common::SharedPtr<DynamicList> &value);
    void setObject(const ObjectReference &value);
    void setObject(const Common::WeakPtr<RuntimeObject> &value);
    void setWriteProxy(const DynamicValueWriteProxy &writeProxy);
 
    bool roundToInt(int32 &outInt) const;
 
    bool convertToType(DynamicValueTypes::DynamicValueType targetType, DynamicValue &result) const;
 
    DynamicValue dereference() const;
 
    DynamicValue &operator=(const DynamicValue &other);
 
    bool operator==(const DynamicValue &other) const;
    inline bool operator!=(const DynamicValue &other) const {
        return !((*this) == other);
    }
 
private:
    union ValueUnion {
        ValueUnion();
        ~ValueUnion();
 
        double asFloat;
        int32 asInt;
        IntRange asIntRange;
        AngleMagVector asVector;
        Label asLabel;
        Event asEvent;
        Common::Point asPoint;
        bool asBool;
        DynamicValueWriteProxy asWriteProxy;
        Common::String asString;
        Common::SharedPtr<DynamicList> asList;
        ObjectReference asObj;
 
        uint64 asUnset;
 
        template<class T, T(ValueUnion::*TMember)>
        void construct(const T &value);
 
        template<class T, T(ValueUnion::*TMember)>
        void construct(T &&value);
 
        template<class T, T(ValueUnion::*TMember)>
        void assign(const T &value);
 
        template<class T, T(ValueUnion::*TMember)>
        void assign(T &&value);
 
        template<class T, T(ValueUnion::*TMember)>
        void destruct();
    };
 
    template<class T>
    void internalSwap(T &a, T &b) {
        T temp = a;
        a = b;
        b = temp;
    }
 
    bool convertIntToType(DynamicValueTypes::DynamicValueType targetType, DynamicValue &result) const;
    bool convertFloatToType(DynamicValueTypes::DynamicValueType targetType, DynamicValue &result) const;
    bool convertBoolToType(DynamicValueTypes::DynamicValueType targetType, DynamicValue &result) const;
    bool convertStringToType(DynamicValueTypes::DynamicValueType targetType, DynamicValue &result) const;
 
    bool convertToTypeNoDereference(DynamicValueTypes::DynamicValueType targetType, DynamicValue &result) const;
 
    void setFromOther(const DynamicValue &other);
    void setFromOther(DynamicValue &&other);
 
    DynamicValueTypes::DynamicValueType _type;
    ValueUnion _value;
};
 
struct DynamicValueSource {
    DynamicValueSource();
    DynamicValueSource(const DynamicValueSource &other);
    DynamicValueSource(DynamicValueSource &&other);
    ~DynamicValueSource();
 
    DynamicValueSource &operator=(const DynamicValueSource &other);
    DynamicValueSource &operator=(DynamicValueSource &&other);
 
    DynamicValueSourceTypes::DynamicValueSourceType getSourceType() const;
    const DynamicValue &getConstant() const;
    const VarReference &getVarReference() const;
 
    bool load(const Data::InternalTypeTaggedValue &data, const Common::String &varSource, const Common::String &varString);
    bool load(const Data::PlugInTypeTaggedValue &data);
 
    void linkInternalReferences(ObjectLinkingScope *scope);
    void visitInternalReferences(IStructuralReferenceVisitor *visitor);
 
    DynamicValue produceValue(const DynamicValue &incomingData) const;
 
private:
    union ValueUnion {
        ValueUnion();
        ~ValueUnion();
 
        DynamicValue _constValue;
        VarReference _varReference;
    };
 
    void destructValue();
    void initFromOther(const DynamicValueSource &other);
    void initFromOther(DynamicValueSource &&other);
 
    DynamicValueSourceTypes::DynamicValueSourceType _sourceType;
    ValueUnion _valueUnion;
};
 
template<class TFloat>
struct DynamicValueWriteFloatHelper {
    static MiniscriptInstructionOutcome write(MiniscriptThread *thread, const DynamicValue &value, void *objectRef, uintptr ptrOrOffset) {
        DynamicValue derefValue = value.dereference();
 
        TFloat &dest = *static_cast<TFloat *>(objectRef);
        switch (derefValue.getType()) {
        case DynamicValueTypes::kFloat:
            dest = static_cast<TFloat>(derefValue.getFloat());
            return kMiniscriptInstructionOutcomeContinue;
        case DynamicValueTypes::kInteger:
            dest = static_cast<TFloat>(derefValue.getInt());
            return kMiniscriptInstructionOutcomeContinue;
        default:
            return kMiniscriptInstructionOutcomeFailed;
        }
    }
    static MiniscriptInstructionOutcome refAttrib(MiniscriptThread *thread, DynamicValueWriteProxy &proxy, void *objectRef, uintptr ptrOrOffset, const Common::String &attrib) {
        return kMiniscriptInstructionOutcomeFailed;
    }
    static MiniscriptInstructionOutcome refAttribIndexed(MiniscriptThread *thread, DynamicValueWriteProxy &proxy, void *objectRef, uintptr ptrOrOffset, const Common::String &attrib, const DynamicValue &index) {
        return kMiniscriptInstructionOutcomeFailed;
    }
 
    static void create(TFloat *floatValue, DynamicValueWriteProxy &proxy) {
        proxy.pod.ptrOrOffset = 0;
        proxy.pod.objectRef = floatValue;
        proxy.pod.ifc = DynamicValueWriteInterfaceGlue<DynamicValueWriteFloatHelper<TFloat> >::getInstance();
    }
};
 
template<class TInteger>
struct DynamicValueWriteIntegerHelper {
    static MiniscriptInstructionOutcome write(MiniscriptThread *thread, const DynamicValue &value, void *objectRef, uintptr ptrOrOffset) {
        DynamicValue derefValue = value.dereference();
 
        TInteger &dest = *static_cast<TInteger *>(objectRef);
        switch (derefValue.getType()) {
        case DynamicValueTypes::kFloat:
            dest = static_cast<TInteger>(floor(derefValue.getFloat() + 0.5));
            return kMiniscriptInstructionOutcomeContinue;
        case DynamicValueTypes::kInteger:
            dest = static_cast<TInteger>(derefValue.getInt());
            return kMiniscriptInstructionOutcomeContinue;
        default:
            return kMiniscriptInstructionOutcomeFailed;
        }
    }
    static MiniscriptInstructionOutcome refAttrib(MiniscriptThread *thread, DynamicValueWriteProxy &proxy, void *objectRef, uintptr ptrOrOffset, const Common::String &attrib) {
        return kMiniscriptInstructionOutcomeFailed;
    }
    static MiniscriptInstructionOutcome refAttribIndexed(MiniscriptThread *thread, DynamicValueWriteProxy &proxy, void *objectRef, uintptr ptrOrOffset, const Common::String &attrib, const DynamicValue &index) {
        return kMiniscriptInstructionOutcomeFailed;
    }
 
    static void create(TInteger *intValue, DynamicValueWriteProxy &proxy) {
        proxy.pod.ptrOrOffset = 0;
        proxy.pod.objectRef = intValue;
        proxy.pod.ifc = DynamicValueWriteInterfaceGlue<DynamicValueWriteIntegerHelper<TInteger> >::getInstance();
    }
};
 
struct DynamicValueWritePointHelper {
    static MiniscriptInstructionOutcome write(MiniscriptThread *thread, const DynamicValue &value, void *objectRef, uintptr ptrOrOffset);
    static MiniscriptInstructionOutcome refAttrib(MiniscriptThread *thread, DynamicValueWriteProxy &proxy, void *objectRef, uintptr ptrOrOffset, const Common::String &attrib);
    static MiniscriptInstructionOutcome refAttribIndexed(MiniscriptThread *thread, DynamicValueWriteProxy &proxy, void *objectRef, uintptr ptrOrOffset, const Common::String &attrib, const DynamicValue &index);
 
    static void create(Common::Point *pointValue, DynamicValueWriteProxy &proxy);
};
 
struct DynamicValueWriteBoolHelper {
    static MiniscriptInstructionOutcome write(MiniscriptThread *thread, const DynamicValue &value, void *objectRef, uintptr ptrOrOffset);
    static MiniscriptInstructionOutcome refAttrib(MiniscriptThread *thread, DynamicValueWriteProxy &proxy, void *objectRef, uintptr ptrOrOffset, const Common::String &attrib);
    static MiniscriptInstructionOutcome refAttribIndexed(MiniscriptThread *thread, DynamicValueWriteProxy &proxy, void *objectRef, uintptr ptrOrOffset, const Common::String &attrib, const DynamicValue &index);
 
    static void create(bool *boolValue, DynamicValueWriteProxy &proxy);
};
 
struct DynamicValueWriteStringHelper {
    static MiniscriptInstructionOutcome write(MiniscriptThread *thread, const DynamicValue &value, void *objectRef, uintptr ptrOrOffset);
    static MiniscriptInstructionOutcome refAttrib(MiniscriptThread *thread, DynamicValueWriteProxy &proxy, void *objectRef, uintptr ptrOrOffset, const Common::String &attrib);
    static MiniscriptInstructionOutcome refAttribIndexed(MiniscriptThread *thread, DynamicValueWriteProxy &proxy, void *objectRef, uintptr ptrOrOffset, const Common::String &attrib, const DynamicValue &index);
 
    static void create(Common::String *strValue, DynamicValueWriteProxy &proxy);
};
 
struct DynamicValueWriteDiscardHelper {
    static MiniscriptInstructionOutcome write(MiniscriptThread *thread, const DynamicValue &value, void *objectRef, uintptr ptrOrOffset);
    static MiniscriptInstructionOutcome refAttrib(MiniscriptThread *thread, DynamicValueWriteProxy &proxy, void *objectRef, uintptr ptrOrOffset, const Common::String &attrib);
    static MiniscriptInstructionOutcome refAttribIndexed(MiniscriptThread *thread, DynamicValueWriteProxy &proxy, void *objectRef, uintptr ptrOrOffset, const Common::String &attrib, const DynamicValue &index);
 
    static void create(DynamicValueWriteProxy &proxy);
};
 
template<class TClass, MiniscriptInstructionOutcome (TClass::*TWriteMethod)(MiniscriptThread *thread, const DynamicValue &dest), MiniscriptInstructionOutcome (TClass::*TRefAttribMethod)(MiniscriptThread *thread, DynamicValueWriteProxy &proxy, const Common::String &attrib)>
struct DynamicValueWriteOrRefAttribFuncHelper {
    static MiniscriptInstructionOutcome write(MiniscriptThread *thread, const DynamicValue &dest, void *objectRef, uintptr ptrOrOffset) {
        DynamicValue derefValue = dest.dereference();
 
        return (static_cast<TClass *>(objectRef)->*TWriteMethod)(thread, derefValue);
    }
    static MiniscriptInstructionOutcome refAttrib(MiniscriptThread *thread, DynamicValueWriteProxy &proxy, void *objectRef, uintptr ptrOrOffset, const Common::String &attrib) {
        return (static_cast<TClass *>(objectRef)->*TRefAttribMethod)(thread, proxy, attrib);
    }
    static MiniscriptInstructionOutcome refAttribIndexed(MiniscriptThread *thread, DynamicValueWriteProxy &proxy, void *objectRef, uintptr ptrOrOffset, const Common::String &attrib, const DynamicValue &index) {
        return kMiniscriptInstructionOutcomeFailed;
    }
 
    static void create(TClass *obj, DynamicValueWriteProxy &proxy) {
        proxy.pod.ptrOrOffset = 0;
        proxy.pod.objectRef = obj;
        proxy.pod.ifc = DynamicValueWriteInterfaceGlue<DynamicValueWriteOrRefAttribFuncHelper<TClass, TWriteMethod, TRefAttribMethod> >::getInstance();
    }
};
 
template<class TClass, MiniscriptInstructionOutcome (TClass::*TWriteMethod)(MiniscriptThread *thread, const DynamicValue &dest), bool TDereference>
struct DynamicValueWriteFuncHelper {
    static MiniscriptInstructionOutcome write(MiniscriptThread *thread, const DynamicValue &dest, void *objectRef, uintptr ptrOrOffset) {
        if (TDereference) {
            return (static_cast<TClass *>(objectRef)->*TWriteMethod)(thread, dest.dereference());
        } else
            return (static_cast<TClass *>(objectRef)->*TWriteMethod)(thread, dest);
    }
    static MiniscriptInstructionOutcome refAttrib(MiniscriptThread *thread, DynamicValueWriteProxy &proxy, void *objectRef, uintptr ptrOrOffset, const Common::String &attrib) {
        return kMiniscriptInstructionOutcomeFailed;
    }
    static MiniscriptInstructionOutcome refAttribIndexed(MiniscriptThread *thread, DynamicValueWriteProxy &proxy, void *objectRef, uintptr ptrOrOffset, const Common::String &attrib, const DynamicValue &index) {
        return kMiniscriptInstructionOutcomeFailed;
    }
 
    static void create(TClass *obj, DynamicValueWriteProxy &proxy) {
        proxy.pod.ptrOrOffset = 0;
        proxy.pod.objectRef = obj;
        proxy.pod.ifc = DynamicValueWriteInterfaceGlue<DynamicValueWriteFuncHelper<TClass, TWriteMethod, TDereference> >::getInstance();
    }
};
 
struct DynamicValueWriteObjectHelper {
    static MiniscriptInstructionOutcome write(MiniscriptThread *thread, const DynamicValue &value, void *objectRef, uintptr ptrOrOffset);
    static MiniscriptInstructionOutcome refAttrib(MiniscriptThread *thread, DynamicValueWriteProxy &proxy, void *objectRef, uintptr ptrOrOffset, const Common::String &attrib);
    static MiniscriptInstructionOutcome refAttribIndexed(MiniscriptThread *thread, DynamicValueWriteProxy &proxy, void *objectRef, uintptr ptrOrOffset, const Common::String &attrib, const DynamicValue &index);
 
    static void create(RuntimeObject *obj, DynamicValueWriteProxy &proxy);
};
 
struct MessengerSendSpec {
    MessengerSendSpec();
 
    bool load(const Data::Event &dataEvent, uint32 dataMessageFlags, const Data::InternalTypeTaggedValue &dataLocator, const Common::String &dataWithSource, const Common::String &dataWithString, uint32 dataDestination);
    bool load(const Data::PlugInTypeTaggedValue &dataEvent, const MessageFlags &dataMessageFlags, const Data::PlugInTypeTaggedValue &dataWith, uint32 dataDestination);
 
    void linkInternalReferences(ObjectLinkingScope *outerScope);
    void visitInternalReferences(IStructuralReferenceVisitor *visitor);
 
    void resolveDestination(Runtime *runtime, Modifier *sender, RuntimeObject *triggerSource, Common::WeakPtr<Structural> &outStructuralDest, Common::WeakPtr<Modifier> &outModifierDest, RuntimeObject *customDestination) const;
 
    static void resolveVariableObjectType(RuntimeObject *obj, Common::WeakPtr<Structural> &outStructuralDest, Common::WeakPtr<Modifier> &outModifierDest);
 
    void sendFromMessenger(Runtime *runtime, Modifier *sender, RuntimeObject *triggerSource, const DynamicValue &incomingData, RuntimeObject *customDestination) const;
    void sendFromMessengerWithCustomData(Runtime *runtime, Modifier *sender, RuntimeObject *triggerSource, const DynamicValue &data, RuntimeObject *customDestination) const;
 
    enum LinkType {
        kLinkTypeNotYetLinked,
        kLinkTypeStructural,
        kLinkTypeModifier,
        kLinkTypeCoded,
        kLinkTypeUnresolved,
    };
 
    Event send;
    MessageFlags messageFlags;
    DynamicValueSource with;
    uint32 destination; // May be a MessageDestination or GUID
 
    LinkType _linkType;
    Common::WeakPtr<Structural> _resolvedStructuralDest;
    Common::WeakPtr<Modifier> _resolvedModifierDest;
    Common::WeakPtr<Modifier> _resolvedVarSource;
 
private:
    void resolveHierarchyStructuralDestination(Runtime *runtime, Modifier *sender, Common::WeakPtr<Structural> &outStructuralDest, Common::WeakPtr<Modifier> &outModifierDest, bool (*compareFunc)(Structural *structural)) const;
    static bool isSceneFilter(Structural *section);
    static bool isSectionFilter(Structural *section);
    static bool isSubsectionFilter(Structural *section);
    static bool isElementFilter(Structural *section);
};
 
enum MessageDestination {
    kMessageDestNone = 0,
 
    kMessageDestSharedScene = 0x65,
    kMessageDestScene = 0x66,
    kMessageDestSection = 0x67,
    kMessageDestProject = 0x68,
    kMessageDestActiveScene = 0x69,
    kMessageDestElementsParent = 0x6a,
    kMessageDestChildren = 0x6b,    // Saw this somewhere but can't find it any more?
    kMessageDestModifiersParent = 0x6c,
    kMessageDestSubsection = 0x6d,
 
    kMessageDestElement = 0xc9,
    kMessageDestSourcesParent = 0xcf,
 
    kMessageDestBehavior = 0xd4,
    kMessageDestNextElement = 0xd1,
    kMessageDestPrevElement = 0xd2,
    kMessageDestBehaviorsParent = 0xd3,
};
 
struct SegmentDescription {
    SegmentDescription();
 
    int volumeID;
    Common::String filePath;
    Common::SeekableReadStream *stream;
};
 
struct IPlugInModifierRegistrar : public IInterfaceBase {
    virtual void registerPlugInModifier(const char *name, const Data::IPlugInModifierDataFactory *loader, const IPlugInModifierFactory *factory) = 0;
    void registerPlugInModifier(const char *name, const IPlugInModifierFactoryAndDataFactory *loaderFactory);
};
 
class PlugIn {
public:
    virtual ~PlugIn();
 
    virtual void registerModifiers(IPlugInModifierRegistrar *registrar) const = 0;
};
 
class ProjectPersistentResource {
public:
    virtual ~ProjectPersistentResource();
};
 
struct ProjectResources {
    virtual ~ProjectResources();
 
    Common::Array<Common::SharedPtr<ProjectPersistentResource> > persistentResources;
};
 
class CursorGraphic {
public:
    virtual ~CursorGraphic();
 
    virtual Graphics::Cursor *getCursor() const = 0;
};
 
class MacCursorGraphic : public CursorGraphic {
public:
    explicit MacCursorGraphic(const Common::SharedPtr<Graphics::MacCursor> &macCursor);
 
    Graphics::Cursor *getCursor() const override;
 
private:
    Common::SharedPtr<Graphics::MacCursor> _macCursor;
};
 
class WinCursorGraphic : public CursorGraphic {
public:
    explicit WinCursorGraphic(const Common::SharedPtr<Graphics::WinCursorGroup> &winCursorGroup, Graphics::Cursor *cursor);
 
    Graphics::Cursor *getCursor() const override;
 
private:
    Common::SharedPtr<Graphics::WinCursorGroup> _winCursorGroup;
    Graphics::Cursor *_cursor;
};
 
class CursorGraphicCollection {
public:
    CursorGraphicCollection();
    ~CursorGraphicCollection();
 
    void addWinCursorGroup(uint32 cursorGroupID, const Common::SharedPtr<Graphics::WinCursorGroup> &cursorGroup);
    void addMacCursor(uint32 cursorID, const Common::SharedPtr<Graphics::MacCursor> &cursor);
 
    Common::SharedPtr<CursorGraphic> getGraphicByID(uint32 id) const;
 
private:
    Common::HashMap<uint32, Common::SharedPtr<CursorGraphic> > _cursorGraphics;
};
 
// The project platform is the platform that the project is running on (not the format of the project)
enum ProjectPlatform {
    kProjectPlatformUnknown,
 
    kProjectPlatformWindows,
    kProjectPlatformMacintosh,
};
 
class ProjectDescription {
public:
    ProjectDescription(ProjectPlatform platform, RuntimeVersion runtimeVersion, bool autoDetectVersion, Common::Archive *rootArchive, const Common::Path &projectRootDir);
    ~ProjectDescription();
 
    void addSegment(int volumeID, const char *filePath);
    void addSegment(int volumeID, Common::SeekableReadStream *stream);
    const Common::Array<SegmentDescription> &getSegments() const;
 
    void addPlugIn(const Common::SharedPtr<PlugIn> &plugIn);
    const Common::Array<Common::SharedPtr<PlugIn> > &getPlugIns() const;
 
    void setResources(const Common::SharedPtr<ProjectResources> &resources);
    const Common::SharedPtr<ProjectResources> &getResources() const;
 
    void setCursorGraphics(const Common::SharedPtr<CursorGraphicCollection> &cursorGraphics);
    const Common::SharedPtr<CursorGraphicCollection> &getCursorGraphics() const;
 
    void setLanguage(Common::Language language);
    Common::Language getLanguage() const;
 
    ProjectPlatform getPlatform() const;
    RuntimeVersion getRuntimeVersion() const;
    bool isRuntimeVersionAuto() const;
 
    Common::Archive *getRootArchive() const;
    const Common::Path &getProjectRootDir() const;
 
    const SubtitleTables &getSubtitles() const;
    void setSubtitles(const SubtitleTables &subs);
 
private:
    Common::Array<SegmentDescription> _segments;
    Common::Array<Common::SharedPtr<PlugIn> > _plugIns;
    Common::SharedPtr<ProjectResources> _resources;
    Common::SharedPtr<CursorGraphicCollection> _cursorGraphics;
    Common::Language _language;
    SubtitleTables _subtitles;
    ProjectPlatform _platform;
    RuntimeVersion _runtimeVersion;
    bool _isRuntimeVersionAuto;
 
    Common::Archive *_rootArchive;
    Common::Path _projectRootDir;
};
 
struct VolumeState {
    VolumeState();
 
    Common::String name;
    int volumeID;
    bool isMounted;
};
 
class ObjectLinkingScope {
public:
    ObjectLinkingScope();
    ~ObjectLinkingScope();
 
    void setParent(ObjectLinkingScope *parent);
    void addObject(uint32 guid, const Common::String &name, const Common::WeakPtr<RuntimeObject> &object);
    Common::WeakPtr<RuntimeObject> resolve(uint32 staticGUID) const;
    Common::WeakPtr<RuntimeObject> resolve(const Common::String &name, bool isNameAlreadyInsensitive) const;
    Common::WeakPtr<RuntimeObject> resolve(uint32 staticGUID, const Common::String &name, bool isNameAlreadyInsensitive) const;
 
    void reset();
 
private:
    Common::HashMap<uint32, Common::WeakPtr<RuntimeObject> > _guidToObject;
    Common::HashMap<Common::String, Common::WeakPtr<RuntimeObject> > _nameToObject;
    ObjectLinkingScope *_parent;
};
 
struct LowLevelSceneStateTransitionAction {
    enum ActionType {
        kLoad,
        kUnload,
        kSendMessage,
        kAutoResetCursor,
        kHideAllElements,
        kShowDefaultVisibleElements,
    };
 
    explicit LowLevelSceneStateTransitionAction(const Common::SharedPtr<MessageDispatch> &msg);
    explicit LowLevelSceneStateTransitionAction(ActionType actionType);
    LowLevelSceneStateTransitionAction(const LowLevelSceneStateTransitionAction &other);
    LowLevelSceneStateTransitionAction(const Common::SharedPtr<Structural> &scene, ActionType actionType);
 
    ActionType getActionType() const;
    const Common::SharedPtr<Structural> &getScene() const;
    const Common::SharedPtr<MessageDispatch> &getMessage() const;
 
    LowLevelSceneStateTransitionAction &operator=(const LowLevelSceneStateTransitionAction &other);
 
private:
    ActionType _actionType;
    Common::SharedPtr<Structural> _scene;
    Common::SharedPtr<MessageDispatch> _msg;
};
 
struct ObjectParentChange {
    explicit ObjectParentChange(const Common::WeakPtr<RuntimeObject> &object, const Common::WeakPtr<RuntimeObject> &newParent);
 
    Common::WeakPtr<RuntimeObject> _object;
    Common::WeakPtr<RuntimeObject> _newParent;
};
 
struct HighLevelSceneTransition {
    enum Type {
        kTypeChangeToScene,
        kTypeChangeSharedScene,
        kTypeForceLoadScene,
        kTypeRequestUnloadScene,
    };
 
    HighLevelSceneTransition(const Common::SharedPtr<Structural> &hlst_scene, Type hlst_type, bool hlst_addToDestinationScene, bool hlst_addToReturnList);
 
    Common::SharedPtr<Structural> scene;
    Type type;
    bool addToDestinationScene;
    bool addToReturnList;
};
 
struct SceneTransitionEffect {
    SceneTransitionEffect();
 
    uint32 _duration; // 6000000 is maximum
    uint16 _steps;
    SceneTransitionTypes::SceneTransitionType _transitionType;
    SceneTransitionDirections::SceneTransitionDirection _transitionDirection;
};
 
class MessageDispatch {
public:
    enum class RootType {
        Invalid,
 
        Command,
        Structural,
        Modifier,
    };
 
    MessageDispatch(const Common::SharedPtr<MessageProperties> &msgProps, Structural *root, bool cascade, bool relay, bool couldBeCommand);
    MessageDispatch(const Common::SharedPtr<MessageProperties> &msgProps, Modifier *root, bool cascade, bool relay, bool couldBeCommand);
 
    const Common::SharedPtr<MessageProperties> &getMsg() const;
    RuntimeObject *getRootPropagator() const;
 
    bool isCascade() const;
    bool isRelay() const;
 
    RootType getRootType() const;
    const Common::WeakPtr<RuntimeObject> &getRootWeakPtr() const;
 
private:
    Common::SharedPtr<MessageProperties> _msg;
 
    Common::WeakPtr<RuntimeObject> _root;
 
    bool _cascade; // Traverses structure tree
    bool _relay;   // Fire on multiple modifiers
    bool _isCommand;
 
    RootType _rootType;
};
 
class KeyEventDispatch {
public:
    explicit KeyEventDispatch(const Common::SharedPtr<KeyboardInputEvent> &evt);
 
    Common::Array<Common::WeakPtr<RuntimeObject> > &getKeyboardMessengerArray();
    static bool keyboardMessengerFilterFunc(void *userData, RuntimeObject *object);
 
    bool isTerminated() const;
    VThreadState continuePropagating(Runtime *runtime);
 
private:
    Common::Array<Common::WeakPtr<RuntimeObject> > _keyboardMessengers;
    size_t _dispatchIndex;
    const Common::SharedPtr<KeyboardInputEvent> _evt;
};
 
class Scheduler;
 
class ScheduledEvent : Common::NonCopyable {
    friend class Scheduler;
 
public:
    void cancel();
    uint64 getScheduledTime() const;
    void activate(Runtime *runtime) const;
 
private:
    ScheduledEvent(void *obj, void (*activateFunc)(void *, Runtime *), uint64 scheduledTime, Scheduler *scheduler);
 
    void *_obj;
    void (*_activateFunc)(void *obj, Runtime *runtime);
 
    uint64 _scheduledTime;
    Scheduler *_scheduler;
};
 
class Scheduler {
    friend class ScheduledEvent;
 
public:
    Scheduler();
    ~Scheduler();
 
    template<class T, void (T::*TMethodPtr)(Runtime *)>
    Common::SharedPtr<ScheduledEvent> scheduleMethod(uint64 scheduledTime, T* obj) {
        Common::SharedPtr<ScheduledEvent> evt(new ScheduledEvent(obj, Scheduler::methodActivateHelper<T, TMethodPtr>, scheduledTime, this));
        insertEvent(evt);
        return evt;
    }
 
    Common::SharedPtr<ScheduledEvent> getFirstEvent() const;
    void descheduleFirstEvent();
 
private:
    template<class T, void (T::*TMethodPtr)(Runtime *)>
    static void methodActivateHelper(void *obj, Runtime *runtime) {
        (static_cast<T *>(obj)->*TMethodPtr)(runtime);
    }
 
    void insertEvent(const Common::SharedPtr<ScheduledEvent> &evt);
    void removeEvent(const ScheduledEvent *evt);
 
    Common::Array<Common::SharedPtr<ScheduledEvent>> _events;
};
 
enum OSEventType {
    kOSEventTypeMouseDown,
    kOSEventTypeMouseUp,
    kOSEventTypeMouseMove,
 
    kOSEventTypeKeyboard,
 
    kOSEventTypeAction,
};
 
class OSEvent {
public:
    explicit OSEvent(OSEventType eventType);
    virtual ~OSEvent();
 
    OSEventType getEventType() const;
 
private:
    OSEventType _eventType;
};
 
class MouseInputEvent : public OSEvent {
public:
    explicit MouseInputEvent(OSEventType eventType, int32 x, int32 y, Actions::MouseButton button);
 
    int32 getX() const;
    int32 getY() const;
    Actions::MouseButton getButton() const;
 
private:
    int32 _x;
    int32 _y;
    Actions::MouseButton _button;
};
 
class KeyboardInputEvent : public OSEvent {
public:
    explicit KeyboardInputEvent(OSEventType osEventType, Common::EventType keyEventType, bool repeat, const Common::KeyState &keyEvt);
 
    Common::EventType getKeyEventType() const;
    bool isRepeat() const;
    const Common::KeyState &getKeyState() const;
 
private:
    Common::EventType _keyEventType;
    bool _repeat;
    const Common::KeyState _keyEvt;
};
 
class ActionEvent : public OSEvent {
public:
    explicit ActionEvent(OSEventType osEventType, Actions::Action action);
 
    Actions::Action getAction() const;
 
private:
    Actions::Action _action;
};
 
struct DragMotionProperties {
    DragMotionProperties();
 
    ConstraintDirection constraintDirection;
    Common::Rect constraintMargin;
    bool constrainToParent;
};
 
class SceneTransitionHooks {
public:
    virtual ~SceneTransitionHooks();
 
    virtual void onSceneTransitionSetup(Runtime *runtime, const Common::WeakPtr<Structural> &oldScene, const Common::WeakPtr<Structural> &newScene);
    virtual void onSceneTransitionEnded(Runtime *runtime, const Common::WeakPtr<Structural> &newScene);
    virtual void onProjectStarted(Runtime *runtime);
};
 
class Palette {
public:
    Palette();
    explicit Palette(const ColorRGB8 *colors);
 
    void initDefaultPalette(int version);
 
    const byte *getPalette() const;
 
    static const uint kNumColors = 256;
 
private:
    byte _colors[kNumColors * 3];
};
 
class Runtime {
public:
    explicit Runtime(OSystem *system, Audio::Mixer *mixer, ISaveUIProvider *saveProvider, ILoadUIProvider *loadProvider, const Common::SharedPtr<SubtitleRenderer> &subRenderer);
    ~Runtime();
 
    bool runFrame();
    void drawFrame();
 
    void queueProject(const Common::SharedPtr<ProjectDescription> &desc);
    void closeProject();
 
    void addVolume(int volumeID, const char *name, bool isMounted);
    bool getVolumeState(const Common::String &name, int &outVolumeID, bool &outIsMounted) const;
 
    void addSceneReturn();
    void addSceneStateTransition(const HighLevelSceneTransition &transition);
 
    void setSceneTransitionEffect(bool isInDestinationScene, SceneTransitionEffect *effect);
 
    Project *getProject() const;
 
    void postConsumeMessageTask(IMessageConsumer *msgConsumer, const Common::SharedPtr<MessageProperties> &msg);
    void postConsumeCommandTask(Structural *structural, const Common::SharedPtr<MessageProperties> &msg);
 
    uint32 allocateRuntimeGUID();
 
    void addWindow(const Common::SharedPtr<Window> &window);
    void removeWindow(Window *window);
 
    // Sets up a supported display mode
    void setupDisplayMode(ColorDepthMode displayMode, const Graphics::PixelFormat &pixelFormat);
 
    bool isDisplayModeSupported(ColorDepthMode displayMode) const;
 
    // Switches to a specified display mode.  Returns true if the mode was actually changed.  If so, all windows will need
    // to be recreated.
    bool switchDisplayMode(ColorDepthMode realDisplayMode, ColorDepthMode fakeDisplayMode);
 
    void setDisplayResolution(uint16 width, uint16 height);
    void getDisplayResolution(uint16 &outWidth, uint16 &outHeight) const;
 
    ColorDepthMode getRealColorDepth() const;
    ColorDepthMode getFakeColorDepth() const;   // Fake color depth that will be reported to scripts
 
    const Graphics::PixelFormat &getRenderPixelFormat() const;
 
    const Common::SharedPtr<Graphics::MacFontManager> &getMacFontManager() const;
 
    const Common::SharedPtr<Structural> &getActiveMainScene() const;
    const Common::SharedPtr<Structural> &getActiveSharedScene() const;
    void getSceneStack(Common::Array<Common::SharedPtr<Structural> > &sceneStack) const;
 
    bool mustDraw() const;
 
    uint64 getRealTime() const;
    uint64 getPlayTime() const;
 
    VThread &getVThread() const;
 
    // Sending a message on the VThread means "immediately"
    void sendMessageOnVThread(const Common::SharedPtr<MessageDispatch> &dispatch);
 
    struct SendMessageOnVThreadCoroutine {
        CORO_DEFINE_RETURN_TYPE(void);
        CORO_DEFINE_PARAMS_2(Runtime *, runtime, Common::SharedPtr<MessageDispatch>, dispatch);
    };
 
    void queueMessage(const Common::SharedPtr<MessageDispatch> &dispatch);
 
    void queueOSEvent(const Common::SharedPtr<OSEvent> &osEvent);
 
    Scheduler &getScheduler();
 
    void getScenesInRenderOrder(Common::Array<Structural *> &scenes) const;
 
    void instantiateIfAlias(Common::SharedPtr<Modifier> &modifier, const Common::WeakPtr<RuntimeObject> &relinkParent);
 
    Common::SharedPtr<Window> findTopWindow(int32 x, int32 y) const;
 
    void setVolume(double volume);
 
    void onMouseDown(int32 x, int32 y, Actions::MouseButton mButton);
    void onMouseMove(int32 x, int32 y);
    void onMouseUp(int32 x, int32 y, Actions::MouseButton mButton);
    void onKeyboardEvent(const Common::EventType evtType, bool repeat, const Common::KeyState &keyEvt);
    void onAction(MTropolis::Actions::Action action);
 
    const Common::Point &getCachedMousePosition() const;
    void setModifierCursorOverride(uint32 cursorID);
    void clearModifierCursorOverride();
    void forceCursorRefreshOnce();
    void setAutoResetCursor(bool enabled);
 
    uint getMultiClickCount() const;
 
    bool isAwaitingSceneTransition() const;
 
    Common::RandomSource *getRandom() const;
    WorldManagerInterface *getWorldManagerInterface() const;
    AssetManagerInterface *getAssetManagerInterface() const;
    SystemInterface *getSystemInterface() const;
 
    ISaveUIProvider *getSaveProvider() const;
    ILoadUIProvider *getLoadProvider() const;
 
    Audio::Mixer *getAudioMixer() const;
 
    Hacks &getHacks();
    const Hacks &getHacks() const;
 
    void setSceneGraphDirty();
    void clearSceneGraphDirty();
    bool isSceneGraphDirty() const;
 
    void addCollider(ICollider *collider);
    void removeCollider(ICollider *collider);
    void checkCollisions(ICollider *optRestrictToCollider);
 
    void setCursorElement(const Common::WeakPtr<VisualElement> &element);
    void updateCursorElementPosition();
 
    void addBoundaryDetector(IBoundaryDetector *boundaryDetector);
    void removeBoundaryDetector(IBoundaryDetector *boundaryDetector);
    void checkBoundaries();
 
    void addPostEffect(IPostEffect *postEffect);
    void removePostEffect(IPostEffect *postEffect);
    const Common::Array<IPostEffect *> &getPostEffects() const;
 
    const Palette &getGlobalPalette() const;
    void setGlobalPalette(const Palette &palette);
 
    void addMouseBlocker();
    void removeMouseBlocker();
 
    const Common::String *resolveAttributeIDName(uint32 attribID) const;
 
    const Common::WeakPtr<Window> &getMainWindow() const;
 
    const Common::SharedPtr<Graphics::ManagedSurface> &getSaveScreenshotOverride() const;
    void setSaveScreenshotOverride(const Common::SharedPtr<Graphics::ManagedSurface> &screenshot);
 
    bool isIdle() const;
 
    const Common::SharedPtr<SubtitleRenderer> &getSubtitleRenderer() const;
 
    void queueCloneObject(const Common::WeakPtr<RuntimeObject> &obj);
    void queueKillObject(const Common::WeakPtr<RuntimeObject> &obj);
    void queueChangeObjectParent(const Common::WeakPtr<RuntimeObject> &obj, const Common::WeakPtr<RuntimeObject> &newParent);
 
    void hotLoadScene(Structural *structural);
 
#ifdef MTROPOLIS_DEBUG_ENABLE
    void debugSetEnabled(bool enabled);
    void debugBreak();
    Debugger *debugGetDebugger() const;
 
    void debugGetPrimaryTaskList(Common::Array<Common::SharedPtr<DebugPrimaryTaskList> > &primaryTaskLists);
#endif
 
private:
    enum SceneTransitionState {
        kSceneTransitionStateNotTransitioning,
        kSceneTransitionStateWaitingForDraw,
        kSceneTransitionStateTransitioning,
    };
 
    struct SceneStackEntry {
        SceneStackEntry();
 
        Common::SharedPtr<Structural> scene;
    };
 
    struct Teardown {
        Teardown();
 
        Common::WeakPtr<Structural> structural;
        Common::WeakPtr<Modifier> modifier;
        bool onlyRemoveChildren;
    };
 
    struct SceneReturnListEntry {
        SceneReturnListEntry();
 
        Common::SharedPtr<Structural> scene;
        bool isAddToDestinationSceneTransition;
    };
 
    struct DispatchMethodTaskData {
        Common::SharedPtr<MessageDispatch> dispatch;
    };
 
    struct DispatchKeyTaskData {
        Common::SharedPtr<KeyEventDispatch> dispatch;
    };
 
    struct DispatchActionTaskData {
        DispatchActionTaskData();
 
        Actions::Action action;
    };
 
    struct ConsumeMessageTaskData {
        ConsumeMessageTaskData();
 
        IMessageConsumer *consumer;
        Common::SharedPtr<MessageProperties> message;
    };
 
    struct ConsumeCommandTaskData {
        ConsumeCommandTaskData();
 
        Structural *structural;
        Common::SharedPtr<MessageProperties> message;
    };
 
    struct ApplyDefaultVisibilityTaskData {
        ApplyDefaultVisibilityTaskData();
 
        VisualElement *element;
        bool targetVisibility;
    };
 
    struct UpdateMouseStateTaskData {
        UpdateMouseStateTaskData();
 
        bool mouseDown;
    };
 
    struct UpdateMousePositionTaskData {
        UpdateMousePositionTaskData();
 
        int32 x;
        int32 y;
    };
 
    struct CollisionCheckState {
        CollisionCheckState();
 
        Common::Array<Common::WeakPtr<VisualElement> > activeElements;
        ICollider *collider;
    };
 
    struct BoundaryCheckState {
        BoundaryCheckState();
 
        IBoundaryDetector *detector;
        uint currentContacts;
        Common::Point position;
        bool positionResolved;
    };
 
    struct ColliderInfo {
        ColliderInfo();
 
        size_t sceneStackDepth;
        uint16 layer;
        VisualElement *element;
        Common::Rect absRect;
    };
 
    static Common::SharedPtr<Structural> findDefaultSharedSceneForScene(Structural *scene);
    void executeTeardown(const Teardown &teardown);
    void executeLowLevelSceneStateTransition(const LowLevelSceneStateTransitionAction &transitionAction);
    void executeHighLevelSceneReturn();
    void executeHighLevelSceneTransition(const HighLevelSceneTransition &transition);
    void executeCompleteTransitionToScene(const Common::SharedPtr<Structural> &scene);
    void executeSharedScenePostSceneChangeActions();
    void executeSceneChangeRecursiveVisibilityChange(Structural *structural, bool showing);
    void executeChangeObjectParent(RuntimeObject *object, RuntimeObject *newParent);
    void executeCloneObject(RuntimeObject *object);
    void executeKillObject(RuntimeObject *object);
 
    void recursiveAutoPlayMedia(Structural *structural);
    void recursiveDeactivateStructural(Structural *structural);
    void recursiveActivateStructural(Structural *structural);
 
    static bool isStructuralMouseInteractive(Structural *structural, MouseInteractivityTestType testType);
    static bool isModifierMouseInteractive(Modifier *modifier, MouseInteractivityTestType testType);
    static void recursiveFindMouseCollision(Structural *&bestResult, int32 &bestLayer, int32 &bestStackHeight, bool &bestDirect, Structural *candidate, int32 stackHeight, int32 relativeX, int32 relativeY, MouseInteractivityTestType testType);
 
    void queueEventAsLowLevelSceneStateTransitionAction(const Event &evt, Structural *root, bool cascade, bool relay);
 
    void loadScene(const Common::SharedPtr<Structural> &scene);
 
    void ensureMainWindowExists();
 
    void unloadProject();
    void refreshPlayTime(); // Updates play time to be in sync with the system clock.  Used so that events occurring after storage access don't skip.
 
    struct DispatchMessageCoroutine {
        CORO_DEFINE_RETURN_TYPE(void);
        CORO_DEFINE_PARAMS_2(Runtime *, runtime, Common::SharedPtr<MessageDispatch>, dispatch);
    };
 
    struct SendMessageToStructuralCoroutine {
        CORO_DEFINE_RETURN_TYPE(void);
        CORO_DEFINE_PARAMS_4(Runtime *, runtime, bool *, isTerminatedPtr, Structural *, structural, MessageDispatch *, dispatch);
    };
 
    struct SendMessageToModifierContainerCoroutine {
        CORO_DEFINE_RETURN_TYPE(void);
        CORO_DEFINE_PARAMS_4(Runtime *, runtime, bool *, isTerminatedPtr, IModifierContainer *, modifierContainer, MessageDispatch *, dispatch);
    };
 
    struct SendMessageToModifierCoroutine {
        CORO_DEFINE_RETURN_TYPE(void);
        CORO_DEFINE_PARAMS_4(Runtime *, runtime, bool *, isTerminatedPtr, Modifier *, modifier, MessageDispatch *, dispatch);
    };
 
    VThreadState dispatchKeyTask(const DispatchKeyTaskData &data);
    VThreadState dispatchActionTask(const DispatchActionTaskData &data);
    VThreadState consumeMessageTask(const ConsumeMessageTaskData &data);
    VThreadState consumeCommandTask(const ConsumeCommandTaskData &data);
    VThreadState updateMouseStateTask(const UpdateMouseStateTaskData &data);
    VThreadState updateMousePositionTask(const UpdateMousePositionTaskData &data);
    VThreadState applyDefaultVisibility(const ApplyDefaultVisibilityTaskData &data);
 
    void updateMainWindowCursor();
 
    static void recursiveFindColliders(Structural *structural, size_t sceneStackDepth, Common::Array<ColliderInfo> &colliders, int32 parentOriginX, int32 parentOriginY, bool isRoot);
    static bool sortColliderPredicate(const ColliderInfo &a, const ColliderInfo &b);
 
    Common::ScopedPtr<ICoroutineManager> _coroManager;
 
    Common::Array<VolumeState> _volumes;
    Common::SharedPtr<ProjectDescription> _queuedProjectDesc;
    Common::SharedPtr<Project> _project;
    Common::ScopedPtr<VThread> _vthread;
    Common::Array<Common::SharedPtr<MessageDispatch> > _messageQueue;
    Common::Array<Common::SharedPtr<OSEvent> > _osEventQueue;
    ObjectLinkingScope _rootLinkingScope;
 
    Common::Array<Teardown> _pendingTeardowns;
    Common::Array<LowLevelSceneStateTransitionAction> _pendingLowLevelTransitions;
    Common::Array<Common::WeakPtr<RuntimeObject> > _pendingKills;
    Common::Array<Common::WeakPtr<RuntimeObject> > _pendingClones;
    Common::Array<Common::WeakPtr<Structural> > _pendingPostCloneShowChecks;
    Common::Array<Common::WeakPtr<Structural> > _pendingShowClonedObject;
    Common::Array<ObjectParentChange> _pendingParentChanges;
    uint _pendingSceneReturnCount;
    Common::Array<HighLevelSceneTransition> _pendingSceneTransitions;
    Common::Array<SceneStackEntry> _sceneStack;
    Common::SharedPtr<Structural> _activeMainScene;
    Common::SharedPtr<Structural> _activeSharedScene;
    Common::Array<SceneReturnListEntry> _sceneReturnList;
 
    SceneTransitionState _sceneTransitionState;
    SceneTransitionEffect _sourceSceneTransitionEffect;
    SceneTransitionEffect _destinationSceneTransitionEffect;
    SceneTransitionEffect *_activeSceneTransitionEffect;
    Common::SharedPtr<Graphics::ManagedSurface> _sceneTransitionOldFrame;
    Common::SharedPtr<Graphics::ManagedSurface> _sceneTransitionNewFrame;
    uint32 _sceneTransitionStartTime;
    uint32 _sceneTransitionEndTime;
    bool _sharedSceneWasSetExplicitly;
 
    Common::WeakPtr<Window> _mainWindow;
    Common::Array<Common::SharedPtr<Window> > _windows;
 
    Common::SharedPtr<Graphics::MacFontManager> _macFontMan;
 
    Common::SharedPtr<Common::RandomSource> _random;
 
    uint32 _nextRuntimeGUID;
 
    bool _displayModeSupported[kColorDepthModeCount];
    Graphics::PixelFormat _displayModePixelFormats[kColorDepthModeCount];
    ColorDepthMode _realDisplayMode;
    ColorDepthMode _fakeDisplayMode;
    uint16 _displayWidth;
    uint16 _displayHeight;
 
    uint64 _realTimeBase;
    uint64 _playTimeBase;
 
    uint32 _realTime;
    uint32 _playTime;
 
    Scheduler _scheduler;
    OSystem *_system;
    Audio::Mixer *_mixer;
 
    ISaveUIProvider *_saveProvider;
    ILoadUIProvider *_loadProvider;
    Common::SharedPtr<Graphics::ManagedSurface> _saveScreenshotOverride;
 
    Common::SharedPtr<CursorGraphic> _lastFrameCursor;
    Common::SharedPtr<CursorGraphic> _defaultCursor;
    bool _lastFrameMouseVisible;
 
    Common::WeakPtr<Window> _mouseFocusWindow;
    bool _mouseFocusFlags[Actions::kMouseButtonCount];
 
    Common::WeakPtr<Window> _keyFocusWindow;
 
    Common::SharedPtr<SystemInterface> _systemInterface;
    Common::SharedPtr<WorldManagerInterface> _worldManagerInterface;
    Common::SharedPtr<AssetManagerInterface> _assetManagerInterface;
 
    // The cached mouse position is updated at frame end
    Common::Point _cachedMousePosition;
 
    // The real mouse position is updated all the time (even when suspended)
    Common::Point _realMousePosition;
 
    // Mouse control is tracked in two ways: Mouse over is detected with mouse movement AND when
    // "refreshCursor" is set on the world manager, it indicates the frontmost object that
    // responds to any mouse event.  The mouse tracking object is the object that was clicked.
    // These can differ if the user holds down the mouse and moves it to a spot where the tracked
    // object is either not clickable, or is behind another object with mouse collision.
    // Note that mouseOverObject is also NOT necessarily what will receive mouse down events.
    Common::WeakPtr<Structural> _mouseOverObject;
    Common::WeakPtr<Structural> _mouseTrackingObject;
    Common::Point _mouseTrackingDragStart;
    Common::Point _mouseTrackingObjectInitialOrigin;
    bool _trackedMouseOutside;
    bool _forceCursorRefreshOnce;
    bool _autoResetCursor;
 
    uint32 _modifierOverrideCursorID;
    bool _haveModifierOverrideCursor;
    bool _haveCursorElement;
 
    uint32 _multiClickStartTime;
    uint32 _multiClickInterval;
    uint _multiClickCount;
 
    uint _numMouseBlockers;
 
    bool _defaultVolumeState;
 
    // True if any elements were added to the scene, removed from the scene, or reparented since last draw
    bool _sceneGraphChanged;
 
    bool _isQuitting;
 
    Common::Array<Common::SharedPtr<CollisionCheckState> > _colliders;
    Common::Array<BoundaryCheckState> _boundaryChecks;
    uint32 _collisionCheckTime;
 
    Common::WeakPtr<VisualElement> _elementTrackedToCursor;
    //uint32 _elementCursorUpdateTime;
 
    Common::Array<IPostEffect *> _postEffects;
 
    Palette _globalPalette;
 
    Common::SharedPtr<SubtitleRenderer> _subtitleRenderer;
 
    Hacks _hacks;
 
    Common::HashMap<uint32, Common::String> _getSetAttribIDsToAttribName;
 
#ifdef MTROPOLIS_DEBUG_ENABLE
    Common::SharedPtr<Debugger> _debugger;
#endif
};
 
struct IModifierContainer : public IInterfaceBase {
    virtual const Common::Array<Common::SharedPtr<Modifier> > &getModifiers() const = 0;
    virtual void appendModifier(const Common::SharedPtr<Modifier> &modifier) = 0;
    virtual void removeModifier(const Modifier *modifier) = 0;
};
 
class SimpleModifierContainer : public IModifierContainer {
public:
    const Common::Array<Common::SharedPtr<Modifier> > &getModifiers() const override;
    void appendModifier(const Common::SharedPtr<Modifier> &modifier) override;
    void removeModifier(const Modifier *modifier) override;
 
    void clear();
 
private:
    Common::Array<Common::SharedPtr<Modifier> > _modifiers;
};
 
class RuntimeObject {
    template<typename TElement, typename TElementData>
    friend class ElementFactory;
 
public:
    RuntimeObject();
    virtual ~RuntimeObject();
 
    uint32 getStaticGUID() const;
    uint32 getRuntimeGUID() const;
 
    void setRuntimeGUID(uint32 runtimeGUID);
 
    void setSelfReference(const Common::WeakPtr<RuntimeObject> &selfReference);
    const Common::WeakPtr<RuntimeObject> &getSelfReference() const;
 
    virtual bool isStructural() const;
    virtual bool isProject() const;
    virtual bool isSection() const;
    virtual bool isSubsection() const;
    virtual bool isModifier() const;
    virtual bool isElement() const;
 
    virtual bool readAttribute(MiniscriptThread *thread, DynamicValue &result, const Common::String &attrib);
    virtual bool readAttributeIndexed(MiniscriptThread *thread, DynamicValue &result, const Common::String &attrib, const DynamicValue &index);
    virtual MiniscriptInstructionOutcome writeRefAttribute(MiniscriptThread *thread, DynamicValueWriteProxy &result, const Common::String &attrib);
    virtual MiniscriptInstructionOutcome writeRefAttributeIndexed(MiniscriptThread *thread, DynamicValueWriteProxy &result, const Common::String &attrib, const DynamicValue &index);
 
protected:
    MiniscriptInstructionOutcome scriptSetClone(MiniscriptThread *thread, const DynamicValue &value);
    MiniscriptInstructionOutcome scriptSetKill(MiniscriptThread *thread, const DynamicValue &value);
    MiniscriptInstructionOutcome scriptSetParent(MiniscriptThread *thread, const DynamicValue &value);
 
    // This is the static GUID stored in the data, it is not guaranteed
    // to be globally unique at runtime.  In particular, cloning an object
    // and using aliased modifiers will cause multiple objects with the same
    // static GUID to exist with separate runtime GUIDs.
    uint32 _guid;
    uint32 _runtimeGUID;
    Common::WeakPtr<RuntimeObject> _selfReference;
 
    struct ParentWriteProxyInterface {
        static MiniscriptInstructionOutcome write(MiniscriptThread *thread, const DynamicValue &dest, void *objectRef, uintptr ptrOrOffset);
        static MiniscriptInstructionOutcome refAttrib(MiniscriptThread *thread, DynamicValueWriteProxy &proxy, void *objectRef, uintptr ptrOrOffset, const Common::String &attrib);
        static MiniscriptInstructionOutcome refAttribIndexed(MiniscriptThread *thread, DynamicValueWriteProxy &proxy, void *objectRef, uintptr ptrOrOffset, const Common::String &attrib, const DynamicValue &index);
 
    private:
        static RuntimeObject *resolveObjectParent(RuntimeObject *obj);
    };
};
 
struct MessageProperties {
    MessageProperties(const Event &evt, const DynamicValue &value, const Common::WeakPtr<RuntimeObject> &source);
 
    const Event &getEvent() const;
    const DynamicValue &getValue() const;
    const Common::WeakPtr<RuntimeObject> &getSource() const;
 
    void setValue(const DynamicValue &value);
 
private:
    Event _evt;
    DynamicValue _value;
    Common::WeakPtr<RuntimeObject> _source;
};
 
struct IStructuralReferenceVisitor : public IInterfaceBase {
    virtual void visitChildStructuralRef(Common::SharedPtr<Structural> &structural) = 0;
    virtual void visitChildModifierRef(Common::SharedPtr<Modifier> &modifier) = 0;
    virtual void visitWeakStructuralRef(Common::WeakPtr<Structural> &structural) = 0;
    virtual void visitWeakModifierRef(Common::WeakPtr<Modifier> &modifier) = 0;
};
 
struct IMessageConsumer : public IInterfaceBase {
    // These should only be implemented as direct responses - child traversal is handled by the message propagation process
    virtual bool respondsToEvent(const Event &evt) const = 0;
    virtual VThreadState consumeMessage(Runtime *runtime, const Common::SharedPtr<MessageProperties> &msg) = 0;
};
 
class WorldManagerInterface : public RuntimeObject {
public:
    WorldManagerInterface();
 
    bool readAttribute(MiniscriptThread *thread, DynamicValue &result, const Common::String &attrib) override;
    MiniscriptInstructionOutcome writeRefAttribute(MiniscriptThread *thread, DynamicValueWriteProxy &result, const Common::String &attrib) override;
 
private:
    MiniscriptInstructionOutcome setCurrentScene(MiniscriptThread *thread, const DynamicValue &value);
    MiniscriptInstructionOutcome setRefreshCursor(MiniscriptThread *thread, const DynamicValue &value);
    MiniscriptInstructionOutcome setAutoResetCursor(MiniscriptThread *thread, const DynamicValue &value);
    MiniscriptInstructionOutcome setWinSndBufferSize(MiniscriptThread *thread, const DynamicValue &value);
    MiniscriptInstructionOutcome setCursor(MiniscriptThread *thread, const DynamicValue &value);
 
    int32 _opInt;
    bool _gameMode;
    bool _combineRedraws;
    bool _postponeRedraws;
};
 
class AssetManagerInterface : public RuntimeObject {
public:
    AssetManagerInterface();
 
    bool readAttribute(MiniscriptThread *thread, DynamicValue &result, const Common::String &attrib) override;
    MiniscriptInstructionOutcome writeRefAttribute(MiniscriptThread *thread, DynamicValueWriteProxy &result, const Common::String &attrib) override;
 
private:
    Common::String _opString;
};
 
class SystemInterface : public RuntimeObject {
public:
    const int kFullVolume = 7;
 
    SystemInterface();
 
    bool readAttribute(MiniscriptThread *thread, DynamicValue &result, const Common::String &attrib) override;
    bool readAttributeIndexed(MiniscriptThread *thread, DynamicValue &result, const Common::String &attrib, const DynamicValue &index) override;
    MiniscriptInstructionOutcome writeRefAttribute(MiniscriptThread *thread, DynamicValueWriteProxy &result, const Common::String &attrib) override;
 
private:
    MiniscriptInstructionOutcome setEjectCD(MiniscriptThread *thread, const DynamicValue &value);
    MiniscriptInstructionOutcome setGameMode(MiniscriptThread *thread, const DynamicValue &value);
    MiniscriptInstructionOutcome setMasterVolume(MiniscriptThread *thread, const DynamicValue &value);
    MiniscriptInstructionOutcome setMonitorBitDepth(MiniscriptThread *thread, const DynamicValue &value);
    MiniscriptInstructionOutcome setVolumeName(MiniscriptThread *thread, const DynamicValue &value);
 
    Common::String _volumeName;
    Common::String _opString;
    int _masterVolume;
};
 
class StructuralHooks {
public:
    virtual ~StructuralHooks();
 
    virtual void onCreate(Structural *structural);
    virtual void onPostActivate(Structural *structural);
    virtual void onSetPosition(Runtime *runtime, Structural *structural, const Common::Point &oldPt, Common::Point &pt);
    virtual void onStopPlayingMToon(Structural *structural, bool &visible, bool &stopped, Graphics::ManagedSurface *lastSurf);
    virtual void onHidden(Structural *structural, bool &visible);
};
 
class Structural : public RuntimeObject, public IModifierContainer, public IMessageConsumer, public Debuggable {
public:
    enum class SceneLoadState {
        kNotAScene,
        kSceneNotLoaded,
        kSceneLoaded,
    };
 
    Structural();
    explicit Structural(Runtime *runtime);
    virtual ~Structural();
 
    bool isStructural() const override;
    SceneLoadState getSceneLoadState() const;
    void setSceneLoadState(SceneLoadState sceneLoadState);
 
    bool readAttribute(MiniscriptThread *thread, DynamicValue &result, const Common::String &attrib) override;
    bool readAttributeIndexed(MiniscriptThread *thread, DynamicValue &result, const Common::String &attrib, const DynamicValue &index) override;
    MiniscriptInstructionOutcome writeRefAttribute(MiniscriptThread *thread, DynamicValueWriteProxy &result, const Common::String &attrib) override;
 
    const Common::Array<Common::SharedPtr<Structural> > &getChildren() const;
    void addChild(const Common::SharedPtr<Structural> &child);
    void removeAllChildren();
    void removeAllModifiers();
    void removeChild(Structural *child);
    void removeAllAssets();
 
    void holdAssets(const Common::Array<Common::SharedPtr<Asset> > &assets);
 
    Structural *getParent() const;
    Structural *findNextSibling() const;
    Structural *findPrevSibling() const;
    void setParent(Structural *parent);
 
    // Helper that finds the scene containing the structural object, or itself if it is the scene
    VisualElement *findScene();
 
    const Common::String &getName() const;
 
    const Common::Array<Common::SharedPtr<Modifier> > &getModifiers() const override;
    void appendModifier(const Common::SharedPtr<Modifier> &modifier) override;
    void removeModifier(const Modifier *modifier) override;
 
    bool respondsToEvent(const Event &evt) const override;
    VThreadState consumeMessage(Runtime *runtime, const Common::SharedPtr<MessageProperties> &msg) override;
 
    void materializeSelfAndDescendents(Runtime *runtime, ObjectLinkingScope *outerScope);
    void materializeDescendents(Runtime *runtime, ObjectLinkingScope *outerScope);
 
    struct StructuralConsumeCommandCoroutine {
        CORO_DEFINE_RETURN_TYPE(void);
        CORO_DEFINE_PARAMS_3(Structural *, self, Runtime *, runtime, Common::SharedPtr<MessageProperties>, msg);
    };
 
    virtual VThreadState asyncConsumeCommand(Runtime *runtime, const Common::SharedPtr<MessageProperties> &msg);
 
    virtual void activate();
    virtual void deactivate();
 
    void recursiveCollectObjectsMatchingCriteria(Common::Array<Common::WeakPtr<RuntimeObject> > &results, bool (*evalFunc)(void *userData, RuntimeObject *object), void *userData, bool onlyEnabled);
 
    void setHooks(const Common::SharedPtr<StructuralHooks> &hooks);
    const Common::SharedPtr<StructuralHooks> &getHooks() const;
 
    // Shallow clones only need to copy the object.  Descendent copies are done using visitInternalReferences.
    virtual Common::SharedPtr<Structural> shallowClone() const = 0;
 
    virtual void visitInternalReferences(IStructuralReferenceVisitor *visitor);
 
#ifdef MTROPOLIS_DEBUG_ENABLE
    SupportStatus debugGetSupportStatus() const override;
    const Common::String &debugGetName() const override;
    void debugInspect(IDebugInspectionReport *report) const override;
 
    virtual void debugSkipMovies();
#endif
 
protected:
    explicit Structural(const Structural &other);
 
    virtual ObjectLinkingScope *getPersistentStructuralScope();
    virtual ObjectLinkingScope *getPersistentModifierScope();
 
    MiniscriptInstructionOutcome scriptSetPaused(MiniscriptThread *thread, const DynamicValue &value);
    MiniscriptInstructionOutcome scriptSetLoop(MiniscriptThread *thread, const DynamicValue &value);
    MiniscriptInstructionOutcome scriptSetDebug(MiniscriptThread *thread, const DynamicValue &value);
    MiniscriptInstructionOutcome scriptSetUnload(MiniscriptThread *thread, const DynamicValue &value);
 
    // If you override this, you must override visitInternalReferences too.
    virtual void linkInternalReferences(ObjectLinkingScope *outerScope);
 
    virtual void onPauseStateChanged();
 
    Runtime *getRuntime() const;
 
    Structural *_parent;
    Common::Array<Common::SharedPtr<Structural> > _children;
    Common::Array<Common::SharedPtr<Modifier> > _modifiers;
    Common::String _name;
 
    Common::Array<Common::SharedPtr<Asset> > _assets;
 
    // "paused" attrib is available for ALL structural types, even when it doesn't do anything.
    // Changing it does not affect modifiers on the object that play media, but does fire
    // "Paused"/"Unpaused" events.
    bool _paused;
 
    // "loop" appears to have been made available on everything in 1.2.  Obsidian depends on it
    // being available for sound indexes to be properly set up.
    bool _loop;
 
    int32 _flushPriority;
    SceneLoadState _sceneLoadState;
 
    Common::SharedPtr<StructuralHooks> _hooks;
 
private:
    Runtime *_runtime;
};
 
struct ProjectPresentationSettings {
    ProjectPresentationSettings();
 
    uint16 width;
    uint16 height;
    uint32 bitsPerPixel;
};
 
struct AssetDefLoaderContext {
    Common::Array<Common::SharedPtr<Asset> > assets;
};
 
struct ChildLoaderContext {
    enum Type {
        kTypeUnknown,
        kTypeCountedModifierList,
        kTypeFlagTerminatedModifierList,
        kTypeProject,
        kTypeSection,
        kTypeFilteredElements,
    };
 
    struct FilteredElements {
        Structural *structural;
        bool (*filterFunc)(Data::DataObjectTypes::DataObjectType dataObjectType);
    };
 
    union ContainerUnion {
        IModifierContainer *modifierContainer;
        Structural *structural;
        FilteredElements filteredElements;
    };
 
    ChildLoaderContext();
 
    uint remainingCount;
    Type type;
    ContainerUnion containerUnion;
};
 
struct ChildLoaderStack {
    Common::Array<ChildLoaderContext> contexts;
};
 
class ProjectPlugInRegistry : public IPlugInModifierRegistrar  {
public:
    ProjectPlugInRegistry();
 
    void registerPlugInModifier(const char *name, const Data::IPlugInModifierDataFactory *dataFactory, const IPlugInModifierFactory *factory) override;
 
    const Data::PlugInModifierRegistry &getDataLoaderRegistry() const;
    const IPlugInModifierFactory *findPlugInModifierFactory(const char *name) const;
 
private:
    Data::PlugInModifierRegistry _dataLoaderRegistry;
    Common::HashMap<Common::String, const IPlugInModifierFactory *> _factoryRegistry;
};
 
struct IPlayMediaSignalReceiver : public IInterfaceBase {
    virtual void playMedia(Runtime *runtime, Project *project) = 0;
};
 
class PlayMediaSignaller {
public:
    PlayMediaSignaller();
    ~PlayMediaSignaller();
 
    void playMedia(Runtime *runtime, Project *project);
    void addReceiver(IPlayMediaSignalReceiver *receiver);
    void removeReceiver(IPlayMediaSignalReceiver *receiver);
 
private:
    Common::Array<IPlayMediaSignalReceiver *> _receivers;
};
 
struct ISegmentUnloadSignalReceiver : public IInterfaceBase {
    virtual void onSegmentUnloaded(int segmentIndex) = 0;
};
 
class SegmentUnloadSignaller {
public:
    explicit SegmentUnloadSignaller(Project *project, int segmentIndex);
    ~SegmentUnloadSignaller();
 
    void onSegmentUnloaded();
    void addReceiver(ISegmentUnloadSignalReceiver *receiver);
    void removeReceiver(ISegmentUnloadSignalReceiver *receiver);
 
private:
    Project *_project;
    int _segmentIndex;
    Common::Array<ISegmentUnloadSignalReceiver *> _receivers;
};
 
struct IKeyboardEventReceiver : public IInterfaceBase {
    virtual void onKeyboardEvent(Runtime *runtime, const KeyboardInputEvent &keyEvt) = 0;
};
 
class KeyboardEventSignaller {
public:
    KeyboardEventSignaller();
    ~KeyboardEventSignaller();
 
    void onKeyboardEvent(Runtime *runtime, const KeyboardInputEvent &keyEvt);
    void addReceiver(IKeyboardEventReceiver *receiver);
    void removeReceiver(IKeyboardEventReceiver *receiver);
 
private:
    Common::Array<IKeyboardEventReceiver *> _receivers;
    Common::SharedPtr<KeyboardEventSignaller> _signaller;
};
 
struct ICollider : public IInterfaceBase {
    virtual void getCollisionProperties(Modifier *&modifier, bool &collideInFront, bool &collideBehind, bool &excludeParents) const = 0;
    virtual void triggerCollision(Runtime *runtime, Structural *collidingElement, bool wasInContact, bool isInContact, bool &outShouldStop) = 0;
};
 
struct IBoundaryDetector : public IInterfaceBase {
    enum EdgeFlags {
        kEdgeTop = 0x1,
        kEdgeBottom = 0x2,
        kEdgeLeft = 0x4,
        kEdgeRight = 0x8,
    };
 
    virtual void getCollisionProperties(Modifier *&modifier, uint &edgeFlags, bool &mustBeCompletelyOutside, bool &continuous) const = 0;
    virtual void triggerCollision(Runtime *runtime) = 0;
};
 
struct IPostEffect : public IInterfaceBase {
    virtual void renderPostEffect(Graphics::ManagedSurface &surface) const = 0;
};
 
struct IMediaCueModifier : public IInterfaceBase {
    virtual Modifier *getMediaCueModifier() = 0;
    virtual Common::WeakPtr<Modifier> getMediaCueTriggerSource() const = 0;
};
 
struct MediaCueState {
    enum TriggerTiming {
        kTriggerTimingStart = 0,
        kTriggerTimingDuring = 1,
        kTriggerTimingEnd = 2,
    };
 
    int32 minTime;
    int32 maxTime;
 
    IMediaCueModifier *sourceModifier;
    TriggerTiming triggerTiming;
    MessengerSendSpec send;
    DynamicValue incomingData;
 
    MediaCueState();
    void checkTimestampChange(Runtime *runtime, uint32 oldTS, uint32 newTS, bool continuousTimestamps, bool canTriggerDuring);
};
 
class Project : public Structural {
public:
    explicit Project(Runtime *runtime);
    ~Project();
 
    VThreadState asyncConsumeCommand(Runtime *runtime, const Common::SharedPtr<MessageProperties> &msg) override;
 
    MiniscriptInstructionOutcome writeRefAttribute(MiniscriptThread *thread, DynamicValueWriteProxy &result, const Common::String &attrib) override;
 
    void loadFromDescription(const ProjectDescription &desc, const Hacks &hacks);
    void loadSceneFromStream(const Common::SharedPtr<Structural> &structural, uint32 streamID, const Hacks &hacks);
 
    Common::SharedPtr<Modifier> resolveAlias(uint32 aliasID) const;
    Common::SharedPtr<Modifier> findGlobalVarWithName(const Common::String &name) const;
    void materializeGlobalVariables(Runtime *runtime, ObjectLinkingScope *scope);
 
    const ProjectPresentationSettings &getPresentationSettings() const;
 
    bool isProject() const override;
 
    Common::String getAssetNameByID(uint32 assetID) const;
    Common::WeakPtr<Asset> getAssetByID(uint32 assetID) const;
    bool getAssetIDByName(const Common::String &assetName, uint32 &outAssetID) const;
    void forceLoadAsset(uint32 assetID, Common::Array<Common::SharedPtr<Asset> > &outHoldAssets);
 
    size_t getSegmentForStreamIndex(size_t streamIndex) const;
    void openSegmentStream(int segmentIndex);
    void closeSegmentStream(int segmentIndex);
    Common::SeekableReadStream *getStreamForSegment(int segmentIndex);
 
    const Common::String *findNameOfLabel(const Label &label) const;
 
    void onPostRender();
    void onKeyboardEvent(Runtime *runtime, const KeyboardInputEvent &keyEvt);
 
    Common::SharedPtr<SegmentUnloadSignaller> notifyOnSegmentUnload(int segmentIndex, ISegmentUnloadSignalReceiver *receiver);
    Common::SharedPtr<KeyboardEventSignaller> notifyOnKeyboardEvent(IKeyboardEventReceiver *receiver);
    Common::SharedPtr<PlayMediaSignaller> notifyOnPlayMedia(IPlayMediaSignalReceiver *receiver);
 
    const char *findAuthorMessageName(uint32 id) const;
 
    const Common::SharedPtr<CursorGraphicCollection> &getCursorGraphics() const;
 
    const SubtitleTables &getSubtitles() const;
 
    RuntimeVersion getRuntimeVersion() const;
    ProjectPlatform getPlatform() const;
 
    void visitInternalReferences(IStructuralReferenceVisitor *visitor) override;
    Common::SharedPtr<Structural> shallowClone() const override;
 
#ifdef MTROPOLIS_DEBUG_ENABLE
    const char *debugGetTypeName() const override { return "Project"; }
#endif
 
private:
    struct LabelSuperGroup {
        LabelSuperGroup();
 
        size_t firstRootNodeIndex;
        size_t numRootNodes;
        size_t numTotalNodes;
 
        uint32 superGroupID;
        Common::String name;
    };
 
    struct LabelTree {
        LabelTree();
 
        size_t firstChildIndex;
        size_t numChildren;
 
        uint32 id;
        Common::String name;
    };
 
    struct Segment {
        Segment();
 
        SegmentDescription desc;
        Common::SharedPtr<Common::SeekableReadStream> rcStream;
 
        Common::SeekableReadStream *weakStream;
        Common::SharedPtr<SegmentUnloadSignaller> unloadSignaller;
    };
 
    enum StreamType {
        kStreamTypeUnknown,
 
        kStreamTypeAsset,
        kStreamTypeBoot,
        kStreamTypeScene,
    };
 
    struct StreamDesc {
        StreamDesc();
 
        StreamType streamType;
        uint16 segmentIndex;
        uint32 size;
        uint32 pos;
    };
 
    struct AssetDesc {
        AssetDesc();
 
        uint32 typeCode;
        uint32 streamID;
        uint32 filePosition;
        size_t id;
        Common::String name;
 
        // If the asset is live, this will be its asset info
        Common::WeakPtr<Asset> asset;
    };
 
    void loadBootStream(size_t streamIndex, const Hacks &hacks);
 
    void loadPresentationSettings(const Data::PresentationSettings &presentationSettings);
    void loadAssetCatalog(const Data::AssetCatalog &assetCatalog);
    void loadGlobalObjectInfo(ChildLoaderStack &loaderStack, const Data::GlobalObjectInfo &globalObjectInfo);
    void loadAssetDef(size_t streamIndex, AssetDefLoaderContext &context, const Data::DataObject &dataObject);
    void loadContextualObject(size_t streamIndex, ChildLoaderStack &stack, const Data::DataObject &dataObject);
    Common::SharedPtr<Modifier> loadModifierObject(ModifierLoaderContext &loaderContext, const Data::DataObject &dataObject);
    void loadLabelMap(const Data::ProjectLabelMap &projectLabelMap);
    static size_t recursiveCountLabels(const Data::ProjectLabelMap::LabelTree &tree);
 
    ObjectLinkingScope *getPersistentStructuralScope() override;
    ObjectLinkingScope *getPersistentModifierScope() override;
 
    void assignAssets(const Common::Array<Common::SharedPtr<Asset> > &assets, const Hacks &hacks);
 
    void initAdditionalSegments(const Common::String &projectName);
 
    Common::Array<Segment> _segments;
    Common::Array<StreamDesc> _streams;
    Common::Array<LabelTree> _labelTree;
    Common::Array<LabelSuperGroup> _labelSuperGroups;
    Data::ProjectFormat _projectFormat;
 
    Common::Array<AssetDesc *> _assetsByID;
    Common::Array<AssetDesc> _realAssets;
 
    Common::HashMap<Common::String, size_t> _assetNameToID;
 
    ProjectPresentationSettings _presentationSettings;
 
    bool _haveGlobalObjectInfo;
    bool _haveProjectStructuralDef;
    SimpleModifierContainer _globalModifiers;
 
    ProjectPlugInRegistry _plugInRegistry;
 
    Common::Array<Common::SharedPtr<PlugIn> > _plugIns;
    Common::SharedPtr<ProjectResources> _resources;
    Common::SharedPtr<CursorGraphicCollection> _cursorGraphics;
 
    ObjectLinkingScope _structuralScope;
    ObjectLinkingScope _modifierScope;
 
    Common::SharedPtr<PlayMediaSignaller> _playMediaSignaller;
    Common::SharedPtr<KeyboardEventSignaller> _keyboardEventSignaller;
 
    SubtitleTables _subtitles;
 
    ProjectPlatform _platform;
 
    Common::Archive *_rootArchive;
    Common::Path _projectRootDir;
 
    RuntimeVersion _runtimeVersion;
    bool _isRuntimeVersionAutoDetect;
};
 
class Section : public Structural {
public:
    bool load(const Data::SectionStructuralDef &data);
 
    bool isSection() const override;
 
    Common::SharedPtr<Structural> shallowClone() const override;
    void visitInternalReferences(IStructuralReferenceVisitor *visitor) override;
 
#ifdef MTROPOLIS_DEBUG_ENABLE
    const char *debugGetTypeName() const override { return "Section"; }
#endif
 
private:
    ObjectLinkingScope *getPersistentStructuralScope() override;
    ObjectLinkingScope *getPersistentModifierScope() override;
 
    ObjectLinkingScope _structuralScope;
    ObjectLinkingScope _modifierScope;
};
 
class Subsection : public Structural {
public:
    bool load(const Data::SubsectionStructuralDef &data);
 
    bool readAttribute(MiniscriptThread *thread, DynamicValue &result, const Common::String &attrib) override;
 
    ObjectLinkingScope *getSceneLoadMaterializeScope();
 
    bool isSubsection() const override;
 
    Common::SharedPtr<Structural> shallowClone() const override;
    void visitInternalReferences(IStructuralReferenceVisitor *visitor) override;
 
#ifdef MTROPOLIS_DEBUG_ENABLE
    const char *debugGetTypeName() const override { return "Subsection"; }
#endif
 
private:
    ObjectLinkingScope *getPersistentStructuralScope() override;
    ObjectLinkingScope *getPersistentModifierScope() override;
 
    ObjectLinkingScope _structuralScope;
    ObjectLinkingScope _modifierScope;
};
 
class Element : public Structural {
public:
    Element();
 
    virtual bool isVisual() const = 0;
    virtual bool canAutoPlay() const;
    virtual void queueAutoPlayEvents(Runtime *runtime, bool isAutoPlaying);
 
    bool isElement() const override;
 
    uint32 getStreamLocator() const;
 
    void addMediaCue(MediaCueState *mediaCue);
    void removeMediaCue(const MediaCueState *mediaCue);
 
    void triggerAutoPlay(Runtime *runtime);
    virtual void tryAutoSetName(Runtime *runtime, Project *project);
 
    virtual bool resolveMediaMarkerLabel(const Label &label, int32 &outResolution) const;
 
    void visitInternalReferences(IStructuralReferenceVisitor *visitor) override;
 
    typedef StructuralConsumeCommandCoroutine ElementConsumeCommandCoroutine;
 
protected:
    Element(const Element &other);
 
    uint32 _streamLocator;
    uint16 _sectionID;
 
    Common::Array<MediaCueState *> _mediaCues;
 
    bool _haveCheckedAutoPlay;
};
 
class VisualElementTransitionProperties {
public:
    VisualElementTransitionProperties();
 
    uint8 getAlpha() const;
    void setAlpha(uint8 alpha);
 
    bool isDirty() const;
    void clearDirty();
 
private:
    uint8 _alpha;
    bool _isDirty;
};
 
class VisualElementRenderProperties {
public:
    VisualElementRenderProperties();
    VisualElementRenderProperties(const VisualElementRenderProperties &) = default;
 
    enum InkMode {
        kInkModeCopy = 0x0,
        kInkModeTransparent = 0x1,              // src*dest
        kInkModeGhost = 0x3,                    // (1-src)+dest
        kInkModeReverseCopy = 0x4,              // 1-src
        kInkModeReverseGhost = 0x7,             // src+dest
        kInkModeReverseTransparent = 0x9,       // (1-src)*dest
        kInkModeBlend = 0x20,                   // (src*bgcolor)+(dest*(1-bgcolor)
        kInkModeBackgroundTransparent = 0x24,   // BG color is transparent
        kInkModeChameleonDark = 0x25,           // src+dest
        kInkModeChameleonLight = 0x27,          // src*dest
        kInkModeBackgroundMatte = 0x224,        // BG color is transparent and non-interactive
        kInkModeInvisible = 0xffff,             // Not drawn, but interactive
 
        kInkModeXor = 0x7ffffff0,               // Fake ink mode for Obsidian canvas puzzle, not a valid value from data
        kInkModeDefault = 0x7fffffff,           // Not a valid value from data
    };
 
    enum Shape {
        kShapeRect = 0x1,
        kShapeRoundedRect = 0x2,
        kShapeOval = 0x3,
        kShapePolygon = 0x9,
        kShapeStar = 0xb, // 5-point star, horizontal arms are at (top+bottom*2)/3
 
        // Fake shapes for Obsidian canvas puzzle, not a valid from data
        kShapeObsidianCanvasPuzzleTri1 = 0x7ffffff1,
        kShapeObsidianCanvasPuzzleTri2 = 0x7ffffff2,
        kShapeObsidianCanvasPuzzleTri3 = 0x7ffffff3,
        kShapeObsidianCanvasPuzzleTri4 = 0x7ffffff4,
    };
 
    InkMode getInkMode() const;
    void setInkMode(InkMode inkMode);
 
    Shape getShape() const;
    void setShape(Shape shape);
 
    const ColorRGB8 &getForeColor() const;
    void setForeColor(const ColorRGB8 &color);
 
    const ColorRGB8 &getBackColor() const;
    void setBackColor(const ColorRGB8 &color);
 
    const ColorRGB8 &getBorderColor() const;
    void setBorderColor(const ColorRGB8 &color);
 
    const ColorRGB8 &getShadowColor() const;
    void setShadowColor(const ColorRGB8 &color);
 
    uint16 getBorderSize() const;
    void setBorderSize(uint16 size);
 
    uint16 getShadowSize() const;
    void setShadowSize(uint16 size);
 
    const Common::Array<Common::Point> &getPolyPoints() const;
    Common::Array<Common::Point> &modifyPolyPoints();
 
    bool isDirty() const;
    void clearDirty();
 
    VisualElementRenderProperties &operator=(const VisualElementRenderProperties &other);
 
private:
    InkMode _inkMode;
    Shape _shape;
    ColorRGB8 _foreColor;
    ColorRGB8 _backColor;
    uint16 _borderSize;
    ColorRGB8 _borderColor;
    uint16 _shadowSize;
    ColorRGB8 _shadowColor;
 
    Common::Array<Common::Point> _polyPoints;
 
    bool _isDirty;
};
 
class VisualElement : public Element {
public:
    VisualElement();
 
    bool isVisual() const override;
    virtual bool isTextLabel() const;
 
    struct VisualElementConsumeCommandCoroutine {
        CORO_DEFINE_RETURN_TYPE(void);
        CORO_DEFINE_PARAMS_3(VisualElement *, self, Runtime *, runtime, Common::SharedPtr<MessageProperties>, msg);
    };
 
    VThreadState asyncConsumeCommand(Runtime *runtime, const Common::SharedPtr<MessageProperties> &msg) override;
 
    bool respondsToEvent(const Event &evt) const override;
    VThreadState consumeMessage(Runtime *runtime, const Common::SharedPtr<MessageProperties> &msg) override;
 
    bool isVisible() const;
    bool isVisibleByDefault() const;
    void setVisible(Runtime *runtime, bool visible);
 
    bool isDirectToScreen() const;
    void setDirectToScreen(bool directToScreen);
 
    uint16 getLayer() const;
    void setLayer(uint16 layer);
 
    bool isMouseInsideDrawableArea(int32 relativeX, int32 relativeY) const;
 
    // Returns true if there is mouse collision at a specified point, assuming it has already passed isMouseInsideBox
    virtual bool isMouseCollisionAtPoint(int32 relativeX, int32 relativeY) const;
 
    bool readAttribute(MiniscriptThread *thread, DynamicValue &result, const Common::String &attrib) override;
    MiniscriptInstructionOutcome writeRefAttribute(MiniscriptThread *thread, DynamicValueWriteProxy &writeProxy, const Common::String &attrib) override;
 
    Common::Point getParentOrigin() const;
    Common::Point getGlobalPosition() const;
    const Common::Rect &getRelativeRect() const;
    virtual Common::Rect getRelativeCollisionRect() const;
 
    void setRelativeRect(const Common::Rect &rect);
 
    // The cached absolute origin is from the last time the element was rendered.
    // Do not rely on it mid-frame.
    const Common::Point &getCachedAbsoluteOrigin() const;
    void setCachedAbsoluteOrigin(const Common::Point &absOrigin);
 
    void setDragMotionProperties(const Common::SharedPtr<DragMotionProperties> &dragProps);
    const Common::SharedPtr<DragMotionProperties> &getDragMotionProperties() const;
 
    void handleDragMotion(Runtime *runtime, const Common::Point &initialOrigin, const Common::Point &targetOrigin);
 
    struct OffsetTranslateTaskData {
        OffsetTranslateTaskData() : dx(0), dy(0) {}
 
        int32 dx;
        int32 dy;
    };
 
    VThreadState offsetTranslateTask(const OffsetTranslateTaskData &data);
 
    void setRenderProperties(const VisualElementRenderProperties &props, const Common::WeakPtr<GraphicModifier> &primaryGraphicModifier);
    const VisualElementRenderProperties &getRenderProperties() const;
    const Common::WeakPtr<GraphicModifier> &getPrimaryGraphicModifier() const;
 
    void setShading(int16 topLeftBevelShading, int16 bottomRightBevelShading, int16 interiorShading, uint32 bevelSize);
 
    void setTransitionProperties(const VisualElementTransitionProperties &props);
    const VisualElementTransitionProperties &getTransitionProperties() const;
 
    bool needsRender() const;
    virtual void render(Window *window) = 0;
    void finalizeRender();
 
    void setPalette(const Common::SharedPtr<Palette> &palette);
    const Common::SharedPtr<Palette> &getPalette() const;
 
    void visitInternalReferences(IStructuralReferenceVisitor *visitor) override;
 
    void pushVisibilityChangeTask(Runtime *runtime, bool desiredVisibility);
 
#ifdef MTROPOLIS_DEBUG_ENABLE
    void debugInspect(IDebugInspectionReport *report) const override;
#endif
 
protected:
    VisualElement(const VisualElement &other);
 
    bool loadCommon(const Common::String &name, uint32 guid, const Data::Rect &rect, uint32 elementFlags, uint16 layer, uint32 streamLocator, uint16 sectionID);
 
    MiniscriptInstructionOutcome scriptSetDirect(MiniscriptThread *thread, const DynamicValue &dest);
    MiniscriptInstructionOutcome scriptSetPosition(MiniscriptThread *thread, const DynamicValue &dest);
    MiniscriptInstructionOutcome scriptSetPositionX(MiniscriptThread *thread, const DynamicValue &dest);
    MiniscriptInstructionOutcome scriptSetPositionY(MiniscriptThread *thread, const DynamicValue &dest);
    MiniscriptInstructionOutcome scriptSetCenterPosition(MiniscriptThread *thread, const DynamicValue &dest);
    MiniscriptInstructionOutcome scriptSetCenterPositionX(MiniscriptThread *thread, const DynamicValue &dest);
    MiniscriptInstructionOutcome scriptSetCenterPositionY(MiniscriptThread *thread, const DynamicValue &dest);
    MiniscriptInstructionOutcome scriptSetVisibility(MiniscriptThread *thread, const DynamicValue &result);
    MiniscriptInstructionOutcome scriptSetSize(MiniscriptThread *thread, const DynamicValue &dest);
    MiniscriptInstructionOutcome scriptSetWidth(MiniscriptThread *thread, const DynamicValue &dest);
    MiniscriptInstructionOutcome scriptSetHeight(MiniscriptThread *thread, const DynamicValue &dest);
    MiniscriptInstructionOutcome scriptSetLayer(MiniscriptThread *thread, const DynamicValue &dest);
 
    MiniscriptInstructionOutcome scriptWriteRefPositionAttribute(MiniscriptThread *thread, DynamicValueWriteProxy &writeProxy, const Common::String &attrib);
    MiniscriptInstructionOutcome scriptWriteRefSizeAttribute(MiniscriptThread *thread, DynamicValueWriteProxy &writeProxy, const Common::String &attrib);
    MiniscriptInstructionOutcome scriptWriteRefCenterPositionAttribute(MiniscriptThread *thread, DynamicValueWriteProxy &writeProxy, const Common::String &attrib);
 
    void offsetTranslate(int32 xDelta, int32 yDelta, bool cachedOriginOnly);
    void resize(int32 width, int32 height);
 
    Common::Point getCenterPosition() const;
 
    struct ChangeVisibilityCoroutine {
        CORO_DEFINE_RETURN_TYPE(void);
        CORO_DEFINE_PARAMS_3(VisualElement *, self, Runtime *, runtime, bool, desiredFlag);
    };
 
    struct ChangeFlagTaskData {
        ChangeFlagTaskData() : desiredFlag(false), runtime(nullptr) {}
 
        bool desiredFlag;
        Runtime *runtime;
    };
 
    VThreadState changeVisibilityTask(const ChangeFlagTaskData &taskData);
 
    static VisualElement *recursiveFindItemWithLayer(VisualElement *element, int32 layer);
 
    void renderShading(Graphics::Surface &surf) const;
 
    static uint32 quantizeShading(uint32 mask, int16 shading);
 
    static void renderShadingScanlineDynamic(void *data, size_t numElements, uint32 rMask, uint32 rAdd, uint32 gMask, uint32 gAdd, uint32 bMask, uint32 bAdd, bool isBrighten, byte bytesPerPixel);
 
    template<class TElement>
    static void renderBrightenScanline(TElement *element, size_t numElements, TElement rMask, TElement rAdd, TElement gMask, TElement gAdd, TElement bMask, TElement bAdd);
 
    template<class TElement>
    static void renderDarkenScanline(TElement *element, size_t numElements, TElement rMask, TElement rSub, TElement gMask, TElement gSub, TElement bMask, TElement bSub);
 
    bool _directToScreen;
    bool _visible;
    bool _visibleByDefault;
    Common::Rect _rect;
    Common::Point _cachedAbsoluteOrigin;
    uint16 _layer;
 
    int16 _topLeftBevelShading;
    int16 _bottomRightBevelShading;
    int16 _interiorShading;
    uint32 _bevelSize;
 
    Common::SharedPtr<DragMotionProperties> _dragProps;
 
    // Quirk: When a graphic modifier is applied, it becomes the primary graphic modifier, and disabling it
    // will only take effect if it's the primary graphic modifier.
    VisualElementRenderProperties _renderProps;
    Common::WeakPtr<GraphicModifier> _primaryGraphicModifier;
 
    VisualElementTransitionProperties _transitionProps;
 
    Common::SharedPtr<Palette> _palette;
 
    Common::Rect _prevRect;
    bool _contentsDirty;
};
 
class NonVisualElement : public Element {
public:
    bool isVisual() const override;
 
    bool loadCommon(const Common::String &name, uint32 guid, uint32 elementFlags);
 
    typedef ElementConsumeCommandCoroutine NonVisualElementConsumeCommandCoroutine;
};
 
struct ModifierFlags {
    ModifierFlags();
    bool load(const uint32 dataModifierFlags);
 
    bool isLastModifier : 1;
    bool flagsWereLoaded : 1;
};
 
class ModifierSaveLoad {
public:
    virtual ~ModifierSaveLoad();
 
    void save(Modifier *modifier, Common::WriteStream *stream);
    bool load(Modifier *modifier, Common::ReadStream *stream, uint32 saveFileVersion);
    virtual void commitLoad() const = 0;
 
protected:
    // Saves the modifier state to a stream
    virtual void saveInternal(Common::WriteStream *stream) const = 0;
 
    // Loads the modifier state from a stream into the save/load state and returns true
    // if successful.  This will not trigger any actual changes until "commit" is called.
    virtual bool loadInternal(Common::ReadStream *stream, uint32 saveFileVersion) = 0;
};
 
class ModifierHooks {
public:
    virtual ~ModifierHooks();
 
    virtual void onCreate(Modifier *modifier);
};
 
class Modifier : public RuntimeObject, public IMessageConsumer, public Debuggable {
public:
    Modifier();
    virtual ~Modifier();
 
    bool readAttribute(MiniscriptThread *thread, DynamicValue &result, const Common::String &attrib) override;
    MiniscriptInstructionOutcome writeRefAttribute(MiniscriptThread *thread, DynamicValueWriteProxy &writeProxy, const Common::String &attrib) override;
 
    void materialize(Runtime *runtime, ObjectLinkingScope *outerScope);
 
    virtual bool isAlias() const;
    virtual bool isVariable() const;
    virtual bool isBehavior() const;
    virtual bool isCompoundVariable() const;
    virtual bool isKeyboardMessenger() const;
    virtual Common::SharedPtr<ModifierSaveLoad> getSaveLoad(Runtime *runtime);
 
    bool isModifier() const override;
 
    // This should only return a propagation container if messages should actually be propagated (i.e. NOT switched-off behaviors!)
    virtual IModifierContainer *getMessagePropagationContainer();
    virtual IModifierContainer *getChildContainer();
 
    const Common::WeakPtr<RuntimeObject> &getParent() const;
    void setParent(const Common::WeakPtr<RuntimeObject> &parent);
 
    Modifier *findNextSibling() const;
    Modifier *findPrevSibling() const;
 
    bool respondsToEvent(const Event &evt) const override;
    VThreadState consumeMessage(Runtime *runtime, const Common::SharedPtr<MessageProperties> &msg) override;
 
    void setName(const Common::String &name);
    const Common::String &getName() const;
 
    const ModifierFlags &getModifierFlags() const;
 
    // Shallow clones only need to copy the object.  Descendent copies are done using visitInternalReferences.
    virtual Common::SharedPtr<Modifier> shallowClone() const = 0;
 
    // Returns the default name of the modifier.  This isn't optional: It can cause behavioral changes, e.g.
    // Obsidian depends on this working properly to resolve the TextWork modifier in the Piazza.
    virtual const char *getDefaultName() const = 0;
 
    // Visits any internal references in the object.
    // Any references to other elements owned by the object MUST be SharedPtr, any references to non-owned objects
    // MUST be WeakPtr, in order for the cloning and materialization logic to work correctly.
    virtual void visitInternalReferences(IStructuralReferenceVisitor *visitor);
 
    bool loadPlugInHeader(const PlugInModifierLoaderContext &plugInContext);
 
    void recursiveCollectObjectsMatchingCriteria(Common::Array<Common::WeakPtr<RuntimeObject> > &results, bool (*evalFunc)(void *userData, RuntimeObject *object), void *userData, bool onlyEnabled);
 
    Structural *findStructuralOwner() const;
 
    void setHooks(const Common::SharedPtr<ModifierHooks> &hooks);
    const Common::SharedPtr<ModifierHooks> &getHooks() const;
 
    // Recursively disable due to containing behavior being disabled
    virtual void disable(Runtime *runtime) = 0;
 
#ifdef MTROPOLIS_DEBUG_ENABLE
    SupportStatus debugGetSupportStatus() const override;
    const Common::String &debugGetName() const override;
    void debugInspect(IDebugInspectionReport *report) const override;
#endif
 
protected:
    bool loadTypicalHeader(const Data::TypicalModifierHeader &typicalHeader);
 
    // Links any references contained in the object, resolving static GUIDs to runtime object references.
    // If you override this, you should override visitInternalReferences too
    virtual void linkInternalReferences(ObjectLinkingScope *scope);
 
    Common::String _name;
    ModifierFlags _modifierFlags;
    Common::WeakPtr<RuntimeObject> _parent;
 
    Common::SharedPtr<ModifierHooks> _hooks;
};
 
class VariableStorage {
public:
    virtual ~VariableStorage();
    virtual Common::SharedPtr<ModifierSaveLoad> getSaveLoad(Runtime *runtime) = 0;
 
    virtual Common::SharedPtr<VariableStorage> clone() const = 0;
};
 
class VariableModifier : public Modifier {
public:
    explicit VariableModifier(const Common::SharedPtr<VariableStorage> &storage);
    VariableModifier(const VariableModifier &other);
 
    virtual bool isVariable() const override;
    virtual bool isListVariable() const;
 
    virtual Common::SharedPtr<ModifierSaveLoad> getSaveLoad(Runtime *runtime) override final;
 
    const Common::SharedPtr<VariableStorage> &getStorage() const;
    void setStorage(const Common::SharedPtr<VariableStorage> &storage);
 
    virtual bool varSetValue(MiniscriptThread *thread, const DynamicValue &value) = 0;
    virtual void varGetValue(DynamicValue &dest) const = 0;
 
    bool readAttribute(MiniscriptThread *thread, DynamicValue &result, const Common::String &attrib) override;
 
    void disable(Runtime *runtime) override;
 
    virtual DynamicValueWriteProxy createWriteProxy();
 
#ifdef MTROPOLIS_DEBUG_ENABLE
    void debugInspect(IDebugInspectionReport *report) const override;
#endif
 
private:
    VariableModifier() = delete;
 
    struct WriteProxyInterface {
        static MiniscriptInstructionOutcome write(MiniscriptThread *thread, const DynamicValue &dest, void *objectRef, uintptr ptrOrOffset);
        static MiniscriptInstructionOutcome refAttrib(MiniscriptThread *thread, DynamicValueWriteProxy &proxy, void *objectRef, uintptr ptrOrOffset, const Common::String &attrib);
        static MiniscriptInstructionOutcome refAttribIndexed(MiniscriptThread *thread, DynamicValueWriteProxy &proxy, void *objectRef, uintptr ptrOrOffset, const Common::String &attrib, const DynamicValue &index);
    };
 
protected:
    Common::SharedPtr<VariableStorage> _storage;
};
 
enum AssetType {
    kAssetTypeNone,
 
    kAssetTypeMovie,
    kAssetTypeAudio,
    kAssetTypeColorTable,
    kAssetTypeImage,
    kAssetTypeText,
    kAssetTypeMToon,
    kAssetTypeAVIMovie,
};
 
class AssetHooks {
public:
    virtual ~AssetHooks();
 
    virtual void onLoaded(Asset *asset, const Common::String &name);
};
 
class Asset {
public:
    Asset();
    virtual ~Asset();
 
    uint32 getAssetID() const;
 
    virtual AssetType getAssetType() const = 0;
 
protected:
    uint32 _assetID;
};
 
 
} // End of namespace MTropolis
 
#endif