Initial commit

engines/lastexpress/lastexpress.h

@@ -0,0 +1,756 @@
+/* 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 LASTEXPRESS_LASTEXPRESS_H
+#define LASTEXPRESS_LASTEXPRESS_H
+
+#include "lastexpress/debug.h"
+#include "lastexpress/game/beetle.h"
+#include "lastexpress/game/vcr.h"
+#include "lastexpress/game/savegame.h"
+#include "lastexpress/sound/slot.h"
+#include "lastexpress/sound/sound.h"
+#include "lastexpress/sound/subtitle.h"
+#include "lastexpress/game/logic.h"
+#include "lastexpress/data/sprites.h"
+#include "lastexpress/game/nis.h"
+#include "lastexpress/game/otis.h"
+#include "lastexpress/game/events.h"
+#include "lastexpress/fight/fight.h"
+#include "lastexpress/menu/menu.h"
+#include "lastexpress/graphics.h"
+#include "lastexpress/memory.h"
+
+#include "common/random.h"
+#include "common/file.h"
+
+#include "engines/engine.h"
+
+#include "graphics/pixelformat.h"
+
+struct ADGameDescription;
+
+/**
+ * This is the namespace of the LastExpress engine.
+ *
+ * Status of this engine:
+ *  The engine is completely implemented, the game is fully playable
+ *  and the code is as faithful to the original disassembly as it reasonably can be.
+ * 
+ *  Notable features:
+ *    - Original savegames are supported and swappable from ScummVM to the original
+ *      (and viceversa).
+ *    - The debugger uses DearImGui and provides a real-time visualization of all the
+ *      characters movements.
+ *
+ * Original maintainers:
+ *  littleboy, jvprat, clone2727
+ *
+ * Engine rewrite/additional reverse engineering:
+ *  Bosca
+ *
+ * Supported games:
+ *  - The Last Express
+ */
+namespace LastExpress {
+
+class ArchiveManager;
+class GoldArchiveManager;
+class CBeetle;
+class CFight;
+class Clock;
+class GraphicsManager;
+class LogicManager;
+class MemoryManager;
+class Menu;
+class MessageManager;
+class NISManager;
+class OtisManager;
+class ResourceManager;
+class SaveManager;
+class Slot;
+class SoundManager;
+class SpriteManager;
+class SubtitleManager;
+class VCR;
+
+struct Extent;
+
+enum {
+	GF_COMPRESSED = 1 << 0
+};
+
+typedef struct Item {
+	uint8 mnum;
+	uint16 closeUp;
+	int8 useable;
+	int8 haveIt;
+	int8 inPocket;
+	int8 floating;
+
+	Item() {
+		clear();
+	}
+
+	void clear() {
+		mnum = 0;
+		closeUp = 0;
+		useable = 0;
+		haveIt = 0;
+		inPocket = 0;
+		floating = 0;
+	}
+} Item;
+
+typedef struct Door {
+	int8 who;
+	int8 status;
+	uint8 windowCursor;
+	uint8 handleCursor;
+	int8 model;
+
+	Door() {
+		clear();
+	}
+
+	void clear() {
+		who = 0;
+		status = 0;
+		windowCursor = 0;
+		handleCursor = 0;
+		model = 0;
+	}
+} Door;
+
+typedef struct Position {
+	uint16 position;
+	uint16 location;
+	uint16 car;
+
+	Position() {
+		clear();
+	}
+
+	void clear() {
+		position = 0;
+		location = 0;
+		car = 0;
+	}
+} Position;
+
+typedef struct Sprite {
+	byte *compData;
+	byte *eraseMask;
+	uint16 *colorPalette;
+	Extent rect;
+	uint16 hotspotX1;
+	uint16 hotspotX2;
+	uint16 hotspotY1;
+	uint16 hotspotY2;
+	byte compBits;
+	byte compType;
+	byte copyScreenAndRedrawFlag;
+	byte spritesUnk3;
+	byte ticksToWaitUntilCycleRestart;
+	byte soundDelay;
+	byte soundAction;
+	byte flags;
+	byte position;
+	byte spritesUnk9;
+	byte spritesUnk10;
+	byte spritesUnk11;
+	int spritesUnk8;
+	uint16 visibilityDist;
+	uint16 hotspotPriority;
+	Sprite *nextSprite;
+
+	Sprite() {
+		compData = nullptr;
+		eraseMask = nullptr;
+		colorPalette = nullptr;
+		hotspotX1 = 0;
+		hotspotX2 = 0;
+		hotspotY1 = 0;
+		hotspotY2 = 0;
+		compBits = 0;
+		compType = 0;
+		copyScreenAndRedrawFlag = 0;
+		spritesUnk3 = 0;
+		ticksToWaitUntilCycleRestart = 0;
+		soundDelay = 0;
+		soundAction = 0;
+		flags = 0;
+		position = 0;
+		spritesUnk9 = 0;
+		spritesUnk10 = 0;
+		spritesUnk11 = 0;
+		spritesUnk8 = 0;
+		visibilityDist = 0;
+		hotspotPriority = 0;
+		nextSprite = nullptr;
+	}
+} Sprite;
+
+typedef struct Seq {
+	int numFrames;
+	Sprite *sprites;
+	Sprite spriteArrayStart;
+	byte gap[18];
+	byte *rawSeqData;
+
+	Seq() {
+		numFrames = 0;
+		sprites = nullptr;
+		memset(gap, 0, sizeof(gap));
+		rawSeqData = nullptr;
+	}
+
+	~Seq() {
+		delete[] sprites;
+		sprites = nullptr;
+	}
+} Seq;
+
+typedef struct CharacterCallParams {
+	int parameters[32];
+
+	CharacterCallParams() {
+		clear();
+	}
+
+	void clear() {
+		for (int i = 0; i < 32; i++) {
+			parameters[i] = 0;
+		}
+	}
+} CharacterCallParams;
+
+typedef struct Character {
+	CharacterCallParams callParams[9];
+	uint8 callbacks[16];
+	uint8 currentCall;
+	Position characterPosition;
+	uint8 walkCounter;
+	int8 attachedConductor;
+	uint8 inventoryItem;
+	int8 direction;
+	int16 waitedTicksUntilCycleRestart;
+	int16 currentFrameSeq1;
+	int16 currentFrameSeq2;
+	int16 elapsedFrames;
+	int16 walkStepSize;
+	int8 clothes;
+	int8 position2;
+	int8 car2;
+	int8 doProcessEntity;
+	int8 needsPosFudge;
+	int8 needsSecondaryPosFudge;
+	int8 directionSwitch;
+	char sequenceName[13];
+	char sequenceName2[13];
+	char sequenceNamePrefix[7];
+	char sequenceNameCopy[13];
+	Sprite *frame1;
+	Sprite *frame2;
+	Seq *sequence1;
+	Seq *sequence2;
+	Seq *sequence3;
+
+	Character() {
+		reset();
+	}
+
+	void reset() {
+		memset(callbacks, 0, sizeof(callbacks));
+		currentCall = 0;
+		walkCounter = 0;
+		attachedConductor = 0;
+		inventoryItem = 0;
+		direction = 0;
+		waitedTicksUntilCycleRestart = 0;
+		currentFrameSeq1 = 0;
+		currentFrameSeq2 = 0;
+		elapsedFrames = 0;
+		walkStepSize = 0;
+		clothes = 0;
+		position2 = 0;
+		car2 = 0;
+		doProcessEntity = 0;
+		needsPosFudge = 0;
+		needsSecondaryPosFudge = 0;
+		directionSwitch = 0;
+
+		memset(sequenceName, 0, sizeof(sequenceName));
+		memset(sequenceName2, 0, sizeof(sequenceName2));
+		memset(sequenceNamePrefix, 0, sizeof(sequenceNamePrefix));
+		memset(sequenceNameCopy, 0, sizeof(sequenceNameCopy));
+
+		frame1 = nullptr;
+		frame2 = nullptr;
+		sequence1 = nullptr;
+		sequence2 = nullptr;
+		sequence3 = nullptr;
+	}
+
+} Character;
+
+typedef struct Characters {
+	Character characters[40];
+} Characters;
+
+typedef struct Line7 {
+	int slope;
+	int intercept;
+	char lineType;
+	Line7 *next;
+
+	Line7() {
+		slope = 0;
+		intercept = 0;
+		lineType = 0;
+		next = nullptr;
+	}
+
+	~Line7() {
+		if (next) {
+			delete next;
+			next = nullptr;
+		}
+	}
+
+} Line7;
+
+typedef struct Link {
+	uint16 left;
+	uint16 right;
+	uint16 top;
+	uint16 bottom;
+	Line7 *lineList;
+	uint16 scene;
+	uint8 location;
+	uint8 action;
+	uint8 param1;
+	uint8 param2;
+	uint8 param3;
+	uint8 cursor;
+	Link *next;
+
+	Link() {
+		left = 0;
+		right = 0;
+		top = 0;
+		bottom = 0;
+		lineList = nullptr;
+		scene = 0;
+		location = 0;
+		action = 0;
+		param1 = 0;
+		param2 = 0;
+		param3 = 0;
+		cursor = 0;
+		next = nullptr;
+	}
+
+	~Link() {
+		if (lineList) {
+			delete lineList;
+			lineList = nullptr;
+		}
+
+		if (next) {
+			delete next;
+			next = nullptr;
+		}
+	}
+
+	void copyFrom(Link *otherLink) {
+		left = otherLink->left;
+		right = otherLink->right;
+		top = otherLink->top;
+		bottom = otherLink->bottom;
+		lineList = nullptr;
+		scene = otherLink->scene;
+		location = otherLink->location;
+		action = otherLink->action;
+		param1 = otherLink->param1;
+		param2 = otherLink->param2;
+		param3 = otherLink->param3;
+		cursor = otherLink->cursor;
+		next = nullptr;
+	}
+} Link;
+
+typedef struct Node {
+	char sceneFilename[9];
+	Position nodePosition;
+	uint8 cathDir;
+	uint8 property;
+	uint8 parameter1;
+	uint8 parameter2;
+	uint8 parameter3;
+	Link *link;
+
+	Node() {
+		memset(sceneFilename, 0, sizeof(sceneFilename));
+		cathDir = 0;
+		property = 0;
+		parameter1 = 0;
+		parameter2 = 0;
+		parameter3 = 0;
+		link = nullptr;
+	}
+
+	~Node() {
+		if (link) {
+			delete link;
+			link = nullptr;
+		}
+	}
+} Node;
+
+#include "common/pack-start.h"
+typedef struct TGAHeader {
+	uint8 idLength;
+	uint8 colorMapType;
+	uint8 imageType;
+	uint16 colorMapFirstEntryIndex;
+	uint16 colorMapLength;
+	uint8 colorMapEntrySize;
+	uint16 xOrigin;
+	uint16 yOrigin;
+	uint16 width;
+	uint16 height;
+	uint8 bitsPerPixel;
+	uint8 imageDescriptor;
+	byte *rawDataPtr; // Not in the original, but we need it to avoid pointer fix-ups...
+
+	TGAHeader() {
+		idLength = 0;
+		colorMapType = 0;
+		imageType = 0;
+		colorMapFirstEntryIndex = 0;
+		colorMapLength = 0;
+		colorMapEntrySize = 0;
+		xOrigin = 0;
+		yOrigin = 0;
+		width = 0;
+		height = 0;
+		bitsPerPixel = 0;
+		imageDescriptor = 0;
+		rawDataPtr = nullptr;
+	}
+} TGAHeader;
+#include "common/pack-end.h"
+
+typedef struct FontData {
+	uint16 palette[16];
+	uint8 charMap[256];
+	uint8 charKerning[256];
+	byte *fontData;
+
+	FontData() {
+		memset(palette, 0, sizeof(palette));
+		memset(charMap, 0, sizeof(charMap));
+		memset(charKerning, 0, sizeof(charKerning));
+		fontData = nullptr;
+	}
+
+	~FontData() {
+		memset(palette, 0, sizeof(palette));
+		memset(charMap, 0, sizeof(charMap));
+		memset(charKerning, 0, sizeof(charKerning));
+
+		if (fontData) {
+			free(fontData);
+			fontData = nullptr;
+		}
+	}
+} FontData;
+
+typedef struct NisSprite {
+	byte *compData;
+	byte *eraseMask;
+	uint16 *colorPalette;
+	Extent rect;
+	uint16 gammaPalette[128];
+	byte compBits;
+
+	NisSprite() {
+		compData = nullptr;
+		eraseMask = nullptr;
+		colorPalette = nullptr;
+		memset(gammaPalette, 0, sizeof(gammaPalette));
+		compBits = 0;
+	}
+} NisSprite;
+
+typedef struct NisEvents {
+	int16 eventType;
+	int16 eventTime;
+	int32 eventSize;
+
+	NisEvents() {
+		eventType = 0;
+		eventTime = 0;
+		eventSize = 0;
+	}
+} NisEvents;
+
+#define MEM_PAGE_SIZE  0x800
+
+#define DEMO_TIMEOUT 2700
+
+typedef uint16 PixMap;
+
+class LastExpressEngine : public Engine {
+	// AARGH! Remove!
+	friend class VCR;
+	friend class SubtitleManager;
+
+protected:
+	// Engine APIs
+	Common::Error run() override;
+	bool hasFeature(EngineFeature f) const override;
+
+public:
+	LastExpressEngine(OSystem *syst, const ADGameDescription *gd);
+	~LastExpressEngine() override;
+
+	// Misc
+	Common::RandomSource& getRandom() {return _random; }
+
+	// Managers
+	ArchiveManager  *getArchiveManager()  const { return _archiveMan;  }
+	GraphicsManager *getGraphicsManager() const { return _graphicsMan; }
+	SubtitleManager *getSubtitleManager() const { return _subtitleMan; }
+
+	MemoryManager  *getMemoryManager()  const { return _memMan;    }
+	MessageManager *getMessageManager() const { return _msgMan;    }
+	NISManager     *getNISManager()     const { return _nisMan;    }
+	SoundManager   *getSoundManager()   const { return _soundMan;  }
+	LogicManager   *getLogicManager()   const { return _logicMan;  }
+	OtisManager    *getOtisManager()    const { return _otisMan;   }
+	SpriteManager  *getSpriteManager()  const { return _spriteMan; }
+	SaveManager    *getSaveManager()    const { return _saveMan;   }
+
+	VCR   *getVCR()   const { return _vcr;   }
+	Menu  *getMenu()  const { return _menu;  }
+	Clock *getClock() const { return _clock; }
+
+	// Event handling
+	bool handleEvents();
+
+	bool isDemo() const;
+	bool isGoldEdition() const;
+	bool isCompressed() const;
+
+	Common::String getTargetName() const;
+
+	// NEW STUFF
+	static void soundTimerHandler(void *refCon);
+
+	int32 _soundFrameCounter = 0;
+
+	Common::Mutex *_soundMutex;
+	const char *_savegameFilename = nullptr;
+	const char *_savegameTempNames[7] = {
+		"blue.tmp",
+		"red.tmp",
+		"green.tmp",
+		"purple.tmp",
+		"teal.tmp",
+		"gold.tmp",
+		"temp.tmp"
+	};
+
+	const char *_savegameNames[6] = {
+		"blue.egg",
+		"red.egg",
+		"green.egg",
+		"purple.egg",
+		"teal.egg",
+		"gold.egg"
+	};
+
+	CVCRFile *_savegame = nullptr;
+
+	int32 _currentGameFileColorId = -1;
+	int32 _gracePeriodTimer = 0;
+	bool _eventTickInternal = false;
+	
+	bool _doShowCredits = false;
+	int32 _currentSavePoint = 0;
+	int32 _lastSavePointIdInFile = 0;
+	int32 _gameTimeOfLastSavePointInFile = 0;
+	int32 _gracePeriodIndex = 0;
+	int32 _fightSkipCounter = 0;
+	
+	bool _navigationEngineIsRunning = false;
+	bool _stopUpdatingCharacters = false;
+	bool _charactersUpdateRecursionFlag = false;
+	bool _mouseHasLeftClicked = false;
+	bool _mouseHasRightClicked = false;
+	bool _fastWalkJustDeactivated = false;
+
+	int32 _cursorX	= 320;
+	int32 _cursorY	= 240;
+	int32 _cursorXOffscreenOffset = 0;
+	int32 _cursorYOffscreenOffset = 0;
+	int _cursorType = 0;
+
+	bool _systemEventLeftMouseDown = false;
+	bool _systemEventRightMouseDown = false;
+	Common::Point _systemEventLastMouseCoords;
+
+	bool _pendingExitEvent = false;
+	bool _exitFromMenuButton = false;
+	int32 _lastForcedScreenUpdateTicks = 0; // Not in the original
+
+	Seq *_doorSeqs[8] = { nullptr, nullptr, nullptr, nullptr, nullptr, nullptr, nullptr, nullptr };
+	Seq *_clockHandsSeqs[2] = { nullptr, nullptr };
+	int32 _clockHandsValues[2] = { 0, 0 };
+
+	int32 _fudgePosition[41] = {
+		   0,  851, 1430, 2110,    0, 2410, 2980, 3450,
+		3760, 4100, 4680, 5140, 5440, 5810, 6410, 6850,
+		7160, 7510, 8514,    0,    0,    0, 2086, 2690,
+		   0, 3110, 3390, 3890, 4460, 4770, 5090, 5610,
+		6160, 6460, 6800, 7320, 7870, 8160, 8500, 9020,
+		9269
+	};
+
+	// DYNAMIC ALLOC
+	byte *_globalMemoryPool = nullptr;
+	byte *_soundMemoryPool = nullptr;
+	byte *_cursorsMemoryPool = nullptr;
+	Characters *_characters = nullptr;
+
+	SVCRSavePointHeader *_savePointHeaders = nullptr;
+
+	// GENERAL
+	void startUp();
+	void shutDown();
+
+	void waitForTimer(int millis);
+	void initGameData();
+	void startNewGame();
+	void engineEventHandler(Event *event);
+
+	int32 getSoundFrameCounter();
+
+	bool getEventTickInternal();
+	void setEventTickInternal(bool flag);
+
+	void mouseSetLeftClicked(bool hasClicked);
+	void mouseSetRightClicked(bool hasClicked);
+	bool mouseHasLeftClicked();
+	bool mouseHasRightClicked();
+
+	// BEETLE
+	CBeetle *_beetle = nullptr;
+	void doBeetle();
+	void endBeetle();
+	void positionSprite(Sprite *sprite, Common::Point coord);
+
+	// CREDITS
+	void doCredits();
+	void abortCredits();
+	void creditsMouse(Event *event);
+	void creditsTimer(Event *event);
+	int32 readTGAIntoMemory(const char *filename, TGAHeader *tgaHeader);
+	void constructPalette(TGAHeader *tgaHeader, uint16 *palette);
+
+	// DEMO CREDITS
+	bool demoEnding(bool wonGame);
+	void demoEndingMouse(Event *event);
+	void demoEndingTimer(Event *event);
+
+	// EVENT HANDLERS
+	void engineEventHandlerWrapper(Event *event);
+
+	void nodeStepMouseWrapper(Event *event);
+	void nodeStepTimerWrapper(Event *event);
+
+	void eggMouseWrapper(Event *event);
+	void eggTimerWrapper(Event *event);
+
+	void nisMouseWrapper(Event *event);
+	void nisTimerWrapper(Event *event);
+
+	void creditsMouseWrapper(Event *event);
+	void creditsTimerWrapper(Event *event);
+
+	void demoEndingMouseWrapper(Event *event);
+	void demoEndingTimerWrapper(Event *event);
+
+	void fightMouseWrapper(Event *event);
+	void fightTimerWrapper(Event *event);
+
+	void emptyHandler(Event *event);
+
+	int _savedFrameCounter = 0;
+	int32 _savedFrameInterval = 0;
+	int _doCredits = 0;
+
+	void (LastExpressEngine::*_savedTimerEventHandle)(Event *) = nullptr;
+	void (LastExpressEngine::*_savedMouseEventHandle)(Event *) = nullptr;
+
+	// FIGHT
+	int doFight(int fightId);
+	void abortFight();
+
+	CFight *_fight = nullptr;
+
+	// DEBUGGER
+	void showEngineInfo();
+
+	bool _lockGracePeriod = false;
+
+private:
+	const ADGameDescription *_gameDescription;
+	Graphics::PixelFormat _pixelFormat;
+
+	// Misc
+	Debugger *_debugger;
+	Common::RandomSource _random;
+
+	// Game
+	Menu *_menu = nullptr;
+	Clock *_clock = nullptr;
+	VCR *_vcr = nullptr;
+
+	// Managers
+	ArchiveManager  *_archiveMan = nullptr;
+	GraphicsManager *_graphicsMan = nullptr;
+	SoundManager    *_soundMan = nullptr;
+	LogicManager    *_logicMan = nullptr;
+	OtisManager     *_otisMan = nullptr;
+	SpriteManager   *_spriteMan = nullptr;
+	MemoryManager   *_memMan = nullptr;
+	MessageManager  *_msgMan = nullptr;
+	NISManager      *_nisMan = nullptr;
+	SaveManager     *_saveMan = nullptr;
+	SubtitleManager *_subtitleMan = nullptr;
+};
+
+} // End of namespace LastExpress
+
+#endif // LASTEXPRESS_LASTEXPRESS_H