Merge remote branch 'upstream/master' into pegasus

48 files changed, 3038 insertions, 2012 deletions

diff --git a/engines/scumm/cursor.cpp b/engines/scumm/cursor.cpp
index a8adb4d5c5..6739282c9d 100644
--- a/engines/scumm/cursor.cpp
+++ b/engines/scumm/cursor.cpp
@@ -22,6 +22,9 @@
 #include "common/system.h"
 #include "common/util.h"
 #include "graphics/cursorman.h"
+#ifdef ENABLE_HE
+#include "graphics/wincursor.h"
+#endif
 #include "scumm/bomp.h"
 #include "scumm/charset.h"
 #include "scumm/he/intern_he.h"
@@ -177,12 +180,8 @@ void ScummEngine_v70he::setDefaultCursor() {
 								   0xff, 0xff, 0xff,
 								   0,    0,    0,    };
 
-	if (_bytesPerPixel == 2) {
-		for (i = 0; i < 1024; i++)
-			WRITE_UINT16(_grabbedCursor + i * 2, 5);
-	} else {
-		memset(_grabbedCursor, 5, sizeof(_grabbedCursor));
-	}
+	
+	memset(_grabbedCursor, 5, sizeof(_grabbedCursor));
 
 	_cursor.hotspotX = _cursor.hotspotY = 2;
 	src = default_he_cursor;
