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

#include "common/bitarray.h"
#include "common/events.h"
#include "common/file.h"
#include "common/memstream.h"
#include "engines/advancedDetector.h"
#include "graphics/managed_surface.h"
#include "graphics/surface.h"


#include "audio/decoders/wave.h"
#include "audio/mixer.h"
#include "audio/softsynth/pcspk.h"
#include "graphics/framelimiter.h"

#include "freescape/area.h"
#include "freescape/font.h"
#include "freescape/gfx.h"
#include "freescape/objects/entrance.h"
#include "freescape/objects/geometricobject.h"
#include "freescape/objects/sensor.h"
#include "freescape/sound.h"

namespace Common {
class RandomSource;
}

namespace Freescape {

class Renderer;

#define FREESCAPE_DATA_BUNDLE "freescape.dat"

enum CameraMovement {
	kForwardMovement,
	kBackwardMovement,
	kLeftMovement,
	kRightMovement
};

enum FreescapeAction {
	kActionNone,
	kActionEscape,
	kActionSave,
	kActionLoad,
	kActionToggleSound,
	kActionMoveUp,
	kActionMoveDown,
	kActionMoveLeft,
	kActionMoveRight,
	kActionShoot,
	kActionActivate,
	kActionIncreaseAngle,
	kActionDecreaseAngle,
	kActionChangeStepSize,
	kActionToggleRiseLower,
	kActionRiseOrFlyUp,
	kActionLowerOrFlyDown,
	kActionChangeMode,
	kActionSkip,
	kActionFaceForward,
	kActionRotateUp,
	kActionRotateDown,
	kActionRotateLeft,
	kActionRotateRight,
	kActionTurnBack,
	kActionInfoMenu,
	kActionIncreaseStepSize,
	kActionDecreaseStepSize,
	kActionToggleFlyMode,
	kActionToggleClipMode,
	// Driller
	kActionDeployDrillingRig,
	kActionCollectDrillingRig,
	kActionRollLeft,
	kActionRollRight,
	// Total Eclipse
	kActionRest,
	// Castle
	kActionRunMode,
	kActionWalkMode,
	kActionCrawlMode,
	kActionSelectPrince,
	kActionSelectPrincess,
	kActionQuit,
	// Demo actions
	kActionUnknownKey,
	kActionWait
};

typedef Common::HashMap<uint16, Area *> AreaMap;
typedef Common::Array<byte *> ColorMap;
typedef Common::HashMap<uint16, int32> StateVars;

enum {
	kFreescapeDebugMove = 1,
	kFreescapeDebugParser,
	kFreescapeDebugCode,
	kFreescapeDebugMedia,
	kFreescapeDebugGroup,
};

enum {
	kFreescapeDefaultVolume = 192,
};

enum GameStateControl {
	kFreescapeGameStateStart,
	kFreescapeGameStatePlaying,
	kFreescapeGameStateDemo,
	kFreescapeGameStateEnd,
	kFreescapeGameStateRestart,
};

struct CGAPaletteEntry {
	int areaId;
	byte *palette;
};

extern Common::String shiftStr(const Common::String &str, int shift);
extern Common::String centerAndPadString(const Common::String &str, int size);

class EventManagerWrapper {
public:
	EventManagerWrapper(Common::EventManager *delegate);
	// EventManager API
	bool pollEvent(Common::Event &event);
	void purgeKeyboardEvents();
	void purgeMouseEvents();
	void pushEvent(Common::Event &event);
	void clearExitEvents();
	bool isActionActive(const Common::CustomEventType &action);
	bool isKeyPressed();

private:
	// for continuous events (keyDown)
	enum {
		kKeyRepeatInitialDelay = 400,
		kKeyRepeatSustainDelay = 100
	};

	Common::EventManager *_delegate;

	Common::KeyState _currentKeyDown;
	Common::CustomEventType _currentActionDown;
	uint32 _keyRepeatTime;
};

class FreescapeEngine : public Engine {

public:
	FreescapeEngine(OSystem *syst, const ADGameDescription *gd);
	~FreescapeEngine();

	const ADGameDescription *_gameDescription;
	GameStateControl _gameStateControl;
	bool isDemo() const;

