TITANIC: Move most of the root classes into new support/ folder

28 files changed, 3751 insertions, 0 deletions

diff --git a/engines/titanic/support/direct_draw.cpp b/engines/titanic/support/direct_draw.cpp
new file mode 100644
index 0000000000..5ddb25bec9
--- /dev/null
+++ b/engines/titanic/support/direct_draw.cpp
@@ -0,0 +1,109 @@
+/* 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 2
+ * 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, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ *
+ */
+
+#include "common/debug.h"
+#include "engines/util.h"
+#include "graphics/pixelformat.h"
+#include "titanic/titanic.h"
+#include "titanic/support/direct_draw.h"
+
+namespace Titanic {
+
+DirectDraw::DirectDraw(TitanicEngine *vm) : _vm(vm),
+		_windowed(false), _fieldC(0), _width(0), _height(0),
+		_bpp(0), _numBackSurfaces(0), _field24(0) {
+}
+
+void DirectDraw::setDisplayMode(int width, int height, int bpp, int refreshRate) {
+	debugC(ERROR_BASIC, kDebugGraphics, "DirectDraw::SetDisplayMode (%d x %d), %d bpp",
+		width, height, bpp);
+	assert(bpp == 16);
+
+	Graphics::PixelFormat pixelFormat(2, 5, 6, 5, 0, 11, 5, 0, 0);
+	initGraphics(width, height, true, &pixelFormat);
+}
+
+void DirectDraw::diagnostics() {
+	debugC(ERROR_BASIC, kDebugGraphics, "Running DirectDraw Diagnostic...");
+}
+
+DirectDrawSurface *DirectDraw::createSurfaceFromDesc(const DDSurfaceDesc &desc) {
+	DirectDrawSurface *surface = new DirectDrawSurface();
+	surface->create(desc._w, desc._h);
+
+	return surface;
+}
+
+/*------------------------------------------------------------------------*/
+
+DirectDrawManager::DirectDrawManager(TitanicEngine *vm, bool windowed) : _directDraw(vm) {
+	_mainSurface = nullptr;
+	_backSurfaces[0] = _backSurfaces[1] = nullptr;
+	_directDraw._windowed = windowed;
+}
+
+void DirectDrawManager::initVideo(int width, int height, int bpp, int numBackSurfaces) {
+	debugC(ERROR_BASIC, kDebugGraphics, "Initialising video surfaces");
+	_directDraw._width = width;
+	_directDraw._numBackSurfaces = numBackSurfaces;
+	_directDraw._height = height;
+	_directDraw._bpp = bpp;
+
+	if (_directDraw._windowed) {
+		initWindowed();
+	} else {
+		initFullScreen();
+	}
+}
+
+void DirectDrawManager::setResolution() {
+	// TODO
+}
+
+void DirectDrawManager::proc2() {
+
+}
+
+void DirectDrawManager::proc3() {
+
+}
+
+void DirectDrawManager::initFullScreen() {
+	debugC(ERROR_BASIC, kDebugGraphics, "Creating surfaces");
+	_directDraw.setDisplayMode(_directDraw._width, _directDraw._height,
+		_directDraw._bpp, 0);
+
+	_mainSurface = new DirectDrawSurface();
+	_mainSurface->create(g_vm->_screen);
+	_backSurfaces[0] = new DirectDrawSurface();
+	_backSurfaces[0]->create(_directDraw._width, _directDraw._height);
+}
+
+DirectDrawSurface *DirectDrawManager::createSurface(int w, int h, int surfaceNum) {
+	if (surfaceNum)
+		return nullptr;
+
+	assert(_mainSurface);
+	return _directDraw.createSurfaceFromDesc(DDSurfaceDesc(w, h));
+}
+
+} // End of namespace Titanic
diff --git a/engines/titanic/support/direct_draw.h b/engines/titanic/support/direct_draw.h
new file mode 100644
index 0000000000..85c344c600
--- /dev/null
+++ b/engines/titanic/support/direct_draw.h
@@ -0,0 +1,105 @@
+/* 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 2
+ * 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, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ *
+ */
+
+#ifndef TITANIC_DIRECT_DRAW_H
+#define TITANIC_DIRECT_DRAW_H
+
+#include "common/scummsys.h"
+#include "common/array.h"
+#include "titanic/support/direct_draw_surface.h"
+
+namespace Titanic {
+
+class TitanicEngine;
+
+class DirectDraw {
+private:
+	TitanicEngine *_vm;
+public:
+	bool _windowed;
+	int _fieldC;
+	int _width;
+	int _height;
+	int _bpp;
+	int _numBackSurfaces;
+	int _field24;
+public:
+	DirectDraw(TitanicEngine *vm);
+
+	/**
+	 * Sets a new display mode
+	 */
+	void setDisplayMode(int width, int height, int bpp, int refreshRate);
+
+	/**
+	 * Logs diagnostic information
+	 */
+	void diagnostics();
+
+	/**
+	 * Create a surface from a passed description record
+	 */
+	DirectDrawSurface *createSurfaceFromDesc(const DDSurfaceDesc &desc);
+};
+
+class DirectDrawManager {
+public:
+	DirectDraw _directDraw;
+	DirectDrawSurface *_mainSurface;
+	DirectDrawSurface *_backSurfaces[2];
+public:
+	DirectDrawManager(TitanicEngine *vm, bool windowed);
+
+	/**
+	 * Initializes video surfaces
+	 * @param width				Screen width
+	 * @param height			Screen height
+	 * @param bpp				Bits per pixel
+	 * @param numBackSurfaces	Number of back surfaces	
+	 */
+	void initVideo(int width, int height, int bpp, int numBackSurfaces);
+
+	void setResolution();
+
+	void proc2();
+
+	void proc3();
+
+	/**
+	 * Initializes the surfaces in windowed mode
+	 */
+	void initWindowed() { initFullScreen(); }
+
+	/**
+	 * Initializes the surfaces for the screen
+	 */
+	void initFullScreen();
+
+	/**
+	 * Create a surface
+	 */
+	DirectDrawSurface *createSurface(int w, int h, int surfaceNum);
+};
+
+} // End of namespace Titanic
+
+#endif /* TITANIC_DIRECT_DRAW_H */
diff --git a/engines/titanic/support/direct_draw_surface.cpp b/engines/titanic/support/direct_draw_surface.cpp
new file mode 100644
index 0000000000..9ebda15b0e
--- /dev/null
+++ b/engines/titanic/support/direct_draw_surface.cpp
@@ -0,0 +1,100 @@
+/* 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 2
+ * 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, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ *
+ */
+
+#include "titanic/support/direct_draw_surface.h"
+
+namespace Titanic {
+
+DirectDrawSurface::DirectDrawSurface() : _surface(nullptr),
+		_disposeAfterUse(DisposeAfterUse::YES) {
+}
+
+DirectDrawSurface::~DirectDrawSurface() {
+	free();
+}
+
+void DirectDrawSurface::create(Graphics::ManagedSurface *surface) {
+	free();
+	_surface = surface;
+	_disposeAfterUse = DisposeAfterUse::NO;
+}
+
+void DirectDrawSurface::create(int w, int h) {
+	Graphics::PixelFormat pixelFormat(2, 5, 6, 5, 0, 11, 5, 0, 0);
+	_surface = new Graphics::ManagedSurface(w, h, pixelFormat);
+	_disposeAfterUse = DisposeAfterUse::YES;
+}
+
+void DirectDrawSurface::free() {
+	if (_disposeAfterUse == DisposeAfterUse::YES)
+		delete _surface;
+	_surface = nullptr;
+	_disposeAfterUse = DisposeAfterUse::NO;
+}
+
+Graphics::ManagedSurface *DirectDrawSurface::lock(const Rect *bounds, int flags) {
+	assert(!_surface->empty());
+	return _surface;
+}
+
+void DirectDrawSurface::unlock() {
+	assert(_surface->w != 0 && _surface->h != 0);
+}
+
+void DirectDrawSurface::fill(const Rect *bounds, uint32 color) {
+	Rect tempBounds;
+
+	assert(_surface);
+	if (bounds) {
+		// Bounds are provided, clip them to the bounds of this surface
+		tempBounds = *bounds;
+		tempBounds.clip(Rect(0, 0, _surface->w, _surface->h));
+	} else {
+		// No bounds provided, so use the entire surface
+		tempBounds = Rect(0, 0, _surface->w, _surface->h);
+	}
+
+	// Fill the area
+	_surface->fillRect(tempBounds, color);
+}
+
+void DirectDrawSurface::fillRect(Rect *rect, byte r, byte g, byte b) {
+	uint color = _surface->format.RGBToColor(r, g, b);
+	Rect tempRect = rect ? *rect : Rect(0, 0, getWidth(), getHeight());
+
+	_surface->fillRect(tempRect, color);
+}
+
+void DirectDrawSurface::blit(const Rect &destRect, DirectDrawSurface *srcSurface, Rect &srcRect) {
+	assert(srcSurface);
+	if (!destRect.isEmpty())
+		_surface->transBlitFrom(*srcSurface->_surface, srcRect, destRect, (uint)-1);
+}
+
+void DirectDrawSurface::blit(const Point &destPos, DirectDrawSurface *srcSurface, Rect *bounds) {
+	if (bounds)
+		_surface->blitFrom(*srcSurface->_surface, *bounds, destPos);
+	else
+		_surface->blitFrom(*srcSurface->_surface, destPos);
+}
+
+} // End of namespace Titanic
diff --git a/engines/titanic/support/direct_draw_surface.h b/engines/titanic/support/direct_draw_surface.h
new file mode 100644
index 0000000000..12848b125d
--- /dev/null
+++ b/engines/titanic/support/direct_draw_surface.h
@@ -0,0 +1,121 @@
+/* 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 2
+ * 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, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ *
+ */
+
+#ifndef TITANIC_DIRECT_DRAW_SURFACE_H
+#define TITANIC_DIRECT_DRAW_SURFACE_H
+
+#include "common/scummsys.h"
+#include "common/array.h"
+#include "graphics/managed_surface.h"
+#include "titanic/support/rect.h"
+
+namespace Titanic {
+
+class TitanicEngine;
+
+struct DDSurfaceDesc {
+	int _w;
+	int _h;
+	int _flags;
+	int _caps;
+
+	DDSurfaceDesc(int w, int h) : _w(w), _h(h), _flags(0x1006), _caps(64) {}
+};
+
+class DirectDrawSurface {
+private:
+	Graphics::ManagedSurface *_surface;
+	DisposeAfterUse::Flag _disposeAfterUse;
+public:
+	DirectDrawSurface();
+	~DirectDrawSurface();
+
+	/**
+	 * Create a surface
+	 */
+	void create(int w, int h);
+
+	/**
+	 * Create a surface based on a passed surface
+	 */
+	void create(Graphics::ManagedSurface *surface);
+
+	/**
+	 * Frees the surface
+	 */
+	void free();
+
+	/**
+	 * Return the size of the surface in ytes
+	 */
+	int getSize() const { return _surface->pitch * _surface->h; }
+
+	/**
+	 * Return the surface width
+	 */
+	int getWidth() const { return _surface->w; }
+
+	/**
+	 * Return the surface width
+	 */
+	int getHeight() const { return _surface->h; }
+
+	/**
+	 * Return the surface pitch
+	 */
+	int getPitch() const { return _surface->pitch; }
+
+	/**
+	 * Lock the surface for access
+	 */
+	Graphics::ManagedSurface *lock(const Rect *bounds, int flags);
+
+	/**
+	 * Unlocks the surface at the end of direct accesses
+	 */
+	void unlock();
+
+	/**
+	 * Fills an area of the surfae with the specified color. If no bounds are passed,
+	 * then the entire surface is filled
+	 */
+	void fill(const Rect *bounds, uint32 color);
+
+	/**
+	 * Fill an area with a specific color
+	 */
+	void fillRect(Rect *rect, byte r, byte g, byte b);
+
+	/**
+	 * Copy data from a source surfcae into this one
+	 */
+	void blit(const Rect &destRect, DirectDrawSurface *srcSurface, Rect &srcRect);
+
+	/**
+	 * Copy data from a source surfcae into this one
+	 */
+	void blit(const Point &destPos, DirectDrawSurface *srcSurface, Rect *bounds);
+};
+
+} // End of namespace Titanic
+
+#endif /* TITANIC_DIRECT_DRAW_SURFACE_H */
diff --git a/engines/titanic/support/files_manager.cpp b/engines/titanic/support/files_manager.cpp
new file mode 100644
index 0000000000..179d77f24f
--- /dev/null
+++ b/engines/titanic/support/files_manager.cpp
@@ -0,0 +1,106 @@
+/* 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 2
+ * 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, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ *
+ */
+
+#include "common/file.h"
+#include "titanic/support/files_manager.h"
+#include "titanic/game_manager.h"
+
+namespace Titanic {
+
+CFilesManager::CFilesManager() : _gameManager(nullptr), 
+		_assetsPath("Assets"), _exeResources(nullptr), _field0(0),
+		_drive(-1), _field18(0), _field1C(0), _field3C(0) {
+}
+
+CFilesManager::~CFilesManager() {
+	delete _exeResources;
+}
+
+bool CFilesManager::fileExists(const CString &name) {
+	Common::File f;
+	return f.exists(name);
+}
+
+bool CFilesManager::scanForFile(const CString &name) {
+	if (name.empty())
+		return false;
+
+	CString filename = name;
+	filename.toLowercase();
+	
+	if (filename[0] == 'y' || filename[0] == 'z')
+		return true;
+	else if (filename[0] < 'a' || filename[0] > 'c')
+		return false;
+
+	CString fname = filename;
+	int idx = fname.indexOf('#');
+	if (idx >= 0) {
+		fname = fname.left(idx);
+		fname += ".st";
+	}
+
+	if (_gameManager)
+		_gameManager->viewChange();
+
+	// The original had a bunch of code here handling determining
+	// which asset path, if any, the filename was present for,
+	// and storing the "active asset path" it was found on.
+	// This is redundant for ScummVM, which takes care of the paths
+	return fileExists(fname);
+}
+
+void CFilesManager::loadDrive() {
+	assert(_drive == -1);
+	resetView();
+}
+
+void CFilesManager::debug(CScreenManager *screenManager) {
+	warning("TODO: CFilesManager::debug");
+}
+
+void CFilesManager::resetView() {
+	if (_gameManager) {
+		_gameManager->_gameState.setMode(GSMODE_SELECTED);
+		_gameManager->initBounds();
+	}
+}
+
+void CFilesManager::fn4(const CString &name) {
+	warning("TODO: CFilesManager::fn4");
+}
+
+void CFilesManager::fn5(const CString &name) {
+	warning("TODO: CFilesManager::fn5");
+}
+
+Common::SeekableReadStream *CFilesManager::getResource(const CString &name,
+		const CString &area) {
+	if (!_exeResources) {
+		_exeResources = new Common::NEResources();
+		_exeResources->loadFromEXE("st.exe");
+	}
+	
+	return nullptr;
+}
+
+} // End of namespace Titanic
diff --git a/engines/titanic/support/files_manager.h b/engines/titanic/support/files_manager.h
new file mode 100644
index 0000000000..7915149412
--- /dev/null
+++ b/engines/titanic/support/files_manager.h
@@ -0,0 +1,96 @@
+/* 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 2
+ * 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, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ *
+ */
+
+#ifndef TITANIC_FILES_MANAGER_H
+#define TITANIC_FILES_MANAGER_H
+
+#include "common/winexe_ne.h"
+#include "titanic/core/list.h"
+#include "titanic/support/screen_manager.h"
+
+namespace Titanic {
+
+class CGameManager;
+
+class CFilesManagerList : public List<ListItem> {
+};
+
+class CFilesManager {
+private:
+	CGameManager *_gameManager;
+	Common::NEResources *_exeResources;
+	CFilesManagerList _list;
+	CString _string1;
+	CString _string2;
+	int _field0;
+	int _drive;
+	int _field18;
+	int _field1C;
+	int _field3C;
+	const CString _assetsPath;
+public:
+	CFilesManager();
+	~CFilesManager();
+
+	/**
+	 * Sets the game manager
+	 */
+	void setGameManager(CGameManager *gameManager) {
+		_gameManager = gameManager;
+	}
+
+	/**
+	 * Returns true if a file of the given name exists
+	 */
+	static bool fileExists(const CString &name);
+
+	/**
+	 * Scans for a file with a matching name
+	 */
+	bool scanForFile(const CString &name);
+
+	/**
+	 * Handles displaying a load drive view if necessary
+	 */
+	void loadDrive();
+
+	void debug(CScreenManager *screenManager);
+
+	/**
+	 * Resets the view being displayed
+	 */
+	void resetView();
+
+	void fn4(const CString &name);
+
+	void fn5(const CString &name);
+
+	/**
+	 * Get a resource from the executable
+	 */
+	Common::SeekableReadStream *getResource(const CString &name,
+		const CString &area);
+};
+
+} // End of namespace Titanic
+
+#endif /* TITANIC_FILES_MANAGER_H */
diff --git a/engines/titanic/support/font.cpp b/engines/titanic/support/font.cpp
new file mode 100644
index 0000000000..6862baf79f
--- /dev/null
+++ b/engines/titanic/support/font.cpp
@@ -0,0 +1,70 @@
+/* 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 2
+ * 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, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ *
+ */
+
+#include "common/textconsole.h"
+#include "titanic/support/font.h"
+#include "titanic/support/files_manager.h"
+#include "titanic/titanic.h"
+
+namespace Titanic {
+
+STFont::STFont() {
+	_dataPtr = nullptr;
+	_dataSize = 0;
+	_field8 = 0;
+	_maxCharWidth = 0;
+	_field810 = 0;
+	_field814 = 0;
+	_field818 = 0;
+}
+
+STFont::~STFont() {
+	delete[] _dataPtr;
+}
+
+void STFont::load(int fontNumber) {
+	assert(!_dataPtr);
+	CString fontNumStr = CString::format("%d", fontNumber);
+	Common::SeekableReadStream *stream = g_vm->_filesManager.getResource(
+		fontNumStr, "STFont");
+	if (!stream)
+		return;
+
+	_field8 = stream->readUint32LE();
+	_maxCharWidth = stream->readUint32LE();
+	for (uint idx = 0; idx < 256; ++idx)
+		_chars[idx]._charWidth = stream->readUint32LE();
+	for (uint idx = 0; idx < 256; ++idx)
+		_chars[idx]._offset = stream->readUint32LE();
+
+	_dataSize = stream->readUint32LE();
+	_dataPtr = new byte[_dataSize];
+	stream->read(_dataPtr, _dataSize);
+
+	delete stream;
+}
+
+void STFont::writeString(int maxWidth, const CString &text, int *v1, int *v2) {
+	warning("TODO: STFont::writeString");
+}
+
+} // End of namespace Titanic
diff --git a/engines/titanic/support/font.h b/engines/titanic/support/font.h
new file mode 100644
index 0000000000..0fff5125df
--- /dev/null
+++ b/engines/titanic/support/font.h
@@ -0,0 +1,64 @@
+/* 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 2
+ * 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, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ *
+ */
+
+#ifndef TITANIC_FONT_H
+#define TITANIC_FONT_H
+
+#include "common/scummsys.h"
+#include "common/array.h"
+#include "titanic/support/string.h"
+
+namespace Titanic {
+
+class STFont {
+	struct CharEntry {
+		uint _charWidth;
+		uint _offset;
+	};
+public:
+	byte *_dataPtr;
+	size_t _dataSize;
+	int _field8;
+	int _maxCharWidth;
+	Common::Array<CharEntry> _chars;
+	int _field810;
+	int _field814;
+	int _field818;
+public:
+	STFont();
+	~STFont();
+
+	/**
+	 * Load a specified font
+	 */
+	void load(int fontNumber);
+
+	/**
+	 * Write out a string
+	 * TODO: Verify this
+	 */
+	void writeString(int maxWidth, const CString &text, int *v1, int *v2);
+};
+
+} // End of namespace Titanic
+
+#endif /* TITANIC_FONT_H */
diff --git a/engines/titanic/support/image.cpp b/engines/titanic/support/image.cpp
new file mode 100644
index 0000000000..cabdd64cf3
--- /dev/null
+++ b/engines/titanic/support/image.cpp
@@ -0,0 +1,121 @@
+/* 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 2
+ * 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, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ *
+ */
+
+#include "common/file.h"
+#include "titanic/support/image.h"
+
+namespace Titanic {
+
+BITMAPINFOHEADER::BITMAPINFOHEADER() {
+	_biSize = 0;
+	_biWidth = 0;
+	_biHeight = 0;
+	_biPlanes = 0;
+	_biBitCount = 0;
+	_biCompression = 0;
+	_biSizeImage = 0;
+	_biXPelsPerMeter = 0;
+	_biYPelsPerMeter = 0;
+	_biClrUsed = 0;
+	_biClrImportant = 0;
+}
+
+/*------------------------------------------------------------------------*/
+
+RGBQuad::RGBQuad() : _rgbRed(0), _rgbGreen(0), _rgbBlue(0), _rgbReserved(0) {}
+
+/*------------------------------------------------------------------------*/
+
+Image::Image() {
+	_bitmapInfo = nullptr;
+	_bits = nullptr;
+	_flag = true;
+
+	set(16, 16);
+}
+
+void Image::proc6() {
+
+}
+
+void Image::set(int width, int height) {
+	delete _bitmapInfo;
+	if (_flag && _bitmapInfo)
+		delete[] _bits;
+
+	_bitmapInfo = new tagBITMAPINFO;
+	_bits = new byte[(width + 3) & 0xFFFC * height];
+
+	tagBITMAPINFO &bi = *_bitmapInfo;
+	bi._bmiHeader._biWidth = width;
+	bi._bmiHeader._biHeight = height;
+	bi._bmiHeader._biPlanes = 1;
+	bi._bmiHeader._biBitCount = 8;
+}
+
+void Image::proc8() {
+
+}
+
+bool Image::loadResource(const Common::String &name) {
+	// This method is hardcoded for the Titanic splash screen resource
+	assert(name == "TITANIC");
+
+	Common::File f;
+	if (!f.open("ST.exe"))
+		return false;
+
+	// The ST.exe executable has a bitmap called "TITANIC". Since we can't use
+	// the Windows FindResource function in ScummVM, this is hardcoded for now
+	f.seek(0x29B660);
+	uint size = f.readUint32LE();
+	if (size != 40)
+		return false;
+
+	loadBitmap(f);
+
+	return true;
+}
+
+void Image::proc10() {
+
+}
+
+void Image::draw() {
+
+}
+
+void Image::loadBitmap(Common::SeekableReadStream &s) {
+	_bitmapInfo->_bmiHeader._biWidth = s.readUint32LE();
+	_bitmapInfo->_bmiHeader._biHeight = s.readUint32LE();
+	_bitmapInfo->_bmiHeader._biPlanes = s.readUint16LE();
+	_bitmapInfo->_bmiHeader._biBitCount = s.readUint16LE();
+	_bitmapInfo->_bmiHeader._biCompression = s.readUint32LE();
+	_bitmapInfo->_bmiHeader._biSizeImage = s.readUint32LE();
+	_bitmapInfo->_bmiHeader._biXPelsPerMeter = s.readUint32LE();
+	_bitmapInfo->_bmiHeader._biYPelsPerMeter = s.readUint32LE();
+	_bitmapInfo->_bmiHeader._biClrUsed = s.readUint32LE();
+	_bitmapInfo->_bmiHeader._biClrImportant = s.readUint32LE();
+
+}
+
+} // End of namespace Titanic
diff --git a/engines/titanic/support/image.h b/engines/titanic/support/image.h
new file mode 100644
index 0000000000..9030e81ad7
--- /dev/null
+++ b/engines/titanic/support/image.h
@@ -0,0 +1,82 @@
+/* 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 2
+ * 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, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ *
+ */
+
+#ifndef TITANIC_IMAGE_H
+#define TITANIC_IMAGE_H
+
+#include "common/scummsys.h"
+#include "common/array.h"
+
+namespace Titanic {
+
+struct BITMAPINFOHEADER {
+	int _biSize;
+	int _biWidth;
+	int _biHeight;
+	int _biPlanes;
+	int _biBitCount;
+	int _biCompression;
+	int _biSizeImage;
+	int _biXPelsPerMeter;
+	int _biYPelsPerMeter;
+	int _biClrUsed;
+	int _biClrImportant;
+
+	BITMAPINFOHEADER();
+};
+
+struct RGBQuad {
+	byte _rgbRed;
+	byte _rgbGreen;
+	byte _rgbBlue;
+	byte _rgbReserved;
+
+	RGBQuad();
+};
+
+struct tagBITMAPINFO {
+	BITMAPINFOHEADER _bmiHeader;
+	RGBQuad _bmiColors[256];
+};
+
+class Image {
+private:
+	void loadBitmap(Common::SeekableReadStream &s);
+public:
+	tagBITMAPINFO *_bitmapInfo;
+	byte *_bits;
+	bool _flag;
+public:
+	Image();
+	virtual ~Image() {}
+
+	virtual void proc6();
+	virtual void set(int width, int height);
+	virtual void proc8();
+	virtual bool loadResource(const Common::String &name);
+	virtual void proc10();
+	virtual void draw();
+};
+
+} // End of namespace Titanic
+
+#endif /* TITANIC_IMAGE_H */
diff --git a/engines/titanic/support/image_decoders.cpp b/engines/titanic/support/image_decoders.cpp
new file mode 100644
index 0000000000..9fe55eb02b
--- /dev/null
+++ b/engines/titanic/support/image_decoders.cpp
@@ -0,0 +1,79 @@
+/* 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 2
+ * 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, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ *
+ */
+
+#include "titanic/support/image_decoders.h"
+
+namespace Titanic {
+
+void CJPEGDecode::decode(OSVideoSurface &surface, const CString &name) {
+	// Open up the resource
+	StdCWadFile file;
+	file.open(name);
+
+	// Use the ScucmmVM deoder to decode it
+	loadStream(*file.readStream());
+	const Graphics::Surface *srcSurf = getSurface();
+	
+	// Resize the surface if necessary
+	if (!surface.hasSurface() || surface.getWidth() != srcSurf->w 
+			|| surface.getHeight() != srcSurf->h)
+		surface.resize(srcSurf->w, srcSurf->h);
+
+	// Convert the decoded surface to the correct pixel format, and then copy it over
+	surface.lock();
+	Graphics::Surface *convertedSurface = srcSurf->convertTo(surface._rawSurface->format);
+
+	Common::copy((byte *)convertedSurface->getPixels(), (byte *)convertedSurface->getPixels() +
+		surface.getPitch() * surface.getHeight(), (byte *)surface._rawSurface->getPixels());
+
+	delete convertedSurface;
+	surface.unlock();
+}
+
+/*------------------------------------------------------------------------*/
+
+void CTargaDecode::decode(OSVideoSurface &surface, const CString &name) {
+	// Open up the resource
+	StdCWadFile file;
+	file.open(name);
+
+	// Use the ScucmmVM deoder to decode it
+	loadStream(*file.readStream());
+	const Graphics::Surface *srcSurf = getSurface();
+
+	// Resize the surface if necessary
+	if (!surface.hasSurface() || surface.getWidth() != srcSurf->w
+			|| surface.getHeight() != srcSurf->h)
+		surface.resize(srcSurf->w, srcSurf->h);
+
+	// Convert the decoded surface to the correct pixel format, and then copy it over
+	surface.lock();
+	Graphics::Surface *convertedSurface = srcSurf->convertTo(surface._rawSurface->format);
+
+	Common::copy((byte *)convertedSurface->getPixels(), (byte *)convertedSurface->getPixels() +
+		surface.getPitch() * surface.getHeight(), (byte *)surface._rawSurface->getPixels());
+
+	delete convertedSurface;
+	surface.unlock();
+}
+
+} // End of namespace Titanic
diff --git a/engines/titanic/support/image_decoders.h b/engines/titanic/support/image_decoders.h
new file mode 100644
index 0000000000..b824b786a7
--- /dev/null
+++ b/engines/titanic/support/image_decoders.h
@@ -0,0 +1,52 @@
+/* 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 2
+ * 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, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ *
+ */
+
+#ifndef TITANIC_IMAGE_DECODERS_H
+#define TITANIC_IMAGE_DECODERS_H
+
+#include "image/jpeg.h"
+#include "image/tga.h"
+#include "titanic/support/string.h"
+#include "titanic/support/simple_file.h"
+#include "titanic/support/video_surface.h"
+
+namespace Titanic {
+
+class CJPEGDecode : public Image::JPEGDecoder {
+public:
+	/**
+	 * Decode the image file onto the passed surface
+	 */
+	void decode(OSVideoSurface &surface, const CString &name);
+};
+
+class CTargaDecode : public Image::TGADecoder {
+public:
+	/**
+	* Decode the image file onto the passed surface
+	*/
+	void decode(OSVideoSurface &surface, const CString &name);
+};
+
+} // End of namespace Titanic
+
+#endif /* TITANIC_IMAGE_DECODERS_H */
diff --git a/engines/titanic/support/mouse_cursor.cpp b/engines/titanic/support/mouse_cursor.cpp
new file mode 100644
index 0000000000..dda16c3b93
--- /dev/null
+++ b/engines/titanic/support/mouse_cursor.cpp
@@ -0,0 +1,113 @@
+/* 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 2
+ * 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, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ *
+ */
+
+#include "graphics/cursorman.h"
+#include "common/textconsole.h"
+#include "titanic/support/mouse_cursor.h"
+#include "titanic/support/movie.h"
+#include "titanic/support/screen_manager.h"
+#include "titanic/titanic.h"
+#include "titanic/support/video_surface.h"
+#include "titanic/core/resource_key.h"
+
+namespace Titanic {
+
+static const int CURSOR_DATA[NUM_CURSORS][4] = {
+	{ 1, 136, 19, 18 },
+	{ 2, 139, 1, 1 },
+	{ 3, 140, 32, 1 },
+	{ 4, 137, 13, 0 },
+	{ 5, 145, 13, 0 },
+	{ 6, 144, 13, 22 },
+	{ 7, 137, 14, 0 },
+	{ 8, 148, 22, 40 },
+	{ 9, 136, 19, 18 },
+	{ 10, 143, 11, 11 },
+	{ 11, 146, 11, 11 },
+	{ 12, 136, 19, 18 },
+	{ 13, 136, 19, 25 },
+	{ 14, 136, 13, 22 },
+	{ 15, 138, 20, 28 }
+};
+
+CMouseCursor::CMouseCursor(CScreenManager *screenManager) : 
+		_screenManager(screenManager), _cursorId(CURSOR_15) {
+	loadCursorImages();
+	setCursor(CURSOR_1);
+}
+
+CMouseCursor::~CMouseCursor() {
+	for (int idx = 0; idx < NUM_CURSORS; ++idx)
+		delete _cursors[idx]._videoSurface;
+}
+
+void CMouseCursor::loadCursorImages() {
+	const CString name("ycursors.avi");
+	const CResourceKey key(name);
+	g_vm->_filesManager.fn4(name);
+
+	// Iterate through each cursor
+	for (int idx = 0; idx < NUM_CURSORS; ++idx) {
+		assert(CURSOR_DATA[idx][0] == (idx + 1));
+		_cursors[idx]._centroid = Common::Point(CURSOR_DATA[idx][2],
+			CURSOR_DATA[idx][3]);
+
+		CVideoSurface *surface = _screenManager->createSurface(64, 64);
+		_cursors[idx]._videoSurface = surface;
+
+		OSMovie movie(key, surface);
+		movie.setFrame(idx);
+		_cursors[idx]._ptrUnknown = movie.proc21();
+		surface->set40(_cursors[idx]._ptrUnknown);
+	}
+}
+
+void CMouseCursor::show() {
+	CursorMan.showMouse(true);
+}
+
+void CMouseCursor::hide() {
+	CursorMan.showMouse(false);
+}
+
+void CMouseCursor::setCursor(CursorId cursorId) {
+	if (cursorId != _cursorId) {
+		CursorEntry &ce = _cursors[cursorId - 1];
+		CVideoSurface &surface = *ce._videoSurface;
+		surface.lock();
+
+		// ***DEBUG*** Dummy cursor
+		Common::fill(surface.getPixels(), surface.getPixels() + 128, 0x5555);
+
+		CursorMan.replaceCursor(surface.getPixels(), surface.getWidth(), surface.getHeight(),
+			ce._centroid.x, ce._centroid.y, 0, false, &g_vm->_screen->format);
+		surface.unlock();
+
+		_cursorId = cursorId;
+	}
+}
+
+void CMouseCursor::update() {
+	// No implementation needed
+}
+
+} // End of namespace Titanic
diff --git a/engines/titanic/support/mouse_cursor.h b/engines/titanic/support/mouse_cursor.h
new file mode 100644
index 0000000000..507f4ecc17
--- /dev/null
+++ b/engines/titanic/support/mouse_cursor.h
@@ -0,0 +1,97 @@
+/* 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 2
+ * 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, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ *
+ */
+
+#ifndef TITANIC_MOUSE_CURSOR_H
+#define TITANIC_MOUSE_CURSOR_H
+
+#include "common/scummsys.h"
+#include "common/rect.h"
+
+namespace Titanic {
+
+#define NUM_CURSORS 15
+
+enum CursorId {
+	CURSOR_1 = 1,
+	CURSOR_2 = 3,
+	CURSOR_3 = 3,
+	CURSOR_4 = 4,
+	CURSOR_5 = 5,
+	CURSOR_6 = 6,
+	CURSOR_7 = 7,
+	CURSOR_8 = 8,
+	CURSOR_9 = 9,
+	CURSOR_10 = 10,
+	CURSOR_11 = 11,
+	CURSOR_12 = 12,
+	CURSOR_13 = 13,
+	CURSOR_14 = 14,
+	CURSOR_15 = 15
+};
+
+class CScreenManager;
+class CVideoSurface;
+
+class CMouseCursor {
+	struct CursorEntry {
+		CVideoSurface *_videoSurface;
+		void *_ptrUnknown;
+		Common::Point _centroid;
+	};
+private:
+	CScreenManager *_screenManager;
+	CursorId _cursorId;
+	CursorEntry _cursors[NUM_CURSORS];
+
+	/**
+	 * Load the images for each cursor
+	 */
+	void loadCursorImages();
+public:
+	CMouseCursor(CScreenManager *screenManager);
+	~CMouseCursor();
+
+	/**
+	 * Make the mouse cursor visible
+	 */
+	void show();
+
+	/**
+	 * Hide the mouse cursor
+	 */
+	void hide();
+	
+	/**
+	 * Set the cursor
+	 */
+	void setCursor(CursorId cursorId);
+	
+	/**
+	 * Updates the mouse cursor
+	 */
+	void update();
+};
+
+
+} // End of namespace Titanic
+
+#endif /* TITANIC_MOUSE_CURSOR_H */
diff --git a/engines/titanic/support/movie.cpp b/engines/titanic/support/movie.cpp
new file mode 100644
index 0000000000..ed5cffaac1
--- /dev/null
+++ b/engines/titanic/support/movie.cpp
@@ -0,0 +1,114 @@
+/* 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 2
+ * 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, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ *
+ */
+
+#include "titanic/support/movie.h"
+#include "titanic/titanic.h"
+
+namespace Titanic {
+
+CMovie::CMovie() : ListItem(), _state(0), _field10(0) {
+}
+
+bool CMovie::isActive() const {
+	return g_vm->_movieList.contains(this);
+}
+
+bool CMovie::get10() {
+	if (_field10) {
+		_field10 = 0;
+		return true;
+	} else {
+		return false;
+	}
+}
+
+/*------------------------------------------------------------------------*/
+
+OSMovie::OSMovie(const CResourceKey &name, CVideoSurface *surface) : _videoSurface(surface) {
+//	_aviDecoder.loadFile(name.getString());
+}
+
+void OSMovie::proc8(int v1, CVideoSurface *surface) {
+	warning("TODO: OSMovie::proc8");
+}
+
+void OSMovie::proc9() {
+	warning("TODO: OSMovie::proc9");
+}
+
+void OSMovie::proc10() {
+	warning("TODO: OSMovie::proc10");
+}
+
+void OSMovie::proc11() {
+	warning("TODO: OSMovie::proc11");
+}
+
+void OSMovie::proc12() {
+	warning("TODO: OSMovie::proc12");
+}
+
+void OSMovie::stop() {
+	warning("TODO: OSMovie::proc13");
+}
+
+void OSMovie::proc14() {
+	warning("TODO: OSMovie::proc14");
+}
+
+void OSMovie::setFrame(uint frameNumber) {
+	warning("TODO: OSMovie::setFrame");
+	/*
+	_aviDecoder.seekToFrame(frameNumber);
+	const Graphics::Surface *s = _aviDecoder.decodeNextFrame();
+
+	_videoSurface->blitFrom(Common::Point(0, 0), s);
+	*/
+}
+
+void OSMovie::proc16() {
+	warning("TODO: OSMovie::proc16");
+}
+
+void OSMovie::proc17() {
+	warning("TODO: OSMovie::proc17");
+}
+
+void OSMovie::proc18() {
+	warning("TODO: OSMovie::proc18");
+}
+
+int OSMovie::proc19() {
+	warning("TODO: OSMovie::proc19");
+	return 0;
+}
+
+void OSMovie::proc20() {
+	warning("TODO: OSMovie::proc20");
+}
+
+void *OSMovie::proc21() {
+	warning("TODO: OSMovie::proc21");
+	return nullptr;
+}
+
+} // End of namespace Titanic
diff --git a/engines/titanic/support/movie.h b/engines/titanic/support/movie.h
new file mode 100644
index 0000000000..3529409fa5
--- /dev/null
+++ b/engines/titanic/support/movie.h
@@ -0,0 +1,95 @@
+/* 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 2
+ * 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, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ *
+ */
+
+#ifndef TITANIC_MOVIE_H
+#define TITANIC_MOVIE_H
+
+#include "video/avi_decoder.h"
+#include "titanic/core/list.h"
+#include "titanic/core/resource_key.h"
+
+namespace Titanic {
+
+class CVideoSurface;
+
+class CMovie : public ListItem {
+protected:
+	int _state;
+	int _field10;
+public:
+	CMovie();
+
+	virtual void proc8(int v1, CVideoSurface *surface) = 0;
+	virtual void proc9() = 0;
+	virtual void proc10() = 0;
+	virtual void proc11() = 0;
+	virtual void proc12() = 0;
+	virtual void stop() = 0;
+	virtual void proc14() = 0;
+	virtual void setFrame(uint frameNumber) = 0;
+	virtual void proc16() = 0;
+	virtual void proc17() = 0;
+	virtual void proc18() = 0;
+	virtual int proc19() = 0;
+	virtual void proc20() = 0;
+	virtual void *proc21() = 0;
+
+	bool isActive() const;
+
+	bool get10();
+};
+
+class OSMovie : public CMovie {
+private:
+	Video::AVIDecoder _aviDecoder;
+	CVideoSurface *_videoSurface;
+public:
+	OSMovie(const CResourceKey &name, CVideoSurface *surface);
+
+	virtual void proc8(int v1, CVideoSurface *surface);
+	virtual void proc9();
+	virtual void proc10();
+	virtual void proc11();
+	virtual void proc12();
+	virtual void stop();
+	virtual void proc14();
+
+	/**
+	 * Set the current frame number
+	 */
+	virtual void setFrame(uint frameNumber);
+	
+	virtual void proc16();
+	virtual void proc17();
+	virtual void proc18();
+	virtual int proc19();
+	virtual void proc20();
+	virtual void *proc21();
+};
+
+class CGlobalMovies : public List<CMovie> {
+public:
+};
+
+} // End of namespace Titanic
+
+#endif /* TITANIC_MOVIE_H */
diff --git a/engines/titanic/support/rect.cpp b/engines/titanic/support/rect.cpp
new file mode 100644
index 0000000000..5fce4402cb
--- /dev/null
+++ b/engines/titanic/support/rect.cpp
@@ -0,0 +1,44 @@
+/* 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 2
+ * 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, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ *
+ */
+
+#include "titanic/support/rect.h"
+
+namespace Titanic {
+
+void Rect::combine(const Rect &r) {
+	if (isEmpty() || r.isEmpty())
+		return;
+
+	Common::Rect::extend(r);
+}
+
+void Rect::constrain(const Rect &r) {
+	if (!isEmpty()) {
+		if (r.isEmpty()) {
+			clear();
+		} else {
+			Common::Rect::clip(r);
+		}
+	}
+}
+
+} // End of namespace Titanic
diff --git a/engines/titanic/support/rect.h b/engines/titanic/support/rect.h
new file mode 100644
index 0000000000..1661711870
--- /dev/null
+++ b/engines/titanic/support/rect.h
@@ -0,0 +1,61 @@
+/* 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 2
+ * 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, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ *
+ */
+
+#ifndef TITANIC_RECT_H
+#define TITANIC_RECT_H
+
+#include "common/rect.h"
+
+namespace Titanic {
+
+typedef Common::Point Point;
+
+class Rect : public Common::Rect {
+public:
+	Rect() : Common::Rect() {}
+	Rect(int16 w, int16 h) : Common::Rect(w, h) {}
+	Rect(int16 x1, int16 y1, int16 x2, int16 y2) : Common::Rect(x1, y1, x2, y2) {}
+
+	/**
+	 * Returns the top/left corner of the rect as a point
+	 */
+	operator const Point() { return Point(left, top); }
+
+	/**
+	 * Clear the rect
+	 */
+	void clear() { left = top = right = bottom = 0; }
+
+	/**
+	 * Combine another rect into this one
+	 */
+	void combine(const Rect &r);
+
+	/**
+	 * Constrains/clips to the intersection area of the given rect
+	 */
+	void constrain(const Rect &r);
+};
+
+} // End of namespace Titanic
+
+#endif /* TITANIC_RECT_H */
diff --git a/engines/titanic/support/screen_manager.cpp b/engines/titanic/support/screen_manager.cpp
new file mode 100644
index 0000000000..05dfa66854
--- /dev/null
+++ b/engines/titanic/support/screen_manager.cpp
@@ -0,0 +1,265 @@
+/* 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 2
+ * 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, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ *
+ */
+
+#include "titanic/support/screen_manager.h"
+#include "titanic/titanic.h"
+#include "titanic/support/video_surface.h"
+
+namespace Titanic {
+
+CScreenManager *CScreenManager::_screenManagerPtr;
+CScreenManager *CScreenManager::_currentScreenManagerPtr;
+
+CScreenManager::CScreenManager(TitanicEngine *vm): _vm(vm) {
+	_screenManagerPtr = nullptr;
+	_currentScreenManagerPtr = nullptr;
+
+	_frontRenderSurface = nullptr;
+	_mouseCursor = nullptr;
+	_textCursor = nullptr;
+	_inputHandler = nullptr;
+	_fontNumber = 0;
+	// TODO: Further initialization
+
+	_screenManagerPtr = this;
+}
+
+CScreenManager::~CScreenManager() {
+	_screenManagerPtr = nullptr;
+}
+
+void CScreenManager::setWindowHandle(int v) {
+	// Not needed
+}
+
+bool CScreenManager::resetWindowHandle(int v) {
+	hideCursor();
+	return true;
+}
+
+CScreenManager *CScreenManager::setCurrent() {
+	if (!_currentScreenManagerPtr)
+		_currentScreenManagerPtr = _screenManagerPtr;
+
+	return _currentScreenManagerPtr;
+}
+
+void CScreenManager::setSurfaceBounds(SurfaceNum surfaceNum, const Rect &r) {
+	if (surfaceNum >= 0 && surfaceNum < (int)_backSurfaces.size())
+		_backSurfaces[surfaceNum]._bounds = r;
+}
+
+/*------------------------------------------------------------------------*/
+
+OSScreenManager::OSScreenManager(TitanicEngine *vm): CScreenManager(vm),
+		_directDrawManager(vm, false) {
+	_field48 = 0;
+	_field4C = 0;
+	_field50 = 0;
+	_field54 = 0;
+}
+
+OSScreenManager::~OSScreenManager() {
+	destroyFrontAndBackBuffers();
+	delete _mouseCursor;
+	delete _textCursor;
+}
+
+void OSScreenManager::setMode(int width, int height, int bpp, uint numBackSurfaces, bool flag2) {
+	assert(bpp == 16);
+	destroyFrontAndBackBuffers();
+	_directDrawManager.initVideo(width, height, bpp, numBackSurfaces);
+
+	_vm->_screen->create(width, height, g_system->getScreenFormat());
+	_frontRenderSurface = new OSVideoSurface(this, nullptr);
+	_frontRenderSurface->setSurface(this, _directDrawManager._mainSurface);
+
+	_backSurfaces.resize(numBackSurfaces);
+	for (uint idx = 0; idx < numBackSurfaces; ++idx) {
+		_backSurfaces[idx]._surface = new OSVideoSurface(this, nullptr);
+		_backSurfaces[idx]._surface->setSurface(this, _directDrawManager._backSurfaces[idx]);
+	}
+
+	// Load fonts
+	_fonts[0].load(149);
+	_fonts[1].load(151);
+	_fonts[2].load(152);
+	_fonts[3].load(153);
+
+	// Load the cursors
+	loadCursors();
+}
+
+void OSScreenManager::drawCursors() {
+	warning("OSScreenManager::drawCursors");
+}
+
+DirectDrawSurface *OSScreenManager::getDDSurface(SurfaceNum surfaceNum) {
+	if (surfaceNum == SURFACE_PRIMARY)
+		return _directDrawManager._mainSurface;
+	else if (surfaceNum < (int)_backSurfaces.size())
+		return _directDrawManager._backSurfaces[surfaceNum];
+	else
+		return nullptr;
+}
+
+void OSScreenManager::proc6() {}
+void OSScreenManager::proc7() {}
+
+CVideoSurface *OSScreenManager::getSurface(SurfaceNum surfaceNum) const {
+	if (surfaceNum == SURFACE_PRIMARY)
+		return _frontRenderSurface;
+	else if (surfaceNum >= 0 && surfaceNum < (int)_backSurfaces.size())
+		return _backSurfaces[surfaceNum]._surface;
+	else
+		return nullptr;
+}
+
+void OSScreenManager::proc9() {}
+
+void OSScreenManager::fillRect(SurfaceNum surfaceNum, Rect *rect, byte r, byte g, byte b) {
+	DirectDrawSurface *surface = getDDSurface(surfaceNum);
+	if (!surface)
+		return;
+
+	// If bounds are provided, clip and use them. Otherwise, use entire surface area
+	Rect surfaceRect(0, 0, surface->getWidth(), surface->getHeight());
+	Rect tempRect;
+
+	if (rect) {
+		tempRect = *rect;
+		tempRect.clip(surfaceRect);
+	} else {
+		tempRect = surfaceRect;
+	}
+
+	if (tempRect.isValidRect())
+		surface->fillRect(&tempRect, r, g, b);
+}
+
+void OSScreenManager::blitFrom(SurfaceNum surfaceNum, CVideoSurface *src,
+	const Point *destPos, const Rect *srcRect) {
+	// Get the dest surface
+	CVideoSurface *destSurface = _frontRenderSurface;
+	if (surfaceNum < -1)
+		return;
+	if (surfaceNum >= 0 && surfaceNum < (int)_backSurfaces.size())
+		destSurface = _backSurfaces[surfaceNum]._surface;
+	if (!destSurface->hasSurface())
+		return;
+	
+	Point destPoint = destPos ? *destPos : Point(0, 0);
+	Rect srcBounds = srcRect ? *srcRect : Rect(0, 0, src->getWidth(), src->getHeight());
+	Rect *bounds = &srcBounds;
+	Rect rect2;
+
+	if (surfaceNum >= 0 && !_backSurfaces[surfaceNum]._bounds.isEmpty()) {
+		// Perform clipping to the bounds of the back surface
+		rect2 = srcBounds;
+		rect2.translate(-srcBounds.left, -srcBounds.top);
+		rect2.translate(destPoint.x, destPoint.y);
+		rect2.constrain(_backSurfaces[surfaceNum]._bounds);
+
+		rect2.translate(-destPoint.x, -destPoint.y);
+		rect2.translate(srcBounds.left, srcBounds.top);
+
+		if (rect2.isEmpty())
+			return;
+
+		destPoint.x += rect2.left - srcBounds.left;
+		destPoint.y += rect2.top - srcBounds.top;
+		bounds = &rect2;
+	}
+
+	if (!bounds->isEmpty())
+		destSurface->blitFrom(destPoint, src, bounds);
+}
+
+void OSScreenManager::proc12() {}
+void OSScreenManager::proc13() {}
+void OSScreenManager::proc14() {}
+void OSScreenManager::proc15() {}
+
+void OSScreenManager::writeString(int maxWidth, const CString &text, int *v1, int *v2) {
+	_fonts[_fontNumber].writeString(maxWidth, text, v1, v2);
+}
+
+void OSScreenManager::getFont() {}
+void OSScreenManager::proc18() {}
+void OSScreenManager::proc19() {}
+
+void OSScreenManager::clearSurface(SurfaceNum surfaceNum, Rect *bounds) {
+	if (surfaceNum == SURFACE_PRIMARY)
+		_directDrawManager._mainSurface->fill(bounds, 0);
+	else if (surfaceNum >= 0 && surfaceNum < (int)_backSurfaces.size())
+		_directDrawManager._backSurfaces[surfaceNum]->fill(bounds, 0);
+}
+
+void OSScreenManager::resizeSurface(CVideoSurface *surface, int width, int height) {
+	DirectDrawSurface *ddSurface = _directDrawManager.createSurface(width, height, 0);
+	surface->setSurface(this, ddSurface);
+}
+
+CVideoSurface *OSScreenManager::createSurface(int w, int h) {
+	DirectDrawSurface *ddSurface = _directDrawManager.createSurface(w, h, 0);
+	return new OSVideoSurface(this, ddSurface);
+}
+
+CVideoSurface *OSScreenManager::createSurface(const CResourceKey &key) {
+	return new OSVideoSurface(this, key);
+}
+
+void OSScreenManager::proc23() {}
+void OSScreenManager::proc24() {}
+void OSScreenManager::proc25() {}
+
+void OSScreenManager::showCursor() {
+
+}
+
+void OSScreenManager::hideCursor() {
+
+}
+
+void OSScreenManager::destroyFrontAndBackBuffers() {
+	delete _frontRenderSurface;
+	_frontRenderSurface = nullptr;
+
+	for (uint idx = 0; idx < _backSurfaces.size(); ++idx)
+		delete _backSurfaces[idx]._surface;
+	_backSurfaces.clear();
+}
+
+void OSScreenManager::loadCursors() {
+	if (_mouseCursor) {
+		hideCursor();
+		delete _mouseCursor;
+	}
+	_mouseCursor = new CMouseCursor(this);
+	showCursor();
+
+	if (!_textCursor) {
+		_textCursor = new CTextCursor();
+	}
+}
+
+} // End of namespace Titanic
diff --git a/engines/titanic/support/screen_manager.h b/engines/titanic/support/screen_manager.h
new file mode 100644
index 0000000000..affe2ec0c9
--- /dev/null
+++ b/engines/titanic/support/screen_manager.h
@@ -0,0 +1,248 @@
+/* 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 2
+ * 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, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ *
+ */
+
+#ifndef TITANIC_SCREEN_MANAGER_H
+#define TITANIC_SCREEN_MANAGER_H
+
+#include "common/scummsys.h"
+#include "common/array.h"
+#include "titanic/support/direct_draw.h"
+#include "titanic/support/font.h"
+#include "titanic/input_handler.h"
+#include "titanic/support/mouse_cursor.h"
+#include "titanic/support/text_cursor.h"
+#include "titanic/support/video_surface.h"
+#include "titanic/core/resource_key.h"
+
+namespace Titanic {
+
+/**
+ * The original used page flipping with one primary and one back buffer.
+ * Since we don't need that in ScummVM, the back buffer number below is
+ * remapped to the primary surface
+ */
+enum SurfaceNum {
+	SURFACE_PRIMARY = -1,
+	SURFACE_BACKBUFFER = -1
+};
+
+class TitanicEngine;
+
+class CScreenManager {
+	struct VideoSurfaceEntry {
+		CVideoSurface *_surface;
+		Rect _bounds;
+	};
+protected:
+	TitanicEngine *_vm;
+public:
+	static CScreenManager *_screenManagerPtr;
+	static CScreenManager *_currentScreenManagerPtr;
+
+	/**
+	 * Set the current screen manager
+	 */
+	static CScreenManager *setCurrent();
+public:
+	Common::Array<VideoSurfaceEntry> _backSurfaces;
+	CVideoSurface *_frontRenderSurface;
+	CMouseCursor *_mouseCursor;
+	CTextCursor *_textCursor;
+	CInputHandler *_inputHandler;
+	int _fontNumber;
+public:
+	CScreenManager(TitanicEngine *vm);
+	virtual ~CScreenManager();
+
+	void fn1() {}
+	void fn2() {}
+
+	virtual void setWindowHandle(int v);
+	virtual bool resetWindowHandle(int v);
+	
+	/**
+	 * Sets the video mode
+	 */
+	virtual void setMode(int width, int height, int bpp, uint numBackSurfaces, bool flag2) = 0;
+
+	/**
+	 * Handles drawing the cursors
+	 */
+	virtual void drawCursors() = 0;
+	
+	virtual void proc6() = 0;
+	virtual void proc7() = 0;
+	virtual CVideoSurface *getSurface(SurfaceNum surfaceNum) const = 0;
+	virtual void proc9() = 0;
+	
+	/**
+	 * Fill an area with a specific color
+	 */
+	virtual void fillRect(SurfaceNum surfaceNum, Rect *rect, byte r, byte g, byte b) = 0;
+
+	/**
+	 * Blits a surface onto one of the screen surfaces
+	 */
+	virtual void blitFrom(SurfaceNum surfaceNum, CVideoSurface *src, const Point *destPos = nullptr,
+		const Rect *srcRect = nullptr) = 0;
+
+	virtual void proc12() = 0;
+	virtual void proc13() = 0;
+	virtual void proc14() = 0;
+	virtual void proc15() = 0;
+
+
+	/**
+	 * Write out a string
+	 */
+	virtual void writeString(int maxWidth, const CString &text, int *v1, int *v2) = 0;
+
+	virtual void getFont() = 0;
+	virtual void proc18() = 0;
+	virtual void proc19() = 0;
+
+	/**
+	 * Clear a portion of a specified surface
+	 */
+	virtual void clearSurface(SurfaceNum surfaceNum, Rect *_bounds) = 0;
+
+	/**
+	 * Resize the passed surface
+	 */
+	virtual void resizeSurface(CVideoSurface *surface, int width, int height) = 0;
+
+	/**
+	 * Creates a surface of a given size
+	 */
+	virtual CVideoSurface *createSurface(int w, int h) = 0;
+	
+	/**
+	 * Creates a surface from a specified resource
+	 */
+	virtual CVideoSurface *createSurface(const CResourceKey &key) = 0;
+	
+	virtual void proc24() = 0;
+	virtual void proc25() = 0;
+	virtual void showCursor() = 0;
+	virtual void hideCursor() = 0;
+
+	void setSurfaceBounds(SurfaceNum surfaceNum, const Rect &r);
+};
+
+class OSScreenManager: CScreenManager {
+private:
+	DirectDrawManager _directDrawManager;
+
+	/**
+	 * Frees any surface buffers
+	 */
+	void destroyFrontAndBackBuffers();
+
+	/**
+	 * Load game cursors
+	 */
+	void loadCursors();
+
+	/**
+	 * Gets an underlying surface
+	 */
+	DirectDrawSurface *getDDSurface(SurfaceNum surfaceNum);
+public:
+	int _field48;
+	int _field4C;
+	int _field50;
+	int _field54;
+	STFont _fonts[4];
+public:
+	OSScreenManager(TitanicEngine *vm);
+	virtual ~OSScreenManager();
+
+	/**
+	 * Sets the video mode
+	 */
+	virtual void setMode(int width, int height, int bpp, uint numBackSurfaces, bool flag2);
+
+	/**
+	 * Handles drawing the cursors
+	 */
+	virtual void drawCursors();
+
+	virtual void proc6();
+	virtual void proc7();
+	virtual CVideoSurface *getSurface(SurfaceNum surfaceNum) const;
+	virtual void proc9();
+
+	/**
+	 * Fill an area with a specific color
+	 */
+	virtual void fillRect(SurfaceNum surfaceNum, Rect *rect, byte r, byte g, byte b);
+
+	/**
+	 * Blits a surface onto one of the screen surfaces
+	 */
+	virtual void blitFrom(SurfaceNum surfaceNum, CVideoSurface *src, const Point *destPos,
+		const Rect *srcRect = nullptr);
+
+	virtual void proc12();
+	virtual void proc13();
+	virtual void proc14();
+	virtual void proc15();
+
+	/**
+	 * Write out a string
+	 */
+	virtual void writeString(int maxWidth, const CString &text, int *v1, int *v2);
+
+	virtual void getFont();
+	virtual void proc18();
+	virtual void proc19();
+
+	/**
+	 * Clear a portion of the screen surface
+	 */
+	virtual void clearSurface(SurfaceNum surfaceNum, Rect *bounds);
+
+	/**
+	 * Resize the passed surface
+	 */
+	virtual void resizeSurface(CVideoSurface *surface, int width, int height);
+
+	/**
+	 * Creates a surface of a given size
+	 */
+	virtual CVideoSurface *createSurface(int w, int h);
+	
+	/**
+	 * Creates a surface from a specified resource
+	 */
+	virtual CVideoSurface *createSurface(const CResourceKey &key);
+
+	virtual void proc23();
+	virtual void proc24();
+	virtual void proc25();
+	virtual void showCursor();
+	virtual void hideCursor();
+};
+
+} // End of namespace Titanic
+
+#endif /* TITANIC_SCREEN_MANAGER_H */
diff --git a/engines/titanic/support/simple_file.cpp b/engines/titanic/support/simple_file.cpp
new file mode 100644
index 0000000000..fccf6c5b4f
--- /dev/null
+++ b/engines/titanic/support/simple_file.cpp
@@ -0,0 +1,385 @@
+/* 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 2
+ * 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, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ *
+ */
+
+#include "common/util.h"
+#include "titanic/support/simple_file.h"
+
+namespace Titanic {
+
+bool File::open(const Common::String &name) {
+	if (!Common::File::open(name))
+		error("Could not open file - %s", name.c_str());
+	return true;
+}
+
+/*------------------------------------------------------------------------*/
+
+SimpleFile::SimpleFile(): _inStream(nullptr), _outStream(nullptr), _lineCount(1) {
+}
+
+SimpleFile::~SimpleFile() {
+	close();
+}
+
+void SimpleFile::open(Common::SeekableReadStream *stream) {
+	close();	
+	_inStream = stream;
+}
+
+void SimpleFile::open(Common::OutSaveFile *stream) {
+	close();
+	_outStream = stream;
+}
+
+void SimpleFile::close() {
+	if (_outStream) {
+		_outStream->finalize();
+		delete _outStream;
+		_outStream = nullptr;
+	}
+
+	if (_inStream) {
+		delete _inStream;
+		_inStream = nullptr;
+	}
+}
+
+void SimpleFile::safeRead(void *dst, size_t count) {
+	if (unsafeRead(dst, count) != count)
+		error("Could not read %d bytes", (int)count);
+}
+
+size_t SimpleFile::unsafeRead(void *dst, size_t count) {
+	assert(_inStream);
+	return _inStream->read(dst, count);
+}
+
+size_t SimpleFile::write(const void *src, size_t count) {
+	assert(_outStream);
+	return _outStream->write(src, count);
+}
+
+CString SimpleFile::readString() {
+	char c;
+	CString result;
+	bool backslashFlag = false;
+
+	// First skip any spaces
+	do {
+		safeRead(&c, 1);
+	} while (Common::isSpace(c));
+
+	// Ensure we've found a starting quote for the string
+	if (c != '"')
+		error("Could not find starting quote");
+
+	bool endFlag = false;
+	while (!endFlag) {
+		// Read the next character
+		safeRead(&c, 1);
+
+		if (backslashFlag) {
+			backslashFlag = false;
+			switch (c) {
+			case 'n':
+				result += '\n';
+				break;
+			case 'r':
+				result += '\r';
+				break;
+			case '\t':
+				result += '\t';
+				break;
+			default:
+				result += c;
+				break;
+			}
+		} else {
+			switch (c) {
+			case '"':
+				endFlag = true;
+				break;
+			case '\\':
+				backslashFlag = true;
+				break;
+			default:
+				result += c;
+				break;
+			}
+		}
+	}
+
+	// Return the string
+	return result;
+}
+
+int SimpleFile::readNumber() {
+	char c;
+	int result = 0;
+	bool minusFlag = false;
+
+	// First skip any spaces
+	do {
+		safeRead(&c, 1);
+	} while (Common::isSpace(c));
+
+	// Check for prefix sign
+	if (c == '+' || c == '-') {
+		minusFlag = c == '-';
+		safeRead(&c, 1);
+	}
+
+	// Read in the number
+	if (!Common::isDigit(c))
+		error("Invalid number");
+
+	while (Common::isDigit(c)) {
+		result = result * 10 + (c - '0');
+		safeRead(&c, 1);
+	}
+
+	// Finally, if it's a minus value, then negate it
+	if (minusFlag)
+		result = -result;
+
+	return result;
+}
+
+double SimpleFile::readFloat() {
+	char c;
+	Common::String result;
+
+	// First skip any spaces
+	do {
+		safeRead(&c, 1);
+	} while (Common::isSpace(c));
+
+	// Check for prefix sign
+	if (c == '+' || c == '-') {
+		result += c;
+		safeRead(&c, 1);
+	}
+
+	// Read in the number
+	if (!Common::isDigit(c))
+		error("Invalid number");
+
+	while (Common::isDigit(c) || c == '.') {
+		result += c;
+		safeRead(&c, 1);
+	}
+
+	// Convert to a float and return it
+	float floatValue;
+	sscanf(result.c_str(), "%f", &floatValue);
+
+	return floatValue;
+}
+
+Point SimpleFile::readPoint() {
+	Point pt;
+	pt.x = readNumber();
+	pt.y = readNumber();
+
+	return pt;
+}
+
+Rect SimpleFile::readRect() {
+	Rect r;
+	r.left = readNumber();
+	r.top = readNumber();
+	r.right = readNumber();
+	r.bottom = readNumber();
+
+	return r;
+}
+
+void SimpleFile::readBuffer(char *buffer, size_t count) {
+	CString tempString = readString();
+	if (buffer) {
+		strncpy(buffer, tempString.c_str(), count);
+		buffer[count - 1] = '\0';
+	}
+}
+
+void SimpleFile::writeLine(const CString &str) {
+	write(str.c_str(), str.size());
+	write("\r\n", 2);
+}
+
+void SimpleFile::writeString(const CString &str) {
+	if (str.empty())
+		return;
+
+	const char *msgP = str.c_str();
+	char c;
+	
+	while ((c = *msgP++) != '\0') {
+		switch (c) {
+		case '\r':
+			write("\\r", 2);
+			break;
+		case '\n':
+			write("\\n", 2);
+			break;
+		case '\t':
+			write("\\t", 2);
+			break;
+		case '\"':
+			write("\\\"", 2);
+			break;
+		case '\\':
+			write("\\\\", 2);
+			break;
+		case '{':
+			write("\\{", 2);
+			break;
+		case '}':
+			write("\\}", 2);
+			break;
+		default:
+			write(&c, 1);
+			break;
+		}
+	}
+}
+
+void SimpleFile::writeQuotedString(const CString &str) {
+	write("\"", 1);
+	writeString(str);
+	write("\" ", 2);
+}
+
+void SimpleFile::writeQuotedLine(const CString &str, int indent) {
+	writeIndent(indent);
+	writeQuotedString(str);
+	write("\n", 1);
+}
+
+void SimpleFile::writeNumber(int val) {
+	CString str = CString::format("%d ", val);
+	write(str.c_str(), str.size());
+}
+
+void SimpleFile::writeNumberLine(int val, int indent) {
+	writeIndent(indent);
+	writeNumber(val);
+	write("\n", 1);
+}
+
+void SimpleFile::writeFloat(double val) {
+	Common::String valStr = Common::String::format("%f ", val);
+	write(valStr.c_str(), valStr.size());
+}
+
+void SimpleFile::writeFloatLine(double val, int indent) {
+	writeIndent(indent);
+	writeFloat(val);
+	write("\n", 1);
+}
+
+void SimpleFile::writePoint(const Point &pt, int indent) {
+	writeIndent(indent);
+	writeNumber(pt.x);
+	writeNumber(pt.y);
+	write("\n", 1);
+}
+
+void SimpleFile::writeRect(const Rect &r, int indent) {
+	writePoint(Point(r.left, r.top), indent);
+	writePoint(Point(r.right, r.bottom), indent);
+}
+
+void SimpleFile::writeIndent(uint indent) {
+	for (uint idx = 0; idx < indent; ++idx)
+		write("\t", 1);
+}
+
+bool SimpleFile::IsClassStart() {
+	char c;
+
+	do {
+		safeRead(&c, 1);
+	} while (Common::isSpace(c));
+
+	assert(c == '{' || c == '}');
+	return c == '{';
+}
+
+void SimpleFile::writeClassStart(const CString &classStr, int indent) {
+	write("\n", 1);
+	writeIndent(indent);
+	write("{\n", 2);
+	writeIndent(indent + 1);
+	writeQuotedString(classStr);
+	write("\n", 1);
+}
+
+void SimpleFile::writeClassEnd(int indent) {
+	writeIndent(indent);
+	write("}\n", 2);
+}
+
+/*------------------------------------------------------------------------*/
+
+void StdCWadFile::open(const CString &name) {
+	File f;
+
+	// Check for whether it is indeed a file/resource pair
+	int idx = name.indexOf('#');
+
+	if (idx < 0) {
+		// Nope, so open up file for standard reading
+		assert(!name.empty());
+		f.open(name);
+
+		SimpleFile::open(f.readStream(f.size()));
+		return;
+	}
+
+	// Split up the name and resource, and get the resource index
+	CString filename = name.left(idx) + ".st";
+	int extPos = name.lastIndexOf('.');
+	CString resStr = name.mid(idx + 1, extPos - idx - 1);
+	int resIndex = resStr.readInt();
+
+	// Open up the index for access 
+	f.open(filename);
+	int indexSize = f.readUint32LE() / 4;
+	assert(resIndex < indexSize);
+
+	// Get the specific resource's offset, and size by also
+	// getting the offset of the following resource
+	f.seek(resIndex * 4);
+	uint resOffset = f.readUint32LE();
+	uint nextOffset = (resIndex == (indexSize - 1)) ? f.size() :
+		f.readUint32LE();
+
+	// Read in the resource
+	f.seek(resOffset);
+	Common::SeekableReadStream *stream = f.readStream(nextOffset - resOffset);
+	SimpleFile::open(stream);
+
+	f.close();
+}
+
+} // End of namespace Titanic
diff --git a/engines/titanic/support/simple_file.h b/engines/titanic/support/simple_file.h
new file mode 100644
index 0000000000..0ba7699088
--- /dev/null
+++ b/engines/titanic/support/simple_file.h
@@ -0,0 +1,236 @@
+/* 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 2
+ * 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, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ *
+ */
+
+#ifndef TITANIC_SIMPLE_FILE_H
+#define TITANIC_SIMPLE_FILE_H
+
+#include "common/file.h"
+#include "titanic/support/rect.h"
+#include "common/savefile.h"
+#include "common/stream.h"
+#include "common/zlib.h"
+#include "titanic/support/string.h"
+
+namespace Titanic {
+
+class Decompressor;
+class DecompressorData;
+
+/**
+ * Simple ScummVM File descendent that throws a wobbly if
+ * the file it tries to open isn't present
+ */
+class File : public Common::File {
+public:
+	virtual bool open(const Common::String &name);
+};
+
+/**
+ * This class implements basic reading and writing to files
+ */
+class SimpleFile {
+protected:
+	Common::SeekableReadStream *_inStream;
+	Common::OutSaveFile *_outStream;
+	int _lineCount;
+public:
+	SimpleFile();
+	virtual ~SimpleFile();
+
+	/**
+	 * Set up a stream for read access
+	 */
+	virtual void open(Common::SeekableReadStream *stream);
+
+	/**
+	 * Set up a stream for write access
+	 */
+	virtual void open(Common::OutSaveFile *stream);
+
+	/**
+	 * Close the file
+	 */
+	virtual void close();
+
+	/**
+	 * Read from the file with validation
+	 */
+	virtual void safeRead(void *dst, size_t count);
+
+	/**
+	 * Read from the file
+	 */
+	virtual size_t unsafeRead(void *dst, size_t count);
+
+	/**
+	 * Write out data
+	 */
+	virtual size_t write(const void *src, size_t count);
+
+	/**
+	 * Read a string from the file
+	 */
+	CString readString();
+
+	/**
+	 * Read a number from the file
+	 */
+	int readNumber();
+
+	/**
+	 * Read a floating point number from the file
+	 */
+	double readFloat();
+
+	/**
+	 * Read in a point
+	 */
+	Point readPoint();
+
+	/**
+	 * Read in a rect
+	 */
+	Rect readRect();
+
+	/**
+	 * Read a string and copy it into an optionally passed buffer
+	 */
+	void readBuffer(char *buffer = nullptr, size_t count = 0);
+
+	/**
+	 * Write a string line
+	 */
+	void writeLine(const CString &str);
+
+	/**
+	 * Write a string
+	 */
+	void writeString(const CString &str);
+
+	/**
+	 * Write a quoted string
+	 */
+	void writeQuotedString(const CString &str);
+
+	/**
+	 * Write a quoted string line
+	 */
+	void writeQuotedLine(const CString &str, int indent);
+
+	/**
+	 * Write a number to file
+	 */
+	void writeNumber(int val);
+
+	/**
+	 * Write a number line to file
+	 */
+	void writeNumberLine(int val, int indent);
+
+	/**
+	 * Write a floating point number
+	 */
+	void writeFloat(double val);
+
+	/**
+	 * Write a floating point number as a line
+	 */
+	void writeFloatLine(double val, int indent);
+
+	/**
+	 * Write out a point line
+	 */
+	void writePoint(const Point &pt, int indent);
+
+	/**
+	 * Write out a rect line
+	 */
+	void writeRect(const Rect &r, int indent);
+
+	/**
+	 * Write out a number of tabs to form an indent in the output
+	 */
+	void writeIndent(uint indent);
+
+	/**
+	 * Validates that the following non-space character is either
+	 * an opening or closing squiggly bracket denoting a class
+	 * definition start or end. Returns true if it's a class start
+	 */
+	bool IsClassStart();
+
+	/**
+	 * Write the starting header for a class definition
+	 */
+	void writeClassStart(const CString &classStr, int indent);
+
+	/**
+	 * Write out the ending footer for a class definition
+	 */
+	void writeClassEnd(int indent);
+};
+
+/**
+ * Derived file that handles compressed files
+ */
+class CompressedFile : public SimpleFile {
+public:
+	CompressedFile() : SimpleFile() {}
+	virtual ~CompressedFile() {}
+
+	/**
+	 * Set up a stream for read access
+	 */
+	virtual void open(Common::SeekableReadStream *stream) {
+		SimpleFile::open(Common::wrapCompressedReadStream(stream));
+	}
+
+	/**
+	 * Set up a stream for write access
+	 */
+	virtual void open(Common::OutSaveFile *stream) {
+		SimpleFile::open(Common::wrapCompressedWriteStream(stream));
+	}
+};
+
+/**
+ * Derived file that handles WAD archives containing multiple files
+ */
+class StdCWadFile : public SimpleFile {
+public:
+	StdCWadFile() : SimpleFile() {}
+	virtual ~StdCWadFile() {}
+
+	/**
+	 * Open up the specified file
+	 */
+	void open(const CString &name);
+
+	/**
+	 * Return a reference to the read stream
+	 */
+	Common::SeekableReadStream *readStream() const { return _inStream; }
+};
+
+} // End of namespace Titanic
+
+#endif /* TITANIC_SIMPLE_FILE_H */
diff --git a/engines/titanic/support/string.cpp b/engines/titanic/support/string.cpp
new file mode 100644
index 0000000000..86dc0be0b0
--- /dev/null
+++ b/engines/titanic/support/string.cpp
@@ -0,0 +1,122 @@
+/* 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 2
+ * 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, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ *
+ */
+
+#include "common/algorithm.h"
+#include "titanic/support/string.h"
+
+namespace Titanic {
+
+CString::CString(char c, uint32 len) : Common::String() {
+	ensureCapacity(len, false);
+	for (uint idx = 0; idx < len; ++idx)
+		(*this) += c;
+}
+
+CString::CString(int val) : Common::String() {
+	char buffer[16];
+	itoa(val, buffer, 10);
+	*this += buffer;
+}
+
+CString CString::left(uint count) const {
+	return (count > size()) ? CString() : CString(c_str(), c_str() + count);
+}
+
+CString CString::right(uint count) const {
+	uint strSize = size();
+	return (count > strSize) ? CString() : 
+		CString(c_str() + strSize - count, c_str() + strSize);
+}
+
+CString CString::mid(uint start, uint count) const {
+	if (start >= size())
+		return CString();
+	else
+		return CString(c_str() + start, MIN(count, size() - start));
+}
+
+CString CString::mid(uint start) const {
+	uint strSize = size();
+	assert(start <= strSize);
+	return mid(start, strSize - start);
+}
+
+int CString::indexOf(char c) const {
+	const char *charP = strchr(c_str(), c);
+	return charP ? charP - c_str() : -1;
+}
+
+int CString::lastIndexOf(char c) const {
+	const char *charP = strrchr(c_str(), c);
+	return charP ? charP - c_str() : -1;
+}
+
+FileType CString::fileTypeSuffix() const {
+	CString ext = right(1);
+	if (ext == "0" || ext == "4")
+		return FILETYPE_IMAGE;
+	else if (ext == "1")
+		return FILETYPE_WAV;
+	else if (ext == "2" || ext == "3")
+		return FILETYPE_MOVIE;
+	
+	ext = right(3);
+	if (ext == "tga" || ext == "jpg")
+		return FILETYPE_IMAGE;
+	else if (ext == "wav")
+		return FILETYPE_WAV;
+	else if (ext == "avi" || ext == "mov")
+		return FILETYPE_MOVIE;
+	else if (ext == "dlg")
+		return FILETYPE_DLG;
+	else
+		return FILETYPE_UNKNOWN;
+}
+
+ImageType CString::imageTypeSuffix() const {
+	CString ext = right(1);
+	if (ext == "0")
+		return IMAGETYPE_TARGA;
+	else if (ext == "4")
+		return IMAGETYPE_JPEG;
+
+	ext = right(3);
+	if (ext == "tga")
+		return IMAGETYPE_TARGA;
+	else if (ext == "jpg")
+		return IMAGETYPE_JPEG;
+	else
+		return IMAGETYPE_UNKNOWN;
+}
+
+CString CString::format(const char *fmt, ...) {
+	String output;
+
+	va_list va;
+	va_start(va, fmt);
+	output = String::vformat(fmt, va);
+	va_end(va);
+
+	return output;
+}
+
+} // End of namespace Titanic
diff --git a/engines/titanic/support/string.h b/engines/titanic/support/string.h
new file mode 100644
index 0000000000..02775de067
--- /dev/null
+++ b/engines/titanic/support/string.h
@@ -0,0 +1,106 @@
+/* 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 2
+ * 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, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ *
+ */
+
+#ifndef TITANIC_STRING_H
+#define TITANIC_STRING_H
+
+#include "common/scummsys.h"
+#include "common/str.h"
+
+namespace Titanic {
+
+enum FileType {
+	FILETYPE_UNKNOWN = 0, FILETYPE_IMAGE = 1, FILETYPE_MOVIE = 2,
+	FILETYPE_WAV = 3, FILETYPE_DLG = 4
+};
+
+enum ImageType {
+	IMAGETYPE_UNKNOWN = 0, IMAGETYPE_TARGA = 1, IMAGETYPE_JPEG = 2
+};
+
+class CString : public Common::String {
+public:
+	CString() : Common::String() {}
+	CString(const char *str) : Common::String(str) {}
+	CString(const char *str, uint32 len) : Common::String(str, len) {}
+	CString(const char *beginP, const char *endP) : Common::String(beginP, endP) {}
+	CString(const String &str) : Common::String(str) {}
+	CString(char c, uint32 len);
+	explicit CString(char c) : Common::String(c) {}
+	explicit CString(int val);
+
+	/**
+	 * Returns the left n characters of the string
+	 */
+	CString left(uint count) const;
+
+	/**
+	 * Returns the right n characters of the string
+	 */
+	CString right(uint count) const;
+
+	/**
+	 * Returns a substring from within the string
+	 */
+	CString mid(uint start, uint count) const;
+
+	/**
+	 * Returns a substring from within the string
+	 */
+	CString mid(uint start) const;
+
+	/**
+	 * Returns the index of the first occurance of a given character
+	 */
+	int indexOf(char c) const;
+
+	/**
+	 * Returns the index of the last occurance of a given character
+	 */
+	int lastIndexOf(char c) const;
+
+	/**
+	 * Returns the type of a filename based on it's extension
+	 */
+	FileType fileTypeSuffix() const;
+
+	/**
+	 * Returns the type of an image filename based on it's extension
+	 */
+	ImageType imageTypeSuffix() const;
+
+	/**
+	 * Parses the string as an integer and returns the value
+	 */
+	int readInt() const {
+		return atoi(c_str());
+	}
+
+	/**
+	 * Format a string
+	 */
+	static CString format(const char *fmt, ...);
+};
+
+} // End of namespace Titanic
+
+#endif /* TITANIC_STRING_H */
diff --git a/engines/titanic/support/text_cursor.cpp b/engines/titanic/support/text_cursor.cpp
new file mode 100644
index 0000000000..fd0c1d22dd
--- /dev/null
+++ b/engines/titanic/support/text_cursor.cpp
@@ -0,0 +1,36 @@
+/* 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 2
+ * 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, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ *
+ */
+
+#include "common/textconsole.h"
+#include "titanic/support/text_cursor.h"
+
+namespace Titanic {
+
+CTextCursor::CTextCursor() : _active(false) {
+}
+
+Rect CTextCursor::getBounds() {
+	warning("CTextCursor::getBounds");
+	return Rect();
+}
+
+} // End of namespace Titanic
diff --git a/engines/titanic/support/text_cursor.h b/engines/titanic/support/text_cursor.h
new file mode 100644
index 0000000000..b6480673eb
--- /dev/null
+++ b/engines/titanic/support/text_cursor.h
@@ -0,0 +1,42 @@
+/* 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 2
+ * 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, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ *
+ */
+
+#ifndef TITANIC_TEXT_CURSOR_H
+#define TITANIC_TEXT_CURSOR_H
+
+#include "common/scummsys.h"
+#include "titanic/support/rect.h"
+
+namespace Titanic {
+
+class CTextCursor {
+public:
+	bool _active;
+public:
+	CTextCursor();
+
+	Rect getBounds();
+};
+
+} // End of namespace Titanic
+
+#endif /* TITANIC_TEXT_CURSOR_H */
diff --git a/engines/titanic/support/video_surface.cpp b/engines/titanic/support/video_surface.cpp
new file mode 100644
index 0000000000..6bba24de5f
--- /dev/null
+++ b/engines/titanic/support/video_surface.cpp
@@ -0,0 +1,376 @@
+/* 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 2
+ * 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, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ *
+ */
+
+#include "titanic/support/video_surface.h"
+#include "titanic/support/image_decoders.h"
+#include "titanic/support/screen_manager.h"
+
+namespace Titanic {
+
+int CVideoSurface::_videoSurfaceCounter = 0;
+
+CVideoSurface::CVideoSurface(CScreenManager *screenManager) :
+		_screenManager(screenManager), _rawSurface(nullptr), _movie(nullptr),
+		_pendingLoad(false), _blitStyleFlag(false), _blitFlag(false),
+		_field40(nullptr), _field44(4), _field48(0), _field50(1) {
+	_videoSurfaceNum = _videoSurfaceCounter++;
+}
+
+CVideoSurface::~CVideoSurface() {
+	if (_ddSurface)
+		_videoSurfaceCounter -= freeSurface();
+	--_videoSurfaceCounter;
+}
+
+void CVideoSurface::setSurface(CScreenManager *screenManager, DirectDrawSurface *surface) {
+	_screenManager = screenManager;
+	_ddSurface = surface;
+}
+
+void CVideoSurface::blitFrom(const Point &destPos, CVideoSurface *src, const Rect *srcRect) {
+	if (loadIfReady() && src->loadIfReady() && _ddSurface && src->_ddSurface) {
+		Rect srcBounds, destBounds;
+		clipBounds(srcBounds, destBounds, src, srcRect, &destPos);
+
+		if (_blitStyleFlag)
+			blitRect2(srcBounds, destBounds, src);
+		else
+			blitRect1(srcBounds, destBounds, src);
+	}
+}
+
+void CVideoSurface::blitFrom(const Point &destPos, const Graphics::Surface *src) {
+	lock();
+	_rawSurface->blitFrom(*src, destPos);
+	unlock();
+}
+
+void CVideoSurface::clipBounds(Rect &srcRect, Rect &destRect,
+		CVideoSurface *srcSurface, const Rect *subRect, const Point *destPos) {
+	// Figure out initial source rect and dest rect, based on whether
+	// specific subRect and/or destPos have been passed
+	if (destPos) {
+		destRect.left = destPos->x;
+		destRect.top = destPos->y;
+	} else {
+		destRect.left = destRect.top = 0;
+	}
+
+	if (subRect) {
+		destRect.right = destRect.left + subRect->width();
+		destRect.bottom = destRect.top + subRect->height();
+		srcRect = *subRect;
+	} else {
+		srcRect.right = srcRect.left + srcSurface->getWidth();
+		srcRect.bottom = srcRect.top + srcSurface->getHeight();
+		srcRect = Rect(0, 0, srcSurface->getWidth(), srcSurface->getHeight());
+	}
+
+	// Clip destination rect to be on-screen
+	if (destRect.left < 0) {
+		srcRect.left -= destRect.left;
+		destRect.left = 0;
+	}
+	if (destRect.top < 0) {
+		srcRect.top -= destRect.top;
+		destRect.top = 0;
+	}
+	if (destRect.right > getWidth()) {
+		srcRect.right += getWidth() - destRect.right;
+		destRect.right = getWidth();
+	}
+	if (destRect.bottom > getHeight()) {
+		srcRect.bottom += getHeight() - destRect.bottom;
+		destRect.bottom = getHeight();
+	}
+
+	// Clip source rect to be within the source surface
+	if (srcRect.left < 0) {
+		destRect.left -= srcRect.left;
+		srcRect.left = 0;
+	}
+	if (srcRect.top < 0) {
+		destRect.top -= srcRect.top;
+		srcRect.top = 0;
+	}
+	if (srcRect.right > srcSurface->getWidth()) {
+		destRect.right += srcSurface->getWidth() - srcRect.right;
+		srcRect.right = srcSurface->getWidth();
+	}
+	if (srcRect.bottom > srcSurface->getHeight()) {
+		destRect.bottom += srcSurface->getHeight() - srcRect.bottom;
+		srcRect.bottom = srcSurface->getHeight();
+	}
+
+	// Validate that the resulting rects are valid
+	if (destRect.left >= destRect.right || destRect.top >= destRect.bottom
+		|| srcRect.left >= srcRect.right || srcRect.top >= srcRect.bottom)
+		error("Invalid rect");
+}
+
+void CVideoSurface::blitRect1(const Rect &srcRect, const Rect &destRect, CVideoSurface *src) {
+	src->lock();
+	lock();
+
+	// TODO: Do it like the original does it
+	_rawSurface->transBlitFrom(*src->_rawSurface, srcRect, destRect,
+		getTransparencyColor());
+
+	src->unlock();
+	unlock();
+}
+
+void CVideoSurface::blitRect2(const Rect &srcRect, const Rect &destRect, CVideoSurface *src) {
+	// TODO: Do it like the original does it
+	blitRect1(srcRect, destRect, src);
+}
+
+uint CVideoSurface::getTransparencyColor() {
+	uint32 val = -(getPixelDepth() - 2);
+	val &= 0xFFFF8400;
+	val += 0xF81F;
+	return val;
+}
+
+bool CVideoSurface::proc45() {
+	if (_field50) {
+		_field50 = 0;
+		return true;
+	} else if (_movie) {
+		return _movie->get10();
+	} else {
+		return false;
+	}
+}
+
+/*------------------------------------------------------------------------*/
+
+OSVideoSurface::OSVideoSurface(CScreenManager *screenManager, DirectDrawSurface *surface) :
+		CVideoSurface(screenManager) {
+	_ddSurface = surface;
+}
+
+OSVideoSurface::OSVideoSurface(CScreenManager *screenManager, const CResourceKey &key, bool pendingLoad) :
+		CVideoSurface(screenManager) {
+	_ddSurface = nullptr;
+	_pendingLoad = pendingLoad;
+	
+	if (_pendingLoad) {
+		loadResource(key);
+	} else {
+		_resourceKey = key;
+		load();
+	}
+}
+
+void OSVideoSurface::loadResource(const CResourceKey &key) {
+	_resourceKey = key;
+	_pendingLoad = true;
+
+	if (hasSurface())
+		load();
+}
+
+void OSVideoSurface::loadTarga(const CResourceKey &key) {
+	// Decode the image
+	CTargaDecode decoder;
+	decoder.decode(*this, key.getString());
+
+	if (getPixelDepth() == 2)
+		shiftColors();
+
+	_resourceKey = key;
+
+}
+
+void OSVideoSurface::loadJPEG(const CResourceKey &key) {
+	// Decode the image
+	CJPEGDecode decoder;
+	decoder.decode(*this, key.getString());
+
+	if (getPixelDepth() == 2)
+		shiftColors();
+
+	_resourceKey = key;
+}
+
+void OSVideoSurface::loadMovie() {
+	warning("TODO");
+}
+
+bool OSVideoSurface::lock() {
+	if (!loadIfReady())
+		return false;
+
+	++_lockCount;
+	_rawSurface = _ddSurface->lock(nullptr, 0);
+	return true;
+}
+
+void OSVideoSurface::unlock() {
+	if (!--_lockCount) {
+		if (_rawSurface)
+			_ddSurface->unlock();
+		_rawSurface = nullptr;
+	}
+}
+
+bool OSVideoSurface::hasSurface() {
+	return _ddSurface != nullptr;
+}
+
+int OSVideoSurface::getWidth() {
+	if (!loadIfReady())
+		error("Could not load resource");
+
+	return _ddSurface->getWidth();
+}
+
+int OSVideoSurface::getHeight() {
+	if (!loadIfReady())
+		error("Could not load resource");
+
+	return _ddSurface->getHeight();
+}
+
+int OSVideoSurface::getPitch() {
+	if (!loadIfReady())
+		error("Could not load resource");
+
+	return _ddSurface->getPitch();
+}
+
+void OSVideoSurface::resize(int width, int height) {
+	freeSurface();
+
+	_screenManager->resizeSurface(this, width, height);
+	if (_ddSurface)
+		_videoSurfaceCounter += _ddSurface->getSize();
+}
+
+int OSVideoSurface::getPixelDepth() {
+	if (!loadIfReady())
+		assert(0);
+
+	lock();
+	
+	int result = _rawSurface->format.bytesPerPixel;
+	if (result == 1)
+		// Paletted 8-bit images don't store the color directly in the pixels
+		result = 0;
+
+	unlock();
+	return result;
+}
+
+bool OSVideoSurface::load() {
+	if (!_resourceKey.scanForFile())
+		return false;
+
+	switch (_resourceKey.fileTypeSuffix()) {
+	case FILETYPE_IMAGE:
+		switch (_resourceKey.imageTypeSuffix()) {
+		case IMAGETYPE_TARGA:
+			loadTarga(_resourceKey);
+			break;
+		case IMAGETYPE_JPEG:
+			loadJPEG(_resourceKey);
+			break;
+		default:
+			break;
+		}
+		return true;
+
+	case FILETYPE_MOVIE:
+		loadMovie();
+		return true;
+
+	default:
+		return false;
+	}
+}
+
+uint16 OSVideoSurface::getPixel(const Common::Point &pt) {
+	if (!loadIfReady())
+		return 0;
+
+	if (pt.x >= 0 && pt.y >= 0 && pt.x < getWidth() && pt.y < getHeight()) {
+		lock();
+		uint16 pixel = *(uint16 *)_rawSurface->getBasePtr(pt.x, pt.y);
+		unlock();
+		return pixel;
+	} else {
+		return getTransparencyColor();
+	}
+}
+
+void OSVideoSurface::shiftColors() {
+	if (!loadIfReady())
+		return;
+
+	// Currently no further processing is needed, since for ScummVM,
+	// we already convert 16-bit surfaces as soon as they're loaded
+}
+
+void OSVideoSurface::proc32(int v1, CVideoSurface *surface) {
+	if (loadIfReady() && _movie)
+		_movie->proc8(v1, surface);
+}
+
+void OSVideoSurface::stopMovie() {
+	if (_movie)
+		_movie->stop();
+}
+
+void OSVideoSurface::setMovieFrame(uint frameNumber) {
+	if (loadIfReady() && _movie)
+		_movie->setFrame(frameNumber);
+}
+
+bool OSVideoSurface::loadIfReady() {
+	_videoSurfaceNum = _videoSurfaceCounter;
+
+	if (hasSurface()) {
+		return true;
+	} else if (_pendingLoad) {
+		_field50 = 1;
+		load();
+		return true;
+	} else {
+		return false;
+	}
+}
+
+int OSVideoSurface::freeSurface() {
+	if (!_ddSurface)
+		return 0;
+	int surfaceSize = _ddSurface->getSize();
+
+	delete _movie;
+	_movie = nullptr;
+	delete _ddSurface;
+	_ddSurface = nullptr;
+
+	return surfaceSize;
+}
+
+} // End of namespace Titanic
diff --git a/engines/titanic/support/video_surface.h b/engines/titanic/support/video_surface.h
new file mode 100644
index 0000000000..1de6a1dd34
--- /dev/null
+++ b/engines/titanic/support/video_surface.h
@@ -0,0 +1,306 @@
+/* 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 2
+ * 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, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ *
+ */
+
+#ifndef TITANIC_VIDEO_SURFACE_H
+#define TITANIC_VIDEO_SURFACE_H
+
+#include "common/scummsys.h"
+#include "common/array.h"
+#include "titanic/support/font.h"
+#include "titanic/support/direct_draw.h"
+#include "titanic/support/movie.h"
+#include "titanic/support/rect.h"
+#include "titanic/core/list.h"
+#include "titanic/core/resource_key.h"
+
+namespace Titanic {
+
+class CScreenManager;
+class CJPEGDecode;
+class CTargaDecode;
+
+class CVideoSurface : public ListItem {
+	friend class CJPEGDecode;
+	friend class CTargaDecode;
+private:
+	/**
+	 * Calculates blitting bounds
+	 */
+	void clipBounds(Rect &srcRect, Rect &destRect, CVideoSurface *srcSurface,
+		const Rect *subRect = nullptr, const Point *destPos = nullptr);
+
+	void blitRect1(const Rect &srcRect, const Rect &destRect, CVideoSurface *src);
+	void blitRect2(const Rect &srcRect, const Rect &destRect, CVideoSurface *src);
+protected:
+	static int _videoSurfaceCounter;
+protected:
+	CScreenManager *_screenManager;
+	CResourceKey _resourceKey;
+	DirectDrawSurface *_ddSurface;
+	Graphics::ManagedSurface *_rawSurface;
+	bool _pendingLoad;
+	void *_field40;
+	int _field44;
+	int _field48;
+	int _videoSurfaceNum;
+	int _field50;
+	int _lockCount;
+public:
+	CMovie *_movie;
+	bool _blitFlag;
+	bool _blitStyleFlag;
+public:
+	CVideoSurface(CScreenManager *screenManager);
+	virtual ~CVideoSurface();
+
+	/**
+	 * Set the underlying surface for this video surface
+	 */
+	void setSurface(CScreenManager *screenManager, DirectDrawSurface *surface);
+
+	/**
+	 * Load the surface with the passed resource
+	 */
+	virtual void loadResource(const CResourceKey &key) = 0;
+
+	/**
+	 * Loads a Targa image file specified by the resource key
+	 */
+	virtual void loadTarga(const CResourceKey &key) = 0;
+
+	/**
+	 * Loads a JPEG image file specified by the resource key
+	 */
+	virtual void loadJPEG(const CResourceKey &key) = 0;
+
+	/**
+	 * Loads a movie file specified by the resource key
+	 */
+	virtual void loadMovie() = 0;
+
+	/**
+	 * Lock the surface for direct access to the pixels
+	 */
+	virtual bool lock() = 0;
+
+	/**
+	 * Unlocks the surface after prior calls to lock()
+	 */
+	virtual void unlock() = 0;
+
+	/**
+	 * Returns true if an underlying raw surface has been set
+	 */
+	virtual bool hasSurface() = 0;
+
+	/**
+	 * Returns the width of the surface
+	 */
+	virtual int getWidth() = 0;
+
+	/**
+	 * Returns the height of the surface
+	 */
+	virtual int getHeight() = 0;
+
+	/**
+	 * Returns the pitch of the surface in bytes
+	 */
+	virtual int getPitch() = 0;
+	
+	/**
+	 * Reiszes the surface
+	 */
+	virtual void resize(int width, int height) = 0;
+
+	/**
+	 * Returns the number of bytes per pixel in the surface
+	 */
+	virtual int getPixelDepth() = 0;
+
+	/**
+	 * Gets the pixel at the specified position within the surface
+	 */
+	virtual uint16 getPixel(const Common::Point &pt) = 0;
+
+	/**
+	 * Shifts the colors of the surface.. maybe greys it out?
+	 */
+	virtual void shiftColors() = 0;
+
+	virtual void proc32(int v1, CVideoSurface *surface) = 0;
+
+	/**
+	 * Stops any movie currently attached to the surface
+	 */
+	virtual void stopMovie() = 0;
+
+	/**
+	 * Sets the movie to the specified frame number
+	 */
+	virtual void setMovieFrame(uint frameNumber) = 0;
+
+	/**
+	 * Loads the surface's resource if there's one pending
+	 */
+	virtual bool loadIfReady() = 0;
+
+	/**
+	 * Loads the surface data based on the currently set resource key
+	 */
+	virtual bool load() = 0;
+
+	virtual bool proc45();
+
+	/**
+	 * Frees the underlying surface
+	 */
+	virtual int freeSurface() { return 0; }
+
+
+
+	/**
+	 * Blit from another surface
+	 */
+	void blitFrom(const Point &destPos, CVideoSurface *src, const Rect *srcRect = nullptr);
+
+	/**
+	 * Blit from another surface
+	 */
+	void blitFrom(const Point &destPos, const Graphics::Surface *src);
+
+	void set40(void *v) { _field40 = v; }
+
+	uint16 *getPixels() { return (uint16 *)_rawSurface->getPixels(); }
+
+	/**
+	 * Returns the transparent color
+	 */
+	uint getTransparencyColor();
+};
+
+class OSVideoSurface : public CVideoSurface {
+public:
+	OSVideoSurface(CScreenManager *screenManager, DirectDrawSurface *surface);
+	OSVideoSurface(CScreenManager *screenManager, const CResourceKey &key, bool flag = false);
+
+	/**
+	 * Load the surface with the passed resource
+	 */
+	virtual void loadResource(const CResourceKey &key);
+
+	/**
+	 * Loads a Targa image file specified by the resource key
+	 */
+	virtual void loadTarga(const CResourceKey &key);
+
+	/**
+	 * Loads a JPEG image file specified by the resource key
+	 */
+	virtual void loadJPEG(const CResourceKey &key);
+
+	/**
+	 * Loads a movie file specified by the resource key
+	 */
+	virtual void loadMovie();
+
+	/**
+	 * Lock the surface for direct access to the pixels
+	 */
+	virtual bool lock();
+
+	/**
+	 * Unlocks the surface after prior calls to lock()
+	 */
+	virtual void unlock();
+
+	/**
+	 * Returns true if an underlying raw surface has been set
+	 */
+	virtual bool hasSurface();
+
+	/**
+	 * Returns the width of the surface
+	 */
+	virtual int getWidth();
+
+	/**
+	 * Returns the height of the surface
+	 */
+	virtual int getHeight();
+
+	/**
+	 * Returns the pitch of the surface in bytes
+	 */
+	virtual int getPitch();
+
+	/**
+	 * Reiszes the surface
+	 */
+	virtual void resize(int width, int height);
+
+	/**
+	 * Returns the number of bytes per pixel in the surface
+	 */
+	virtual int getPixelDepth();
+
+	/**
+	 * Gets the pixel at the specified position within the surface
+	 */
+	virtual uint16 getPixel(const Common::Point &pt);
+
+	/**
+	 * Shifts the colors of the surface.. maybe greys it out?
+	 */
+	virtual void shiftColors();
+
+	virtual void proc32(int v1, CVideoSurface *surface);
+
+	/**
+	 * Stops any movie currently attached to the surface
+	 */
+	virtual void stopMovie();
+
+	/**
+	 * Sets the movie to the specified frame number
+	 */
+	virtual void setMovieFrame(uint frameNumber);
+
+	/**
+	 * Loads the surface's resource if there's one pending
+	 */
+	virtual bool loadIfReady();
+
+	/**
+	 * Loads the surface data based on the currently set resource key
+	 */
+	virtual bool load();
+
+	/**
+	 * Frees the underlying surface
+	 */
+	virtual int freeSurface();
+};
+
+} // End of namespace Titanic
+
+#endif /* TITANIC_VIDEO_SURFACE_H */