@@ -195,16 +194,10 @@ void ScummEngine_v70he::setDefaultCursor() {
 		for (j = 0; j < 32; j++) {
 			switch ((p & (0x3 << 14)) >> 14) {
 				case 1:
-					if (_bytesPerPixel == 2)
-						WRITE_UINT16(_grabbedCursor + 64 * i + j * 2, get16BitColor(palette[4], palette[5], palette[6]));
-					else
-						_grabbedCursor[32 * i + j] = 0xfe;
+					_grabbedCursor[32 * i + j] = 0xfe;
 					break;
 				case 2:
-					if (_bytesPerPixel == 2)
-						WRITE_UINT16(_grabbedCursor + 64 * i + j * 2, get16BitColor(palette[0], palette[1], palette[2]));
-					else
-						_grabbedCursor[32 * i + j] = 0xfd;
+					_grabbedCursor[32 * i + j] = 0xfd;
 					break;
 				default:
 					break;
@@ -216,15 +209,63 @@ void ScummEngine_v70he::setDefaultCursor() {
 		}
 	}
 
+	// Since white color position is not guaranteed
+	// we setup our own palette if supported by backend
+	CursorMan.disableCursorPalette(false);
+	CursorMan.replaceCursorPalette(palette, 0xfd, 3);
+
+	updateCursor();
+}
+
+#ifdef ENABLE_HE
+void ScummEngine_v80he::setDefaultCursor() {
+	// v80+ games use the default Windows cursor instead of the usual
+	// default HE cursor.
+	Graphics::Cursor *cursor = Graphics::makeDefaultWinCursor();
+
+	// Clear the cursor
+	if (_bytesPerPixel == 2) {
+		for (int i = 0; i < 1024; i++)
+			WRITE_UINT16(_grabbedCursor + i * 2, 5);
+	} else {
+		memset(_grabbedCursor, 5, sizeof(_grabbedCursor));
+	}
+
+	_cursor.width = cursor->getWidth();
+	_cursor.height = cursor->getHeight();
+	_cursor.hotspotX = cursor->getHotspotX();
+	_cursor.hotspotY = cursor->getHotspotY();
+
+	const byte *surface = cursor->getSurface();
+	const byte *palette = cursor->getPalette();
+
+	for (uint16 y = 0; y < _cursor.height; y++) {
+		for (uint16 x = 0; x < _cursor.width; x++) {
+			byte pixel = *surface++;
+
+			if (pixel != cursor->getKeyColor()) {
+				pixel -= cursor->getPaletteStartIndex();
+
+				if (_bytesPerPixel == 2)
+					WRITE_UINT16(_grabbedCursor + (y * _cursor.width + x) * 2, get16BitColor(palette[pixel * 3], palette[pixel * 3 + 1], palette[pixel * 3 + 2]));
+				else
+					_grabbedCursor[y * _cursor.width + x] = (pixel == 0) ? 0xfd : 0xfe;
+			}
+		}
+	}
+
 	if (_bytesPerPixel == 1) {
 		// Since white color position is not guaranteed
 		// we setup our own palette if supported by backend
 		CursorMan.disableCursorPalette(false);
-		CursorMan.replaceCursorPalette(palette, 0xfd, 3);
+		CursorMan.replaceCursorPalette(palette, 0xfd, cursor->getPaletteCount());
 	}
 
+	delete cursor;
+
 	updateCursor();
 }
+#endif
 
 void ScummEngine_v6::setCursorFromImg(uint img, uint room, uint imgindex) {
 	int w, h;
diff --git a/engines/scumm/detection.cpp b/engines/scumm/detection.cpp
index d3514645d3..037c12bdbf 100644
--- a/engines/scumm/detection.cpp
+++ b/engines/scumm/detection.cpp
@@ -33,6 +33,8 @@
 #include "common/savefile.h"
 #include "common/system.h"
 
+#include "audio/mididrv.h"
+
 #include "scumm/detection.h"
 #include "scumm/detection_tables.h"
 #include "scumm/he/intern_he.h"
@@ -145,7 +147,7 @@ Common::String ScummEngine_v70he::generateFilename(const int room) const {
 	Common::String bPattern = _filenamePattern.pattern;
 
 	// Special cases for Blue's games, which share common (b) files
-	if (_game.id == GID_BIRTHDAY && !(_game.features & GF_DEMO))
+	if (_game.id == GID_BIRTHDAYYELLOW || _game.id == GID_BIRTHDAYRED)
 		bPattern = "Blue'sBirthday";
 	else if (_game.id == GID_TREASUREHUNT)
 		bPattern = "Blue'sTreasureHunt";
diff --git a/engines/scumm/detection_tables.h b/engines/scumm/detection_tables.h
index 11901f7565..78645ea8d5 100644
--- a/engines/scumm/detection_tables.h
+++ b/engines/scumm/detection_tables.h
@@ -222,7 +222,7 @@ static const GameSettings gameVariantsTable[] = {
 
 	{"indy3", "EGA",      "ega", GID_INDY3, 3, 0, MDT_PCSPK | MDT_PCJR | MDT_CMS | MDT_ADLIB, 0, UNK, GUIO_NOSPEECH | GUIO_NOMIDI},
 	{"indy3", "No AdLib", "ega", GID_INDY3, 3, 0, MDT_PCSPK | MDT_PCJR,             0, UNK, GUIO_NOSPEECH | GUIO_NOMIDI},
-	{"indy3", "VGA",      "vga", GID_INDY3, 3, 0, MDT_PCSPK | MDT_PCJR | MDT_ADLIB, GF_OLD256 | GF_FEW_LOCALS,                  Common::kPlatformPC, GUIO_NOSPEECH | GUIO_NOMIDI},
+	{"indy3", "VGA",      "vga", GID_INDY3, 3, 0, MDT_PCSPK | MDT_PCJR | MDT_CMS | MDT_ADLIB, GF_OLD256 | GF_FEW_LOCALS,                  Common::kPlatformPC, GUIO_NOSPEECH | GUIO_NOMIDI},
 	{"indy3", "FM-TOWNS",     0, GID_INDY3, 3, 0, MDT_TOWNS,             GF_OLD256 | GF_FEW_LOCALS | GF_AUDIOTRACKS, Common::kPlatformFMTowns, GUIO_NOSPEECH | GUIO_NOMIDI | GUIO_MIDITOWNS},
 
 	{"loom", "EGA",      "ega", GID_LOOM, 3, 0, MDT_PCSPK | MDT_PCJR | MDT_CMS | MDT_ADLIB | MDT_MIDI | MDT_PREFER_MT32, 0, UNK, GUIO_NOSPEECH},
@@ -233,9 +233,9 @@ static const GameSettings gameVariantsTable[] = {
 	{"loom", "FM-TOWNS",     0, GID_LOOM, 3, 0, MDT_TOWNS,                        GF_AUDIOTRACKS | GF_OLD256, Common::kPlatformFMTowns, GUIO_NOSPEECH | GUIO_NOMIDI | GUIO_MIDITOWNS},
 	{"loom", "VGA",      "vga", GID_LOOM, 4, 0, MDT_NONE,                         GF_AUDIOTRACKS,             Common::kPlatformPC, GUIO_NOSPEECH | GUIO_NOMIDI},
 
-	{"pass", 0, 0, GID_PASS, 4, 0, MDT_PCSPK | MDT_PCJR | MDT_ADLIB, GF_16COLOR, Common::kPlatformPC, GUIO_NOSPEECH | GUIO_NOMIDI},
+	{"pass", 0, 0, GID_PASS, 4, 0, MDT_PCSPK | MDT_PCJR | MDT_CMS | MDT_ADLIB, GF_16COLOR, Common::kPlatformPC, GUIO_NOSPEECH | GUIO_NOMIDI},
 
-	{"monkey", "VGA",      "vga", GID_MONKEY_VGA, 4, 0, MDT_PCSPK | MDT_PCJR | MDT_ADLIB | MDT_MIDI | MDT_PREFER_MT32, 0, UNK, GUIO_NOSPEECH},
+	{"monkey", "VGA",      "vga", GID_MONKEY_VGA, 4, 0, MDT_PCSPK | MDT_PCJR | MDT_CMS | MDT_ADLIB | MDT_MIDI | MDT_PREFER_MT32, 0, UNK, GUIO_NOSPEECH},
 	{"monkey", "EGA",      "ega", GID_MONKEY_EGA, 4, 0, MDT_PCSPK | MDT_PCJR | MDT_CMS | MDT_ADLIB | MDT_MIDI | MDT_PREFER_MT32, GF_16COLOR,     Common::kPlatformPC, GUIO_NOSPEECH},
 	{"monkey", "No AdLib", "ega", GID_MONKEY_EGA, 4, 0, MDT_PCSPK | MDT_PCJR,                        GF_16COLOR,     Common::kPlatformAtariST, GUIO_NOSPEECH | GUIO_NOMIDI},
 	{"monkey", "Demo",     "ega", GID_MONKEY_EGA, 4, 0, MDT_PCSPK | MDT_PCJR | MDT_ADLIB,            GF_16COLOR,     Common::kPlatformPC, GUIO_NOSPEECH | GUIO_NOMIDI},
@@ -343,7 +343,9 @@ static const GameSettings gameVariantsTable[] = {
 	{"puttrace", "HE 99",   0, GID_PUTTRACE, 6, 99, MDT_NONE, GF_USE_KEY, UNK, GUIO_NOLAUNCHLOAD | GUIO_NOMIDI},
 
 	{"bluesabctime", "", 0, GID_HEGAME, 6, 98, MDT_NONE, GF_USE_KEY, UNK, GUIO_NOLAUNCHLOAD | GUIO_NOMIDI},
-	{"BluesBirthday", 0, 0, GID_BIRTHDAY, 6, 98, MDT_NONE, GF_USE_KEY, UNK, GUIO_NOLAUNCHLOAD | GUIO_NOMIDI},
+	{"BluesBirthday", "", 0, GID_HEGAME, 6, 98, MDT_NONE, GF_USE_KEY, UNK, GUIO_NOLAUNCHLOAD | GUIO_NOMIDI},
+	{"BluesBirthday", "Red", 0, GID_BIRTHDAYRED, 6, 98, MDT_NONE, GF_USE_KEY, UNK, GUIO_NOLAUNCHLOAD | GUIO_NOMIDI},
+	{"BluesBirthday", "Yellow", 0, GID_BIRTHDAYYELLOW, 6, 98, MDT_NONE, GF_USE_KEY, UNK, GUIO_NOLAUNCHLOAD | GUIO_NOMIDI},
 	{"soccer", "", 0, GID_SOCCER, 6, 98, MDT_NONE, GF_USE_KEY, UNK, GUIO_NOLAUNCHLOAD | GUIO_NOMIDI},
 
 	// Global scripts increased to 2048
diff --git a/engines/scumm/dialogs.cpp b/engines/scumm/dialogs.cpp
index f7f0c7d7ec..74a92f2204 100644
--- a/engines/scumm/dialogs.cpp
+++ b/engines/scumm/dialogs.cpp
@@ -23,6 +23,7 @@
 #include "common/savefile.h"
 #include "common/system.h"
 #include "common/events.h"
+#include "common/localization.h"
 #include "common/translation.h"
 
 #include "graphics/scaler.h"
@@ -171,29 +172,33 @@ static const ResString string_map_table_v6[] = {
 };
 
 static const ResString string_map_table_v345[] = {
-	{1, "Insert Disk %c and Press Button to Continue."},
-	{2, "Unable to Find %s, (%c%d) Press Button."},
-	{3, "Error reading disk %c, (%c%d) Press Button."},
-	{4, "Game Paused.  Press SPACE to Continue."},
-	{5, "Are you sure you want to restart?  (Y/N)"},
-	{6, "Are you sure you want to quit?  (Y/N)"},
+	{1, _s("Insert Disk %c and Press Button to Continue.")},
+	{2, _s("Unable to Find %s, (%c%d) Press Button.")},
+	{3, _s("Error reading disk %c, (%c%d) Press Button.")},
+	{4, _s("Game Paused.  Press SPACE to Continue.")},
+	// I18N: You may specify 'Yes' symbol at the end of the line, like this:
+	// "Moechten Sie wirklich neu starten?  (J/N)J"
+	// Will react to J as 'Yes'
+	{5, _s("Are you sure you want to restart?  (Y/N)")},
+	// I18N: you may specify 'Yes' symbol at the end of the line. See previous comment 
+	{6, _s("Are you sure you want to quit?  (Y/N)")},
 
 	// Added in SCUMM4
-	{7, "Save"},
-	{8, "Load"},
-	{9, "Play"},
-	{10, "Cancel"},
-	{11, "Quit"},
-	{12, "OK"},
-	{13, "Insert save/load game disk"},
-	{14, "You must enter a name"},
-	{15, "The game was NOT saved (disk full?)"},
-	{16, "The game was NOT loaded"},
-	{17, "Saving '%s'"},
-	{18, "Loading '%s'"},
-	{19, "Name your SAVE game"},
-	{20, "Select a game to LOAD"},
-	{28, "Game title"}
+	{7, _s("Save")},
+	{8, _s("Load")},
+	{9, _s("Play")},
+	{10, _s("Cancel")},
+	{11, _s("Quit")},
+	{12, _s("OK")},
+	{13, _s("Insert save/load game disk")},
+	{14, _s("You must enter a name")},
+	{15, _s("The game was NOT saved (disk full?)")},
+	{16, _s("The game was NOT loaded")},
+	{17, _s("Saving '%s'")},
+	{18, _s("Loading '%s'")},
+	{19, _s("Name your SAVE game")},
+	{20, _s("Select a game to LOAD")},
+	{28, _s("Game title)")}
 };
 
 #pragma mark -
@@ -278,7 +283,9 @@ HelpDialog::HelpDialog(const GameSettings &game)
 
 	_numPages = ScummHelp::numPages(_game.id);
 
+	// I18N: Previous page button
 	_prevButton = new GUI::ButtonWidget(this, "ScummHelp.Prev", _("~P~revious"), 0, kPrevCmd);
+	// I18N: Next page button
 	_nextButton = new GUI::ButtonWidget(this, "ScummHelp.Next", _("~N~ext"), 0, kNextCmd);
 	new GUI::ButtonWidget(this, "ScummHelp.Close", _("~C~lose"), 0, GUI::kCloseCmd);
 	_prevButton->clearFlags(WIDGET_ENABLED);
@@ -429,7 +436,7 @@ const Common::String InfoDialog::queryResString(int stringno) {
 	else if (_vm->_game.version >= 3)
 		result = _vm->getStringAddress(string_map_table_v345[stringno - 1].num);
 	else
-		return string_map_table_v345[stringno - 1].string;
+		return _(string_map_table_v345[stringno - 1].string);
 
 	if (result && *result == '/') {
 		_vm->translateText(result, buf);
@@ -437,7 +444,7 @@ const Common::String InfoDialog::queryResString(int stringno) {
 	}
 
 	if (!result || *result == '\0') {	// Gracelessly degrade to english :)
-		return string_map_table_v345[stringno - 1].string;
+		return _(string_map_table_v345[stringno - 1].string);
 	}
 
 	// Convert to a proper string (take care of FF codes)
@@ -482,10 +489,14 @@ ConfirmDialog::ConfirmDialog(ScummEngine *scumm, int res)
 }
 
 void ConfirmDialog::handleKeyDown(Common::KeyState state) {
-	if (state.keycode == Common::KEYCODE_n || state.ascii == _noKey) {
+	Common::KeyCode keyYes, keyNo;
+
+	Common::getLanguageYesNo(keyYes, keyNo);
+
+	if (state.keycode == Common::KEYCODE_n || state.ascii == _noKey || state.ascii == keyNo) {
 		setResult(0);
 		close();
-	} else if (state.keycode == Common::KEYCODE_y || state.ascii == _yesKey) {
+	} else if (state.keycode == Common::KEYCODE_y || state.ascii == _yesKey || state.ascii == keyYes) {
 		setResult(1);
 		close();
 	} else
@@ -583,9 +594,9 @@ void SubtitleSettingsDialog::open() {
 
 void SubtitleSettingsDialog::cycleValue() {
 	static const char* subtitleDesc[] = {
-		"Speech Only",
-		"Speech and Subtitles",
-		"Subtitles Only"
+		_s("Speech Only"),
+		_s("Speech and Subtitles"),
+		_s("Subtitles Only")
 	};
 
 	_value += 1;
@@ -593,9 +604,9 @@ void SubtitleSettingsDialog::cycleValue() {
 		_value = 0;
 
 	if (_value == 1 && g_system->getOverlayWidth() <= 320)
-		setInfoText("Speech & Subs");
+		setInfoText(_sc("Speech & Subs", "lowres"));
 	else
-		setInfoText(subtitleDesc[_value]);
+		setInfoText(_(subtitleDesc[_value]));
 
 	_timer = g_system->getMillis() + 1500;
 }
diff --git a/engines/scumm/gfx.cpp b/engines/scumm/gfx.cpp
index f22547f193..8a32b963cd 100644
--- a/engines/scumm/gfx.cpp
+++ b/engines/scumm/gfx.cpp
@@ -4111,4 +4111,3 @@ void ScummEngine::unkScreenEffect6() {
 }
 
 } // End of namespace Scumm
-
diff --git a/engines/scumm/he/intern_he.h b/engines/scumm/he/intern_he.h
index c49217b650..f4df6571fa 100644
--- a/engines/scumm/he/intern_he.h
+++ b/engines/scumm/he/intern_he.h
@@ -383,6 +383,8 @@ protected:
 	void drawLine(int x1, int y1, int x, int unk1, int unk2, int type, int id);
 	void drawPixel(int x, int y, int flags);
 
+	virtual void setDefaultCursor();
+
 	/* HE version 80 script opcodes */
 	void o80_createSound();
 	void o80_getFileSize();
diff --git a/engines/scumm/he/logic/baseball2001.cpp b/engines/scumm/he/logic/baseball2001.cpp
new file mode 100644
index 0000000000..342423fd79
--- /dev/null
+++ b/engines/scumm/he/logic/baseball2001.cpp
@@ -0,0 +1,63 @@
+/* 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 "scumm/he/intern_he.h"
+#include "scumm/he/logic_he.h"
+
+namespace Scumm {
+
+/**
+ * Logic code for:
+ *     Backyard Baseball 2001
+ */
+class LogicHEbaseball2001 : public LogicHE {
+public:
+	LogicHEbaseball2001(ScummEngine_v90he *vm) : LogicHE(vm) {}
+
+	int versionID();
+	int32 dispatch(int op, int numArgs, int32 *args);
+};
+
+int LogicHEbaseball2001::versionID() {
+	return 1;
+}
+
+int32 LogicHEbaseball2001::dispatch(int op, int numArgs, int32 *args) {
+	int res = 0;
+
+	switch (op) {
+	case 3001:
+		// Check network status
+		break;
+
+	default:
+		LogicHE::dispatch(op, numArgs, args);
+	}
+
+	return res;
+}
+
+LogicHE *makeLogicHEbaseball2001(ScummEngine_v90he *vm) {
+	return new LogicHEbaseball2001(vm);
+}
+
+} // End of namespace Scumm
diff --git a/engines/scumm/he/logic/basketball.cpp b/engines/scumm/he/logic/basketball.cpp
new file mode 100644
index 0000000000..8352aa4357
--- /dev/null
+++ b/engines/scumm/he/logic/basketball.cpp
@@ -0,0 +1,230 @@
+/* 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 "scumm/he/intern_he.h"
+#include "scumm/he/logic_he.h"
+
+namespace Scumm {
+
+/**
+ * Logic code for:
+ *     Backyard Basketball
+ */
+class LogicHEbasketball : public LogicHE {
+public:
+	LogicHEbasketball(ScummEngine_v90he *vm) : LogicHE(vm) {}
+
+	int versionID();
+	int32 dispatch(int op, int numArgs, int32 *args);
+
+private:
+	int op_1012();
+	int op_1050(int32 *args);
+	int op_1053();
+
+	// op_1050 loads court object data
+	enum CourtObjectType {
+		kObjectTypeBackboard = 1,
+		kObjectTypeRim = 2,
+		kObjectTypeOther = 3,
+		kObjectTypeFloor = 4
+	};
+
+	struct CourtObject {
+		Common::String name;
+		CourtObjectType type;
+		uint32 data[10];
+	};
+
+	Common::Array<CourtObject> _courtObjects;
+	uint32 _backboardObjectLeft, _backboardObjectRight;
+};
+
+int LogicHEbasketball::versionID() {
+	return 1;
+}
+
+int32 LogicHEbasketball::dispatch(int op, int numArgs, int32 *args) {
+	int res = 0;
+
+	switch (op) {
+	case 1001:
+		break;
+
+	case 1006:
+		break;
+
+	case 1011:
+		break;
+
+	case 1012:
+		res = op_1012();
+		break;
+
+	case 1035:
+		break;
+
+	case 1050:
+		res = op_1050(args);
+		break;
+
+	case 1051:
+		break;
+
+	case 1052:
+		break;
+
+	case 1053:
+		res = op_1053();
+		break;
+
+	case 1056:
+		break;
+
+	case 1057:
+		break;
+
+	case 1058:
+		break;
+
+	case 1060:
+		break;
+
+	case 1064:
+		break;
+
+	case 1067:
+		break;
+
+	case 1073:
+		break;
+
+	case 1075:
+		break;
+
+	case 1076:
+		break;
+
+	case 1080:
+		break;
+
+	case 1081:
+		break;
+
+	case 1090:
+		break;
+
+	case 1091:
+		break;
+
+	case 1513:
+		break;
+
+	default:
+		LogicHE::dispatch(op, numArgs, args);
+	}
+
+	return res;
+}
+
+int LogicHEbasketball::op_1012() {
+	writeScummVar(108, 12000);
+	writeScummVar(109, 8000);
+	writeScummVar(110, 760);
+	writeScummVar(111, 4000);
+	writeScummVar(112, 1600);
+	return 1;
+}
+
+int LogicHEbasketball::op_1050(int32 *args) {
+	// This function loads the court data
+	static const char *courtNames[] = {
+		"Dobbaguchi", "Jocindas", "SandyFlats", "Queens",
+		"Park", "Scheffler", "Polk", "McMillan",
+		"CrownHill", "Memorial", "TechState", "Garden",
+		"Moon", "Barn"
+	};
+
+	Common::String courtFileName = Common::String::format("data/courts/%s.cof", courtNames[args[0] - 1]);
+
+	Common::File file;
+	if (!file.open(courtFileName))
+		error("Could not open file '%s'", courtFileName.c_str());
+
+	debug(0, "Loading court data from '%s'", courtFileName.c_str());
+
+	// First, read in the header
+	file.readUint32LE(); // Header size (?)
+
+	char version[6];
+	file.read(version, 5);
+	version[5] = 0;
+
+	if (strcmp(version, "01.05"))
+		error("Invalid court version field: %s", version);
+
+	uint32 objectCount = file.readUint32LE();
+
+	for (uint32 i = 0; i < objectCount; i++) {
+		char nameBuf[100];
+		memset(nameBuf, 0, sizeof(nameBuf));
+
+		uint32 nameLength = file.readUint32LE();
+		assert(nameLength < sizeof(nameBuf) - 1);
+		file.read(nameBuf, nameLength);
+
+		CourtObject object;
+		object.name = nameBuf;
+		object.type = (CourtObjectType)file.readUint32LE();
+		for (uint32 j = 0; j < 10; j++)
+			object.data[j] = file.readUint32LE();
+
+		debug(1, "Found court object '%s' - Type %d", nameBuf, object.type);
+
+		// Store backboard object indices for later
+		if (object.type == kObjectTypeBackboard) {
+			if (object.data[7] + object.data[4] / 2 >= 6000)
+				_backboardObjectRight = i;
+			else
+				_backboardObjectLeft = i;
+		}
+
+		_courtObjects.push_back(object);
+	}
+
+	// TODO: Some other variables are initialized with constants here
+
+	return 1;
+}
+
+int LogicHEbasketball::op_1053() {
+	_courtObjects.clear();
+	// TODO: This also calls op_1065 with one argument (5)
+
+	return 1;
+}
+
+LogicHE *makeLogicHEbasketball(ScummEngine_v90he *vm) {
+	return new LogicHEbasketball(vm);
+}
+
+} // End of namespace Scumm
diff --git a/engines/scumm/he/logic/football.cpp b/engines/scumm/he/logic/football.cpp
new file mode 100644
index 0000000000..f86f97eaf7
--- /dev/null
+++ b/engines/scumm/he/logic/football.cpp
@@ -0,0 +1,288 @@
+/* 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 "scumm/he/intern_he.h"
+#include "scumm/he/logic_he.h"
+
+namespace Scumm {
+
+/**
+ * Logic code for:
+ *     Backyard Football
+ *     Backyard Football 2002
+ */
+class LogicHEfootball : public LogicHE {
+public:
+	LogicHEfootball(ScummEngine_v90he *vm) : LogicHE(vm) {}
+
+	int versionID();
+	int32 dispatch(int op, int numArgs, int32 *args);
+
+private:
+	int op_1004(int32 *args);
+	int op_1006(int32 *args);
+	int op_1007(int32 *args);
+	int op_1010(int32 *args);
+	int op_1022(int32 *args);
+	int op_1023(int32 *args);
+	int op_1024(int32 *args);
+};
+
+int LogicHEfootball::versionID() {
+	return 1;
+}
+
+int32 LogicHEfootball::dispatch(int op, int numArgs, int32 *args) {
+	int res = 0;
+
+	switch (op) {
+	case 1004:
+		res = op_1004(args);
+		break;
+
+	case 1006:
+		res = op_1006(args);
+		break;
+
+	case 1007:
+		res = op_1007(args);
+		break;
+
+	case 1010:
+		res = op_1010(args);
+		break;
+
+	case 1022:
+		res = op_1022(args);
+		break;
+
+	case 1023:
+		res = op_1023(args);
+		break;
+
+	case 1024:
+		res = op_1024(args);
+		break;
+
+	case 8221968:
+		// Someone had a fun and used his birthday as opcode number
+		res = getFromArray(args[0], args[1], args[2]);
+		break;
+
+	case 1492: case 1493: case 1494: case 1495: case 1496:
+	case 1497: case 1498: case 1499: case 1500: case 1501:
+	case 1502: case 1503: case 1504: case 1505: case 1506:
+	case 1507: case 1508: case 1509: case 1510: case 1511:
+	case 1512: case 1513: case 1514: case 1555:
+		// DirectPlay-related
+		// 1513: initialize
+		// 1555: set fake lag
+		break;
+
+	case 2200: case 2201: case 2202: case 2203: case 2204:
+	case 2205: case 2206: case 2207: case 2208: case 2209:
+	case 2210: case 2211: case 2212: case 2213: case 2214:
+	case 2215: case 2216: case 2217: case 2218: case 2219:
+	case 2220: case 2221: case 2222: case 2223: case 2224:
+	case 2225: case 2226: case 2227: case 2228:
+		// Boneyards-related
+		break;
+
+	case 3000: case 3001: case 3002: case 3003: case 3004:
+		// Internet-related
+		// 3000: check for updates
+		// 3001: check network status
+		// 3002: autoupdate
+		// 3003: close connection
+		break;
+
+	default:
+		LogicHE::dispatch(op, numArgs, args);
+		warning("Tell sev how to reproduce it (%d)", op);
+	}
+
+	return res;
+}
+
+int LogicHEfootball::op_1004(int32 *args) {
+	// Identical to LogicHEsoccer::op_1004
+	double res, a2, a4, a5;
+
+	a5 = ((double)args[4] - (double)args[1]) / ((double)args[5] - (double)args[2]);
+	a4 = ((double)args[3] - (double)args[0]) / ((double)args[5] - (double)args[2]);
+	a2 = (double)args[2] - (double)args[0] * a4 - args[1] * a5;
+
+	res = (double)args[6] * a4 + (double)args[7] * a5 + a2;
+	writeScummVar(108, (int32)res);
+
+	writeScummVar(109, (int32)a2);
+	writeScummVar(110, (int32)a5);
+	writeScummVar(111, (int32)a4);
+
+	return 1;
+}
+
+int LogicHEfootball::op_1006(int32 *args) {
+	// This seems to be more or less the inverse of op_1010
+	const double a1 = args[1];
+	double res;
+
+	// 2.9411764e-4 = 1/3400
+	// 5.3050399e-2 = 1/18.85 = 20/377
+	// 1.1764706e-2 = 1/85 = 40/3400
+	// 1.2360656e-1 = 377/3050
+	res = (1.0 - a1 * 2.9411764e-4 * 5.3050399e-2) * 1.2360656e-1 * args[0] +
+		a1 * 1.1764706e-2 + 46;
+
+	// Shortened / optimized version of that formula:
+	// res = (377.0 - a1 / 170.0) / 3050.0 * args[0] + a1 / 85.0 + 46;
+
+	writeScummVar(108, (int32)res);
+
+	// 1.2360656e-1 = 377/3050
+	// 1.1588235e-1 = 197/1700 = 394/3400
+	res = 640.0 - args[2] * 1.2360656e-1 - a1 * 1.1588235e-1 - 26;
+
+	writeScummVar(109, (int32)res);
+
+	return 1;
+}
+
+int LogicHEfootball::op_1007(int32 *args) {
+	double res, temp;
+
+	temp = (double)args[1] * 0.32;
+
+	if (temp > 304.0)
+		res = -args[2] * 0.142;
+	else
+		res = args[2] * 0.142;
+
+	res += temp;
+
+	writeScummVar(108, (int32)res);
+
+	res = (1000.0 - args[2]) * 0.48;
+
+	writeScummVar(109, (int32)res);
+
+	return 1;
+}
+
+int LogicHEfootball::op_1010(int32 *args) {
+	// This seems to be more or less the inverse of op_1006
+	double a1 = (640.0 - (double)args[1] - 26.0) / 1.1588235e-1;
+
+	// 2.9411764e-4 = 1/3400
+	// 5.3050399e-2 = 1/18.85 = 20/377
+	// 1.1764706e-2 = 1/85 = 40/3400
+	// 1.2360656e-1 = 377/3050
+	double a0 = ((double)args[0] - 46 - a1 * 1.1764706e-2) /
+		((1.0 - a1 * 2.9411764e-4 * 5.3050399e-2) * 1.2360656e-1);
+
+	writeScummVar(108, (int32)a0);
+	writeScummVar(109, (int32)a1);
+
+	return 1;
+}
+
+int LogicHEfootball::op_1022(int32 *args) {
+	double res;
+	double var10 = args[4] - args[1];
+	double var8 = args[5] - args[2];
+	double var6 = args[3] - args[0];
+
+	res = sqrt(var8 * var8 + var6 * var6 + var10 * var10);
+
+	if (res >= (double)args[6]) {
+		var8 = (double)args[6] * var8 / res;
+		var10 = (double)args[6] * var10 / res;
+		res = (double)args[6] * var6 / res;
+	}
+
+	writeScummVar(108, (int32)res);
+	writeScummVar(109, (int32)var10);
+	writeScummVar(110, (int32)var8);
+
+	return 1;
+}
+
+int LogicHEfootball::op_1023(int32 *args) {
+	double var10, var18, var20, var28, var30, var30_;
+	double argf[7];
+
+	for (int i = 0; i < 7; i++)
+		argf[i] = args[i];
+
+	var10 = (argf[3] - argf[1]) / (argf[2] - argf[0]);
+	var28 = var10 * var10 + 1;
+	var20 = argf[0] * var10;
+	var18 = (argf[5] + argf[1] + var20) * argf[4] * var10 * 2 +
+		argf[6] * argf[6] * var28 + argf[4] * argf[4] -
+		argf[0] * argf[0] * var10 * var10 -
+		argf[5] * argf[0] * var10 * 2 -
+		argf[5] * argf[1] * 2 -
+		argf[1] * argf[1] - argf[5] * argf[5];
+
+	if (var18 >= 0) {
+		var18 = sqrt(var18);
+
+		var30_ = argf[4] + argf[5] * var10 + argf[1] * var10 + argf[0] * var10 * var10;
+		var30 = (var30_ - var18) / var28;
+		var18 = (var30_ + var18) / var28;
+
+		if ((argf[0] - var30 < 0) && (argf[0] - var18 < 0)) {
+			var30_ = var30;
+			var30 = var18;
+			var18 = var30_;
+		}
+		var28 = var18 * var10 - var20 - argf[1];
+		var20 = var30 * var10 - var20 - argf[1];
+	} else {
+		var18 = 0;
+		var20 = 0;
+		var28 = 0;
+		var30 = 0;
+	}
+
+	writeScummVar(108, (int32)var18);
+	writeScummVar(109, (int32)var28);
+	writeScummVar(110, (int32)var30);
+	writeScummVar(111, (int32)var20);
+
+	return 1;
+}
+
+int LogicHEfootball::op_1024(int32 *args) {
+	writeScummVar(108, 0);
+	writeScummVar(109, 0);
+	writeScummVar(110, 0);
+	writeScummVar(111, 0);
+
+	return 1;
+}
+
+LogicHE *makeLogicHEfootball(ScummEngine_v90he *vm) {
+	return new LogicHEfootball(vm);
+}
+
+} // End of namespace Scumm
diff --git a/engines/scumm/he/logic/funshop.cpp b/engines/scumm/he/logic/funshop.cpp
new file mode 100644
index 0000000000..8993fedad2
--- /dev/null
+++ b/engines/scumm/he/logic/funshop.cpp
@@ -0,0 +1,216 @@
+/* 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 "scumm/he/intern_he.h"
+#include "scumm/he/logic_he.h"
+
+namespace Scumm {
+
+/**
+ * Logic code for:
+ *     Freddi Fish's One-Stop Fun Shop
+ *     Pajama Sam's One-Stop Fun Shop
+ *     Putt-Putt's One-Stop Fun Shop
+ */
+class LogicHEfunshop : public LogicHE {
+public:
+	LogicHEfunshop(ScummEngine_v90he *vm) : LogicHE(vm) {}
+
+	int versionID();
+	int32 dispatch(int op, int numArgs, int32 *args);
+
+private:
+	void op_1004(int32 *args);
+	void op_1005(int32 *args);
+	int checkShape(int32 data0, int32 data1, int32 data4, int32 data5, int32 data2, int32 data3, int32 data6, int32 data7, int32 *x, int32 *y);
+};
+
+int LogicHEfunshop::versionID() {
+	return 1;
+}
+
+int32 LogicHEfunshop::dispatch(int op, int numArgs, int32 *args) {
+	switch (op) {
+	case 1004:
+		op_1004(args);
+		break;
+
+	case 1005:
+		op_1005(args);
+		break;
+
+	default:
+		break;
+	}
+
+	return 0;
+}
+
+void LogicHEfunshop::op_1004(int32 *args) {
+	double data[8], at, sq;
+	int32 x, y;
+	int i=0;
+
+	for (i = 0; i <= 6; i += 2) {
+		data[i] = getFromArray(args[0], 0, 519 + i);
+		data[i + 1] = getFromArray(args[0], 0, 519 + i + 1);
+	}
+	int s = checkShape((int32)data[0], (int32)data[1], (int32)data[4], (int32)data[5],
+		(int32)data[2], (int32)data[3], (int32)data[6], (int32)data[7], &x, &y);
+
+	if (s != 1) {
+		error("LogicHEfunshop::op_1004: Your shape has defied the laws of physics");
+		return;
+	}
+
+	for (i = 0; i <= 6; i += 2) {
+		data[i] -= (double)x;
+		data[i + 1] -= (double)y;
+	}
+
+	double a1 = (double)args[1] * DEG2RAD;
+
+	for (i = 0; i <= 6; i += 2) {
+		at = atan2(data[i + 1], data[i]);
+		sq = sqrt(data[i + 1] * data[i + 1] + data[i] * data[i]);
+
+		if (at <= 0)
+			at += 2 * M_PI;
+
+		data[i] = cos(at + a1) * sq;
+		data[i + 1] = sin(at + a1) * sq;
+	}
+
+	double minx = data[0];
+	double miny = data[1];
+
+	for (i = 0; i <= 6; i += 2) {
+		if (data[i] < minx)
+			minx = data[i];
+		if (data[i + 1] < miny)
+			miny = data[i + 1];
+	}
+
+	for (i = 0; i <= 6; i += 2) {
+		data[i] -= minx;
+		data[i + 1] -= miny;
+
+		putInArray(args[0], 0, 519 + i, scummRound(data[i]));
+		putInArray(args[0], 0, 519 + i + 1, scummRound(data[i + 1]));
+	}
+}
+
+void LogicHEfunshop::op_1005(int32 *args) {
+	double data[8];
+	double args1, args2;
+	int i;
+	for (i = 520; i <= 526; i += 2) {
+		data[i - 520] = getFromArray(args[0], 0, i - 1);
+		data[i - 520 + 1] = getFromArray(args[0], 0, i);
+	}
+
+	args1 = (double)args[1] * 0.01 + 1;
+	args2 = (double)args[2] * 0.01 + 1;
+
+	for (i = 0; i < 4; i++) {
+		data[2 * i] *= args1;
+		data[2 * i + 1] *= args2;
+	}
+
+	for (i = 520; i <= 526; i += 2) {
+		putInArray(args[0], 0, i - 1, scummRound(data[i - 520]));
+		putInArray(args[0], 0, i, scummRound(data[i - 520 + 1]));
+	}
+}
+
+int LogicHEfunshop::checkShape(int32 data0, int32 data1, int32 data4, int32 data5, int32 data2, int32 data3, int32 data6, int32 data7, int32 *x, int32 *y) {
+	int32 diff5_1, diff0_4, diff7_3, diff2_6;
+	int32 diff1, diff2;
+	int32 delta, delta2;
+	int32 sum1, sum2;
+
+	diff0_4 = data0 - data4;
+	diff5_1 = data5 - data1;
+	diff1 = data1 * data4 - data0 * data5;
+	sum1 = diff0_4 * data3 + diff1 + diff5_1 * data2;
+	sum2 = diff0_4 * data7 + diff1 + diff5_1 * data6;
+
+	if (sum1 != 0 && sum2 != 0) {
+		sum2 ^= sum1;
+
+		if (sum2 >= 0)
+			return 0;
+	}
+
+	diff2_6 = data2 - data6;
+	diff7_3 = data7 - data3;
+	diff2 = data3 * data6 - data2 * data7;
+	sum1 = diff2_6 * data1 + diff2 + diff7_3 * data0;
+	sum2 = diff2_6 * data5 + diff2 + diff7_3 * data4;
+
+	if (sum1 != 0 && sum2 != 0) {
+		sum2 ^= sum1;
+
+		if (sum2 >= 0)
+			return 0;
+	}
+
+	delta = diff2_6 * diff5_1 - diff0_4 * diff7_3;
+
+	if (delta == 0) {
+		return 2;
+	}
+
+	if (delta < 0) {
+		data7 = -((delta + 1) >> 1);
+	} else {
+		data7 = delta >> 1;
+	}
+
+	delta2 = diff2 * diff0_4 - diff1 * diff2_6;
+
+	if (delta2 < 0) {
+		delta2 -= data7;
+	} else {
+		delta2 += data7;
+	}
+
+	*x = delta2 / delta;
+
+	delta2 = diff1 * diff7_3 - diff2 * diff5_1;
+
+	if (delta2 < 0) {
+		delta2 -= data7;
+	} else {
+		delta2 += data7;
+	}
+
+	*y = delta2 / delta;
+
+	return 1;
+}
+
+LogicHE *makeLogicHEfunshop(ScummEngine_v90he *vm) {
+	return new LogicHEfunshop(vm);
+}
+
+} // End of namespace Scumm
diff --git a/engines/scumm/he/logic/moonbase.cpp b/engines/scumm/he/logic/moonbase.cpp
new file mode 100644
index 0000000000..fac2ea27ff
--- /dev/null
+++ b/engines/scumm/he/logic/moonbase.cpp
@@ -0,0 +1,50 @@
+/* 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 "scumm/he/intern_he.h"
+#include "scumm/he/logic_he.h"
+
+namespace Scumm {
+
+/**
+ * Logic code for:
+ *     Moonbase Commander
+ */
+class LogicHEmoonbase : public LogicHE {
+public:
+	LogicHEmoonbase(ScummEngine_v90he *vm) : LogicHE(vm) {}
+
+	int versionID();
+};
+
+int LogicHEmoonbase::versionID() {
+	if (_vm->_game.features & GF_DEMO)
+		return -100;
+	else
+		return 100;
+}
+
+LogicHE *makeLogicHEmoonbase(ScummEngine_v90he *vm) {
+	return new LogicHEmoonbase(vm);
+}
+
+} // End of namespace Scumm
diff --git a/engines/scumm/he/logic/puttrace.cpp b/engines/scumm/he/logic/puttrace.cpp
new file mode 100644
index 0000000000..ea4397cd97
--- /dev/null
+++ b/engines/scumm/he/logic/puttrace.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 "scumm/he/intern_he.h"
+#include "scumm/he/logic_he.h"
+
+namespace Scumm {
+
+/**
+ * Logic code for:
+ *     Putt-Putt Enters the Race
+ */
+class LogicHErace : public LogicHE {
+private:
+	float *_userData;
+	double *_userDataD;
+public:
+	LogicHErace(ScummEngine_v90he *vm);
+	~LogicHErace();
+
+	int versionID();
+	int32 dispatch(int op, int numArgs, int32 *args);
+
+private:
+	int32 op_1003(int32 *args);
+	int32 op_1004(int32 *args);
+	int32 op_1100(int32 *args);
+	int32 op_1101(int32 *args);
+	int32 op_1102(int32 *args);
+	int32 op_1103(int32 *args);
+	int32 op_1110();
+	int32 op_1120(int32 *args);
+	int32 op_1130(int32 *args);
+	int32 op_1140(int32 *args);
+
+	void op_sub1(float arg);
+	void op_sub2(float arg);
+	void op_sub3(float arg);
+};
+
+LogicHErace::LogicHErace(ScummEngine_v90he *vm) : LogicHE(vm) {
+	// Originally it used 0x930 and stored both floats and doubles inside
+	_userData = (float *)calloc(550, sizeof(float));
+	_userDataD = (double *)calloc(30, sizeof(double));
+
+	// FIXME: of the 550 entries in _userData, only 516 till 532 are used
+	// FIXME: similarly, in _userDataD only 9 till 17 are used for computations
+	//       (some of the other entries are also set, but never read, hence useless).
+}
+
+LogicHErace::~LogicHErace() {
+	free(_userData);
+	free(_userDataD);
+}
+
+int LogicHErace::versionID() {
+	return 1;
+}
+
+int32 LogicHErace::dispatch(int op, int numArgs, int32 *args) {
+	int32 res;
+
+	switch (op) {
+	case 1003:
+		res = op_1003(args);
+		break;
+
+	case 1004:
+		res = op_1004(args);
+		break;
+
+	case 1100:
+		res = op_1100(args);
+		break;
+
+	case 1101:
+		res = op_1101(args);
+		break;
+
+	case 1102:
+		res = op_1102(args);
+		break;
+
+	case 1103:
+		res = op_1103(args);
+		break;
+
+	case 1110:
+		res = op_1110();
+		break;
+
+	case 1120:
+		res = op_1120(args);
+		break;
+
+	case 1130:
+		res = op_1130(args);
+		break;
+
+	case 1140:
+		res = op_1140(args);
+		break;
+
+	default:
+		res = 0;
+		break;
+
+	}
+
+	return res;
+}
+
+#define RAD2DEG (180 / M_PI)
+#define DEG2RAD (M_PI / 180)
+
+int32 LogicHErace::op_1003(int32 *args) {
+	int value = args[2] ? args[2] : 1;
+
+	writeScummVar(108, (int32)(atan2((double)args[0], (double)args[1]) * RAD2DEG * value));
+
+	return 1;
+}
+
+int32 LogicHErace::op_1004(int32 *args) {
+	int value = args[1] ? args[1] : 1;
+
+	writeScummVar(108, (int32)(sqrt((float)args[0]) * value));
+
+	return 1;
+}
+
+int32 LogicHErace::op_1100(int32 *args) {
+	// _userData 516,517,518 describe a 3D translation?
+	_userData[516] = (float)args[0] / args[10];
+	_userData[517] = (float)args[1] / args[10];
+	_userData[518] = (float)args[2] / args[10];
+
+	// _userData 519,520,521 describe rotation angles around the x,y,z axes?
+	_userData[519] = (float)args[3] / args[10];
+	_userData[520] = (float)args[4] / args[10];
+	_userData[521] = (float)args[5] / args[10];
+
+	op_sub1(_userData[520]);
+	op_sub2(_userData[521]);
+
+	// _userData[532] seems to be some kind of global scale factor
+	_userData[532] = (float)args[10];
+
+	_userData[524] = (float)args[8];	// not used
+	_userData[525] = (float)args[9];	// not used
+	_userData[522] = (float)args[6] / args[10];	// not used
+	_userData[523] = (float)args[7] / args[10];	// only used to compute 528 and 529
+
+	// The following two are some kind of scale factors
+	_userData[526] = (float)args[6] / args[8] / args[10];
+	_userData[527] = (float)args[7] / args[9] / args[10];
+
+	// Set var 108 and 109 -- the value set here corresponds to the values
+	// set by op_1110!
+	writeScummVar(108, (int32)((float)args[6] / args[8] * args[10]));
+	writeScummVar(109, (int32)((float)args[7] / args[9] * args[10]));
+
+	_userData[528] = (float)(_userData[519] - _userData[523] * 0.5);
+	_userData[529] = (float)(_userData[519] + _userData[523] * 0.5);
+
+	writeScummVar(110, (int32)(_userData[528] * args[10]));
+	writeScummVar(111, (int32)(_userData[529] * args[10]));
+
+	// 530 and 531 are only used to set vars 112 and 113, so no need
+	// to store them permanently
+	_userData[530] = (float)(_userData[517] / tan(_userData[529] * DEG2RAD));
+	_userData[531] = (float)(_userData[517] / tan(_userData[528] * DEG2RAD));
+
+	writeScummVar(112, (int32)(_userData[530] * args[10]));
+	writeScummVar(113, (int32)(_userData[531] * args[10]));
+
+	return 1;
+}
+
+int32 LogicHErace::op_1101(int32 *args) {
+	// Update rotation params?
+	int32 retval;
+	float temp;
+
+	temp = args[0] / _userData[532];
+	if (_userData[519] != temp) {
+		_userData[519] = temp;
+		op_sub3(temp);
+		retval = 1;
+	} else {
+		retval = (int32)temp;
+	}
+
+	temp = args[1] / _userData[532];
+	if (_userData[520] != temp) {
+		_userData[520] = temp;
+		op_sub1(temp);
+		retval = 1;
+	}
+
+	temp = args[2] / _userData[532];
+	if (_userData[521] != temp) {
+		_userData[521] = temp;
+		op_sub2(temp);
+		retval = 1;
+	}
+
+	return retval;
+}
+
+int32 LogicHErace::op_1102(int32 *args) {
+	// Update translation params?
+	int32 retval;
+	float temp;
+
+	temp = args[0] / _userData[532];
+	if (_userData[516] != temp) {
+		_userData[516] = temp;
+		retval = 1;
+	} else {
+		retval = (int32)_userData[532];
+	}
+
+	temp = args[1] / _userData[532];
+	if (_userData[517] != temp) {
+		_userData[517] = temp;
+		retval = 1;
+	}
+
+	temp = args[2] / _userData[532];
+	if (_userData[518] != temp) {
+		_userData[518] = temp;
+		retval = 1;
+	}
+
+	return retval;
+}
+
+int32 LogicHErace::op_1103(int32 *args) {
+	double angle = args[0] / args[1] * DEG2RAD;
+
+	writeScummVar(108, (int32)(sin(angle) * args[2]));
+	writeScummVar(109, (int32)(cos(angle) * args[2]));
+
+	return 1;
+}
+
+int32 LogicHErace::op_1110() {
+	writeScummVar(108, (int32)(_userData[526] * _userData[532] * _userData[532]));
+	writeScummVar(109, (int32)(_userData[527] * _userData[532] * _userData[532]));
+	writeScummVar(110, (int32)(_userData[532]));
+
+	return 1;
+}
+
+int32 LogicHErace::op_1120(int32 *args) {
+	double a0, a1, a2;
+	double b0, b1, b2;
+	double res1, res2;
+
+	a0 = args[0] / _userData[532] - _userData[516];
+	a1 = args[1] / _userData[532] - _userData[517];
+	a2 = args[2] / _userData[532] - _userData[518];
+
+	// Perform matrix multiplication (multiplying by a rotation matrix)
+	b2 = a2 * _userDataD[17] + a1 * _userDataD[14] + a0 * _userDataD[11];
+	b1 = a2 * _userDataD[16] + a1 * _userDataD[13] + a0 * _userDataD[10];
+	b0 = a2 * _userDataD[15] + a1 * _userDataD[12] + a0 * _userDataD[9];
+
+	res1 = (atan2(b0, b2) * RAD2DEG) / _userData[526];
+	res2 = (atan2(b1, b2) * RAD2DEG - _userData[528]) / _userData[527];
+
+	writeScummVar(108, (int32)res1);
+	writeScummVar(109, (int32)res2);
+
+	return 1;
+}
+
+int32 LogicHErace::op_1130(int32 *args) {
+	double cs = cos(args[0] / _userData[532] * DEG2RAD);
+	double sn = sin(args[0] / _userData[532] * DEG2RAD);
+
+	writeScummVar(108, (int32)(cs * args[1] + sn * args[2]));
+	writeScummVar(109, (int32)(cs * args[2] - sn * args[1]));
+
+	return 1;
+}
+
+int32 LogicHErace::op_1140(int32 *args) {
+	// This functions seems to perform some kind of projection: We project
+	// the vector (arg2,arg3) onto the vector (arg0,arg1), but also apply
+	// some kind of distortion factor ?!?
+	double x = args[2], y = args[3];
+
+	// We start by normalizing the vector described by arg2 and arg3.
+	// So compute its length and divide the x and y coordinates
+	const double sq = sqrt(x*x + y*y);
+	x /= sq;
+	y /= sq;
+
+	// Compute the scalar product of the vectors (arg0,arg1) and (x,y)
+	const double scalarProduct = x * args[0] + y * args[1];
+
+	// Finally compute the projection of (arg2,arg3) onto (arg0,arg1)
+	double projX = args[0] - 2 * scalarProduct * x;
+	double projY = args[1] - 2 * scalarProduct * y;
+
+	projX = projX * 20.0 / 23.0;	// FIXME: Why is this here?
+
+	writeScummVar(108, (int32)projX);
+
+	if (args[3] >= 0)	// FIXME: Why is this here?
+		projY = projY * 5.0 / 6.0;
+
+	writeScummVar(109, (int32)projY);
+
+	return 1;
+}
+
+void LogicHErace::op_sub1(float arg) {
+	// Setup a rotation matrix
+	_userDataD[10] = _userDataD[12] = _userDataD[14] = _userDataD[16] = 0;
+	_userDataD[13] = 1;
+
+	_userDataD[9] = cos(arg * DEG2RAD);
+	_userDataD[15] = sin(arg * DEG2RAD);
+	_userDataD[11] = -_userDataD[15];
+	_userDataD[17] = _userDataD[9];
+}
+
+void LogicHErace::op_sub2(float arg) {
+	// Setup a rotation matrix -- but it is NEVER USED!
+	_userDataD[20] = _userDataD[21] = _userDataD[24] = _userDataD[25] = 0;
+	_userDataD[26] = 1;
+
+	_userDataD[19] = sin(arg * DEG2RAD);
+	_userDataD[18] = cos(arg * DEG2RAD);
+	_userDataD[21] = -_userDataD[19];
+	_userDataD[22] = _userDataD[18];
+}
+
+void LogicHErace::op_sub3(float arg) {
+	// Setup a rotation matrix -- but it is NEVER USED!
+	_userDataD[1] = _userDataD[2] = _userDataD[3] = _userDataD[6] = 0;
+	_userDataD[0] = 1;
+
+	_userDataD[4] = cos(arg * DEG2RAD);
+	_userDataD[5] = sin(arg * DEG2RAD);
+	_userDataD[7] = -_userDataD[5];
+	_userDataD[8] = _userDataD[4];
+}
+
+LogicHE *makeLogicHErace(ScummEngine_v90he *vm) {
+	return new LogicHErace(vm);
+}
+
+} // End of namespace Scumm
diff --git a/engines/scumm/he/logic/soccer.cpp b/engines/scumm/he/logic/soccer.cpp
new file mode 100644
index 0000000000..05f377a736
--- /dev/null
+++ b/engines/scumm/he/logic/soccer.cpp
@@ -0,0 +1,1206 @@
+/* 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 "scumm/he/intern_he.h"
+#include "scumm/he/logic_he.h"
+
+namespace Scumm {
+
+/**
+ * Logic code for:
+ *     Backyard Soccer
+ *     Backyard Soccer MLS Edition
+ *     Backyard Soccer 2004
+ */
+class LogicHEsoccer : public LogicHE {
+private:
+	double *_userDataD;
+
+public:
+	LogicHEsoccer(ScummEngine_v90he *vm);
+	~LogicHEsoccer();
+
+	int versionID();
+	int32 dispatch(int op, int numArgs, int32 *args);
+
+	void beforeBootScript();
+	void initOnce();
+	int startOfFrame();
+
+private:
+	int op_1005(float x1, float y1, float z1, float x2, float y2, float z2, float *nextVelX, float *nextVelY, float *nextVelZ, float *a10);
+	int op_1006(int32 a1, int32 a2, int32 a3, int32 a4);
+	int op_1007(int32 *args);
+	int op_1008(int outArray, int srcX, int srcY, int srcZ, int vecX, int vecY, int vecZ, int airResX, int airResY, int airResZ, int vecNumerator, int vecDenom, int gravityMult, int requiredSegments, int a15, int a16, int a17, int a18, int fieldType);
+	int op_1011(int32 worldPosArray, int32 screenPosArray, int32 a3, int32 closestActorArray, int32 maxDistance, int32 fieldAreaArray);
+	int op_1012(int32 *args);
+	int op_1013(int32 a1, int32 a2, int32 a3);
+	int op_1014(int32 srcX, int32 srcY, int32 srcZ, int32 velX, int32 velY, int32 velZ, int32 outArray, int32 dataArrayId, int32 indexArrayId, int32 requestType, int32 vecNumerator, int32 vecDenom, int32 a13, int32 a14);
+	int op_1016(int32 *args);
+	int op_1017(int32 *args);
+	int op_1019(int32 *args);
+	int op_1021(int32 inX, int32 inY, int32 inZ, int32 velX, int32 velY, int32 velZ, int32 internalUse);
+
+	// op_1007 allocates some arrays
+	// they're then filled by op_1019
+	byte _collisionObjIds[4096], _collisionNodeEnabled[585];
+
+	// op_1011 has a subfunction
+	void calculateDistances(int32 worldPosArray, int32 a2, int32 closestActorArray, int32 maxDistance);
+
+	// array containing collision detection tree
+	bool _collisionTreeAllocated;
+	uint32 *_collisionTree;
+	int addCollisionTreeChild(int depth, int index, int parent);
+
+	// op_1014 has several subops
+	// ...and several sub-subops
+	int generateCollisionObjectList(float srcX, float srcY, float srcZ, float velX, float velY, float velZ);
+	int addFromCollisionTreeNode(int index, int parent, uint32 *indices, int objIndexBase);
+	void addCollisionObj(byte objId);
+	int findCollisionWith(int objId, float inX, float inY, float inZ, float inXVec, float inYVec, float inZVec, float &collideX, float &collideY, float &collideZ, int indexArrayId, int dataArrayId, float *nextVelX, float *nextVelY, float *nextVelZ, float *a15);
+	void getPointsForFace(int faceId, float &x1, float &y1, float &z1, float &x2, float &y2, float &z2, float &x3, float &y3, float &z3, float &x4, float &y4, float &z4, const int *objPoints);
+	void crossProduct(float x1, float y1, float z1, float x2, float y2, float z2, float x3, float y3, float z3, float x4, float y4, float z4, float &outX, float &outY, float &outZ);
+	double dotProduct(float a1, float a2, float a3, float a4, float a5, float a6);
+	void sortCollisionList(float *data, int numEntries, int entrySize, int compareOn);
+	int setCollisionOutputData(float *collisionData, int entrySize, int dataArrayId, int indexArrayId, int startX, int startY, int startZ, float a8, int a9, int a10, int a11, int *out);
+
+	// op_1014 sets an array optionally based upon
+	// setCollisionOutputData; it is then used by op_1008
+	int _internalCollisionOutData[10];
+	Common::List<byte> _collisionObjs;
+
+	// op_1021 can (optionally) set two variables for use in op_1008
+	uint32 _var1021[2];
+};
+
+int LogicHEsoccer::versionID() {
+	return 1;
+}
+
+LogicHEsoccer::LogicHEsoccer(ScummEngine_v90he *vm) : LogicHE(vm) {
+	_userDataD = (double *)calloc(1732, sizeof(double));
+	_collisionTree = 0;
+	_collisionTreeAllocated = false;
+}
+
+LogicHEsoccer::~LogicHEsoccer() {
+	free(_userDataD);
+	delete[] _collisionTree;
+}
+
+int32 LogicHEsoccer::dispatch(int op, int numArgs, int32 *args) {
+	int res = 0;
+
+	switch (op) {
+	case 1006:
+		res = op_1006(args[0], args[1], args[2], args[3]);
+		break;
+
+	case 1007:
+		res = op_1007(args);
+		break;
+
+	case 1008:
+		res = op_1008(args[0], args[1], args[2], args[3], args[4], args[5], args[6], args[7], args[8], args[9], args[10], args[11], args[12], args[13], args[14], args[15], args[16], args[17], args[18]);
+		break;
+
+	case 1011:
+		res = op_1011(args[0], args[1], args[2], args[3], args[4], args[5]);
+		break;
+
+	case 1012:
+		res = op_1012(args);
+		break;
+
+	case 1013:
+		res = op_1013(args[0], args[1], args[2]);
+		break;
+
+	case 1014:
+		res = op_1014(args[0], args[1], args[2], args[3], args[4], args[5], args[6], args[7], args[8], args[9], args[10], args[11], args[12], args[13]);
+		break;
+
+	case 1016:
+		res = op_1016(args);
+		break;
+
+	case 1017:
+		res = op_1017(args);
+		break;
+
+	case 1019:
+		res = op_1019(args);
+		break;
+
+	case 1021:
+		res = op_1021(args[0], args[1], args[2], args[3], args[4], args[5], args[6]);
+		break;
+
+	case 1001: case 1002: case 1003: case 1005:
+	case 1009: case 8221968:
+		// In the u32, but unused by any of the soccer scripts
+		// 1005 is called from another opcode, however
+		error("Unused soccer u32 opcode %d called", op);
+
+	case 1004: case 1010: case 1015: case 1018:
+	case 1020:
+		// Used only by the unaccessible in-game editor (so, fall through)
+
+	default:
+		LogicHE::dispatch(op, numArgs, args);
+	}
+
+	return res;
+}
+
+void LogicHEsoccer::beforeBootScript() {
+	_userDataD[530] = 0;
+}
+
+void LogicHEsoccer::initOnce() {
+	// The original sets some paths here that we don't need to worry about
+	_collisionTreeAllocated = false;
+	_userDataD[530] = 0;
+}
+
+int LogicHEsoccer::startOfFrame() {
+	// This variable is some sort of flag that activates this mode
+	int res = (int)_userDataD[530];
+
+	if (res)
+		res = op_1011((int)_userDataD[531], (int)_userDataD[532], (int)_userDataD[533], (int)_userDataD[534], (int)_userDataD[535], (int)_userDataD[536]);
+
+	return res;
+}
+
+int LogicHEsoccer::op_1005(float x1, float y1, float z1, float x2, float y2, float z2, float *nextVelX, float *nextVelY, float *nextVelZ, float *a10) {
+	// Called from op_1014
+
+	double dot = x1 * x2 + y1 * y2 + z1 * z2;
+	*nextVelX = x2 - 2 * dot * x1;
+	*nextVelY = y2 - 2 * dot * y1;
+	*nextVelZ = z2 - 2 * dot * z1;
+	*a10 = 1.0f; // It always does this. How curious!
+
+	return 1;
+}
+
+int LogicHEsoccer::op_1006(int32 a1, int32 a2, int32 a3, int32 a4) {
+	double v1 = a1 * 0.01;
+	double v2 = a2 * 0.01;
+	double v3 = a3 * 0.01;
+	double var108, var109;
+
+	_userDataD[529] = a4;
+
+	var108 = atan2(v1, v3) * _userDataD[523] - a4;
+	var109 = _userDataD[526] - _userDataD[528] - (_userDataD[521] - atan2(_userDataD[524] - v2, v3)) * _userDataD[522];
+
+	writeScummVar(108, (int32)var108);
+	writeScummVar(109, (int32)var109);
+
+	return 1;
+}
+
+int LogicHEsoccer::op_1007(int32 *args) {
+	// Used when the HE logo is shown
+	// This initializes the _userDataD fields that are used in op_1006/op_1011
+
+	float y1 = (double)args[0] / 100.0;
+	float x1 = (double)args[1] / 100.0;
+	float x2 = (double)args[2] / 100.0;
+	float y2 = (double)args[3] / 100.0;
+	float x3 = (double)args[4] / 100.0;
+
+	_userDataD[518] = x2;
+	_userDataD[519] = 2 * atan2(y2, x2 - x3);
+	_userDataD[520] = atan2(y1, x2);
+	_userDataD[521] = atan2(y1, x1);
+	_userDataD[524] = y1;
+	_userDataD[525] = 2 * (_userDataD[521] - _userDataD[520]);
+	_userDataD[526] = args[6];
+	_userDataD[527] = args[5];
+	_userDataD[528] = args[7];
+	_userDataD[522] = _userDataD[526] / _userDataD[525];
+	_userDataD[523] = _userDataD[527] / _userDataD[519];
+
+	// Clear both byte arrays
+	memset(_collisionObjIds, 0, 4096);
+	memset(_collisionNodeEnabled, 0, 585);
+
+	if (!_collisionTreeAllocated)
+		op_1013(4, args[8], args[9]);
+
+	return 1;
+}
+
+static inline double vectorLength(double x, double y, double z) {
+	return sqrt(x * x + y * y + z * z);
+}
+
+int LogicHEsoccer::op_1008(int outArray, int srcX, int srcY, int srcZ, int vecX, int vecY, int vecZ, int airResX, int airResY, int airResZ, int vecNumerator, int vecDenom, int gravityMult, int requiredSegments, int a15, int a16, int a17, int a18, int fieldType) {
+	// Calculate requiredSegments consecutive movement segments, and place
+	// the associated data (positions, vectors, etc) into outArray.
+
+	int loopsSoFar = 0;
+	int segmentsSoFar = 1;
+	int prevVecY = 500;
+	int inX = srcX;
+	int inZ = srcZ;
+	int checkForCollisions = 0;
+
+	while (segmentsSoFar <= requiredSegments) {
+		if (fieldType == 1 && srcZ > 8819)
+			checkForCollisions = 1;
+		else if (fieldType == 2 && (srcX < -2350 || srcX > 2350))
+			checkForCollisions = 1;
+		else if (fieldType == 3 && (srcX < -2350 || srcX > 2350 || srcZ < 6119 || srcZ > 8819))
+			checkForCollisions = 1;
+
+		if (srcY > 0)
+			vecY -= vecNumerator * gravityMult / vecDenom;
+
+		int prevX = srcX;
+		int prevY = srcY;
+		int prevZ = srcZ;
+		srcX += vecNumerator * vecX / vecDenom;
+		srcY += vecNumerator * vecY / vecDenom;
+		srcZ += vecNumerator * vecZ / vecDenom;
+
+		if (srcY > 0) {
+			if (checkForCollisions && op_1014(prevX, prevY, prevZ, vecX, vecY, vecZ, 0, a17, a18, 3, vecNumerator, vecDenom, a15, a16)) {
+				srcX = _internalCollisionOutData[6];
+				srcY = _internalCollisionOutData[7];
+				srcZ = _internalCollisionOutData[8];
+				vecX = _internalCollisionOutData[3];
+				vecY = _internalCollisionOutData[4];
+				vecZ = _internalCollisionOutData[5];
+				putInArray(outArray, segmentsSoFar, 0, loopsSoFar);
+				putInArray(outArray, segmentsSoFar, 1, (int)vectorLength((double)(_internalCollisionOutData[6] - inX), 0.0, (double)(_internalCollisionOutData[8] - inZ)));
+				putInArray(outArray, segmentsSoFar, 2, _internalCollisionOutData[6]);
+				putInArray(outArray, segmentsSoFar, 3, _internalCollisionOutData[7]);
+				putInArray(outArray, segmentsSoFar, 4, _internalCollisionOutData[8]);
+				putInArray(outArray, segmentsSoFar, 5, vecX);
+				putInArray(outArray, segmentsSoFar, 6, vecY);
+				putInArray(outArray, segmentsSoFar++, 7, vecZ);
+			} 
+		} else {
+			srcY = 0;
+			int thisVecX = vecX;
+			int thisVecZ = vecZ;
+			vecX = vecX * airResX / 100;
+
+			if (vecY) {
+				int v18 = ABS(vecY);
+				if (v18 > ABS(prevVecY))
+					vecY = ABS(prevVecY);
+				vecY = ABS(airResY * vecY) / 100;
+			}
+
+			vecZ = airResZ * vecZ / 100;
+
+			if (prevVecY >= 0) {
+				if (op_1014(prevX, prevY, prevZ, thisVecX, prevVecY, thisVecZ, 0, a17, a18, 3, vecNumerator, vecDenom, a15, a16)) {
+					srcX = _internalCollisionOutData[6];
+					srcY = _internalCollisionOutData[7];
+					srcZ = _internalCollisionOutData[8];
+					vecX = _internalCollisionOutData[3];
+					vecY = _internalCollisionOutData[4];
+					vecZ = _internalCollisionOutData[5];
+				}
+			} else {
+				if (checkForCollisions) {
+					op_1021(srcX, 0, srcZ, thisVecX, prevVecY, thisVecZ, 1);
+
+					if (op_1014(prevX, prevY, prevZ, thisVecX, prevVecY, thisVecZ, 0, a17, a18, 3, vecNumerator, vecDenom, a15, a16)) {
+						srcX = _internalCollisionOutData[6];
+						srcY = _internalCollisionOutData[7];
+						srcZ = _internalCollisionOutData[8];
+						vecX = _internalCollisionOutData[3];
+						vecY = _internalCollisionOutData[4];
+						vecZ = _internalCollisionOutData[5];
+					} else {
+						// try it with the output of op_1021 instead
+						int tmpVecZ = vecZ + prevZ - _var1021[1];
+						int v20 = ABS(prevVecY);
+
+						if (op_1014(_var1021[0], 0, _var1021[1], vecX + prevX - _var1021[0], v20 - prevY, tmpVecZ, 0, a17, a18, 3, vecNumerator, vecDenom, a15, a16)) {
+							srcX = _internalCollisionOutData[6];
+							srcY = _internalCollisionOutData[7];
+							srcZ = _internalCollisionOutData[8];
+							vecX = _internalCollisionOutData[3];
+							vecY = _internalCollisionOutData[4];
+							vecZ = _internalCollisionOutData[5];
+						}
+					}
+				}
+			}
+
+			prevVecY = vecY;
+			putInArray(outArray, segmentsSoFar, 0, loopsSoFar);
+			putInArray(outArray, segmentsSoFar, 1, (int32)vectorLength(srcX - inX, 0.0, srcZ - inZ));
+			putInArray(outArray, segmentsSoFar, 2, srcX);
+			putInArray(outArray, segmentsSoFar, 3, srcY);
+			putInArray(outArray, segmentsSoFar, 4, srcZ);
+			putInArray(outArray, segmentsSoFar, 5, vecX);
+			putInArray(outArray, segmentsSoFar, 6, vecY);
+			putInArray(outArray, segmentsSoFar++, 7, vecZ);
+		}
+
+		loopsSoFar++;
+	}
+
+	return 1;
+}
+
+int LogicHEsoccer::op_1011(int32 worldPosArray, int32 screenPosArray, int32 a3, int32 closestActorArray, int32 maxDistance, int32 fieldAreaArray) {
+	// This is called on each frame by startOfFrame() if activated by op_1012.
+
+	float objY = 0.0;
+
+	// First, iterate over the field objects and project them onto the screen.
+	for (int i = 0; i < 18; i++) {
+		int rawX = getFromArray(worldPosArray, i, 0);
+		int rawY = getFromArray(worldPosArray, i, 1);
+		int rawZ = getFromArray(worldPosArray, i, 2);
+
+		float objX = (double)rawX / 100.0;
+		objY = (double)rawY / 100.0;
+		float objZ = (double)rawZ / 100.0;
+
+		if (i < 13) {
+			// For the players and the ball: work out the area of the field
+			// this object is in, storing it in an array if provided.
+			int areaX = (rawX + 2750) / 500;
+			areaX = CLIP(areaX, 0, 10);
+
+			int areaZ = (9219 - rawZ) / 500;
+			areaZ = CLIP(areaZ, 0, 6);
+
+			if (fieldAreaArray)
+				putInArray(fieldAreaArray, 0, i, areaX + 11 * areaZ);
+		}
+
+		float v7 = atan2(_userDataD[524] - objY, (double)objZ);
+		int screenY = (int)(_userDataD[526] - (_userDataD[521] - v7) * _userDataD[522] - 300.0);
+		double v9 = _userDataD[523];
+
+		// x/y position of objects
+		putInArray(screenPosArray, i, 0, (int32)(atan2(objX, objZ) * v9 + 640.0));
+		putInArray(screenPosArray, i, 1, screenY);
+
+		double v10 = atan2(_userDataD[524], (double)objZ);
+		int shadowScreenY = (int)(_userDataD[526] - (_userDataD[521] - (float)v10) * _userDataD[522] - 300.0);
+		double v13 = _userDataD[523];
+
+		// x/y position of shadows
+		putInArray(screenPosArray, i + ((_vm->_game.id == GID_SOCCER) ? 20 : 22), 0, (int32)(atan2(objX, objZ) * v13 + 640.0));
+		putInArray(screenPosArray, i + ((_vm->_game.id == GID_SOCCER) ? 20 : 22), 1, shadowScreenY);
+	}
+
+	// soccer only uses one array here
+	// soccermls/soccer2004 use four
+	int start = (_vm->_game.id == GID_SOCCER) ? 19 : 18;
+	int end = (_vm->_game.id == GID_SOCCER) ? 19 : 21;
+
+	// The following loop is doing cursor scaling
+	// The further up on the screen, the smaller the cursor is
+	for (int i = start; i <= end; i++) {
+		int x = getFromArray(screenPosArray, i, 0);
+		int y = getFromArray(screenPosArray, i, 1);
+
+		// This retains objY from (i == 17)?
+		float v16 = _userDataD[524] - objY;
+		float scaledZ = v16 / tan((_userDataD[528] + y - _userDataD[526]) / _userDataD[522] + _userDataD[521]);
+		double scaledX = tan((double)(x - ((_vm->_game.id == GID_SOCCER) ? 0 : 640)) / _userDataD[523]) * scaledZ;
+		putInArray(worldPosArray, i, 0, (int)(scaledX * 100.0));
+		putInArray(worldPosArray, i, 2, (int)(scaledZ * 100.0));
+	}
+
+	calculateDistances(worldPosArray, a3, closestActorArray, maxDistance);
+
+	return 1;
+}
+
+static inline int distance(int a1, int a2, int a3, int a4) {
+	return (int)sqrt((double)((a4 - a3) * (a4 - a3) + (a2 - a1) * (a2 - a1)));
+}
+
+void LogicHEsoccer::calculateDistances(int32 worldPosArray, int32 a2, int32 closestActorArray, int32 maxDistance) {
+	// As you can guess, this is called from op_1011
+	// This seems to be checking distances between the players and the ball
+	// and which distance is the shortest.
+
+	int closestActor[13];
+	int objectX[13];
+	int objectZ[13];
+	int closestDistance[195];
+
+	for (int i = 0; i < 13; i++) {
+		closestActor[i] = 0;
+		objectX[i] = getFromArray(worldPosArray, i, 0);
+		objectZ[i] = getFromArray(worldPosArray, i, 2);
+	}
+
+	// 12 here, 13 up there
+	// Probably 12 for players, 13 for players+ball
+	for (int i = 0; i < 12; i++) {
+		int bestDistance = maxDistance;
+		for (int j = i + 1; j < 13; j++) {
+			closestDistance[i * 15 + j] = distance(objectX[i], objectX[j], objectZ[i], objectZ[j]);
+			putInArray(a2, i, j, closestDistance[i * 15 + j]);
+			putInArray(a2, j, i, closestDistance[i * 15 + j]);
+			if (closestDistance[i * 15 + j] < bestDistance) {
+				bestDistance = closestDistance[i * 15 + j];
+				closestActor[i] = j + 1;
+				closestActor[j] = i + 1;
+			}
+		}
+	}
+
+	int v13 = getFromArray(worldPosArray, 18, 0);
+	int v14 = getFromArray(worldPosArray, 18, 2);
+	int v15 = getFromArray(worldPosArray, 19, 0);
+	int v16 = getFromArray(worldPosArray, 19, 2);
+	int v19[15];
+	int v20[15];
+
+	if (_vm->_game.id == GID_SOCCER) {
+		// soccer gets to be different
+		for (int i = 0; i < 13; i++)
+			v20[i] = distance(v15, objectX[i], v16, objectZ[i]);
+
+		for (int i = 0; i < 13; i++)
+			v19[i] = distance(v13, objectX[i], v14, objectZ[i]);
+	} else {
+		// soccermls and soccer2004 use two other arrays here
+		int v9 = getFromArray(worldPosArray, 20, 0);
+		int v10 = getFromArray(worldPosArray, 20, 2);
+		int v11 = getFromArray(worldPosArray, 21, 0);
+		int v12 = getFromArray(worldPosArray, 21, 2);
+
+		for (int i = 0; i < 6; i++) {
+			v20[i] = distance(v9, objectX[i], v10, objectZ[i]);
+			v19[i] = distance(v13, objectX[i], v14, objectZ[i]);
+		}
+
+		for (int i = 6; i < 13; i++) {
+			v20[i] = distance(v11, objectX[i], v12, objectZ[i]);
+			v19[i] = distance(v15, objectX[i], v16, objectZ[i]);
+		}
+	}
+
+	for (int i = 0; i < 13; i++) {
+		putInArray(a2, 14, i, v20[i]);
+		putInArray(a2, i, 14, v20[i]);
+		putInArray(a2, 13, i, v19[i]);
+		putInArray(a2, i, 13, v19[i]);
+		putInArray(closestActorArray, 0, i, closestActor[i]);
+	}
+}
+
+int LogicHEsoccer::op_1012(int32 *args) {
+	// Used after op_1019
+	// This function activates startOfFrame() to call op_1011
+	// (Possibly field parameters?)
+
+	_userDataD[530] = (args[0] != 0) ? 1 : 0;
+	_userDataD[531] = args[1];
+	_userDataD[532] = args[2];
+	_userDataD[533] = args[3];
+	_userDataD[534] = args[4];
+	_userDataD[535] = args[5];
+	_userDataD[536] = args[6];
+
+	return 1;
+}
+
+int LogicHEsoccer::addCollisionTreeChild(int depth, int index, int parent) {
+	uint32 *dataPtr = _collisionTree + 11 * index;
+
+	/*
+	 * This sets up a node of the tree stored in _collisionTree. There are
+	 * two sets of parents (at depth 1 and 2), then child nodes at depth
+	 * 3 which represent a single collision object.
+	 *
+	 * 0 = this index, 1 = parent index,
+	 * 2-9 = child indices (or all -1 if leaf),
+	 * 10 = _collisionObjIds index (if leaf)
+	 */
+	dataPtr[0] = index;
+	dataPtr[1] = parent;
+
+	if (depth > 2) {
+		// store the offset into _collisionObjIds (which holds collision object ids),
+		// but subtract 585 first because there are already (8 + 8*8 + 8*8*8 = 584)
+		// indexes at higher levels of the tree, and we want to start at 0
+		dataPtr[10] = 8 * index - 585;
+		for (int i = 0; i < 8; i++)
+			dataPtr[i + 2] = 0xffffffff;
+	} else {
+		for (int i = 0; i < 8; i++)
+			dataPtr[i + 2] = addCollisionTreeChild(depth + 1, i + 8 * index + 1, index);
+	}
+
+	return index;
+}
+
+int LogicHEsoccer::op_1013(int32 a1, int32 a2, int32 a3) {
+	// Initialises _collisionTree, a tree used for collision detection.
+	// It is used by op_1014 to work out which objects to check.
+
+	_collisionTree = new uint32[585 * 11];
+	_collisionTreeAllocated = true;
+	for (int i = 0; i < 585 * 11; i++)
+		_collisionTree[i] = 0;
+
+	for (int i = 0; i < 8; i++)
+		_collisionTree[i + 2] = addCollisionTreeChild(1, i + 1, 0);
+
+	return 1;
+}
+
+int LogicHEsoccer::op_1014(int32 srcX, int32 srcY, int32 srcZ, int32 velX, int32 velY, int32 velZ, int32 outArray, int32 dataArrayId, int32 indexArrayId, int32 requestType, int32 vecNumerator, int32 vecDenom, int32 a13, int32 a14) {
+	// Used many times during a match
+	// And called from op_1008!
+	// This seems to be doing collision handling
+
+	double startX = (double)srcX;
+	double startY = (double)srcY;
+	double startZ = (double)srcZ;
+	double adjustedVelZ = 0.0, adjustedVelY = 0.0, adjustedVelX = 0.0;
+
+	writeScummVar(108, 0);
+	writeScummVar(109, 0);
+
+	switch (requestType) {
+	case 1:
+	case 3:
+		adjustedVelX = (double)velX * (double)vecNumerator / (double)vecDenom / 100.0;
+		adjustedVelY = (double)velY * (double)vecNumerator / (double)vecDenom / 100.0;
+		adjustedVelZ = (double)velZ * (double)vecNumerator / (double)vecDenom / 100.0;
+		break;
+	case 2:
+		// length of movement vector
+		double v15 = vectorLength((double)velX * (double)vecNumerator / (double)vecDenom, (double)velY * (double)vecNumerator / (double)vecDenom, (double)velZ * (double)vecNumerator / (double)vecDenom);
+
+		if (v15 != 0.0) {
+			// add the (scaled) movement vector to the input
+			double v26 = (double)ABS(velX) * (double)vecNumerator / (double)vecDenom * 50.0 / v15;
+			srcX = (int)((double)srcX + v26);
+			double v25 = (double)ABS(velY) * (double)vecNumerator / (double)vecDenom * 50.0 / v15;
+			srcY = (int)((double)srcY + v25);
+			double v24 = (double)ABS(velZ) * (double)vecNumerator / (double)vecDenom * 50.0 / v15;
+			srcZ = (int)((double)srcZ + v24);
+		}
+
+		// srcX = (newX / newZ) * 3869
+		startX = (double)srcX / (double)srcZ * 3869.0;
+		// srcY = (newY - (+524 * 100)) / (newZ * 3869 + (+524 * 100)
+		startY = ((double)srcY - _userDataD[524] * 100.0) / (double)srcZ * 3869.0 + _userDataD[524] * 100.0;
+		// srcZ = 3869
+		startZ = 3869.0;
+		// vectorX = (newX - srcX) / 100
+		adjustedVelX = ((double)srcX - startX) / 100.0;
+		// vectorY = (newY - srcY) / 100
+		adjustedVelY = ((double)srcY - startY) / 100.0;
+		// vectorZ = (newZ - 3869 = srcZ) / 100
+		adjustedVelZ = ((double)srcZ - 3869.0) / 100.0;
+		break;
+	}
+	
+	int foundCollision = 0;
+
+	// work out which collision objects we might collide with (if any)
+	if (generateCollisionObjectList(startX, startY, startZ, adjustedVelX, adjustedVelY, adjustedVelZ)) {
+		int collisionId = 0;
+		float v46; // always 1.0 after a collision due to op_1005
+
+		float collisionInfo[42 * 8];
+		memset(collisionInfo, 0, 42 * 8 * sizeof(float));
+
+		// check each potential collision object for an actual collision,
+		// add it to collisionInfo if there is one
+		for (Common::List<byte>::const_iterator it = _collisionObjs.begin(); it != _collisionObjs.end(); it++) {
+			float collideZ, collideY, collideX;
+			float nextVelX, nextVelY, nextVelZ;
+
+			if (findCollisionWith(*it, startX, startY, startZ, adjustedVelX * 100.0, adjustedVelY * 100.0, adjustedVelZ * 100.0, collideX, collideY, collideZ, indexArrayId, dataArrayId, &nextVelX, &nextVelY, &nextVelZ, &v46)) {
+				collisionInfo[collisionId * 8] = *it;
+				collisionInfo[collisionId * 8 + 1] = vectorLength(collideX - startX, collideY - startY, collideZ - startZ);
+				collisionInfo[collisionId * 8 + 2] = collideX;
+				collisionInfo[collisionId * 8 + 3] = collideY;
+				collisionInfo[collisionId * 8 + 4] = collideZ;
+				collisionInfo[collisionId * 8 + 5] = vecDenom * nextVelX / vecNumerator;
+				collisionInfo[collisionId * 8 + 6] = vecDenom * nextVelY / vecNumerator;
+				collisionInfo[collisionId * 8 + 7] = vecDenom * nextVelZ / vecNumerator;
+				foundCollision = 1;
+				collisionId++;
+			}
+		}
+
+		if (foundCollision) {
+			// if we have more than one collision, sort them by distance
+			// to find the closest one
+			if (collisionId != 1)
+				sortCollisionList(collisionInfo, 42, 8, 1);
+
+			int v22, v39, v42;
+			float tmpData[8];
+			int outData[10];
+
+			// output the collision we found
+			switch (requestType) {
+				case 1:
+					for (int i = 0; i < 8; i++)
+						tmpData[i] = collisionInfo[i];
+					v22 = getFromArray(indexArrayId, 0, (int)((tmpData[0] - 1.0) * 4.0));
+					v42 = getFromArray(indexArrayId, 0, (int)((tmpData[0] - 1.0) * 4.0  + 1.0));
+					v39 = getFromArray(indexArrayId, 0, (int)((tmpData[0] - 1.0) * 4.0  + 2.0));
+					setCollisionOutputData(tmpData, 8, dataArrayId, indexArrayId, (int)startX, (int)startY, (int)startZ, v46, v22, v42, v39, outData);
+					for (int i = 0; i < 10; i++)
+						putInArray(outArray, 0, i, outData[i]);
+					break;
+				case 2:
+					// write the object id if collision happened (note that other case can't happen)
+					if (collisionId)
+						writeScummVar(109, (int)collisionInfo[(collisionId - 1) * 8]);
+					else
+						writeScummVar(109, 0);
+					break;
+				case 3:
+					for (int i = 0; i < 8; i++)
+						tmpData[i] = collisionInfo[i];
+					v22 = getFromArray(indexArrayId, 0, (int)((tmpData[0] - 1.0) * 4.0));
+					v42 = getFromArray(indexArrayId, 0, (int)((tmpData[0] - 1.0) * 4.0  + 1.0));
+					v39 = getFromArray(indexArrayId, 0, (int)((tmpData[0] - 1.0) * 4.0  + 2.0));
+					setCollisionOutputData(tmpData, 8, dataArrayId, indexArrayId, (int)startX, (int)startY, (int)startZ, v46, v22, v42, v39, outData);
+					for (int i = 0; i < 10; i++)
+						_internalCollisionOutData[i] = outData[i];
+					break;
+			}
+		}
+	}
+
+	writeScummVar(108, foundCollision);
+
+	_collisionObjs.clear();
+
+	return foundCollision;
+}
+
+int LogicHEsoccer::generateCollisionObjectList(float srcX, float srcY, float srcZ, float velX, float velY, float velZ) {
+	float v36 = srcX / 100.0;
+	float v37 = v36 + 52.0;
+	float destX = v37 + velX;
+
+	int v33, v29;
+
+	if (((int)destX / 52) ^ ((int)v37 / 52)) {
+		v33 = 1;
+		v29 = 1;
+	} else if ((int)v37 / 52) {
+		v29 = 0;
+		v33 = 1;
+	} else {
+		v33 = 0;
+		v29 = 1;
+	}
+
+	uint32 areaEnabled[8];
+	for (int i = 0; i < 4; i++) {
+		areaEnabled[i] = v29;
+		areaEnabled[i + 4] = v33;
+	}
+
+	float v38 = srcY / 100.0;
+	float destY = v38 + velY;
+
+	if (((int)destY / 20) ^ ((int)v38 / 20)) {
+		v33 = 1;
+		v29 = 1;
+	} else if ((int)v38 / 20) {
+		v33 = 1;
+		v29 = 0;
+	} else {
+		v29 = 1;
+		v33 = 0;
+	}
+
+	for (int i = 0; i < 2; i++) {
+		if (areaEnabled[i * 4 + 0])
+			areaEnabled[i * 4 + 0] = v29;
+		if (areaEnabled[i * 4 + 1])
+			areaEnabled[i * 4 + 1] = v29;
+		if (areaEnabled[i * 4 + 2])
+			areaEnabled[i * 4 + 2] = v33;
+		if (areaEnabled[i * 4 + 3])
+			areaEnabled[i * 4 + 3] = v33;
+	}
+
+	float v39 = srcZ / 100.0;
+	float v40 = v39 - 38.69;
+	float destZ = v40 + velZ;
+
+	if (((int)destZ / 36) ^ ((int)v40 / 36)) {
+		v33 = 1;
+		v29 = 1;
+	} else if ((int)v40 / 36) {
+		v29 = 0;
+		v33 = 1;
+	} else {
+		v33 = 0;
+		v29 = 1;
+	}
+
+	for (int i = 0; i <= 6; i += 2) {
+		if (areaEnabled[i])
+			areaEnabled[i] = v29;
+		if (areaEnabled[i + 1])
+			areaEnabled[i + 1] = v33;
+	}
+
+	int objCount = 0;
+
+	for (int i = 0; i < 8; i++) {
+		if (areaEnabled[i]) {
+			uint32 *ptr = _collisionTree +  _collisionTree[i + 2] * 11;
+			objCount += addFromCollisionTreeNode(ptr[0], ptr[1], &ptr[2], ptr[10]);
+		}
+	}
+
+	writeScummVar(109, objCount);
+	return objCount;
+}
+
+int LogicHEsoccer::addFromCollisionTreeNode(int index, int parent, uint32 *indices, int objIndexBase) {
+	int objCount = 0;
+
+	if (indices[0] == 0xffffffff) {
+		for (int i = 0; i < 8; i++) {
+			if (_collisionObjIds[i + objIndexBase]) {
+				addCollisionObj(_collisionObjIds[i + objIndexBase]);
+				objCount = 1;
+			}
+		}
+	} else {
+		if (_collisionNodeEnabled[index]) {
+			for (int i = 0; i < 8; i++) {
+				uint32 *ptr = _collisionTree + indices[i] * 11;
+				objCount += addFromCollisionTreeNode(ptr[0], ptr[1], &ptr[2], ptr[10]);
+			}
+		}
+	}
+
+	return objCount;
+}
+
+void LogicHEsoccer::addCollisionObj(byte objId) {
+	// Add objId to the list if not found
+	for (Common::List<byte>::const_iterator it = _collisionObjs.begin(); it != _collisionObjs.end(); it++)
+		if (*it == objId)
+			return;
+
+	_collisionObjs.push_back(objId);
+}
+
+int LogicHEsoccer::findCollisionWith(int objId, float inX, float inY, float inZ, float inXVec, float inYVec, float inZVec, float &collideX, float &collideY, float &collideZ, int indexArrayId, int dataArrayId, float *nextVelX, float *nextVelY, float *nextVelZ, float *a15) {
+	int foundCollision = 0;
+	float inY_plus1 = inY + 1.0;
+	float destX = inX + inXVec;
+	float destY = inY_plus1 + inYVec;
+	float destZ = inZ + inZVec;
+
+	// don't go below the ground!
+	if (inY_plus1 <= 1.0001 && destY < 0.0) {
+		destY = 0.0;
+		inYVec = ABS((int)inYVec);
+	}
+
+	// get the 8 points which define the 6 faces of this object
+	int objIndex = getFromArray(indexArrayId, 0, 4 * objId - 1);
+	int objPoints[24];
+	for (int i = 0; i < 24; i++)
+		objPoints[i] = getFromArray(dataArrayId, 0, objIndex + i);
+
+	for (int faceId = 0; faceId < 6; faceId++) {
+		// This assigns variables from objPoints based on faceId
+		float x1, y1, z1, x2, y2, z2, x3, y3, z3, x4, y4, z4;
+		float faceCrossX, faceCrossY, faceCrossZ;
+		getPointsForFace(faceId, x1, y1, z1, x2, y2, z2, x3, y3, z3, x4, y4, z4, objPoints);
+		crossProduct(x1, y1, z1, x2, y2, z2, x1, y1, z1, x3, y3, z3, faceCrossX, faceCrossY, faceCrossZ);
+
+		float faceArea = sqrt(faceCrossX * faceCrossX + faceCrossY * faceCrossY + faceCrossZ * faceCrossZ);
+
+		// The original did not initialize these variables and would
+		// use them uninitialized if faceArea == 0.0
+		float xMult = 0.0, yMult = 0.0, zMult = 0.0;
+
+		if (faceArea != 0.0) {
+			// UnitCross = Cross/||Cross||
+			xMult = faceCrossX / faceArea;
+			yMult = faceCrossY / faceArea;
+			zMult = faceCrossZ / faceArea;
+		}
+		double scalingMult = 5.0;
+
+		float ZToFacePoint1 = z1 - inZ;
+		float YToFacePoint1 = y1 - inY_plus1;
+		float XToFacePoint1 = x1 - inX;
+		// scalar component of UnitCross in direction of (start -> P1)
+		double ToFacePoint1 = dotProduct(xMult, yMult, zMult, XToFacePoint1, YToFacePoint1, ZToFacePoint1);
+
+		float ZToDest = destZ - inZ;
+		float YToDest = destY - inY_plus1;
+		float XToDest = destX - inX;
+		// scalar component of UnitCross in direction of (start -> dest)
+		double ToDest = dotProduct(xMult, yMult, zMult, XToDest, YToDest, ZToDest);
+
+		if (fabs(ToDest) > 0.00000001)
+			scalingMult = ToFacePoint1 / ToDest;
+
+		if (scalingMult >= 0.0 && fabs(scalingMult) <= 1.0 && ToDest != 0.0) {
+			// calculate where the collision would be, in the plane containing this face
+			double collisionX = inX + (destX - inX) * scalingMult;
+			double collisionY = inY_plus1 + (destY - inY_plus1) * scalingMult + 5.0;
+			double collisionZ = inZ + (destZ - inZ) * scalingMult;
+
+			// now we need to work out whether this point is actually inside the face
+			double dot1 = dotProduct(x2 - x1, y2 - y1, z2 - z1, x3 - x1, y3 - y1, z3 - z1);
+			double sqrt1 = vectorLength(x2 - x1, y2 - y1, z2 - z1);
+			double num1 = dot1 / (vectorLength(x3 - x1, y3 - y1, z3 - z1) * sqrt1);
+			num1 = CLIP<double>(num1, -1.0, 1.0);
+			double faceAngle = acos(num1);
+
+			double dot2 = dotProduct(x2 - x1, y2 - y1, z2 - z1, collisionX - x1, collisionY - y1, collisionZ - z1);
+			double sqrt2 = vectorLength(x2 - x1, y2 - y1, z2 - z1);
+			double num2 = dot2 / (vectorLength(collisionX - x1, collisionY - y1, collisionZ - z1) * sqrt2);
+			num2 = CLIP<double>(num2, -1.0, 1.0);
+			double angle1 = acos(num2);
+
+			double dot3 = dotProduct(x3 - x1, y3 - y1, z3 - z1, collisionX - x1, collisionY - y1, collisionZ - z1);
+			double sqrt3 = vectorLength(x3 - x1, y3 - y1, z3 - z1);
+			double num3 = dot3 / (vectorLength(collisionX - x1, collisionY - y1, collisionZ - z1) * sqrt3);
+			num3 = CLIP<double>(num3, -1.0, 1.0);
+			double angle2 = acos(num3);
+
+			if (angle1 + angle2 - 0.001 <= faceAngle) {
+				double dot4 = dotProduct(x2 - x4, y2 - y4, z2 - z4, x3 - x4, y3 - y4, z3 - z4);
+				double sqrt4 = vectorLength(x2 - x4, y2 - y4, z2 - z4);
+				double num4 = dot4 / (vectorLength(x3 - x4, y3 - y4, z3 - z4) * sqrt4);
+				num4 = CLIP<double>(num4, -1.0, 1.0);
+				faceAngle = acos(num4);
+
+				double dot5 = dotProduct(x2 - x4, y2 - y4, z2 - z4, collisionX - x4, collisionY - y4, collisionZ - z4);
+				double sqrt5 = vectorLength(x2 - x4, y2 - y4, z2 - z4);
+				double num5 = dot5 / (vectorLength(collisionX - x4, collisionY - y4, collisionZ - z4) * sqrt5);
+				num5 = CLIP<double>(num5, -1.0, 1.0);
+				double angle3 = acos(num5);
+
+				double dot6 = dotProduct(x3 - x4, y3 - y4, z3 - z4, collisionX - x4, collisionY - y4, collisionZ - z4);
+				double sqrt6 = vectorLength(x3 - x4, y3 - y4, z3 - z4);
+				double num6 = dot6 / (vectorLength(collisionX - x4, collisionY - y4, collisionZ - z4) * sqrt6);
+				num6 = CLIP<double>(num6, -1.0, 1.0);
+				double angle4 = acos(num6);
+
+				if (angle3 + angle4 - 0.001 <= faceAngle) {
+					// found a collision with this face
+					if (foundCollision) {
+						// if we already found one, is the new one closer?
+						// (except this don't adjust for the modification of collideX/Y/Z..)
+						double ToCollide = vectorLength(inX - collisionX, inY_plus1 - collisionY, inZ - collisionZ);
+						if (vectorLength(inX - collideX, inY_plus1 - collideY, inZ - collideZ) > ToCollide) {
+							collideX = collisionX - xMult * 3.0;
+							collideY = collisionY - yMult * 3.0;
+							collideZ = collisionZ - zMult * 3.0;
+							op_1005(xMult, yMult, zMult, inXVec, inYVec, inZVec, nextVelX, nextVelY, nextVelZ, a15);
+						}
+					} else {
+						collideX = collisionX - xMult * 3.0;
+						collideY = collisionY - yMult * 3.0;
+						collideZ = collisionZ - zMult * 3.0;
+						op_1005(xMult, yMult, zMult, inXVec, inYVec, inZVec, nextVelX, nextVelY, nextVelZ, a15);
+					}
+
+					foundCollision = 1;
+				}
+			}
+		}
+	}
+
+	return foundCollision;
+}
+
+void LogicHEsoccer::getPointsForFace(int faceId, float &x1, float &y1, float &z1, float &x2, float &y2, float &z2, float &x3, float &y3, float &z3, float &x4, float &y4, float &z4, const int *objPoints) {
+	// Note that this originally returned a value, but said value was never used
+	// TODO: This can probably be shortened using a few tables...
+
+	switch (faceId) {
+	case 0:
+		x1 = objPoints[0];
+		y1 = objPoints[1];
+		z1 = objPoints[2];
+		x2 = objPoints[3];
+		y2 = objPoints[4];
+		z2 = objPoints[5];
+		x3 = objPoints[6];
+		y3 = objPoints[7];
+		z3 = objPoints[8];
+		x4 = objPoints[9];
+		y4 = objPoints[10];
+		z4 = objPoints[11];
+		break;
+	case 1:
+		x1 = objPoints[0];
+		y1 = objPoints[1];
+		z1 = objPoints[2];
+		x2 = objPoints[6];
+		y2 = objPoints[7];
+		z2 = objPoints[8];
+		x3 = objPoints[12];
+		y3 = objPoints[13];
+		z3 = objPoints[14];
+		x4 = objPoints[18];
+		y4 = objPoints[19];
+		z4 = objPoints[20];
+		break;
+	case 2:
+		x1 = objPoints[3];
+		y1 = objPoints[4];
+		z1 = objPoints[5];
+		x2 = objPoints[15];
+		y2 = objPoints[16];
+		z2 = objPoints[17];
+		x3 = objPoints[9];
+		y3 = objPoints[10];
+		z3 = objPoints[11];
+		x4 = objPoints[21];
+		y4 = objPoints[22];
+		z4 = objPoints[23];
+		break;
+	case 3:
+		x1 = objPoints[0];
+		y1 = objPoints[1];
+		z1 = objPoints[2];
+		x2 = objPoints[12];
+		y2 = objPoints[13];
+		z2 = objPoints[14];
+		x3 = objPoints[3];
+		y3 = objPoints[4];
+		z3 = objPoints[5];
+		x4 = objPoints[15];
+		y4 = objPoints[16];
+		z4 = objPoints[17];
+		break;
+	case 4:
+		x1 = objPoints[6];
+		y1 = objPoints[7];
+		z1 = objPoints[8];
+		x2 = objPoints[9];
+		y2 = objPoints[10];
+		z2 = objPoints[11];
+		x3 = objPoints[18];
+		y3 = objPoints[19];
+		z3 = objPoints[20];
+		x4 = objPoints[21];
+		y4 = objPoints[22];
+		z4 = objPoints[23];
+		break;
+	case 5:
+		x1 = objPoints[15];
+		y1 = objPoints[16];
+		z1 = objPoints[17];
+		x2 = objPoints[12];
+		y2 = objPoints[13];
+		z2 = objPoints[14];
+		x3 = objPoints[21];
+		y3 = objPoints[22];
+		z3 = objPoints[23];
+		x4 = objPoints[18];
+		y4 = objPoints[19];
+		z4 = objPoints[20];
+		break;
+	}
+}
+
+void LogicHEsoccer::crossProduct(float x1, float y1, float z1, float x2, float y2, float z2, float x3, float y3, float z3, float x4, float y4, float z4, float &outX, float &outY, float &outZ) {
+	outX = (y2 - y1) * (z4 - z3) - (y4 - y3) * (z2 - z1);
+	outY = ((x2 - x1) * (z4 - z3) - (x4 - x3) * (z2 - z1)) * -1.0;
+	outZ = (x2 - x1) * (y4 - y3) - (x4 - x3) * (y2 - y1);
+}
+
+double LogicHEsoccer::dotProduct(float a1, float a2, float a3, float a4, float a5, float a6) {
+	return a1 * a4 + a2 * a5 + a3 * a6;
+}
+
+void LogicHEsoccer::sortCollisionList(float *data, int numEntries, int entrySize, int compareOn) {
+	// This takes an input array of collisions, and tries to sort it based on the distance
+	// (index of compareOn, always 1), copying in groups of entrySize, which is always 8
+
+	bool found = true;
+	int entry = 0;
+
+	while (found) {
+		found = false;
+
+		// while we still have entries, and there is an obj id set for the next entry
+		while (entry <= numEntries - 2 && data[(entry + 1) * 8] != 0.0) {
+			// if the current entry has distance 0, or the next entry is closer (distance is less)
+			if (data[compareOn + entry * 8] == 0 || data[compareOn + entry * 8] > data[compareOn + (entry + 1) * 8]) {
+				found = true;
+
+				// swap all data with the next entry
+				for (int i = 0; i < entrySize; i++) {
+					float tmp = data[i + entry * 8];
+					data[i + entry * 8] = data[i + (entry + 1) * 8];
+					data[i + (entry + 1) * 8] = tmp;
+				}
+			}
+
+			entry++;
+		}
+	}
+}
+
+int LogicHEsoccer::setCollisionOutputData(float *collisionData, int entrySize, int dataArrayId, int indexArrayId, int startX, int startY, int startZ, float a8, int a9, int a10, int a11, int *out) {
+	// area-provided data
+	out[0] = a9;
+	out[1] = a10;
+	out[2] = a11;
+	// new velocity, slowed by area-provided value
+	out[3] = (int)(collisionData[5] * (double)a10 / 100.0);
+	out[4] = (int)(collisionData[6] * (double)a10 / 100.0 * a8); // Note: a8 should always be 1
+	out[5] = (int)(collisionData[7] * (double)a10 / 100.0);
+	// new position
+	out[6] = (int)collisionData[2];
+	out[7] = (int)collisionData[3];
+	out[8] = (int)collisionData[4];
+	// collision object id
+	out[9] = (int)collisionData[0];
+	return out[9];
+}
+
+int LogicHEsoccer::op_1016(int32 *args) {
+	// Called when a goal is scored
+
+	int result = 0;
+
+	double v9 = (double)args[1] / 100.0;
+	double v13 = (double)args[2] / 100.0;
+	double v12 = (double)args[3] / 100.0;
+	double v18 = v13 * v13;
+	double v10 = (double)args[0] / 100.0 * (double)args[0] / 100.0;
+	double v11 = v9 * v9;
+	double v19 = (v9 * v9 * v12 * v12 + 2.0 * v9 * v12 * v18 + v18 * v18) * v10 * v10 - (v10 + v11) * v12 * v12 * v10 * v10;
+
+	if (v19 >= 0.0) {
+		double v6 = sqrt(v19);
+		double v17 = ((v9 * v12 + v18) * v10 + v6) / (v10 + v11 + v10 + v11);
+		double v16 = ((v9 * v12 + v18) * v10 - v6) / (v10 + v11 + v10 + v11);
+		double v7, v14;
+
+		if (v17 <= 0.0 || (v7 = sqrt(v17), v14 = acos(v7 / v13), v14 > 0.7853981633974475)) {
+			double v8, v15;
+			if (v16 <= 0.0 || (v8 = sqrt(v16), v15 = acos(v8 / v13), v15 > 0.7853981633974475)) {
+				writeScummVar(108, -1);
+			} else {
+				writeScummVar(108, (int)(v15 / 0.01745329251994328 * 100.0));
+				result = 1;
+			}
+		} else {
+			writeScummVar(108, (int)(v14 / 0.01745329251994328 * 100.0));
+			result = 1;
+		}
+	} else {
+		writeScummVar(108, -1);
+	}
+
+	return result;
+}
+
+int LogicHEsoccer::op_1017(int32 *args) {
+	// Used sporadically during a match (out of bounds?)
+	if (!args[1])
+		args[1] = 1;
+
+	double v3 = asin((double)args[0] / (double)args[1]);
+	writeScummVar(108, (int32)(v3 / 0.01745329251994328 * (double)args[1]));
+
+	return 1;
+}
+
+int LogicHEsoccer::op_1019(int32 *args) {
+	// Used at the beginning of a match
+	// Initializes some arrays with field collision data
+
+	// _collisionObjIds provides object ids for leaf nodes
+	// of the collision tree (_collisionTree).
+	for (int i = 0; i < 4096; i++)
+		_collisionObjIds[i] = getFromArray(args[1], 0, i);
+
+	// _collisionNodeEnabled enables or disables non-leaf nodes
+	// of the collision tree (_collisionTree).
+	for (int i = 0; i < 585; i++)
+		_collisionNodeEnabled[i] = getFromArray(args[0], 0, i);
+
+	// The remaining code of this function was used for the
+	// built-in editor. However, it is incomplete in the
+	// final product, so we do not need to have it.
+
+	return 1;
+}
+
+int LogicHEsoccer::op_1021(int32 inX, int32 inY, int32 inZ, int32 velX, int32 velY, int32 velZ, int32 internalUse) {
+	// Used during a match (ball movement?)
+	// Also called from op_1008
+
+	int outX;
+	if (velX && velY)
+		outX = (int)(((double)inY - (double)velY * (double)inX / (double)velX) * -1.0 * (double)velX / (double)velY);
+	else
+		outX = inX;
+
+	int outZ;
+	if (velZ && velY)
+		outZ = (int)(((double)inY - (double)velY * (double)inZ / (double)velZ) * -1.0 * (double)velZ / (double)velY);
+	else
+		outZ = inZ;
+
+	// The final argument chooses whether to store the results for op_1008 or
+	// store them in SCUMM variables.
+	if (internalUse) {
+		_var1021[0] = outX;
+		_var1021[1] = outZ;
+	} else {
+		writeScummVar(108, outX);
+		writeScummVar(109, outZ);
+	}
+
+	return 1;
+}
+
+LogicHE *makeLogicHEsoccer(ScummEngine_v90he *vm) {
+	return new LogicHEsoccer(vm);
+}
+
+} // End of namespace Scumm
diff --git a/engines/scumm/he/logic_he.cpp b/engines/scumm/he/logic_he.cpp
index af56bca2ee..a76c393e13 100644
--- a/engines/scumm/he/logic_he.cpp
+++ b/engines/scumm/he/logic_he.cpp
@@ -33,29 +33,10 @@ LogicHE::LogicHE(ScummEngine_v90he *vm) : _vm(vm) {
 LogicHE::~LogicHE() {
 }
 
-LogicHErace::LogicHErace(ScummEngine_v90he *vm) : LogicHE(vm) {
-	// Originally it used 0x930 and stored both floats and doubles inside
-	_userData = (float *)calloc(550, sizeof(float));
-	_userDataD = (double *)calloc(30, sizeof(double));
-
-	// FIXME: of the 550 entries in _userData, only 516 till 532 are used
-	// FIXME: similarly, in _userDataD only 9 till 17 are used for computations
-	//       (some of the other entries are also set, but never read, hence useless).
-}
-
-LogicHErace::~LogicHErace() {
-	free(_userData);
-	free(_userDataD);
-}
-
 void LogicHE::writeScummVar(int var, int32 value) {
 	_vm->writeVar(var, value);
 }
 
-static int32 scumm_round(double arg) {
-	return (int32)(arg + 0.5);
-}
-
 int LogicHE::versionID() {
 	return 1;
 }
@@ -95,1370 +76,34 @@ int32 LogicHE::dispatch(int op, int numArgs, int32 *args) {
 	return 1;
 }
 
-/***********************
- * Putt-Putt Joins the Race
- *
- */
-
-int LogicHErace::versionID() {
-	return 1;
-}
-
-int32 LogicHErace::dispatch(int op, int numArgs, int32 *args) {
-	int32 res;
-
-	switch (op) {
-	case 1003:
-		res = op_1003(args);
-		break;
-
-	case 1004:
-		res = op_1004(args);
-		break;
-
-	case 1100:
-		res = op_1100(args);
-		break;
-
-	case 1101:
-		res = op_1101(args);
-		break;
-
-	case 1102:
-		res = op_1102(args);
-		break;
-
-	case 1103:
-		res = op_1103(args);
-		break;
-
-	case 1110:
-		res = op_1110();
-		break;
-
-	case 1120:
-		res = op_1120(args);
-		break;
-
-	case 1130:
-		res = op_1130(args);
-		break;
-
-	case 1140:
-		res = op_1140(args);
-		break;
-
-	default:
-		res = 0;
-		break;
-
-	}
-
-	return res;
-}
-
-#define RAD2DEG (180 / M_PI)
-#define DEG2RAD (M_PI / 180)
-
-int32 LogicHErace::op_1003(int32 *args) {
-	int value = args[2] ? args[2] : 1;
-
-	writeScummVar(108, (int32)(atan2((double)args[0], (double)args[1]) * RAD2DEG * value));
-
-	return 1;
-}
-
-int32 LogicHErace::op_1004(int32 *args) {
-	int value = args[1] ? args[1] : 1;
-
-	writeScummVar(108, (int32)(sqrt((float)args[0]) * value));
-
-	return 1;
-}
-
-int32 LogicHErace::op_1100(int32 *args) {
-	// _userData 516,517,518 describe a 3D translation?
-	_userData[516] = (float)args[0] / args[10];
-	_userData[517] = (float)args[1] / args[10];
-	_userData[518] = (float)args[2] / args[10];
-
-	// _userData 519,520,521 describe rotation angles around the x,y,z axes?
-	_userData[519] = (float)args[3] / args[10];
-	_userData[520] = (float)args[4] / args[10];
-	_userData[521] = (float)args[5] / args[10];
-
-	op_sub1(_userData[520]);
-	op_sub2(_userData[521]);
-
-	// _userData[532] seems to be some kind of global scale factor
-	_userData[532] = (float)args[10];
-
-	_userData[524] = (float)args[8];	// not used
-	_userData[525] = (float)args[9];	// not used
-	_userData[522] = (float)args[6] / args[10];	// not used
-	_userData[523] = (float)args[7] / args[10];	// only used to compute 528 and 529
-
-	// The following two are some kind of scale factors
-	_userData[526] = (float)args[6] / args[8] / args[10];
-	_userData[527] = (float)args[7] / args[9] / args[10];
-
-	// Set var 108 and 109 -- the value set here corresponds to the values
-	// set by op_1110!
-	writeScummVar(108, (int32)((float)args[6] / args[8] * args[10]));
-	writeScummVar(109, (int32)((float)args[7] / args[9] * args[10]));
-
-	_userData[528] = (float)(_userData[519] - _userData[523] * 0.5);
-	_userData[529] = (float)(_userData[519] + _userData[523] * 0.5);
-
-	writeScummVar(110, (int32)(_userData[528] * args[10]));
-	writeScummVar(111, (int32)(_userData[529] * args[10]));
-
-	// 530 and 531 are only used to set vars 112 and 113, so no need
-	// to store them permanently
-	_userData[530] = (float)(_userData[517] / tan(_userData[529] * DEG2RAD));
-	_userData[531] = (float)(_userData[517] / tan(_userData[528] * DEG2RAD));
-
-	writeScummVar(112, (int32)(_userData[530] * args[10]));
-	writeScummVar(113, (int32)(_userData[531] * args[10]));
-
-	return 1;
-}
-
-int32 LogicHErace::op_1101(int32 *args) {
-	// Update rotation params?
-	int32 retval;
-	float temp;
-
-	temp = args[0] / _userData[532];
-	if (_userData[519] != temp) {
-		_userData[519] = temp;
-		op_sub3(temp);
-		retval = 1;
-	} else {
-		retval = (int32)temp;
-	}
-
-	temp = args[1] / _userData[532];
-	if (_userData[520] != temp) {
-		_userData[520] = temp;
-		op_sub1(temp);
-		retval = 1;
-	}
-
-	temp = args[2] / _userData[532];
-	if (_userData[521] != temp) {
-		_userData[521] = temp;
-		op_sub2(temp);
-		retval = 1;
-	}
-
-	return retval;
-}
-
-int32 LogicHErace::op_1102(int32 *args) {
-	// Update translation params?
-	int32 retval;
-	float temp;
-
-	temp = args[0] / _userData[532];
-	if (_userData[516] != temp) {
-		_userData[516] = temp;
-		retval = 1;
-	} else {
-		retval = (int32)_userData[532];
-	}
-
-	temp = args[1] / _userData[532];
-	if (_userData[517] != temp) {
-		_userData[517] = temp;
-		retval = 1;
-	}
-
-	temp = args[2] / _userData[532];
-	if (_userData[518] != temp) {
-		_userData[518] = temp;
-		retval = 1;
-	}
-
-	return retval;
-}
-
-int32 LogicHErace::op_1103(int32 *args) {
-	double angle = args[0] / args[1] * DEG2RAD;
-
-	writeScummVar(108, (int32)(sin(angle) * args[2]));
-	writeScummVar(109, (int32)(cos(angle) * args[2]));
-
-	return 1;
-}
-
-int32 LogicHErace::op_1110() {
-	writeScummVar(108, (int32)(_userData[526] * _userData[532] * _userData[532]));
-	writeScummVar(109, (int32)(_userData[527] * _userData[532] * _userData[532]));
-	writeScummVar(110, (int32)(_userData[532]));
-
-	return 1;
-}
-
-int32 LogicHErace::op_1120(int32 *args) {
-	double a0, a1, a2;
-	double b0, b1, b2;
-	double res1, res2;
-
-	a0 = args[0] / _userData[532] - _userData[516];
-	a1 = args[1] / _userData[532] - _userData[517];
-	a2 = args[2] / _userData[532] - _userData[518];
-
-	// Perform matrix multiplication (multiplying by a rotation matrix)
-	b2 = a2 * _userDataD[17] + a1 * _userDataD[14] + a0 * _userDataD[11];
-	b1 = a2 * _userDataD[16] + a1 * _userDataD[13] + a0 * _userDataD[10];
-	b0 = a2 * _userDataD[15] + a1 * _userDataD[12] + a0 * _userDataD[9];
-
-	res1 = (atan2(b0, b2) * RAD2DEG) / _userData[526];
-	res2 = (atan2(b1, b2) * RAD2DEG - _userData[528]) / _userData[527];
-
-	writeScummVar(108, (int32)res1);
-	writeScummVar(109, (int32)res2);
-
-	return 1;
-}
-
-int32 LogicHErace::op_1130(int32 *args) {
-	double cs = cos(args[0] / _userData[532] * DEG2RAD);
-	double sn = sin(args[0] / _userData[532] * DEG2RAD);
-
-	writeScummVar(108, (int32)(cs * args[1] + sn * args[2]));
-	writeScummVar(109, (int32)(cs * args[2] - sn * args[1]));
-
-	return 1;
-}
-
-int32 LogicHErace::op_1140(int32 *args) {
-	// This functions seems to perform some kind of projection: We project
-	// the vector (arg2,arg3) onto the vector (arg0,arg1), but also apply
-	// some kind of distortion factor ?!?
-	double x = args[2], y = args[3];
-
-	// We start by normalizing the vector described by arg2 and arg3.
-	// So compute its length and divide the x and y coordinates
-	const double sq = sqrt(x*x + y*y);
-	x /= sq;
-	y /= sq;
-
-	// Compute the scalar product of the vectors (arg0,arg1) and (x,y)
-	const double scalarProduct = x * args[0] + y * args[1];
-
-	// Finally compute the projection of (arg2,arg3) onto (arg0,arg1)
-	double projX = args[0] - 2 * scalarProduct * x;
-	double projY = args[1] - 2 * scalarProduct * y;
-
-	projX = projX * 20.0 / 23.0;	// FIXME: Why is this here?
-
-	writeScummVar(108, (int32)projX);
-
-	if (args[3] >= 0)	// FIXME: Why is this here?
-		projY = projY * 5.0 / 6.0;
-
-	writeScummVar(109, (int32)projY);
-
-	return 1;
-}
-
-void LogicHErace::op_sub1(float arg) {
-	// Setup a rotation matrix
-	_userDataD[10] = _userDataD[12] = _userDataD[14] = _userDataD[16] = 0;
-	_userDataD[13] = 1;
-
-	_userDataD[9] = cos(arg * DEG2RAD);
-	_userDataD[15] = sin(arg * DEG2RAD);
-	_userDataD[11] = -_userDataD[15];
-	_userDataD[17] = _userDataD[9];
-}
-
-void LogicHErace::op_sub2(float arg) {
-	// Setup a rotation matrix -- but it is NEVER USED!
-	_userDataD[20] = _userDataD[21] = _userDataD[24] = _userDataD[25] = 0;
-	_userDataD[26] = 1;
-
-	_userDataD[19] = sin(arg * DEG2RAD);
-	_userDataD[18] = cos(arg * DEG2RAD);
-	_userDataD[21] = -_userDataD[19];
-	_userDataD[22] = _userDataD[18];
-}
-
-void LogicHErace::op_sub3(float arg) {
-	// Setup a rotation matrix -- but it is NEVER USED!
-	_userDataD[1] = _userDataD[2] = _userDataD[3] = _userDataD[6] = 0;
-	_userDataD[0] = 1;
-
-	_userDataD[4] = cos(arg * DEG2RAD);
-	_userDataD[5] = sin(arg * DEG2RAD);
-	_userDataD[7] = -_userDataD[5];
-	_userDataD[8] = _userDataD[4];
-}
-
-/***********************
- * Freddi Fish's One-Stop Fun Shop
- * Pajama Sam's One-Stop Fun Shop
- * Putt-Putt's One-Stop Fun Shop
- *
- */
-
-int LogicHEfunshop::versionID() {
-	return 1;
-}
-
-int32 LogicHEfunshop::dispatch(int op, int numArgs, int32 *args) {
-	switch (op) {
-	case 1004:
-		op_1004(args);
-		break;
-
-	case 1005:
-		op_1005(args);
-		break;
-
-	default:
-		break;
-	}
-
-	return 0;
-}
-
-void LogicHEfunshop::op_1004(int32 *args) {
-	double data[8], at, sq;
-	int32 x, y;
-	int i=0;
-
-	for (i = 0; i <= 6; i += 2) {
-		data[i] = getFromArray(args[0], 0, 519 + i);
-		data[i + 1] = getFromArray(args[0], 0, 519 + i + 1);
-	}
-	int s = checkShape((int32)data[0], (int32)data[1], (int32)data[4], (int32)data[5],
-		(int32)data[2], (int32)data[3], (int32)data[6], (int32)data[7], &x, &y);
-
-	if (s != 1) {
-		error("LogicHEfunshop::op_1004: Your shape has defied the laws of physics");
-		return;
-	}
-
-	for (i = 0; i <= 6; i += 2) {
-		data[i] -= (double)x;
-		data[i + 1] -= (double)y;
-	}
-
-	double a1 = (double)args[1] * DEG2RAD;
-
-	for (i = 0; i <= 6; i += 2) {
-		at = atan2(data[i + 1], data[i]);
-		sq = sqrt(data[i + 1] * data[i + 1] + data[i] * data[i]);
-
-		if (at <= 0)
-			at += 2 * M_PI;
-
-		data[i] = cos(at + a1) * sq;
-		data[i + 1] = sin(at + a1) * sq;
-	}
-
-	double minx = data[0];
-	double miny = data[1];
-
-	for (i = 0; i <= 6; i += 2) {
-		if (data[i] < minx)
-			minx = data[i];
-		if (data[i + 1] < miny)
-			miny = data[i + 1];
-	}
-
-	for (i = 0; i <= 6; i += 2) {
-		data[i] -= minx;
-		data[i + 1] -= miny;
-
-		putInArray(args[0], 0, 519 + i, scumm_round(data[i]));
-		putInArray(args[0], 0, 519 + i + 1, scumm_round(data[i + 1]));
-	}
-}
-
-void LogicHEfunshop::op_1005(int32 *args) {
-	double data[8];
-	double args1, args2;
-	int i;
-	for (i = 520; i <= 526; i += 2) {
-		data[i - 520] = getFromArray(args[0], 0, i - 1);
-		data[i - 520 + 1] = getFromArray(args[0], 0, i);
-	}
-
-	args1 = (double)args[1] * 0.01 + 1;
-	args2 = (double)args[2] * 0.01 + 1;
-
-	for (i = 0; i < 4; i++) {
-		data[2 * i] *= args1;
-		data[2 * i + 1] *= args2;
-	}
-
-	for (i = 520; i <= 526; i += 2) {
-		putInArray(args[0], 0, i - 1, scumm_round(data[i - 520]));
-		putInArray(args[0], 0, i, scumm_round(data[i - 520 + 1]));
-	}
-}
-
-int LogicHEfunshop::checkShape(int32 data0, int32 data1, int32 data4, int32 data5, int32 data2, int32 data3, int32 data6, int32 data7, int32 *x, int32 *y) {
-	int32 diff5_1, diff0_4, diff7_3, diff2_6;
-	int32 diff1, diff2;
-	int32 delta, delta2;
-	int32 sum1, sum2;
-
-	diff0_4 = data0 - data4;
-	diff5_1 = data5 - data1;
-	diff1 = data1 * data4 - data0 * data5;
-	sum1 = diff0_4 * data3 + diff1 + diff5_1 * data2;
-	sum2 = diff0_4 * data7 + diff1 + diff5_1 * data6;
-
-	if (sum1 != 0 && sum2 != 0) {
-		sum2 ^= sum1;
-
-		if (sum2 >= 0)
-			return 0;
-	}
-
-	diff2_6 = data2 - data6;
-	diff7_3 = data7 - data3;
-	diff2 = data3 * data6 - data2 * data7;
-	sum1 = diff2_6 * data1 + diff2 + diff7_3 * data0;
-	sum2 = diff2_6 * data5 + diff2 + diff7_3 * data4;
-
-	if (sum1 != 0 && sum2 != 0) {
-		sum2 ^= sum1;
-
-		if (sum2 >= 0)
-			return 0;
-	}
-
-	delta = diff2_6 * diff5_1 - diff0_4 * diff7_3;
-
-	if (delta == 0) {
-		return 2;
-	}
-
-	if (delta < 0) {
-		data7 = -((delta + 1) >> 1);
-	} else {
-		data7 = delta >> 1;
-	}
-
-	delta2 = diff2 * diff0_4 - diff1 * diff2_6;
-
-	if (delta2 < 0) {
-		delta2 -= data7;
-	} else {
-		delta2 += data7;
-	}
-
-	*x = delta2 / delta;
-
-	delta2 = diff1 * diff7_3 - diff2 * diff5_1;
-
-	if (delta2 < 0) {
-		delta2 -= data7;
-	} else {
-		delta2 += data7;
-	}
-
-	*y = delta2 / delta;
-
-	return 1;
-}
-
-/***********************
- * Backyard Football
- * Backyard Football 2002
- * Backyard Football Demo
- *
- */
-
-int LogicHEfootball::versionID() {
-	return 1;
-}
-
-int32 LogicHEfootball::dispatch(int op, int numArgs, int32 *args) {
-	int res = 0;
-
-	switch (op) {
-	case 1004:
-		res = op_1004(args);
-		break;
-
-	case 1006:
-		res = op_1006(args);
-		break;
-
-	case 1007:
-		res = op_1007(args);
-		break;
-
-	case 1010:
-		res = op_1010(args);
-		break;
-
-	case 1022:
-		res = op_1022(args);
-		break;
-
-	case 1023:
-		res = op_1023(args);
-		break;
-
-	case 1024:
-		res = op_1024(args);
-		break;
-
-	case 8221968:
-		// Someone had a fun and used his birthday as opcode number
-		res = getFromArray(args[0], args[1], args[2]);
-		break;
-
-	case 1492: case 1493: case 1494: case 1495: case 1496:
-	case 1497: case 1498: case 1499: case 1500: case 1501:
-	case 1502: case 1503: case 1504: case 1505: case 1506:
-	case 1507: case 1508: case 1509: case 1510: case 1511:
-	case 1512: case 1513: case 1514: case 1555:
-		// DirectPlay-related
-		// 1513: initialize
-		// 1555: set fake lag
-		break;
-
-	case 2200: case 2201: case 2202: case 2203: case 2204:
-	case 2205: case 2206: case 2207: case 2208: case 2209:
-	case 2210: case 2211: case 2212: case 2213: case 2214:
-	case 2215: case 2216: case 2217: case 2218: case 2219:
-	case 2220: case 2221: case 2222: case 2223: case 2224:
-	case 2225: case 2226: case 2227: case 2228:
-		// Boneyards-related
-		break;
-
-	case 3000: case 3001: case 3002: case 3003: case 3004:
-		// Internet-related
-		// 3000: check for updates
-		// 3001: check network status
-		// 3002: autoupdate
-		// 3003: close connection
-		break;
-
-	default:
-		LogicHE::dispatch(op, numArgs, args);
-		warning("Tell sev how to reproduce it (%d)", op);
-	}
-
-	return res;
-}
-
-int LogicHEfootball::op_1004(int32 *args) {
-	// Identical to LogicHEsoccer::op_1004
-	double res, a2, a4, a5;
-
-	a5 = ((double)args[4] - (double)args[1]) / ((double)args[5] - (double)args[2]);
-	a4 = ((double)args[3] - (double)args[0]) / ((double)args[5] - (double)args[2]);
-	a2 = (double)args[2] - (double)args[0] * a4 - args[1] * a5;
-
-	res = (double)args[6] * a4 + (double)args[7] * a5 + a2;
-	writeScummVar(108, (int32)res);
-
-	writeScummVar(109, (int32)a2);
-	writeScummVar(110, (int32)a5);
-	writeScummVar(111, (int32)a4);
-
-	return 1;
-}
-
-int LogicHEfootball::op_1006(int32 *args) {
-	// This seems to be more or less the inverse of op_1010
-	const double a1 = args[1];
-	double res;
-
-	// 2.9411764e-4 = 1/3400
-	// 5.3050399e-2 = 1/18.85 = 20/377
-	// 1.1764706e-2 = 1/85 = 40/3400
-	// 1.2360656e-1 = 377/3050
-	res = (1.0 - a1 * 2.9411764e-4 * 5.3050399e-2) * 1.2360656e-1 * args[0] +
-		a1 * 1.1764706e-2 + 46;
-
-	// Shortened / optimized version of that formula:
-	// res = (377.0 - a1 / 170.0) / 3050.0 * args[0] + a1 / 85.0 + 46;
-
-	writeScummVar(108, (int32)res);
-
-	// 1.2360656e-1 = 377/3050
-	// 1.1588235e-1 = 197/1700 = 394/3400
-	res = 640.0 - args[2] * 1.2360656e-1 - a1 * 1.1588235e-1 - 26;
-
-	writeScummVar(109, (int32)res);
-
-	return 1;
-}
-
-int LogicHEfootball::op_1007(int32 *args) {
-	double res, temp;
-
-	temp = (double)args[1] * 0.32;
-
-	if (temp > 304.0)
-		res = -args[2] * 0.142;
-	else
-		res = args[2] * 0.142;
-
-	res += temp;
-
-	writeScummVar(108, (int32)res);
-
-	res = (1000.0 - args[2]) * 0.48;
-
-	writeScummVar(109, (int32)res);
-
-	return 1;
-}
-
-int LogicHEfootball::op_1010(int32 *args) {
-	// This seems to be more or less the inverse of op_1006
-	double a1 = (640.0 - (double)args[1] - 26.0) / 1.1588235e-1;
-
-	// 2.9411764e-4 = 1/3400
-	// 5.3050399e-2 = 1/18.85 = 20/377
-	// 1.1764706e-2 = 1/85 = 40/3400
-	// 1.2360656e-1 = 377/3050
-	double a0 = ((double)args[0] - 46 - a1 * 1.1764706e-2) /
-		((1.0 - a1 * 2.9411764e-4 * 5.3050399e-2) * 1.2360656e-1);
-
-	writeScummVar(108, (int32)a0);
-	writeScummVar(109, (int32)a1);
-
-	return 1;
-}
-
-int LogicHEfootball::op_1022(int32 *args) {
-	double res;
-	double var10 = args[4] - args[1];
-	double var8 = args[5] - args[2];
-	double var6 = args[3] - args[0];
-
-	res = sqrt(var8 * var8 + var6 * var6 + var10 * var10);
-
-	if (res >= (double)args[6]) {
-		var8 = (double)args[6] * var8 / res;
-		var10 = (double)args[6] * var10 / res;
-		res = (double)args[6] * var6 / res;
-	}
-
-	writeScummVar(108, (int32)res);
-	writeScummVar(109, (int32)var10);
-	writeScummVar(110, (int32)var8);
-
-	return 1;
-}
-
-int LogicHEfootball::op_1023(int32 *args) {
-	double var10, var18, var20, var28, var30, var30_;
-	double argf[7];
-
-	for (int i = 0; i < 7; i++)
-		argf[i] = args[i];
-
-	var10 = (argf[3] - argf[1]) / (argf[2] - argf[0]);
-	var28 = var10 * var10 + 1;
-	var20 = argf[0] * var10;
-	var18 = (argf[5] + argf[1] + var20) * argf[4] * var10 * 2 +
-		argf[6] * argf[6] * var28 + argf[4] * argf[4] -
-		argf[0] * argf[0] * var10 * var10 -
-		argf[5] * argf[0] * var10 * 2 -
-		argf[5] * argf[1] * 2 -
-		argf[1] * argf[1] - argf[5] * argf[5];
-
-	if (var18 >= 0) {
-		var18 = sqrt(var18);
-
-		var30_ = argf[4] + argf[5] * var10 + argf[1] * var10 + argf[0] * var10 * var10;
-		var30 = (var30_ - var18) / var28;
-		var18 = (var30_ + var18) / var28;
-
-		if ((argf[0] - var30 < 0) && (argf[0] - var18 < 0)) {
-			var30_ = var30;
-			var30 = var18;
-			var18 = var30_;
-		}
-		var28 = var18 * var10 - var20 - argf[1];
-		var20 = var30 * var10 - var20 - argf[1];
-	} else {
-		var18 = 0;
-		var20 = 0;
-		var28 = 0;
-		var30 = 0;
-	}
-
-	writeScummVar(108, (int32)var18);
-	writeScummVar(109, (int32)var28);
-	writeScummVar(110, (int32)var30);
-	writeScummVar(111, (int32)var20);
-
-	return 1;
-}
-int LogicHEfootball::op_1024(int32 *args) {
-	writeScummVar(108, 0);
-	writeScummVar(109, 0);
-	writeScummVar(110, 0);
-	writeScummVar(111, 0);
-
-	return 1;
-}
-
-
-/***********************
- * Backyard Soccer
- *
- */
-
-int LogicHEsoccer::versionID() {
-	return 1;
-}
-
-LogicHEsoccer::LogicHEsoccer(ScummEngine_v90he *vm) : LogicHE(vm) {
-	_userDataD = (double *)calloc(1732, sizeof(double));
-	_intArray1 = 0;
-	_intArray2 = 0;
-	_intArraysAllocated = false;
-	_array1013 = 0;
-	_array1013Allocated = false;
-}
-
-LogicHEsoccer::~LogicHEsoccer() {
-	free(_userDataD);
-	op_1020(); // clear int arrays
-	delete[] _array1013;
-}
-
-int32 LogicHEsoccer::dispatch(int op, int numArgs, int32 *args) {
-	int res = 0;
-
-	switch (op) {
-	case 1001:
-		res = op_1001(args);
-		break;
-
-	case 1002:
-		res = op_1002(args);
-		break;
-
-	case 1004:
-		res = op_1004(args);
-		break;
-
-	case 1006:
-		res = op_1006(args[0], args[1], args[2], args[3]);
-		break;
-
-	case 1011:
-		// args[4] is ignored!
-		// soccer passes the argument, but then ends up not using it
-		// Makes sense that they removed it for soccermls
-		res = op_1011(args[0], args[1], args[2], args[3], args[5]);
-		break;
-
-	case 1012:
-		res = op_1012(args);
-		break;
-
-	case 1013:
-		res = op_1013(args[0], args[1], args[2]);
-		break;
-
-	case 1019:
-		res = op_1019(args);
-		break;
-
-	case 1020:
-		res = op_1020();
-		break;
-
-	case 1021:
-		res = op_1021(args[0], args[1], args[2], args[3], args[4], args[5], args[6]);
-		break;
-
-	case 8221968:
-		// Someone had a fun and used his birthday as opcode number
-		res = getFromArray(args[0], args[1], args[2]);
-		break;
-
-	default:
-		// original range is 1001 - 1021
-		LogicHE::dispatch(op, numArgs, args);
-	}
-
-	return res;
-}
-
-void LogicHEsoccer::beforeBootScript() {
-	if (_intArraysAllocated)
-		op_1020();
-
-	_userDataD[530] = 0;
-}
-
-void LogicHEsoccer::initOnce() {
-	// The original sets some paths here that we don't need to worry about
-	_array1013Allocated = false;
-	_userDataD[530] = 0;
-}
-
-int LogicHEsoccer::startOfFrame() {
-	// This variable is some sort of flag that activates this mode
-	int res = (int)_userDataD[530];
-
-	// _userDataD[535] is not used!
-	// soccer passes the argument, but then ends up not using it
-	// Makes sense that they removed it for soccermls
-	if (res)
-		res = op_1011((int)_userDataD[531], (int)_userDataD[532], (int)_userDataD[533], (int)_userDataD[534], (int)_userDataD[536]);
-
-	return res;
-}
-
-int LogicHEsoccer::op_1001(int32 *args) {
-	return (int)(args[0] * sin((float)args[1]));
-}
-
-int LogicHEsoccer::op_1002(int32 *args) {
-	return _vm->VAR(2) * args[0];
-}
-
-int LogicHEsoccer::op_1003(int32 *args) {
-	double data[6], out[3];
-	int i;
-
-	for (i = 0; i < 6; i++) {
-		data[i] = getFromArray(args[0], 0, i);
-	}
-
-	out[0] = data[1] * data[5] - data[4] * data[2];
-	out[1] = data[5] * data[0] - data[3] * data[2];
-	out[2] = data[4] * data[0] - data[3] * data[1];
-
-	for (i = 0; i < 3; i++) {
-		putInArray(args[0], 0, i, scumm_round(out[i]));
-	}
-
-	return 1;
-}
-
-int LogicHEsoccer::op_1004(int32 *args) {
-	// Identical to LogicHEfootball::op_1004
-	double res, a2, a4, a5;
-
-	a5 = ((double)args[4] - (double)args[1]) / ((double)args[5] - (double)args[2]);
-	a4 = ((double)args[3] - (double)args[0]) / ((double)args[5] - (double)args[2]);
-	a2 = (double)args[2] - (double)args[0] * a4 - args[1] * a5;
-
-	res = (double)args[6] * a4 + (double)args[7] * a5 + a2;
-	writeScummVar(108, (int32)res);
-
-	writeScummVar(109, (int32)a2);
-	writeScummVar(110, (int32)a5);
-	writeScummVar(111, (int32)a4);
-
-	return 1;
-}
-
-int LogicHEsoccer::op_1006(int32 a1, int32 a2, int32 a3, int32 a4) {
-	double v1 = a1 * 0.01;
-	double v2 = a2 * 0.01;
-	double v3 = a3 * 0.01;
-	double var108, var109;
-
-	_userDataD[529] = a4;
-
-	var108 = atan2(v1, v3) * _userDataD[523] - a4;
-	var109 = _userDataD[526] - _userDataD[528] + (_userDataD[521] - atan2(_userDataD[524] - v2, v3)) * _userDataD[522];
-
-	writeScummVar(108, (int32)var108);
-	writeScummVar(109, (int32)var109);
-
-	return 1;
-}
-
-int LogicHEsoccer::op_1007(int32 *args) {
-	// Used when the HE logo is shown
-	// This initializes the _userDataD fields that are used in op_1006/op_1011
-
-	_intArraysAllocated = false;
-	double v14 = (double)args[0] * 0.01;
-	double v13 = (double)args[2] * 0.01;
-	_userDataD[524] = v14;
-	double v12 = atan2(v13, v14);
-	_userDataD[520] = v12;
-	double v15 = atan2(v13 - (double)args[4] * 0.01, (double)args[3] * 0.01);
-	double v19 = v15 * 2.0;
-	double v17 = atan2(v13 - (double)args[4] * 0.01, v14);
-	_userDataD[519] = v19;
-	_userDataD[521] = v17;
-	_userDataD[525] = (v17 - v12) * 2.0;
-	_userDataD[527] = (double)args[5];
-	_userDataD[526] = (double)args[6];
-	_userDataD[528] = (double)args[7];
-	_userDataD[522] = _userDataD[526] / _userDataD[525];
-	_userDataD[523] = _userDataD[527] / _userDataD[519];
-	_userDataD[518] = v13;
-
-	// Clear both byte arrays
-	memset(_byteArray1, 0, 4096);
-	memset(_byteArray2, 0, 585);
-
-	if (_array1013Allocated == 0 )
-		op_1013(4, args[8], args[9]);
-
-	return 1;
-}
-
-// Returns the square root of the sum of the squares of the arguments
-static inline double sqrtSquare(double a1, double a2, double a3) {
-	return sqrt(a1 * a1 + a2 * a2 + a3 * a3);
-}
-
-int LogicHEsoccer::op_1008(int32 *args) {
-	// TODO: Used during a match (kicking?)
-
-	return 1;
-}
-
-int LogicHEsoccer::op_1011(int32 a1, int32 a2, int32 a3, int32 a4, int32 a5) {
-	// This is called on each frame by startOfFrame() if activated by op_1012.
-	// This seems to do player placement!
-
-	float v28 = 0.0;
-
-	for (int i = 0; i < 18; i++) {
-		// These seem to be some sort of percent? of angles?
-		int v32 = getFromArray(a1, i, 0);
-		int v6 = getFromArray(a1, i, 1);
-		int v30 = getFromArray(a1, i, 2);
-
-		float v29 = (double)v32 / 100.0;
-		v28 = (double)v6 / 100.0;
-		float v31 = (double)v30 / 100.0;
-
-		if (i < 13) {
-			int v25 = ((v32 + 2760) / 500 >= 0) ? ((v32 + 2750) / 500) : 0;
-			int v24 = 10;
-
-			if (v25 <= 10) {
-				int v23 = 0;
-				if ((v32 + 2750) / 500 >= 0)
-					v23 = (v32 + 2750) / 500;
-
-				v24 = v23;
-			}
-
-			int v22 = 0;
-			if ((9219 - v30) / 500 >= 0)
-				v22 = (9219 - v30) / 500;
-
-			int v21 = 6;
-			if (v22 <= 6) {
-				int v20 = 0;
-				if ((9219 - v30) / 500 >= 0)
-					v20 = (9219 - v30) / 500;
-				v21 = v20;
-			}
-
-			if (a5)
-				putInArray(a5, 0, i, v24 + 11 * v21);
-		}
-
-		float v7 = atan2(_userDataD[524] - v28, (double)v31);
-		int v8 = (int)(_userDataD[526] - (_userDataD[521] - v7) * _userDataD[522] + 300.0);
-
-		double v9 = atan2(_userDataD[523], (double)v31);
-		// x/y position?
-		putInArray(a2, i, 0, (int32)(v29 * v9 + 640.0));
-		putInArray(a2, i, 1, v8);
-
-		double v10 = atan2(_userDataD[524], (double)v31);
-		int v12 = (int)(_userDataD[526] - (_userDataD[521] - (float)v10) * _userDataD[522] + 300.0);
-		double v13 = _userDataD[523];
-
-		v29 = atan2(v29, v31);
-		// x/y position?
-		putInArray(a2, i + 22, 0, (int32)(v29 * v13 + 640.0));
-		putInArray(a2, i + 22, 1, v12);
-	}
-
-	// soccer only uses one array here
-	// soccermls/soccer2004 use four
-	int start = (_vm->_game.id == GID_SOCCER) ? 19 : 18;
-	int end = (_vm->_game.id == GID_SOCCER) ? 19 : 21;
-
-	for (int i = start; i <= end; i++) {
-		int v14 = getFromArray(a2, i, 0);
-		int v15 = getFromArray(a2, i, 1);
-
-		// This retains v28 from (i == 17)?
-		float v16 = _userDataD[524] - v28;
-		float v17 = v16 / tan((_userDataD[528] + v15 - _userDataD[526]) / (_userDataD[522] + _userDataD[521]));
-		double v18 = tan((double)(v14 - 640) / _userDataD[523]) * v17;
-		putInArray(a1, i, 0, (int)(v18 * 100.0));
-		putInArray(a1, i, 2, (int)(v17 * 100.0));
-	}
-
-	op_1011_sub(a1, a3, a4, a4);
-
-	return 1;
-}
-
-static inline int distance(int a1, int a2, int a3, int a4) {
-	return (int)sqrt((double)((a4 - a3) * (a4 - a3) + (a2 - a1) * (a2 - a1)));
-}
-
-void LogicHEsoccer::op_1011_sub(int32 a1, int32 a2, int32 a3, int32 a4) {
-	// As you can guess, this is called from op_1011
-	// This seems to be checking distances between the players and the ball
-	// and which distance is the shortest.
-
-	int v6[13];
-	int v7[13];
-	int v8[13];
-	int v18[195];
-
-	for (int i = 0; i < 13; i++) {
-		v6[i] = 0;
-		v7[i] = getFromArray(a1, i, 0);
-		v8[i] = getFromArray(a1, i, 2);
-	}
-
-	// 12 here, 13 up there
-	// Probably 12 for players, 13 for players+ball
-	for (int i = 0; i < 12; i++) {
-		int v22 = a4;
-		for (int j = i + 1; j < 13; j++) {
-			v18[i * 15 + j] = distance(v7[i], v7[j], v8[i], v8[j]);
-			putInArray(a2, i, j, v18[i * 15 + j]);
-			putInArray(a2, j, i, v18[i * 15 + j]);
-			if (v18[i * 15 + j] < v22) {
-				v22 = v18[i * 15 + j];
-				v6[i] = j + 1;
-				v6[j] = i + 1;
-			}
-		}
-	}
-
-	int v13 = getFromArray(a1, 18, 0);
-	int v14 = getFromArray(a1, 18, 2);
-	int v15 = getFromArray(a1, 19, 0);
-	int v16 = getFromArray(a1, 19, 2);
-	int v19[15];
-	int v20[15];
-
-	if (_vm->_game.id == GID_SOCCER) {
-		// soccer gets to be different
-		for (int i = 0; i < 13; i++)
-			v20[i] = distance(v13, v7[i], v14, v8[i]);
-
-		for (int i = 0; i < 13; i++)
-			v19[i] = distance(v15, v7[i], v16, v8[i]);
-	} else {
-		// soccermls and soccer2004 use two other arrays here
-		int v9 = getFromArray(a1, 20, 0);
-		int v10 = getFromArray(a1, 20, 2);
-		int v11 = getFromArray(a1, 21, 0);
-		int v12 = getFromArray(a1, 21, 2);
-
-		for (int i = 0; i < 6; i++) {
-			v20[i] = distance(v9, v7[i], v10, v8[i]);
-			v19[i] = distance(v13, v7[i], v14, v8[i]);
-		}
-
-		for (int i = 6; i < 13; i++) {
-			v20[i] = distance(v11, v7[i], v12, v8[i]);
-			v19[i] = distance(v15, v7[i], v16, v8[i]);
-		}
-	}
-
-	for (int i = 0; i < 13; i++) {
-		putInArray(a2, 14, i, v20[i]);
-		putInArray(a2, i, 14, v20[i]);
-		putInArray(a2, 13, i, v19[i]);
-		putInArray(a2, i, 13, v19[i]);
-		putInArray(a3, 0, i, v6[i]);
-	}
-}
-
-int LogicHEsoccer::op_1012(int32 *args) {
-	// Used after op_1019
-	// This function activates startOfFrame() to call op_1011
-	// (Possibly field parameters?)
-
-	_userDataD[530] = (args[0] != 0) ? 1 : 0;
-	_userDataD[531] = args[1];
-	_userDataD[532] = args[2];
-	_userDataD[533] = args[3];
-	_userDataD[534] = args[4];
-	_userDataD[535] = args[5]; // unused!!!
-	_userDataD[536] = args[6];
-
-	return 1;
-}
-
-// Some strange power operation, ignores negative exponents
-static inline double u32Pow(float a1, int a2) {
-	if (a2 < 0)
-		return 0.0;
+LogicHE *LogicHE::makeLogicHE(ScummEngine_v90he *vm) {
+	switch (vm->_game.id) {
+	case GID_PUTTRACE:
+		return makeLogicHErace(vm);
 
-	float v4 = 1.0;
+	case GID_FUNSHOP:
+		return makeLogicHEfunshop(vm);
 
-	for (int i = 1; i <= a2; i++)
-		v4 *= a1;
+	case GID_FOOTBALL:
+		return makeLogicHEfootball(vm);
 
-	return v4;
-}
+	case GID_SOCCER:
+	case GID_SOCCERMLS:
+	case GID_SOCCER2004:
+		return makeLogicHEsoccer(vm);
 
-int LogicHEsoccer::op_sub5(int a1, int a2, int a3) {
-	byte *v9 = _array1013 + 44 * a2;
+	case GID_BASEBALL2001:
+		return makeLogicHEbaseball2001(vm);
 
-	*((uint32 *)v9 + 4) = a3;
-	*((uint32 *)v9) = a2;
+	case GID_BASKETBALL:
+		return makeLogicHEbasketball(vm);
 
-	if (a1 > 2) {
-		// Casual observation: 585 is also the size of _byteArray2
-		*((uint32 *)v9 + 40) = 8 * a2 - 585;
-		for (int i = 0; i < 8; i++)
-			*((uint32 *)v9 + 4 * i + 8) = 0xffffffff;
-	} else {
-		for (int i = 0; i < 8; i++)
-			*((uint32 *)v9 + 4 * i + 8) = op_sub5(a1 + 1, i + 8 * a2 + 1, a2);
-	}
-
-	return a2;
-}
-
-int LogicHEsoccer::op_1013(int32 a1, int32 a2, int32 a3) {
-	// Creates _array1013 for *some* purpose
-	// _array1013Temp is used again op_1014 for some reason...
-	// Seems to be used in op_1015
-
-	int v4 = (int)((1.0 - u32Pow(8.0, 4)) / -7.0);
-
-	_array1013 = new byte[v4 * 44];
-	memset(_array1013, 0, v4 * 44);
-	_array1013Allocated = true;
-	memset(_array1013Temp, 0, 44);
-
-	for (int i = 0; i < 8; i++)
-		_array1013Temp[i + 2] = op_sub5(1, i + 1, 0);
-
-	// Yes, this is not endian-safe, but should not matter since we're
-	// not saving/loading the data anywhere
-	memcpy(_array1013, _array1013Temp, 44);
-
-	return 1;
-}
-
-int LogicHEsoccer::op_1014(int32 a1, int32 a2, int32 a3, int32 a4, int32 a5, int32 a6, int32 a7, int32 a8, int32 a9, int32 a10, int32 a11, int32 a12, int32 a13, int32 a14) {
-	// TODO: Used many times during a match
-	// And called from op_1008!
-
-	return 1;
-}
-
-int LogicHEsoccer::op_1019(int32 *args) {
-	// Used at the beginning of a match
-	// Initializes some arrays. Player positions?
-
-	// These two arrays are used in op_1014 and op_1015
-	for (int i = 0; i < 4096; i++)
-		_byteArray1[i] = getFromArray(args[1], 0, i);
-
-	for (int i = 0; i < 585; i++)
-		_byteArray2[i] = getFromArray(args[0], 0, i);
-
-	// Deallocate the two integer arrays
-	if (_intArraysAllocated)
-		op_1020();
-
-	// Reallocate them
-	_intArray1 = new uint32[1008];
-	_intArray2 = new uint32[168];
-	_intArraysAllocated = true;
-
-	memset(_intArray1, 0, 4 * 4);
-	memset(_intArray2, 0, 24 * 4);
-
-	// These two arrays are used in op_1015
-	for (int i = 0; i < 42; i++) {
-		for (int j = 0; j < 24; j++)
-			_intArray1[j + 24 * i] = getFromArray(args[3], 0, j + 24 * i);
-
-		for (int j = 0; j < 4; j++)
-			_intArray2[j + 4 * i] = getFromArray(args[2], 0, j + 4 * i);
-	}
-
-	return 1;
-}
-
-int LogicHEsoccer::op_1020() {
-	// Deallocate integer arrays
-	// The arrays can be allocated in op_1015 or op_1019
-
-	delete[] _intArray1; _intArray1 = 0;
-	delete[] _intArray2; _intArray2 = 0;
-	_intArraysAllocated = false;
-
-	return 1;
-}
-
-int LogicHEsoccer::op_1021(int32 a1, int32 a2, int32 a3, int32 a4, int32 a5, int32 a6, int32 a7) {
-	// Used during a match (ball movement?)
-	// Also called from op_1008
-
-	int v10;
-	if (a4 && a5)
-		v10 = (int)(((double)a2 - (double)a5 * (double)a1 / (double)a4) * -1.0 * (double)a4 / (double)a5);
-	else
-		v10 = a1;
-
-	int v9;
-	if (a6 && a5)
-		v9 = (int)(((double)a2 - (double)a5 * (double)a3 / (double)a6) * -1.0 * (double)a6 / (double)a5);
-	else
-		v9 = a3;
-
-	// The final argument chooses whether to store the results for op_1008 or
-	// store them in SCUMM variables.
-	if (a7) {
-		_var1021[0] = v10;
-		_var1021[1] = v9;
-	} else {
-		writeScummVar(108, v10);
-		writeScummVar(109, v9);
-	}
-
-	return 1;
-}
-
-/***********************
- * Backyard Baseball 2001
- *
- */
-
-int LogicHEbaseball2001::versionID() {
-	return 1;
-}
-
-int32 LogicHEbaseball2001::dispatch(int op, int numArgs, int32 *args) {
-	int res = 0;
-
-	switch (op) {
-	case 3001:
-		// Check network status
-		break;
-
-	default:
-		LogicHE::dispatch(op, numArgs, args);
-	}
-
-	return res;
-}
-
-/***********************
- * Backyard Basketball
- *
- */
-
-int LogicHEbasketball::versionID() {
-	return 1;
-}
-
-int32 LogicHEbasketball::dispatch(int op, int numArgs, int32 *args) {
-	int res = 0;
-
-	switch (op) {
-	case 1001:
-		break;
-
-	case 1006:
-		break;
-
-	case 1011:
-		break;
-
-	case 1012:
-		break;
-
-	case 1035:
-		break;
-
-	case 1050:
-		break;
-
-	case 1051:
-		break;
-
-	case 1052:
-		break;
-
-	case 1056:
-		break;
-
-	case 1057:
-		break;
-
-	case 1058:
-		break;
-
-	case 1060:
-		break;
-
-	case 1064:
-		break;
-
-	case 1067:
-		break;
-
-	case 1073:
-		break;
-
-	case 1075:
-		break;
-
-	case 1076:
-		break;
-
-	case 1080:
-		break;
-
-	case 1081:
-		break;
-
-	case 1090:
-		break;
-
-	case 1091:
-		break;
-
-	case 1513:
-		break;
+	case GID_MOONBASE:
+		return makeLogicHEmoonbase(vm);
 
 	default:
-		LogicHE::dispatch(op, numArgs, args);
+		return new LogicHE(vm);
 	}
-
-	return res;
-}
-
-/***********************
- * Moonbase Commander
- *
- */
-
-int LogicHEmoonbase::versionID() {
-	if (_vm->_game.features & GF_DEMO)
-		return -100;
-	else
-		return 100;
 }
 
 } // End of namespace Scumm
diff --git a/engines/scumm/he/logic_he.h b/engines/scumm/he/logic_he.h
index e05a05f310..893dc81b87 100644
--- a/engines/scumm/he/logic_he.h
+++ b/engines/scumm/he/logic_he.h
@@ -29,15 +29,10 @@ class ScummEngine_v90he;
 
 class LogicHE {
 public:
-	ScummEngine_v90he *_vm;
+	static LogicHE *makeLogicHE(ScummEngine_v90he *vm);
 
-	LogicHE(ScummEngine_v90he *vm);
 	virtual ~LogicHE();
 
-	void writeScummVar(int var, int32 value);
-	int getFromArray(int arg0, int idx2, int idx1);
-	void putInArray(int arg0, int idx2, int idx1, int val);
-
 	virtual void beforeBootScript() {}
 	virtual void initOnce() {}
 	virtual int startOfFrame() { return 1; }
@@ -46,142 +41,30 @@ public:
 
 	virtual int versionID();
 	virtual int32 dispatch(int op, int numArgs, int32 *args);
-};
 
-class LogicHErace : public LogicHE {
-private:
-	float *_userData;
-	double *_userDataD;
-public:
-	LogicHErace(ScummEngine_v90he *vm);
-	~LogicHErace();
-
-	int versionID();
-	int32 dispatch(int op, int numArgs, int32 *args);
-
-private:
-	int32 op_1003(int32 *args);
-	int32 op_1004(int32 *args);
-	int32 op_1100(int32 *args);
-	int32 op_1101(int32 *args);
-	int32 op_1102(int32 *args);
-	int32 op_1103(int32 *args);
-	int32 op_1110();
-	int32 op_1120(int32 *args);
-	int32 op_1130(int32 *args);
-	int32 op_1140(int32 *args);
-
-	void op_sub1(float arg);
-	void op_sub2(float arg);
-	void op_sub3(float arg);
-};
-
-class LogicHEfunshop : public LogicHE {
-public:
-	LogicHEfunshop(ScummEngine_v90he *vm) : LogicHE(vm) {}
-
-	int versionID();
-	int32 dispatch(int op, int numArgs, int32 *args);
-
-private:
-	void op_1004(int32 *args);
-	void op_1005(int32 *args);
-	int checkShape(int32 data0, int32 data1, int32 data4, int32 data5, int32 data2, int32 data3, int32 data6, int32 data7, int32 *x, int32 *y);
-};
-
-class LogicHEfootball : public LogicHE {
-public:
-	LogicHEfootball(ScummEngine_v90he *vm) : LogicHE(vm) {}
-
-	int versionID();
-	int32 dispatch(int op, int numArgs, int32 *args);
-
-private:
-	int op_1004(int32 *args);
-	int op_1006(int32 *args);
-	int op_1007(int32 *args);
-	int op_1010(int32 *args);
-	int op_1022(int32 *args);
-	int op_1023(int32 *args);
-	int op_1024(int32 *args);
-};
-
-class LogicHEsoccer : public LogicHE {
-private:
-	double *_userDataD;
-
-public:
-	LogicHEsoccer(ScummEngine_v90he *vm);
-	~LogicHEsoccer();
-
-	int versionID();
-	int32 dispatch(int op, int numArgs, int32 *args);
-
-	void beforeBootScript();
-	void initOnce();
-	int startOfFrame();
-
-private:
-	int op_1001(int32 *args);
-	int op_1002(int32 *args);
-	int op_1003(int32 *args);
-	int op_1004(int32 *args);
-	int op_1006(int32 a1, int32 a2, int32 a3, int32 a4);
-	int op_1007(int32 *args);
-	int op_1008(int32 *args);
-	int op_1011(int32 a1, int32 a2, int32 a3, int32 a4, int32 a5);
-	int op_1012(int32 *args);
-	int op_1013(int32 a1, int32 a2, int32 a3);
-	int op_1014(int32 a1, int32 a2, int32 a3, int32 a4, int32 a5, int32 a6, int32 a7, int32 a8, int32 a9, int32 a10, int32 a11, int32 a12, int32 a13, int32 a14);
-	int op_1019(int32 *args);
-	int op_1020();
-	int op_1021(int32 a1, int32 a2, int32 a3, int32 a4, int32 a5, int32 a6, int32 a7);
-
-	// Two integer arrays are used between some functions
-	// Originally, these pointers were in _userData, but we keep them separate
-	// Also, doing it that would break things on non 32-bit systems...
-	bool _intArraysAllocated;
-	uint32 *_intArray1, *_intArray2;
-
-	// op_1007 allocates some arrays
-	// they're then filled by op_1019
-	byte _byteArray1[4096], _byteArray2[585];
-
-	// op_1011 has a subfunction
-	void op_1011_sub(int32 a1, int32 a2, int32 a3, int32 a4);
-
-	// op_1013 creates some array, purpose unknown
-	bool _array1013Allocated;
-	byte *_array1013;
-	uint32 _array1013Temp[11];
-	int op_sub5(int a1, int a2, int a3);
-
-	// op_1021 can (optionally) set two variables for use in op_1008
-	uint32 _var1021[2];
-};
-
-class LogicHEbaseball2001 : public LogicHE {
-public:
-	LogicHEbaseball2001(ScummEngine_v90he *vm) : LogicHE(vm) {}
+protected:
+	// Only to be used from makeLogicHE()
+	LogicHE(ScummEngine_v90he *vm);
 
-	int versionID();
-	int32 dispatch(int op, int numArgs, int32 *args);
-};
+	ScummEngine_v90he *_vm;
 
-class LogicHEbasketball : public LogicHE {
-public:
-	LogicHEbasketball(ScummEngine_v90he *vm) : LogicHE(vm) {}
+	void writeScummVar(int var, int32 value);
+	int getFromArray(int arg0, int idx2, int idx1);
+	void putInArray(int arg0, int idx2, int idx1, int val);
+	int32 scummRound(double arg) { return (int32)(arg + 0.5); }
 
-	int versionID();
-	int32 dispatch(int op, int numArgs, int32 *args);
+	#define RAD2DEG (180 / M_PI)
+	#define DEG2RAD (M_PI / 180)
 };
 
-class LogicHEmoonbase : public LogicHE {
-public:
-	LogicHEmoonbase(ScummEngine_v90he *vm) : LogicHE(vm) {}
-
-	int versionID();
-};
+// Logic declarations
+LogicHE *makeLogicHErace(ScummEngine_v90he *vm);
+LogicHE *makeLogicHEfunshop(ScummEngine_v90he *vm);
+LogicHE *makeLogicHEfootball(ScummEngine_v90he *vm);
+LogicHE *makeLogicHEsoccer(ScummEngine_v90he *vm);
+LogicHE *makeLogicHEbaseball2001(ScummEngine_v90he *vm);
+LogicHE *makeLogicHEbasketball(ScummEngine_v90he *vm);
+LogicHE *makeLogicHEmoonbase(ScummEngine_v90he *vm);
 
 } // End of namespace Scumm
 
diff --git a/engines/scumm/he/script_v100he.cpp b/engines/scumm/he/script_v100he.cpp
index 5a9172ff8a..56ea10f507 100644
--- a/engines/scumm/he/script_v100he.cpp
+++ b/engines/scumm/he/script_v100he.cpp
@@ -542,7 +542,7 @@ void ScummEngine_v100he::o100_arrayOps() {
 	int dim1end, dim1start, dim2end, dim2start;
 	int id, len, b, c, list[128];
 	int offs, tmp, tmp2;
-	uint tmp3;
+	uint tmp3, type;
 
 	byte subOp = fetchScriptByte();
 	int array = fetchScriptWord();
@@ -625,11 +625,10 @@ void ScummEngine_v100he::o100_arrayOps() {
 		}
 		break;
 	case 132:
-		debug(0, "o100_arrayOps: case 132");
-		// TODO: Used by Moonbase Commander
+		// TODO: Used by room 2 script 2180 in Moonbase Commander
 		fetchScriptWord();
 		fetchScriptWord();
-		pop();
+		type = pop();
 		pop();
 		pop();
 		pop();
@@ -646,6 +645,21 @@ void ScummEngine_v100he::o100_arrayOps() {
 		if (id == 0) {
 			defineArray(array, kDwordArray, dim2start, dim2end, dim1start, dim1end);
 		}
+		switch (type) {
+		case 1:
+			break;
+		case 2:
+			break;
+		case 3:
+			break;
+		case 4:
+			break;
+		case 5:
+			break;
+		default:
+			error("o100_arrayOps: case 132 unknown type %d)", type);
+		}
+		debug(0, "o100_arrayOps: case 132 type %d", type);
 		break;
 	case 133:
 		b = pop();
diff --git a/engines/scumm/he/script_v72he.cpp b/engines/scumm/he/script_v72he.cpp
index 5af4035930..b9f454de0f 100644
--- a/engines/scumm/he/script_v72he.cpp
+++ b/engines/scumm/he/script_v72he.cpp
@@ -1827,10 +1827,19 @@ void ScummEngine_v72he::o72_readINI() {
 	switch (subOp) {
 	case 43: // HE 100
 	case 6: // number
-		if (!strcmp((char *)option, "NoPrinting")) {
+		if (!strcmp((char *)option, "DisablePrinting") || !strcmp((char *)option, "NoPrinting")) {
 			push(1);
 		} else if (!strcmp((char *)option, "TextOn")) {
 			push(ConfMan.getBool("subtitles"));
+		} else if (!strcmp((char *)option, "Disk") && (_game.id == GID_BIRTHDAYRED || _game.id == GID_BIRTHDAYYELLOW)) {
+			// WORKAROUND: Override the disk detection
+			// This removes the reliance on having the binary file around (which is
+			// very bad for the Mac version) just for the scripts to figure out if
+			// we're running Yellow or Red
+			if (_game.id == GID_BIRTHDAYRED)
+				push(4);
+			else
+				push(2);
 		} else {
 			push(ConfMan.getInt((char *)option));
 		}
diff --git a/engines/scumm/he/script_v80he.cpp b/engines/scumm/he/script_v80he.cpp
index 7970d7806f..9711f6415b 100644
--- a/engines/scumm/he/script_v80he.cpp
+++ b/engines/scumm/he/script_v80he.cpp
@@ -171,7 +171,10 @@ void ScummEngine_v80he::o80_readConfigFile() {
 	case 6: // number
 		ConfFile.getKey((const char *)option, (const char *)section, entry);
 
-		push(atoi(entry.c_str()));
+		if (!strcmp((char *)option, "Benchmark"))
+			push(2);
+		else
+			push(atoi(entry.c_str()));
 		break;
 	case 77: // HE 100
 	case 7: // string
diff --git a/engines/scumm/he/sprite_he.cpp b/engines/scumm/he/sprite_he.cpp
index 0b37673e4a..081110c7cd 100644
--- a/engines/scumm/he/sprite_he.cpp
+++ b/engines/scumm/he/sprite_he.cpp
@@ -804,12 +804,18 @@ void Sprite::setSpriteImage(int spriteId, int imageNum) {
 
 	if (_spriteTable[spriteId].image) {
 		_spriteTable[spriteId].imageStateCount = _vm->_wiz->getWizImageStates(_spriteTable[spriteId].image);
-		_spriteTable[spriteId].flags |= kSFActive | kSFAutoAnim | kSFMarkDirty | kSFBlitDirectly;
+
+		if (_vm->VAR(139))
+			_spriteTable[spriteId].flags |= kSFActive;
+		else
+			_spriteTable[spriteId].flags |= kSFActive | kSFAutoAnim | kSFMarkDirty | kSFBlitDirectly;
 
 		if (_spriteTable[spriteId].image != origResId || _spriteTable[spriteId].imageStateCount != origResWizStates)
 			_spriteTable[spriteId].flags |= kSFChanged | kSFNeedRedraw;
 	} else {
-		if (_spriteTable[spriteId].flags & kSFImageless)
+		if (_vm->VAR(139))
+			_spriteTable[spriteId].flags &= ~kSFActive;
+		else if (_spriteTable[spriteId].flags & kSFImageless)
 			_spriteTable[spriteId].flags = 0;
 		else
 			_spriteTable[spriteId].flags = kSFChanged | kSFBlitDirectly;
diff --git a/engines/scumm/he/sprite_he.h b/engines/scumm/he/sprite_he.h
index d28c9f1944..be6717faa5 100644
--- a/engines/scumm/he/sprite_he.h
+++ b/engines/scumm/he/sprite_he.h
@@ -218,4 +218,3 @@ private:
 } // End of namespace Scumm
 
 #endif
-
diff --git a/engines/scumm/he/wiz_he.cpp b/engines/scumm/he/wiz_he.cpp
index 4107034fe6..f67922c81c 100644
--- a/engines/scumm/he/wiz_he.cpp
+++ b/engines/scumm/he/wiz_he.cpp
@@ -1755,7 +1755,7 @@ void Wiz::captureWizPolygon(int resNum, int maskNum, int maskState, int id1, int
 		uint8 *tmpPtr = imageBuffer;
 		for (i = 0; i < dsth; i++) {
 			for (j = 0; j < dstw; j++)
-				WRITE_UINT16(tmpPtr + j * 2, transColor);
+				WRITE_LE_UINT16(tmpPtr + j * 2, transColor);
 			tmpPtr += dstpitch;
 		}
 	} else {
diff --git a/engines/scumm/help.cpp b/engines/scumm/help.cpp
index ae7a1ad3bc..cfb23a392a 100644
--- a/engines/scumm/help.cpp
+++ b/engines/scumm/help.cpp
@@ -175,6 +175,7 @@ void ScummHelp::updateStrings(byte gameId, byte version, Common::Platform platfo
 			ADD_BIND("b", _("To Henry / To Indy"));
 			break;
 		case GID_LOOM:
+			// I18N: These are different musical notes
 			ADD_BIND("q, c", _("play C minor on distaff"));
 			ADD_BIND("w, d", _("play D on distaff"));
 			ADD_BIND("e, e", _("play E on distaff"));
@@ -238,6 +239,7 @@ void ScummHelp::updateStrings(byte gameId, byte version, Common::Platform platfo
 			ADD_BIND("e", _("Examine"));
 			ADD_BIND("t", _("Regular cursor"));
 			ADD_BIND("i", _("Inventory"));
+			// I18N: Comm is a communication device
 			ADD_BIND("c", _("Comm"));
 			break;
 		case GID_CMI:
diff --git a/engines/scumm/help.h b/engines/scumm/help.h
index 9763da8c00..5ba6bdc65c 100644
--- a/engines/scumm/help.h
+++ b/engines/scumm/help.h
@@ -42,4 +42,3 @@ public:
 } // End of namespace Scumm
 
 #endif
-
diff --git a/engines/scumm/imuse/pcspk.cpp b/engines/scumm/imuse/pcspk.cpp
index 01e2ab3b7d..cbf3446f10 100644
--- a/engines/scumm/imuse/pcspk.cpp
+++ b/engines/scumm/imuse/pcspk.cpp
@@ -380,7 +380,7 @@ int16 PcSpkDriver::getEffectModLevel(int16 level, int8 mod) {
 	}
 }
 
-int16 PcSpkDriver::getRandMultipy(int16 input) {
+int16 PcSpkDriver::getRandScale(int16 input) {
 	if (_randBase & 1)
 		_randBase = (_randBase >> 1) ^ 0xB8;
 	else
@@ -470,7 +470,7 @@ void PcSpkDriver::initNextEnvelopeState(EffectEnvelope &env) {
 
 	uint16 stepCount = _effectEnvStepTable[getEffectModifier(((env.stateTargetLevels[lastState] & 0x7F) << 5) + env.modWheelSensitivity)];
 	if (env.stateTargetLevels[lastState] & 0x80)
-		stepCount = getRandMultipy(stepCount);
+		stepCount = getRandScale(stepCount);
 	if (!stepCount)
 		stepCount = 1;
 
@@ -480,7 +480,7 @@ void PcSpkDriver::initNextEnvelopeState(EffectEnvelope &env) {
 	if (lastState != 2) {
 		totalChange = getEffectModLevel(env.maxLevel, (env.stateModWheelLevels[lastState] & 0x7F) - 31);
 		if (env.stateModWheelLevels[lastState] & 0x80)
-			totalChange = getRandMultipy(totalChange);
+			totalChange = getRandScale(totalChange);
 
 		if (totalChange + env.startLevel > env.maxLevel)
 			totalChange = env.maxLevel - env.startLevel;
@@ -832,4 +832,3 @@ const uint16 PcSpkDriver::_frequencyTable[] = {
 };
 
 } // End of namespace Scumm
-
diff --git a/engines/scumm/imuse/pcspk.h b/engines/scumm/imuse/pcspk.h
index e77ac8c1bf..195bd34b07 100644
--- a/engines/scumm/imuse/pcspk.h
+++ b/engines/scumm/imuse/pcspk.h
@@ -57,7 +57,7 @@ private:
 
 	static uint8 getEffectModifier(uint16 level);
 	int16 getEffectModLevel(int16 level, int8 mod);
-	int16 getRandMultipy(int16 input);
+	int16 getRandScale(int16 input);
 
 	struct EffectEnvelope {
 		uint8 state;
@@ -158,4 +158,3 @@ private:
 } // End of namespace Scumm
 
 #endif
-
diff --git a/engines/scumm/imuse/sysex.h b/engines/scumm/imuse/sysex.h
index 7dd38e785e..06ac483afd 100644
--- a/engines/scumm/imuse/sysex.h
+++ b/engines/scumm/imuse/sysex.h
@@ -35,4 +35,3 @@ extern void sysexHandler_SamNMax(Player *, const byte *, uint16);
 } // End of namespace Scumm
 
 #endif
-
diff --git a/engines/scumm/imuse_digi/dimuse.cpp b/engines/scumm/imuse_digi/dimuse.cpp
index 23f57a01b9..eb3717494f 100644
--- a/engines/scumm/imuse_digi/dimuse.cpp
+++ b/engines/scumm/imuse_digi/dimuse.cpp
@@ -58,7 +58,7 @@ IMuseDigital::IMuseDigital(ScummEngine_v7 *scumm, Audio::Mixer *mixer, int fps)
 		memset(_track[l], 0, sizeof(Track));
 		_track[l]->trackId = l;
 	}
-	_vm->getTimerManager()->installTimerProc(timer_handler, 1000000 / _callbackFps, this);
+	_vm->getTimerManager()->installTimerProc(timer_handler, 1000000 / _callbackFps, this, "IMuseDigital");
 
 	_audioNames = NULL;
 	_numAudioNames = 0;
diff --git a/engines/scumm/input.cpp b/engines/scumm/input.cpp
index 5eea7acc6b..6d9e1f3f72 100644
--- a/engines/scumm/input.cpp
+++ b/engines/scumm/input.cpp
@@ -324,7 +324,17 @@ void ScummEngine::processInput() {
 		VAR(VAR_LEFTBTN_HOLD) = (_leftBtnPressed & msDown) != 0;
 		VAR(VAR_RIGHTBTN_HOLD) = (_rightBtnPressed & msDown) != 0;
 
-		if (_game.version >= 7) {
+		if (_game.heversion >= 72) {
+			// HE72 introduced a flag for whether or not this is a click
+			// or the player is continuing to hold the button down.
+			// 0x80 signifies that the button is continuing to be held down
+			// Backyard Soccer needs this in order to function
+			if (VAR(VAR_LEFTBTN_HOLD) && !(_leftBtnPressed & msClicked))
+				VAR(VAR_LEFTBTN_HOLD) |= 0x80;
+
+			if (VAR(VAR_RIGHTBTN_HOLD) && !(_rightBtnPressed & msClicked))
+				VAR(VAR_RIGHTBTN_HOLD) |= 0x80;
+		} else if (_game.version >= 7) {
 			VAR(VAR_LEFTBTN_DOWN) = (_leftBtnPressed & msClicked) != 0;
 			VAR(VAR_RIGHTBTN_DOWN) = (_rightBtnPressed & msClicked) != 0;
 		}
diff --git a/engines/scumm/insane/insane_enemy.cpp b/engines/scumm/insane/insane_enemy.cpp
index 68766ab72c..913f761f31 100644
--- a/engines/scumm/insane/insane_enemy.cpp
+++ b/engines/scumm/insane/insane_enemy.cpp
@@ -2779,4 +2779,3 @@ int32 Insane::actionEnemy() {
 }
 
 }
-
diff --git a/engines/scumm/insane/insane_iact.cpp b/engines/scumm/insane/insane_iact.cpp
index 3592d67c18..48c96b537c 100644
--- a/engines/scumm/insane/insane_iact.cpp
+++ b/engines/scumm/insane/insane_iact.cpp
@@ -520,4 +520,3 @@ void Insane::iactScene21(byte *renderBitmap, int32 codecparam, int32 setupsan12,
 }
 
 }
-
diff --git a/engines/scumm/insane/insane_scenes.cpp b/engines/scumm/insane/insane_scenes.cpp
index 841fedafe2..6db1cb5059 100644
--- a/engines/scumm/insane/insane_scenes.cpp
+++ b/engines/scumm/insane/insane_scenes.cpp
@@ -1506,4 +1506,3 @@ void Insane::postCaseMore(byte *renderBitmap, int32 codecparam, int32 setupsan12
 }
 
 }
-
diff --git a/engines/scumm/module.mk b/engines/scumm/module.mk
index 99ffdf7f21..781ca30459 100644
--- a/engines/scumm/module.mk
+++ b/engines/scumm/module.mk
@@ -124,7 +124,14 @@ MODULE_OBJS += \
 	he/script_v90he.o \
 	he/script_v100he.o \
 	he/sprite_he.o \
-	he/wiz_he.o
+	he/wiz_he.o \
+	he/logic/baseball2001.o \
+	he/logic/basketball.o \
+	he/logic/football.o \
+	he/logic/funshop.o \
+	he/logic/moonbase.o \
+	he/logic/puttrace.o \
+	he/logic/soccer.o
 endif
 
 # This module can be built as a plugin
diff --git a/engines/scumm/palette.cpp b/engines/scumm/palette.cpp
index 51ba2195d7..30096000ce 100644
--- a/engines/scumm/palette.cpp
+++ b/engines/scumm/palette.cpp
@@ -544,6 +544,12 @@ void ScummEngine::palManipulateInit(int resID, int start, int end, int time) {
 		return;
 #endif
 
+	// This function is actually a nullsub in Indy4 Amiga.
+	// It might very well be a nullsub in other Amiga games, but for now I
+	// limit this to Indy4 Amiga, since that is the only game I can check.
+	if (_game.platform == Common::kPlatformAmiga && _game.id == GID_INDY4)
+		return;
+
 	byte *string1 = getStringAddress(resID);
 	byte *string2 = getStringAddress(resID + 1);
 	byte *string3 = getStringAddress(resID + 2);
@@ -670,6 +676,12 @@ static inline uint colorWeight(int red, int green, int blue) {
 }
 
 void ScummEngine::setShadowPalette(int redScale, int greenScale, int blueScale, int startColor, int endColor, int start, int end) {
+	// This function is actually a nullsub in Indy4 Amiga.
+	// It might very well be a nullsub in other Amiga games, but for now I
+	// limit this to Indy4 Amiga, since that is the only game I can check.
+	if (_game.platform == Common::kPlatformAmiga && _game.id == GID_INDY4)
+		return;
+
 	const byte *basepal = getPalettePtr(_curPalIndex, _roomResource);
 	const byte *compareptr;
 	const byte *pal = basepal + start * 3;
diff --git a/engines/scumm/player_v2.h b/engines/scumm/player_v2.h
index 14a0b9c1e0..d932585b8e 100644
--- a/engines/scumm/player_v2.h
+++ b/engines/scumm/player_v2.h
@@ -46,10 +46,7 @@ public:
 	virtual int  getSoundStatus(int sound) const;
 
 	// AudioStream API
-	int readBuffer(int16 *buffer, const int numSamples);
-	bool isStereo() const { return true; }
-	bool endOfData() const { return false; }
-	int getRate() const { return _sampleRate; }
+	virtual int readBuffer(int16 *buffer, const int numSamples);
 
 protected:
 	unsigned int _update_step;
diff --git a/engines/scumm/player_v2base.h b/engines/scumm/player_v2base.h
index 2f048070ad..eb9ed941ca 100644
--- a/engines/scumm/player_v2base.h
+++ b/engines/scumm/player_v2base.h
@@ -86,9 +86,9 @@ public:
 		return numSamples;
 	}
 */
-	bool isStereo() const { return true; }
-	bool endOfData() const { return false; }
-	int getRate() const { return _sampleRate; }
+	virtual bool isStereo() const { return true; }
+	virtual bool endOfData() const { return false; }
+	virtual int getRate() const { return _sampleRate; }
 
 protected:
 	enum {
diff --git a/engines/scumm/player_v2cms.cpp b/engines/scumm/player_v2cms.cpp
index 21e7f193b5..d4b21774ed 100644
--- a/engines/scumm/player_v2cms.cpp
+++ b/engines/scumm/player_v2cms.cpp
@@ -28,162 +28,49 @@
 
 namespace Scumm {
 
-#define PROCESS_ATTACK 1
-#define PROCESS_RELEASE 2
-#define PROCESS_SUSTAIN 3
-#define PROCESS_DECAY 4
-#define PROCESS_VIBRATO 5
-
-#define CMS_RATE 22050
-
-static const byte freqTable[] = {
-	  3,  10,  17,  24,  31,  38,  45,  51,
-	 58,  65,  71,  77,  83,  90,  96, 102,
-	107, 113, 119, 125, 130, 136, 141, 146,
-	151, 157, 162, 167, 172, 177, 181, 186,
-	191, 195, 200, 204, 209, 213, 217, 221,
-	226, 230, 234, 238, 242, 246, 249, 253
-};
-
-/*static const byte amplTable[] = {
-	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,	// 0 %
-	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,	// 10 %
-	0x00, 0x00, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10,
-	0x00, 0x00, 0x00, 0x00, 0x00, 0x10, 0x10, 0x10,	// 20 %
-	0x10, 0x10, 0x20, 0x20, 0x20, 0x20, 0x20, 0x30,
-	0x00, 0x00, 0x00, 0x00, 0x10, 0x10, 0x10, 0x20,	// 30%
-	0x20, 0x20, 0x30, 0x30, 0x30, 0x30, 0x40, 0x40,
-	0x00, 0x00, 0x00, 0x10, 0x10, 0x20, 0x20, 0x20,	// 40 %
-	0x30, 0x30, 0x40, 0x40, 0x40, 0x50, 0x50, 0x60,
-	0x00, 0x00, 0x10, 0x10, 0x20, 0x20, 0x30, 0x30,	// 50%
-	0x40, 0x40, 0x50, 0x50, 0x60, 0x60, 0x70, 0x70,
-	0x00, 0x00, 0x10, 0x10, 0x20, 0x30, 0x30, 0x40,	// 60 %
-	0x40, 0x50, 0x60, 0x60, 0x70, 0x70, 0x80, 0x90,
-	0x00, 0x00, 0x10, 0x20, 0x20, 0x30, 0x40, 0x40,	// 70 %
-	0x50, 0x60, 0x70, 0x70, 0x80, 0x90, 0x90, 0xA0,
-	0x00, 0x00, 0x10, 0x20, 0x30, 0x40, 0x40, 0x50,	// 80 %
-	0x60, 0x70, 0x80, 0x80, 0x90, 0xA0, 0xB0, 0xC0,
-	0x00, 0x00, 0x10, 0x20, 0x30, 0x40, 0x50, 0x60,	// 90 %
-	0x70, 0x80, 0x90, 0x90, 0xA0, 0xB0, 0xC0, 0xD0,
-	0x00, 0x10, 0x20, 0x30, 0x40, 0x50, 0x60, 0x70,	// 100 %
-	0x80, 0x90, 0xA0, 0xB0, 0xC0, 0xD0, 0xE0, 0xF0
-};*/
-
-static const byte octaveTable[] = {
-	0x00, 0x00, 0x00, 0x01, 0x00, 0x02, 0x00, 0x03,
-	0x00, 0x04, 0x00, 0x05, 0x00, 0x06, 0x00, 0x07,
-	0x00, 0x08, 0x00, 0x09, 0x00, 0x0A, 0x00, 0x0B,
-	0x01, 0x00, 0x01, 0x01, 0x01, 0x02, 0x01, 0x03,
-	0x01, 0x04, 0x01, 0x05, 0x01, 0x06, 0x01, 0x07,
-	0x01, 0x08, 0x01, 0x09, 0x01, 0x0A, 0x01, 0x0B,
-	0x02, 0x00, 0x02, 0x01, 0x02, 0x02, 0x02, 0x03,
-	0x02, 0x04, 0x02, 0x05, 0x02, 0x06, 0x02, 0x07,
-	0x02, 0x08, 0x02, 0x09, 0x02, 0x0A, 0x02, 0x0B,
-	0x03, 0x00, 0x03, 0x01, 0x03, 0x02, 0x03, 0x03,
-	0x03, 0x04, 0x03, 0x05, 0x03, 0x06, 0x03, 0x07,
-	0x03, 0x08, 0x03, 0x09, 0x03, 0x0A, 0x03, 0x0B,
-	0x04, 0x00, 0x04, 0x01, 0x04, 0x02, 0x04, 0x03,
-	0x04, 0x04, 0x04, 0x05, 0x04, 0x06, 0x04, 0x07,
-	0x04, 0x08, 0x04, 0x09, 0x04, 0x0A, 0x04, 0x0B,
-	0x05, 0x00, 0x05, 0x01, 0x05, 0x02, 0x05, 0x03,
-	0x05, 0x04, 0x05, 0x05, 0x05, 0x06, 0x05, 0x07,
-	0x05, 0x08, 0x05, 0x09, 0x05, 0x0A, 0x05, 0x0B,
-	0x06, 0x00, 0x06, 0x01, 0x06, 0x02, 0x06, 0x03,
-	0x06, 0x04, 0x06, 0x05, 0x06, 0x06, 0x06, 0x07,
-	0x06, 0x08, 0x06, 0x09, 0x06, 0x0A, 0x06, 0x0B,
-	0x07, 0x00, 0x07, 0x01, 0x07, 0x02, 0x07, 0x03,
-	0x07, 0x04, 0x07, 0x05, 0x07, 0x06, 0x07, 0x07,
-	0x07, 0x08, 0x07, 0x09, 0x07, 0x0A, 0x07, 0x0B,
-	0x08, 0x00, 0x08, 0x01, 0x08, 0x02, 0x08, 0x03,
-	0x08, 0x04, 0x08, 0x05, 0x08, 0x06, 0x08, 0x07,
-	0x08, 0x08, 0x08, 0x09, 0x08, 0x0A, 0x08, 0x0B,
-	0x09, 0x00, 0x09, 0x01, 0x09, 0x02, 0x09, 0x03,
-	0x09, 0x04, 0x09, 0x05, 0x09, 0x06, 0x09, 0x07,
-	0x09, 0x08, 0x09, 0x09, 0x09, 0x0A, 0x09, 0x0B,
-	0x0A, 0x00, 0x0A, 0x01, 0x0A, 0x02, 0x0A, 0x03,
-	0x0A, 0x04, 0x0A, 0x05, 0x0A, 0x06, 0x0A, 0x07,
-	0x0A, 0x08, 0x0A, 0x09, 0x0A, 0x0A, 0x0A, 0x0B
-};
-
-static const byte attackRate[] = {
-	  0,   2,   4,   7,  14,  26,  48,  82,
-	128, 144, 160, 176, 192, 208, 224, 255
-};
-
-static const byte decayRate[] = {
-	  0,   1,   2,   3,   4,   6,  12,  24,
-	 48,  96, 192, 215, 255, 255, 255, 255
-};
-
-static const byte sustainRate[] = {
-	255, 180, 128,  96,  80,  64,  56,  48,
-	 42,  36,  32,  28,  24,  20,  16,   0
-};
-
-static const byte releaseRate[] = {
-	  0,   1,   2,   4,   6,   9,  14,  22,
-	 36,  56,  80, 100, 120, 140, 160, 255
-};
-
-static const byte volumeTable[] = {
-	0x00, 0x10, 0x10, 0x11, 0x11, 0x21, 0x22, 0x22,
-	0x33, 0x44, 0x55, 0x66, 0x88, 0xAA, 0xCC, 0xFF
-};
-
 Player_V2CMS::Player_V2CMS(ScummEngine *scumm, Audio::Mixer *mixer)
-	: Player_V2Base(scumm, mixer, true) {
-	int i;
-
+	: Player_V2Base(scumm, mixer, true), _cmsVoicesBase(), _cmsVoices(),
+	  _cmsChips(), _midiDelay(0), _octaveMask(0), _looping(0), _tempo(0),
+	  _tempoSum(0), _midiData(0), _midiSongBegin(0), _musicTimer(0),
+	  _musicTimerTicks(0), _voiceTimer(0), _loadedMidiSong(0),
+	  _outputTableReady(0), _midiChannel(), _midiChannelUse() {
 	setMusicVolume(255);
 
-	memset(_cmsVoicesBase, 0, sizeof(Voice)*16);
-	memset(_cmsVoices, 0, sizeof(Voice2)*8);
-	memset(_cmsChips, 0, sizeof(MusicChip)*2);
-	_midiDelay = _octaveMask = _looping = _tempo = 0;
-	_midiData = _midiSongBegin = 0;
-	_loadedMidiSong = 0;
-	memset(_midiChannel, 0, sizeof(Voice2*)*16);
-	memset(_midiChannelUse, 0, sizeof(byte)*16);
-
-	_cmsVoices[0].amplitudeOutput = &(_cmsChips[0].ampl[0]);
-	_cmsVoices[0].freqOutput = &(_cmsChips[0].freq[0]);
-	_cmsVoices[0].octaveOutput = &(_cmsChips[0].octave[0]);
-	_cmsVoices[1].amplitudeOutput = &(_cmsChips[0].ampl[1]);
-	_cmsVoices[1].freqOutput = &(_cmsChips[0].freq[1]);
-	_cmsVoices[1].octaveOutput = &(_cmsChips[0].octave[0]);
-	_cmsVoices[2].amplitudeOutput = &(_cmsChips[0].ampl[2]);
-	_cmsVoices[2].freqOutput = &(_cmsChips[0].freq[2]);
-	_cmsVoices[2].octaveOutput = &(_cmsChips[0].octave[1]);
-	_cmsVoices[3].amplitudeOutput = &(_cmsChips[0].ampl[3]);
-	_cmsVoices[3].freqOutput = &(_cmsChips[0].freq[3]);
-	_cmsVoices[3].octaveOutput = &(_cmsChips[0].octave[1]);
-	_cmsVoices[4].amplitudeOutput = &(_cmsChips[1].ampl[0]);
-	_cmsVoices[4].freqOutput = &(_cmsChips[1].freq[0]);
-	_cmsVoices[4].octaveOutput = &(_cmsChips[1].octave[0]);
-	_cmsVoices[5].amplitudeOutput = &(_cmsChips[1].ampl[1]);
-	_cmsVoices[5].freqOutput = &(_cmsChips[1].freq[1]);
-	_cmsVoices[5].octaveOutput = &(_cmsChips[1].octave[0]);
-	_cmsVoices[6].amplitudeOutput = &(_cmsChips[1].ampl[2]);
-	_cmsVoices[6].freqOutput = &(_cmsChips[1].freq[2]);
-	_cmsVoices[6].octaveOutput = &(_cmsChips[1].octave[1]);
-	_cmsVoices[7].amplitudeOutput = &(_cmsChips[1].ampl[3]);
-	_cmsVoices[7].freqOutput = &(_cmsChips[1].freq[3]);
-	_cmsVoices[7].octaveOutput = &(_cmsChips[1].octave[1]);
+	memset(_sfxFreq, 0xFF, sizeof(_sfxFreq));
+	memset(_sfxAmpl, 0x00, sizeof(_sfxAmpl));
+	memset(_sfxOctave, 0x66, sizeof(_sfxOctave));
+
+	_cmsVoices[0].amplitudeOutput = &_cmsChips[0].ampl[0];
+	_cmsVoices[0].freqOutput = &_cmsChips[0].freq[0];
+	_cmsVoices[0].octaveOutput = &_cmsChips[0].octave[0];
+	_cmsVoices[1].amplitudeOutput = &_cmsChips[0].ampl[1];
+	_cmsVoices[1].freqOutput = &_cmsChips[0].freq[1];
+	_cmsVoices[1].octaveOutput = &_cmsChips[0].octave[0];
+	_cmsVoices[2].amplitudeOutput = &_cmsChips[0].ampl[2];
+	_cmsVoices[2].freqOutput = &_cmsChips[0].freq[2];
+	_cmsVoices[2].octaveOutput = &_cmsChips[0].octave[1];
+	_cmsVoices[3].amplitudeOutput = &_cmsChips[0].ampl[3];
+	_cmsVoices[3].freqOutput = &_cmsChips[0].freq[3];
+	_cmsVoices[3].octaveOutput = &_cmsChips[0].octave[1];
+	_cmsVoices[4].amplitudeOutput = &_cmsChips[1].ampl[0];
+	_cmsVoices[4].freqOutput = &_cmsChips[1].freq[0];
+	_cmsVoices[4].octaveOutput = &_cmsChips[1].octave[0];
+	_cmsVoices[5].amplitudeOutput = &_cmsChips[1].ampl[1];
+	_cmsVoices[5].freqOutput = &_cmsChips[1].freq[1];
+	_cmsVoices[5].octaveOutput = &_cmsChips[1].octave[0];
+	_cmsVoices[6].amplitudeOutput = &_cmsChips[1].ampl[2];
+	_cmsVoices[6].freqOutput = &_cmsChips[1].freq[2];
+	_cmsVoices[6].octaveOutput = &_cmsChips[1].octave[1];
+	_cmsVoices[7].amplitudeOutput = &_cmsChips[1].ampl[3];
+	_cmsVoices[7].freqOutput = &_cmsChips[1].freq[3];
+	_cmsVoices[7].octaveOutput = &_cmsChips[1].octave[1];
 
 	// inits the CMS Emulator like in the original
 	_cmsEmu = new CMSEmulator(_sampleRate);
-	static const byte cmsInitData[13*2] = {
-		0x1C, 0x02,
-		0x00, 0x00, 0x01, 0x00, 0x02, 0x00, 0x03, 0x00, 0x04, 0x00, 0x05, 0x00,
-		0x14, 0x3F, 0x15, 0x00, 0x16, 0x00, 0x18, 0x00, 0x19, 0x00, 0x1C, 0x01
-	};
-
-	i = 0;
-	for (int cmsPort = 0x220; i < 2; cmsPort += 2, ++i) {
+	for (int i = 0, cmsPort = 0x220; i < 2; cmsPort += 2, ++i) {
 		for (int off = 0; off < 13; ++off) {
-			_cmsEmu->portWrite(cmsPort+1, cmsInitData[off*2]);
-			_cmsEmu->portWrite(cmsPort, cmsInitData[off*2+1]);
+			_cmsEmu->portWrite(cmsPort+1, _cmsInitData[off*2]);
+			_cmsEmu->portWrite(cmsPort, _cmsInitData[off*2+1]);
 		}
 	}
 
@@ -200,6 +87,10 @@ Player_V2CMS::~Player_V2CMS() {
 void Player_V2CMS::setMusicVolume(int vol) {
 }
 
+int Player_V2CMS::getMusicTimer() {
+	return _midiData ? _musicTimer : Player_V2Base::getMusicTimer();
+}
+
 void Player_V2CMS::stopAllSounds() {
 	Common::StackLock lock(_mutex);
 
@@ -211,6 +102,7 @@ void Player_V2CMS::stopAllSounds() {
 	_midiData = 0;
 	_midiSongBegin = 0;
 	_midiDelay = 0;
+	_musicTimer = _musicTimerTicks = 0;
 	offAllChannels();
 }
 
@@ -244,6 +136,7 @@ void Player_V2CMS::startSound(int nr) {
 	assert(data);
 
 	if (data[6] == 0x80) {
+		_musicTimer = _musicTimerTicks = 0;
 		loadMidiData(data, nr);
 	} else {
 		int cprio = _current_data ? *(_current_data + _header_len) : 0;
@@ -282,7 +175,8 @@ void Player_V2CMS::startSound(int nr) {
 }
 
 void Player_V2CMS::loadMidiData(byte *data, int sound) {
-	memset(_midiChannelUse, 0, sizeof(byte)*16);
+	memset(_midiChannelUse, 0, sizeof(_midiChannelUse));
+	memset(_midiChannel, 0, sizeof(_midiChannel));
 
 	_tempo = data[7];
 	_looping = data[8];
@@ -299,11 +193,11 @@ void Player_V2CMS::loadMidiData(byte *data, int sound) {
 			Voice *voiceDef = &_cmsVoicesBase[channel];
 
 			byte attackDecay = voice2[10];
-			voiceDef->attack = attackRate[attackDecay >> 4];
-			voiceDef->decay = decayRate[attackDecay & 0x0F];
+			voiceDef->attack = _attackRate[attackDecay >> 4];
+			voiceDef->decay = _decayRate[attackDecay & 0x0F];
 			byte sustainRelease = voice2[11];
-			voiceDef->sustain = sustainRate[sustainRelease >> 4];
-			voiceDef->release = releaseRate[sustainRelease & 0x0F];
+			voiceDef->sustain = _sustainRate[sustainRelease >> 4];
+			voiceDef->release = _releaseRate[sustainRelease & 0x0F];
 
 			if (voice2[3] & 0x40) {
 				voiceDef->vibrato = 0x0301;
@@ -331,12 +225,10 @@ void Player_V2CMS::loadMidiData(byte *data, int sound) {
 		}
 	}
 
-	for (int i = 0, channel = 0; i < 8; ++i, channel += 2) {
+	for (int i = 0; i < 8; ++i) {
 		_cmsVoices[i].chanNumber = 0xFF;
 		_cmsVoices[i].curVolume = 0;
 		_cmsVoices[i].nextVoice = 0;
-
-		_midiChannel[channel] = 0;
 	}
 
 	_midiDelay = 0;
@@ -351,11 +243,17 @@ int Player_V2CMS::getSoundStatus(int nr) const {
 	return _current_nr == nr || _next_nr == nr || _loadedMidiSong == nr;
 }
 
-void Player_V2CMS::processMidiData(uint ticks) {
+void Player_V2CMS::processMidiData() {
 	byte *currentData = _midiData;
 	byte command = 0x00;
 	int16 temp = 0;
 
+	++_musicTimerTicks;
+	if (_musicTimerTicks > 60) {
+		_musicTimerTicks = 0;
+		++_musicTimer;
+	}
+
 	if (!_midiDelay) {
 		while (true) {
 			if ((command = *currentData++) == 0xFF) {
@@ -365,6 +263,8 @@ void Player_V2CMS::processMidiData(uint ticks) {
 						continue;
 					}
 					_midiData = _midiSongBegin = 0;
+					_midiDelay = 0;
+					_loadedMidiSong = 0;
 					offAllChannels();
 					return;
 				} else {
@@ -400,7 +300,7 @@ void Player_V2CMS::processMidiData(uint ticks) {
 		_midiDelay = temp;
 	}
 
-	_midiDelay -= ticks;
+	--_midiDelay;
 	if (_midiDelay < 0)
 		_midiDelay = 0;
 
@@ -415,27 +315,21 @@ int Player_V2CMS::readBuffer(int16 *buffer, const int numSamples) {
 
 	// maybe this needs a complete rewrite
 	do {
-		if (_midiData) {
-			--_clkFrequenz;
-			if (!(_clkFrequenz & 0x01)) {
-				playVoice();
-			}
-
-			_tempoSum += _tempo;
-			// FIXME: _tempoSum is declared as char; on some systems char is unsigned.
-			// E.g. on OS X. Hence the following check is always false.
-			// Moral of the story: Use uint8, int8 or any of the other types provided by
-			// ScummVM if you want to ensure signedness and number of available bits.
-			if (_tempoSum < 0) {
-				// this have to be called in the same rate as in the original (I think)
-				processMidiData(1);
+		if (!(_next_tick >> FIXP_SHIFT)) {
+			if (_midiData) {
+				--_voiceTimer;
+				if (!(_voiceTimer & 0x01))
+					playVoice();
+
+				int newTempoSum = _tempo + _tempoSum;
+				_tempoSum = newTempoSum & 0xFF;
+				if (newTempoSum > 0xFF)
+					processMidiData();
+			} else {
+				nextTick();
+				play();
 			}
-		}
-
-		if (!(_next_tick >> FIXP_SHIFT) && !_midiData) {
 			_next_tick += _tick_len;
-			nextTick();
-			play();
 		}
 
 		step = len;
@@ -456,99 +350,95 @@ void Player_V2CMS::playVoice() {
 	}
 
 	_octaveMask = 0xF0;
-	Voice2 *voice =0;
+	Voice2 *voice = 0;
 	for (int i = 0; i < 8; ++i) {
 		voice = &_cmsVoices[i];
 		_octaveMask = ~_octaveMask;
 
 		if (voice->chanNumber != 0xFF) {
 			processChannel(voice);
-			continue;
-		}
-
-		if (!voice->curVolume) {
-			*(voice->amplitudeOutput) = 0;
-		}
+		} else {
+			if (!voice->curVolume) {
+				*(voice->amplitudeOutput) = 0;
+			}
 
-		int volume = voice->curVolume - voice->releaseRate;
-		voice->curVolume = volume;
+			int volume = voice->curVolume - voice->releaseRate;
+			if (volume < 0)
+				volume = 0;
 
-		if (volume < 0) {
-			volume = voice->curVolume = 0;
+			voice->curVolume = volume;
+			*(voice->amplitudeOutput) = ((volume >> 4) | (volume & 0xF0)) & voice->channel;
+			++_outputTableReady;
 		}
-
-		*(voice->amplitudeOutput) = ((volume >> 4) | (volume & 0xF0)) & voice->channel;
-		++_outputTableReady;
 	}
 }
 
 void Player_V2CMS::processChannel(Voice2 *channel) {
 	++_outputTableReady;
 	switch (channel->nextProcessState) {
-	case PROCESS_RELEASE:
-		processRelease(channel);
-		break;
-
-	case PROCESS_ATTACK:
+	case Voice2::kEnvelopeAttack:
 		processAttack(channel);
 		break;
 
-	case PROCESS_DECAY:
+	case Voice2::kEnvelopeDecay:
 		processDecay(channel);
 		break;
 
-	case PROCESS_SUSTAIN:
+	case Voice2::kEnvelopeSustain:
 		processSustain(channel);
 		break;
 
-	case PROCESS_VIBRATO:
-		processVibrato(channel);
-		break;
-
-	default:
+	case Voice2::kEnvelopeRelease:
+		processRelease(channel);
 		break;
 	}
 }
 
 void Player_V2CMS::processRelease(Voice2 *channel) {
-	channel->curVolume -= channel->releaseRate;
-	if (channel->curVolume < 0)
-		channel->curVolume = 0;
+	int newVolume = channel->curVolume - channel->releaseRate;
+	if (newVolume < 0)
+		newVolume = 0;
+
+	channel->curVolume = newVolume;
 	processVibrato(channel);
 }
 
 void Player_V2CMS::processAttack(Voice2 *channel) {
-	channel->curVolume += channel->attackRate;
-	if (channel->curVolume >= 0) {
-		if (channel->curVolume <= channel->maxAmpl)
-			return processVibrato(channel);
+	int newVolume = channel->curVolume + channel->attackRate;
+	if (newVolume > channel->maxAmpl) {
+		channel->curVolume = channel->maxAmpl;
+		channel->nextProcessState = Voice2::kEnvelopeDecay;
+	} else {
+		channel->curVolume = newVolume;
 	}
-	channel->curVolume = channel->maxAmpl;
-	channel->nextProcessState = PROCESS_DECAY;
+
 	processVibrato(channel);
 }
 
 void Player_V2CMS::processDecay(Voice2 *channel) {
-	channel->curVolume -= channel->decayRate;
-	if (channel->curVolume >= 0) {
-		if (channel->curVolume > channel->sustainRate)
-			return processVibrato(channel);
+	int newVolume = channel->curVolume - channel->decayRate;
+	if (newVolume <= channel->sustainRate) {
+		channel->curVolume = channel->sustainRate;
+		channel->nextProcessState = Voice2::kEnvelopeSustain;
+	} else {
+		channel->curVolume = newVolume;
 	}
-	channel->curVolume = channel->sustainRate;
-	channel->nextProcessState = PROCESS_SUSTAIN;
+
 	processVibrato(channel);
 }
 
 void Player_V2CMS::processSustain(Voice2 *channel) {
 	if (channel->unkVibratoRate) {
-		int volume = (int)channel->curVolume + (int)channel->unkRate;
+		int16 volume = channel->curVolume + channel->unkRate;
 		if (volume & 0xFF00) {
-			volume = ((~volume) >> 8) & 0xFF;
+			volume = int8(volume >> 8);
+			volume = -volume;
 		}
+
 		channel->curVolume = volume;
-		--(channel->unkCount);
+		--channel->unkCount;
 		if (!channel->unkCount) {
-			channel->unkRate = ~(channel->unkRate);
+			channel->unkRate = -channel->unkRate;
 			channel->unkCount = (channel->unkVibratoDepth & 0x0F) << 1;
 		}
 	}
@@ -557,12 +447,13 @@ void Player_V2CMS::processSustain(Voice2 *channel) {
 
 void Player_V2CMS::processVibrato(Voice2 *channel) {
 	if (channel->vibratoRate) {
-		uint16 temp = channel->curFreq + channel->curVibratoRate;
+		int16 temp = channel->curFreq + channel->curVibratoRate;
 		channel->curOctave += (temp & 0xFF00) >> 8;
 		channel->curFreq = temp & 0xFF;
-		--(channel->curVibratoUnk);
+
+		--channel->curVibratoUnk;
 		if (!channel->curVibratoUnk) {
-			channel->curVibratoRate = ~(channel->curVibratoRate);
+			channel->curVibratoRate = -channel->curVibratoRate;
 			channel->curVibratoUnk = (channel->vibratoDepth & 0x0F) << 1;
 		}
 	}
@@ -572,25 +463,16 @@ void Player_V2CMS::processVibrato(Voice2 *channel) {
 	output = channel->freqOutput;
 	*output = channel->curFreq;
 	output = channel->octaveOutput;
-	*output = ((((channel->curOctave >> 4) | (channel->curOctave & 0x0F)) & _octaveMask) | ((~_octaveMask) & *output));
+	*output = (((channel->curOctave << 4) | (channel->curOctave & 0x0F)) & _octaveMask) | ((~_octaveMask) & *output);
 }
 
 void Player_V2CMS::offAllChannels() {
-	warning("offAllChannels STUB");
-/*
-	// after using this sound can not be played anymore (since it would deinit the emulator)
-	static const byte cmsOffData[10*2] = {
-		0x1C, 0x02,
-		0x00, 0x00, 0x01, 0x00, 0x02, 0x00, 0x03, 0x00, 0x04, 0x00, 0x05, 0x00,
-		0x14, 0x3F, 0x15, 0x00, 0x16, 0x00
-	};
-
 	for (int cmsPort = 0x220, i = 0; i < 2; cmsPort += 2, ++i) {
-		for (int off = 0; off < 10; ++off) {
-			_cmsEmu->portWrite(cmsPort+1, cmsOffData[off*2]);
-			_cmsEmu->portWrite(cmsPort, cmsOffData[off*2+1]);
+		for (int off = 1; off <= 10; ++off) {
+			_cmsEmu->portWrite(cmsPort+1, _cmsInitData[off*2]);
+			_cmsEmu->portWrite(cmsPort, _cmsInitData[off*2+1]);
 		}
-	}*/
+	}
 }
 
 Player_V2CMS::Voice2 *Player_V2CMS::getFreeVoice() {
@@ -637,8 +519,10 @@ void Player_V2CMS::playNote(byte *&data) {
 			freeVoice->sustainRate = voice->sustain;
 			freeVoice->releaseRate = voice->release;
 			freeVoice->octaveAdd = voice->octadd;
-			freeVoice->vibratoRate = freeVoice->curVibratoRate = voice->vibrato;
-			freeVoice->unkVibratoRate = freeVoice->unkRate = voice->vibrato2;
+			freeVoice->vibratoRate = freeVoice->curVibratoRate = voice->vibrato & 0xFF;
+			freeVoice->vibratoDepth = freeVoice->curVibratoUnk = voice->vibrato >> 8;
+			freeVoice->unkVibratoRate = freeVoice->unkRate = voice->vibrato2 & 0xFF;
+			freeVoice->unkVibratoDepth = freeVoice->unkCount = voice->vibrato2 >> 8;
 			freeVoice->maxAmpl = 0xFF;
 
 			uint8 rate = freeVoice->attackRate;
@@ -650,7 +534,14 @@ void Player_V2CMS::playNote(byte *&data) {
 			rate -= freeVoice->attackRate;
 			freeVoice->curVolume = rate;
 			freeVoice->playingNote = *data;
-			int octave = octaveTable[(*data + 3) << 1] + freeVoice->octaveAdd - 3;
+
+			int effectiveNote = freeVoice->playingNote + 3;
+			if (effectiveNote < 0 || effectiveNote >= ARRAYSIZE(_midiNotes)) {
+				warning("Player_V2CMS::playNote: Note %d out of bounds", effectiveNote);
+				effectiveNote = CLIP<int>(effectiveNote, 0, ARRAYSIZE(_midiNotes) - 1);
+			}
+
+			int octave = _midiNotes[effectiveNote].baseOctave + freeVoice->octaveAdd - 3;
 			if (octave < 0)
 				octave = 0;
 			if (octave > 7)
@@ -658,10 +549,10 @@ void Player_V2CMS::playNote(byte *&data) {
 			if (!octave)
 				++octave;
 			freeVoice->curOctave = octave;
-			freeVoice->curFreq = freqTable[volume << 2];
+			freeVoice->curFreq = _midiNotes[effectiveNote].frequency;
 			freeVoice->curVolume = 0;
-			freeVoice->nextProcessState = PROCESS_ATTACK;
-			if (_lastMidiCommand & 1)
+			freeVoice->nextProcessState = Voice2::kEnvelopeAttack;
+			if (!(_lastMidiCommand & 1))
 				freeVoice->channel = 0xF0;
 			else
 				freeVoice->channel = 0x0F;
@@ -672,35 +563,27 @@ void Player_V2CMS::playNote(byte *&data) {
 
 Player_V2CMS::Voice2 *Player_V2CMS::getPlayVoice(byte param) {
 	byte channelNum = _lastMidiCommand & 0x0F;
-	Voice2 *channel = _midiChannel[channelNum];
+	Voice2 *curVoice = _midiChannel[channelNum];
 
-	if (channel) {
-		Voice2 *backUp = 0;
+	if (curVoice) {
+		Voice2 *prevVoice = 0;
 		while (true) {
-			if (channel->playingNote == param)
+			if (curVoice->playingNote == param)
 				break;
 
-			backUp = channel;
-			channel = channel->nextVoice;
-			if (!channel)
+			prevVoice = curVoice;
+			curVoice = curVoice->nextVoice;
+			if (!curVoice)
 				return 0;
 		}
 
-		Voice2 *backUp2 = channel->nextVoice;
-		{
-			Voice2 *temp = backUp;
-			backUp = channel;
-			channel = temp;
-		}
-		if (channel) {
-			channel->nextVoice = backUp2;
-		} else {
-			_midiChannel[channelNum] = backUp2;
-		}
-		channel = backUp;
+		if (prevVoice)
+			prevVoice->nextVoice = curVoice->nextVoice;
+		else
+			_midiChannel[channelNum] = curVoice->nextVoice;
 	}
 
-	return channel;
+	return curVoice;
 }
 
 void Player_V2CMS::clearNote(byte *&data) {
@@ -708,22 +591,17 @@ void Player_V2CMS::clearNote(byte *&data) {
 	if (voice) {
 		voice->chanNumber = 0xFF;
 		voice->nextVoice = 0;
-		voice->nextProcessState = PROCESS_RELEASE;
+		voice->nextProcessState = Voice2::kEnvelopeRelease;
 	}
 	data += 2;
 }
 
 void Player_V2CMS::play() {
 	_octaveMask = 0xF0;
-	channel_data *chan = &(_channels[0].d);
+	channel_data *chan = &_channels[0].d;
 
-	static byte volumeReg[4] = { 0x00, 0x00, 0x00, 0x00 };
-	static byte octaveReg[4] = { 0x66, 0x66, 0x66, 0x66 };
-	static byte freqReg[4] = { 0xFF, 0xFF, 0xFF, 0xFF };
+	byte noiseGen = 3;
 
-	static byte freqEnable = 0x3E;
-	static byte noiseEnable = 0x01;
-	static byte noiseGen = 0x02;
 	for (int i = 1; i <= 4; ++i) {
 		if (chan->time_left) {
 			uint16 freq = chan->freq;
@@ -733,8 +611,8 @@ void Player_V2CMS::play() {
 					noiseGen = freq & 0xFF;
 				} else {
 					noiseGen = 3;
-					freqReg[0] = freqReg[3];
-					octaveReg[0] = (octaveReg[0] & 0xF0) | ((octaveReg[1] & 0xF0) >> 4);
+					_sfxFreq[0] = _sfxFreq[3];
+					_sfxOctave[0] = (_sfxOctave[0] & 0xF0) | ((_sfxOctave[1] & 0xF0) >> 4);
 				}
 			} else {
 				if (freq == 0) {
@@ -760,17 +638,18 @@ void Player_V2CMS::play() {
 				oct |= cmsOct;
 
 				oct &= _octaveMask;
-				oct |= ((~_octaveMask) & octaveReg[((i & 3) >> 1)]);
-				octaveReg[((i & 3) >> 1)] = oct;
+				oct |= (~_octaveMask) & _sfxOctave[(i & 3) >> 1];
+				_sfxOctave[(i & 3) >> 1] = oct;
 
-				freq >>= -(cmsOct-9);
-				freqReg[(i&3)] = (-(freq-511)) & 0xFF;
+				freq >>= -(cmsOct - 9);
+				_sfxFreq[i & 3] = (-(freq - 511)) & 0xFF;
 			}
-			volumeReg[i & 3] = volumeTable[chan->volume >> 12];
+			_sfxAmpl[i & 3] = _volumeTable[chan->volume >> 12];
 		} else {
-			volumeReg[i & 3] = 0;
+			_sfxAmpl[i & 3] = 0;
 		}
-		chan = &(_channels[i].d);
+
+		chan = &_channels[i].d;
 		_octaveMask ^= 0xFF;
 	}
 
@@ -778,29 +657,29 @@ void Player_V2CMS::play() {
 	// the right channels amplitude is set
 	// with the low value the left channels amplitude
 	_cmsEmu->portWrite(0x221, 0);
-	_cmsEmu->portWrite(0x220, volumeReg[0]);
+	_cmsEmu->portWrite(0x220, _sfxAmpl[0]);
 	_cmsEmu->portWrite(0x221, 1);
-	_cmsEmu->portWrite(0x220, volumeReg[1]);
+	_cmsEmu->portWrite(0x220, _sfxAmpl[1]);
 	_cmsEmu->portWrite(0x221, 2);
-	_cmsEmu->portWrite(0x220, volumeReg[2]);
+	_cmsEmu->portWrite(0x220, _sfxAmpl[2]);
 	_cmsEmu->portWrite(0x221, 3);
-	_cmsEmu->portWrite(0x220, volumeReg[3]);
+	_cmsEmu->portWrite(0x220, _sfxAmpl[3]);
 	_cmsEmu->portWrite(0x221, 8);
-	_cmsEmu->portWrite(0x220, freqReg[0]);
+	_cmsEmu->portWrite(0x220, _sfxFreq[0]);
 	_cmsEmu->portWrite(0x221, 9);
-	_cmsEmu->portWrite(0x220, freqReg[1]);
+	_cmsEmu->portWrite(0x220, _sfxFreq[1]);
 	_cmsEmu->portWrite(0x221, 10);
-	_cmsEmu->portWrite(0x220, freqReg[2]);
+	_cmsEmu->portWrite(0x220, _sfxFreq[2]);
 	_cmsEmu->portWrite(0x221, 11);
-	_cmsEmu->portWrite(0x220, freqReg[3]);
+	_cmsEmu->portWrite(0x220, _sfxFreq[3]);
 	_cmsEmu->portWrite(0x221, 0x10);
-	_cmsEmu->portWrite(0x220, octaveReg[0]);
+	_cmsEmu->portWrite(0x220, _sfxOctave[0]);
 	_cmsEmu->portWrite(0x221, 0x11);
-	_cmsEmu->portWrite(0x220, octaveReg[1]);
+	_cmsEmu->portWrite(0x220, _sfxOctave[1]);
 	_cmsEmu->portWrite(0x221, 0x14);
-	_cmsEmu->portWrite(0x220, freqEnable);
+	_cmsEmu->portWrite(0x220, 0x3E);
 	_cmsEmu->portWrite(0x221, 0x15);
-	_cmsEmu->portWrite(0x220, noiseEnable);
+	_cmsEmu->portWrite(0x220, 0x01);
 	_cmsEmu->portWrite(0x221, 0x16);
 	_cmsEmu->portWrite(0x220, noiseGen);
 }
@@ -838,4 +717,71 @@ void Player_V2CMS::playMusicChips(const MusicChip *table) {
 	} while ((cmsPort & 2) == 0);
 }
 
+const Player_V2CMS::MidiNote Player_V2CMS::_midiNotes[132] = {
+	{   3,  0 }, {  31,  0 }, {  58,  0 }, {  83,  0 },  
+	{ 107,  0 }, { 130,  0 }, { 151,  0 }, { 172,  0 },  
+	{ 191,  0 }, { 209,  0 }, { 226,  0 }, { 242,  0 },  
+	{   3,  1 }, {  31,  1 }, {  58,  1 }, {  83,  1 },  
+	{ 107,  1 }, { 130,  1 }, { 151,  1 }, { 172,  1 },  
+	{ 191,  1 }, { 209,  1 }, { 226,  1 }, { 242,  1 },  
+	{   3,  2 }, {  31,  2 }, {  58,  2 }, {  83,  2 },  
+	{ 107,  2 }, { 130,  2 }, { 151,  2 }, { 172,  2 },  
+	{ 191,  2 }, { 209,  2 }, { 226,  2 }, { 242,  2 },  
+	{   3,  3 }, {  31,  3 }, {  58,  3 }, {  83,  3 },  
+	{ 107,  3 }, { 130,  3 }, { 151,  3 }, { 172,  3 },  
+	{ 191,  3 }, { 209,  3 }, { 226,  3 }, { 242,  3 },  
+	{   3,  4 }, {  31,  4 }, {  58,  4 }, {  83,  4 },  
+	{ 107,  4 }, { 130,  4 }, { 151,  4 }, { 172,  4 },  
+	{ 191,  4 }, { 209,  4 }, { 226,  4 }, { 242,  4 },  
+	{   3,  5 }, {  31,  5 }, {  58,  5 }, {  83,  5 },  
+	{ 107,  5 }, { 130,  5 }, { 151,  5 }, { 172,  5 },  
+	{ 191,  5 }, { 209,  5 }, { 226,  5 }, { 242,  5 },  
+	{   3,  6 }, {  31,  6 }, {  58,  6 }, {  83,  6 },  
+	{ 107,  6 }, { 130,  6 }, { 151,  6 }, { 172,  6 },  
+	{ 191,  6 }, { 209,  6 }, { 226,  6 }, { 242,  6 },  
+	{   3,  7 }, {  31,  7 }, {  58,  7 }, {  83,  7 },  
+	{ 107,  7 }, { 130,  7 }, { 151,  7 }, { 172,  7 },  
+	{ 191,  7 }, { 209,  7 }, { 226,  7 }, { 242,  7 },  
+	{   3,  8 }, {  31,  8 }, {  58,  8 }, {  83,  8 },  
+	{ 107,  8 }, { 130,  8 }, { 151,  8 }, { 172,  8 },  
+	{ 191,  8 }, { 209,  8 }, { 226,  8 }, { 242,  8 },  
+	{   3,  9 }, {  31,  9 }, {  58,  9 }, {  83,  9 },  
+	{ 107,  9 }, { 130,  9 }, { 151,  9 }, { 172,  9 },  
+	{ 191,  9 }, { 209,  9 }, { 226,  9 }, { 242,  9 },  
+	{   3, 10 }, {  31, 10 }, {  58, 10 }, {  83, 10 },  
+	{ 107, 10 }, { 130, 10 }, { 151, 10 }, { 172, 10 },  
+	{ 191, 10 }, { 209, 10 }, { 226, 10 }, { 242, 10 }
+};
+
+const byte Player_V2CMS::_attackRate[16] = {
+	  0,   2,   4,   7,  14,  26,  48,  82,
+	128, 144, 160, 176, 192, 208, 224, 255
+};
+
+const byte Player_V2CMS::_decayRate[16] = {
+	  0,   1,   2,   3,   4,   6,  12,  24,
+	 48,  96, 192, 215, 255, 255, 255, 255
+};
+
+const byte Player_V2CMS::_sustainRate[16] = {
+	255, 180, 128,  96,  80,  64,  56,  48,
+	 42,  36,  32,  28,  24,  20,  16,   0
+};
+
+const byte Player_V2CMS::_releaseRate[16] = {
+	  0,   1,   2,   4,   6,   9,  14,  22,
+	 36,  56,  80, 100, 120, 140, 160, 255
+};
+
+const byte Player_V2CMS::_volumeTable[16] = {
+	0x00, 0x10, 0x10, 0x11, 0x11, 0x21, 0x22, 0x22,
+	0x33, 0x44, 0x55, 0x66, 0x88, 0xAA, 0xCC, 0xFF
+};
+
+const byte Player_V2CMS::_cmsInitData[26] = {
+	0x1C, 0x02,
+	0x00, 0x00, 0x01, 0x00, 0x02, 0x00, 0x03, 0x00, 0x04, 0x00, 0x05, 0x00,
+	0x14, 0x3F, 0x15, 0x00, 0x16, 0x00, 0x18, 0x00, 0x19, 0x00, 0x1C, 0x01
+};
+
 } // End of namespace Scumm
diff --git a/engines/scumm/player_v2cms.h b/engines/scumm/player_v2cms.h
index f7dc0c16b1..905c7c141e 100644
--- a/engines/scumm/player_v2cms.h
+++ b/engines/scumm/player_v2cms.h
@@ -42,18 +42,14 @@ public:
 	virtual void startSound(int sound);
 	virtual void stopSound(int sound);
 	virtual void stopAllSounds();
-//	virtual int  getMusicTimer();
+	virtual int  getMusicTimer();
 	virtual int  getSoundStatus(int sound) const;
 
 	// AudioStream API
-	int readBuffer(int16 *buffer, const int numSamples);
-	bool isStereo() const { return true; }
-	bool endOfData() const { return false; }
-	int getRate() const { return _sampleRate; }
+	virtual int readBuffer(int16 *buffer, const int numSamples);
+	virtual bool isStereo() const { return true; }
 
-protected:
-
-#include "common/pack-start.h"	// START STRUCT PACKING
+private:
 	struct Voice {
 		byte attack;
 		byte decay;
@@ -63,7 +59,7 @@ protected:
 		int16 vibrato;
 		int16 vibrato2;
 		int16 noise;
-	} PACKED_STRUCT;
+	};
 
 	struct Voice2 {
 		byte *amplitudeOutput;
@@ -72,12 +68,12 @@ protected:
 
 		uint8 channel;
 		int8 sustainLevel;
-		int8 attackRate;
+		uint8 attackRate;
 		uint8 maxAmpl;
-		int8 decayRate;
-		int8 sustainRate;
-		int8 releaseRate;
-		int8 releaseTime;
+		uint8 decayRate;
+		uint8 sustainRate;
+		uint8 releaseRate;
+		uint8 releaseTime;
 		int8 vibratoRate;
 		int8 vibratoDepth;
 
@@ -90,10 +86,17 @@ protected:
 		int8 unkRate;
 		int8 unkCount;
 
-		int nextProcessState;
-		int8 curVolume;
-		int8 curOctave;
-		int8 curFreq;
+		enum EnvelopeState {
+			kEnvelopeAttack,
+			kEnvelopeDecay,
+			kEnvelopeSustain,
+			kEnvelopeRelease
+		};
+
+		EnvelopeState nextProcessState;
+		uint8 curVolume;
+		uint8 curOctave;
+		uint8 curFreq;
 
 		int8 octaveAdd;
 
@@ -101,21 +104,20 @@ protected:
 		Voice2 *nextVoice;
 
 		byte chanNumber;
-	} PACKED_STRUCT;
+	};
 
 	struct MusicChip {
 		byte ampl[4];
 		byte freq[4];
 		byte octave[2];
-	} PACKED_STRUCT;
-#include "common/pack-end.h"	// END STRUCT PACKING
+	};
 
 	Voice _cmsVoicesBase[16];
 	Voice2 _cmsVoices[8];
 	MusicChip _cmsChips[2];
 
-	int8 _tempo;
-	int8 _tempoSum;
+	uint8 _tempo;
+	uint8 _tempoSum;
 	byte _looping;
 	byte _octaveMask;
 	int16 _midiDelay;
@@ -126,11 +128,13 @@ protected:
 
 	int _loadedMidiSong;
 
+	byte _sfxFreq[4], _sfxAmpl[4], _sfxOctave[2];
+
 	byte _lastMidiCommand;
 	uint _outputTableReady;
-	byte _clkFrequenz;
-	byte _restart;
-	byte _curSno;
+	byte _voiceTimer;
+
+	int _musicTimer, _musicTimerTicks;
 
 	void loadMidiData(byte *data, int sound);
 	void play();
@@ -147,15 +151,25 @@ protected:
 	void clearNote(byte *&data);
 	void offAllChannels();
 	void playVoice();
-	void processMidiData(uint ticks);
+	void processMidiData();
 
 	Voice2 *getFreeVoice();
 	Voice2 *getPlayVoice(byte param);
 
-	// from Player_V2
-protected:
-	CMSEmulator *_cmsEmu;
+	struct MidiNote {
+		byte frequency;
+		byte baseOctave;
+	};
+
+	static const MidiNote _midiNotes[132];
+	static const byte _attackRate[16];
+	static const byte _decayRate[16];
+	static const byte _sustainRate[16];
+	static const byte _releaseRate[16];
+	static const byte _volumeTable[16];
+	static const byte _cmsInitData[26];
 
+	CMSEmulator *_cmsEmu;
 };
 
 } // End of namespace Scumm
diff --git a/engines/scumm/saveload.cpp b/engines/scumm/saveload.cpp
index 3cc710c207..870ec8cdf7 100644
--- a/engines/scumm/saveload.cpp
+++ b/engines/scumm/saveload.cpp
@@ -686,12 +686,7 @@ Graphics::Surface *ScummEngine::loadThumbnailFromSlot(const char *target, int sl
 
 	Graphics::Surface *thumb = 0;
 	if (Graphics::checkThumbnailHeader(*in)) {
-		thumb = new Graphics::Surface();
-		assert(thumb);
-		if (!Graphics::loadThumbnail(*in, *thumb)) {
-			delete thumb;
-			thumb = 0;
-		}
+		thumb = Graphics::loadThumbnail(*in);
 	}
 
 	delete in;
diff --git a/engines/scumm/scumm-md5.h b/engines/scumm/scumm-md5.h
index 8f555818f4..319eddf871 100644
--- a/engines/scumm/scumm-md5.h
+++ b/engines/scumm/scumm-md5.h
@@ -1,5 +1,5 @@
 /*
-  This file was generated by the md5table tool on Sun Apr 17 10:46:26 2011
+  This file was generated by the md5table tool on Wed Aug  3 03:14:00 2011
   DO NOT EDIT MANUALLY!
  */
 
@@ -99,7 +99,7 @@ static const MD5Table md5table[] = {
 	{ "1ed22f601f8b3695804a6583cc3083f1", "puttrace", "HE 98.5", "", -1, Common::NL_NLD, Common::kPlatformUnknown },
 	{ "1f2e62b5a9c50589fc342285a6bb3a27", "freddi", "HE 73", "", -1, Common::HE_ISR, Common::kPlatformWindows },
 	{ "1fbebd7b2b692df5297870447a80cfed", "atlantis", "Floppy", "Floppy", 12030, Common::DE_DEU, Common::kPlatformPC },
-	{ "1ff5997c78fbd0a841a75ef15a05d9d5", "BluesBirthday", "", "Red", -1, Common::EN_ANY, Common::kPlatformWindows },
+	{ "1ff5997c78fbd0a841a75ef15a05d9d5", "BluesBirthday", "Red", "Red", -1, Common::EN_ANY, Common::kPlatformUnknown },
 	{ "2012f854d83d9cc6f73b2b544cd8bbf8", "water", "HE 80", "", -1, Common::RU_RUS, Common::kPlatformWindows },
 	{ "20176076d708bf14407bcc9bdcd7a418", "pajama3", "", "", -1, Common::RU_RUS, Common::kPlatformWindows },
 	{ "204453e33456c4faa26e276229fe5b76", "spyfox2", "", "Demo", 14689, Common::DE_DEU, Common::kPlatformWindows },
@@ -403,7 +403,7 @@ static const MD5Table md5table[] = {
 	{ "9781422e4288dbc090720e4563168ba7", "puttzoo", "", "", -1, Common::FR_FRA, Common::kPlatformWindows },
 	{ "981e1e1891f2be7e25a01f50ae55a5af", "puttrace", "HE 98", "", -1, Common::EN_USA, Common::kPlatformUnknown },
 	{ "98744fe66ff730e8c2b3b1f58803ab0b", "atlantis", "Floppy", "Demo", -1, Common::EN_ANY, Common::kPlatformPC },
-	{ "99128b6a5bdd9831d9682fb8b5cbf8d4", "BluesBirthday", "", "Yellow", -1, Common::EN_ANY, Common::kPlatformUnknown },
+	{ "99128b6a5bdd9831d9682fb8b5cbf8d4", "BluesBirthday", "Yellow", "Yellow", -1, Common::EN_ANY, Common::kPlatformUnknown },
 	{ "99a3699f80b8f776efae592b44b9b991", "maniac", "V2", "V2", -1, Common::FR_FRA, Common::kPlatformPC },
 	{ "99b6f822b0b2612415407865438697d6", "atlantis", "", "Demo", -1, Common::EN_ANY, Common::kPlatformPC },
 	{ "9b7452b5cd6d3ffb2b2f5118010af84f", "ft", "Demo", "Demo", 116463537, Common::EN_ANY, Common::kPlatformMacintosh },
diff --git a/engines/scumm/scumm.cpp b/engines/scumm/scumm.cpp
index 0f01e39459..3b83019275 100644
--- a/engines/scumm/scumm.cpp
+++ b/engines/scumm/scumm.cpp
@@ -299,7 +299,6 @@ ScummEngine::ScummEngine(OSystem *syst, const DetectorResult &dr)
 	_haveActorSpeechMsg = false;
 	_useTalkAnims = false;
 	_defaultTalkDelay = 0;
-	_musicType = MDT_NONE;
 	_saveSound = 0;
 	memset(_extraBoxFlags, 0, sizeof(_extraBoxFlags));
 	memset(_scaleSlots, 0, sizeof(_scaleSlots));
@@ -1669,43 +1668,8 @@ void ScummEngine_v90he::resetScumm() {
 	_sprite->resetTables(0);
 	memset(&_wizParams, 0, sizeof(_wizParams));
 
-	if (_game.heversion >= 98) {
-		switch (_game.id) {
-		case GID_PUTTRACE:
-			_logicHE = new LogicHErace(this);
-			break;
-
-		case GID_FUNSHOP:
-			_logicHE = new LogicHEfunshop(this);
-			break;
-
-		case GID_FOOTBALL:
-			_logicHE = new LogicHEfootball(this);
-			break;
-
-		case GID_SOCCER:
-		case GID_SOCCERMLS:
-		case GID_SOCCER2004:
-			_logicHE = new LogicHEsoccer(this);
-			break;
-
-		case GID_BASEBALL2001:
-			_logicHE = new LogicHEbaseball2001(this);
-			break;
-
-		case GID_BASKETBALL:
-			_logicHE = new LogicHEbasketball(this);
-			break;
-
-		case GID_MOONBASE:
-			_logicHE = new LogicHEmoonbase(this);
-			break;
-
-		default:
-			_logicHE = new LogicHE(this);
-			break;
-		}
-	}
+	if (_game.heversion >= 98)
+		_logicHE = LogicHE::makeLogicHE(this);
 }
 
 void ScummEngine_v99he::resetScumm() {
@@ -1746,40 +1710,36 @@ void ScummEngine::setupMusic(int midi) {
 
 	switch (MidiDriver::getMusicType(dev)) {
 	case MT_NULL:
-		_musicType = MDT_NONE;
+		_sound->_musicType = MDT_NONE;
 		break;
 	case MT_PCSPK:
-		_musicType = MDT_PCSPK;
+		_sound->_musicType = MDT_PCSPK;
 		break;
 	case MT_PCJR:
-		_musicType = MDT_PCJR;
+		_sound->_musicType = MDT_PCJR;
 		break;
-	//case MT_CMS:
-#if 1
-		_musicType = MDT_ADLIB;
-#else
-		_musicType = MDT_CMS; // Still has number of bugs, disable by default
-#endif
+	case MT_CMS:
+		_sound->_musicType = MDT_CMS;
 		break;
 	case MT_TOWNS:
-		_musicType = MDT_TOWNS;
+		_sound->_musicType = MDT_TOWNS;
 		break;
 	case MT_ADLIB:
-		_musicType = MDT_ADLIB;
+		_sound->_musicType = MDT_ADLIB;
 		break;
 	case MT_C64:
-		_musicType = MDT_C64;
+		_sound->_musicType = MDT_C64;
 		break;
 	case MT_APPLEIIGS:
-		_musicType = MDT_APPLEIIGS;
+		_sound->_musicType = MDT_APPLEIIGS;
 		break;
 	default:
-		_musicType = MDT_MIDI;
+		_sound->_musicType = MDT_MIDI;
 		break;
 	}
 
 	if ((_game.id == GID_MONKEY_EGA || (_game.id == GID_LOOM && _game.version == 3))
-	   &&  (_game.platform == Common::kPlatformPC) && _musicType == MDT_MIDI) {
+	   &&  (_game.platform == Common::kPlatformPC) && _sound->_musicType == MDT_MIDI) {
 		Common::String fileName;
 		bool missingFile = false;
 		if (_game.id == GID_LOOM) {
@@ -1809,7 +1769,7 @@ void ScummEngine::setupMusic(int midi) {
 					"but %s is missing. Using AdLib instead."), fileName.c_str()),
 				_("OK"));
 			dialog.runModal();
-			_musicType = MDT_ADLIB;
+			_sound->_musicType = MDT_ADLIB;
 		}
 	}
 
@@ -1823,9 +1783,9 @@ void ScummEngine::setupMusic(int midi) {
 	 * automatically when samples need to be generated */
 	if (!_mixer->isReady()) {
 		warning("Sound mixer initialization failed");
-		if (_musicType == MDT_ADLIB || _musicType == MDT_PCSPK || _musicType == MDT_PCJR || _musicType == MDT_CMS) {
+		if (_sound->_musicType == MDT_ADLIB || _sound->_musicType == MDT_PCSPK || _sound->_musicType == MDT_PCJR || _sound->_musicType == MDT_CMS) {
 			dev = 0;
-			_musicType = MDT_NONE;
+			_sound->_musicType = MDT_NONE;
 			warning("MIDI driver depends on sound mixer, switching to null MIDI driver");
 		}
 	}
@@ -1857,9 +1817,9 @@ void ScummEngine::setupMusic(int midi) {
 		_musicEngine = new Player_V1(this, _mixer, MidiDriver::getMusicType(dev) != MT_PCSPK);
 	} else if (_game.version <= 2) {
 		_musicEngine = new Player_V2(this, _mixer, MidiDriver::getMusicType(dev) != MT_PCSPK);
-	} else if ((_musicType == MDT_PCSPK || _musicType == MDT_PCJR) && (_game.version > 2 && _game.version <= 4)) {
+	} else if ((_sound->_musicType == MDT_PCSPK || _sound->_musicType == MDT_PCJR) && (_game.version > 2 && _game.version <= 4)) {
 		_musicEngine = new Player_V2(this, _mixer, MidiDriver::getMusicType(dev) != MT_PCSPK);
-	} else if (_musicType == MDT_CMS) {
+	} else if (_sound->_musicType == MDT_CMS) {
 		_musicEngine = new Player_V2CMS(this, _mixer);
 	} else if (_game.platform == Common::kPlatform3DO && _game.heversion <= 62) {
 		// 3DO versions use digital music and sound samples.
@@ -1871,15 +1831,15 @@ void ScummEngine::setupMusic(int midi) {
 		MidiDriver *nativeMidiDriver = 0;
 		MidiDriver *adlibMidiDriver = 0;
 
-		if (_musicType != MDT_ADLIB && _musicType != MDT_TOWNS && _musicType != MDT_PCSPK)
+		if (_sound->_musicType != MDT_ADLIB && _sound->_musicType != MDT_TOWNS && _sound->_musicType != MDT_PCSPK)
 			nativeMidiDriver = MidiDriver::createMidi(dev);
 		if (nativeMidiDriver != NULL && _native_mt32)
 			nativeMidiDriver->property(MidiDriver::PROP_CHANNEL_MASK, 0x03FE);
-		bool multi_midi = ConfMan.getBool("multi_midi") && _musicType != MDT_NONE && _musicType != MDT_PCSPK && (midi & MDT_ADLIB);
-		if (_musicType == MDT_ADLIB || _musicType == MDT_TOWNS || multi_midi) {
-			adlibMidiDriver = MidiDriver::createMidi(MidiDriver::detectDevice(_musicType == MDT_TOWNS ? MDT_TOWNS : MDT_ADLIB));
+		bool multi_midi = ConfMan.getBool("multi_midi") && _sound->_musicType != MDT_NONE && _sound->_musicType != MDT_PCSPK && (midi & MDT_ADLIB);
+		if (_sound->_musicType == MDT_ADLIB || _sound->_musicType == MDT_TOWNS || multi_midi) {
+			adlibMidiDriver = MidiDriver::createMidi(MidiDriver::detectDevice(_sound->_musicType == MDT_TOWNS ? MDT_TOWNS : MDT_ADLIB));
 			adlibMidiDriver->property(MidiDriver::PROP_OLD_ADLIB, (_game.features & GF_SMALL_HEADER) ? 1 : 0);
-		} else if (_musicType == MDT_PCSPK) {
+		} else if (_sound->_musicType == MDT_PCSPK) {
 			adlibMidiDriver = new PcSpkDriver(_mixer);
 		}
 
@@ -1909,7 +1869,7 @@ void ScummEngine::setupMusic(int midi) {
 				_imuse->property(IMuse::PROP_LIMIT_PLAYERS, 1);
 				_imuse->property(IMuse::PROP_RECYCLE_PLAYERS, 1);
 			}
-			if (_musicType == MDT_PCSPK)
+			if (_sound->_musicType == MDT_PCSPK)
 				_imuse->property(IMuse::PROP_PC_SPEAKER, 1);
 		}
 	}
diff --git a/engines/scumm/scumm.h b/engines/scumm/scumm.h
index e503af750d..04a175e732 100644
--- a/engines/scumm/scumm.h
+++ b/engines/scumm/scumm.h
@@ -40,8 +40,6 @@
 #include "scumm/detection.h"
 #include "scumm/script.h"
 
-#include "audio/mididrv.h"
-
 #ifdef __DS__
 /* This disables the dual layer mode which is used in FM-Towns versions
  * of SCUMM games and which emulates the behavior of the original code.
@@ -235,7 +233,8 @@ enum ScummGameId {
 	GID_PUTTMOON,
 	GID_FUNPACK,
 	GID_FREDDI3,
-	GID_BIRTHDAY,
+	GID_BIRTHDAYRED,
+	GID_BIRTHDAYYELLOW,
 	GID_TREASUREHUNT,
 	GID_PUTTRACE,
 	GID_FUNSHOP,	// Used for all three funshops
@@ -1084,7 +1083,6 @@ protected:
 	int _saveSound;
 	bool _native_mt32;
 	bool _enable_gs;
-	MidiDriverFlags _musicType;
 	bool _copyProtection;
 
 public:
diff --git a/engines/scumm/smush/channel.cpp b/engines/scumm/smush/channel.cpp
index 7f71d0549b..fd822f56b6 100644
--- a/engines/scumm/smush/channel.cpp
+++ b/engines/scumm/smush/channel.cpp
@@ -60,6 +60,8 @@ void SmushChannel::processBuffer() {
 			if (offset < _tbufferSize) {
 				int new_size = _tbufferSize - offset;
 				_tbuffer = (byte *)malloc(new_size);
+				// FIXME: _tbuffer might be 0 if new_size is 0.
+				// NB: Also check other "if (_tbuffer)" locations in smush
 				if (!_tbuffer)
 					error("smush channel failed to allocate memory");
 				memcpy(_tbuffer, _sbuffer + offset, new_size);
@@ -97,6 +99,8 @@ void SmushChannel::processBuffer() {
 				byte *old = _tbuffer;
 				int32 new_size = _tbufferSize - offset;
 				_tbuffer = (byte *)malloc(new_size);
+				// FIXME: _tbuffer might be 0 if new_size is 0.
+				// NB: Also check other "if (_tbuffer)" locations in smush
 				if (!_tbuffer)
 					error("smush channel failed to allocate memory");
 				memcpy(_tbuffer, old + offset, new_size);
diff --git a/engines/scumm/smush/codec37.cpp b/engines/scumm/smush/codec37.cpp
index dcc8ee3c19..344057e3ac 100644
--- a/engines/scumm/smush/codec37.cpp
+++ b/engines/scumm/smush/codec37.cpp
@@ -571,4 +571,3 @@ void Codec37Decoder::decode(byte *dst, const byte *src) {
 }
 
 } // End of namespace Scumm
-
diff --git a/engines/scumm/smush/smush_font.cpp b/engines/scumm/smush/smush_font.cpp
index 7765bf1292..5cfa0ea519 100644
--- a/engines/scumm/smush/smush_font.cpp
+++ b/engines/scumm/smush/smush_font.cpp
@@ -258,4 +258,3 @@ void SmushFont::drawStringWrap(const char *str, byte *buffer, int dst_width, int
 }
 
 } // End of namespace Scumm
-
diff --git a/engines/scumm/sound.cpp b/engines/scumm/sound.cpp
index c3cad19fdc..d8235206f8 100644
--- a/engines/scumm/sound.cpp
+++ b/engines/scumm/sound.cpp
@@ -84,6 +84,8 @@ Sound::Sound(ScummEngine *parent, Audio::Mixer *mixer)
 	memset(_soundQue, 0, sizeof(_soundQue));
 	memset(_soundQue2, 0, sizeof(_soundQue2));
 	memset(_mouthSyncTimes, 0, sizeof(_mouthSyncTimes));
+
+	_musicType = MDT_NONE;
 }
 
 Sound::~Sound() {
@@ -1016,7 +1018,7 @@ void Sound::startCDTimer() {
 	// appears.
 
 	_vm->getTimerManager()->removeTimerProc(&cd_timer_handler);
-	_vm->getTimerManager()->installTimerProc(&cd_timer_handler, 100700, _vm);
+	_vm->getTimerManager()->installTimerProc(&cd_timer_handler, 100700, _vm, "scummCDtimer");
 }
 
 void Sound::stopCDTimer() {
@@ -1094,7 +1096,7 @@ int ScummEngine::readSoundResource(ResId idx) {
 	switch (basetag) {
 	case MKTAG('M','I','D','I'):
 	case MKTAG('i','M','U','S'):
-		if (_musicType != MDT_PCSPK && _musicType != MDT_PCJR) {
+		if (_sound->_musicType != MDT_PCSPK && _sound->_musicType != MDT_PCJR) {
 			_fileHandle->seek(-8, SEEK_CUR);
 			_fileHandle->read(_res->createResource(rtSound, idx, total_size + 8), total_size + 8);
 			return 1;
@@ -1118,7 +1120,7 @@ int ScummEngine::readSoundResource(ResId idx) {
 				break;
 			case MKTAG('A','D','L',' '):
 				pri = 1;
-				if (_musicType == MDT_ADLIB || _musicType == MDT_TOWNS)
+				if (_sound->_musicType == MDT_ADLIB || _sound->_musicType == MDT_TOWNS)
 					pri = 10;
 				break;
 			case MKTAG('A','M','I',' '):
@@ -1137,15 +1139,15 @@ int ScummEngine::readSoundResource(ResId idx) {
 				break;
 			case MKTAG('S','P','K',' '):
 				pri = -1;
-				if (_musicType == MDT_PCSPK || _musicType == MDT_PCJR)
+				if (_sound->_musicType == MDT_PCSPK || _sound->_musicType == MDT_PCJR)
 					pri = 11;
 				break;
 			}
 
-			// We only allow SPK resources for PC Speaker, PCJr and CMS here
+			// We only allow SPK resources for PC Speaker and PCJr here
 			// since other resource would sound horribly with their output
 			// drivers.
-			if ((_musicType == MDT_PCSPK || _musicType == MDT_PCJR || _musicType == MDT_CMS) && pri != 11)
+			if ((_sound->_musicType == MDT_PCSPK || _sound->_musicType == MDT_PCJR) && pri != 11)
 				pri = -1;
 
 			// We only allow ADL resources when AdLib or FM-Towns is used as
@@ -1155,12 +1157,16 @@ int ScummEngine::readSoundResource(ResId idx) {
 			// only contains a ROL resource for sound id 60. Formerly we tried
 			// to play that via the AdLib or FM-Towns audio driver resulting
 			// in strange noises. Now we behave like the original did.
-			if ((_musicType == MDT_ADLIB || _musicType == MDT_TOWNS) && pri != 10)
+			// We make an exception for Macintosh, which uses priority 2 for
+			// its sound resources, and Amiga games, which feature only ROL
+			// resources, since we are a doing Midi -> AdLib conversion for
+			// these.
+			if ((_sound->_musicType == MDT_ADLIB || _sound->_musicType == MDT_TOWNS) && pri != 10
+				&& pri != 2 && _game.platform != Common::kPlatformAmiga)
 				pri = -1;
 
 			debugC(DEBUG_RESOURCE, "    tag: %s, total_size=%d, pri=%d", tag2str(tag), size, pri);
 
-
 			if (pri > best_pri) {
 				best_pri = pri;
 				best_size = size;
@@ -1997,6 +2003,14 @@ static void convertADResource(ResourceManager *res, const GameSettings& game, Re
 				break;
 
 			case 0x80:
+				// FIXME: This is incorrect. The original uses 0x80 for
+				// looping a single channel. We currently interpret it as stop
+				// thus we won't get looping for sound effects. It should
+				// always jump to the start of the channel.
+				//
+				// Since we convert the data to MIDI and we cannot only loop a
+				// single channel via MIDI fixing this will require some more
+				// thought.
 				track_time[ch] = -1;
 				src_ptr ++;
 				break;
@@ -2087,7 +2101,7 @@ int ScummEngine::readSoundResourceSmallHeader(ResId idx) {
 		}
 	}
 
-	if ((_musicType == MDT_PCSPK || _musicType == MDT_PCJR) && wa_offs != 0) {
+	if ((_sound->_musicType == MDT_PCSPK || _sound->_musicType == MDT_PCJR) && wa_offs != 0) {
 		if (_game.features & GF_OLD_BUNDLE) {
 			_fileHandle->seek(wa_offs, SEEK_SET);
 			_fileHandle->read(_res->createResource(rtSound, idx, wa_size), wa_size);
@@ -2096,18 +2110,37 @@ int ScummEngine::readSoundResourceSmallHeader(ResId idx) {
 			_fileHandle->read(_res->createResource(rtSound, idx, wa_size + 6), wa_size + 6);
 		}
 		return 1;
-	} else if (_musicType == MDT_CMS && ad_offs != 0) {
+	} else if (_sound->_musicType == MDT_CMS) {
 		if (_game.features & GF_OLD_BUNDLE) {
-			_fileHandle->seek(wa_offs + wa_size + 6, SEEK_SET);
-			byte musType = _fileHandle->readByte();
+			bool hasAdLibMusicTrack = false;
 
-			if (musType == 0x80) {
+			if (ad_offs) {
+				_fileHandle->seek(ad_offs + 4 + 2, SEEK_SET);
+				hasAdLibMusicTrack = (_fileHandle->readByte() == 0x80);
+			}
+
+			if (hasAdLibMusicTrack) {
 				_fileHandle->seek(ad_offs, SEEK_SET);
 				_fileHandle->read(_res->createResource(rtSound, idx, ad_size), ad_size);
 			} else {
 				_fileHandle->seek(wa_offs, SEEK_SET);
 				_fileHandle->read(_res->createResource(rtSound, idx, wa_size), wa_size);
 			}
+		} else {
+			bool hasAdLibMusicTrack = false;
+
+			if (ad_offs) {
+				_fileHandle->seek(ad_offs + 2, SEEK_SET);
+				hasAdLibMusicTrack = (_fileHandle->readByte() == 0x80);
+			}
+
+			if (hasAdLibMusicTrack) {
+				_fileHandle->seek(ad_offs - 4, SEEK_SET);
+				_fileHandle->read(_res->createResource(rtSound, idx, ad_size + 4), ad_size + 4);
+			} else {
+				_fileHandle->seek(wa_offs - 6, SEEK_SET);
+				_fileHandle->read(_res->createResource(rtSound, idx, wa_size + 6), wa_size + 6);
+			}
 		}
 	} else if (ad_offs != 0) {
 		// AD resources have a header, instrument definitions and one MIDI track.
diff --git a/engines/scumm/sound.h b/engines/scumm/sound.h
index 03659ceff1..e9a37ac9fa 100644
--- a/engines/scumm/sound.h
+++ b/engines/scumm/sound.h
@@ -24,6 +24,7 @@
 
 #include "common/scummsys.h"
 #include "audio/audiostream.h"
+#include "audio/mididrv.h"
 #include "audio/mixer.h"
 #include "scumm/saveload.h"
 
@@ -90,6 +91,8 @@ public:
 	byte _sfxMode;
 	uint _lastSound;
 
+	MidiDriverFlags _musicType;
+
 public:
 	Sound(ScummEngine *parent, Audio::Mixer *mixer);
 	virtual ~Sound();
diff --git a/engines/scumm/string.cpp b/engines/scumm/string.cpp
index 2d2209c155..61bb89328d 100644
--- a/engines/scumm/string.cpp
+++ b/engines/scumm/string.cpp
@@ -1127,8 +1127,6 @@ int ScummEngine::convertMessageToString(const byte *msg, byte *dst, int dstSize)
 				}
 				num += (_game.version == 8) ? 4 : 2;
 			}
-		} else if (_game.id == GID_DIG && (chr == 1 || chr == 2 || chr == 3 || chr == 8)) {
-			// Skip these characters
 		} else {
 			if ((chr != '@') || (_game.id == GID_CMI && _language == Common::ZH_TWN) ||
 				(_game.id == GID_LOOM && _game.platform == Common::kPlatformPCEngine && _language == Common::JA_JPN) ||
@@ -1142,6 +1140,14 @@ int ScummEngine::convertMessageToString(const byte *msg, byte *dst, int dstSize)
 		if (dst >= end)
 			error("convertMessageToString: buffer overflow");
 	}
+
+	// WORKAROUND: Russian The Dig pads messages with 03. No idea why
+	// it does not work as is with our rendering code, thus fixing it
+	// with a workaround.
+	if (_game.id == GID_DIG) {
+		while (*(dst - 1) == 0x03)
+			dst--;
+	}
 	*dst = 0;
 
 	return dstSize - (end - dst);
diff --git a/engines/scumm/vars.cpp b/engines/scumm/vars.cpp
index 4527d7a121..26a6a2f3b1 100644
--- a/engines/scumm/vars.cpp
+++ b/engines/scumm/vars.cpp
@@ -25,9 +25,12 @@
 #include "scumm/scumm.h"
 #include "scumm/scumm_v0.h"
 #include "scumm/scumm_v8.h"
+#include "scumm/sound.h"
 #include "scumm/he/intern_he.h"
 #include "scumm/he/logic_he.h"
 
+#include "audio/mididrv.h"
+
 namespace Scumm {
 
 void ScummEngine::setupScummVars() {
@@ -722,7 +725,7 @@ void ScummEngine::resetScummVars() {
 		// 2 CMS
 		// 3 AdLib
 		// 4 Roland
-		switch (_musicType) {
+		switch (_sound->_musicType) {
 		case MDT_NONE:
 		case MDT_PCSPK:
 			VAR(VAR_SOUNDCARD) = 0;