	// Game selection
	uint32 _variant;
	Common::Language _language;
	bool isSpaceStationOblivion() { return _targetName.hasPrefix("spacestationoblivion"); }
	bool isDriller() { return _targetName.hasPrefix("driller") || _targetName.hasPrefix("spacestationoblivion"); }
	bool isDark() { return _targetName.hasPrefix("darkside"); }
	bool isEclipse() { return _targetName.hasPrefix("totaleclipse"); } // This will match Total Eclipse 1 and 2.
	bool isEclipse2() { return _targetName.hasPrefix("totaleclipse2"); }
	bool isCastle() { return _targetName.hasPrefix("castle"); }
	bool isAmiga() { return _gameDescription->platform == Common::kPlatformAmiga; }
	bool isAtariST() { return _gameDescription->platform == Common::kPlatformAtariST; }
	bool isDOS() { return _gameDescription->platform == Common::kPlatformDOS; }
	bool isSpectrum() { return _gameDescription->platform == Common::kPlatformZX; }
	bool isCPC() { return _gameDescription->platform == Common::kPlatformAmstradCPC; }
	bool isC64() { return _gameDescription->platform == Common::kPlatformC64; }

	virtual void beforeStarting();
	Common::Error run() override;

	// UI
	Common::Rect _viewArea;
	Common::Rect _fullscreenViewArea;
	void centerCrossair();

	virtual void borderScreen();
	virtual void titleScreen();

	void drawFullscreenSurface(Graphics::Surface *surface);
	virtual void loadBorder();
	virtual void processBorder();
	void waitInLoop(int maxWait);
	void drawBorder();
	void drawTitle();
	virtual void drawBackground();
	void clearBackground();
	virtual void drawUI();
	virtual void drawInfoMenu();
	void drawBorderScreenAndWait(Graphics::Surface *surface, int maxWait = INT_MAX);

	virtual void drawCrossair(Graphics::Surface *surface);
	Graphics::ManagedSurface *_border;
	Graphics::ManagedSurface *_title;
	Graphics::ManagedSurface *_background;

	Texture *_borderTexture;
	Texture *_titleTexture;
	Texture *_uiTexture;
	Texture *_skyTexture;

	Common::Array<Graphics::Surface *>_indicators;
	Common::HashMap<uint16, Texture *> _borderCGAByArea;
	Common::HashMap<uint16, byte *> _paletteCGAByArea;

	// Parsing assets
	uint8 _binaryBits;
	virtual void loadAssets();
	virtual void loadAssetsDemo();
	virtual void loadAssetsFullGame();

	virtual void loadAssetsAtariFullGame();
	virtual void loadAssetsAtariDemo();

	virtual void loadAssetsAmigaFullGame();
	virtual void loadAssetsAmigaDemo();

	virtual void loadAssetsDOSFullGame();
	virtual void loadAssetsDOSDemo();

	virtual void loadAssetsZXFullGame();
	virtual void loadAssetsZXDemo();

	virtual void loadAssetsCPCFullGame();
	virtual void loadAssetsCPCDemo();

	virtual void loadAssetsC64FullGame();
	virtual void loadAssetsC64Demo();

	virtual void drawDOSUI(Graphics::Surface *surface);
	virtual void drawZXUI(Graphics::Surface *surface);
	virtual void drawCPCUI(Graphics::Surface *surface);
	virtual void drawC64UI(Graphics::Surface *surface);
	virtual void drawAmigaAtariSTUI(Graphics::Surface *surface);

	Common::Archive *_dataBundle;
	void loadDataBundle();
	Graphics::Surface *loadBundledImage(const Common::String &name, bool appendRenderMode = true);
	byte *getPaletteFromNeoImage(Common::SeekableReadStream *stream, int offset);
	Graphics::ManagedSurface *loadAndConvertNeoImage(Common::SeekableReadStream *stream, int offset, byte *palette = nullptr);
	Graphics::ManagedSurface *loadAndConvertScrImage(Common::SeekableReadStream *stream);
	Graphics::ManagedSurface *loadAndConvertDoodleImage(Common::SeekableReadStream *bitmap, Common::SeekableReadStream *color1, Common::SeekableReadStream *color2, byte *palette);

	void loadPalettes(Common::SeekableReadStream *file, int offset);
	byte *loadPalette(Common::SeekableReadStream *file);
	void swapPalette(uint16 areaID);
	virtual byte *findCGAPalette(uint16 levelID);
	Common::HashMap<uint16, byte *> _paletteByArea;
	void loadColorPalette();

