/* 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_MODIFIERS_H
#define MTROPOLIS_MODIFIERS_H

#include "common/events.h"

#include "mtropolis/render.h"
#include "mtropolis/runtime.h"
#include "mtropolis/data.h"

namespace MTropolis {

struct AudioMetadata;
class AudioPlayer;
class CachedAudio;
struct ModifierLoaderContext;
class MiniscriptProgram;
class MiniscriptReferences;
class MiniscriptThread;

class BehaviorModifier : public Modifier, public IModifierContainer {
public:
	BehaviorModifier();

	bool load(ModifierLoaderContext &context, const Data::BehaviorModifier &data);

	bool isBehavior() const override { return true; }

	const Common::Array<Common::SharedPtr<Modifier> > &getModifiers() const override;
	void appendModifier(const Common::SharedPtr<Modifier> &modifier) override;
	void removeModifier(const Modifier *modifier) override;

	IModifierContainer *getMessagePropagationContainer() override;
	IModifierContainer *getChildContainer() override;

	bool respondsToEvent(const Event &evt) const override;
	VThreadState consumeMessage(Runtime *runtime, const Common::SharedPtr<MessageProperties> &msg) override;
	void disable(Runtime *runtime) override;

#ifdef MTROPOLIS_DEBUG_ENABLE
	const char *debugGetTypeName() const override { return "Behavior Modifier"; }
	SupportStatus debugGetSupportStatus() const override { return kSupportStatusDone; }
	void debugInspect(IDebugInspectionReport *report) const override;
#endif

private:
	struct SwitchTaskData {
		SwitchTaskData() : targetState(false), eventID(EventIDs::kNothing), runtime(nullptr) {}

		bool targetState;
		EventIDs::EventID eventID;
		Runtime *runtime;
	};

	struct PropagateTaskData {
		PropagateTaskData() : index(0), eventID(EventIDs::kNothing), runtime(nullptr) {}

		size_t index;
		EventIDs::EventID eventID;
		Runtime *runtime;
	};

	struct DisableTaskData {
		DisableTaskData() : runtime(nullptr) {}

		Runtime *runtime;
	};

	VThreadState switchTask(const SwitchTaskData &taskData);
	VThreadState propagateTask(const PropagateTaskData &taskData);
	VThreadState disableTask(const DisableTaskData &taskData);

	Common::SharedPtr<Modifier> shallowClone() const override;
	const char *getDefaultName() const override;
	void linkInternalReferences(ObjectLinkingScope *scope) override;
	void visitInternalReferences(IStructuralReferenceVisitor *visitor) override;

	Common::Array<Common::SharedPtr<Modifier> > _children;

	Event _enableWhen;
	Event _disableWhen;
	bool _switchable;
	bool _isEnabled;
};

class MiniscriptModifier : public Modifier {
public:
	bool load(ModifierLoaderContext &context, const Data::MiniscriptModifier &data);

	bool respondsToEvent(const Event &evt) const override;
	VThreadState consumeMessage(Runtime *runtime, const Common::SharedPtr<MessageProperties> &msg) override;

	void disable(Runtime *runtime) override {}

#ifdef MTROPOLIS_DEBUG_ENABLE
	const char *debugGetTypeName() const override { return "Miniscript Modifier"; }
	SupportStatus debugGetSupportStatus() const override { return kSupportStatusDone; }
#endif

private:
	Common::SharedPtr<Modifier> shallowClone() const override;
	const char *getDefaultName() const override;
	void linkInternalReferences(ObjectLinkingScope *scope) override;
	void visitInternalReferences(IStructuralReferenceVisitor *visitor) override;

	Event _enableWhen;

	Common::SharedPtr<MiniscriptProgram> _program;
	Common::SharedPtr<MiniscriptReferences> _references;
};

class ColorTableModifier : public Modifier {
public:
	ColorTableModifier();

	bool load(ModifierLoaderContext &context, const Data::ColorTableModifier &data);

	bool respondsToEvent(const Event &evt) const override;
	VThreadState consumeMessage(Runtime *runtime, const Common::SharedPtr<MessageProperties> &msg) override;

	void disable(Runtime *runtime) override {}

#ifdef MTROPOLIS_DEBUG_ENABLE
	const char *debugGetTypeName() const override { return "Color Table Modifier"; }
	SupportStatus debugGetSupportStatus() const override { return kSupportStatusDone; }
#endif

private:
	Common::SharedPtr<Modifier> shallowClone() const override;
	const char *getDefaultName() const override;

	Event _applyWhen;

	uint32 _assetID;
};

class SoundFadeModifier : public Modifier {
public:
	SoundFadeModifier();

	bool load(ModifierLoaderContext &context, const Data::SoundFadeModifier &data);

	bool respondsToEvent(const Event &evt) const override;
	VThreadState consumeMessage(Runtime *runtime, const Common::SharedPtr<MessageProperties> &msg) override;

	void disable(Runtime *runtime) override {}

#ifdef MTROPOLIS_DEBUG_ENABLE
	const char *debugGetTypeName() const override { return "Sound Fade Modifier"; }
	SupportStatus debugGetSupportStatus() const override { return kSupportStatusNone; }
#endif

private:
	Common::SharedPtr<Modifier> shallowClone() const override;
	const char *getDefaultName() const override;

	Event _enableWhen;
	Event _disableWhen;

	uint16 _fadeToVolume;
	uint32 _durationMSec;
};

class SaveAndRestoreModifier : public Modifier {
public:
	bool load(ModifierLoaderContext &context, const Data::SaveAndRestoreModifier &data);

	bool respondsToEvent(const Event &evt) const override;
	VThreadState consumeMessage(Runtime *runtime, const Common::SharedPtr<MessageProperties> &msg) override;

	void disable(Runtime *runtime) override {}

#ifdef MTROPOLIS_DEBUG_ENABLE
	const char *debugGetTypeName() const override { return "Save And Restore Modifier"; }
	SupportStatus debugGetSupportStatus() const override { return kSupportStatusDone; }
#endif

protected:
	void linkInternalReferences(ObjectLinkingScope *scope) override;
	void visitInternalReferences(IStructuralReferenceVisitor *visitor) override;

private:
	Common::SharedPtr<Modifier> shallowClone() const override;
	const char *getDefaultName() const override;

	Event _saveWhen;
	Event _restoreWhen;

	DynamicValueSource _saveOrRestoreValue;

	Common::String _filePath;
	Common::String _fileName;
};

class MessengerModifier : public Modifier {
public:
	bool load(ModifierLoaderContext &context, const Data::MessengerModifier &data);

	bool respondsToEvent(const Event &evt) const override;
	VThreadState consumeMessage(Runtime *runtime, const Common::SharedPtr<MessageProperties> &msg) override;

	void disable(Runtime *runtime) override {}

	void linkInternalReferences(ObjectLinkingScope *outerScope) override;
	void visitInternalReferences(IStructuralReferenceVisitor *visitor) override;

#ifdef MTROPOLIS_DEBUG_ENABLE
	const char *debugGetTypeName() const override { return "Messenger Modifier"; }
	SupportStatus debugGetSupportStatus() const override { return kSupportStatusDone; }
#endif

private:
	Common::SharedPtr<Modifier> shallowClone() const override;
	const char *getDefaultName() const override;

	Event _when;
	MessengerSendSpec _sendSpec;
};

class SetModifier : public Modifier {
public:
	bool load(ModifierLoaderContext &context, const Data::SetModifier &data);

	bool respondsToEvent(const Event &evt) const override;
	VThreadState consumeMessage(Runtime *runtime, const Common::SharedPtr<MessageProperties> &msg) override;

	void disable(Runtime *runtime) override {}

	void linkInternalReferences(ObjectLinkingScope *outerScope) override;
	void visitInternalReferences(IStructuralReferenceVisitor *visitor) override;

#ifdef MTROPOLIS_DEBUG_ENABLE
	const char *debugGetTypeName() const override { return "Set Modifier"; }
	SupportStatus debugGetSupportStatus() const override { return kSupportStatusDone; }
#endif

private:
	Common::SharedPtr<Modifier> shallowClone() const override;
	const char *getDefaultName() const override;

	Event _executeWhen;
	DynamicValueSource _source;
	DynamicValueSource _target;
};

class AliasModifier : public Modifier {
public:
	AliasModifier();

	bool load(ModifierLoaderContext &context, const Data::AliasModifier &data);
	uint32 getAliasID() const;

	bool isAlias() const override;

	void disable(Runtime *runtime) override {}

#ifdef MTROPOLIS_DEBUG_ENABLE
	const char *debugGetTypeName() const override { return "Alias Modifier"; }
	SupportStatus debugGetSupportStatus() const override { return kSupportStatusDone; }
#endif

private:
	Common::SharedPtr<Modifier> shallowClone() const override;
	const char *getDefaultName() const override;

	uint32 _aliasID;
};

class ChangeSceneModifier : public Modifier {
public:
	bool load(ModifierLoaderContext &context, const Data::ChangeSceneModifier &data);

	bool respondsToEvent(const Event &evt) const override;
	VThreadState consumeMessage(Runtime *runtime, const Common::SharedPtr<MessageProperties> &msg) override;

	void disable(Runtime *runtime) override {}

#ifdef MTROPOLIS_DEBUG_ENABLE
	const char *debugGetTypeName() const override { return "Change Scene Modifier"; }
	SupportStatus debugGetSupportStatus() const override { return kSupportStatusDone; }
#endif

private:
	Common::SharedPtr<Modifier> shallowClone() const override;
	const char *getDefaultName() const override;

	enum SceneSelectionType {
		kSceneSelectionTypeNext,
		kSceneSelectionTypePrevious,
		kSceneSelectionTypeSpecific,
	};

	Event _executeWhen;
	SceneSelectionType _sceneSelectionType;
	uint32 _targetSectionGUID;
	uint32 _targetSubsectionGUID;
	uint32 _targetSceneGUID;
	bool _addToReturnList;
	bool _addToDestList;
	bool _wrapAround;
};

class SoundEffectModifier : public Modifier {
public:
	SoundEffectModifier();

	bool load(ModifierLoaderContext &context, const Data::SoundEffectModifier &data);

	bool respondsToEvent(const Event &evt) const override;
	VThreadState consumeMessage(Runtime *runtime, const Common::SharedPtr<MessageProperties> &msg) override;
	void disable(Runtime *runtime) override;

#ifdef MTROPOLIS_DEBUG_ENABLE
	const char *debugGetTypeName() const override { return "Sound Effect Modifier"; }
	SupportStatus debugGetSupportStatus() const override { return kSupportStatusDone; }
#endif

private:
	Common::SharedPtr<Modifier> shallowClone() const override;
	const char *getDefaultName() const override;

	enum SoundType {
		kSoundTypeBeep,
		kSoundTypeAudioAsset,
	};

	void loadAndCacheAudio(Runtime *runtime);

	Event _executeWhen;
	Event _terminateWhen;

	SoundType _soundType;
	uint32 _assetID;

	Common::SharedPtr<CachedAudio> _cachedAudio;
	Common::SharedPtr<AudioMetadata> _metadata;
	Common::SharedPtr<AudioPlayer> _player;
};

class PathMotionModifier : public Modifier {
public:
	PathMotionModifier();
	~PathMotionModifier();

	bool load(ModifierLoaderContext &context, const Data::PathMotionModifier &data);

	bool respondsToEvent(const Event &evt) const override;
	VThreadState consumeMessage(Runtime *runtime, const Common::SharedPtr<MessageProperties> &msg) override;
	void disable(Runtime *runtime) override;

	void linkInternalReferences(ObjectLinkingScope *scope) override;
	void visitInternalReferences(IStructuralReferenceVisitor *visitor) override;

#ifdef MTROPOLIS_DEBUG_ENABLE
	const char *debugGetTypeName() const override { return "Path Motion Modifier"; }
	SupportStatus debugGetSupportStatus() const override { return kSupportStatusPartial; }
#endif

private:
	struct PointDef {
		PointDef();

		Common::Point point;
		uint32 frame;
		bool useFrame;

		MessengerSendSpec sendSpec;
	};

	struct ExecuteTaskData {
		ExecuteTaskData() : runtime(nullptr) {}

		Runtime *runtime;
	};

	struct TerminateTaskData {
		TerminateTaskData() : runtime(nullptr) {}

		Runtime *runtime;
	};

	struct ChangePointsTaskData {
		ChangePointsTaskData() : runtime(nullptr), prevPoint(0), newPoint(0), isTerminal(false) {}

		Runtime *runtime;
		uint prevPoint;
		uint newPoint;
		bool isTerminal;
	};

	struct TriggerMessageTaskData {
		TriggerMessageTaskData() : runtime(nullptr), pointIndex(0) {}

		Runtime *runtime;
		uint pointIndex;
	};

	struct SendMessageToParentTaskData {
		SendMessageToParentTaskData() : runtime(nullptr), eventID(EventIDs::kNothing) {}

		Runtime *runtime;
		EventIDs::EventID eventID;
	};

	struct ChangeCelTaskData {
		ChangeCelTaskData() : runtime(nullptr), pointIndex(0) {}

		Runtime *runtime;
		uint pointIndex;
	};

	struct ChangePositionTaskData {
		ChangePositionTaskData() : runtime(nullptr) {}

		Runtime *runtime;
		Common::Point positionDelta;
	};

	struct AdvanceFrameTaskData {
		AdvanceFrameTaskData() : runtime(nullptr), terminationTimeDUSec(0) {}

		Runtime *runtime;
		uint64 terminationTimeDUSec;
	};

	VThreadState executeTask(const ExecuteTaskData &taskData);
	VThreadState terminateTask(const TerminateTaskData &taskData);
	VThreadState changePointsTask(const ChangePointsTaskData &taskData);
	VThreadState triggerMessageTask(const TriggerMessageTaskData &taskData);
	VThreadState sendMessageToParentTask(const SendMessageToParentTaskData &taskData);
	VThreadState changeCelTask(const ChangeCelTaskData &taskData);
	VThreadState changePositionTask(const ChangePositionTaskData &taskData);
	VThreadState advanceFrameTask(const AdvanceFrameTaskData &taskData);

	void scheduleNextAdvance(Runtime *runtime, uint64 startingFromTimeDUSec);
	void advance(Runtime *runtime);

	Common::SharedPtr<Modifier> shallowClone() const override;
	const char *getDefaultName() const override;

	Event _executeWhen;
	Event _terminateWhen;

	bool _reverse;
	bool _loop;
	bool _alternate;
	bool _startAtBeginning;

	uint64 _frameDurationDUSec;

	Common::Array<PointDef> _points;

	DynamicValue _incomingData;

	Common::WeakPtr<RuntimeObject> _triggerSource;
	Common::SharedPtr<ScheduledEvent> _scheduledEvent;
	bool _isAlternatingDirection;
	uint _currentPointIndex;
	uint64 _lastPointTimeDUSec;
};

class SimpleMotionModifier : public Modifier {
public:
	SimpleMotionModifier();
	~SimpleMotionModifier();

	bool load(ModifierLoaderContext &context, const Data::SimpleMotionModifier &data);

	bool respondsToEvent(const Event &evt) const override;
	VThreadState consumeMessage(Runtime *runtime, const Common::SharedPtr<MessageProperties> &msg) override;
	void disable(Runtime *runtime) override;

#ifdef MTROPOLIS_DEBUG_ENABLE
	const char *debugGetTypeName() const override { return "Simple Motion Modifier"; }
	SupportStatus debugGetSupportStatus() const override { return kSupportStatusNone; }
#endif

private:
	enum MotionType {
		kMotionTypeOutOfScene = 1,
		kMotionTypeIntoScene = 2,
		kMotionTypeRandomBounce = 3,
	};

	enum DirectionFlags {
		kDirectionFlagDown = 1,
		kDirectionFlagUp = 2,
		kDirectionFlagRight = 4,
		kDirectionFlagLeft = 8,
	};

	void startRandomBounce(Runtime *runtime);
	void runRandomBounce(Runtime *runtime);

	Common::SharedPtr<Modifier> shallowClone() const override;
	const char *getDefaultName() const override;

	Event _executeWhen;
	Event _terminateWhen;

	MotionType _motionType;
	uint16 _directionFlags;
	uint16 _steps;
	uint32 _delayMSecTimes4800;

	uint64 _lastTickTime;

	Common::Point _velocity;

	Common::SharedPtr<ScheduledEvent> _scheduledEvent;
};

class DragMotionModifier : public Modifier {
public:
	bool load(ModifierLoaderContext &context, const Data::DragMotionModifier &data);

	bool respondsToEvent(const Event &evt) const override;
	VThreadState consumeMessage(Runtime *runtime, const Common::SharedPtr<MessageProperties> &msg) override;
	void disable(Runtime *runtime) override;

#ifdef MTROPOLIS_DEBUG_ENABLE
	const char *debugGetTypeName() const override { return "Drag Motion Modifier"; }
	SupportStatus debugGetSupportStatus() const override { return kSupportStatusDone; }
#endif

private:
	Common::SharedPtr<Modifier> shallowClone() const override;
	const char *getDefaultName() const override;

	Event _enableWhen;
	Event _disableWhen;

	Common::SharedPtr<DragMotionProperties> _dragProps;
};

class VectorMotionModifier : public Modifier {
public:
	~VectorMotionModifier();

	bool load(ModifierLoaderContext &context, const Data::VectorMotionModifier &data);

	bool respondsToEvent(const Event &evt) const override;
	VThreadState consumeMessage(Runtime *runtime, const Common::SharedPtr<MessageProperties> &msg) override;
	void disable(Runtime *runtime) override;

#ifdef MTROPOLIS_DEBUG_ENABLE
	const char *debugGetTypeName() const override { return "Vector Modifier"; }
	SupportStatus debugGetSupportStatus() const override { return kSupportStatusDone; }
#endif

private:
	Common::SharedPtr<Modifier> shallowClone() const override;
	const char *getDefaultName() const override;
	void linkInternalReferences(ObjectLinkingScope *scope) override;
	void visitInternalReferences(IStructuralReferenceVisitor *visitor) override;

	void trigger(Runtime *runtime);

	Event _enableWhen;
	Event _disableWhen;

	DynamicValueSource _vec;

	AngleMagVector _resolvedVector;
	uint16 _subpixelX;
	uint16 _subpixelY;

	Common::SharedPtr<ScheduledEvent> _scheduledEvent;
	uint64 _lastTickTime;
};

class SceneTransitionModifier : public Modifier {
public:
	bool load(ModifierLoaderContext &context, const Data::SceneTransitionModifier &data);

	bool respondsToEvent(const Event &evt) const override;
	VThreadState consumeMessage(Runtime *runtime, const Common::SharedPtr<MessageProperties> &msg) override;
	void disable(Runtime *runtime) override;

#ifdef MTROPOLIS_DEBUG_ENABLE
	const char *debugGetTypeName() const override { return "Scene Transition Modifier"; }
	SupportStatus debugGetSupportStatus() const override { return kSupportStatusDone; }
#endif

private:
	Common::SharedPtr<Modifier> shallowClone() const override;
	const char *getDefaultName() const override;

	Event _enableWhen;
	Event _disableWhen;

	uint32 _duration;	// 6000000 is maximum
	uint16 _steps;
	SceneTransitionTypes::SceneTransitionType _transitionType;
	SceneTransitionDirections::SceneTransitionDirection _transitionDirection;
};

class ElementTransitionModifier : public Modifier {
public:
	ElementTransitionModifier();
	~ElementTransitionModifier();

	bool load(ModifierLoaderContext &context, const Data::ElementTransitionModifier &data);

	bool respondsToEvent(const Event &evt) const override;
	VThreadState consumeMessage(Runtime *runtime, const Common::SharedPtr<MessageProperties> &msg) override;
	void disable(Runtime *runtime) override;

	enum TransitionType {
		kTransitionTypeRectangularIris,
		kTransitionTypeOvalIris,
		kTransitionTypeZoom,
		kTransitionTypeFade,
	};

	enum RevealType {
		kRevealTypeReveal,
		kRevealTypeConceal,
	};

#ifdef MTROPOLIS_DEBUG_ENABLE
	const char *debugGetTypeName() const override { return "Element Transition Modifier"; }
	SupportStatus debugGetSupportStatus() const override { return kSupportStatusPartial; }
#endif

private:
	Common::SharedPtr<Modifier> shallowClone() const override;
	const char *getDefaultName() const override;

	void continueTransition(Runtime *runtime);
	void completeTransition(Runtime *runtime);

	void setTransitionProgress(uint32 steps, uint32 maxSteps);

	Event _enableWhen;
	Event _disableWhen;

	uint32 _rate;	// Steps per second
	uint16 _steps;
	TransitionType _transitionType;
	RevealType _revealType;

	uint64 _transitionStartTime;
	uint32 _currentStep;

	Common::SharedPtr<ScheduledEvent> _scheduledEvent;
};

class SharedSceneModifier : public Modifier {
public:
	SharedSceneModifier();
	~SharedSceneModifier();

	bool load(ModifierLoaderContext &context, const Data::SharedSceneModifier &data);

	bool respondsToEvent(const Event &evt) const override;
	VThreadState consumeMessage(Runtime *runtime, const Common::SharedPtr<MessageProperties> &msg) override;
	void disable(Runtime *runtime) override;

#ifdef MTROPOLIS_DEBUG_ENABLE
	const char *debugGetTypeName() const override { return "Shared Scene Modifier"; }
	SupportStatus debugGetSupportStatus() const override { return kSupportStatusDone; }
#endif

private:
	Common::SharedPtr<Modifier> shallowClone() const override;
	const char *getDefaultName() const override;

	Event _executeWhen;

	uint32 _targetSectionGUID;
	uint32 _targetSubsectionGUID;
	uint32 _targetSceneGUID;
};

class IfMessengerModifier : public Modifier {
public:
	bool load(ModifierLoaderContext &context, const Data::IfMessengerModifier &data);

	bool respondsToEvent(const Event &evt) const override;
	VThreadState consumeMessage(Runtime *runtime, const Common::SharedPtr<MessageProperties> &msg) override;
	void disable(Runtime *runtime) override {}

#ifdef MTROPOLIS_DEBUG_ENABLE
	const char *debugGetTypeName() const override { return "If Messenger Modifier"; }
	SupportStatus debugGetSupportStatus() const override { return kSupportStatusDone; }
#endif

private:
	struct RunEvaluateAndSendCoroutine {
		CORO_DEFINE_RETURN_TYPE(void);
		CORO_DEFINE_PARAMS_3(IfMessengerModifier *, self, Runtime *, runtime, Common::SharedPtr<MessageProperties>, msg);
	};

	Common::SharedPtr<Modifier> shallowClone() const override;
	const char *getDefaultName() const override;
	void linkInternalReferences(ObjectLinkingScope *scope) override;
	void visitInternalReferences(IStructuralReferenceVisitor *visitor) override;

	Event _when;
	MessengerSendSpec _sendSpec;

	Common::SharedPtr<MiniscriptProgram> _program;
	Common::SharedPtr<MiniscriptReferences> _references;
};

class TimerMessengerModifier : public Modifier {
public:
	TimerMessengerModifier();
	~TimerMessengerModifier();

	bool load(ModifierLoaderContext &context, const Data::TimerMessengerModifier &data);

	bool respondsToEvent(const Event &evt) const override;
	VThreadState consumeMessage(Runtime *runtime, const Common::SharedPtr<MessageProperties> &msg) override;
	void disable(Runtime *runtime) override;

	void linkInternalReferences(ObjectLinkingScope *outerScope) override;
	void visitInternalReferences(IStructuralReferenceVisitor *visitor) override;

#ifdef MTROPOLIS_DEBUG_ENABLE
	const char *debugGetTypeName() const override { return "Timer Messenger Modifier"; }
	SupportStatus debugGetSupportStatus() const override { return kSupportStatusDone; }
#endif

private:
	Common::SharedPtr<Modifier> shallowClone() const override;
	const char *getDefaultName() const override;

	void trigger(Runtime *runtime);

	Event _executeWhen;
	Event _terminateWhen;
	MessengerSendSpec _sendSpec;
	uint32 _milliseconds;
	bool _looping;
	DynamicValue _incomingData;

	Common::SharedPtr<ScheduledEvent> _scheduledEvent;
	Common::WeakPtr<RuntimeObject> _triggerSource;
};

class BoundaryDetectionMessengerModifier : public Modifier, public IBoundaryDetector {
public:
	BoundaryDetectionMessengerModifier();
	~BoundaryDetectionMessengerModifier();

	bool load(ModifierLoaderContext &context, const Data::BoundaryDetectionMessengerModifier &data);

	bool respondsToEvent(const Event &evt) const override;
	VThreadState consumeMessage(Runtime *runtime, const Common::SharedPtr<MessageProperties> &msg) override;
	void disable(Runtime *runtime) override;

	void linkInternalReferences(ObjectLinkingScope *outerScope) override;
	void visitInternalReferences(IStructuralReferenceVisitor *visitor) override;

	void getCollisionProperties(Modifier *&modifier, uint &edgeFlags, bool &mustBeCompletelyOutside, bool &continuous) const override;
	void triggerCollision(Runtime *runtime) override;

#ifdef MTROPOLIS_DEBUG_ENABLE
	const char *debugGetTypeName() const override { return "Boundary Detection Modifier"; }
#endif

private:
	Common::SharedPtr<Modifier> shallowClone() const override;
	const char *getDefaultName() const override;

	enum ExitTriggerMode {
		kExitTriggerExiting,
		kExitTriggerOnceExited,
	};

	enum DetectionMode {
		kContinuous,
		kOnFirstDetection,
	};

	Event _enableWhen;
	Event _disableWhen;
	ExitTriggerMode _exitTriggerMode;
	DetectionMode _detectionMode;
	bool _detectTopEdge;
	bool _detectBottomEdge;
	bool _detectLeftEdge;
	bool _detectRightEdge;
	MessengerSendSpec _send;

	Runtime *_runtime;
	bool _isActive;
	DynamicValue _incomingData;
	Common::WeakPtr<RuntimeObject> _triggerSource;
};

class CollisionDetectionMessengerModifier : public Modifier, public ICollider {
public:
	CollisionDetectionMessengerModifier();
	~CollisionDetectionMessengerModifier();

	bool load(ModifierLoaderContext &context, const Data::CollisionDetectionMessengerModifier &data);

	bool respondsToEvent(const Event &evt) const override;
	VThreadState consumeMessage(Runtime *runtime, const Common::SharedPtr<MessageProperties> &msg) override;
	void disable(Runtime *runtime) override;

	void linkInternalReferences(ObjectLinkingScope *scope) override;
	void visitInternalReferences(IStructuralReferenceVisitor *visitor) override;

#ifdef MTROPOLIS_DEBUG_ENABLE
	const char *debugGetTypeName() const override { return "Collision Detection Messenger Modifier"; }
	SupportStatus debugGetSupportStatus() const override { return kSupportStatusPartial; }
#endif

private:
	Common::SharedPtr<Modifier> shallowClone() const override;
	const char *getDefaultName() const override;

	struct EnableTaskData {
	};

	struct DisableTaskData {
	};

	VThreadState enableTask(const EnableTaskData &taskData);
	VThreadState disableTask(const DisableTaskData &taskData);

	void getCollisionProperties(Modifier *&modifier, bool &collideInFront, bool &collideBehind, bool &excludeParents) const override;
	void triggerCollision(Runtime *runtime, Structural *collidingElement, bool wasInContact, bool isInContact, bool &outShouldStop) override;

	enum DetectionMode {
		kDetectionModeFirstContact,
		kDetectionModeWhileInContact,
		kDetectionModeExiting,
	};

	Event _enableWhen;
	Event _disableWhen;
	MessengerSendSpec _sendSpec;

	DetectionMode _detectionMode;
	bool _detectInFront;
	bool _detectBehind;
	bool _ignoreParent;
	bool _sendToCollidingElement; // ... instead of to send spec destination, but send spec with/flags still apply!
	bool _sendToOnlyFirstCollidingElement;

	Runtime *_runtime;
	bool _isActive;

	DynamicValue _incomingData;
	Common::WeakPtr<RuntimeObject> _triggerSource;
};

class KeyboardMessengerModifier : public Modifier {
public:
	KeyboardMessengerModifier();
	~KeyboardMessengerModifier();

	bool isKeyboardMessenger() const override;

	bool load(ModifierLoaderContext &context, const Data::KeyboardMessengerModifier &data);

	bool respondsToEvent(const Event &evt) const override;
	VThreadState consumeMessage(Runtime *runtime, const Common::SharedPtr<MessageProperties> &msg) override;
	void disable(Runtime *runtime) override;

	bool checkKeyEventTrigger(Runtime *runtime, Common::EventType evtType, bool repeat, const Common::KeyState &keyEvt, Common::String &outChar) const;
	void dispatchMessage(Runtime *runtime, const Common::String &charStr);

#ifdef MTROPOLIS_DEBUG_ENABLE
	const char *debugGetTypeName() const override { return "Keyboard Messenger Modifier"; }
	SupportStatus debugGetSupportStatus() const override { return kSupportStatusDone; }
#endif

private:
	Common::SharedPtr<Modifier> shallowClone() const override;
	const char *getDefaultName() const override;

	void visitInternalReferences(IStructuralReferenceVisitor *visitor) override;
	void linkInternalReferences(ObjectLinkingScope *scope) override;

	enum KeyCodeType {
		kAny = 0x00,
		kHome = 0x01,
		kEnter = 0x03,
		kEnd = 0x04,
		kHelp = 0x05,
		kBackspace = 0x08,
		kTab = 0x09,
		kPageUp = 0x0b,
		kPageDown = 0x0c,
		kReturn = 0x0d,
		kEscape = 0x1b,
		kArrowLeft = 0x1c,
		kArrowRight = 0x1d,
		kArrowUp = 0x1e,
		kArrowDown = 0x1f,
		kDelete = 0x7f,
		kMacRomanChar = 0xff,
	};

	Event _send;

	bool _onDown : 1;
	bool _onUp : 1;
	bool _onRepeat : 1;
	bool _keyModControl : 1;
	bool _keyModCommand : 1;
	bool _keyModOption : 1;
	bool _isEnabled : 1;
	KeyCodeType _keyCodeType;
	char _macRomanChar;

	MessengerSendSpec _sendSpec;
};

class TextStyleModifier : public Modifier {
public:
	bool load(ModifierLoaderContext &context, const Data::TextStyleModifier &data);

	bool respondsToEvent(const Event &evt) const override;
	VThreadState consumeMessage(Runtime *runtime, const Common::SharedPtr<MessageProperties> &msg) override;
	void disable(Runtime *runtime) override;

#ifdef MTROPOLIS_DEBUG_ENABLE
	const char *debugGetTypeName() const override { return "Text Style Modifier"; }
#endif

private:
	Common::SharedPtr<Modifier> shallowClone() const override;
	const char *getDefaultName() const override;

	uint16 _macFontID;
	uint16 _size;
	ColorRGB8 _textColor;
	ColorRGB8 _backgroundColor;
	TextAlignment _alignment;
	TextStyleFlags _styleFlags;
	Event _applyWhen;
	Event _removeWhen;
	Common::String _fontFamilyName;
};

class GraphicModifier : public Modifier {
public:
	bool load(ModifierLoaderContext &context, const Data::GraphicModifier &data);

	bool respondsToEvent(const Event &evt) const override;
	VThreadState consumeMessage(Runtime *runtime, const Common::SharedPtr<MessageProperties> &msg) override;
	void disable(Runtime *runtime) override;

#ifdef MTROPOLIS_DEBUG_ENABLE
	const char *debugGetTypeName() const override { return "Graphic Modifier"; }
	SupportStatus debugGetSupportStatus() const override { return kSupportStatusDone; }
#endif

private:
	Common::SharedPtr<Modifier> shallowClone() const override;
	const char *getDefaultName() const override;

	Event _applyWhen;
	Event _removeWhen;

	VisualElementRenderProperties _renderProps;
};

class ImageEffectModifier : public Modifier {
public:
	ImageEffectModifier();

	bool load(ModifierLoaderContext &context, const Data::ImageEffectModifier &data);

	bool respondsToEvent(const Event &evt) const override;
	VThreadState consumeMessage(Runtime *runtime, const Common::SharedPtr<MessageProperties> &msg) override;
	void disable(Runtime *runtime) override;

#ifdef MTROPOLIS_DEBUG_ENABLE
	const char *debugGetTypeName() const override { return "Image Effect Modifier"; }
	SupportStatus debugGetSupportStatus() const override { return kSupportStatusNone; }
#endif

private:
	enum Type {
		kTypeUnknown = 0,

		kTypeInvert = 1,
		kTypeSelectedBevels,
		kTypeDeselectedBevels,
		kTypeToneDown,
		kTypeToneUp,
	};

	struct ApplyTaskData {
		ApplyTaskData() : runtime(nullptr) {}

		Runtime *runtime;
	};

	struct RemoveTaskData {
		RemoveTaskData() : runtime(nullptr) {}

		Runtime *runtime;
	};

	Common::SharedPtr<Modifier> shallowClone() const override;
	const char *getDefaultName() const override;

	VThreadState applyTask(const ApplyTaskData &taskData);
	VThreadState removeTask(const RemoveTaskData &taskData);

	Event _applyWhen;
	Event _removeWhen;
	Type _type;
	uint16 _bevelWidth;
	uint16 _toneAmount;
	bool _includeBorders;
};

class ReturnModifier : public Modifier {
public:
	ReturnModifier();

	bool load(ModifierLoaderContext &context, const Data::ReturnModifier &data);

	bool respondsToEvent(const Event &evt) const override;
	VThreadState consumeMessage(Runtime *runtime, const Common::SharedPtr<MessageProperties> &msg) override;
	void disable(Runtime *runtime) override;

#ifdef MTROPOLIS_DEBUG_ENABLE
	const char *debugGetTypeName() const override { return "Return Modifier"; }
	SupportStatus debugGetSupportStatus() const override { return kSupportStatusNone; }
#endif

private:
	Common::SharedPtr<Modifier> shallowClone() const override;
	const char *getDefaultName() const override;

	Event _executeWhen;
};

class CursorModifierV1 : public Modifier {
public:
	CursorModifierV1();

	bool load(ModifierLoaderContext &context, const Data::CursorModifierV1 &data);

	bool respondsToEvent(const Event &evt) const override;
	VThreadState consumeMessage(Runtime *runtime, const Common::SharedPtr<MessageProperties> &msg) override;
	void disable(Runtime *runtime) override;

#ifdef MTROPOLIS_DEBUG_ENABLE
	const char *debugGetTypeName() const override { return "Cursor Modifier V1"; }
	SupportStatus debugGetSupportStatus() const override { return kSupportStatusNone; }
#endif

private:
	enum {
		kCursor_Inactive,
		kCursor_Interact,
		kCursor_HandGrabBW,
		kCursor_HandOpenBW,
		kCursor_HandPointUp,
		kCursor_HandPointRight,
		kCursor_HandPointLeft,
		kCursor_HandPointDown,
		kCursor_HandGrabColor,
		kCursor_HandOpenColor,
		kCursor_Arrow,
		kCursor_Pencil,
		kCursor_Smiley,
		kCursor_Wait,
		kCursor_Hidden,
	};

	Common::SharedPtr<Modifier> shallowClone() const override;
	const char *getDefaultName() const override;

	Event _applyWhen;
	uint32 _cursorIndex;
};

// Compound variable modifiers are not true variable modifiers.
// They aren't treated as values by Miniscript and they aren't
// treated as unique objects by aliases.  The only way that
// they behave like variable modifiers is that it's legal to
// put them inside of CompoundVariableModifiers.
class CompoundVariableModifier : public Modifier, public IModifierContainer {
public:
	bool load(ModifierLoaderContext &context, const Data::CompoundVariableModifier &data);

	void disable(Runtime *runtime) override;

	Common::SharedPtr<ModifierSaveLoad> getSaveLoad(Runtime *runtime) override;

	IModifierContainer *getChildContainer() override;

	bool isCompoundVariable() const override { return true; }

#ifdef MTROPOLIS_DEBUG_ENABLE
	const char *debugGetTypeName() const override { return "Compound Variable Modifier"; }
	SupportStatus debugGetSupportStatus() const override { return kSupportStatusDone; }
#endif

private:
	class SaveLoad : public ModifierSaveLoad {
	public:
		SaveLoad(Runtime *runtime, CompoundVariableModifier *modifier);

		void saveInternal(Common::WriteStream *stream) const override;
		bool loadInternal(Common::ReadStream *stream, uint32 saveFileVersion) override;
		void commitLoad() const override;

	private:
		struct ChildSaveLoad {
			ChildSaveLoad();

			Modifier *modifier;
			Common::SharedPtr<ModifierSaveLoad> saveLoad;
		};

		Common::Array<ChildSaveLoad> _childrenSaveLoad;

		//CompoundVariableModifier *_modifier;
	};

	Common::SharedPtr<Modifier> shallowClone() const override;
	const char *getDefaultName() const override;

	const Common::Array<Common::SharedPtr<Modifier> > &getModifiers() const override;
	void appendModifier(const Common::SharedPtr<Modifier> &modifier) override;
	void removeModifier(const Modifier *modifier) override;
	void visitInternalReferences(IStructuralReferenceVisitor *visitor) override;

	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 &writeProxy, const Common::String &attrib) override;
	MiniscriptInstructionOutcome writeRefAttributeIndexed(MiniscriptThread *thread, DynamicValueWriteProxy &writeProxy, const Common::String &attrib, const DynamicValue &index) override;

	Modifier *findChildByName(Runtime *runtime, const Common::String &name) const;

	Common::Array<Common::SharedPtr<Modifier> > _children;
};

class BooleanVariableModifier : public VariableModifier {
public:
	BooleanVariableModifier();

	bool load(ModifierLoaderContext &context, const Data::BooleanVariableModifier &data);

	bool varSetValue(MiniscriptThread *thread, const DynamicValue &value) override;
	void varGetValue(DynamicValue &dest) const override;

#ifdef MTROPOLIS_DEBUG_ENABLE
	const char *debugGetTypeName() const override { return "Boolean Variable Modifier"; }
	SupportStatus debugGetSupportStatus() const override { return kSupportStatusDone; }
	void debugInspect(IDebugInspectionReport *report) const override;
#endif

private:
	Common::SharedPtr<Modifier> shallowClone() const override;
	const char *getDefaultName() const override;
};

class BooleanVariableStorage : public VariableStorage {
public:
	friend class BooleanVariableModifier;

	BooleanVariableStorage();

	Common::SharedPtr<ModifierSaveLoad> getSaveLoad(Runtime *runtime) override;

	Common::SharedPtr<VariableStorage> clone() const override;

private:
	class SaveLoad : public ModifierSaveLoad {
	public:
		explicit SaveLoad(BooleanVariableStorage *modifier);

	private:
		void commitLoad() const override;
		void saveInternal(Common::WriteStream *stream) const override;
		bool loadInternal(Common::ReadStream *stream, uint32 saveFileVersion) override;

		BooleanVariableStorage *_storage;
		bool _value;
	};

	bool _value;
};

class IntegerVariableModifier : public VariableModifier {
public:
	IntegerVariableModifier();

	bool load(ModifierLoaderContext &context, const Data::IntegerVariableModifier &data);

	bool varSetValue(MiniscriptThread *thread, const DynamicValue &value) override;
	void varGetValue(DynamicValue &dest) const override;

#ifdef MTROPOLIS_DEBUG_ENABLE
	const char *debugGetTypeName() const override { return "Integer Variable Modifier"; }
	SupportStatus debugGetSupportStatus() const override { return kSupportStatusDone; }
	void debugInspect(IDebugInspectionReport *report) const override;
#endif

private:
	Common::SharedPtr<Modifier> shallowClone() const override;
	const char *getDefaultName() const override;
};

class IntegerVariableStorage : public VariableStorage {
public:
	friend class IntegerVariableModifier;

	IntegerVariableStorage();

	Common::SharedPtr<ModifierSaveLoad> getSaveLoad(Runtime *runtime) override;

	Common::SharedPtr<VariableStorage> clone() const override;

private:
	class SaveLoad : public ModifierSaveLoad {
	public:
		explicit SaveLoad(IntegerVariableStorage *storage);

	private:
		void commitLoad() const override;
		void saveInternal(Common::WriteStream *stream) const override;
		bool loadInternal(Common::ReadStream *stream, uint32 saveFileVersion) override;

		IntegerVariableStorage *_storage;
		int32 _value;
	};

	int32 _value;
};

class IntegerRangeVariableModifier : public VariableModifier {
public:
	IntegerRangeVariableModifier();

	bool load(ModifierLoaderContext &context, const Data::IntegerRangeVariableModifier &data);

	bool varSetValue(MiniscriptThread *thread, const DynamicValue &value) override;
	void varGetValue(DynamicValue &dest) const override;

	bool readAttribute(MiniscriptThread *thread, DynamicValue &result, const Common::String &attrib) override;
	MiniscriptInstructionOutcome writeRefAttribute(MiniscriptThread *thread, DynamicValueWriteProxy &result, const Common::String &attrib) override;

#ifdef MTROPOLIS_DEBUG_ENABLE
	const char *debugGetTypeName() const override { return "Integer Range Variable Modifier"; }
	SupportStatus debugGetSupportStatus() const override { return kSupportStatusDone; }
	void debugInspect(IDebugInspectionReport *report) const override;
#endif

private:
	Common::SharedPtr<Modifier> shallowClone() const override;
	const char *getDefaultName() const override;
};

class IntegerRangeVariableStorage : public VariableStorage {
public:
	friend class IntegerRangeVariableModifier;

	IntegerRangeVariableStorage();

	Common::SharedPtr<ModifierSaveLoad> getSaveLoad(Runtime *runtime) override;

	Common::SharedPtr<VariableStorage> clone() const override;

private:
	class SaveLoad : public ModifierSaveLoad {
	public:
		explicit SaveLoad(IntegerRangeVariableStorage *storage);

	private:
		void commitLoad() const override;
		void saveInternal(Common::WriteStream *stream) const override;
		bool loadInternal(Common::ReadStream *stream, uint32 saveFileVersion) override;

		IntegerRangeVariableStorage *_storage;
		IntRange _range;
	};

	IntRange _range;
};

class VectorVariableModifier : public VariableModifier {
public:
	VectorVariableModifier();

	bool load(ModifierLoaderContext &context, const Data::VectorVariableModifier &data);

	bool varSetValue(MiniscriptThread *thread, const DynamicValue &value) override;
	void varGetValue(DynamicValue &dest) const override;

	bool readAttribute(MiniscriptThread *thread, DynamicValue &result, const Common::String &attrib) override;
	MiniscriptInstructionOutcome writeRefAttribute(MiniscriptThread *thread, DynamicValueWriteProxy &result, const Common::String &attrib) override;

#ifdef MTROPOLIS_DEBUG_ENABLE
	const char *debugGetTypeName() const override { return "Vector Variable Modifier"; }
	SupportStatus debugGetSupportStatus() const override { return kSupportStatusDone; }
	void debugInspect(IDebugInspectionReport *report) const override;
#endif

private:
	Common::SharedPtr<Modifier> shallowClone() const override;
	const char *getDefaultName() const override;
};

class VectorVariableStorage : public VariableStorage {
	friend class VectorVariableModifier;

	VectorVariableStorage();

	Common::SharedPtr<ModifierSaveLoad> getSaveLoad(Runtime *runtime) override;

	Common::SharedPtr<VariableStorage> clone() const override;

private:
	class SaveLoad : public ModifierSaveLoad {
	public:
		explicit SaveLoad(VectorVariableStorage *storage);

	private:
		void commitLoad() const override;
		void saveInternal(Common::WriteStream *stream) const override;
		bool loadInternal(Common::ReadStream *stream, uint32 saveFileVersion) override;

		VectorVariableStorage *_storage;
		AngleMagVector _vector;
	};

	AngleMagVector _vector;
};

class PointVariableModifier : public VariableModifier {
public:
	PointVariableModifier();

	bool load(ModifierLoaderContext &context, const Data::PointVariableModifier &data);

	bool varSetValue(MiniscriptThread *thread, const DynamicValue &value) override;
	void varGetValue(DynamicValue &dest) const override;

	bool readAttribute(MiniscriptThread *thread, DynamicValue &result, const Common::String &attrib) override;
	MiniscriptInstructionOutcome writeRefAttribute(MiniscriptThread *thread, DynamicValueWriteProxy &writeProxy, const Common::String &attrib) override;

#ifdef MTROPOLIS_DEBUG_ENABLE
	const char *debugGetTypeName() const override { return "Point Variable Modifier"; }
	SupportStatus debugGetSupportStatus() const override { return kSupportStatusDone; }
	void debugInspect(IDebugInspectionReport *report) const override;
#endif

private:
	Common::SharedPtr<Modifier> shallowClone() const override;
	const char *getDefaultName() const override;
};

class PointVariableStorage : public VariableStorage {
public:
	friend class PointVariableModifier;

	PointVariableStorage();

	Common::SharedPtr<ModifierSaveLoad> getSaveLoad(Runtime *runtime) override;

	Common::SharedPtr<VariableStorage> clone() const override;

private:
	class SaveLoad : public ModifierSaveLoad {
	public:
		explicit SaveLoad(PointVariableStorage *storage);

	private:
		void commitLoad() const override;
		void saveInternal(Common::WriteStream *stream) const override;
		bool loadInternal(Common::ReadStream *stream, uint32 saveFileVersion) override;

		PointVariableStorage *_storage;
		Common::Point _value;
	};

	Common::Point _value;
};

class FloatingPointVariableModifier : public VariableModifier {
public:
	FloatingPointVariableModifier();

	bool load(ModifierLoaderContext &context, const Data::FloatingPointVariableModifier &data);

	bool varSetValue(MiniscriptThread *thread, const DynamicValue &value) override;
	void varGetValue(DynamicValue &dest) const override;

#ifdef MTROPOLIS_DEBUG_ENABLE
	const char *debugGetTypeName() const override { return "Floating Point Variable Modifier"; }
	SupportStatus debugGetSupportStatus() const override { return kSupportStatusDone; }
	void debugInspect(IDebugInspectionReport *report) const override;
#endif

private:
	Common::SharedPtr<Modifier> shallowClone() const override;
	const char *getDefaultName() const override;
};

class FloatingPointVariableStorage : public VariableStorage {
public:
	friend class FloatingPointVariableModifier;

	FloatingPointVariableStorage();

	Common::SharedPtr<ModifierSaveLoad> getSaveLoad(Runtime *runtime) override;

	Common::SharedPtr<VariableStorage> clone() const override;

private:
	class SaveLoad : public ModifierSaveLoad {
	public:
		explicit SaveLoad(FloatingPointVariableStorage *storage);

	private:
		void commitLoad() const override;
		void saveInternal(Common::WriteStream *stream) const override;
		bool loadInternal(Common::ReadStream *stream, uint32 saveFileVersion) override;

		FloatingPointVariableStorage *_storage;
		double _value;
	};

	double _value;
};

class StringVariableModifier : public VariableModifier {
public:
	StringVariableModifier();

	bool load(ModifierLoaderContext &context, const Data::StringVariableModifier &data);

	bool varSetValue(MiniscriptThread *thread, const DynamicValue &value) override;
	void varGetValue(DynamicValue &dest) const override;

#ifdef MTROPOLIS_DEBUG_ENABLE
	const char *debugGetTypeName() const override { return "String Variable Modifier"; }
	SupportStatus debugGetSupportStatus() const override { return kSupportStatusDone; }
	void debugInspect(IDebugInspectionReport *report) const override;
#endif

private:
	Common::SharedPtr<Modifier> shallowClone() const override;
	const char *getDefaultName() const override;
};

class StringVariableStorage : public VariableStorage {
public:
	friend class StringVariableModifier;

	StringVariableStorage();

	Common::SharedPtr<ModifierSaveLoad> getSaveLoad(Runtime *runtime) override;

	Common::SharedPtr<VariableStorage> clone() const override;

private:
	class SaveLoad : public ModifierSaveLoad {
	public:
		explicit SaveLoad(StringVariableStorage *storage);

	private:
		void commitLoad() const override;
		void saveInternal(Common::WriteStream *stream) const override;
		bool loadInternal(Common::ReadStream *stream, uint32 saveFileVersion) override;

		StringVariableStorage *_storage;
		Common::String _value;
	};

	Common::String _value;
};

class ObjectReferenceVariableModifierV1 : public VariableModifier {
public:
	ObjectReferenceVariableModifierV1();

	bool load(ModifierLoaderContext &context, const Data::ObjectReferenceVariableModifierV1 &data);

	bool varSetValue(MiniscriptThread *thread, const DynamicValue &value) override;
	void varGetValue(DynamicValue &dest) const override;

	bool respondsToEvent(const Event &evt) const override;
	VThreadState consumeMessage(Runtime *runtime, const Common::SharedPtr<MessageProperties> &msg) override;

	bool readAttribute(MiniscriptThread *thread, DynamicValue &result, const Common::String &attrib) override;

#ifdef MTROPOLIS_DEBUG_ENABLE
	const char *debugGetTypeName() const override { return "Object Reference Variable Modifier V1"; }
	SupportStatus debugGetSupportStatus() const override { return kSupportStatusNone; }
#endif

private:
	Common::SharedPtr<Modifier> shallowClone() const override;
	const char *getDefaultName() const override;

	Event _setToSourcesParentWhen;
};

class ObjectReferenceVariableV1Storage : public VariableStorage {
public:
	friend class ObjectReferenceVariableModifierV1;

	ObjectReferenceVariableV1Storage();

	Common::SharedPtr<ModifierSaveLoad> getSaveLoad(Runtime *runtime) override;

	Common::SharedPtr<VariableStorage> clone() const override;

private:
	class SaveLoad : public ModifierSaveLoad {
	public:
		explicit SaveLoad(ObjectReferenceVariableV1Storage *storage);

	private:
		void commitLoad() const override;
		void saveInternal(Common::WriteStream *stream) const override;
		bool loadInternal(Common::ReadStream *stream, uint32 saveFileVersion) override;

		ObjectReferenceVariableV1Storage *_storage;
		Common::WeakPtr<RuntimeObject> _value;
	};

	Common::WeakPtr<RuntimeObject> _value;
};

}	// End of namespace MTropolis

#endif