PRINCE: code formating fixed

17 files changed, 691 insertions, 610 deletions

diff --git a/engines/prince/archive.h b/engines/prince/archive.h
index 3f5c5be4ef..8e106693dc 100644
--- a/engines/prince/archive.h
+++ b/engines/prince/archive.h
@@ -25,6 +25,7 @@
 
 #include "common/archive.h"
 
+// This is here just as remainder that archive support is missing
 namespace Price {
 
 class Archive : public Common::Archive {
diff --git a/engines/prince/debugger.cpp b/engines/prince/debugger.cpp
index 2415c1c7ce..be9677b99f 100644
--- a/engines/prince/debugger.cpp
+++ b/engines/prince/debugger.cpp
@@ -26,113 +26,130 @@
 namespace Prince {
 
 Debugger::Debugger(PrinceEngine *vm) : GUI::Debugger(), _vm(vm) {
-	DCmd_Register("continue",		WRAP_METHOD(Debugger, Cmd_Exit));
-	DCmd_Register("setflag",		WRAP_METHOD(Debugger, Cmd_SetFlag));
-	DCmd_Register("getflag",		WRAP_METHOD(Debugger, Cmd_GetFlag));
-	DCmd_Register("clearflag",		WRAP_METHOD(Debugger, Cmd_ClearFlag));
-	DCmd_Register("viewflc",		WRAP_METHOD(Debugger, Cmd_ViewFlc));
-	DCmd_Register("initroom",		WRAP_METHOD(Debugger, Cmd_InitRoom));
-	DCmd_Register("changecursor",	WRAP_METHOD(Debugger, Cmd_ChangeCursor));
+    DCmd_Register("continue",       WRAP_METHOD(Debugger, Cmd_Exit));
+    DCmd_Register("level",          WRAP_METHOD(Debugger, Cmd_DebugLevel));
+    DCmd_Register("setflag",        WRAP_METHOD(Debugger, Cmd_SetFlag));
+    DCmd_Register("getflag",        WRAP_METHOD(Debugger, Cmd_GetFlag));
+    DCmd_Register("clearflag",      WRAP_METHOD(Debugger, Cmd_ClearFlag));
+    DCmd_Register("viewflc",        WRAP_METHOD(Debugger, Cmd_ViewFlc));
+    DCmd_Register("initroom",       WRAP_METHOD(Debugger, Cmd_InitRoom));
+    DCmd_Register("changecursor",   WRAP_METHOD(Debugger, Cmd_ChangeCursor));
 }
 
 static int strToInt(const char *s) {
-	if (!*s)
-		// No string at all
-		return 0;
-	else if (toupper(s[strlen(s) - 1]) != 'H')
-		// Standard decimal string
-		return atoi(s);
-
-	// Hexadecimal string
-	uint tmp = 0;
-	int read = sscanf(s, "%xh", &tmp);
-	if (read < 1)
-		error("strToInt failed on string \"%s\"", s);
-	return (int)tmp;
+    if (!*s)
+        // No string at all
+        return 0;
+    else if (toupper(s[strlen(s) - 1]) != 'H')
+        // Standard decimal string
+        return atoi(s);
+
+    // Hexadecimal string
+    uint tmp = 0;
+    int read = sscanf(s, "%xh", &tmp);
+    if (read < 1)
+        error("strToInt failed on string \"%s\"", s);
+    return (int)tmp;
+}
+
+bool Debugger::Cmd_DebugLevel(int argc, const char **argv) {
+    if (argc == 1) {
+            DebugPrintf("Debugging is currently set at level %d\n", gDebugLevel);
+    } else { // set level
+        gDebugLevel = atoi(argv[1]);
+        if (0 <= gDebugLevel && gDebugLevel < 11) {
+            DebugPrintf("Debug level set to level %d\n", gDebugLevel);
+        } else if (gDebugLevel < 0) {
+            DebugPrintf("Debugging is now disabled\n");
+        } else
+            DebugPrintf("Not a valid debug level (0 - 10)\n");
+    }
+
+    return true;
 }
 
 /*
  * This command sets a flag
  */
 bool Debugger::Cmd_SetFlag(int argc, const char **argv) {
-	// Check for a flag to set
-	if (argc != 2) {
-		DebugPrintf("Usage: %s <flag number>\n", argv[0]);
-		return true;
-	}
-
-	int flagNum = strToInt(argv[1]);
-	//g_globals->setFlag(flagNum);
-	return true;
+    // Check for a flag to set
+    if (argc != 2) {
+        DebugPrintf("Usage: %s <flag number>\n", argv[0]);
+        return true;
+    }
+
+    int flagNum = strToInt(argv[1]);
+    //g_globals->setFlag(flagNum);
+    return true;
 }
 
 /*
  * This command gets the value of a flag
  */
 bool Debugger::Cmd_GetFlag(int argc, const char **argv) {
-	// Check for an flag to display
-	if (argc != 2) {
-		DebugPrintf("Usage: %s <flag number>\n", argv[0]);
-		return true;
-	}
-
-	int flagNum = strToInt(argv[1]);
-	//DebugPrintf("Value: %d\n", g_globals->getFlag(flagNum));
-	return true;
+    // Check for an flag to display
+    if (argc != 2) {
+        DebugPrintf("Usage: %s <flag number>\n", argv[0]);
+        return true;
+    }
+
+    int flagNum = strToInt(argv[1]);
+    //DebugPrintf("Value: %d\n", g_globals->getFlag(flagNum));
+    return true;
 }
 
 /*
  * This command clears a flag
  */
 bool Debugger::Cmd_ClearFlag(int argc, const char **argv) {
-	// Check for a flag to clear
-	if (argc != 2) {
-		DebugPrintf("Usage: %s <flag number>\n", argv[0]);
-		return true;
-	}
-
-	int flagNum = strToInt(argv[1]);
-	//g_globals->clearFlag(flagNum);
-	return true;
+    // Check for a flag to clear
+    if (argc != 2) {
+        DebugPrintf("Usage: %s <flag number>\n", argv[0]);
+        return true;
+    }
+
+    int flagNum = strToInt(argv[1]);
+    //g_globals->clearFlag(flagNum);
+    return true;
 }
 
 /*
  * This command starts new flc anim
  */
 bool Debugger::Cmd_ViewFlc(int argc, const char **argv) {
-	// Check for a flag to clear
-	if (argc != 2) {
-		DebugPrintf("Usage: %s <anim number>\n", argv[0]);
-		return true;
-	}
-
-	int flagNum = strToInt(argv[1]);
-	_vm->loadAnim(flagNum, false);
-	return true;
+    // Check for a flag to clear
+    if (argc != 2) {
+        DebugPrintf("Usage: %s <anim number>\n", argv[0]);
+        return true;
+    }
+
+    int flagNum = strToInt(argv[1]);
+    _vm->loadAnim(flagNum, false);
+    return true;
 }
 
 bool Debugger::Cmd_InitRoom(int argc, const char **argv) {
-	// Check for a flag to clear
-	if (argc != 2) {
-		DebugPrintf("Usage: %s <anim number>\n", argv[0]);
-		return true;
-	}
-
-	int flagNum = strToInt(argv[1]);
-	_vm->loadLocation(flagNum);
-	return true;
+    // Check for a flag to clear
+    if (argc != 2) {
+        DebugPrintf("Usage: %s <anim number>\n", argv[0]);
+        return true;
+    }
+
+    int flagNum = strToInt(argv[1]);
+    _vm->loadLocation(flagNum);
+    return true;
 }
 
 bool Debugger::Cmd_ChangeCursor(int argc, const char **argv) {
-	// Check for a flag to clear
-	if (argc != 2) {
-		DebugPrintf("Usage: %s <curId>\n", argv[0]);
-		return true;
-	}
-
-	int flagNum = strToInt(argv[1]);
-	_vm->changeCursor(flagNum);
-	return true;
+    // Check for a flag to clear
+    if (argc != 2) {
+        DebugPrintf("Usage: %s <curId>\n", argv[0]);
+        return true;
+    }
+
+    int flagNum = strToInt(argv[1]);
+    _vm->changeCursor(flagNum);
+    return true;
 }
 
 } 
diff --git a/engines/prince/debugger.h b/engines/prince/debugger.h
index 087f29e550..08b1676fd7 100644
--- a/engines/prince/debugger.h
+++ b/engines/prince/debugger.h
@@ -36,6 +36,7 @@ public:
 	virtual ~Debugger() {}	// we need this for __SYMBIAN32__ archaic gcc/UIQ
 
 private:
+	bool Cmd_DebugLevel(int argc, const char **argv);
 	bool Cmd_SetFlag(int argc, const char **argv);
 	bool Cmd_GetFlag(int argc, const char **argv);
 	bool Cmd_ClearFlag(int argc, const char **argv);
diff --git a/engines/prince/detection.cpp b/engines/prince/detection.cpp
index c5f6039ca1..fa9df38c90 100644
--- a/engines/prince/detection.cpp
+++ b/engines/prince/detection.cpp
@@ -1,145 +1,147 @@
-/* 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 "base/plugins.h"

-#include "engines/advancedDetector.h"

-

-#include "prince/prince.h"

-

-namespace Prince {

-

-struct PrinceGameDescription {

-    ADGameDescription desc;

-

-    int gameType;

-};

-

-int PrinceEngine::getGameType() const {

-    return _gameDescription->gameType;

-}

-

-const char *PrinceEngine::getGameId() const {

-    return _gameDescription->desc.gameid;

-}

-

-uint32 PrinceEngine::getFeatures() const {

-    return _gameDescription->desc.flags;

-}

-

-Common::Language PrinceEngine::getLanguage() const {

-    return _gameDescription->desc.language;

-}

-

-}

-

-static const PlainGameDescriptor princeGames[] = {

-    {"prince", "Prince Game"},

-    {0, 0}

-};

-

-namespace Prince {

-

-static const PrinceGameDescription gameDescriptions[] = {

-    

-    // German

-    {

-        {

-            "prince",

-            "Galador",

-            AD_ENTRY1s("databank.ptc", "5fa03833177331214ec1354761b1d2ee", 3565031),

-            Common::DE_DEU,

-            Common::kPlatformWindows,

-            ADGF_NO_FLAGS,

-            GUIO1(GUIO_NONE)

-        },

-        0

-    },

-    // Polish

-    {

-        {

-            "prince",

-            "Ksiaze i Tchorz",

-            AD_ENTRY1s("databank.ptc", "48ec9806bda9d152acbea8ce31c93c49", 3435298),

-            Common::PL_POL,

-            Common::kPlatformWindows,

-            ADGF_NO_FLAGS,

-            GUIO1(GUIO_NONE)

-        },

-        1

-    },

-

-

-    { AD_TABLE_END_MARKER, 0 }

-};

-

-} // End of namespace Prince

-

-using namespace Prince;

-

-// we match from data too, to stop detection from a non-top-level directory

-const static char *directoryGlobs[] = {

-    "all",

-    0

-};

-

-class PrinceMetaEngine : public AdvancedMetaEngine {

-public:

-    PrinceMetaEngine() : AdvancedMetaEngine(Prince::gameDescriptions, sizeof(Prince::PrinceGameDescription), princeGames) {

-        _singleid = "prince";

-        _maxScanDepth = 2;

-        _directoryGlobs = directoryGlobs;

-    }

-

-    virtual const char *getName() const {

-        return "Prince Engine";

-    }

-

-    virtual const char *getOriginalCopyright() const {

-        return "Copyright (C)";

-    }

-

-    virtual bool createInstance(OSystem *syst, Engine **engine, const ADGameDescription *desc) const;

-    virtual bool hasFeature(MetaEngineFeature f) const;

-};

-

-bool PrinceMetaEngine::createInstance(OSystem *syst, Engine **engine, const ADGameDescription *desc) const {

-    using namespace Prince;

-    const PrinceGameDescription *gd = (const PrinceGameDescription *)desc;

-    if (gd) {

-        *engine = new PrinceEngine(syst, gd);

-    }

-    return gd != 0;

-}

-

-bool PrinceMetaEngine::hasFeature(MetaEngineFeature f) const {

-    return false;

-}

-

-bool Prince::PrinceEngine::hasFeature(EngineFeature f) const {

-    return false;//(f == kSupportsRTL);

-}

-

-#if PLUGIN_ENABLED_DYNAMIC(PRINCE)

-REGISTER_PLUGIN_DYNAMIC(PRINCE, PLUGIN_TYPE_ENGINE, PrinceMetaEngine);

-#else

-REGISTER_PLUGIN_STATIC(PRINCE, PLUGIN_TYPE_ENGINE, PrinceMetaEngine);

-#endif

+/* 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 "base/plugins.h"
+#include "engines/advancedDetector.h"
+
+#include "prince/prince.h"
+
+namespace Prince {
+
+struct PrinceGameDescription {
+	ADGameDescription desc;
+
+	int gameType;
+};
+
+int PrinceEngine::getGameType() const {
+	return _gameDescription->gameType;
+}
+
+const char *PrinceEngine::getGameId() const {
+	return _gameDescription->desc.gameid;
+}
+
+uint32 PrinceEngine::getFeatures() const {
+	return _gameDescription->desc.flags;
+}
+
+Common::Language PrinceEngine::getLanguage() const {
+	return _gameDescription->desc.language;
+}
+
+}
+
+static const PlainGameDescriptor princeGames[] = {
+	{"prince", "Prince Game"},
+	{0, 0}
+};
+
+namespace Prince {
+
+static const PrinceGameDescription gameDescriptions[] = {
+	
+	// German
+	{
+		{
+			"prince",
+			"Galador",
+			AD_ENTRY1s("databank.ptc", "5fa03833177331214ec1354761b1d2ee", 3565031),
+			Common::DE_DEU,
+			Common::kPlatformWindows,
+			ADGF_NO_FLAGS,
+			GUIO1(GUIO_NONE)
+		},
+		0
+	},
+	// Polish
+	{
+		{
+			"prince",
+			"Ksiaze i Tchorz",
+			AD_ENTRY1s("databank.ptc", "48ec9806bda9d152acbea8ce31c93c49", 3435298),
+			Common::PL_POL,
+			Common::kPlatformWindows,
+			ADGF_NO_FLAGS,
+			GUIO1(GUIO_NONE)
+		},
+		1
+	},
+
+
+	{ AD_TABLE_END_MARKER, 0 }
+};
+
+} // End of namespace Prince
+
+using namespace Prince;
+
+// we match from data too, to stop detection from a non-top-level directory
+const static char *directoryGlobs[] = {
+	"all",
+	0
+};
+
+class PrinceMetaEngine : public AdvancedMetaEngine {
+public:
+	PrinceMetaEngine() : AdvancedMetaEngine(Prince::gameDescriptions, sizeof(Prince::PrinceGameDescription), princeGames) {
+		_singleid = "prince";
+		_maxScanDepth = 2;
+		_directoryGlobs = directoryGlobs;
+	}
+
+	virtual const char *getName() const {
+		return "Prince Engine";
+	}
+
+	virtual const char *getOriginalCopyright() const {
+		return "Copyright (C)";
+	}
+
+	virtual bool createInstance(OSystem *syst, Engine **engine, const ADGameDescription *desc) const;
+	virtual bool hasFeature(MetaEngineFeature f) const;
+};
+
+bool PrinceMetaEngine::createInstance(OSystem *syst, Engine **engine, const ADGameDescription *desc) const {
+	using namespace Prince;
+	const PrinceGameDescription *gd = (const PrinceGameDescription *)desc;
+	if (gd) {
+		*engine = new PrinceEngine(syst, gd);
+	}
+	return gd != 0;
+}
+
+bool PrinceMetaEngine::hasFeature(MetaEngineFeature f) const {
+	return false;
+}
+
+bool Prince::PrinceEngine::hasFeature(EngineFeature f) const {
+	return false;//(f == kSupportsRTL);
+}
+
+#if PLUGIN_ENABLED_DYNAMIC(PRINCE)
+REGISTER_PLUGIN_DYNAMIC(PRINCE, PLUGIN_TYPE_ENGINE, PrinceMetaEngine);
+#else
+REGISTER_PLUGIN_STATIC(PRINCE, PLUGIN_TYPE_ENGINE, PrinceMetaEngine);
+#endif
+
+/* vim: set tabstop=4 noexpandtab: */
diff --git a/engines/prince/flags.cpp b/engines/prince/flags.cpp
index 5fb93ac4b1..d6d577a575 100644
--- a/engines/prince/flags.cpp
+++ b/engines/prince/flags.cpp
@@ -27,15 +27,15 @@ namespace Prince {
 const char * Flags::getFlagName(uint16 flagId)
 {
 	switch (flagId) {
-	default: return "unknown_flag";
+	default: 			return "unknown_flag";
 	case FLAGA1:			return "FLAGA1";
 	case FLAGA2:			return "FLAGA2";
 	case FLAGA3:			return "FLAGA3";
-	case DESTX:				return "DESTX";
-	case DESTY:				return "DESTY";
-	case DESTD:				return "DESTD";
+	case DESTX:			return "DESTX";
+	case DESTY:			return "DESTY";
+	case DESTD:			return "DESTD";
 	case DwarfDone:			return "DwarfDone";
-	case GRABARZCOUNTER:	return "GRABARZCOUNTER";
+	case GRABARZCOUNTER:		return "GRABARZCOUNTER";
 	case KIERUNEK:			return "KIERUNEK";
 	case BACKFLAG1:			return "BACKFLAG1";
 	case BACKFLAG2:			return "BACKFLAG2";
@@ -154,159 +154,159 @@ const char * Flags::getFlagName(uint16 flagId)
 	case LetterGiven:			return "LetterGiven";
 	case LutniaTaken:			return "LutniaTaken";
 	case BardHomeOpen:			return "BardHomeOpen";
-	case FjordNoMonsters:			return "FjordNoMonsters";
-	case ShandriaWallTalking:			return "ShandriaWallTalking";
-	case ShandriaWallCounter:			return "ShandriaWallCounter";
-	case ShandriaWallDone:			return "ShandriaWallDone";
-	case FutureDone:			return "FutureDone";
+	case FjordNoMonsters:		return "FjordNoMonsters";
+	case ShandriaWallTalking:	return "ShandriaWallTalking";
+	case ShandriaWallCounter:	return "ShandriaWallCounter";
+	case ShandriaWallDone:	return "ShandriaWallDone";
+	case FutureDone:		return "FutureDone";
 	case TalkButch:			return "TalkButch";
 	case GotSzalik:			return "GotSzalik";
-	case GotCzosnek:			return "GotCzosnek";
+	case GotCzosnek:		return "GotCzosnek";
 	case BearDone:			return "BearDone";
-	case NekrVisited:			return "NekrVisited";
+	case NekrVisited:		return "NekrVisited";
 	case SunRiddle:			return "SunRiddle";
-	case PtaszekAway:			return "PtaszekAway";
-	case KotGadanie:			return "KotGadanie";
-	case SzlafmycaTaken:			return "SzlafmycaTaken";
+	case PtaszekAway:		return "PtaszekAway";
+	case KotGadanie:		return "KotGadanie";
+	case SzlafmycaTaken:	return "SzlafmycaTaken";
 	case BabkaTalk:			return "BabkaTalk";
-	case SellerTalk:			return "SellerTalk";
-	case CzosnekDone:			return "CzosnekDone";
-	case PriestCounter:			return "PriestCounter";
-	case PriestGest1:			return "PriestGest1";
-	case PriestGest2:			return "PriestGest2";
-	case PriestGest3:			return "PriestGest3";
-	case PriestGest4:			return "PriestGest4";
-	case PriestAnim:			return "PriestAnim";
-	case HolyWaterTaken:			return "HolyWaterTaken";
+	case SellerTalk:		return "SellerTalk";
+	case CzosnekDone:		return "CzosnekDone";
+	case PriestCounter:		return "PriestCounter";
+	case PriestGest1:		return "PriestGest1";
+	case PriestGest2:		return "PriestGest2";
+	case PriestGest3:		return "PriestGest3";
+	case PriestGest4:		return "PriestGest4";
+	case PriestAnim:		return "PriestAnim";
+	case HolyWaterTaken:	return "HolyWaterTaken";
 	case AxeTaken:			return "AxeTaken";
-	case BadylTaken1:			return "BadylTaken1";
-	case BadylTaken2:			return "BadylTaken2";
-	case BadylSharpened:			return "BadylSharpened";
-	case PorwanieSmoka:			return "PorwanieSmoka";
-	case ShopReOpen:			return "ShopReOpen";
-	case LuskaShown:			return "LuskaShown";
+	case BadylTaken1:		return "BadylTaken1";
+	case BadylTaken2:		return "BadylTaken2";
+	case BadylSharpened:	return "BadylSharpened";
+	case PorwanieSmoka:		return "PorwanieSmoka";
+	case ShopReOpen:		return "ShopReOpen";
+	case LuskaShown:		return "LuskaShown";
 	case CudKnow:			return "CudKnow";
-	case VampireDead:			return "VampireDead";
-	case MapaVisible1:			return "MapaVisible1";
-	case MapaVisible2:			return "MapaVisible2";
-	case MapaVisible3:			return "MapaVisible3";
-	case MapaVisible4:			return "MapaVisible4";
-	case MapaVisible5:			return "MapaVisible5";
-	case MapaVisible6:			return "MapaVisible6";
-	case MapaVisible7:			return "MapaVisible7";
-	case MapaVisible8:			return "MapaVisible8";
-	case MapaVisible9:			return "MapaVisible9";
-	case MapaX:			return "MapaX";
-	case MapaY:			return "MapaY";
-	case MapaD:			return "MapaD";
+	case VampireDead:		return "VampireDead";
+	case MapaVisible1:		return "MapaVisible1";
+	case MapaVisible2:		return "MapaVisible2";
+	case MapaVisible3:		return "MapaVisible3";
+	case MapaVisible4:		return "MapaVisible4";
+	case MapaVisible5:		return "MapaVisible5";
+	case MapaVisible6:		return "MapaVisible6";
+	case MapaVisible7:		return "MapaVisible7";
+	case MapaVisible8:		return "MapaVisible8";
+	case MapaVisible9:		return "MapaVisible9";
+	case MapaX:				return "MapaX";
+	case MapaY:				return "MapaY";
+	case MapaD:				return "MapaD";
 	case OldMapaX:			return "OldMapaX";
 	case OldMapaY:			return "OldMapaY";
 	case OldMapaD:			return "OldMapaD";
-	case MovingBack:			return "MovingBack";
+	case MovingBack:		return "MovingBack";
 	case MapaCount:			return "MapaCount";
-	case Pustelnia1st:			return "Pustelnia1st";
-	case CzarnePole1st:			return "CzarnePole1st";
-	case TalkArivNum:			return "TalkArivNum";
-	case Pfui:			return "Pfui";
-	case MapaSunlordEnabled:			return "MapaSunlordEnabled";
+	case Pustelnia1st:		return "Pustelnia1st";
+	case CzarnePole1st:		return "CzarnePole1st";
+	case TalkArivNum:		return "TalkArivNum";
+	case Pfui:				return "Pfui";
+	case MapaSunlordEnabled:return "MapaSunlordEnabled";
 	case WebDone:			return "WebDone";
-	case DragonDone:			return "DragonDone";
+	case DragonDone:		return "DragonDone";
 	case KanPlay:			return "KanPlay";
-	case OldKanPlay:			return "OldKanPlay";
+	case OldKanPlay:		return "OldKanPlay";
 	case LapkiWait:			return "LapkiWait";
-	case WebNoCheck:			return "WebNoCheck";
-	case Perfumeria:			return "Perfumeria";
-	case SmokNoCheck:			return "SmokNoCheck";
-	case IluzjaBroken:			return "IluzjaBroken";
-	case IluzjaWorking:			return "IluzjaWorking";
-	case IluzjaCounter:			return "IluzjaCounter";
-	case KurhanOpen1:			return "KurhanOpen1";
-	case KastetTaken:			return "KastetTaken";
-	case KastetDown:			return "KastetDown";
-	case KurhanDone:			return "KurhanDone";
-	case SkelCounter:			return "SkelCounter";
+	case WebNoCheck:		return "WebNoCheck";
+	case Perfumeria:		return "Perfumeria";
+	case SmokNoCheck:		return "SmokNoCheck";
+	case IluzjaBroken:		return "IluzjaBroken";
+	case IluzjaWorking:		return "IluzjaWorking";
+	case IluzjaCounter:		return "IluzjaCounter";
+	case KurhanOpen1:		return "KurhanOpen1";
+	case KastetTaken:		return "KastetTaken";
+	case KastetDown:		return "KastetDown";
+	case KurhanDone:		return "KurhanDone";
+	case SkelCounter:		return "SkelCounter";
 	case SkelDial1:			return "SkelDial1";
 	case SkelDial2:			return "SkelDial2";
 	case SkelDial3:			return "SkelDial3";
 	case SkelDial4:			return "SkelDial4";
-	case SameTalker:			return "SameTalker";
-	case RunMonstersText:			return "RunMonstersText";
-	case PiwnicaChecked:			return "PiwnicaChecked";
-	case DragonTalked:			return "DragonTalked";
-	case ToldAboutBook:			return "ToldAboutBook";
-	case SilmanionaDone:			return "SilmanionaDone";
-	case ToldBookCount:			return "ToldBookCount";
-	case SmrodNoCheck:			return "SmrodNoCheck";
+	case SameTalker:		return "SameTalker";
+	case RunMonstersText:	return "RunMonstersText";
+	case PiwnicaChecked:	return "PiwnicaChecked";
+	case DragonTalked:		return "DragonTalked";
+	case ToldAboutBook:		return "ToldAboutBook";
+	case SilmanionaDone:	return "SilmanionaDone";
+	case ToldBookCount:		return "ToldBookCount";
+	case SmrodNoCheck:		return "SmrodNoCheck";
 	case RopeTaken:			return "RopeTaken";
 	case RopeTime:			return "RopeTime";
 	case LaskaFree:			return "LaskaFree";
-	case ShanSmokTalked:			return "ShanSmokTalked";
-	case SwordTaken:			return "SwordTaken";
+	case ShanSmokTalked:	return "ShanSmokTalked";
+	case SwordTaken:		return "SwordTaken";
 	case Mill1st:			return "Mill1st";
 	case SawRat:			return "SawRat";
 	case KnowRat:			return "KnowRat";
-	case DziuraTimer:			return "DziuraTimer";
-	case LaskaInside:			return "LaskaInside";
+	case DziuraTimer:		return "DziuraTimer";
+	case LaskaInside:		return "LaskaInside";
 	case HoleBig:			return "HoleBig";
-	case EnableWiedzmin:			return "EnableWiedzmin";
-	case EnableTrucizna:			return "EnableTrucizna";
-	case KnowPoison:			return "KnowPoison";
-	case KufelTaken:			return "KufelTaken";
-	case BojkaEnabled:			return "BojkaEnabled";
-	case BitwaNot1st:			return "BitwaNot1st";
-	case BojkaTimer:			return "BojkaTimer";
+	case EnableWiedzmin:	return "EnableWiedzmin";
+	case EnableTrucizna:	return "EnableTrucizna";
+	case KnowPoison:		return "KnowPoison";
+	case KufelTaken:		return "KufelTaken";
+	case BojkaEnabled:		return "BojkaEnabled";
+	case BitwaNot1st:		return "BitwaNot1st";
+	case BojkaTimer:		return "BojkaTimer";
 	case BojkaGirl:			return "BojkaGirl";
 	case Look1st:			return "Look1st";
 	case RatTaken:			return "RatTaken";
-	case LaskaTalkedGr:			return "LaskaTalkedGr";
-	case RatusGivus:			return "RatusGivus";
+	case LaskaTalkedGr:		return "LaskaTalkedGr";
+	case RatusGivus:		return "RatusGivus";
 	case MamObole:			return "MamObole";
 	case Speed1st:			return "Speed1st";
-	case SpeedTimer:			return "SpeedTimer";
+	case SpeedTimer:		return "SpeedTimer";
 	case ProveIt:			return "ProveIt";
 	case Proven:			return "Proven";
-	case ShowWoalka:			return "ShowWoalka";
-	case PoisonTaken:			return "PoisonTaken";
-	case HellOpened:			return "HellOpened";
-	case HellNoCheck:			return "HellNoCheck";
+	case ShowWoalka:		return "ShowWoalka";
+	case PoisonTaken:		return "PoisonTaken";
+	case HellOpened:		return "HellOpened";
+	case HellNoCheck:		return "HellNoCheck";
 	case TalAn1:			return "TalAn1";
 	case TalAn2:			return "TalAn2";
 	case TalAn3:			return "TalAn3";
-	case TalkDevilGuard:			return "TalkDevilGuard";
+	case TalkDevilGuard:	return "TalkDevilGuard";
 	case Sword1st:			return "Sword1st";
-	case IluzjaNoCheck:			return "IluzjaNoCheck";
-	case RozdzielniaNumber:			return "RozdzielniaNumber";
-	case JailChecked:			return "JailChecked";
-	case JailTalked:			return "JailTalked";
-	case TrickFailed:			return "TrickFailed";
-	case WegielVisible:			return "WegielVisible";
-	case WegielTimer1:			return "WegielTimer1";
-	case RandomSample:			return "RandomSample";
-	case RandomSampleTimer:			return "RandomSampleTimer";
-	case SampleTimer:			return "SampleTimer";
-	case ZonaSample:			return "ZonaSample";
-	case HoleTryAgain:			return "HoleTryAgain";
-	case TeleportTimer:			return "TeleportTimer";
+	case IluzjaNoCheck:		return "IluzjaNoCheck";
+	case RozdzielniaNumber:	return "RozdzielniaNumber";
+	case JailChecked:		return "JailChecked";
+	case JailTalked:		return "JailTalked";
+	case TrickFailed:		return "TrickFailed";
+	case WegielVisible:		return "WegielVisible";
+	case WegielTimer1:		return "WegielTimer1";
+	case RandomSample:		return "RandomSample";
+	case RandomSampleTimer:	return "RandomSampleTimer";
+	case SampleTimer:		return "SampleTimer";
+	case ZonaSample:		return "ZonaSample";
+	case HoleTryAgain:		return "HoleTryAgain";
+	case TeleportTimer:		return "TeleportTimer";
 	case RozLezy:			return "RozLezy";
 	case UdkoTimer:			return "UdkoTimer";
-	case ZaworZatkany:			return "ZaworZatkany";
-	case ZaworOpened:			return "ZaworOpened";
-	case DoorExploded:			return "DoorExploded";
-	case SkoraTaken:			return "SkoraTaken";
-	case CiezkieByl:			return "CiezkieByl";
+	case ZaworZatkany:		return "ZaworZatkany";
+	case ZaworOpened:		return "ZaworOpened";
+	case DoorExploded:		return "DoorExploded";
+	case SkoraTaken:		return "SkoraTaken";
+	case CiezkieByl:		return "CiezkieByl";
 	case MamWegiel:			return "MamWegiel";
-	case SwiecaAway:			return "SwiecaAway";
+	case SwiecaAway:		return "SwiecaAway";
 	case ITSAVE:			return "ITSAVE";
-	case RozpadlSie:			return "RozpadlSie";
-	case WegielFullTimer:			return "WegielFullTimer";
-	case WegielDown:			return "WegielDown";
-	case WegielDownTimer:			return "WegielDownTimer";
+	case RozpadlSie:		return "RozpadlSie";
+	case WegielFullTimer:	return "WegielFullTimer";
+	case WegielDown:		return "WegielDown";
+	case WegielDownTimer:	return "WegielDownTimer";
 	case PaliSie:			return "PaliSie";
-	case DiabGuardTalked:			return "DiabGuardTalked";
-	case GuardsNoCheck:			return "GuardsNoCheck";
-	case TalkedPowloka:			return "TalkedPowloka";
+	case DiabGuardTalked:	return "DiabGuardTalked";
+	case GuardsNoCheck:		return "GuardsNoCheck";
+	case TalkedPowloka:		return "TalkedPowloka";
 	case JailOpen:			return "JailOpen";
-	case PrzytulTimer:			return "PrzytulTimer";
+	case PrzytulTimer:		return "PrzytulTimer";
 	case JailDone:			return "JailDone";
 	case MamMonety:			return "MamMonety";
 	case LotTimer:			return "LotTimer";
@@ -315,96 +315,92 @@ const char * Flags::getFlagName(uint16 flagId)
 	case BookTimer:			return "BookTimer";
 	case BookGiba:			return "BookGiba";
 	case PtakLata:			return "PtakLata";
-	case Podej:			return "Podej";
+	case Podej:				return "Podej";
 	case GotHint:			return "GotHint";
 	case LawaLeci:			return "LawaLeci";
 	case PowerKlik:			return "PowerKlik";
 	case LucekBad:			return "LucekBad";
-	case LucekBad1st:			return "LucekBad1st";
-	case IntroDial1:			return "IntroDial1";
-	case IntroDial2:			return "IntroDial2";
+	case LucekBad1st:		return "LucekBad1st";
+	case IntroDial1:		return "IntroDial1";
+	case IntroDial2:		return "IntroDial2";
 	case ItsOutro:			return "ItsOutro";
-	case KamienComment:			return "KamienComment";
-	case KamienSkip:			return "KamienSkip";
-	case TesterFlag:			return "TesterFlag";
-	case RememberLine:			return "RememberLine";
+	case KamienComment:		return "KamienComment";
+	case KamienSkip:		return "KamienSkip";
+	case TesterFlag:		return "TesterFlag";
+	case RememberLine:		return "RememberLine";
 	case OpisLapek:			return "OpisLapek";
-	// case OpisKamienia:			return "//OpisKamienia";
 	case TalWait:			return "TalWait";
-	case OpisKamienia:			return "OpisKamienia";
+	case OpisKamienia:		return "OpisKamienia";
 	case JumpBox:			return "JumpBox";
 	case JumpBox1:			return "JumpBox1";
 	case JumpBox2:			return "JumpBox2";
 	case JumpBox3:			return "JumpBox3";
-	case SpecPiesek:			return "SpecPiesek";
-	case SpecPiesekCount:			return "SpecPiesekCount";
-	case SpecPiesekGadanie:			return "SpecPiesekGadanie";
+	case SpecPiesek:		return "SpecPiesek";
+	case SpecPiesekCount:	return "SpecPiesekCount";
+	case SpecPiesekGadanie:	return "SpecPiesekGadanie";
 	case ZnikaFlag:			return "ZnikaFlag";
-	case ZnikaTimer:			return "ZnikaTimer";
+	case ZnikaTimer:		return "ZnikaTimer";
 	case SowaTimer:			return "SowaTimer";
-	case MamrotanieOff:			return "MamrotanieOff";
+	case MamrotanieOff:		return "MamrotanieOff";
 
 	case CURRMOB:			return "CURRMOB";
-	case KOLOR:			return "KOLOR";
+	case KOLOR:				return "KOLOR";
 	case MBFLAG:			return "MBFLAG";
 	case MXFLAG:			return "MXFLAG";
 	case MYFLAG:			return "MYFLAG";
-	case SCROLLTYPE:			return "SCROLLTYPE";
-	case SCROLLVALUE:			return "SCROLLVALUE";
-	case SCROLLVALUE2:			return "SCROLLVALUE2";
-	case TALKEXITCODE:			return "TALKEXITCODE";
-	case SPECROUTFLAG1:			return "SPECROUTFLAG1";
-	case SPECROUTFLAG2:			return "SPECROUTFLAG2";
-	case SPECROUTFLAG3:			return "SPECROUTFLAG3";
-	case TALKFLAGCODE:			return "TALKFLAGCODE";
+	case SCROLLTYPE:		return "SCROLLTYPE";
+	case SCROLLVALUE:		return "SCROLLVALUE";
+	case SCROLLVALUE2:		return "SCROLLVALUE2";
+	case TALKEXITCODE:		return "TALKEXITCODE";
+	case SPECROUTFLAG1:		return "SPECROUTFLAG1";
+	case SPECROUTFLAG2:		return "SPECROUTFLAG2";
+	case SPECROUTFLAG3:		return "SPECROUTFLAG3";
+	case TALKFLAGCODE:		return "TALKFLAGCODE";
 	case CURRROOM:			return "CURRROOM";
-	case Talker1Init:			return "Talker1Init";
-	case Talker2Init:			return "Talker2Init";
-	case RESTOREROOM:			return "RESTOREROOM";
-	case INVALLOWED:			return "INVALLOWED";
+	case Talker1Init:		return "Talker1Init";
+	case Talker2Init:		return "Talker2Init";
+	case RESTOREROOM:		return "RESTOREROOM";
+	case INVALLOWED:		return "INVALLOWED";
 	case BOXSEL:			return "BOXSEL";
-	case CURSEBLINK:			return "CURSEBLINK";
+	case CURSEBLINK:		return "CURSEBLINK";
 	case EXACTMOVE:			return "EXACTMOVE";
 	case MOVEDESTX:			return "MOVEDESTX";
 	case MOVEDESTY:			return "MOVEDESTY";
-	case NOANTIALIAS:			return "NOANTIALIAS";
+	case NOANTIALIAS:		return "NOANTIALIAS";
 	case ESCAPED:			return "ESCAPED";
-	case ALLOW1OPTION:			return "ALLOW1OPTION";
-	case VOICE_H_LINE:			return "VOICE_H_LINE";
-	case VOICE_A_LINE:			return "VOICE_A_LINE";
-	case VOICE_B_LINE:			return "VOICE_B_LINE";
-	case VOICE_C_LINE:			return "VOICE_C_LINE";
-	case NOHEROATALL:			return "NOHEROATALL";
-	case MOUSEENABLED:			return "MOUSEENABLED";
+	case ALLOW1OPTION:		return "ALLOW1OPTION";
+	case VOICE_H_LINE:		return "VOICE_H_LINE";
+	case VOICE_A_LINE:		return "VOICE_A_LINE";
+	case VOICE_B_LINE:		return "VOICE_B_LINE";
+	case VOICE_C_LINE:		return "VOICE_C_LINE";
+	case NOHEROATALL:		return "NOHEROATALL";
+	case MOUSEENABLED:		return "MOUSEENABLED";
 	case DIALINES:			return "DIALINES";
 
-	//case SELITEM:			return "SELITEM";
-	
 	case SHANWALK:			return "SHANWALK";
 	case SHANDOG:			return "SHANDOG";
-	case GETACTIONBACK:			return "GETACTIONBACK";
-	case GETACTIONDATA:			return "GETACTIONDATA";
+	case GETACTIONBACK:		return "GETACTIONBACK";
+	case GETACTIONDATA:		return "GETACTIONDATA";
 	case GETACTION:			return "GETACTION";
 	case HEROFAST:			return "HEROFAST";
 	case SELITEM:			return "SELITEM";
 	case LMOUSE:			return "LMOUSE";
-	case MINMX:			return "MINMX";
-	case MAXMX:			return "MAXMX";
-	case MINMY:			return "MINMY";
-	case MAXMY:			return "MAXMY";
-	case TORX1:			return "TORX1";
-	case TORY1:			return "TORY1";
-	case TORX2:			return "TORX2";
-	case TORY2:			return "TORY2";
-	case POWER:			return "POWER";
-	case POWERENABLED:			return "POWERENABLED";
-	case FLCRESTORE:			return "FLCRESTORE";
+	case MINMX:				return "MINMX";
+	case MAXMX:				return "MAXMX";
+	case MINMY:				return "MINMY";
+	case MAXMY:				return "MAXMY";
+	case TORX1:				return "TORX1";
+	case TORY1:				return "TORY1";
+	case TORX2:				return "TORX2";
+	case TORY2:				return "TORY2";
+	case POWER:				return "POWER";
+	case POWERENABLED:		return "POWERENABLED";
+	case FLCRESTORE:		return "FLCRESTORE";
 	case NOCLSTEXT:			return "NOCLSTEXT";
 	case ESCAPED2:			return "ESCAPED2";
 	}
 }
 
-
 }
 
 /* vim: set tabstop=4 noexpandtab: */
diff --git a/engines/prince/flags.h b/engines/prince/flags.h
index d360912526..7eb8d7f1b7 100644
--- a/engines/prince/flags.h
+++ b/engines/prince/flags.h
@@ -20,6 +20,9 @@
  *
  */
 
+#ifndef PRINCE_FLAGS_H
+#define PRINCE_FLAGS_H
+
 #include "common/scummsys.h"
 
 namespace Prince {
@@ -406,4 +409,6 @@ struct Flags {
 };
 
 }
+#endif
 /* vim: set tabstop=4 noexpandtab: */
+
diff --git a/engines/prince/font.cpp b/engines/prince/font.cpp
index aac790dfe0..30e7b5aee2 100644
--- a/engines/prince/font.cpp
+++ b/engines/prince/font.cpp
@@ -35,55 +35,57 @@ Font::Font() {
 }
 
 Font::~Font() {
-    delete [] _fontData;
+	delete [] _fontData;
 }
 
 bool Font::load(Common::SeekableReadStream &stream) {
-    stream.seek(0);
-    _fontData = new byte[stream.size()];
-    stream.read(_fontData, stream.size());
-    return true;
+	stream.seek(0);
+	_fontData = new byte[stream.size()];
+	stream.read(_fontData, stream.size());
+	return true;
 }
 
 int Font::getFontHeight() const {
-    return _fontData[5];
+	return _fontData[5];
 }
 
 int Font::getMaxCharWidth() const {
-    return 0;
+	return 0;
 }
 
 Font::ChrData Font::getChrData(byte chr) const {
-    chr -= 32;
-    uint16 chrOffset = 4*chr+6;
+	chr -= 32;
+	uint16 chrOffset = 4*chr+6;
 
-    ChrData chrData;
-    chrData._width = _fontData[chrOffset+2];
-    chrData._height = _fontData[chrOffset+3];
-    chrData._pixels = _fontData + READ_LE_UINT16(_fontData + chrOffset);
+	ChrData chrData;
+	chrData._width = _fontData[chrOffset+2];
+	chrData._height = _fontData[chrOffset+3];
+	chrData._pixels = _fontData + READ_LE_UINT16(_fontData + chrOffset);
 
-    return chrData;
+	return chrData;
 }
 
 int Font::getCharWidth(byte chr) const {
-    return getChrData(chr)._width;
+	return getChrData(chr)._width;
 }
 
 void Font::drawChar(Graphics::Surface *dst, byte chr, int posX, int posY, uint32 color) const {
-    const ChrData chrData = getChrData(chr);
-
-    for (int y = 0; y < chrData._height; ++y) {
-        for (int x = 0; x < chrData._width; ++x) {
-            byte d = chrData._pixels[x + (chrData._width * y)];
-            if (d == 0) d = 255;
-            else if (d == 1) d = 0;
-            else if (d == 2) d = color;
-            else if (d == 3) d = 0;
-            if (d != 255) {
-                *(byte*)dst->getBasePtr(posX + x, posY + y) = d;
-            }
-        }
-    }
+	const ChrData chrData = getChrData(chr);
+
+	for (int y = 0; y < chrData._height; ++y) {
+		for (int x = 0; x < chrData._width; ++x) {
+			byte d = chrData._pixels[x + (chrData._width * y)];
+			if (d == 0) d = 255;
+			else if (d == 1) d = 0;
+			else if (d == 2) d = color;
+			else if (d == 3) d = 0;
+			if (d != 255) {
+				*(byte*)dst->getBasePtr(posX + x, posY + y) = d;
+			}
+		}
+	}
 }
 
 }
+
+/* vim: set tabstop=4 expandtab!: */
diff --git a/engines/prince/font.h b/engines/prince/font.h
index 629b5d61eb..8b622ce08a 100644
--- a/engines/prince/font.h
+++ b/engines/prince/font.h
@@ -25,44 +25,46 @@
 #include "graphics/font.h"
 
 namespace Graphics {
-    struct Surface;
+	struct Surface;
 }
 
 namespace Common {
-    class String;
+	class String;
 }
 
 namespace Prince {
 
 class Font : public Graphics::Font {
 public:
-    Font();
-    virtual ~Font();
+	Font();
+	virtual ~Font();
 
-    bool load(Common::SeekableReadStream &stream);
+	bool load(Common::SeekableReadStream &stream);
 
-    virtual int getFontHeight() const override;
+	virtual int getFontHeight() const override;
 
-    virtual int getMaxCharWidth() const override;
+	virtual int getMaxCharWidth() const override;
 
-    virtual int getCharWidth(byte chr) const override;
+	virtual int getCharWidth(byte chr) const override;
 
-    virtual void drawChar(Graphics::Surface *dst, byte chr, int x, int y, uint32 color) const override;
+	virtual void drawChar(Graphics::Surface *dst, byte chr, int x, int y, uint32 color) const override;
 
 	virtual int getKerningOffset(byte left, byte right) const { return -2; }
 
 private:
-    struct ChrData {
-        byte * _pixels;
-        byte _width;
-        byte _height;
-    };
+	struct ChrData {
+		byte *_pixels;
+		byte _width;
+		byte _height;
+	};
 
-    ChrData getChrData(byte chr) const;
+	ChrData getChrData(byte chr) const;
 
-    byte * _fontData;
+	byte *_fontData;
 };
 
 }
 
 #endif
+
+/* vim: set tabstop=4 expandtab!: */
diff --git a/engines/prince/mhwanh.cpp b/engines/prince/mhwanh.cpp
index 4240ed4097..92a6a900f5 100644
--- a/engines/prince/mhwanh.cpp
+++ b/engines/prince/mhwanh.cpp
@@ -29,45 +29,45 @@
 namespace Prince {
 
 MhwanhDecoder::MhwanhDecoder() 
-    : _surface(NULL), _palette(0), _paletteColorCount(0) {
+	: _surface(NULL), _palette(0), _paletteColorCount(0) {
 }
 
 MhwanhDecoder::~MhwanhDecoder() {
-    destroy();
+	destroy();
 }
 
 void MhwanhDecoder::destroy() {
-    if (_surface) {
-        _surface->free();
-        delete _surface; _surface = 0;
-    }
+	if (_surface) {
+		_surface->free();
+		delete _surface; _surface = 0;
+	}
 
-    delete [] _palette; _palette = 0;
-    _paletteColorCount = 0;
+	delete [] _palette; _palette = 0;
+	_paletteColorCount = 0;
 }
 
 bool MhwanhDecoder::loadStream(Common::SeekableReadStream &stream) {
-    destroy();
-    _paletteColorCount = 256;
-    stream.seek(0);
-    stream.skip(0x20);
-    // Read the palette
-    _palette = new byte[_paletteColorCount * 3]; 
-    for (uint16 i = 0; i < _paletteColorCount; i++) {
-        _palette[i * 3 + 0] = stream.readByte();
-        _palette[i * 3 + 1] = stream.readByte();
-        _palette[i * 3 + 2] = stream.readByte();
-    }  
-
-    _surface = new Graphics::Surface();
-    _surface->create(640, 480, Graphics::PixelFormat::createFormatCLUT8());
-    for (int h = 0; h < 480; ++h) {
-        stream.read(_surface->getBasePtr(0, h), 640);
-    }
-
-    return true;
+	destroy();
+	_paletteColorCount = 256;
+	stream.seek(0);
+	stream.skip(0x20);
+	// Read the palette
+	_palette = new byte[_paletteColorCount * 3]; 
+	for (uint16 i = 0; i < _paletteColorCount; i++) {
+		_palette[i * 3 + 0] = stream.readByte();
+		_palette[i * 3 + 1] = stream.readByte();
+		_palette[i * 3 + 2] = stream.readByte();
+	}  
+
+	_surface = new Graphics::Surface();
+	_surface->create(640, 480, Graphics::PixelFormat::createFormatCLUT8());
+	for (int h = 0; h < 480; ++h) {
+		stream.read(_surface->getBasePtr(0, h), 640);
+	}
+
+	return true;
 }
 
 }
 
-
+/* vim: set tabstop=4 noexpandtab: */
diff --git a/engines/prince/mhwanh.h b/engines/prince/mhwanh.h
index 24472da7a5..2b70ae525b 100644
--- a/engines/prince/mhwanh.h
+++ b/engines/prince/mhwanh.h
@@ -30,23 +30,24 @@ namespace Prince {
 
 class MhwanhDecoder : public Graphics::ImageDecoder {
 public:
-    MhwanhDecoder();
-    virtual ~MhwanhDecoder();
+	MhwanhDecoder();
+	virtual ~MhwanhDecoder();
 
-    // ImageDecoder API
-    void destroy();
-    virtual bool loadStream(Common::SeekableReadStream &stream);
-    virtual Graphics::Surface *getSurface() const { return _surface; }
-    const byte *getPalette() const { return _palette; }
-    uint16 getPaletteCount() const { return _paletteColorCount; }
+	// ImageDecoder API
+	void destroy();
+	virtual bool loadStream(Common::SeekableReadStream &stream);
+	virtual Graphics::Surface *getSurface() const { return _surface; }
+	const byte *getPalette() const { return _palette; }
+	uint16 getPaletteCount() const { return _paletteColorCount; }
 
 private:
-    Graphics::Surface *_surface;
-    byte *_palette;
-    uint16 _paletteColorCount;
+	Graphics::Surface *_surface;
+	byte *_palette;
+	uint16 _paletteColorCount;
 };
 
 }
 
-
 #endif
+
+/* vim: set tabstop=4 noexpandtab: */
diff --git a/engines/prince/mob.cpp b/engines/prince/mob.cpp
index caf44fef12..3df7235d2d 100644
--- a/engines/prince/mob.cpp
+++ b/engines/prince/mob.cpp
@@ -27,37 +27,39 @@
 namespace Prince {
 
 bool Mob::loadFromStream(Common::SeekableReadStream &stream) {
-    int32 pos = stream.pos();
+	int32 pos = stream.pos();
 
-    uint16 visible = stream.readUint16LE();
+	uint16 visible = stream.readUint16LE();
 
-    if (visible == 0xFFFF)
-        return false;
+	if (visible == 0xFFFF)
+		return false;
 
-    _visible = visible;
-    _type = stream.readUint16LE();
-    _rect.left = stream.readUint16LE();
-    _rect.top = stream.readUint16LE();
-    _rect.right = stream.readUint16LE();
-    _rect.bottom = stream.readUint16LE();
+	_visible = visible;
+	_type = stream.readUint16LE();
+	_rect.left = stream.readUint16LE();
+	_rect.top = stream.readUint16LE();
+	_rect.right = stream.readUint16LE();
+	_rect.bottom = stream.readUint16LE();
 
-    stream.skip(6 * sizeof(uint16));
-    uint32 nameOffset = stream.readUint32LE();
-    uint32 examTextOffset = stream.readUint32LE();
+	stream.skip(6 * sizeof(uint16));
+	uint32 nameOffset = stream.readUint32LE();
+	uint32 examTextOffset = stream.readUint32LE();
 
-    byte c;
-    stream.seek(nameOffset);
-    _name.clear();
-    while ((c = stream.readByte()))
-        _name += c;
+	byte c;
+	stream.seek(nameOffset);
+	_name.clear();
+	while ((c = stream.readByte()))
+		_name += c;
 
-    stream.seek(examTextOffset);
-    _examText.clear();
-    while ((c = stream.readByte()))
-        _examText += c;
-    stream.seek(pos + 32);
+	stream.seek(examTextOffset);
+	_examText.clear();
+	while ((c = stream.readByte()))
+		_examText += c;
+	stream.seek(pos + 32);
 
-    return true;
+	return true;
 }
 
 }
+
+/* vim: set tabstop=4 noexpandtab: */
diff --git a/engines/prince/mob.h b/engines/prince/mob.h
index 5b2a6f9d6e..b8208246a1 100644
--- a/engines/prince/mob.h
+++ b/engines/prince/mob.h
@@ -20,29 +20,34 @@
  *
  */
 
+#ifndef PRINCE_MOB_H
+#define PRINCE_MOB_H
+
 #include "common/scummsys.h"
 #include "common/rect.h"
 #include "common/str.h"
 
 namespace Common {
-    class SeekableReadStream;
+	class SeekableReadStream;
 }
 
 namespace Prince {
 
 class Mob {
 public:
-    Mob() {}
+	Mob() {}
 
-    bool loadFromStream(Common::SeekableReadStream &stream);
-  
+	bool loadFromStream(Common::SeekableReadStream &stream);
 
-    bool _visible; 
-    uint16 _type;
-    Common::Rect _rect;
-    Common::String _name;
-    Common::String _examText;
+	bool _visible; 
+	uint16 _type;
+	Common::Rect _rect;
+	Common::String _name;
+	Common::String _examText;
 };
 
 }
 
+#endif
+
+/* vim: set tabstop=4 noexpandtab: */
diff --git a/engines/prince/module.mk b/engines/prince/module.mk
index 8bdccdf74d..f8003f834a 100644
--- a/engines/prince/module.mk
+++ b/engines/prince/module.mk
@@ -1,23 +1,23 @@
-MODULE := engines/prince

-

-MODULE_OBJS = \

-	debugger.o \

-	script.o \

-	graphics.o \

-	mhwanh.o \

-	detection.o \

-	font.o \

-	mob.o \

-	object.o \

-	sound.o \

-	flags.o \

-	variatxt.o \

-	prince.o

-

-# This module can be built as a plugin

-ifeq ($(ENABLE_PRINCE), DYNAMIC_PLUGIN)

-PLUGIN := 1

-endif

-

-# Include common rules

-include $(srcdir)/rules.mk

+MODULE := engines/prince
+
+MODULE_OBJS = \
+	debugger.o \
+	script.o \
+	graphics.o \
+	mhwanh.o \
+	detection.o \
+	font.o \
+	mob.o \
+	object.o \
+	sound.o \
+	flags.o \
+	variatxt.o \
+	prince.o
+
+# This module can be built as a plugin
+ifeq ($(ENABLE_PRINCE), DYNAMIC_PLUGIN)
+PLUGIN := 1
+endif
+
+# Include common rules
+include $(srcdir)/rules.mk
diff --git a/engines/prince/musNum.h b/engines/prince/musNum.h
index cb81332604..65b31f8175 100644
--- a/engines/prince/musNum.h
+++ b/engines/prince/musNum.h
@@ -20,73 +20,68 @@
  *
  */
 
-/*
- * This code is based on original Soltys source code
- * Copyright (c) 1994-1995 Janus B. Wisniewski and L.K. Avalon
- */
-
 namespace Prince {
 
 enum RoomMus {
-ROOM01MUS   =3,
-ROOM02MUS   =9,
-ROOM03MUS   =9,
-ROOM04MUS   =9,
-ROOM05MUS   =13,
-ROOM06MUS   =9,
-ROOM07MUS   =9,
-ROOM08MUS   =9,
-ROOM09MUS   =14,
-ROOM10MUS   =9,
-ROOM11MUS   =9,
-ROOM12MUS   =9,
-ROOM13MUS   =9,
-ROOM14MUS   =9,
-ROOM15MUS   =5,
-ROOM16MUS   =5,
-ROOM17MUS   =5,
-ROOM18MUS   =5,
-ROOM19MUS   =5,
-ROOM20MUS   =12,
-ROOM21MUS   =9,
-ROOM22MUS   =9,
-ROOM23MUS   =1,
-ROOM24MUS   =1,
-ROOM25MUS   =2,
-ROOM26MUS   =10,
-ROOM27MUS   =7,
-ROOM28MUS   =10,
-ROOM29MUS   =10,
-ROOM30MUS   =11,
-ROOM31MUS   =14,
-ROOM32MUS   =11,
-ROOM33MUS   =7,
-ROOM34MUS   =7,
-ROOM35MUS   =7,
-ROOM36MUS   =7,
-ROOM37MUS   =7,
-ROOM38MUS   =7,
-ROOM39MUS   =7,
-ROOM40MUS   =7,
-ROOM41MUS   =7,
-ROOM42MUS   =7,
-ROOM43MUS   =15,
-ROOM46MUS   =100,
-ROOM47MUS   =100,
-ROOM48MUS   =100,
-ROOM49MUS   =100,
-ROOM50MUS   =100,
-ROOM51MUS   =12,
-ROOM52MUS   =9,
-ROOM53MUS   =5,
-ROOM54MUS   =11,
-ROOM55MUS   =11,
-ROOM56MUS   =11,
-ROOM57MUS   =7,
-ROOM58MUS   =13,
-ROOM59MUS   =16,
-ROOM60MUS   =4,
-ROOM61MUS   =0
+	ROOM01MUS = 3,
+	ROOM02MUS = 9,
+	ROOM03MUS = 9,
+	ROOM04MUS = 9,
+	ROOM05MUS = 13,
+	ROOM06MUS = 9,
+	ROOM07MUS = 9,
+	ROOM08MUS = 9,
+	ROOM09MUS = 14,
+	ROOM10MUS = 9,
+	ROOM11MUS = 9,
+	ROOM12MUS = 9,
+	ROOM13MUS = 9,
+	ROOM14MUS = 9,
+	ROOM15MUS = 5,
+	ROOM16MUS = 5,
+	ROOM17MUS = 5,
+	ROOM18MUS = 5,
+	ROOM19MUS = 5,
+	ROOM20MUS = 12,
+	ROOM21MUS = 9,
+	ROOM22MUS = 9,
+	ROOM23MUS = 1,
+	ROOM24MUS = 1,
+	ROOM25MUS = 2,
+	ROOM26MUS = 10,
+	ROOM27MUS = 7,
+	ROOM28MUS = 10,
+	ROOM29MUS = 10,
+	ROOM30MUS = 11,
+	ROOM31MUS = 14,
+	ROOM32MUS = 11,
+	ROOM33MUS = 7,
+	ROOM34MUS = 7,
+	ROOM35MUS = 7,
+	ROOM36MUS = 7,
+	ROOM37MUS = 7,
+	ROOM38MUS = 7,
+	ROOM39MUS = 7,
+	ROOM40MUS = 7,
+	ROOM41MUS = 7,
+	ROOM42MUS = 7,
+	ROOM43MUS = 15,
+	ROOM46MUS = 100,
+	ROOM47MUS = 100,
+	ROOM48MUS = 100,
+	ROOM49MUS = 100,
+	ROOM50MUS = 100,
+	ROOM51MUS = 12,
+	ROOM52MUS = 9,
+	ROOM53MUS = 5,
+	ROOM54MUS = 11,
+	ROOM55MUS = 11,
+	ROOM56MUS = 11,
+	ROOM57MUS = 7,
+	ROOM58MUS = 13,
+	ROOM59MUS = 16,
+	ROOM60MUS = 4,
+	ROOM61MUS = 0
 };
 
 }
diff --git a/engines/prince/prince.cpp b/engines/prince/prince.cpp
index 1d8f71ddcb..2fc4407f6e 100644
--- a/engines/prince/prince.cpp
+++ b/engines/prince/prince.cpp
@@ -21,7 +21,7 @@
  */
 
 #include "common/scummsys.h"
- 
+
 #include "common/config-manager.h"
 #include "common/debug-channels.h"
 #include "common/debug.h"
@@ -51,6 +51,7 @@
 #include "prince/mob.h"
 #include "prince/sound.h"
 #include "prince/variatxt.h"
+#include "prince/flags.h"
 
 #include "video/flic_decoder.h"
 
@@ -93,6 +94,9 @@ PrinceEngine::PrinceEngine(OSystem *syst, const PrinceGameDescription *gameDesc)
 
 	DebugMan.enableDebugChannel("script");
 
+	gDebugLevel = 10;
+	
+
 	_rnd = new Common::RandomSource("prince");
 	_debugger = new Debugger(this);
 	_midiPlayer = new MusicPlayer(this);
@@ -373,18 +377,21 @@ void PrinceEngine::scrollCameraRight(int16 delta) {
 
 void PrinceEngine::keyHandler(Common::Event event) {
 	uint16 nChar = event.kbd.keycode;
-	if (event.kbd.hasFlags(Common::KBD_CTRL)) {
-		switch (nChar) {
-		case Common::KEYCODE_d:
+	switch (nChar) {
+	case Common::KEYCODE_d:
+		if (event.kbd.hasFlags(Common::KBD_CTRL)) {
 			getDebugger()->attach();
-			break;
-		case Common::KEYCODE_LEFT:
-			scrollCameraLeft(32);
-			break;
-		case Common::KEYCODE_RIGHT:
-			scrollCameraRight(32);
-			break;
 		}
+		break;
+	case Common::KEYCODE_LEFT:
+		scrollCameraLeft(32);
+		break;
+	case Common::KEYCODE_RIGHT:
+		scrollCameraRight(32);
+		break;
+	case Common::KEYCODE_ESCAPE:
+		_script->setFlag(Flags::ESCAPED2, 1);
+		break;
 	}
 }
 
@@ -464,6 +471,9 @@ void PrinceEngine::showTexts() {
 		}
 
 		--text._time;
+		if (text._time == 0) {
+			text._str = NULL;
+		}
 	}
 }
 
@@ -521,8 +531,8 @@ void PrinceEngine::mainLoop() {
 		if (shouldQuit())
 			return;
 
-		drawScreen();
 		_script->step();
+		drawScreen();
 
 		// Calculate the frame delay based off a desired frame time
 		int delay = 1000/15 - int32(_system->getMillis() - currentTime);
diff --git a/engines/prince/script.cpp b/engines/prince/script.cpp
index 49a0a9751c..55264a35a6 100644
--- a/engines/prince/script.cpp
+++ b/engines/prince/script.cpp
@@ -47,6 +47,10 @@ Script::~Script() {
 	delete[] _code;
 }
 
+void Script::setFlag(Flags::Id flagId, uint16 value) {
+	_flags[flagId - 0x8000] = value;
+}
+
 bool Script::loadFromStream(Common::SeekableReadStream &stream) {
 	_codeSize = stream.size();
 	_code = new byte[_codeSize];
@@ -56,7 +60,8 @@ bool Script::loadFromStream(Common::SeekableReadStream &stream) {
 
 	stream.read(_code, _codeSize);
 	// Initialize the script
-	_currentInstruction = READ_LE_UINT32(_code + 4);
+	_fgOpcodePC = READ_LE_UINT32(_code + 4);
+	_bgOpcodePC = 0;
 
 	return true;
 }
@@ -73,10 +78,21 @@ void Script::debugScript(const char *s, ...) {
 	str += Common::String::format("op %04d: ", _lastOpcode);
 	//debugC(10, DebugChannel::kScript, "PrinceEngine::Script %s %s", str.c_str(), buf);
 
-	debug("PrinceEngine::Script frame %ld %s %s", _vm->_frameNr, str.c_str(), buf);
+	debug("Prince::Script frame %ld %s %s", _vm->_frameNr, str.c_str(), buf);
 }
 
 void Script::step() {
+	if (_bgOpcodePC) {
+		_bgOpcodePC = step(_bgOpcodePC);
+	}
+	if (_fgOpcodePC) {
+		_fgOpcodePC = step(_fgOpcodePC);
+	}
+}
+
+uint32 Script::step(uint32 opcodePC) {
+
+	_currentInstruction = opcodePC;
 	while (!_opcodeNF)
 	{
 		_lastInstruction = _currentInstruction;
@@ -103,6 +119,8 @@ void Script::step() {
 			break;
 		}
 	}
+
+	return _currentInstruction;
 }
 
 uint8 Script::getCodeByte(uint32 address) {
@@ -593,6 +611,7 @@ void Script::O_GETANIMDATA() {}
 void Script::O_SETBGCODE() {
 	int32 bgcode = readScript32bits();
 	debugScript("O_SETBGCODE %d", bgcode);
+	_bgOpcodePC = _currentInstruction + bgcode;
 }
 void Script::O_SETBACKFRAME() {}
 void Script::O_GETRND() {}
@@ -633,7 +652,8 @@ void Script::O_ZOOMIN() {}
 
 void Script::O_ZOOMOUT() {}
 
-void Script::O_SETSTRINGOFFSET() {}
+void Script::O_SETSTRINGOFFSET() {
+}
 
 void Script::O_GETOBJDATA() {}
 
@@ -641,7 +661,12 @@ void Script::O_SETOBJDATA() {}
 
 void Script::O_SWAPOBJECTS() {}
 
-void Script::O_CHANGEHEROSET() {}
+void Script::O_CHANGEHEROSET() {
+	uint16 hero = readScript16bits();
+	uint16 heroSet = readScript16bits();
+
+	debugScript("O_CHANGEHEROSET hero %d, heroSet %d", hero, heroSet);
+}
 
 void Script::O_ADDSTRING() {}
 
@@ -660,6 +685,7 @@ void Script::O_STOPSAMPLE() {
 	debugScript("O_STOPSAMPLE slot %d", slot);
 
 	_vm->_mixer->stopID(slot);
+	_voiceStream = NULL;
 }
 
 void Script::O_BACKANIMRANGE() {
@@ -712,6 +738,8 @@ void Script::O_SETFGCODE() {
 	int32 offset = readScript32bits();
 
 	debugScript("O_SETFGCODE offset %04X", offset);
+
+	_fgOpcodePC = _currentInstruction + offset;	
 }
 
 void Script::O_STOPHERO() {
@@ -846,7 +874,10 @@ void Script::O_SKIPTEXT() {
 }
 
 void Script::SetVoice(uint32 slot) {
-	const Common::String streamName = Common::String::format("%03d-01.WAV", _currentString);
+
+	const uint16 VOICE_H_LINE = _flags[Flags::VOICE_H_LINE - 0x8000];
+
+	const Common::String streamName = Common::String::format("%03d-%02d.WAV", _currentString, VOICE_H_LINE);
 	debugScript("Loading wav %s slot %d", streamName.c_str(), slot);
 
 	_voiceStream = SearchMan.createReadStreamForMember(streamName);
diff --git a/engines/prince/script.h b/engines/prince/script.h
index 1343051fc9..984b2d93e9 100644
--- a/engines/prince/script.h
+++ b/engines/prince/script.h
@@ -27,6 +27,8 @@
 
 #include "audio/mixer.h"
 
+#include "prince/flags.h"
+
 namespace Common {
 	class SeekableReadStream;
 }
@@ -43,6 +45,7 @@ public:
 	bool loadFromStream(Common::SeekableReadStream &stream);
 
 	void step();
+	void setFlag(Flags::Id flag, uint16 value);
 
 private:
 	PrinceEngine *_vm;
@@ -50,12 +53,17 @@ private:
 	byte *_code;
 	uint32 _codeSize;
 	uint32 _currentInstruction;
+
+	uint32 _bgOpcodePC;
+	uint32 _fgOpcodePC;
+
 	uint16 _lastOpcode;
 	uint32 _lastInstruction;
 	byte _result;
 	int16 _flags[2000];
 	bool _opcodeNF;
 
+
 	// Stack
 	static const uint32 _STACK_SIZE = 500;
 	uint32 _stack[_STACK_SIZE];
@@ -69,6 +77,7 @@ private:
 	Common::SeekableReadStream *_voiceStream;
 
 	// Helper functions
+	uint32 step(uint32 opcodePC);
 	void checkPC(uint32 address);
 	uint8 getCodeByte(uint32 address);
 	uint8 readScript8bits();
@@ -81,6 +90,8 @@ private:
 	typedef void (Script::*OpcodeFunc)();
 	static OpcodeFunc _opcodes[];
 
+	// Keep opcode handlers names as they are in original code 
+	// it easier to switch back and forth
 	void O_WAITFOREVER();
 	void O_BLACKPALETTE();
 	void O_SETUPPALETTE();