	// Demo
	Common::Array<byte> _demoData;
	int _demoIndex;
	int _currentDemoInputCode;
	int _currentDemoInputRepetition;
	Common::Array<Common::Event> _demoEvents;
	Common::Point _currentDemoMousePosition;
	void loadDemoData(Common::SeekableReadStream *file, int offset, int size);
	int decodeAmigaAtariKey(int code);
	int decodeDOSKey(int code);
	Common::Event decodeDOSMouseEvent(int code, int repetition);

	uint16 readField(Common::SeekableReadStream *file, int nbits);
	uint16 readPtr(Common::SeekableReadStream *file);
	Common::Array<uint16> readArray(Common::SeekableReadStream *file, int size);

	// 8-bit
	void load8bitBinary(Common::SeekableReadStream *file, int offset, int ncolors);
	Area *load8bitArea(Common::SeekableReadStream *file, uint16 ncolors);
	Object *load8bitObject(Common::SeekableReadStream *file);
	Group *load8bitGroup(Common::SeekableReadStream *file, byte rawFlagsAndType);
	Group *load8bitGroupV1(Common::SeekableReadStream *file, byte rawFlagsAndType);
	Group *load8bitGroupV2(Common::SeekableReadStream *file, byte rawFlagsAndType);

	void loadGlobalObjects(Common::SeekableReadStream *file, int offset, int size);
	void renderPixels8bitBinImage(Graphics::ManagedSurface *surface, int row, int column, int bit, int count);

	void renderPixels8bitBinCGAImage(Graphics::ManagedSurface *surface, int &i, int &j, uint8 pixels, int color);
	void renderPixels8bitBinEGAImage(Graphics::ManagedSurface *surface, int &i, int &j, uint8 pixels, int color);

	Graphics::ManagedSurface *load8bitBinImage(Common::SeekableReadStream *file, int offset);
	void load8bitBinImageRow(Common::SeekableReadStream *file, Graphics::ManagedSurface *surface, int row);
	void load8bitBinImageRowIteration(Common::SeekableReadStream *file, Graphics::ManagedSurface *surface, int row, int bit);
	int execute8bitBinImageCommand(Common::SeekableReadStream *file, Graphics::ManagedSurface *surface, int row, int pixels, int bit);
	int execute8bitBinImageSingleCommand(Common::SeekableReadStream *file, Graphics::ManagedSurface *surface, int row, int pixels, int bit, int count);
	int execute8bitBinImageMultiCommand(Common::SeekableReadStream *file, Graphics::ManagedSurface *surface, int row, int pixels, int bit, int count);

	void parseAmigaAtariHeader(Common::SeekableReadStream *file);
	Common::SeekableReadStream *decryptFileAmigaAtari(const Common::Path &packed, const Common::Path &unpacker, uint32 unpackArrayOffset);

	// Areas
	uint16 _startArea;
	uint16 _endArea;
	AreaMap _areaMap;
	Area *_currentArea;
	bool _gotoExecuted;
	Math::Vector3d _scale;

	virtual void gotoArea(uint16 areaID, int entranceID);
	// Entrance
	uint16 _startEntrance;
	uint16 _endEntrance;
	Common::HashMap<int, const struct entrancesTableEntry *> _entranceTable;

	// Input
	bool _demoMode;
	bool _disableDemoMode;
	bool _flyMode;
	bool _shootMode;
	bool _noClipMode;
	bool _invertY;

	bool _smoothMovement;
	// Player movement state
	bool _moveForward;
	bool _moveBackward;
	bool _strafeLeft;
	bool _strafeRight;
	bool _moveUp;
	bool _moveDown;

	virtual void initKeymaps(Common::Keymap *engineKeyMap, Common::Keymap *infoScreenKeyMap, const char *target);
	EventManagerWrapper *_eventManager;
	void processInput();
	void resetInput();
	void stopMovement();
	void generateDemoInput();
	virtual void pressedKey(const int keycode);
	virtual void releasedKey(const int keycode);
	Common::Point getNormalizedPosition(Common::Point position);
	virtual bool onScreenControls(Common::Point mouse);
	void updatePlayerMovement(float deltaTime);
	void updatePlayerMovementSmooth(float deltaTime);
	void updatePlayerMovementClassic(float deltaTime);
	void resolveCollisions(Math::Vector3d newPosition);
	virtual void checkIfStillInArea();
	void changePlayerHeight(int index);
	void increaseStepSize();
	void decreaseStepSize();
	void changeStepSize();

