Merge pull request #700 from waltervn/adl-engine

ADL: New engine

10 files changed, 2729 insertions, 0 deletions

diff --git a/engines/adl/adl.cpp b/engines/adl/adl.cpp
new file mode 100644
index 0000000000..1ab74c3cf6
--- /dev/null
+++ b/engines/adl/adl.cpp
@@ -0,0 +1,1038 @@
+/* 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/scummsys.h"
+#include "common/config-manager.h"
+#include "common/debug.h"
+#include "common/error.h"
+#include "common/file.h"
+#include "common/system.h"
+#include "common/events.h"
+#include "common/stream.h"
+#include "common/savefile.h"
+
+#include "engines/util.h"
+
+#include "graphics/palette.h"
+#include "graphics/thumbnail.h"
+
+#include "adl/adl.h"
+#include "adl/display.h"
+#include "adl/detection.h"
+
+namespace Adl {
+
+AdlEngine::~AdlEngine() {
+	delete _display;
+}
+
+AdlEngine::AdlEngine(OSystem *syst, const AdlGameDescription *gd) :
+		Engine(syst),
+		_display(nullptr),
+		_gameDescription(gd),
+		_isRestarting(false),
+		_isRestoring(false),
+		_saveVerb(0),
+		_saveNoun(0),
+		_restoreVerb(0),
+		_restoreNoun(0),
+		_canSaveNow(false),
+		_canRestoreNow(false) {
+}
+
+Common::String AdlEngine::readString(Common::ReadStream &stream, byte until) const {
+	Common::String str;
+
+	while (1) {
+		byte b = stream.readByte();
+
+		if (stream.eos() || stream.err())
+			error("Error reading string");
+
+		if (b == until)
+			break;
+
+		str += b;
+	};
+
+	return str;
+}
+
+Common::String AdlEngine::readStringAt(Common::SeekableReadStream &stream, uint offset, byte until) const {
+	stream.seek(offset);
+	return readString(stream, until);
+}
+
+void AdlEngine::printMessage(uint idx, bool wait) const {
+	Common::String msg = _messages[idx - 1];
+	wordWrap(msg);
+	_display->printString(msg);
+
+	if (wait)
+		delay(14 * 166018 / 1000);
+}
+
+void AdlEngine::delay(uint32 ms) const {
+	Common::EventManager *ev = g_system->getEventManager();
+
+	uint32 start = g_system->getMillis();
+
+	while (!g_engine->shouldQuit() && g_system->getMillis() - start < ms) {
+		Common::Event event;
+		if (ev->pollEvent(event)) {
+			if (event.type == Common::EVENT_KEYDOWN && (event.kbd.flags & Common::KBD_CTRL)) {
+				switch(event.kbd.keycode) {
+				case Common::KEYCODE_q:
+					g_engine->quitGame();
+					break;
+				default:
+					break;
+				}
+			}
+		}
+		g_system->delayMillis(16);
+	}
+}
+
+Common::String AdlEngine::inputString(byte prompt) const {
+	Common::String s;
+
+	if (prompt > 0)
+		_display->printString(Common::String(prompt));
+
+	while (1) {
+		byte b = inputKey();
+
+		if (g_engine->shouldQuit() || _isRestoring)
+			return 0;
+
+		if (b == 0)
+			continue;
+
+		if (b == ('\r' | 0x80)) {
+			s += b;
+			_display->printString(Common::String(b));
+			return s;
+		}
+
+		if (b < 0xa0) {
+			switch (b) {
+			case Common::KEYCODE_BACKSPACE | 0x80:
+				if (!s.empty()) {
+					_display->moveCursorBackward();
+					_display->setCharAtCursor(APPLECHAR(' '));
+					s.deleteLastChar();
+				}
+				break;
+			};
+		} else {
+			if (s.size() < 255) {
+				s += b;
+				_display->printString(Common::String(b));
+			}
+		}
+	}
+}
+
+byte AdlEngine::inputKey() const {
+	Common::EventManager *ev = g_system->getEventManager();
+
+	byte key = 0;
+
+	_display->showCursor(true);
+
+	while (!g_engine->shouldQuit() && !_isRestoring && key == 0) {
+		Common::Event event;
+		if (ev->pollEvent(event)) {
+			if (event.type != Common::EVENT_KEYDOWN)
+				continue;
+
+			if (event.kbd.flags & Common::KBD_CTRL) {
+				if (event.kbd.keycode == Common::KEYCODE_q)
+					g_engine->quitGame();
+				continue;
+			}
+
+			switch (event.kbd.keycode) {
+			case Common::KEYCODE_BACKSPACE:
+			case Common::KEYCODE_RETURN:
+				key = convertKey(event.kbd.keycode);
+				break;
+			default:
+				if (event.kbd.ascii >= 0x20 && event.kbd.ascii < 0x80)
+					key = convertKey(event.kbd.ascii);
+			};
+		}
+
+		_display->updateTextScreen();
+		g_system->delayMillis(16);
+	}
+
+	_display->showCursor(false);
+
+	return key;
+}
+
+void AdlEngine::loadWords(Common::ReadStream &stream, WordMap &map) const {
+	uint index = 0;
+
+	while (1) {
+		++index;
+
+		byte buf[IDI_WORD_SIZE];
+
+		if (stream.read(buf, IDI_WORD_SIZE) < IDI_WORD_SIZE)
+			error("Error reading word list");
+
+		Common::String word((char *)buf, IDI_WORD_SIZE);
+
+		if (!map.contains(word))
+			map[word] = index;
+
+		byte synonyms = stream.readByte();
+
+		if (stream.err() || stream.eos())
+			error("Error reading word list");
+
+		if (synonyms == 0xff)
+			break;
+
+		for (uint i = 0; i < synonyms; ++i) {
+			if (stream.read((char *)buf, IDI_WORD_SIZE) < IDI_WORD_SIZE)
+				error("Error reading word list");
+
+			word = Common::String((char *)buf, IDI_WORD_SIZE);
+
+			if (!map.contains(word))
+				map[word] = index;
+		}
+	}
+}
+
+void AdlEngine::readCommands(Common::ReadStream &stream, Commands &commands) {
+	while (1) {
+		Command command;
+		command.room = stream.readByte();
+
+		if (command.room == 0xff)
+			return;
+
+		command.verb = stream.readByte();
+		command.noun = stream.readByte();
+
+		byte scriptSize = stream.readByte() - 6;
+
+		command.numCond = stream.readByte();
+		command.numAct = stream.readByte();
+
+		for (uint i = 0; i < scriptSize; ++i)
+			command.script.push_back(stream.readByte());
+
+		if (stream.eos() || stream.err())
+			error("Failed to read commands");
+
+		if (command.numCond == 0 && command.script[0] == IDO_ACT_SAVE) {
+			_saveVerb = command.verb;
+			_saveNoun = command.noun;
+		}
+
+		if (command.numCond == 0 && command.script[0] == IDO_ACT_LOAD) {
+			_restoreVerb = command.verb;
+			_restoreNoun = command.noun;
+		}
+
+		commands.push_back(command);
+	}
+}
+
+Common::Error AdlEngine::run() {
+	_display = new Display();
+
+	loadData();
+
+	int saveSlot = ConfMan.getInt("save_slot");
+	if (saveSlot >= 0) {
+		if (loadGameState(saveSlot).getCode() != Common::kNoError)
+			error("Failed to load save game from slot %i", saveSlot);
+		_display->moveCursorTo(Common::Point(0, 23));
+		_isRestoring = true;
+	} else {
+		runIntro();
+		initState();
+	}
+
+	_display->setMode(DISPLAY_MODE_MIXED);
+	_display->printAsciiString("\r\r\r\r\r");
+
+	while (1) {
+		uint verb = 0, noun = 0;
+
+		// When restoring from the launcher, we don't read
+		// input on the first iteration. This is needed to
+		// ensure that restoring from the launcher and
+		// restoring in-game brings us to the same game state.
+		// (Also see comment below.)
+		if (!_isRestoring) {
+			clearScreen();
+			showRoom();
+
+			_canSaveNow = _canRestoreNow = true;
+			getInput(verb, noun);
+			_canSaveNow = _canRestoreNow = false;
+
+			if (shouldQuit())
+				break;
+
+			// If we just restored from the GMM, we skip this command
+			// set, as no command has been input by the user
+			if (!_isRestoring)
+				if (!doOneCommand(_roomCommands, verb, noun))
+					printMessage(_messageIds.dontUnderstand);
+		}
+
+		if (_isRestoring) {
+			// We restored from the GMM or launcher. As restoring
+			// with "RESTORE GAME" does not end command processing,
+			// we don't break it off here either. This essentially
+			// means that restoring a game will always run through
+			// the global commands and increase the move counter
+			// before the first user input.
+			_display->printAsciiString("\r");
+			_isRestoring = false;
+			verb = _restoreVerb;
+			noun = _restoreNoun;
+		}
+
+		// Restarting does end command processing
+		if (_isRestarting) {
+			_isRestarting = false;
+			continue;
+		}
+
+		doAllCommands(_globalCommands, verb, noun);
+		_state.moves++;
+	}
+
+	return Common::kNoError;
+}
+
+bool AdlEngine::hasFeature(EngineFeature f) const {
+	switch (f) {
+	case kSupportsLoadingDuringRuntime:
+	case kSupportsSavingDuringRuntime:
+	case kSupportsRTL:
+		return true;
+	default:
+		return false;
+	}
+}
+
+Common::Error AdlEngine::loadGameState(int slot) {
+	Common::String fileName = Common::String::format("%s.s%02d", _targetName.c_str(), slot);
+	Common::InSaveFile *inFile = getSaveFileManager()->openForLoading(fileName);
+
+	if (!inFile) {
+		warning("Failed to open file '%s'", fileName.c_str());
+		return Common::kUnknownError;
+	}
+
+	if (inFile->readUint32BE() != MKTAG('A', 'D', 'L', ':')) {
+		warning("No header found in '%s'", fileName.c_str());
+		delete inFile;
+		return Common::kUnknownError;
+	}
+
+	byte saveVersion = inFile->readByte();
+	if (saveVersion != SAVEGAME_VERSION) {
+		warning("Save game version %i not supported", saveVersion);
+		delete inFile;
+		return Common::kUnknownError;
+	}
+
+	// Skip description
+	inFile->seek(SAVEGAME_NAME_LEN, SEEK_CUR);
+	// Skip save time
+	inFile->seek(6, SEEK_CUR);
+
+	uint32 playTime = inFile->readUint32BE();
+
+	Graphics::skipThumbnail(*inFile);
+
+	initState();
+
+	_state.room = inFile->readByte();
+	_state.moves = inFile->readByte();
+	_state.isDark = inFile->readByte();
+
+	uint32 size = inFile->readUint32BE();
+	if (size != _state.rooms.size())
+		error("Room count mismatch (expected %i; found %i)", _state.rooms.size(), size);
+
+	for (uint i = 0; i < size; ++i) {
+		_state.rooms[i].picture = inFile->readByte();
+		_state.rooms[i].curPicture = inFile->readByte();
+	}
+
+	size = inFile->readUint32BE();
+	if (size != _state.items.size())
+		error("Item count mismatch (expected %i; found %i)", _state.items.size(), size);
+
+	for (uint i = 0; i < size; ++i) {
+		_state.items[i].room = inFile->readByte();
+		_state.items[i].picture = inFile->readByte();
+		_state.items[i].position.x = inFile->readByte();
+		_state.items[i].position.y = inFile->readByte();
+		_state.items[i].state = inFile->readByte();
+	}
+
+	size = inFile->readUint32BE();
+	if (size != _state.vars.size())
+		error("Variable count mismatch (expected %i; found %i)", _state.vars.size(), size);
+
+	for (uint i = 0; i < size; ++i)
+		_state.vars[i] = inFile->readByte();
+
+	if (inFile->err() || inFile->eos())
+		error("Failed to load game '%s'", fileName.c_str());
+
+	delete inFile;
+
+	setTotalPlayTime(playTime);
+
+	_isRestoring = true;
+	return Common::kNoError;
+}
+
+bool AdlEngine::canLoadGameStateCurrently() {
+	return _canRestoreNow;
+}
+
+Common::Error AdlEngine::saveGameState(int slot, const Common::String &desc) {
+	Common::String fileName = Common::String::format("%s.s%02d", _targetName.c_str(), slot);
+	Common::OutSaveFile *outFile = getSaveFileManager()->openForSaving(fileName);
+
+	if (!outFile) {
+		warning("Failed to open file '%s'", fileName.c_str());
+		return Common::kUnknownError;
+	}
+
+	outFile->writeUint32BE(MKTAG('A', 'D', 'L', ':'));
+	outFile->writeByte(SAVEGAME_VERSION);
+
+	char name[SAVEGAME_NAME_LEN] = { };
+
+	if (!desc.empty())
+		strncpy(name, desc.c_str(), sizeof(name) - 1);
+	else {
+		Common::String defaultName("Save ");
+		defaultName += 'A' + slot;
+		strncpy(name, defaultName.c_str(), sizeof(name) - 1);
+	}
+
+	outFile->write(name, sizeof(name));
+
+	TimeDate t;
+	g_system->getTimeAndDate(t);
+
+	outFile->writeUint16BE(t.tm_year);
+	outFile->writeByte(t.tm_mon);
+	outFile->writeByte(t.tm_mday);
+	outFile->writeByte(t.tm_hour);
+	outFile->writeByte(t.tm_min);
+
+	uint32 playTime = getTotalPlayTime();
+	outFile->writeUint32BE(playTime);
+
+	_display->saveThumbnail(*outFile);
+
+	outFile->writeByte(_state.room);
+	outFile->writeByte(_state.moves);
+	outFile->writeByte(_state.isDark);
+
+	outFile->writeUint32BE(_state.rooms.size());
+	for (uint i = 0; i < _state.rooms.size(); ++i) {
+		outFile->writeByte(_state.rooms[i].picture);
+		outFile->writeByte(_state.rooms[i].curPicture);
+	}
+
+	outFile->writeUint32BE(_state.items.size());
+	for (uint i = 0; i < _state.items.size(); ++i) {
+		outFile->writeByte(_state.items[i].room);
+		outFile->writeByte(_state.items[i].picture);
+		outFile->writeByte(_state.items[i].position.x);
+		outFile->writeByte(_state.items[i].position.y);
+		outFile->writeByte(_state.items[i].state);
+	}
+
+	outFile->writeUint32BE(_state.vars.size());
+	for (uint i = 0; i < _state.vars.size(); ++i)
+		outFile->writeByte(_state.vars[i]);
+
+	outFile->finalize();
+
+	if (outFile->err()) {
+		delete outFile;
+		warning("Failed to save game '%s'", fileName.c_str());
+		return Common::kUnknownError;
+	}
+
+	delete outFile;
+	return Common::kNoError;
+}
+
+bool AdlEngine::canSaveGameStateCurrently() {
+	if (!_canSaveNow)
+		return false;
+
+	Commands::const_iterator cmd;
+
+	// Here we check whether or not the game currently accepts the command
+	// "SAVE GAME". This prevents saving via the GMM in situations where
+	// it wouldn't otherwise be possible to do so.
+	for (cmd = _roomCommands.begin(); cmd != _roomCommands.end(); ++cmd) {
+		uint offset;
+		if (matchCommand(*cmd, _saveVerb, _saveNoun, &offset))
+			return cmd->script[offset] == IDO_ACT_SAVE;
+	}
+
+	return false;
+}
+
+void AdlEngine::wordWrap(Common::String &str) const {
+	uint end = 39;
+
+	while (1) {
+		if (str.size() <= end)
+			return;
+
+		while (str[end] != APPLECHAR(' '))
+			--end;
+
+		str.setChar(APPLECHAR('\r'), end);
+		end += 40;
+	}
+}
+
+byte AdlEngine::convertKey(uint16 ascii) const {
+	ascii = toupper(ascii);
+
+	if (ascii >= 0x80)
+		return 0;
+
+	ascii |= 0x80;
+
+	if (ascii >= 0x80 && ascii <= 0xe0)
+		return ascii;
+
+	return 0;
+}
+
+Common::String AdlEngine::getLine() const {
+	// Original engine uses a global here, which isn't reset between
+	// calls and may not match actual mode
+	bool textMode = false;
+
+	while (1) {
+		Common::String line = inputString(APPLECHAR('?'));
+
+		if (shouldQuit() || _isRestoring)
+			return "";
+
+		if ((byte)line[0] == ('\r' | 0x80)) {
+			textMode = !textMode;
+			_display->setMode(textMode ? DISPLAY_MODE_TEXT : DISPLAY_MODE_MIXED);
+			continue;
+		}
+
+		// Remove the return
+		line.deleteLastChar();
+		return line;
+	}
+}
+
+Common::String AdlEngine::getWord(const Common::String &line, uint &index) const {
+	Common::String str;
+
+	for (uint i = 0; i < 8; ++i)
+		str += APPLECHAR(' ');
+
+	int copied = 0;
+
+	// Skip initial whitespace
+	while (1) {
+		if (index == line.size())
+			return str;
+		if (line[index] != APPLECHAR(' '))
+			break;
+		++index;
+	}
+
+	// Copy up to 8 characters
+	while (1) {
+		if (copied < 8)
+			str.setChar(line[index], copied++);
+
+		index++;
+
+		if (index == line.size() || line[index] == APPLECHAR(' '))
+			return str;
+	}
+}
+
+void AdlEngine::getInput(uint &verb, uint &noun) {
+	while (1) {
+		_display->printString(_strings.enterCommand);
+		Common::String line = getLine();
+
+		if (shouldQuit() || _isRestoring)
+			return;
+
+		uint index = 0;
+		Common::String verbStr = getWord(line, index);
+
+		if (!_verbs.contains(verbStr)) {
+			Common::String err = _strings.verbError;
+			for (uint i = 0; i < verbStr.size(); ++i)
+				err.setChar(verbStr[i], i + 19);
+			_display->printString(err);
+			continue;
+		}
+
+		verb = _verbs[verbStr];
+
+		Common::String nounStr = getWord(line, index);
+
+		if (!_nouns.contains(nounStr)) {
+			Common::String err = _strings.nounError;
+			for (uint i = 0; i < verbStr.size(); ++i)
+				err.setChar(verbStr[i], i + 19);
+			for (uint i = 0; i < nounStr.size(); ++i)
+				err.setChar(nounStr[i], i + 30);
+			_display->printString(err);
+			continue;
+		}
+
+		noun = _nouns[nounStr];
+		return;
+	}
+}
+
+void AdlEngine::showRoom() const {
+	if (!_state.isDark) {
+		drawPic(getCurRoom().curPicture);
+		drawItems();
+	}
+
+	_display->updateHiResScreen();
+	printMessage(getCurRoom().description, false);
+}
+
+void AdlEngine::clearScreen() const {
+	_display->setMode(DISPLAY_MODE_MIXED);
+	_display->clear(0x00);
+}
+
+void AdlEngine::drawItems() const {
+	Common::Array<Item>::const_iterator item;
+
+	uint dropped = 0;
+
+	for (item = _state.items.begin(); item != _state.items.end(); ++item) {
+		if (item->room != _state.room)
+			continue;
+
+		if (item->state == IDI_ITEM_MOVED) {
+			if (getCurRoom().picture == getCurRoom().curPicture) {
+				const Common::Point &p =  _itemOffsets[dropped];
+				if (item->isLineArt)
+					drawLineArt(_lineArt[item->picture - 1], p);
+				else
+					drawPic(item->picture, p);
+				++dropped;
+			}
+			continue;
+		}
+
+		Common::Array<byte>::const_iterator pic;
+
+		for (pic = item->roomPictures.begin(); pic != item->roomPictures.end(); ++pic) {
+			if (*pic == getCurRoom().curPicture) {
+				if (item->isLineArt)
+					drawLineArt(_lineArt[item->picture - 1], item->position);
+				else
+					drawPic(item->picture, item->position);
+				continue;
+			}
+		}
+	}
+}
+
+void AdlEngine::drawNextPixel(Common::Point &p, byte color, byte bits, byte quadrant) const {
+	if (bits & 4)
+		_display->putPixel(p, color);
+
+	bits += quadrant;
+
+	if (bits & 1)
+		p.x += (bits & 2 ? -1 : 1);
+	else
+		p.y += (bits & 2 ? 1 : -1);
+}
+
+void AdlEngine::drawLineArt(const Common::Array<byte> &lineArt, const Common::Point &pos, byte rotation, byte scaling, byte color) const {
+	const byte stepping[] = {
+		0xff, 0xfe, 0xfa, 0xf4, 0xec, 0xe1, 0xd4, 0xc5,
+		0xb4, 0xa1, 0x8d, 0x78, 0x61, 0x49, 0x31, 0x18,
+		0xff
+	};
+
+	byte quadrant = rotation >> 4;
+	rotation &= 0xf;
+	byte xStep = stepping[rotation];
+	byte yStep = stepping[(rotation ^ 0xf) + 1] + 1;
+
+	Common::Point p(pos);
+
+	for (uint i = 0; i < lineArt.size(); ++i) {
+		byte b = lineArt[i];
+
+		do {
+			byte xFrac = 0x80;
+			byte yFrac = 0x80;
+			for (uint j = 0; j < scaling; ++j) {
+				if (xFrac + xStep + 1 > 255)
+					drawNextPixel(p, color, b, quadrant);
+				xFrac += xStep + 1;
+				if (yFrac + yStep > 255)
+					drawNextPixel(p, color, b, quadrant + 1);
+				yFrac += yStep;
+			}
+			b >>= 3;
+		} while (b != 0);
+	}
+}
+
+const Room &AdlEngine::getRoom(uint i) const {
+	if (i < 1 || i > _state.rooms.size())
+		error("Room %i out of range [1, %i]", i, _state.rooms.size());
+
+	return _state.rooms[i - 1];
+}
+
+Room &AdlEngine::getRoom(uint i) {
+	if (i < 1 || i > _state.rooms.size())
+		error("Room %i out of range [1, %i]", i, _state.rooms.size());
+
+	return _state.rooms[i - 1];
+}
+
+const Room &AdlEngine::getCurRoom() const {
+	return getRoom(_state.room);
+}
+
+Room &AdlEngine::getCurRoom() {
+	return getRoom(_state.room);
+}
+
+const Item &AdlEngine::getItem(uint i) const {
+	if (i < 1 || i > _state.items.size())
+		error("Item %i out of range [1, %i]", i, _state.items.size());
+
+	return _state.items[i - 1];
+}
+
+Item &AdlEngine::getItem(uint i) {
+	if (i < 1 || i > _state.items.size())
+		error("Item %i out of range [1, %i]", i, _state.items.size());
+
+	return _state.items[i - 1];
+}
+
+byte AdlEngine::getVar(uint i) const {
+	if (i >= _state.vars.size())
+		error("Variable %i out of range [0, %i]", i, _state.vars.size() - 1);
+
+	return _state.vars[i];
+}
+
+void AdlEngine::setVar(uint i, byte value) {
+	if (i >= _state.vars.size())
+		error("Variable %i out of range [0, %i]", i, _state.vars.size() - 1);
+
+	_state.vars[i] = value;
+}
+
+void AdlEngine::takeItem(byte noun) {
+	Common::Array<Item>::iterator item;
+
+	for (item = _state.items.begin(); item != _state.items.end(); ++item) {
+		if (item->noun != noun || item->room != _state.room)
+			continue;
+
+		if (item->state == IDI_ITEM_DOESNT_MOVE) {
+			printMessage(_messageIds.itemDoesntMove);
+			return;
+		}
+
+		if (item->state == IDI_ITEM_MOVED) {
+			item->room = IDI_NONE;
+			return;
+		}
+
+		Common::Array<byte>::const_iterator pic;
+		for (pic = item->roomPictures.begin(); pic != item->roomPictures.end(); ++pic) {
+			if (*pic == getCurRoom().curPicture) {
+				item->room = IDI_NONE;
+				item->state = IDI_ITEM_MOVED;
+				return;
+			}
+		}
+	}
+
+	printMessage(_messageIds.itemNotHere);
+}
+
+void AdlEngine::dropItem(byte noun) {
+	Common::Array<Item>::iterator item;
+
+	for (item = _state.items.begin(); item != _state.items.end(); ++item) {
+		if (item->noun != noun || item->room != IDI_NONE)
+			continue;
+
+		item->room = _state.room;
+		item->state = IDI_ITEM_MOVED;
+		return;
+	}
+
+	printMessage(_messageIds.dontUnderstand);
+}
+
+#define ARG(N) (command.script[offset + (N)])
+
+bool AdlEngine::matchCommand(const Command &command, byte verb, byte noun, uint *actions) const {
+	if (command.room != IDI_NONE && command.room != _state.room)
+		return false;
+
+	if (command.verb != IDI_NONE && command.verb != verb)
+		return false;
+
+	if (command.noun != IDI_NONE && command.noun != noun)
+		return false;
+
+	uint offset = 0;
+	for (uint i = 0; i < command.numCond; ++i) {
+		switch (ARG(0)) {
+		case IDO_CND_ITEM_IN_ROOM:
+			if (getItem(ARG(1)).room != ARG(2))
+				return false;
+			offset += 3;
+			break;
+		case IDO_CND_MOVES_GE:
+			if (ARG(1) > _state.moves)
+				return false;
+			offset += 2;
+			break;
+		case IDO_CND_VAR_EQ:
+			if (getVar(ARG(1)) != ARG(2))
+				return false;
+			offset += 3;
+			break;
+		case IDO_CND_CUR_PIC_EQ:
+			if (getCurRoom().curPicture != ARG(1))
+				return false;
+			offset += 2;
+			break;
+		case IDO_CND_ITEM_PIC_EQ:
+			if (getItem(ARG(1)).picture != ARG(2))
+				return false;
+			offset += 3;
+			break;
+		default:
+			error("Invalid condition opcode %02x", command.script[offset]);
+		}
+	}
+
+	if (actions)
+		*actions = offset;
+
+	return true;
+}
+
+void AdlEngine::doActions(const Command &command, byte noun, byte offset) {
+	for (uint i = 0; i < command.numAct; ++i) {
+		switch (ARG(0)) {
+		case IDO_ACT_VAR_ADD:
+			setVar(ARG(2), getVar(ARG(2) + ARG(1)));
+			offset += 3;
+			break;
+		case IDO_ACT_VAR_SUB:
+			setVar(ARG(2), getVar(ARG(2)) - ARG(1));
+			offset += 3;
+			break;
+		case IDO_ACT_VAR_SET:
+			setVar(ARG(1), ARG(2));
+			offset += 3;
+			break;
+		case IDO_ACT_LIST_ITEMS: {
+			Common::Array<Item>::const_iterator item;
+
+			for (item = _state.items.begin(); item != _state.items.end(); ++item)
+				if (item->room == IDI_NONE)
+					printMessage(item->description);
+
+			++offset;
+			break;
+		}
+		case IDO_ACT_MOVE_ITEM:
+			getItem(ARG(1)).room = ARG(2);
+			offset += 3;
+			break;
+		case IDO_ACT_SET_ROOM:
+			getCurRoom().curPicture = getCurRoom().picture;
+			_state.room = ARG(1);
+			offset += 2;
+			break;
+		case IDO_ACT_SET_CUR_PIC:
+			getCurRoom().curPicture = ARG(1);
+			offset += 2;
+			break;
+		case IDO_ACT_SET_PIC:
+			getCurRoom().picture = getCurRoom().curPicture = ARG(1);
+			offset += 2;
+			break;
+		case IDO_ACT_PRINT_MSG:
+			printMessage(ARG(1));
+			offset += 2;
+			break;
+		case IDO_ACT_SET_LIGHT:
+			_state.isDark = false;
+			++offset;
+			break;
+		case IDO_ACT_SET_DARK:
+			_state.isDark = true;
+			++offset;
+			break;
+		case IDO_ACT_SAVE:
+			saveGameState(0, "");
+			++offset;
+			break;
+		case IDO_ACT_LOAD:
+			loadGameState(0);
+			++offset;
+			// Original engine does not jump out of the loop,
+			// so we don't either.
+			// We reset the restore flag, as the restore game
+			// process is complete
+			_isRestoring = false;
+			break;
+		case IDO_ACT_RESTART: {
+			_display->printString(_strings.playAgain);
+			Common::String input = inputString();
+			if (input.size() == 0 || input[0] != APPLECHAR('N')) {
+				_isRestarting = true;
+				_display->clear(0x00);
+				_display->updateHiResScreen();
+				restartGame();
+				return;
+			}
+			// Fall-through
+		}
+		case IDO_ACT_QUIT:
+			printMessage(_messageIds.thanksForPlaying);
+			quitGame();
+			return;
+		case IDO_ACT_PLACE_ITEM:
+			getItem(ARG(1)).room = ARG(2);
+			getItem(ARG(1)).position.x = ARG(3);
+			getItem(ARG(1)).position.y = ARG(4);
+			offset += 5;
+			break;
+		case IDO_ACT_SET_ITEM_PIC:
+			getItem(ARG(2)).picture = ARG(1);
+			offset += 3;
+			break;
+		case IDO_ACT_RESET_PIC:
+			getCurRoom().curPicture = getCurRoom().picture;
+			++offset;
+			break;
+		case IDO_ACT_GO_NORTH:
+		case IDO_ACT_GO_SOUTH:
+		case IDO_ACT_GO_EAST:
+		case IDO_ACT_GO_WEST:
+		case IDO_ACT_GO_UP:
+		case IDO_ACT_GO_DOWN: {
+			byte room = getCurRoom().connections[ARG(0) - IDO_ACT_GO_NORTH];
+
+			if (room == 0) {
+				printMessage(_messageIds.cantGoThere);
+				return;
+			}
+
+			getCurRoom().curPicture = getCurRoom().picture;
+			_state.room = room;
+			return;
+		}
+		case IDO_ACT_TAKE_ITEM:
+			takeItem(noun);
+			++offset;
+			break;
+		case IDO_ACT_DROP_ITEM:
+			dropItem(noun);
+			++offset;
+			break;
+		case IDO_ACT_SET_ROOM_PIC:
+			getRoom(ARG(1)).picture = getRoom(ARG(1)).curPicture = ARG(2);
+			offset += 3;
+			break;
+		default:
+			error("Invalid action opcode %02x", ARG(0));
+		}
+	}
+}
+
+#undef ARG
+
+bool AdlEngine::doOneCommand(const Commands &commands, byte verb, byte noun) {
+	Commands::const_iterator cmd;
+
+	for (cmd = commands.begin(); cmd != commands.end(); ++cmd) {
+		uint offset = 0;
+		if (matchCommand(*cmd, verb, noun, &offset)) {
+			doActions(*cmd, noun, offset);
+			return true;
+		}
+	}
+
+	return false;
+}
+
+void AdlEngine::doAllCommands(const Commands &commands, byte verb, byte noun) {
+	Commands::const_iterator cmd;
+
+	for (cmd = commands.begin(); cmd != commands.end(); ++cmd) {
+		uint offset = 0;
+		if (matchCommand(*cmd, verb, noun, &offset))
+			doActions(*cmd, noun, offset);
+	}
+}
+
+} // End of namespace Adl
diff --git a/engines/adl/adl.h b/engines/adl/adl.h
new file mode 100644
index 0000000000..4ea7566669
--- /dev/null
+++ b/engines/adl/adl.h
@@ -0,0 +1,247 @@
+/* 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 ADL_ADL_H
+#define ADL_ADL_H
+
+#include "common/array.h"
+#include "common/rect.h"
+#include "common/str.h"
+
+#include "engines/engine.h"
+
+namespace Common {
+class ReadStream;
+class SeekableReadStream;
+}
+
+namespace Adl {
+
+class Display;
+struct AdlGameDescription;
+
+// Conditional opcodes
+#define IDO_CND_ITEM_IN_ROOM   0x03
+#define IDO_CND_MOVES_GE       0x05
+#define IDO_CND_VAR_EQ         0x06
+#define IDO_CND_CUR_PIC_EQ     0x09
+#define IDO_CND_ITEM_PIC_EQ    0x0a
+
+// Action opcodes
+#define IDO_ACT_VAR_ADD        0x01
+#define IDO_ACT_VAR_SUB        0x02
+#define IDO_ACT_VAR_SET        0x03
+#define IDO_ACT_LIST_ITEMS     0x04
+#define IDO_ACT_MOVE_ITEM      0x05
+#define IDO_ACT_SET_ROOM       0x06
+#define IDO_ACT_SET_CUR_PIC    0x07
+#define IDO_ACT_SET_PIC        0x08
+#define IDO_ACT_PRINT_MSG      0x09
+#define IDO_ACT_SET_LIGHT      0x0a
+#define IDO_ACT_SET_DARK       0x0b
+#define IDO_ACT_QUIT           0x0d
+#define IDO_ACT_SAVE           0x0f
+#define IDO_ACT_LOAD           0x10
+#define IDO_ACT_RESTART        0x11
+#define IDO_ACT_PLACE_ITEM     0x12
+#define IDO_ACT_SET_ITEM_PIC   0x13
+#define IDO_ACT_RESET_PIC      0x14
+#define IDO_ACT_GO_NORTH       0x15
+#define IDO_ACT_GO_SOUTH       0x16
+#define IDO_ACT_GO_EAST        0x17
+#define IDO_ACT_GO_WEST        0x18
+#define IDO_ACT_GO_UP          0x19
+#define IDO_ACT_GO_DOWN        0x1a
+#define IDO_ACT_TAKE_ITEM      0x1b
+#define IDO_ACT_DROP_ITEM      0x1c
+#define IDO_ACT_SET_ROOM_PIC   0x1d
+
+#define IDI_WORD_SIZE 8
+
+struct Room {
+	byte description;
+	byte connections[6];
+	byte picture;
+	byte curPicture;
+};
+
+struct Picture {
+	byte block;
+	uint16 offset;
+};
+
+struct Command {
+	byte room;
+	byte verb, noun;
+	byte numCond, numAct;
+	Common::Array<byte> script;
+};
+
+enum {
+	IDI_ITEM_NOT_MOVED,
+	IDI_ITEM_MOVED,
+	IDI_ITEM_DOESNT_MOVE
+};
+
+#define IDI_NONE 0xfe
+
+struct Item {
+	byte noun;
+	byte room;
+	byte picture;
+	bool isLineArt;
+	Common::Point position;
+	int state;
+	byte description;
+	Common::Array<byte> roomPictures;
+};
+
+struct State {
+	Common::Array<Room> rooms;
+	Common::Array<Item> items;
+	Common::Array<byte> vars;
+
+	byte room;
+	uint16 moves;
+	bool isDark;
+
+	State() : room(1), moves(0), isDark(false) { }
+};
+
+typedef Common::List<Command> Commands;
+typedef Common::HashMap<Common::String, uint> WordMap;
+
+class AdlEngine : public Engine {
+public:
+	virtual ~AdlEngine();
+
+protected:
+	AdlEngine(OSystem *syst, const AdlGameDescription *gd);
+
+	Common::String readString(Common::ReadStream &stream, byte until = 0) const;
+	Common::String readStringAt(Common::SeekableReadStream &stream, uint offset, byte until = 0) const;
+
+	virtual void printMessage(uint idx, bool wait = true) const;
+	void delay(uint32 ms) const;
+
+	Common::String inputString(byte prompt = 0) const;
+	byte inputKey() const;
+
+	void loadWords(Common::ReadStream &stream, WordMap &map) const;
+	void readCommands(Common::ReadStream &stream, Commands &commands);
+
+	Display *_display;
+
+	// Message strings in data file
+	Common::Array<Common::String> _messages;
+	// Picture data
+	Common::Array<Picture> _pictures;
+	// Dropped item screen offsets
+	Common::Array<Common::Point> _itemOffsets;
+	// Drawings consisting of horizontal and vertical lines only, but
+	// supporting scaling and rotation
+	Common::Array<Common::Array<byte> > _lineArt;
+	// <room, verb, noun, script> lists
+	Commands _roomCommands;
+	Commands _globalCommands;
+
+	WordMap _verbs;
+	WordMap _nouns;
+
+	struct {
+		Common::String enterCommand;
+		Common::String dontHaveIt;
+		Common::String gettingDark;
+		Common::String verbError;
+		Common::String nounError;
+		Common::String playAgain;
+	} _strings;
+
+	struct {
+		uint cantGoThere;
+		uint dontUnderstand;
+		uint itemDoesntMove;
+		uint itemNotHere;
+		uint thanksForPlaying;
+	} _messageIds;
+
+	// Game state
+	State _state;
+
+private:
+	virtual void runIntro() const { }
+	virtual void loadData() = 0;
+	virtual void initState() = 0;
+	virtual void restartGame() = 0;
+	virtual void drawPic(byte pic, Common::Point pos = Common::Point()) const = 0;
+
+	// Engine
+	Common::Error run();
+	bool hasFeature(EngineFeature f) const;
+	Common::Error loadGameState(int slot);
+	bool canLoadGameStateCurrently();
+	Common::Error saveGameState(int slot, const Common::String &desc);
+	bool canSaveGameStateCurrently();
+
+	// Text output
+	void wordWrap(Common::String &str) const;
+
+	// Text input
+	byte convertKey(uint16 ascii) const;
+	Common::String getLine() const;
+	Common::String getWord(const Common::String &line, uint &index) const;
+	void getInput(uint &verb, uint &noun);
+
+	// Graphics
+	void showRoom() const;
+	void clearScreen() const;
+	void drawItems() const;
+	void drawNextPixel(Common::Point &p, byte color, byte bits, byte quadrant) const;
+	void drawLineArt(const Common::Array<byte> &lineArt, const Common::Point &pos, byte rotation = 0, byte scaling = 1, byte color = 0x7f) const;
+
+	// Game state functions
+	const Room &getRoom(uint i) const;
+	Room &getRoom(uint i);
+	const Room &getCurRoom() const;
+	Room &getCurRoom();
+	const Item &getItem(uint i) const;
+	Item &getItem(uint i);
+	byte getVar(uint i) const;
+	void setVar(uint i, byte value);
+	void takeItem(byte noun);
+	void dropItem(byte noun);
+	bool matchCommand(const Command &command, byte verb, byte noun, uint *actions = nullptr) const;
+	void doActions(const Command &command, byte noun, byte offset);
+	bool doOneCommand(const Commands &commands, byte verb, byte noun);
+	void doAllCommands(const Commands &commands, byte verb, byte noun);
+
+	const AdlGameDescription *_gameDescription;
+	bool _isRestarting, _isRestoring;
+	byte _saveVerb, _saveNoun, _restoreVerb, _restoreNoun;
+	bool _canSaveNow, _canRestoreNow;
+};
+
+AdlEngine *HiRes1Engine__create(OSystem *syst, const AdlGameDescription *gd);
+
+} // End of namespace Adl
+
+#endif
diff --git a/engines/adl/configure.engine b/engines/adl/configure.engine
new file mode 100644
index 0000000000..844e2b8e6a
--- /dev/null
+++ b/engines/adl/configure.engine
@@ -0,0 +1,3 @@
+# This file is included from the main "configure" script
+# add_engine [name] [desc] [build-by-default] [subengines] [base games] [deps]
+add_engine adl "ADL" no
diff --git a/engines/adl/detection.cpp b/engines/adl/detection.cpp
new file mode 100644
index 0000000000..1a8c5025e8
--- /dev/null
+++ b/engines/adl/detection.cpp
@@ -0,0 +1,247 @@
+/* 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/system.h"
+#include "common/savefile.h"
+#include "common/translation.h"
+
+#include "graphics/thumbnail.h"
+
+#include "engines/advancedDetector.h"
+
+#include "adl/detection.h"
+
+namespace Adl {
+
+#define GAMEOPTION_COLOR      GUIO_GAMEOPTIONS1
+#define GAMEOPTION_SCANLINES  GUIO_GAMEOPTIONS2
+
+static const ADExtraGuiOptionsMap optionsList[] = {
+	{
+		GAMEOPTION_COLOR,
+		{
+			_s("Color mode"),
+			_s("Use color graphics"),
+			"color",
+			false
+		}
+	},
+
+	{
+		GAMEOPTION_SCANLINES,
+		{
+			_s("Scanlines"),
+			_s("Show scanlines"),
+			"scanlines",
+			false
+		}
+	},
+
+	AD_EXTRA_GUI_OPTIONS_TERMINATOR
+};
+
+static const PlainGameDescriptor adlGames[] = {
+	{"hires1", "Hi-Res Adventure #1: Mystery House"},
+	{0, 0}
+};
+
+static const AdlGameDescription gameDescriptions[] = {
+	{ // Hi-Res Adventure #1: Mystery House - Apple II - 1987 PD release
+		{
+			"hires1", 0,
+			{
+				{"ADVENTURE", 0, "22d9e63a11d69fa033ba1738715ad09a", 29952},
+				{"AUTO LOAD OBJ", 0, "23bfccfe9fcff9b22cf6c41bde9078ac", 12291},
+				{"MYSTERY.HELLO", 0, "2289b7fea300b506e902a4c597968369", 836},
+				AD_LISTEND
+			},
+			Common::EN_ANY,
+			Common::kPlatformApple2GS, // FIXME
+			ADGF_NO_FLAGS,
+			GUIO2(GAMEOPTION_COLOR, GAMEOPTION_SCANLINES)
+		},
+		GAME_TYPE_HIRES1
+	},
+	{ AD_TABLE_END_MARKER, GAME_TYPE_NONE }
+};
+
+class AdlMetaEngine : public AdvancedMetaEngine {
+public:
+	AdlMetaEngine() : AdvancedMetaEngine(gameDescriptions, sizeof(AdlGameDescription), adlGames, optionsList) { }
+
+	const char *getName() const {
+		return "ADL";
+	}
+
+	const char *getOriginalCopyright() const {
+		return "Copyright (C) Sierra On-Line";
+	}
+
+	bool hasFeature(MetaEngineFeature f) const;
+	SaveStateDescriptor querySaveMetaInfos(const char *target, int slot) const;
+	int getMaximumSaveSlot() const { return 'O' - 'A'; }
+	SaveStateList listSaves(const char *target) const;
+	void removeSaveState(const char *target, int slot) const;
+
+	bool createInstance(OSystem *syst, Engine **engine, const ADGameDescription *gd) const;
+};
+
+bool AdlMetaEngine::hasFeature(MetaEngineFeature f) const {
+	switch(f) {
+	case kSupportsListSaves:
+	case kSupportsLoadingDuringStartup:
+	case kSupportsDeleteSave:
+	case kSavesSupportMetaInfo:
+	case kSavesSupportThumbnail:
+	case kSavesSupportCreationDate:
+	case kSavesSupportPlayTime:
+		return true;
+	default:
+		return false;
+	}
+}
+
+SaveStateDescriptor AdlMetaEngine::querySaveMetaInfos(const char *target, int slot) const {
+	Common::String fileName = Common::String::format("%s.s%02d", target, slot);
+	Common::InSaveFile *inFile = g_system->getSavefileManager()->openForLoading(fileName);
+
+	if (!inFile)
+		return SaveStateDescriptor();
+
+	if (inFile->readUint32BE() != MKTAG('A', 'D', 'L', ':')) {
+		delete inFile;
+		return SaveStateDescriptor();
+	}
+
+	byte saveVersion = inFile->readByte();
+	if (saveVersion != SAVEGAME_VERSION) {
+		delete inFile;
+		return SaveStateDescriptor();
+	}
+
+	char name[SAVEGAME_NAME_LEN] = { };
+	inFile->read(name, sizeof(name) - 1);
+	inFile->readByte();
+
+	if (inFile->eos() || inFile->err()) {
+		delete inFile;
+		return SaveStateDescriptor();
+	}
+
+	SaveStateDescriptor sd(slot, name);
+
+	int year = inFile->readUint16BE();
+	int month = inFile->readByte();
+	int day = inFile->readByte();
+	sd.setSaveDate(year + 1900, month + 1, day);
+
+	int hour = inFile->readByte();
+	int minutes = inFile->readByte();
+	sd.setSaveTime(hour, minutes);
+
+	uint32 playTime = inFile->readUint32BE();
+	sd.setPlayTime(playTime);
+
+	if (inFile->eos() || inFile->err()) {
+		delete inFile;
+		return SaveStateDescriptor();
+	}
+
+	Graphics::Surface *const thumbnail = Graphics::loadThumbnail(*inFile);
+	sd.setThumbnail(thumbnail);
+
+	delete inFile;
+	return sd;
+}
+
+SaveStateList AdlMetaEngine::listSaves(const char *target) const {
+	Common::SaveFileManager *saveFileMan = g_system->getSavefileManager();
+	Common::StringArray files = saveFileMan->listSavefiles(Common::String(target) + ".s##");
+
+	SaveStateList saveList;
+
+	for (uint i = 0; i < files.size(); ++i) {
+		const Common::String &fileName = files[i];
+		Common::InSaveFile *inFile = saveFileMan->openForLoading(fileName);
+		if (!inFile) {
+			warning("Cannot open save file '%s'", fileName.c_str());
+			continue;
+		}
+
+		if (inFile->readUint32BE() != MKTAG('A', 'D', 'L', ':')) {
+			warning("No header found in '%s'", fileName.c_str());
+			delete inFile;
+			continue;
+		}
+
+		byte saveVersion = inFile->readByte();
+		if (saveVersion != SAVEGAME_VERSION) {
+			warning("Unsupported save game version %i found in '%s'", saveVersion, fileName.c_str());
+			delete inFile;
+			continue;
+		}
+
+		char name[SAVEGAME_NAME_LEN] = { };
+		inFile->read(name, sizeof(name) - 1);
+		delete inFile;
+
+		int slotNum = atoi(fileName.c_str() + fileName.size() - 2);
+		SaveStateDescriptor sd(slotNum, name);
+		saveList.push_back(sd);
+	}
+
+	// Sort saves based on slot number.
+	Common::sort(saveList.begin(), saveList.end(), SaveStateDescriptorSlotComparator());
+	return saveList;
+}
+
+void AdlMetaEngine::removeSaveState(const char *target, int slot) const {
+	Common::String fileName = Common::String::format("%s.s%02d", target, slot);
+	g_system->getSavefileManager()->removeSavefile(fileName);
+}
+
+Engine *HiRes1Engine_create(OSystem *syst, const AdlGameDescription *gd);
+
+bool AdlMetaEngine::createInstance(OSystem *syst, Engine **engine, const ADGameDescription *gd) const {
+	if (!gd)
+		return false;
+
+	const AdlGameDescription *adlGd = (const AdlGameDescription *)gd;
+
+	switch (adlGd->gameType) {
+	case GAME_TYPE_HIRES1:
+		*engine = HiRes1Engine_create(syst, adlGd);
+		break;
+	default:
+		error("Unknown GameType");
+	}
+
+	return true;
+}
+
+} // End of namespace Adl
+
+#if PLUGIN_ENABLED_DYNAMIC(ADL)
+	REGISTER_PLUGIN_DYNAMIC(ADL, PLUGIN_TYPE_ENGINE, Adl::AdlMetaEngine);
+#else
+	REGISTER_PLUGIN_STATIC(ADL, PLUGIN_TYPE_ENGINE, Adl::AdlMetaEngine);
+#endif
diff --git a/engines/adl/detection.h b/engines/adl/detection.h
new file mode 100644
index 0000000000..c646aeb5b9
--- /dev/null
+++ b/engines/adl/detection.h
@@ -0,0 +1,45 @@
+/* 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 ADL_DETECTION_H
+#define ADL_DETECTION_H
+
+#include "engines/advancedDetector.h"
+
+namespace Adl {
+
+#define SAVEGAME_VERSION 0
+#define SAVEGAME_NAME_LEN 32
+
+enum GameType {
+	GAME_TYPE_NONE,
+	GAME_TYPE_HIRES1
+};
+
+struct AdlGameDescription {
+	ADGameDescription desc;
+	GameType gameType;
+};
+
+} // End of namespace Adl
+
+#endif
diff --git a/engines/adl/display.cpp b/engines/adl/display.cpp
new file mode 100644
index 0000000000..6342504bc3
--- /dev/null
+++ b/engines/adl/display.cpp
@@ -0,0 +1,520 @@
+/* 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/stream.h"
+#include "common/rect.h"
+#include "common/system.h"
+#include "common/str.h"
+#include "common/config-manager.h"
+
+#include "graphics/surface.h"
+#include "graphics/palette.h"
+#include "graphics/thumbnail.h"
+
+#include "engines/util.h"
+
+#include "adl/display.h"
+
+namespace Adl {
+
+// This implements the Apple II "Hi-Res" display mode
+
+#define DISPLAY_PITCH (DISPLAY_WIDTH / 7)
+#define DISPLAY_SIZE (DISPLAY_PITCH * DISPLAY_HEIGHT)
+
+#define TEXT_WIDTH 40
+#define TEXT_HEIGHT 24
+#define TEXT_BUF_SIZE (TEXT_WIDTH * TEXT_HEIGHT)
+
+#define COLOR_PALETTE_ENTRIES 8
+static const byte colorPalette[COLOR_PALETTE_ENTRIES * 3] = {
+	0x00, 0x00, 0x00,
+	0xff, 0xff, 0xff,
+	0xc7, 0x34, 0xff,
+	0x38, 0xcb, 0x00,
+	0x00, 0x00, 0x00,
+	0xff, 0xff, 0xff,
+	0x0d, 0xa1, 0xff,
+	0xf2, 0x5e, 0x00
+};
+
+// Corresponding color in second palette
+#define PAL2(X) ((X) | 0x04)
+
+// Alternate color for odd pixel rows (for scanlines)
+#define ALTCOL(X) ((X) | 0x08)
+
+// Green monochrome palette
+#define MONO_PALETTE_ENTRIES 2
+static const byte monoPalette[MONO_PALETTE_ENTRIES * 3] = {
+	0x00, 0x00, 0x00,
+	0x00, 0xc0, 0x01
+};
+
+// Uppercase-only Apple II font (manually created).
+static const byte font[64][5] = {
+	{ 0x7c, 0x82, 0xba, 0xb2, 0x9c }, { 0xf8, 0x24, 0x22, 0x24, 0xf8 }, // @A
+	{ 0xfe, 0x92, 0x92, 0x92, 0x6c }, { 0x7c, 0x82, 0x82, 0x82, 0x44 }, // BC
+	{ 0xfe, 0x82, 0x82, 0x82, 0x7c }, { 0xfe, 0x92, 0x92, 0x92, 0x82 }, // DE
+	{ 0xfe, 0x12, 0x12, 0x12, 0x02 }, { 0x7c, 0x82, 0x82, 0xa2, 0xe2 }, // FG
+	{ 0xfe, 0x10, 0x10, 0x10, 0xfe }, { 0x00, 0x82, 0xfe, 0x82, 0x00 }, // HI
+	{ 0x40, 0x80, 0x80, 0x80, 0x7e }, { 0xfe, 0x10, 0x28, 0x44, 0x82 }, // JK
+	{ 0xfe, 0x80, 0x80, 0x80, 0x80 }, { 0xfe, 0x04, 0x18, 0x04, 0xfe }, // LM
+	{ 0xfe, 0x08, 0x10, 0x20, 0xfe }, { 0x7c, 0x82, 0x82, 0x82, 0x7c }, // NO
+	{ 0xfe, 0x12, 0x12, 0x12, 0x0c }, { 0x7c, 0x82, 0xa2, 0x42, 0xbc }, // PQ
+	{ 0xfe, 0x12, 0x32, 0x52, 0x8c }, { 0x4c, 0x92, 0x92, 0x92, 0x64 }, // RS
+	{ 0x02, 0x02, 0xfe, 0x02, 0x02 }, { 0x7e, 0x80, 0x80, 0x80, 0x7e }, // TU
+	{ 0x3e, 0x40, 0x80, 0x40, 0x3e }, { 0xfe, 0x40, 0x30, 0x40, 0xfe }, // VW
+	{ 0xc6, 0x28, 0x10, 0x28, 0xc6 }, { 0x06, 0x08, 0xf0, 0x08, 0x06 }, // XY
+	{ 0xc2, 0xa2, 0x92, 0x8a, 0x86 }, { 0xfe, 0xfe, 0x82, 0x82, 0x82 }, // Z[
+	{ 0x04, 0x08, 0x10, 0x20, 0x40 }, { 0x82, 0x82, 0x82, 0xfe, 0xfe }, // \]
+	{ 0x20, 0x10, 0x08, 0x10, 0x20 }, { 0x80, 0x80, 0x80, 0x80, 0x80 }, // ^_
+	{ 0x00, 0x00, 0x00, 0x00, 0x00 }, { 0x00, 0x00, 0xbe, 0x00, 0x00 }, //  !
+	{ 0x00, 0x0e, 0x00, 0x0e, 0x00 }, { 0x28, 0xfe, 0x28, 0xfe, 0x28 }, // "#
+	{ 0x48, 0x54, 0xfe, 0x54, 0x24 }, { 0x46, 0x26, 0x10, 0xc8, 0xc4 }, // $%
+	{ 0x6c, 0x92, 0xac, 0x40, 0xa0 }, { 0x00, 0x00, 0x0e, 0x00, 0x00 }, // &'
+	{ 0x38, 0x44, 0x82, 0x00, 0x00 }, { 0x00, 0x00, 0x82, 0x44, 0x38 }, // ()
+	{ 0x44, 0x28, 0xfe, 0x28, 0x44 }, { 0x10, 0x10, 0x7c, 0x10, 0x10 }, // *+
+	{ 0x00, 0x80, 0x60, 0x00, 0x00 }, { 0x10, 0x10, 0x10, 0x10, 0x10 }, // ,-
+	{ 0x00, 0x00, 0x80, 0x00, 0x00 }, { 0x40, 0x20, 0x10, 0x08, 0x04 }, // ./
+	{ 0x7c, 0xa2, 0x92, 0x8a, 0x7c }, { 0x00, 0x84, 0xfe, 0x80, 0x00 }, // 01
+	{ 0xc4, 0xa2, 0x92, 0x92, 0x8c }, { 0x42, 0x82, 0x92, 0x9a, 0x66 }, // 23
+	{ 0x30, 0x28, 0x24, 0xfe, 0x20 }, { 0x4e, 0x8a, 0x8a, 0x8a, 0x72 }, // 45
+	{ 0x78, 0x94, 0x92, 0x92, 0x62 }, { 0x02, 0xe2, 0x12, 0x0a, 0x06 }, // 67
+	{ 0x6c, 0x92, 0x92, 0x92, 0x6c }, { 0x8c, 0x92, 0x92, 0x52, 0x3c }, // 89
+	{ 0x00, 0x00, 0x28, 0x00, 0x00 }, { 0x00, 0x80, 0x68, 0x00, 0x00 }, // :;
+	{ 0x10, 0x28, 0x44, 0x82, 0x00 }, { 0x28, 0x28, 0x28, 0x28, 0x28 }, // <=
+	{ 0x00, 0x82, 0x44, 0x28, 0x10 }, { 0x04, 0x02, 0xb2, 0x0a, 0x04 }  // >?
+};
+
+Display::Display() :
+		_mode(DISPLAY_MODE_TEXT),
+		_cursorPos(0),
+		_showCursor(false) {
+
+	initGraphics(DISPLAY_WIDTH * 2, DISPLAY_HEIGHT * 2, true);
+
+	_monochrome = !ConfMan.getBool("color");
+	_scanlines = ConfMan.getBool("scanlines");
+
+	if (_monochrome)
+		g_system->getPaletteManager()->setPalette(monoPalette, 0, MONO_PALETTE_ENTRIES);
+	else
+		g_system->getPaletteManager()->setPalette(colorPalette, 0, COLOR_PALETTE_ENTRIES);
+
+	showScanlines(_scanlines);
+
+	_frameBuf = new byte[DISPLAY_SIZE];
+	memset(_frameBuf, 0, DISPLAY_SIZE);
+	_frameBufSurface = new Graphics::Surface;
+	// We need 2x scaling to properly render the half-pixel shift
+	// of the second palette
+	_frameBufSurface->create(DISPLAY_WIDTH * 2, DISPLAY_HEIGHT * 2, Graphics::PixelFormat::createFormatCLUT8());
+
+	_textBuf = new byte[TEXT_BUF_SIZE];
+	memset(_textBuf, APPLECHAR(' '), TEXT_BUF_SIZE);
+	_textBufSurface = new Graphics::Surface;
+	// For ease of copying, also use 2x scaling here
+	_textBufSurface->create(DISPLAY_WIDTH * 2, DISPLAY_HEIGHT * 2, Graphics::PixelFormat::createFormatCLUT8());
+
+	createFont();
+}
+
+Display::~Display() {
+	delete[] _frameBuf;
+	_frameBufSurface->free();
+	delete _frameBufSurface;
+
+	delete[] _textBuf;
+	_textBufSurface->free();
+	delete _textBufSurface;
+
+	_font->free();
+	delete _font;
+}
+
+void Display::setMode(DisplayMode mode) {
+	_mode = mode;
+
+	if (_mode == DISPLAY_MODE_TEXT || _mode == DISPLAY_MODE_MIXED)
+		updateTextScreen();
+	if (_mode == DISPLAY_MODE_HIRES || _mode == DISPLAY_MODE_MIXED)
+		updateHiResScreen();
+}
+
+void Display::updateTextScreen() {
+	updateTextSurface();
+
+	if (_mode == DISPLAY_MODE_TEXT)
+		g_system->copyRectToScreen(_textBufSurface->getPixels(), _textBufSurface->pitch, 0, 0, _textBufSurface->w, _textBufSurface->h);
+	else if (_mode == DISPLAY_MODE_MIXED)
+		g_system->copyRectToScreen(_textBufSurface->getBasePtr(0, _textBufSurface->h - 4 * 8 * 2), _textBufSurface->pitch, 0, _textBufSurface->h - 4 * 8 * 2, _textBufSurface->w, 4 * 8 * 2);
+
+	g_system->updateScreen();
+}
+
+void Display::updateHiResScreen() {
+	updateHiResSurface();
+
+	if (_mode == DISPLAY_MODE_HIRES)
+		g_system->copyRectToScreen(_frameBufSurface->getPixels(), _frameBufSurface->pitch, 0, 0, _frameBufSurface->w, _frameBufSurface->h);
+	else if (_mode == DISPLAY_MODE_MIXED)
+		g_system->copyRectToScreen(_frameBufSurface->getPixels(), _frameBufSurface->pitch, 0, 0, _frameBufSurface->w, _frameBufSurface->h - 4 * 8 * 2);
+
+	g_system->updateScreen();
+}
+
+bool Display::saveThumbnail(Common::WriteStream &out) {
+	if (_scanlines) {
+		showScanlines(false);
+		g_system->updateScreen();
+	}
+
+	bool retval = Graphics::saveThumbnail(out);
+
+	if (_scanlines) {
+		showScanlines(true);
+		g_system->updateScreen();
+	}
+
+	return retval;
+}
+
+void Display::loadFrameBuffer(Common::ReadStream &stream) {
+	byte *dst = _frameBuf;
+	for (uint j = 0; j < 8; ++j) {
+		for (uint i = 0; i < 8; ++i) {
+			stream.read(dst, DISPLAY_PITCH);
+			dst += DISPLAY_PITCH * 64;
+			stream.read(dst, DISPLAY_PITCH);
+			dst += DISPLAY_PITCH * 64;
+			stream.read(dst, DISPLAY_PITCH);
+			stream.readUint32LE();
+			stream.readUint32LE();
+			dst -= DISPLAY_PITCH * 120;
+		}
+		dst -= DISPLAY_PITCH * 63;
+	}
+
+	if (stream.eos() || stream.err())
+		error("Failed to read frame buffer");
+}
+
+void Display::putPixel(const Common::Point &p, byte color) {
+	byte offset = p.x / 7;
+
+	if (offset & 1) {
+		byte c = color << 1;
+		if (c >= 0x40 && c < 0xc0)
+			color ^= 0x7f;
+	}
+
+	byte *b = _frameBuf + p.y * DISPLAY_PITCH + offset;
+	color ^= *b;
+	color &= 1 << (p.x % 7);
+	*b ^= color;
+}
+
+void Display::clear(byte color) {
+	byte val = 0;
+
+	byte c = color << 1;
+	if (c >= 0x40 && c < 0xc0)
+		val = 0x7f;
+
+	for (uint i = 0; i < DISPLAY_SIZE; ++i) {
+		_frameBuf[i] = color;
+		color ^= val;
+	}
+}
+
+void Display::home() {
+	memset(_textBuf, APPLECHAR(' '), TEXT_BUF_SIZE);
+	_cursorPos = 0;
+}
+
+void Display::moveCursorForward() {
+	++_cursorPos;
+
+	if (_cursorPos >= TEXT_BUF_SIZE)
+		scrollUp();
+}
+
+void Display::moveCursorBackward() {
+	if (_cursorPos > 0)
+		--_cursorPos;
+}
+
+void Display::moveCursorTo(const Common::Point &pos) {
+	_cursorPos = pos.y * TEXT_WIDTH + pos.x;
+
+	if (_cursorPos >= TEXT_BUF_SIZE)
+		error("Cursor position (%i, %i) out of bounds", pos.x, pos.y);
+}
+
+void Display::printString(const Common::String &str) {
+	Common::String::const_iterator c;
+	for (c = str.begin(); c != str.end(); ++c) {
+		byte b = *c;
+
+		if (*c == APPLECHAR('\r'))
+			_cursorPos = (_cursorPos / TEXT_WIDTH + 1) * TEXT_WIDTH;
+		else if (b < 0x80 || b >= 0xa0) {
+			setCharAtCursor(b);
+			++_cursorPos;
+		}
+
+		if (_cursorPos == TEXT_BUF_SIZE)
+			scrollUp();
+	}
+
+	updateTextScreen();
+}
+
+void Display::printAsciiString(const Common::String &str) {
+	Common::String aStr;
+
+	Common::String::const_iterator it;
+	for (it = str.begin(); it != str.end(); ++it)
+			aStr += APPLECHAR(*it);
+
+	printString(aStr);
+}
+
+void Display::setCharAtCursor(byte c) {
+	_textBuf[_cursorPos] = c;
+}
+
+void Display::showCursor(bool enable) {
+	_showCursor = enable;
+}
+
+void Display::showScanlines(bool enable) {
+	byte pal[COLOR_PALETTE_ENTRIES * 3] = { };
+
+	if (enable)
+		g_system->getPaletteManager()->setPalette(pal, COLOR_PALETTE_ENTRIES, COLOR_PALETTE_ENTRIES);
+	else {
+		g_system->getPaletteManager()->grabPalette(pal, 0, COLOR_PALETTE_ENTRIES);
+		g_system->getPaletteManager()->setPalette(pal, COLOR_PALETTE_ENTRIES, COLOR_PALETTE_ENTRIES);
+	}
+}
+
+static byte processColorBits(uint16 &bits, bool &odd, bool secondPal) {
+	byte color = 0;
+
+	switch (bits & 0x7) {
+	case 0x3: // 011 (white)
+	case 0x6: // 110
+	case 0x7: // 111
+		color = 1;
+		break;
+	case 0x2: // 010 (color)
+		color = 2 + odd;
+		break;
+	case 0x5: // 101 (color)
+		color = 2 + !odd;
+	}
+
+	if (secondPal)
+		color = PAL2(color);
+
+	odd = !odd;
+	bits >>= 1;
+
+	return color;
+}
+
+static void renderPixelRowColor(byte *dst, byte *src) {
+	uint16 bits = (src[0] & 0x7f) << 1;
+	byte pal = src[0] >> 7;
+
+	if (pal != 0)
+		*dst++ = 0;
+
+	bool odd = false;
+
+	for (uint i = 0; i < DISPLAY_PITCH; ++i) {
+		if (i != DISPLAY_PITCH - 1) {
+			bits |= (src[i + 1] & 0x7f) << 8;
+			pal |= (src[i + 1] >> 7) << 1;
+		}
+
+		// For the first 6 bits in the block we draw two pixels
+		for (uint j = 0; j < 6; ++j) {
+			byte color = processColorBits(bits, odd, pal & 1);
+			*dst++ = color;
+			*dst++ = color;
+		}
+
+		// Last bit of the block, draw one, two or three pixels
+		byte color = processColorBits(bits, odd, pal & 1);
+
+		// Draw the first pixel
+		*dst++ = color;
+
+		switch (pal) {
+			case 0x0:
+			case 0x3:
+				// If palette stays the same, draw a second pixel
+				*dst++ = color;
+				break;
+			case 0x2:
+				// If we're moving from first to second palette,
+				// draw a second pixel, and a third in the second
+				// palette.
+				*dst++ = color;
+				*dst++ = PAL2(color);
+		}
+
+		pal >>= 1;
+	}
+}
+
+static void renderPixelRowMono(byte *dst, byte *src) {
+	byte pal = src[0] >> 7;
+
+	if (pal != 0)
+		*dst++ = 0;
+
+	for (uint i = 0; i < DISPLAY_PITCH; ++i) {
+		if (i != DISPLAY_PITCH - 1)
+			pal |= (src[i + 1] >> 7) << 1;
+
+		for (uint j = 0; j < 6; ++j) {
+			bool color = src[i] & (1 << j);
+			*dst++ = color;
+			*dst++ = color;
+		}
+
+		bool color = src[i] & (1 << 6);
+
+		*dst++ = color;
+
+		switch (pal) {
+			case 0x0:
+			case 0x3:
+				*dst++ = color;
+				break;
+			case 0x2:
+				*dst++ = color;
+				*dst++ = color;
+		}
+
+		pal >>= 1;
+	}
+}
+
+static void copyEvenSurfaceRows(Graphics::Surface &surf) {
+	byte *src = (byte *)surf.getPixels();
+
+	for (uint y = 0; y < surf.h / 2; ++y) {
+		byte *dst = src + surf.pitch;
+		for (uint x = 0; x < surf.w; ++x)
+			dst[x] = ALTCOL(src[x]);
+		src += surf.pitch * 2;
+	}
+}
+
+void Display::updateHiResSurface() {
+	byte *src = _frameBuf;
+	byte *dst = (byte *)_frameBufSurface->getPixels();
+
+	for (uint i = 0; i < DISPLAY_HEIGHT; ++i) {
+		if (_monochrome)
+			renderPixelRowMono(dst, src);
+		else
+			renderPixelRowColor(dst, src);
+		src += DISPLAY_PITCH;
+		dst += _frameBufSurface->pitch * 2;
+	}
+
+	copyEvenSurfaceRows(*_frameBufSurface);
+}
+
+void Display::updateTextSurface() {
+	for (uint row = 0; row < 24; ++row)
+		for (uint col = 0; col < TEXT_WIDTH; ++col) {
+			uint charPos = row * TEXT_WIDTH + col;
+			char c = _textBuf[row * TEXT_WIDTH + col];
+
+			if (charPos == _cursorPos && _showCursor)
+				c = (c & 0x3f) | 0x40;
+
+			Common::Rect r(7 * 2, 8 * 2);
+			r.translate(((c & 0x3f) % 16) * 7 * 2, (c & 0x3f) / 16 * 8 * 2);
+
+			if (!(c & 0x80)) {
+				if (!(c & 0x40) || ((g_system->getMillis() / 270) & 1))
+					r.translate(0, 4 * 8 * 2);
+			}
+
+			_textBufSurface->copyRectToSurface(*_font, col * 7 * 2, row * 8 * 2, r);
+		}
+}
+
+void Display::drawChar(byte c, int x, int y) {
+	byte *buf = (byte *)_font->getPixels() + y * _font->pitch + x;
+
+	for (uint row = 0; row < 8; ++row) {
+		for (uint col = 1; col < 6; ++col) {
+			if (font[c][col - 1] & (1 << row)) {
+				buf[col * 2] = 1;
+				buf[col * 2 + 1] = 1;
+			}
+		}
+
+		buf += 2 * _font->pitch;
+	}
+}
+
+void Display::createFont() {
+	_font = new Graphics::Surface;
+	_font->create(16 * 7 * 2, 4 * 8 * 2 * 2, Graphics::PixelFormat::createFormatCLUT8());
+
+	for (uint i = 0; i < 4; ++i)
+		for (uint j = 0; j < 16; ++j)
+			drawChar(i * 16 + j, j * 7 * 2, i * 8 * 2);
+
+	// Create inverted font
+	byte *buf = (byte *)_font->getPixels();
+	byte *bufInv = buf + (_font->h / 2) * _font->pitch;
+
+	for (uint row = 0; row < _font->h / 2; row += 2) {
+		for (uint col = 0; col < _font->w; ++col)
+			bufInv[col] = (buf[col] ? 0 : 1);
+
+		buf += _font->pitch * 2;
+		bufInv += _font->pitch * 2;
+	}
+
+	copyEvenSurfaceRows(*_font);
+}
+
+void Display::scrollUp() {
+	memmove(_textBuf, _textBuf + TEXT_WIDTH, TEXT_BUF_SIZE - TEXT_WIDTH);
+	memset(_textBuf + TEXT_BUF_SIZE - TEXT_WIDTH, APPLECHAR(' '), TEXT_WIDTH);
+	if (_cursorPos >= TEXT_WIDTH)
+		_cursorPos -= TEXT_WIDTH;
+}
+
+} // End of namespace Adl
diff --git a/engines/adl/display.h b/engines/adl/display.h
new file mode 100644
index 0000000000..e61477da84
--- /dev/null
+++ b/engines/adl/display.h
@@ -0,0 +1,102 @@
+/* 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 ADL_DISPLAY_H
+#define ADL_DISPLAY_H
+
+#include <common/types.h>
+
+namespace Common {
+class ReadStream;
+class WriteStream;
+class String;
+class Point;
+}
+
+namespace Graphics {
+class Surface;
+}
+
+namespace Adl {
+
+#define DISPLAY_WIDTH 280
+#define DISPLAY_HEIGHT 192
+
+enum DisplayMode {
+	DISPLAY_MODE_HIRES,
+	DISPLAY_MODE_TEXT,
+	DISPLAY_MODE_MIXED
+};
+
+#define APPLECHAR(C) ((char)((C) | 0x80))
+
+class Display {
+public:
+	Display();
+	~Display();
+
+	void setMode(DisplayMode mode);
+	void updateTextScreen();
+	void updateHiResScreen();
+	bool saveThumbnail(Common::WriteStream &out);
+
+	// Graphics
+	void loadFrameBuffer(Common::ReadStream &stream);
+	void putPixel(const Common::Point &p, byte color);
+	void clear(byte color);
+
+	// Text
+	void home();
+	void moveCursorTo(const Common::Point &pos);
+	void moveCursorForward();
+	void moveCursorBackward();
+	void printString(const Common::String &str);
+	void printAsciiString(const Common::String &str);
+	void setCharAtCursor(byte c);
+	void showCursor(bool enable);
+
+private:
+	void updateHiResSurface();
+	void showScanlines(bool enable);
+
+	void updateTextSurface();
+	void drawChar(byte c, int x, int y);
+	void createFont();
+	void scrollUp();
+
+	DisplayMode _mode;
+
+	byte *_frameBuf;
+	Graphics::Surface *_frameBufSurface;
+	bool _scanlines;
+	bool _monochrome;
+
+	byte *_textBuf;
+	Graphics::Surface *_textBufSurface;
+	Graphics::Surface *_font;
+	uint _cursorPos;
+	bool _showCursor;
+};
+ 
+} // End of namespace Adl
+
+#endif
diff --git a/engines/adl/hires1.cpp b/engines/adl/hires1.cpp
new file mode 100644
index 0000000000..6e1e31df9f
--- /dev/null
+++ b/engines/adl/hires1.cpp
@@ -0,0 +1,396 @@
+/* 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/system.h"
+#include "common/debug.h"
+#include "common/error.h"
+#include "common/file.h"
+#include "common/stream.h"
+
+#include "adl/hires1.h"
+#include "adl/display.h"
+
+namespace Adl {
+
+void HiRes1Engine::runIntro() const {
+	Common::File file;
+
+	if (!file.open(IDS_HR1_EXE_0))
+		error("Failed to open file '" IDS_HR1_EXE_0 "'");
+
+	file.seek(IDI_HR1_OFS_LOGO_0);
+	_display->setMode(DISPLAY_MODE_HIRES);
+	_display->loadFrameBuffer(file);
+	_display->updateHiResScreen();
+	delay(4000);
+
+	if (shouldQuit())
+		return;
+
+	_display->setMode(DISPLAY_MODE_TEXT);
+
+	Common::File basic;
+	if (!basic.open(IDS_HR1_LOADER))
+		error("Failed to open file '" IDS_HR1_LOADER "'");
+
+	Common::String str;
+
+	str = readStringAt(basic, IDI_HR1_OFS_PD_TEXT_0, '"');
+	_display->printAsciiString(str + '\r');
+
+	str = readStringAt(basic, IDI_HR1_OFS_PD_TEXT_1, '"');
+	_display->printAsciiString(str + "\r\r");
+
+	str = readStringAt(basic, IDI_HR1_OFS_PD_TEXT_2, '"');
+	_display->printAsciiString(str + "\r\r");
+
+	str = readStringAt(basic, IDI_HR1_OFS_PD_TEXT_3, '"');
+	_display->printAsciiString(str + '\r');
+
+	inputKey();
+	if (g_engine->shouldQuit())
+		return;
+
+	_display->setMode(DISPLAY_MODE_MIXED);
+
+	str = readStringAt(file, IDI_HR1_OFS_GAME_OR_HELP);
+
+	bool instructions = false;
+
+	while (1) {
+		_display->printString(str);
+		Common::String s = inputString();
+
+		if (g_engine->shouldQuit())
+			break;
+
+		if (s.empty())
+			continue;
+
+		if (s[0] == APPLECHAR('I')) {
+			instructions = true;
+			break;
+		} else if (s[0] == APPLECHAR('G')) {
+			break;
+		}
+	};
+
+	if (instructions) {
+		_display->setMode(DISPLAY_MODE_TEXT);
+		file.seek(IDI_HR1_OFS_INTRO_TEXT);
+
+		const uint pages[] = { 6, 6, 4, 5, 8, 7, 0 };
+
+		uint page = 0;
+		while (pages[page] != 0) {
+			_display->home();
+
+			uint count = pages[page++];
+			for (uint i = 0; i < count; ++i) {
+				str = readString(file);
+				_display->printString(str);
+				file.seek(3, SEEK_CUR);
+			}
+
+			inputString();
+
+			if (g_engine->shouldQuit())
+				return;
+
+			file.seek(6, SEEK_CUR);
+		}
+	}
+
+	_display->printAsciiString("\r");
+
+	file.close();
+
+	_display->setMode(DISPLAY_MODE_MIXED);
+
+	if (!file.open(IDS_HR1_EXE_1))
+		error("Failed to open file '" IDS_HR1_EXE_1 "'");
+
+	// Title screen shown during loading
+	file.seek(IDI_HR1_OFS_LOGO_1);
+	_display->loadFrameBuffer(file);
+	_display->updateHiResScreen();
+	delay(2000);
+}
+
+void HiRes1Engine::loadData() {
+	Common::File f;
+
+	if (!f.open(IDS_HR1_MESSAGES))
+		error("Failed to open file '" IDS_HR1_MESSAGES "'");
+
+	for (uint i = 0; i < IDI_HR1_NUM_MESSAGES; ++i)
+		_messages.push_back(readString(f, APPLECHAR('\r')) + APPLECHAR('\r'));
+
+	f.close();
+
+	if (!f.open(IDS_HR1_EXE_1))
+		error("Failed to open file '" IDS_HR1_EXE_1 "'");
+
+	// Some messages have overrides inside the executable
+	_messages[IDI_HR1_MSG_CANT_GO_THERE - 1] = readStringAt(f, IDI_HR1_OFS_STR_CANT_GO_THERE);
+	_messages[IDI_HR1_MSG_DONT_HAVE_IT - 1] = readStringAt(f, IDI_HR1_OFS_STR_DONT_HAVE_IT);
+	_messages[IDI_HR1_MSG_DONT_UNDERSTAND - 1] = readStringAt(f, IDI_HR1_OFS_STR_DONT_UNDERSTAND);
+	_messages[IDI_HR1_MSG_GETTING_DARK - 1] = readStringAt(f, IDI_HR1_OFS_STR_GETTING_DARK);
+
+	// Load other strings from executable
+	_strings.enterCommand = readStringAt(f, IDI_HR1_OFS_STR_ENTER_COMMAND);
+	_strings.dontHaveIt = readStringAt(f, IDI_HR1_OFS_STR_DONT_HAVE_IT);
+	_strings.gettingDark = readStringAt(f, IDI_HR1_OFS_STR_GETTING_DARK);
+	_strings.verbError = readStringAt(f, IDI_HR1_OFS_STR_VERB_ERROR);
+	_strings.nounError = readStringAt(f, IDI_HR1_OFS_STR_NOUN_ERROR);
+	_strings.playAgain = readStringAt(f, IDI_HR1_OFS_STR_PLAY_AGAIN);
+	_gameStrings.pressReturn = readStringAt(f, IDI_HR1_OFS_STR_PRESS_RETURN);
+
+	// Set message IDs
+	_messageIds.cantGoThere = IDI_HR1_MSG_CANT_GO_THERE;
+	_messageIds.dontUnderstand = IDI_HR1_MSG_DONT_UNDERSTAND;
+	_messageIds.itemDoesntMove = IDI_HR1_MSG_ITEM_DOESNT_MOVE;
+	_messageIds.itemNotHere = IDI_HR1_MSG_ITEM_NOT_HERE;
+	_messageIds.thanksForPlaying = IDI_HR1_MSG_THANKS_FOR_PLAYING;
+
+	// Load picture data from executable
+	f.seek(IDI_HR1_OFS_PICS);
+	for (uint i = 0; i < IDI_HR1_NUM_PICS; ++i) {
+		struct Picture pic;
+		pic.block = f.readByte();
+		pic.offset = f.readUint16LE();
+		_pictures.push_back(pic);
+	}
+
+	// Load commands from executable
+	f.seek(IDI_HR1_OFS_CMDS_1);
+	readCommands(f, _roomCommands);
+
+	f.seek(IDI_HR1_OFS_CMDS_0);
+	readCommands(f, _globalCommands);
+
+	// Load dropped item offsets
+	f.seek(IDI_HR1_OFS_ITEM_OFFSETS);
+	for (uint i = 0; i < IDI_HR1_NUM_ITEM_OFFSETS; ++i) {
+		Common::Point p;
+		p.x = f.readByte();
+		p.y = f.readByte();
+		_itemOffsets.push_back(p);
+	}
+
+	// Load right-angle line art
+	f.seek(IDI_HR1_OFS_LINE_ART);
+	uint16 lineArtTotal = f.readUint16LE();
+	for (uint i = 0; i < lineArtTotal; ++i) {
+		f.seek(IDI_HR1_OFS_LINE_ART + 2 + i * 2);
+		uint16 offset = f.readUint16LE();
+		f.seek(IDI_HR1_OFS_LINE_ART + offset);
+
+		Common::Array<byte> lineArt;
+		byte b = f.readByte();
+		while (b != 0) {
+			lineArt.push_back(b);
+			b = f.readByte();
+		}
+		_lineArt.push_back(lineArt);
+	}
+
+	if (f.eos() || f.err())
+		error("Failed to read game data from '" IDS_HR1_EXE_1 "'");
+
+	f.seek(IDI_HR1_OFS_VERBS);
+	loadWords(f, _verbs);
+
+	f.seek(IDI_HR1_OFS_NOUNS);
+	loadWords(f, _nouns);
+}
+
+void HiRes1Engine::initState() {
+	Common::File f;
+
+	_state.room = 1;
+	_state.moves = 0;
+	_state.isDark = false;
+
+	_state.vars.clear();
+	_state.vars.resize(IDI_HR1_NUM_VARS);
+
+	if (!f.open(IDS_HR1_EXE_1))
+		error("Failed to open file '" IDS_HR1_EXE_1 "'");
+
+	// Load room data from executable
+	_state.rooms.clear();
+	f.seek(IDI_HR1_OFS_ROOMS);
+	for (uint i = 0; i < IDI_HR1_NUM_ROOMS; ++i) {
+		Room room;
+		f.readByte();
+		room.description = f.readByte();
+		for (uint j = 0; j < 6; ++j)
+			room.connections[j] = f.readByte();
+		room.picture = f.readByte();
+		room.curPicture = f.readByte();
+		_state.rooms.push_back(room);
+	}
+
+	// Load item data from executable
+	_state.items.clear();
+	f.seek(IDI_HR1_OFS_ITEMS);
+	while (f.readByte() != 0xff) {
+		Item item;
+		item.noun = f.readByte();
+		item.room = f.readByte();
+		item.picture = f.readByte();
+		item.isLineArt = f.readByte();
+		item.position.x = f.readByte();
+		item.position.y = f.readByte();
+		item.state = f.readByte();
+		item.description = f.readByte();
+
+		f.readByte();
+
+		byte size = f.readByte();
+
+		for (uint i = 0; i < size; ++i)
+			item.roomPictures.push_back(f.readByte());
+
+		_state.items.push_back(item);
+	}
+}
+
+void HiRes1Engine::restartGame() {
+	initState();
+	_display->printString(_gameStrings.pressReturn);
+	inputString(); // Missing in the original
+	_display->printAsciiString("\r\r\r\r\r");
+}
+
+void HiRes1Engine::drawPic(byte pic, Common::Point pos) const {
+	Common::File f;
+	Common::String name = Common::String::format("BLOCK%i", _pictures[pic].block);
+
+	if (!f.open(name))
+		error("Failed to open file '%s'", name.c_str());
+
+	f.seek(_pictures[pic].offset);
+	drawPic(f, pos);
+}
+
+void HiRes1Engine::printMessage(uint idx, bool wait) const {
+	// Messages with hardcoded overrides don't delay after printing.
+	// It's unclear if this is a bug or not. In some cases the result
+	// is that these strings will scroll past the four-line text window
+	// before the user gets a chance to read them.
+	// NOTE: later games seem to wait for a key when the text window
+	// overflows and don't use delays. It might be better to use
+	// that system for this game as well.
+	switch (idx) {
+	case IDI_HR1_MSG_CANT_GO_THERE:
+	case IDI_HR1_MSG_DONT_HAVE_IT:
+	case IDI_HR1_MSG_DONT_UNDERSTAND:
+	case IDI_HR1_MSG_GETTING_DARK:
+		wait = false;
+	}
+
+	AdlEngine::printMessage(idx, wait);
+}
+
+void HiRes1Engine::drawLine(const Common::Point &p1, const Common::Point &p2, byte color) const {
+	// This draws a four-connected line
+
+	int16 deltaX = p2.x - p1.x;
+	int8 xStep = 1;
+
+	if (deltaX < 0) {
+		deltaX = -deltaX;
+		xStep = -1;
+	}
+
+	int16 deltaY = p2.y - p1.y;
+	int8 yStep = -1;
+
+	if (deltaY > 0) {
+		deltaY = -deltaY;
+		yStep = 1;
+	}
+
+	Common::Point p(p1);
+	int16 steps = deltaX - deltaY + 1;
+	int16 err = deltaX + deltaY;
+
+	while (1) {
+		_display->putPixel(p, color);
+
+		if (--steps == 0)
+			return;
+
+		if (err < 0) {
+			p.y += yStep;
+			err += deltaX;
+		} else {
+			p.x += xStep;
+			err += deltaY;
+		}
+	}
+}
+
+void HiRes1Engine::drawPic(Common::ReadStream &stream, const Common::Point &pos) const {
+	byte x, y;
+	bool bNewLine = false;
+	byte oldX = 0, oldY = 0;
+	while (1) {
+		x = stream.readByte();
+		y = stream.readByte();
+
+		if (stream.err() || stream.eos())
+			error("Failed to read picture");
+
+		if (x == 0xff && y == 0xff)
+			return;
+
+		if (x == 0 && y == 0) {
+			bNewLine = true;
+			continue;
+		}
+
+		x += pos.x;
+		y += pos.y;
+
+		if (y > 160)
+			y = 160;
+
+		if (bNewLine) {
+			_display->putPixel(Common::Point(x, y), 0x7f);
+			bNewLine = false;
+		} else {
+			drawLine(Common::Point(oldX, oldY), Common::Point(x, y), 0x7f);
+		}
+
+		oldX = x;
+		oldY = y;
+	}
+}
+
+Engine *HiRes1Engine_create(OSystem *syst, const AdlGameDescription *gd) {
+	return new HiRes1Engine(syst, gd);
+}
+
+} // End of namespace Adl
diff --git a/engines/adl/hires1.h b/engines/adl/hires1.h
new file mode 100644
index 0000000000..d9d67c46e4
--- /dev/null
+++ b/engines/adl/hires1.h
@@ -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.
+ *
+ */
+
+#ifndef ADL_HIRES1_H
+#define ADL_HIRES1_H
+
+#include "common/str.h"
+
+#include "adl/adl.h"
+
+namespace Common {
+class ReadStream;
+class Point;
+}
+
+namespace Adl {
+
+#define IDS_HR1_EXE_0    "AUTO LOAD OBJ"
+#define IDS_HR1_EXE_1    "ADVENTURE"
+#define IDS_HR1_LOADER   "MYSTERY.HELLO"
+#define IDS_HR1_MESSAGES "MESSAGES"
+
+#define IDI_HR1_NUM_ROOMS         41
+#define IDI_HR1_NUM_PICS          98
+#define IDI_HR1_NUM_VARS          20
+#define IDI_HR1_NUM_ITEM_OFFSETS  21
+#define IDI_HR1_NUM_MESSAGES     167
+
+// Messages used outside of scripts
+#define IDI_HR1_MSG_CANT_GO_THERE      137
+#define IDI_HR1_MSG_DONT_UNDERSTAND     37
+#define IDI_HR1_MSG_ITEM_DOESNT_MOVE   151
+#define IDI_HR1_MSG_ITEM_NOT_HERE      152
+#define IDI_HR1_MSG_THANKS_FOR_PLAYING 140
+#define IDI_HR1_MSG_DONT_HAVE_IT       127
+#define IDI_HR1_MSG_GETTING_DARK         7
+
+#define IDI_HR1_OFS_STR_ENTER_COMMAND   0x5bbc
+#define IDI_HR1_OFS_STR_VERB_ERROR      0x5b4f
+#define IDI_HR1_OFS_STR_NOUN_ERROR      0x5b8e
+#define IDI_HR1_OFS_STR_PLAY_AGAIN      0x5f1e
+#define IDI_HR1_OFS_STR_CANT_GO_THERE   0x6c0a
+#define IDI_HR1_OFS_STR_DONT_HAVE_IT    0x6c31
+#define IDI_HR1_OFS_STR_DONT_UNDERSTAND 0x6c51
+#define IDI_HR1_OFS_STR_GETTING_DARK    0x6c7c
+#define IDI_HR1_OFS_STR_PRESS_RETURN    0x5f68
+
+#define IDI_HR1_OFS_PD_TEXT_0    0x005d
+#define IDI_HR1_OFS_PD_TEXT_1    0x012b
+#define IDI_HR1_OFS_PD_TEXT_2    0x016d
+#define IDI_HR1_OFS_PD_TEXT_3    0x0259
+
+#define IDI_HR1_OFS_INTRO_TEXT   0x0066
+#define IDI_HR1_OFS_GAME_OR_HELP 0x000f
+
+#define IDI_HR1_OFS_LOGO_0       0x1003
+#define IDI_HR1_OFS_LOGO_1       0x1800
+
+#define IDI_HR1_OFS_ITEMS        0x0100
+#define IDI_HR1_OFS_ROOMS        0x050a
+#define IDI_HR1_OFS_PICS         0x4b00
+#define IDI_HR1_OFS_CMDS_0       0x3c00
+#define IDI_HR1_OFS_CMDS_1       0x3d00
+
+#define IDI_HR1_OFS_ITEM_OFFSETS 0x68ff
+#define IDI_HR1_OFS_LINE_ART     0x4f00
+
+#define IDI_HR1_OFS_VERBS        0x3800
+#define IDI_HR1_OFS_NOUNS        0x0f00
+
+class HiRes1Engine : public AdlEngine {
+public:
+	HiRes1Engine(OSystem *syst, const AdlGameDescription *gd) : AdlEngine(syst, gd) { }
+
+private:
+	// AdlEngine
+	void runIntro() const;
+	void loadData();
+	void initState();
+	void restartGame();
+	void drawPic(byte pic, Common::Point pos) const;
+	void printMessage(uint idx, bool wait = true) const;
+
+	void drawLine(const Common::Point &p1, const Common::Point &p2, byte color) const;
+	void drawPic(Common::ReadStream &stream, const Common::Point &pos) const;
+
+	struct {
+		Common::String pressReturn;
+	} _gameStrings;
+};
+
+} // End of namespace Adl
+
+#endif
diff --git a/engines/adl/module.mk b/engines/adl/module.mk
new file mode 100644
index 0000000000..6acd06f6de
--- /dev/null
+++ b/engines/adl/module.mk
@@ -0,0 +1,18 @@
+MODULE := engines/adl
+
+MODULE_OBJS := \
+	adl.o \
+	detection.o \
+	display.o \
+	hires1.o
+
+MODULE_DIRS += \
+	engines/adl
+
+# This module can be built as a plugin
+ifeq ($(ENABLE_ADL), DYNAMIC_PLUGIN)
+PLUGIN := 1
+endif
+
+# Include common rules
+include $(srcdir)/rules.mk