	void changeAngle(int offset, bool wrapAround);
	bool rise();
	void lower();
	bool checkFloor(Math::Vector3d currentPosition);
	bool tryStepUp(Math::Vector3d currentPosition);
	bool tryStepDown(Math::Vector3d currentPosition);
	bool _hasFallen;
	bool _isCollidingWithWall;
	bool _isSteppingUp;
	bool _isSteppingDown;
	bool _isFalling;
	int _maxFallingDistance;
	int _maxShield;
	int _maxEnergy;

	void rotate(float xoffset, float yoffset, float zoffset);
	// Input state
	float _lastFrame;

	// Interaction
	void activate();
	void shoot();
	void traverseEntrance(uint16 entranceID);

	// Euler Angles
	float _yaw;
	float _pitch;
	int _roll;
	int _angleRotationIndex;
	Common::Array<float> _angleRotations;

	Math::Vector3d directionToVector(float pitch, float heading, bool useTable);
	void updateCamera();

	// Camera options
	Common::Point _crossairPosition;
	float _mouseSensitivity;
	Math::Vector3d _upVector; // const
	Math::Vector3d _cameraFront, _cameraRight;
	// Spacial attributes
	Math::Vector3d _position, _rotation, _velocity;
	Math::Vector3d _lastPosition;
	int _playerHeightNumber;
	int _playerHeightMaxNumber;
	uint16 _playerHeight;
	uint16 _playerWidth;
	uint16 _playerDepth;
	uint16 _stepUpDistance;

	int _playerStepIndex;
	Common::Array<int> _playerSteps;

	Common::Point crossairPosToMousePos(const Common::Point &crossairPos);
	Common::Point mousePosToCrossairPos(const Common::Point &mousePos);
	void warpMouseToCrossair(void);

	// Effects
	Common::Array<Common::String> _conditionSources;
	Common::Array<FCLInstructionVector> _conditions;

	bool runCollisionConditions(Math::Vector3d const lastPosition, Math::Vector3d const newPosition);
	Math::Vector3d _objExecutingCodeSize;
	bool _executingGlobalCode;
	virtual void executeMovementConditions();
	bool executeObjectConditions(GeometricObject *obj, bool shot, bool collided, bool activated);
	void executeEntranceConditions(Entrance *entrance);
	void executeLocalGlobalConditions(bool shot, bool collided, bool timer);
	bool executeCode(FCLInstructionVector &code, bool shot, bool collided, bool timer, bool activated);

	// Instructions
	bool checkConditional(FCLInstruction &instruction, bool shot, bool collided, bool timer, bool activated);
	bool checkIfGreaterOrEqual(FCLInstruction &instruction);
	bool checkIfLessOrEqual(FCLInstruction &instruction);
	void executeExecute(FCLInstruction &instruction);
	void executeIncrementVariable(FCLInstruction &instruction);
	void executeDecrementVariable(FCLInstruction &instruction);
	void executeSetVariable(FCLInstruction &instruction);
	void executeGoto(FCLInstruction &instruction);
	void executeIfThenElse(FCLInstruction &instruction);
	virtual void executeMakeInvisible(FCLInstruction &instruction);
	void executeMakeVisible(FCLInstruction &instruction);
	void executeToggleVisibility(FCLInstruction &instruction);
	virtual void executeDestroy(FCLInstruction &instruction);
	virtual void executeRedraw(FCLInstruction &instruction);
	void executeSound(FCLInstruction &instruction);
	void executeDelay(FCLInstruction &instruction);
	bool executeEndIfNotEqual(FCLInstruction &instruction);
	void executeSetBit(FCLInstruction &instruction);
	void executeClearBit(FCLInstruction &instruction);
	void executeToggleBit(FCLInstruction &instruction);
	bool executeEndIfBitNotEqual(FCLInstruction &instruction);
	bool executeEndIfVisibilityIsEqual(FCLInstruction &instruction);
	void executeSwapJet(FCLInstruction &instruction);
	virtual void executePrint(FCLInstruction &instruction);
	void executeSPFX(FCLInstruction &instruction);
	void executeStartAnim(FCLInstruction &instruction);

	// Sound
	Audio::SoundHandle _soundFxHandle;
	Audio::SoundHandle _musicHandle;
	Audio::SoundHandle _movementSoundHandle;
	Freescape::SizedPCSpeaker *_speaker;

	bool _syncSound;
	bool _firstSound;
	bool _usePrerecordedSounds;
	void waitForSounds();
	void stopAllSounds(Audio::SoundHandle &handle);
	bool isPlayingSound();
	void playSound(int index, bool sync, Audio::SoundHandle &handle);
	void playWav(const Common::Path &filename);
	void playMusic(const Common::Path &filename);
	void queueSoundConst(double hzFreq, int duration);
	void playSilence(int duration, bool sync);
	void playSoundConst(double hzFreq, int duration, bool sync);
	void playSoundSweepIncWL(double hzFreq1, double hzFreq2, double wlStepPerMS, int resolution, bool sync);
	uint16 playSoundDOSSpeaker(uint16 startFrequency, soundSpeakerFx *speakerFxInfo);
	void playSoundDOS(soundSpeakerFx *speakerFxInfo, bool sync, Audio::SoundHandle &handle);

	virtual void playSoundFx(int index, bool sync);
	virtual void loadSoundsFx(Common::SeekableReadStream *file, int offset, int number);
	Common::HashMap<uint16, soundFx *> _soundsFx;
	void loadSpeakerFxDOS(Common::SeekableReadStream *file, int offsetFreq, int offsetDuration, int numberSounds);
	void loadSpeakerFxZX(Common::SeekableReadStream *file, int sfxTable, int sfxData);
	Common::HashMap<uint16, soundSpeakerFx *> _soundsSpeakerFx;

	void playSoundZX(Common::Array<soundUnitZX> *data, Audio::SoundHandle &handle);
	Common::HashMap<uint16, Common::Array<soundUnitZX>*> _soundsSpeakerFxZX;
	int _soundIndexShoot;
	int _soundIndexCollide;
	int _soundIndexStepDown;
	int _soundIndexStepUp;
	int _soundIndexFall;
	int _soundIndexMenu;
	int _soundIndexStart;
	int _soundIndexAreaChange;
	int _soundIndexHit;

	int _soundIndexNoShield;
	int _soundIndexNoEnergy;
	int _soundIndexFallen;
	int _soundIndexTimeout;
	int _soundIndexForceEndGame;
	int _soundIndexCrushed;
	int _soundIndexMissionComplete;

	// Rendering
	int _screenW, _screenH;
	Renderer *_gfx;
	Graphics::FrameLimiter *_frameLimiter;
	bool _vsyncEnabled;
	Common::RenderMode _renderMode;
	ColorMap _colorMap;
	int _underFireFrames;
	int _avoidRenderingFrames;
	int _shootingFrames;
	GeometricObject *_delayedShootObject;
	void drawFrame();
	void flashScreen(int backgroundColor);
	uint8 _colorNumber;
	Math::Vector3d _scaleVector;
	float _nearClipPlane;
	float _farClipPlane;

	// Text messages and Fonts
	void insertTemporaryMessage(const Common::String &message, int deadline);
	void getLatestMessages(Common::String &message, int &deadline);
	void clearTemporalMessages();
	Common::StringArray _temporaryMessages;
	Common::Array<int> _temporaryMessageDeadlines;
	Common::StringArray _messagesList;
	Common::String _noShieldMessage;
	Common::String _noEnergyMessage;
	Common::String _fallenMessage;
	Common::String _timeoutMessage;
	Common::String _forceEndGameMessage;
	Common::String _crushedMessage;
	Common::String _outOfReachMessage;
	Common::String _noEffectMessage;

	void loadMessagesFixedSize(Common::SeekableReadStream *file, int offset, int size, int number);
	virtual void loadMessagesVariableSize(Common::SeekableReadStream *file, int offset, int number);
	void drawFullscreenMessageAndWait(Common::String message);
	void drawFullscreenMessage(Common::String message, uint32 front, Graphics::Surface *surface);

	// Font loading and rendering
	void loadFonts(Common::SeekableReadStream *file, int offset);
	void loadFonts(byte *font, int charNumber);
	Common::Array<Graphics::ManagedSurface *> getChars(Common::SeekableReadStream *file, int offset, int charsNumber);
	Common::Array<Graphics::ManagedSurface *> getCharsAmigaAtariInternal(int sizeX, int sizeY, int additional, int m1, int m2, Common::SeekableReadStream *file, int offset, int charsNumber);
	Common::Array<Graphics::ManagedSurface *> getCharsAmigaAtari(Common::SeekableReadStream *file, int offset, int charsNumber);
	Common::StringArray _currentAreaMessages;
	Common::StringArray _currentEphymeralMessages;
	Font _font;
	bool _fontLoaded;
	virtual void drawStringInSurface(const Common::String &str, int x, int y, uint32 fontColor, uint32 backColor, Graphics::Surface *surface, int offset = 0);
	virtual void drawStringInSurface(const Common::String &str, int x, int y, uint32 primaryFontColor, uint32 secondaryFontColor, uint32 backColor, Graphics::Surface *surface, int offset = 0);
	Graphics::Surface *drawStringsInSurface(const Common::Array<Common::String> &lines, Graphics::Surface *surface);

	// Game state
	virtual void initGameState();
	void setGameBit(int index);
	void clearGameBit(int index);
	void toggleGameBit(int index);
	uint16 getGameBit(int index);

	StateVars _gameStateVars;
	uint32 _gameStateBits;
	void checkIfPlayerWasCrushed();
	virtual bool checkIfGameEnded();
	virtual void endGame();
	int _endGameDelayTicks;
	bool _endGameKeyPressed;
	bool _endGamePlayerEndArea;
	bool _forceEndGame;
	bool _playerWasCrushed;
	Common::HashMap<uint16, bool> _exploredAreas;
	ObjectArray _sensors;
	virtual void checkSensors();
	virtual void drawSensorShoot(Sensor *sensor);
	void takeDamageFromSensor();

	bool hasFeature(EngineFeature f) const override;
	bool canLoadGameStateCurrently(Common::U32String *msg = nullptr) override { return true; }
	bool canSaveAutosaveCurrently() override { return false; }
	bool canSaveGameStateCurrently(Common::U32String *msg = nullptr) override { return _gameStateControl == kFreescapeGameStatePlaying && _currentArea; }
	Common::Error loadGameStream(Common::SeekableReadStream *stream) override;
	Common::Error saveGameStream(Common::WriteStream *stream, bool isAutosave = false) override;
	virtual Common::Error saveGameStreamExtended(Common::WriteStream *stream, bool isAutosave = false);
	virtual Common::Error loadGameStreamExtended(Common::SeekableReadStream *stream);
	Graphics::Surface *_savedScreen;

	void pauseEngineIntern(bool pause) override;

	// Timers
	bool startCountdown(uint32 delay);
	void removeTimers();
	bool _timerStarted;
	int _initialCountdown;
	int _countdown;
	int _ticks;
	int _ticksFromEnd;
	int _lastTick;
	int _lastMinute;

	void getTimeFromCountdown(int &seconds, int &minutes, int &hours);
	virtual void updateTimeVariables();

	// Cheats
	bool _useExtendedTimer;
	bool _disableSensors;
	bool _disableFalling;

	// Random
	Common::RandomSource *_rnd;

	// C64 specifics
	byte *decompressC64RLE(byte *buffer, int *size, byte marker);
	byte *_extraBuffer;
};

enum GameReleaseFlags {
	GF_AMIGA_RETAIL = (1 << 0),
	GF_AMIGA_BUDGET = (1 << 1),
	GF_ZX_RETAIL = (1 << 2),
	GF_ZX_BUDGET = (1 << 3),
	GF_ZX_DISC = (1 << 4),
	GF_CPC_RETAIL = (1 << 5),
	GF_CPC_RETAIL_ALT = (1 << 6),
	GF_CPC_BUDGET = (1 << 7),
	GF_CPC_VIRTUALWORLDS = (1 << 8),
	GF_ATARI_RETAIL = (1 << 9),
	GF_ATARI_BUDGET = (1 << 10),
	GF_C64_TAPE = (1 << 11),
	GF_C64_DISC = (1 << 12),
};

extern FreescapeEngine *g_freescape;

} // namespace Freescape

#endif // FREESCAPE_H