From afee4aeacccf66f52fefacbb0904049f0ce45227 Mon Sep 17 00:00:00 2001
From: Einar Johan Trøan Sømåen
Date: Tue, 13 Mar 2012 04:57:25 +0100
Subject: WINTERMUTE: One big and ugly commit that resolves most of the
 forbidden-symbols.

The StringUtils aren't complete or tested, and the SysClasses are a hack,
and there are a few "FORBIDDEN_SYMBOL_EXCEPTIONS".

Expect this commit to need a bunch of cleanup going forwards.
---
 engines/wintermute/AdObject.cpp            |  43 ++--
 engines/wintermute/BBase.cpp               |  10 +-
 engines/wintermute/BBase.h                 |  13 +-
 engines/wintermute/BFader.cpp              |   3 +-
 engines/wintermute/BFileEntry.h            |   2 +-
 engines/wintermute/BFileManager.cpp        |  20 +-
 engines/wintermute/BFileManager.h          |   4 +-
 engines/wintermute/BFontBitmap.cpp         |   6 +-
 engines/wintermute/BFontTT.cpp             |  23 ++-
 engines/wintermute/BFontTT.h               |   6 +-
 engines/wintermute/BGame.cpp               |  15 +-
 engines/wintermute/BGame.h                 |   2 +-
 engines/wintermute/BObject.h               |   4 +-
 engines/wintermute/BParser.cpp             |   3 +-
 engines/wintermute/BPkgFile.cpp            |   9 +-
 engines/wintermute/BRegistry.cpp           |  21 +-
 engines/wintermute/BRegistry.h             |   4 +-
 engines/wintermute/BStringTable.cpp        |  12 +-
 engines/wintermute/BStringTable.h          |   6 +-
 engines/wintermute/BTransitionMgr.cpp      |   4 +-
 engines/wintermute/BViewport.cpp           |   8 +-
 engines/wintermute/FontGlyphCache.cpp      |   6 +-
 engines/wintermute/FontGlyphCache.h        |   3 +-
 engines/wintermute/PathUtil.cpp            |  40 ++--
 engines/wintermute/StringUtil.cpp          | 154 +++++++++++----
 engines/wintermute/StringUtil.h            |   6 +-
 engines/wintermute/SysClass.cpp            |  70 ++++---
 engines/wintermute/SysClass.h              |  23 ++-
 engines/wintermute/SysClassRegistry.cpp    |  35 ++--
 engines/wintermute/SysClassRegistry.h      |  34 +++-
 engines/wintermute/SysInstance.cpp         |   1 +
 engines/wintermute/UIEdit.cpp              |  17 +-
 engines/wintermute/dctypes.h               |  29 +--
 engines/wintermute/scriptables/ScEngine.h  |   2 +-
 engines/wintermute/scriptables/ScValue.cpp |   2 +-
 engines/wintermute/tinystr.cpp             | 111 +++++++++++
 engines/wintermute/tinystr.h               | 305 +++++++++++++++++++++++++++++
 engines/wintermute/tinyxml.h               |   2 +-
 engines/wintermute/utils.cpp               |  12 +-
 engines/wintermute/wintermute.cpp          |   4 +-
 engines/wintermute/wintypes.h              |   4 +-
 41 files changed, 826 insertions(+), 252 deletions(-)
 create mode 100644 engines/wintermute/tinystr.cpp
 create mode 100644 engines/wintermute/tinystr.h

(limited to 'engines')

diff --git a/engines/wintermute/AdObject.cpp b/engines/wintermute/AdObject.cpp
index 11552b1488..0e2a351ed4 100644
--- a/engines/wintermute/AdObject.cpp
+++ b/engines/wintermute/AdObject.cpp
@@ -27,29 +27,30 @@
  */
 
 #include "dcgf.h"
-#include "AdObject.h"
-#include "AdScene.h"
-#include "BGame.h"
-#include "BFrame.h"
-#include "BSound.h"
-#include "BSurfaceStorage.h"
-#include "engines/wintermute/scriptables/ScValue.h"
-#include "AdGame.h"
-#include "AdLayer.h"
-#include "AdSceneNode.h"
-#include "AdInventory.h"
-#include "AdWaypointGroup.h"
-#include "AdItem.h"
-#include "BSubFrame.h"
-#include "BFont.h"
-#include "BFontStorage.h"
+#include "engines/wintermute/AdGame.h"
+#include "engines/wintermute/AdItem.h"
+#include "engines/wintermute/AdObject.h"
+#include "engines/wintermute/AdInventory.h"
+#include "engines/wintermute/AdLayer.h"
+#include "engines/wintermute/AdScene.h"
+#include "engines/wintermute/AdSceneNode.h"
+#include "engines/wintermute/AdSentence.h"
+#include "engines/wintermute/AdWaypointGroup.h"
+#include "engines/wintermute/BGame.h"
+#include "engines/wintermute/BFrame.h"
+#include "engines/wintermute/BSound.h"
+#include "engines/wintermute/BSurfaceStorage.h"
+#include "engines/wintermute/BSubFrame.h"
+#include "engines/wintermute/BFont.h"
+#include "engines/wintermute/BFontStorage.h"
+#include "engines/wintermute/BSprite.h"
+#include "engines/wintermute/BStringTable.h"
 #include "engines/wintermute/scriptables/ScEngine.h"
-#include "BStringTable.h"
-#include "AdSentence.h"
 #include "engines/wintermute/scriptables/ScScript.h"
-#include "BSprite.h"
 #include "engines/wintermute/scriptables/ScStack.h"
+#include "engines/wintermute/scriptables/ScValue.h"
 #include "common/str.h"
+#include "common/util.h"
 
 namespace WinterMute {
 
@@ -860,8 +861,8 @@ void CAdObject::Talk(char *Text, char *Sound, uint32 Duration, char *Stances, TT
 	}
 
 	// set duration by text length
-	if (m_Sentence->m_Duration <= 0) {
-		m_Sentence->m_Duration = MAX(1000, Game->m_SubtitlesSpeed * strlen(m_Sentence->m_Text));
+	if (m_Sentence->m_Duration <= 0) {// TODO: Avoid longs.
+		m_Sentence->m_Duration = MAX((unsigned long)1000, Game->m_SubtitlesSpeed * strlen(m_Sentence->m_Text));
 	}
 
 
diff --git a/engines/wintermute/BBase.cpp b/engines/wintermute/BBase.cpp
index 845543c351..536decb5f9 100644
--- a/engines/wintermute/BBase.cpp
+++ b/engines/wintermute/BBase.cpp
@@ -57,7 +57,9 @@ CBBase::~CBBase() {
 //////////////////////////////////////////////////////////////////////////
 const char *CBBase::GetEditorProp(const char *PropName, const char *InitVal) {
 	m_EditorPropsIter = m_EditorProps.find(PropName);
-	if (m_EditorPropsIter != m_EditorProps.end()) return m_EditorPropsIter->second.c_str();
+	if (m_EditorPropsIter != m_EditorProps.end())
+		return m_EditorPropsIter->_value.c_str();
+		//return m_EditorPropsIter->second.c_str(); // <- TODO Clean
 	else return InitVal;
 }
 
@@ -161,8 +163,10 @@ HRESULT CBBase::SaveAsText(CBDynBuffer *Buffer, int Indent) {
 	while (m_EditorPropsIter != m_EditorProps.end()) {
 		Buffer->PutTextIndent(Indent, "EDITOR_PROPERTY\n");
 		Buffer->PutTextIndent(Indent, "{\n");
-		Buffer->PutTextIndent(Indent + 2, "NAME=\"%s\"\n", (char *)m_EditorPropsIter->first.c_str());
-		Buffer->PutTextIndent(Indent + 2, "VALUE=\"%s\"\n", m_EditorPropsIter->second.c_str());
+		Buffer->PutTextIndent(Indent + 2, "NAME=\"%s\"\n", (char *)m_EditorPropsIter->_key.c_str());
+		Buffer->PutTextIndent(Indent + 2, "VALUE=\"%s\"\n", m_EditorPropsIter->_value.c_str());
+		//Buffer->PutTextIndent(Indent + 2, "NAME=\"%s\"\n", (char *)m_EditorPropsIter->first.c_str()); // <- TODO, remove
+		//Buffer->PutTextIndent(Indent + 2, "VALUE=\"%s\"\n", m_EditorPropsIter->second.c_str()); // <- TODO, remove
 		Buffer->PutTextIndent(Indent, "}\n\n");
 
 		m_EditorPropsIter++;
diff --git a/engines/wintermute/BBase.h b/engines/wintermute/BBase.h
index ba228bc572..c72d687eca 100644
--- a/engines/wintermute/BBase.h
+++ b/engines/wintermute/BBase.h
@@ -31,8 +31,11 @@
 
 #include "wintypes.h"
 #include "dctypes.h"
-#include <map>
-#include <string>
+#include "common/str.h"
+#include "common/hashmap.h"
+#include "common/hash-str.h"
+//#include <map>
+//#include <string>
 
 namespace WinterMute {
 
@@ -52,8 +55,10 @@ public:
 	CBBase(CBGame *GameOwner);
 	virtual ~CBBase();
 
-	std::map<std::string, std::string> m_EditorProps;
-	std::map<std::string, std::string>::iterator m_EditorPropsIter;
+	Common::HashMap<Common::String, Common::String> m_EditorProps;
+	Common::HashMap<Common::String, Common::String>::iterator m_EditorPropsIter;
+/*	std::map<std::string, std::string> m_EditorProps;
+	std::map<std::string, std::string>::iterator m_EditorPropsIter;*/
 };
 
 } // end of namespace WinterMute
diff --git a/engines/wintermute/BFader.cpp b/engines/wintermute/BFader.cpp
index f64023a08d..955f0252f5 100644
--- a/engines/wintermute/BFader.cpp
+++ b/engines/wintermute/BFader.cpp
@@ -30,6 +30,7 @@
 #include "BFader.h"
 #include "BGame.h"
 #include "PlatformSDL.h"
+#include "common/util.h"
 
 namespace WinterMute {
 
@@ -73,7 +74,7 @@ HRESULT CBFader::Update() {
 	else {
 		m_CurrentAlpha = m_SourceAlpha + (float)time / (float)m_Duration * AlphaDelta;
 	}
-	m_CurrentAlpha = MIN(255, std::max(m_CurrentAlpha, (byte )0));
+	m_CurrentAlpha = MIN((unsigned char)255, MAX(m_CurrentAlpha, (byte )0)); // TODO: clean
 
 	m_Ready = time >= m_Duration;
 	if (m_Ready && m_CurrentAlpha == 0x00) m_Active = false;
diff --git a/engines/wintermute/BFileEntry.h b/engines/wintermute/BFileEntry.h
index cfad80926c..2c555c8bfe 100644
--- a/engines/wintermute/BFileEntry.h
+++ b/engines/wintermute/BFileEntry.h
@@ -42,7 +42,7 @@ public:
 	uint32 m_TimeDate1;
 	uint32 m_Flags;
 	uint32 m_JournalTime;
-	std::string m_Filename;
+	Common::String m_Filename;
 	uint32 m_CompressedLength;
 	uint32 m_Length;
 	uint32 m_Offset;
diff --git a/engines/wintermute/BFileManager.cpp b/engines/wintermute/BFileManager.cpp
index ce0de04596..8763506e99 100644
--- a/engines/wintermute/BFileManager.cpp
+++ b/engines/wintermute/BFileManager.cpp
@@ -43,6 +43,7 @@
 #include "PlatformSDL.h"
 #include "common/str.h"
 #include "common/textconsole.h"
+#include "common/util.h"
 //#include <boost/filesystem.hpp>
 
 #ifdef __WIN32__
@@ -106,7 +107,7 @@ HRESULT CBFileManager::Cleanup() {
 	// delete file entries
 	m_FilesIter = m_Files.begin();
 	while (m_FilesIter != m_Files.end()) {
-		delete m_FilesIter->second;
+		delete m_FilesIter->_value;
 		m_FilesIter++;
 	}
 	m_Files.clear();
@@ -491,7 +492,6 @@ HRESULT CBFileManager::RegisterPackage(const char *Path, const char *Name, bool
 				fread(&TimeDate1, sizeof(uint32), 1, f);
 				fread(&TimeDate2, sizeof(uint32), 1, f);
 			}
-
 			m_FilesIter = m_Files.find(Name);
 			if (m_FilesIter == m_Files.end()) {
 				CBFileEntry *file = new CBFileEntry(Game);
@@ -504,12 +504,12 @@ HRESULT CBFileManager::RegisterPackage(const char *Path, const char *Name, bool
 				m_Files[Name] = file;
 			} else {
 				// current package has lower CD number or higher priority, than the registered
-				if (pkg->m_CD < m_FilesIter->second->m_Package->m_CD || pkg->m_Priority > m_FilesIter->second->m_Package->m_Priority) {
-					m_FilesIter->second->m_Package = pkg;
-					m_FilesIter->second->m_Offset = Offset;
-					m_FilesIter->second->m_Length = Length;
-					m_FilesIter->second->m_CompressedLength = CompLength;
-					m_FilesIter->second->m_Flags = Flags;
+				if (pkg->m_CD < m_FilesIter->_value->m_Package->m_CD || pkg->m_Priority > m_FilesIter->_value->m_Package->m_Priority) {
+					m_FilesIter->_value->m_Package = pkg;
+					m_FilesIter->_value->m_Offset = Offset;
+					m_FilesIter->_value->m_Length = Length;
+					m_FilesIter->_value->m_CompressedLength = CompLength;
+					m_FilesIter->_value->m_Flags = Flags;
 				}
 			}
 			delete [] Name;
@@ -605,7 +605,7 @@ CBFileEntry *CBFileManager::GetPackageEntry(const char *Filename) {
 
 	CBFileEntry *ret = NULL;
 	m_FilesIter = m_Files.find(upc_name);
-	if (m_FilesIter != m_Files.end()) ret = m_FilesIter->second;
+	if (m_FilesIter != m_Files.end()) ret = m_FilesIter->_value;
 
 	delete [] upc_name;
 
@@ -721,7 +721,7 @@ bool CBFileManager::FindPackageSignature(FILE *f, uint32 *Offset) {
 	int BytesRead = StartPos;
 
 	while (BytesRead < FileSize - 16) {
-		int ToRead = MIN(32768, FileSize - BytesRead);
+		int ToRead = MIN((unsigned int)32768, FileSize - BytesRead);
 		fseek(f, StartPos, SEEK_SET);
 		int ActuallyRead = fread(buf, 1, ToRead, f);
 		if (ActuallyRead != ToRead) return false;
diff --git a/engines/wintermute/BFileManager.h b/engines/wintermute/BFileManager.h
index e585841a4a..849a30bf8e 100644
--- a/engines/wintermute/BFileManager.h
+++ b/engines/wintermute/BFileManager.h
@@ -68,10 +68,10 @@ public:
 	CBArray<CBPackage *, CBPackage *> m_Packages;
 	CBArray<CBFile *, CBFile *> m_OpenFiles;
 
-	std::map<std::string, CBFileEntry *> m_Files;
+	Common::HashMap<Common::String, CBFileEntry *> m_Files;
 private:
 	HRESULT RegisterPackage(const char *Path, const char *Name, bool SearchSignature = false);
-	std::map<std::string, CBFileEntry *>::iterator m_FilesIter;
+	Common::HashMap<Common::String, CBFileEntry *>::iterator m_FilesIter;
 	bool IsValidPackage(const AnsiString &fileName) const;
 
 };
diff --git a/engines/wintermute/BFontBitmap.cpp b/engines/wintermute/BFontBitmap.cpp
index 4b5b0c6199..9b49a84079 100644
--- a/engines/wintermute/BFontBitmap.cpp
+++ b/engines/wintermute/BFontBitmap.cpp
@@ -92,10 +92,12 @@ int CBFontBitmap::GetTextWidth(byte  *text, int MaxLength) {
 		str = AnsiString((char *)text);
 	}
 
-	if (MaxLength >= 0 && str.length() > MaxLength) str = str.substr(0, MaxLength);
+	if (MaxLength >= 0 && str.size() > MaxLength) 
+		str = Common::String(str.c_str(), MaxLength);
+		//str.substr(0, MaxLength); // TODO: Remove
 
 	int TextWidth = 0;
-	for (size_t i = 0; i < str.length(); i++) {
+	for (size_t i = 0; i < str.size(); i++) {
 		TextWidth += GetCharWidth(str[i]);
 	}
 
diff --git a/engines/wintermute/BFontTT.cpp b/engines/wintermute/BFontTT.cpp
index a1ca6577fa..398d3bb1d9 100644
--- a/engines/wintermute/BFontTT.cpp
+++ b/engines/wintermute/BFontTT.cpp
@@ -124,7 +124,9 @@ int CBFontTT::GetTextWidth(byte  *Text, int MaxLength) {
 	if (Game->m_TextEncoding == TEXT_UTF8) text = StringUtil::Utf8ToWide((char *)Text);
 	else text = StringUtil::AnsiToWide((char *)Text);
 
-	if (MaxLength >= 0 && text.length() > MaxLength) text = text.substr(0, MaxLength);
+	if (MaxLength >= 0 && text.size() > MaxLength) 
+		text = Common::String(text.c_str(), MaxLength);
+		//text = text.substr(0, MaxLength); // TODO: Remove
 
 	int textWidth, textHeight;
 	MeasureText(text, -1, -1, textWidth, textHeight);
@@ -156,7 +158,9 @@ void CBFontTT::DrawText(byte  *Text, int X, int Y, int Width, TTextAlign Align,
 	if (Game->m_TextEncoding == TEXT_UTF8) text = StringUtil::Utf8ToWide((char *)Text);
 	else text = StringUtil::AnsiToWide((char *)Text);
 
-	if (MaxLength >= 0 && text.length() > MaxLength) text = text.substr(0, MaxLength);
+	if (MaxLength >= 0 && text.size() > MaxLength) 
+		text = Common::String(text.c_str(), MaxLength);
+		//text = text.substr(0, MaxLength); // TODO: Remove
 
 	CBRenderSDL *m_Renderer = (CBRenderSDL *)Game->m_Renderer;
 
@@ -258,7 +262,7 @@ CBSurface *CBFontTT::RenderTextToTexture(const WideString &text, int width, TTex
 
 
 		textOffset = 0;
-		for (size_t i = 0; i < line->GetText().length(); i++) {
+		for (size_t i = 0; i < line->GetText().size(); i++) {
 			wchar_t ch = line->GetText()[i];
 
 			GlyphInfo *glyph = m_GlyphCache->GetGlyph(ch);
@@ -271,7 +275,7 @@ CBSurface *CBFontTT::RenderTextToTexture(const WideString &text, int width, TTex
 		int origPosX = posX;
 
 		wchar_t prevChar = L'\0';
-		for (size_t i = 0; i < line->GetText().length(); i++) {
+		for (size_t i = 0; i < line->GetText().size(); i++) {
 			wchar_t ch = line->GetText()[i];
 
 			GlyphInfo *glyph = m_GlyphCache->GetGlyph(ch);
@@ -700,7 +704,7 @@ void CBFontTT::WrapText(const WideString &text, int maxWidth, int maxHeight, Tex
 
 	PrepareGlyphs(text);
 
-	for (size_t i = 0; i < text.length(); i++) {
+	for (size_t i = 0; i < text.size(); i++) {
 		wchar_t ch = text[i];
 
 		if (ch == L' ') {
@@ -728,7 +732,7 @@ void CBFontTT::WrapText(const WideString &text, int maxWidth, int maxHeight, Tex
 		if (lineTooLong && currWidth == 0) break;
 
 
-		if (ch == L'\n' || i == text.length() - 1 || lineTooLong) {
+		if (ch == L'\n' || i == text.size() - 1 || lineTooLong) {
 			int breakPoint, breakWidth;
 
 			if (prevSpaceIndex >= 0 && lineTooLong) {
@@ -742,7 +746,7 @@ void CBFontTT::WrapText(const WideString &text, int maxWidth, int maxHeight, Tex
 				breakOnSpace = (ch == L'\n');
 
 				// we're at the end
-				if (i == text.length() - 1) {
+				if (i == text.size() - 1) {
 					breakPoint++;
 					breakWidth += charWidth;
 				}
@@ -750,7 +754,8 @@ void CBFontTT::WrapText(const WideString &text, int maxWidth, int maxHeight, Tex
 
 			if (maxHeight >= 0 && (lines.size() + 1) * GetLineHeight() > maxHeight) break;
 
-			WideString line = text.substr(lineStartIndex, breakPoint - lineStartIndex);
+			//WideString line = text.substr(lineStartIndex, breakPoint - lineStartIndex); // TODO: Remove
+			WideString line = Common::String(text.c_str() + lineStartIndex, breakPoint - lineStartIndex);
 			lines.push_back(new TextLine(line, breakWidth));
 
 			currWidth = 0;
@@ -805,7 +810,7 @@ float CBFontTT::GetKerning(wchar_t leftChar, wchar_t rightChar) {
 //////////////////////////////////////////////////////////////////////////
 void CBFontTT::PrepareGlyphs(const WideString &text) {
 	// make sure we have all the glyphs we need
-	for (size_t i = 0; i < text.length(); i++) {
+	for (size_t i = 0; i < text.size(); i++) {
 		wchar_t ch = text[i];
 		if (!m_GlyphCache->HasGlyph(ch)) CacheGlyph(ch);
 	}
diff --git a/engines/wintermute/BFontTT.h b/engines/wintermute/BFontTT.h
index 6fbb019a27..5675cca5de 100644
--- a/engines/wintermute/BFontTT.h
+++ b/engines/wintermute/BFontTT.h
@@ -35,6 +35,7 @@
 
 #define NUM_CACHED_TEXTS 30
 class SDL_Surface;
+class SDL_Rect;
 namespace WinterMute {
 
 class FontGlyphCache;
@@ -55,7 +56,8 @@ private:
 		bool m_Marked;
 
 		CBCachedTTFontText() {
-			m_Text = L"";
+			//m_Text = L"";
+			m_Text = "";
 			m_Width = m_MaxHeight = m_MaxLength = -1;
 			m_Align = TAL_LEFT;
 			m_Surface = NULL;
@@ -108,7 +110,7 @@ public:
 		WideString m_Text;
 		int m_Width;
 	};
-	typedef std::list<TextLine *> TextLineList;
+	typedef Common::List<TextLine *> TextLineList;
 
 
 public:
diff --git a/engines/wintermute/BGame.cpp b/engines/wintermute/BGame.cpp
index a4329fc5df..5cc048b48d 100644
--- a/engines/wintermute/BGame.cpp
+++ b/engines/wintermute/BGame.cpp
@@ -68,6 +68,7 @@
 #include "engines/wintermute/scriptables/SXStore.h"
 #include "engines/wintermute/scriptables/SXString.h"
 #include "common/textconsole.h"
+#include "common/util.h"
 
 #ifdef __IPHONEOS__
 #   include "ios_utils.h"
@@ -514,7 +515,7 @@ void CBGame::DEBUG_DebugEnable(const char *Filename) {
 		m_DEBUG_LogFile = fopen(safeLogFileName.c_str(), "a+");
 	}
 
-	if (m_DEBUG_LogFile != NULL) fprintf(m_DEBUG_LogFile, "\n");
+	if (m_DEBUG_LogFile != NULL) fprintf((FILE*)m_DEBUG_LogFile, "\n");
 #endif
 
 	time_t timeNow;
@@ -540,7 +541,7 @@ void CBGame::DEBUG_DebugEnable(const char *Filename) {
 void CBGame::DEBUG_DebugDisable() {
 	if (m_DEBUG_LogFile != NULL) {
 		LOG(0, "********** DEBUG LOG CLOSED ********************************************");
-		fclose(m_DEBUG_LogFile);
+		fclose((FILE*)m_DEBUG_LogFile);
 		m_DEBUG_LogFile = NULL;
 	}
 	m_DEBUG_DebugMode = false;
@@ -576,8 +577,8 @@ void CBGame::LOG(HRESULT res, LPCSTR fmt, ...) {
 	if (m_DebugMgr) m_DebugMgr->OnLog(res, buff);
 
 	warning("%02d:%02d: %s\n", tm->tm_hour, tm->tm_min, buff);
-	fprintf(m_DEBUG_LogFile, "%02d:%02d: %s\n", tm->tm_hour, tm->tm_min, buff);
-	fflush(m_DEBUG_LogFile);
+	fprintf((FILE*)m_DEBUG_LogFile, "%02d:%02d: %s\n", tm->tm_hour, tm->tm_min, buff);
+	fflush((FILE*)m_DEBUG_LogFile);
 #endif
 
 	//QuickMessage(buff);
@@ -615,12 +616,12 @@ HRESULT CBGame::InitLoop() {
 
 	m_LiveTimerDelta = m_LiveTimer - m_LiveTimerLast;
 	m_LiveTimerLast = m_LiveTimer;
-	m_LiveTimer += MIN(1000, m_DeltaTime);
+	m_LiveTimer += MIN((uint32)1000, m_DeltaTime);
 
 	if (m_State != GAME_FROZEN) {
 		m_TimerDelta = m_Timer - m_TimerLast;
 		m_TimerLast = m_Timer;
-		m_Timer += MIN(1000, m_DeltaTime);
+		m_Timer += MIN((uint32)1000, m_DeltaTime);
 	} else m_TimerDelta = 0;
 
 	m_FramesRendered++;
@@ -2015,7 +2016,7 @@ HRESULT CBGame::ScCallMethod(CScScript *Script, CScStack *Stack, CScStack *ThisS
 			int BytesRead = 0;
 
 			while (BytesRead < File->GetSize()) {
-				int BufSize = MIN(1024, File->GetSize() - BytesRead);
+				int BufSize = MIN((uint32)1024, File->GetSize() - BytesRead);
 				BytesRead += BufSize;
 
 				File->Read(Buf, BufSize);
diff --git a/engines/wintermute/BGame.h b/engines/wintermute/BGame.h
index 610915d154..5de2beacc3 100644
--- a/engines/wintermute/BGame.h
+++ b/engines/wintermute/BGame.h
@@ -191,7 +191,7 @@ public:
 	bool m_DEBUG_DebugMode;
 	bool m_DEBUG_AbsolutePathWarning;
 
-	FILE *m_DEBUG_LogFile;
+	void *m_DEBUG_LogFile;
 	int m_Sequence;
 	virtual HRESULT LoadFile(const char *Filename);
 	virtual HRESULT LoadBuffer(byte  *Buffer, bool Complete = true);
diff --git a/engines/wintermute/BObject.h b/engines/wintermute/BObject.h
index 064cc78fc4..3fd22fafcd 100644
--- a/engines/wintermute/BObject.h
+++ b/engines/wintermute/BObject.h
@@ -30,10 +30,12 @@
 #define WINTERMUTE_BOBJECT_H
 
 
-#include "SDL.h"
+//#include "SDL.h"
 #include "BScriptHolder.h"
 #include "persistent.h"
 
+union SDL_Event;
+
 namespace WinterMute {
 
 class CBSprite;
diff --git a/engines/wintermute/BParser.cpp b/engines/wintermute/BParser.cpp
index de8dd140d2..94de0771f9 100644
--- a/engines/wintermute/BParser.cpp
+++ b/engines/wintermute/BParser.cpp
@@ -31,6 +31,7 @@
 #include "BGame.h"
 #include "PlatformSDL.h"
 #include "common/str.h"
+#include "common/util.h"
 
 #define WHITESPACE " \t\n\r"
 
@@ -88,7 +89,7 @@ long CBParser::GetObject(char **buf, TokenDesc *tokens, char **name, char **data
 	if (tokens->id == 0) {
 		char *p = strchr(*buf, '\n');
 		if (p && p > *buf) {
-			strncpy(m_LastOffender, *buf, MIN(255, p - *buf));
+			strncpy(m_LastOffender, *buf, MIN((long int)255, p - *buf)); // TODO, clean
 		} else strcpy(m_LastOffender, "");
 
 		return PARSERR_TOKENNOTFOUND;
diff --git a/engines/wintermute/BPkgFile.cpp b/engines/wintermute/BPkgFile.cpp
index 1210d90e24..deac1c8817 100644
--- a/engines/wintermute/BPkgFile.cpp
+++ b/engines/wintermute/BPkgFile.cpp
@@ -31,6 +31,7 @@
 #include "BPkgFile.h"
 #include "BGame.h"
 #include "BFileManager.h"
+#include "common/util.h"
 
 #if _DEBUG
 #pragma comment(lib, "zlib_d.lib")
@@ -131,7 +132,7 @@ HRESULT CBPkgFile::Read(void *Buffer, uint32 Size) {
 		while (m_Stream.total_out - InitOut < Size && m_Stream.total_in < m_FileEntry->m_CompressedLength) {
 			// needs to read more data?
 			if (m_Stream.avail_in == 0) {
-				m_Stream.avail_in = MIN(COMPRESSED_BUFFER_SIZE, m_FileEntry->m_CompressedLength - m_Stream.total_in);
+				m_Stream.avail_in = MIN((long unsigned int)COMPRESSED_BUFFER_SIZE, m_FileEntry->m_CompressedLength - m_Stream.total_in); // TODO: long unsigned int????
 				m_FileEntry->m_Package->Read(m_File, m_FileEntry->m_Offset + m_Stream.total_in, m_CompBuffer, m_Stream.avail_in);
 				m_Stream.next_in = m_CompBuffer;
 			}
@@ -192,7 +193,7 @@ HRESULT CBPkgFile::SeekToPos(uint32 NewPos) {
 
 		m_Stream.avail_in = 0;
 		m_Stream.next_in = m_CompBuffer;
-		m_Stream.avail_out = MIN(STREAM_BUFFER_SIZE, NewPos);
+		m_Stream.avail_out = MIN((uint32)STREAM_BUFFER_SIZE, NewPos); //TODO: remove cast.
 		m_Stream.next_out = StreamBuffer;
 		inflateInit(&m_Stream);
 		m_InflateInit = true;
@@ -200,7 +201,7 @@ HRESULT CBPkgFile::SeekToPos(uint32 NewPos) {
 		while (m_Stream.total_out < NewPos && m_Stream.total_in < m_FileEntry->m_CompressedLength) {
 			// needs to read more data?
 			if (m_Stream.avail_in == 0) {
-				m_Stream.avail_in = MIN(COMPRESSED_BUFFER_SIZE, m_FileEntry->m_CompressedLength - m_Stream.total_in);
+				m_Stream.avail_in = MIN((long unsigned int)COMPRESSED_BUFFER_SIZE, m_FileEntry->m_CompressedLength - m_Stream.total_in); // TODO: long unsigned int???
 				m_FileEntry->m_Package->Read(m_File, m_FileEntry->m_Offset + m_Stream.total_in, m_CompBuffer, m_Stream.avail_in);
 				m_Stream.next_in = m_CompBuffer;
 			}
@@ -208,7 +209,7 @@ HRESULT CBPkgFile::SeekToPos(uint32 NewPos) {
 			// needs more space?
 			if (m_Stream.avail_out == 0) {
 				m_Stream.next_out = StreamBuffer;
-				m_Stream.avail_out = MIN(STREAM_BUFFER_SIZE, NewPos - m_Stream.total_out);
+				m_Stream.avail_out = MIN((long unsigned int)STREAM_BUFFER_SIZE, NewPos - m_Stream.total_out); // TODO: long unsigned int???.
 			}
 
 			// stream on!
diff --git a/engines/wintermute/BRegistry.cpp b/engines/wintermute/BRegistry.cpp
index 4d7b1b6d37..75b621d90f 100644
--- a/engines/wintermute/BRegistry.cpp
+++ b/engines/wintermute/BRegistry.cpp
@@ -159,26 +159,27 @@ AnsiString CBRegistry::GetValue(PathValueMap &values, const AnsiString path, con
 	PathValueMap::iterator it = values.find(path);
 	if (it == values.end()) return "";
 
-	KeyValuePair pairs = (*it).second;
+	KeyValuePair pairs = (*it)._value;
 	KeyValuePair::iterator keyIt = pairs.find(key);
 	if (keyIt == pairs.end()) return "";
 	else {
 		found = true;
-		return (*keyIt).second;
+		return (*keyIt)._value;
 	}
 }
 
 //////////////////////////////////////////////////////////////////////////
 void CBRegistry::LoadXml(const AnsiString fileName, PathValueMap &values) {
-	TiXmlDocument doc(fileName);
+	TiXmlDocument doc(fileName.c_str());
 	if (!doc.LoadFile()) return;
 
 	TiXmlElement *rootElem = doc.RootElement();
-	if (!rootElem || rootElem->ValueStr() != "Settings") return;
+	if (!rootElem || Common::String(rootElem->Value()) != "Settings") // TODO: Avoid this strcmp-use. (Hack for now, since we might drop TinyXML all together)
+		return;
 
 	for (TiXmlElement *pathElem = rootElem->FirstChildElement(); pathElem != NULL; pathElem = pathElem->NextSiblingElement()) {
 		for (TiXmlElement *keyElem = pathElem->FirstChildElement(); keyElem != NULL; keyElem = keyElem->NextSiblingElement()) {
-			values[pathElem->ValueStr()][keyElem->ValueStr()] = keyElem->GetText();
+			values[Common::String(pathElem->Value())][Common::String(keyElem->Value())] = keyElem->GetText();
 		}
 	}
 }
@@ -196,17 +197,17 @@ void CBRegistry::SaveXml(const AnsiString fileName, PathValueMap &values) {
 
 	PathValueMap::iterator pathIt;
 	for (pathIt = m_Values.begin(); pathIt != m_Values.end(); ++pathIt) {
-		TiXmlElement *pathElem = new TiXmlElement((*pathIt).first);
+		TiXmlElement *pathElem = new TiXmlElement((*pathIt)._key.c_str());
 		root->LinkEndChild(pathElem);
 
 
-		KeyValuePair pairs = (*pathIt).second;
+		KeyValuePair pairs = (*pathIt)._value;
 		KeyValuePair::iterator keyIt;
 		for (keyIt = pairs.begin(); keyIt != pairs.end(); ++keyIt) {
-			TiXmlElement *keyElem = new TiXmlElement((*keyIt).first);
+			TiXmlElement *keyElem = new TiXmlElement((*keyIt)._key.c_str());
 			pathElem->LinkEndChild(keyElem);
 
-			keyElem->LinkEndChild(new TiXmlText((*keyIt).second));
+			keyElem->LinkEndChild(new TiXmlText((*keyIt)._value.c_str()));
 		}
 	}
 
@@ -219,7 +220,7 @@ void CBRegistry::SaveXml(const AnsiString fileName, PathValueMap &values) {
 
 	if (!stream.is_open()) return;
 	else {
-		stream << printer.Str();
+		stream << printer.CStr();
 		stream.close();
 	}
 }
diff --git a/engines/wintermute/BRegistry.h b/engines/wintermute/BRegistry.h
index 48b88fd663..2838d3794f 100644
--- a/engines/wintermute/BRegistry.h
+++ b/engines/wintermute/BRegistry.h
@@ -57,8 +57,8 @@ public:
 private:
 	char *m_IniName;
 
-	typedef std::map<AnsiString, AnsiString> KeyValuePair;
-	typedef std::map<AnsiString, KeyValuePair> PathValueMap;
+	typedef Common::HashMap<AnsiString, AnsiString> KeyValuePair;
+	typedef Common::HashMap<AnsiString, KeyValuePair> PathValueMap;
 
 	PathValueMap m_LocalValues;
 	PathValueMap m_Values;
diff --git a/engines/wintermute/BStringTable.cpp b/engines/wintermute/BStringTable.cpp
index e3bf2fd89b..fda4853115 100644
--- a/engines/wintermute/BStringTable.cpp
+++ b/engines/wintermute/BStringTable.cpp
@@ -58,7 +58,7 @@ HRESULT CBStringTable::AddString(const char *Key, const char *Val, bool ReportDu
 		return S_OK;
 	}
 
-	std::string final_key = Key;
+	Common::String final_key = Key;
 	StringUtil::ToLowerCase(final_key);
 
 	m_StringsIter = m_Strings.find(final_key);
@@ -85,8 +85,8 @@ char *CBStringTable::GetKey(const char *Str) {
 
 	m_StringsIter = m_Strings.find(key);
 	if (m_StringsIter != m_Strings.end()) {
-		new_str = new char[m_StringsIter->second.length() + 1];
-		strcpy(new_str, m_StringsIter->second.c_str());
+		new_str = new char[m_StringsIter->_value.size() + 1];
+		strcpy(new_str, m_StringsIter->_value.c_str());
 		if (strlen(new_str) > 0 && new_str[0] == '/' && strchr(new_str + 1, '/')) {
 			delete [] key;
 			char *Ret = GetKey(new_str);
@@ -121,8 +121,8 @@ void CBStringTable::Expand(char **Str, bool ForceExpand) {
 
 	m_StringsIter = m_Strings.find(key);
 	if (m_StringsIter != m_Strings.end()) {
-		new_str = new char[m_StringsIter->second.length() + 1];
-		strcpy(new_str, m_StringsIter->second.c_str());
+		new_str = new char[m_StringsIter->_value.size() + 1];
+		strcpy(new_str, m_StringsIter->_value.c_str());
 	} else {
 		new_str = new char[strlen(value) + 1];
 		strcpy(new_str, value);
@@ -156,7 +156,7 @@ const char *CBStringTable::ExpandStatic(const char *String, bool ForceExpand) {
 
 	m_StringsIter = m_Strings.find(key);
 	if (m_StringsIter != m_Strings.end()) {
-		new_str = m_StringsIter->second.c_str();
+		new_str = m_StringsIter->_value.c_str();
 	} else {
 		new_str = value;
 	}
diff --git a/engines/wintermute/BStringTable.h b/engines/wintermute/BStringTable.h
index 6b28f5307d..28617c8593 100644
--- a/engines/wintermute/BStringTable.h
+++ b/engines/wintermute/BStringTable.h
@@ -30,7 +30,7 @@
 #define WINTERMUTE_BSTRINGTABLE_H
 
 
-#include <map>
+#include "common/hashmap.h"
 #include "BBase.h"
 
 namespace WinterMute {
@@ -43,10 +43,10 @@ public:
 	HRESULT AddString(const char *Key, const char *Val, bool ReportDuplicities = true);
 	CBStringTable(CBGame *inGame);
 	virtual ~CBStringTable();
-	std::map<std::string, std::string> m_Strings;
+	Common::HashMap<Common::String, Common::String> m_Strings;
 	char *GetKey(const char *Str);
 private:
-	std::map<std::string, std::string>::iterator m_StringsIter;
+	Common::HashMap<Common::String, Common::String>::iterator m_StringsIter;
 
 };
 
diff --git a/engines/wintermute/BTransitionMgr.cpp b/engines/wintermute/BTransitionMgr.cpp
index 56703b3336..78fd43c545 100644
--- a/engines/wintermute/BTransitionMgr.cpp
+++ b/engines/wintermute/BTransitionMgr.cpp
@@ -98,7 +98,7 @@ HRESULT CBTransitionMgr::Update() {
 	case TRANSITION_FADE_OUT: {
 		uint32 time = CBPlatform::GetTime() - m_LastTime;
 		int Alpha = 255 - (float)time / (float)FADE_DURATION * 255;
-		Alpha = std::min(255, std::max(Alpha, 0));
+		Alpha = MIN(255, MAX(Alpha, 0));
 		Game->m_Renderer->Fade((WORD)Alpha);
 
 		if (time > FADE_DURATION) m_State = TRANS_MGR_READY;
@@ -108,7 +108,7 @@ HRESULT CBTransitionMgr::Update() {
 	case TRANSITION_FADE_IN: {
 		uint32 time = CBPlatform::GetTime() - m_LastTime;
 		int Alpha = (float)time / (float)FADE_DURATION * 255;
-		Alpha = std::min(255, std::max(Alpha, 0));
+		Alpha = MIN(255, MAX(Alpha, 0));
 		Game->m_Renderer->Fade((WORD)Alpha);
 
 		if (time > FADE_DURATION) m_State = TRANS_MGR_READY;
diff --git a/engines/wintermute/BViewport.cpp b/engines/wintermute/BViewport.cpp
index bb2f5b6b29..57cb1bc02f 100644
--- a/engines/wintermute/BViewport.cpp
+++ b/engines/wintermute/BViewport.cpp
@@ -65,10 +65,10 @@ HRESULT CBViewport::Persist(CBPersistMgr *PersistMgr) {
 //////////////////////////////////////////////////////////////////////////
 HRESULT CBViewport::SetRect(int left, int top, int right, int bottom, bool NoCheck) {
 	if (!NoCheck) {
-		left = std::max(left, 0);
-		top = std::max(top, 0);
-		right = std::min(right, Game->m_Renderer->m_Width);
-		bottom = std::min(bottom, Game->m_Renderer->m_Height);
+		left = MAX(left, 0);
+		top = MAX(top, 0);
+		right = MIN(right, Game->m_Renderer->m_Width);
+		bottom = MIN(bottom, Game->m_Renderer->m_Height);
 	}
 
 	CBPlatform::SetRect(&m_Rect, left, top, right, bottom);
diff --git a/engines/wintermute/FontGlyphCache.cpp b/engines/wintermute/FontGlyphCache.cpp
index 6181fb2704..04c7095dd1 100644
--- a/engines/wintermute/FontGlyphCache.cpp
+++ b/engines/wintermute/FontGlyphCache.cpp
@@ -36,8 +36,8 @@ FontGlyphCache::~FontGlyphCache() {
 	GlyphInfoMap::iterator it;
 
 	for (it = m_Glyphs.begin(); it != m_Glyphs.end(); ++it) {
-		delete it->second;
-		it->second = NULL;
+		delete it->_value;
+		it->_value = NULL;
 	}
 }
 
@@ -56,7 +56,7 @@ GlyphInfo *FontGlyphCache::GetGlyph(wchar_t ch) {
 	it = m_Glyphs.find(ch);
 	if (it == m_Glyphs.end()) return NULL;
 
-	return it->second;
+	return it->_value;
 }
 
 //////////////////////////////////////////////////////////////////////////
diff --git a/engines/wintermute/FontGlyphCache.h b/engines/wintermute/FontGlyphCache.h
index 50db962771..c30e0f92b8 100644
--- a/engines/wintermute/FontGlyphCache.h
+++ b/engines/wintermute/FontGlyphCache.h
@@ -111,7 +111,8 @@ public:
 	void AddGlyph(wchar_t ch, int glyphIndex, FT_GlyphSlot glyphSlot, size_t width, size_t height, byte *pixels, size_t stride = 0);
 
 private:
-	typedef std::map<wchar_t, GlyphInfo *> GlyphInfoMap;
+	//typedef Common::HashMap<wchar_t, GlyphInfo *> GlyphInfoMap;
+	typedef Common::HashMap<char, GlyphInfo *> GlyphInfoMap; // TODO
 	GlyphInfoMap m_Glyphs;
 };
 
diff --git a/engines/wintermute/PathUtil.cpp b/engines/wintermute/PathUtil.cpp
index d7d632f398..aea35e395f 100644
--- a/engines/wintermute/PathUtil.cpp
+++ b/engines/wintermute/PathUtil.cpp
@@ -77,40 +77,48 @@ AnsiString PathUtil::Combine(const AnsiString &path1, const AnsiString &path2) {
 AnsiString PathUtil::GetDirectoryName(const AnsiString &path) {
 	AnsiString newPath = UnifySeparators(path);
 
-	size_t pos = newPath.find_last_of(L'/');
-
-	if (pos == AnsiString::npos) return "";
-	else return newPath.substr(0, pos + 1);
+	//size_t pos = newPath.find_last_of(L'/');
+	Common::String filename = GetFileName(path);
+	return Common::String(path.c_str(), path.size() - filename.size());
+	//if (pos == AnsiString::npos) return "";
+	//else return newPath.substr(0, pos + 1);
 }
 
 //////////////////////////////////////////////////////////////////////////
 AnsiString PathUtil::GetFileName(const AnsiString &path) {
 	AnsiString newPath = UnifySeparators(path);
 
-	size_t pos = newPath.find_last_of(L'/');
-
-	if (pos == AnsiString::npos) return path;
-	else return newPath.substr(pos + 1);
+	//size_t pos = newPath.find_last_of(L'/'); TODO REMOVE.
+	Common::String lastPart = Common::lastPathComponent(path,'/');
+	if (lastPart[lastPart.size() - 1 ] != '/')
+		return lastPart;
+	else
+		return path;
+	//if (pos == AnsiString::npos) return path;
+	//else return newPath.substr(pos + 1);
 }
 
 //////////////////////////////////////////////////////////////////////////
 AnsiString PathUtil::GetFileNameWithoutExtension(const AnsiString &path) {
 	AnsiString fileName = GetFileName(path);
 
-	size_t pos = fileName.find_last_of('.');
-
-	if (pos == AnsiString::npos) return fileName;
-	else return fileName.substr(0, pos);
+	//size_t pos = fileName.find_last_of('.'); //TODO REMOVE!
+	// TODO: Prettify this.
+	Common::String extension = Common::lastPathComponent(path, '.');
+	Common::String filename = Common::String(path.c_str(), path.size() - extension.size());
+	return filename;
+	//if (pos == AnsiString::npos) return fileName;
+	//else return fileName.substr(0, pos);
 }
 
 //////////////////////////////////////////////////////////////////////////
 AnsiString PathUtil::GetExtension(const AnsiString &path) {
 	AnsiString fileName = GetFileName(path);
 
-	size_t pos = fileName.find_last_of('.');
-
-	if (pos == AnsiString::npos) return "";
-	else return fileName.substr(pos);
+	//size_t pos = fileName.find_last_of('.');
+	return Common::lastPathComponent(path, '.');
+	//if (pos == AnsiString::npos) return "";
+	//else return fileName.substr(pos);
 }
 
 
diff --git a/engines/wintermute/StringUtil.cpp b/engines/wintermute/StringUtil.cpp
index f3b4e0c0db..a8af7f25ec 100644
--- a/engines/wintermute/StringUtil.cpp
+++ b/engines/wintermute/StringUtil.cpp
@@ -42,9 +42,9 @@ void StringUtil::ToLowerCase(AnsiString &str) {
 }
 
 //////////////////////////////////////////////////////////////////////////
-void StringUtil::ToLowerCase(WideString &str) {
+/*void StringUtil::ToLowerCase(WideString &str) {
 	std::transform(str.begin(), str.end(), str.begin(), ::towlower);
-}
+}*/
 
 //////////////////////////////////////////////////////////////////////////
 void StringUtil::ToUpperCase(AnsiString &str) {
@@ -52,9 +52,9 @@ void StringUtil::ToUpperCase(AnsiString &str) {
 }
 
 //////////////////////////////////////////////////////////////////////////
-void StringUtil::ToUpperCase(WideString &str) {
+/*void StringUtil::ToUpperCase(WideString &str) {
 	std::transform(str.begin(), str.end(), str.begin(), ::towupper);
-}
+}*/
 
 //////////////////////////////////////////////////////////////////////////
 bool StringUtil::CompareNoCase(const AnsiString &str1, const AnsiString &str2) {
@@ -68,7 +68,7 @@ bool StringUtil::CompareNoCase(const AnsiString &str1, const AnsiString &str2) {
 }
 
 //////////////////////////////////////////////////////////////////////////
-bool StringUtil::CompareNoCase(const WideString &str1, const WideString &str2) {
+/*bool StringUtil::CompareNoCase(const WideString &str1, const WideString &str2) {
 	WideString str1lc = str1;
 	WideString str2lc = str2;
 
@@ -76,11 +76,12 @@ bool StringUtil::CompareNoCase(const WideString &str1, const WideString &str2) {
 	ToLowerCase(str2lc);
 
 	return (str1lc == str2lc);
-}
+}*/
 
 //////////////////////////////////////////////////////////////////////////
 WideString StringUtil::Utf8ToWide(const Utf8String &Utf8Str) {
-	size_t WideSize = Utf8Str.length();
+	error("WideString not supported yet");
+/*	size_t WideSize = Utf8Str.size();
 
 	if (sizeof(wchar_t) == 2) {
 		wchar_t *WideStringNative = new wchar_t[WideSize + 1];
@@ -122,12 +123,14 @@ WideString StringUtil::Utf8ToWide(const Utf8String &Utf8Str) {
 		return ResultString;
 	} else {
 		return L"";
-	}
+	}*/
+	return "";
 }
 
 //////////////////////////////////////////////////////////////////////////
 Utf8String StringUtil::WideToUtf8(const WideString &WideStr) {
-	size_t WideSize = WideStr.length();
+	error("Widestring not supported yet");
+/*	size_t WideSize = WideStr.length();
 
 	if (sizeof(wchar_t) == 2) {
 		size_t Utf8Size = 3 * WideSize + 1;
@@ -169,37 +172,42 @@ Utf8String StringUtil::WideToUtf8(const WideString &WideStr) {
 		return ResultString;
 	} else {
 		return (Utf8String)"";
-	}
+	}*/
+	return "";
 }
 
 //////////////////////////////////////////////////////////////////////////
 WideString StringUtil::AnsiToWide(const AnsiString &str) {
 	// using default os locale!
-	setlocale(LC_CTYPE, "");
+	error("WideString not supported yet");
+/*	setlocale(LC_CTYPE, "");
 	size_t WideSize = mbstowcs(NULL, str.c_str(), 0) + 1;
 	wchar_t *wstr = new wchar_t[WideSize];
 	mbstowcs(wstr, str.c_str(), WideSize);
 	WideString ResultString(wstr);
 	delete [] wstr;
-	return ResultString;
+	return ResultString;*/
+	return "";
 }
 
 //////////////////////////////////////////////////////////////////////////
 AnsiString StringUtil::WideToAnsi(const WideString &wstr) {
 	// using default os locale!
-	setlocale(LC_CTYPE, "");
+	error("WideString not supported yet");
+/*	setlocale(LC_CTYPE, "");
 	size_t WideSize = wcstombs(NULL, wstr.c_str(), 0) + 1;
 	char *str = new char[WideSize];
 	wcstombs(str, wstr.c_str(), WideSize);
 	AnsiString ResultString(str);
 	delete [] str;
-	return ResultString;
+	return ResultString;*/
+	return "";
 }
 
 //////////////////////////////////////////////////////////////////////////
 bool StringUtil::StartsWith(const AnsiString &str, const AnsiString &pattern, bool ignoreCase) {
-	size_t strLength = str.length();
-	size_t patternLength = pattern.length();
+/*	size_t strLength = str.size();
+	size_t patternLength = pattern.size();
 
 	if (strLength < patternLength || patternLength == 0)
 		return false;
@@ -207,13 +215,26 @@ bool StringUtil::StartsWith(const AnsiString &str, const AnsiString &pattern, bo
 	AnsiString startPart = str.substr(0, patternLength);
 
 	if (ignoreCase) return CompareNoCase(startPart, pattern);
-	else return (startPart == pattern);
+	else return (startPart == pattern);*/
+	if (!ignoreCase)
+		return str.hasPrefix(pattern);
+	else {
+		size_t strLength = str.size();
+		size_t patternLength = pattern.size();
+		
+		if (strLength < patternLength || patternLength == 0)
+			return false;
+		
+		AnsiString startPart(str.c_str(), patternLength);
+		uint32 likeness = str.compareToIgnoreCase(pattern.c_str());
+		return (likeness == 0);
+	}
 }
 
 //////////////////////////////////////////////////////////////////////////
 bool StringUtil::EndsWith(const AnsiString &str, const AnsiString &pattern, bool ignoreCase) {
-	size_t strLength = str.length();
-	size_t patternLength = pattern.length();
+/*	size_t strLength = str.size(); // TODO: Remove
+	size_t patternLength = pattern.size();
 
 	if (strLength < patternLength || patternLength == 0)
 		return false;
@@ -221,7 +242,20 @@ bool StringUtil::EndsWith(const AnsiString &str, const AnsiString &pattern, bool
 	AnsiString endPart = str.substr(strLength - patternLength, patternLength);
 
 	if (ignoreCase) return CompareNoCase(endPart, pattern);
-	else return (endPart == pattern);
+	else return (endPart == pattern);*/
+	if (!ignoreCase) {
+		return str.hasSuffix(pattern);
+	} else {
+		size_t strLength = str.size();
+		size_t patternLength = pattern.size();
+		
+		if (strLength < patternLength || patternLength == 0)
+			return false;
+		
+		Common::String endPart(str.c_str(), strLength - patternLength);
+		uint32 likeness = str.compareToIgnoreCase(pattern.c_str());
+		return (likeness == 0);
+	}
 }
 
 //////////////////////////////////////////////////////////////////////////
@@ -237,12 +271,20 @@ AnsiString StringUtil::Replace(const AnsiString &str, const AnsiString &from, co
 	AnsiString result = str;
 	size_t pos = 0;
 
-	while (true) {
-		pos = result.find(from, pos);
+	while (result.contains(from)) {
+		const char* startPtr = strstr(result.c_str(), from.c_str());
+		uint32 index = startPtr - result.c_str();
+		
+		Common::String tail(result.c_str() + index + to.size());
+		result = Common::String(result.c_str(), index);
+		result += to;
+		result += tail;
+		
+/*		pos = result.find(from, pos);
 		if (pos == result.npos) break;
 
 		result.replace(pos, from.size(), to);
-		pos += to.size();
+		pos += to.size();*/
 	}
 
 	return result;
@@ -252,55 +294,83 @@ AnsiString StringUtil::Replace(const AnsiString &str, const AnsiString &from, co
 AnsiString StringUtil::Trim(const AnsiString &str, bool fromLeft, bool fromRight, const AnsiString &chars) {
 	AnsiString trimmedStr = str;
 
-	if (fromRight)
-		trimmedStr.erase(trimmedStr.find_last_not_of(chars) + 1);
-	if (fromLeft)
-		trimmedStr.erase(0, trimmedStr.find_first_not_of(chars));
-
+	if (fromRight) {
+		//trimmedStr.erase(trimmedStr.find_last_not_of(chars) + 1); // TODO
+		warning("fromRight-trim not implemented yet, %s", chars.c_str());
+	}
+	if (fromLeft) {
+		uint32 lastOf = LastIndexOf(str, chars, 0);
+		trimmedStr = Common::String(trimmedStr.c_str() + lastOf);
+		//trimmedStr.erase(0, trimmedStr.find_first_not_of(chars));
+	}
 	return trimmedStr;
 }
 
 //////////////////////////////////////////////////////////////////////////
 int StringUtil::IndexOf(const WideString &str, const WideString &toFind, size_t startFrom) {
-	size_t pos = str.find(toFind, startFrom);
+	/*size_t pos = str.find(toFind, startFrom);
 	if (pos == str.npos) return -1;
-	else return pos;
+	else return pos;*/
+	const char* index = strstr(str.c_str(), toFind.c_str());
+	if (index == NULL)
+		return -1;
+	else
+		return str.c_str() - index;
 }
 
 //////////////////////////////////////////////////////////////////////////
 int StringUtil::LastIndexOf(const WideString &str, const WideString &toFind, size_t startFrom) {
-	size_t pos = str.rfind(toFind, startFrom);
+	/*size_t pos = str.rfind(toFind, startFrom);
 	if (pos == str.npos) return -1;
-	else return pos;
+	else return pos;*/
+	uint32 lastIndex = -1;
+	bool found = false;
+	for (int i = startFrom; i < str.size(); i++) {
+		found = false;
+		for (int j = 0; j < toFind.size(); j++) {
+			if (str[i+j] != toFind[j]) {
+				found = false;
+				break;
+			} else {
+				found = true;
+			}
+		}
+		if (found)
+			lastIndex = i;
+	}
+	return lastIndex;
 }
 
 //////////////////////////////////////////////////////////////////////////
 AnsiString StringUtil::ToString(size_t val) {
-	std::ostringstream str;
+/*	std::ostringstream str;
 	str << val;
-	return str.str();
+	return str.str();*/
+	return Common::String::format("%u", val);
 }
 
 //////////////////////////////////////////////////////////////////////////
 AnsiString StringUtil::ToString(int val) {
-	std::ostringstream str;
+/*	std::ostringstream str;
 	str << val;
-	return str.str();
-
+	return str.str();*/
+	return Common::String::format("%d", val);
 }
 
 //////////////////////////////////////////////////////////////////////////
 AnsiString StringUtil::ToString(float val) {
-	std::ostringstream str;
+/*	std::ostringstream str;
 	str << val;
-	return str.str();
+	return str.str();*/
+	return Common::String::format("%f", val);
 }
 
 //////////////////////////////////////////////////////////////////////////
 AnsiString StringUtil::ToString(double val) {
-	std::ostringstream str;
+/*	std::ostringstream str;
 	str << val;
-	return str.str();
+	return str.str();*/
+	return Common::String::format("%f", val);
 }
 
 
@@ -315,7 +385,7 @@ void StringUtil::Split(const AnsiString &list, const AnsiString &delimiters, Ans
 	//separator_t del(delimiters.c_str(), "", keepEmptyItems ? boost::keep_empty_tokens : boost::drop_empty_tokens);
 	//tokenizer_t tokens(list, del);
 	while (!tokenizer.empty()) {
-		std::string copy(tokenizer.nextToken().c_str());
+		Common::String copy(tokenizer.nextToken().c_str());
 		result.push_back(copy);
 	}
 }
diff --git a/engines/wintermute/StringUtil.h b/engines/wintermute/StringUtil.h
index 80c95ced03..f62f82db9a 100644
--- a/engines/wintermute/StringUtil.h
+++ b/engines/wintermute/StringUtil.h
@@ -36,11 +36,11 @@ namespace WinterMute {
 class StringUtil {
 public:
 	static void ToLowerCase(AnsiString &str);
-	static void ToLowerCase(WideString &str);
+	//static void ToLowerCase(WideString &str);
 	static void ToUpperCase(AnsiString &str);
-	static void ToUpperCase(WideString &str);
+	//static void ToUpperCase(WideString &str);
 	static bool CompareNoCase(const AnsiString &str1, const AnsiString &str2);
-	static bool CompareNoCase(const WideString &str1, const WideString &str2);
+	//static bool CompareNoCase(const WideString &str1, const WideString &str2);
 	static WideString Utf8ToWide(const Utf8String &Utf8Str);
 	static Utf8String WideToUtf8(const WideString &WideStr);
 	static WideString AnsiToWide(const AnsiString &str);
diff --git a/engines/wintermute/SysClass.cpp b/engines/wintermute/SysClass.cpp
index a673943b57..ebde28cdb1 100644
--- a/engines/wintermute/SysClass.cpp
+++ b/engines/wintermute/SysClass.cpp
@@ -35,6 +35,8 @@
 
 namespace WinterMute {
 
+// TODO: Note that the set was removed, this might have bizarre side-effects.
+
 //////////////////////////////////////////////////////////////////////////
 CSysClass::CSysClass(const AnsiString &name, PERSISTBUILD build, PERSISTLOAD load, bool persistent_class) {
 	m_Name = name;
@@ -58,11 +60,11 @@ CSysClass::~CSysClass() {
 
 //////////////////////////////////////////////////////////////////////////
 bool CSysClass::RemoveAllInstances() {
-	Instances::iterator it;
-	for (it = m_Instances.begin(); it != m_Instances.end(); ++it) {
-		delete(*it);
+	InstanceMap::iterator it;
+	for (it = m_InstanceMap.begin(); it != m_InstanceMap.end(); ++it) {
+		delete(it->_value);
 	}
-	m_Instances.clear();
+	//m_Instances.clear();
 	m_InstanceMap.clear();
 
 	return true;
@@ -72,7 +74,7 @@ bool CSysClass::RemoveAllInstances() {
 CSysInstance *CSysClass::AddInstance(void *instance, int id, int savedId) {
 	CSysInstance *inst = new CSysInstance(instance, id, this);
 	inst->SetSavedID(savedId);
-	m_Instances.insert(inst);
+	//m_Instances.insert(inst);
 
 	m_InstanceMap[instance] = inst;
 
@@ -86,13 +88,14 @@ CSysInstance *CSysClass::AddInstance(void *instance, int id, int savedId) {
 bool CSysClass::RemoveInstance(void *instance) {
 	InstanceMap::iterator mapIt = m_InstanceMap.find(instance);
 	if (mapIt == m_InstanceMap.end()) return false;
-
+/*
 	Instances::iterator it = m_Instances.find((*mapIt).second);
 	if (it != m_Instances.end()) {
 		delete(*it);
 		m_Instances.erase(it);
-	}
+	}*/
 
+	delete mapIt->_value;
 	m_InstanceMap.erase(mapIt);
 
 	return false;
@@ -102,39 +105,49 @@ bool CSysClass::RemoveInstance(void *instance) {
 int CSysClass::GetInstanceID(void *pointer) {
 	InstanceMap::iterator mapIt = m_InstanceMap.find(pointer);
 	if (mapIt == m_InstanceMap.end()) return -1;
-	else return (*mapIt).second->GetID();
+	else return (*mapIt)._value->GetID();
 }
 
 //////////////////////////////////////////////////////////////////////////
 void *CSysClass::IDToPointer(int savedID) {
 	//slow
-	Instances::iterator it;
+	/*Instances::iterator it;
 	for (it = m_Instances.begin(); it != m_Instances.end(); ++it) {
 		if ((*it)->GetSavedID() == savedID) return (*it)->GetInstance();
+	}*/
+	InstanceMap::iterator it;
+	for (it = m_InstanceMap.begin(); it != m_InstanceMap.end(); ++it) {
+		if ((it->_value)->GetSavedID() == savedID) return (it->_value)->GetInstance();
 	}
 	return NULL;
 }
 
 //////////////////////////////////////////////////////////////////////////
 int CSysClass::GetNumInstances() {
-	return m_Instances.size();
+	//return m_Instances.size();
+	return m_InstanceMap.size(); // TODO: This might break, if we have multiple keys per value.
 }
 
 //////////////////////////////////////////////////////////////////////////
-void CSysClass::Dump(FILE *stream) {
-	fprintf(stream, "%03d %c %-20s instances: %d\n", m_ID, m_Persistent ? 'p' : ' ', m_Name.c_str(), GetNumInstances());
+void CSysClass::Dump(void *stream) {
+	fprintf((FILE*)stream, "%03d %c %-20s instances: %d\n", m_ID, m_Persistent ? 'p' : ' ', m_Name.c_str(), GetNumInstances());
 }
 
 //////////////////////////////////////////////////////////////////////////
 void CSysClass::SaveTable(CBGame *Game, CBPersistMgr *PersistMgr) {
 	PersistMgr->PutString(m_Name.c_str());
 	PersistMgr->PutDWORD(m_ID);
-	PersistMgr->PutDWORD(m_Instances.size());
+	PersistMgr->PutDWORD(m_InstanceMap.size());
 
+	InstanceMap::iterator it;
+	for (it = m_InstanceMap.begin(); it != m_InstanceMap.end(); ++it) {
+		PersistMgr->PutDWORD((it->_value)->GetID());
+	}
+	/*
 	Instances::iterator it;
 	for (it = m_Instances.begin(); it != m_Instances.end(); ++it) {
 		PersistMgr->PutDWORD((*it)->GetID());
-	}
+	}*/
 }
 
 //////////////////////////////////////////////////////////////////////////
@@ -151,10 +164,11 @@ void CSysClass::LoadTable(CBGame *Game, CBPersistMgr *PersistMgr) {
 				continue;
 			}
 
-			Instances::iterator it = m_Instances.begin();
-			if (it != m_Instances.end()) {
-				(*it)->SetSavedID(instId);
-				CSysClassRegistry::GetInstance()->AddInstanceToTable((*it), (*it)->GetInstance());
+			InstanceMap::iterator it = m_InstanceMap.begin();
+/*			Instances::iterator it = m_Instances.begin();*/
+			if (it != m_InstanceMap.end()) {
+				(it->_value)->SetSavedID(instId);
+				CSysClassRegistry::GetInstance()->AddInstanceToTable((it->_value), (it->_value)->GetInstance());
 			} else Game->LOG(0, "Warning: instance %d of persistent class %s not found", i, m_Name.c_str());
 		}
 		// normal instances, create empty objects
@@ -168,13 +182,13 @@ void CSysClass::LoadTable(CBGame *Game, CBPersistMgr *PersistMgr) {
 
 //////////////////////////////////////////////////////////////////////////
 void CSysClass::SaveInstances(CBGame *Game, CBPersistMgr *PersistMgr) {
-	Instances::iterator it;
-	for (it = m_Instances.begin(); it != m_Instances.end(); ++it) {
+	InstanceMap::iterator it;
+	for (it = m_InstanceMap.begin(); it != m_InstanceMap.end(); ++it) {
 		// write instace header
 		PersistMgr->PutDWORD(m_ID);
-		PersistMgr->PutDWORD((*it)->GetID());
+		PersistMgr->PutDWORD((it->_value)->GetID());
 
-		m_Load((*it)->GetInstance(), PersistMgr);
+		m_Load((it->_value)->GetInstance(), PersistMgr);
 	}
 }
 
@@ -186,17 +200,17 @@ void CSysClass::LoadInstance(void *instance, CBPersistMgr *PersistMgr) {
 
 //////////////////////////////////////////////////////////////////////////
 void CSysClass::ResetSavedIDs() {
-	Instances::iterator it;
-	for (it = m_Instances.begin(); it != m_Instances.end(); ++it) {
-		(*it)->SetSavedID(-1);
+	InstanceMap::iterator it;
+	for (it = m_InstanceMap.begin(); it != m_InstanceMap.end(); ++it) {
+		(it->_value)->SetSavedID(-1);
 	}
 }
 
 //////////////////////////////////////////////////////////////////////////
 void CSysClass::InstanceCallback(SYS_INSTANCE_CALLBACK lpCallback, void *lpData) {
-	Instances::iterator it;
-	for (it = m_Instances.begin(); it != m_Instances.end(); ++it) {
-		lpCallback((*it)->GetInstance(), lpData);
+	InstanceMap::iterator it;
+	for (it = m_InstanceMap.begin(); it != m_InstanceMap.end(); ++it) {
+		lpCallback((it->_value)->GetInstance(), lpData);
 	}
 }
 
diff --git a/engines/wintermute/SysClass.h b/engines/wintermute/SysClass.h
index 48d7a2626e..bcd63cc5e4 100644
--- a/engines/wintermute/SysClass.h
+++ b/engines/wintermute/SysClass.h
@@ -30,10 +30,21 @@
 #define WINTERMUTE_SYSCLASS_H
 
 #include "persistent.h"
-#include <set>
-#include <map>
 #include "dctypes.h"
 
+//#include <set>
+//#include <map>
+#include "common/hashmap.h"
+#include "common/func.h"
+namespace Common {
+template<typename T> struct Hash;
+
+template<> struct Hash<void*> : public UnaryFunction<void*, uint> {
+	uint operator()(void* val) const { return (uint)((size_t)val); }
+};
+
+}
+
 namespace WinterMute {
 class CSysInstance;
 class CBGame;
@@ -80,7 +91,7 @@ public:
 
 	void ResetSavedIDs();
 
-	void Dump(FILE *stream);
+	void Dump(void *stream);
 
 private:
 	int m_NumInst;
@@ -92,10 +103,10 @@ private:
 	PERSISTBUILD m_Build;
 	PERSISTLOAD m_Load;
 
-	typedef std::set<CSysInstance *> Instances;
-	Instances m_Instances;
+	//typedef std::set<CSysInstance *> Instances;
+	//Instances m_Instances;
 
-	typedef std::map<void *, CSysInstance *> InstanceMap;
+	typedef Common::HashMap<void *, CSysInstance *> InstanceMap;
 	InstanceMap m_InstanceMap;
 };
 
diff --git a/engines/wintermute/SysClassRegistry.cpp b/engines/wintermute/SysClassRegistry.cpp
index 72740a79cf..1170921768 100644
--- a/engines/wintermute/SysClassRegistry.cpp
+++ b/engines/wintermute/SysClassRegistry.cpp
@@ -53,7 +53,8 @@ CSysClassRegistry *CSysClassRegistry::GetInstance() {
 //////////////////////////////////////////////////////////////////////////
 bool CSysClassRegistry::RegisterClass(CSysClass *classObj) {
 	classObj->SetID(m_Count++);
-	m_Classes.insert(classObj);
+	//m_Classes.insert(classObj);
+	m_Classes[classObj] = classObj;
 
 	m_NameMap[classObj->GetName()] = classObj;
 	m_IdMap[classObj->GetID()] = classObj;
@@ -93,7 +94,7 @@ bool CSysClassRegistry::RegisterInstance(const char *className, void *instance)
 	NameMap::iterator mapIt = m_NameMap.find(className);
 	if (mapIt == m_NameMap.end()) return false;
 
-	CSysInstance *inst = (*mapIt).second->AddInstance(instance, m_Count++);
+	CSysInstance *inst = (*mapIt)._value->AddInstance(instance, m_Count++);
 	return (inst != NULL);
 }
 
@@ -114,7 +115,7 @@ int CSysClassRegistry::GetNextID() {
 bool CSysClassRegistry::UnregisterInstance(const char *className, void *instance) {
 	NameMap::iterator mapIt = m_NameMap.find(className);
 	if (mapIt == m_NameMap.end()) return false;
-	(*mapIt).second->RemoveInstance(instance);
+	(*mapIt)._value->RemoveInstance(instance);
 
 	InstanceMap::iterator instIt = m_InstanceMap.find(instance);
 	if (instIt != m_InstanceMap.end()) {
@@ -132,7 +133,7 @@ bool CSysClassRegistry::GetPointerID(void *pointer, int *classID, int *instanceI
 	if (it == m_InstanceMap.end()) return false;
 
 
-	CSysInstance *inst = (*it).second;
+	CSysInstance *inst = (*it)._value;
 	*instanceID = inst->GetID();
 	*classID = inst->GetClass()->GetID();
 
@@ -143,7 +144,7 @@ bool CSysClassRegistry::GetPointerID(void *pointer, int *classID, int *instanceI
 void *CSysClassRegistry::IDToPointer(int classID, int instanceID) {
 	SavedInstanceMap::iterator it = m_SavedInstanceMap.find(instanceID);
 	if (it == m_SavedInstanceMap.end()) return NULL;
-	else return (*it).second->GetInstance();
+	else return (*it)._value->GetInstance();
 }
 
 
@@ -163,7 +164,7 @@ HRESULT CSysClassRegistry::SaveTable(CBGame *Game, CBPersistMgr *PersistMgr, boo
 			Game->m_Renderer->Flip();
 		}
 
-		(*it)->SaveTable(Game, PersistMgr);
+		(it->_value)->SaveTable(Game, PersistMgr);
 	}
 
 	return S_OK;
@@ -176,12 +177,12 @@ HRESULT CSysClassRegistry::LoadTable(CBGame *Game, CBPersistMgr *PersistMgr) {
 
 	// reset SavedID of current instances
 	for (it = m_Classes.begin(); it != m_Classes.end(); ++it) {
-		(*it)->ResetSavedIDs();
+		(it->_value)->ResetSavedIDs();
 	}
 
 	for (it = m_Classes.begin(); it != m_Classes.end(); ++it) {
-		if ((*it)->IsPersistent()) continue;
-		(*it)->RemoveAllInstances();
+		if ((it->_value)->IsPersistent()) continue;
+		(it->_value)->RemoveAllInstances();
 	}
 
 	m_InstanceMap.clear();
@@ -196,7 +197,7 @@ HRESULT CSysClassRegistry::LoadTable(CBGame *Game, CBPersistMgr *PersistMgr) {
 
 		char *className = PersistMgr->GetString();
 		NameMap::iterator mapIt = m_NameMap.find(className);
-		if (mapIt != m_NameMap.end())(*mapIt).second->LoadTable(Game, PersistMgr);
+		if (mapIt != m_NameMap.end())(*mapIt)._value->LoadTable(Game, PersistMgr);
 	}
 
 	return S_OK;
@@ -211,7 +212,7 @@ HRESULT CSysClassRegistry::SaveInstances(CBGame *Game, CBPersistMgr *PersistMgr,
 	// count total instances
 	int numInstances = 0;
 	for (it = m_Classes.begin(); it != m_Classes.end(); ++it) {
-		numInstances += (*it)->GetNumInstances();
+		numInstances += (it->_value)->GetNumInstances();
 	}
 
 	PersistMgr->PutDWORD(numInstances);
@@ -229,7 +230,7 @@ HRESULT CSysClassRegistry::SaveInstances(CBGame *Game, CBPersistMgr *PersistMgr,
 		}
 		Game->MiniUpdate();
 
-		(*it)->SaveInstances(Game, PersistMgr);
+		(it->_value)->SaveInstances(Game, PersistMgr);
 	}
 
 	return S_OK;
@@ -255,8 +256,8 @@ HRESULT CSysClassRegistry::LoadInstances(CBGame *Game, CBPersistMgr *PersistMgr)
 
 		Classes::iterator it;
 		for (it = m_Classes.begin(); it != m_Classes.end(); ++it) {
-			if ((*it)->GetSavedID() == classID) {
-				(*it)->LoadInstance(instance, PersistMgr);
+			if ((it->_value)->GetSavedID() == classID) {
+				(it->_value)->LoadInstance(instance, PersistMgr);
 			}
 		}
 	}
@@ -272,16 +273,16 @@ HRESULT CSysClassRegistry::EnumInstances(SYS_INSTANCE_CALLBACK lpCallback, const
 	NameMap::iterator mapIt = m_NameMap.find(className);
 	if (mapIt == m_NameMap.end()) return E_FAIL;
 
-	(*mapIt).second->InstanceCallback(lpCallback, lpData);
+	(*mapIt)._value->InstanceCallback(lpCallback, lpData);
 	return S_OK;
 }
 
 
 //////////////////////////////////////////////////////////////////////////
-void CSysClassRegistry::DumpClasses(FILE *stream) {
+void CSysClassRegistry::DumpClasses(void *stream) {
 	Classes::iterator it;
 	for (it = m_Classes.begin(); it != m_Classes.end(); ++it)
-		(*it)->Dump(stream);
+		(it->_value)->Dump(stream);
 }
 
 } // end of namespace WinterMute
diff --git a/engines/wintermute/SysClassRegistry.h b/engines/wintermute/SysClassRegistry.h
index 1a73f28010..6d3367fc30 100644
--- a/engines/wintermute/SysClassRegistry.h
+++ b/engines/wintermute/SysClassRegistry.h
@@ -32,14 +32,30 @@
 #include "wintypes.h"
 #include "dctypes.h"
 #include "persistent.h"
-#include <set>
-#include <map>
+//#include <set>
+//#include <map>
+#include "common/hashmap.h"
+#include "common/hash-str.h"
+#include "common/func.h"
+
+#define FORBIDDEN_SYMBOL_EXCEPTION_FILE
+
+namespace WinterMute {
+class CSysClass;
+}
+
+namespace Common {
+template<typename T> struct Hash;	
+template<> struct Hash<WinterMute::CSysClass*> : public UnaryFunction<WinterMute::CSysClass*, uint> {
+	uint operator()(WinterMute::CSysClass* val) const { return (uint)((size_t)val); }
+};
+
+}
 
 namespace WinterMute {
 
 class CBGame;
 class CBPersistMgr;
-class CSysClass;
 class CSysInstance;
 
 class CSysClassRegistry {
@@ -57,7 +73,7 @@ public:
 	bool UnregisterClass(CSysClass *classObj);
 	bool RegisterInstance(const char *className, void *instance);
 	bool UnregisterInstance(const char *className, void *instance);
-	void DumpClasses(FILE *stream);
+	void DumpClasses(void *stream);
 	int GetNextID();
 	void AddInstanceToTable(CSysInstance *instance, void *pointer);
 
@@ -67,19 +83,19 @@ public:
 	bool m_Disabled;
 	int m_Count;
 
-	typedef std::set<CSysClass *> Classes;
+	typedef Common::HashMap<CSysClass *, CSysClass *> Classes;
 	Classes m_Classes;
 
-	typedef std::map<AnsiString, CSysClass *> NameMap;
+	typedef Common::HashMap<AnsiString, CSysClass *> NameMap;
 	NameMap m_NameMap;
 
-	typedef std::map<int, CSysClass *> IdMap;
+	typedef Common::HashMap<int, CSysClass *> IdMap;
 	IdMap m_IdMap;
 
-	typedef std::map<void *, CSysInstance *> InstanceMap;
+	typedef Common::HashMap<void *, CSysInstance *> InstanceMap;
 	InstanceMap m_InstanceMap;
 
-	typedef std::map<int, CSysInstance *> SavedInstanceMap;
+	typedef Common::HashMap<int, CSysInstance *> SavedInstanceMap;
 	SavedInstanceMap m_SavedInstanceMap;
 
 };
diff --git a/engines/wintermute/SysInstance.cpp b/engines/wintermute/SysInstance.cpp
index b937136706..857a857a45 100644
--- a/engines/wintermute/SysInstance.cpp
+++ b/engines/wintermute/SysInstance.cpp
@@ -27,6 +27,7 @@
  */
 
 #include "SysInstance.h"
+#include "SysClassRegistry.h"
 #include "SysClass.h"
 
 namespace WinterMute {
diff --git a/engines/wintermute/UIEdit.cpp b/engines/wintermute/UIEdit.cpp
index 58ac8ff13b..6d1018ec0a 100644
--- a/engines/wintermute/UIEdit.cpp
+++ b/engines/wintermute/UIEdit.cpp
@@ -45,6 +45,7 @@
 #include "engines/wintermute/scriptables/ScStack.h"
 #include "engines/wintermute/scriptables/ScScript.h"
 #include "engines/wintermute/utils.h"
+#include "common/util.h"
 
 namespace WinterMute {
 
@@ -462,7 +463,7 @@ HRESULT CUIEdit::ScSetProperty(char *Name, CScValue *Value) {
 	if (strcmp(Name, "SelStart") == 0) {
 		m_SelStart = Value->GetInt();
 		m_SelStart = MAX(m_SelStart, 0);
-		m_SelStart = MIN(m_SelStart, strlen(m_Text));
+		m_SelStart = MIN((size_t)m_SelStart, strlen(m_Text));
 		return S_OK;
 	}
 
@@ -472,7 +473,7 @@ HRESULT CUIEdit::ScSetProperty(char *Name, CScValue *Value) {
 	else if (strcmp(Name, "SelEnd") == 0) {
 		m_SelEnd = Value->GetInt();
 		m_SelEnd = MAX(m_SelEnd, 0);
-		m_SelEnd = MIN(m_SelEnd, strlen(m_Text));
+		m_SelEnd = MIN((size_t)m_SelEnd, strlen(m_Text));
 		return S_OK;
 	}
 
@@ -567,8 +568,8 @@ HRESULT CUIEdit::Display(int OffsetX, int OffsetY) {
 	m_SelStart = MAX(m_SelStart, 0);
 	m_SelEnd   = MAX(m_SelEnd, 0);
 
-	m_SelStart = MIN(m_SelStart, strlen(m_Text));
-	m_SelEnd   = MIN(m_SelEnd,   strlen(m_Text));
+	m_SelStart = MIN((size_t)m_SelStart, strlen(m_Text));
+	m_SelEnd   = MIN((size_t)m_SelEnd,   strlen(m_Text));
 
 	//int CursorWidth = font->GetCharWidth(m_CursorChar[0]);
 	int CursorWidth = font->GetTextWidth((byte  *)m_CursorChar);
@@ -788,8 +789,8 @@ bool CUIEdit::HandleKeypress(SDL_Event *event) {
 int CUIEdit::DeleteChars(int Start, int End) {
 	if (Start > End) CBUtils::Swap(&Start, &End);
 
-	Start = MAX(Start, 0);
-	End = MIN(End, strlen(m_Text));
+	Start = MAX(Start, (int)0);
+	End = MIN((size_t)End, strlen(m_Text));
 
 	char *str = new char[strlen(m_Text) - (End - Start) + 1];
 	if (str) {
@@ -811,8 +812,8 @@ int CUIEdit::InsertChars(int Pos, byte *Chars, int Num) {
 		Num -= (strlen(m_Text) + Num - m_MaxLength);
 	}
 
-	Pos = MAX(Pos, 0);
-	Pos = MIN(Pos, strlen(m_Text));
+	Pos = MAX(Pos, (int)0);
+	Pos = MIN((size_t)Pos, strlen(m_Text));
 
 	char *str = new char[strlen(m_Text) + Num + 1];
 	if (str) {
diff --git a/engines/wintermute/dctypes.h b/engines/wintermute/dctypes.h
index 0ee5a6bf54..bd5ec3b6e5 100644
--- a/engines/wintermute/dctypes.h
+++ b/engines/wintermute/dctypes.h
@@ -29,22 +29,29 @@
 #ifndef WINTERMUTE_DCTYPES_H
 #define WINTERMUTE_DCTYPES_H
 
-#include <string>
-#include <list>
-#include <vector>
+#define FORBIDDEN_SYMBOL_ALLOW_ALL
 
-namespace WinterMute {
+#include "common/str.h"
+#include "common/list.h"
+#include "common/array.h"
+//#include <string>
+//#include <list>
+//#include <vector>
 
-typedef std::string AnsiString;
-typedef std::string Utf8String;
-typedef std::wstring WideString;
+namespace WinterMute {
 
+//typedef std::string AnsiString;
+//typedef std::string Utf8String;
+//typedef std::wstring WideString;
+typedef Common::String AnsiString;
+typedef Common::String Utf8String;
+typedef Common::String WideString; // NB: Not actually true I presume.
 
-typedef std::list<WideString> WideStringList;
-typedef std::list<AnsiString> AnsiStringList;
+typedef Common::List<WideString> WideStringList;
+typedef Common::List<AnsiString> AnsiStringList;
 
-typedef std::vector<WideString> WideStringArray;
-typedef std::vector<AnsiString> AnsiStringArray;
+typedef Common::Array<WideString> WideStringArray;
+typedef Common::Array<AnsiString> AnsiStringArray;
 
 
 enum TGameState {
diff --git a/engines/wintermute/scriptables/ScEngine.h b/engines/wintermute/scriptables/ScEngine.h
index 54e590bdfe..13103f6d3c 100644
--- a/engines/wintermute/scriptables/ScEngine.h
+++ b/engines/wintermute/scriptables/ScEngine.h
@@ -168,7 +168,7 @@ private:
 	bool m_IsProfiling;
 	uint32 m_ProfilingStartTime;
 
-	typedef std::map<std::string, uint32> ScriptTimes;
+	typedef Common::HashMap<Common::String, uint32> ScriptTimes;
 	ScriptTimes m_ScriptTimes;
 
 };
diff --git a/engines/wintermute/scriptables/ScValue.cpp b/engines/wintermute/scriptables/ScValue.cpp
index 387bf45b46..186f4ff9d2 100644
--- a/engines/wintermute/scriptables/ScValue.cpp
+++ b/engines/wintermute/scriptables/ScValue.cpp
@@ -170,7 +170,7 @@ CScValue *CScValue::GetProp(char *Name) {
 			Game->m_ScValue->SetInt(strlen(m_ValString));
 		} else {
 			WideString wstr = StringUtil::Utf8ToWide(m_ValString);
-			Game->m_ScValue->SetInt(wstr.length());
+			Game->m_ScValue->SetInt(wstr.size());
 		}
 
 		return Game->m_ScValue;
diff --git a/engines/wintermute/tinystr.cpp b/engines/wintermute/tinystr.cpp
new file mode 100644
index 0000000000..0665768205
--- /dev/null
+++ b/engines/wintermute/tinystr.cpp
@@ -0,0 +1,111 @@
+/*
+www.sourceforge.net/projects/tinyxml
+
+This software is provided 'as-is', without any express or implied
+warranty. In no event will the authors be held liable for any
+damages arising from the use of this software.
+
+Permission is granted to anyone to use this software for any
+purpose, including commercial applications, and to alter it and
+redistribute it freely, subject to the following restrictions:
+
+1. The origin of this software must not be misrepresented; you must
+not claim that you wrote the original software. If you use this
+software in a product, an acknowledgment in the product documentation
+would be appreciated but is not required.
+
+2. Altered source versions must be plainly marked as such, and
+must not be misrepresented as being the original software.
+
+3. This notice may not be removed or altered from any source
+distribution.
+*/
+
+
+#ifndef TIXML_USE_STL
+
+#include "tinystr.h"
+
+// Error value for find primitive
+const TiXmlString::size_type TiXmlString::npos = static_cast< TiXmlString::size_type >(-1);
+
+
+// Null rep.
+TiXmlString::Rep TiXmlString::nullrep_ = { 0, 0, { '\0' } };
+
+
+void TiXmlString::reserve (size_type cap)
+{
+	if (cap > capacity())
+	{
+		TiXmlString tmp;
+		tmp.init(length(), cap);
+		memcpy(tmp.start(), data(), length());
+		swap(tmp);
+	}
+}
+
+
+TiXmlString& TiXmlString::assign(const char* str, size_type len)
+{
+	size_type cap = capacity();
+	if (len > cap || cap > 3*(len + 8))
+	{
+		TiXmlString tmp;
+		tmp.init(len);
+		memcpy(tmp.start(), str, len);
+		swap(tmp);
+	}
+	else
+	{
+		memmove(start(), str, len);
+		set_size(len);
+	}
+	return *this;
+}
+
+
+TiXmlString& TiXmlString::append(const char* str, size_type len)
+{
+	size_type newsize = length() + len;
+	if (newsize > capacity())
+	{
+		reserve (newsize + capacity());
+	}
+	memmove(finish(), str, len);
+	set_size(newsize);
+	return *this;
+}
+
+
+TiXmlString operator + (const TiXmlString & a, const TiXmlString & b)
+{
+	TiXmlString tmp;
+	tmp.reserve(a.length() + b.length());
+	tmp += a;
+	tmp += b;
+	return tmp;
+}
+
+TiXmlString operator + (const TiXmlString & a, const char* b)
+{
+	TiXmlString tmp;
+	TiXmlString::size_type b_len = static_cast<TiXmlString::size_type>( strlen(b) );
+	tmp.reserve(a.length() + b_len);
+	tmp += a;
+	tmp.append(b, b_len);
+	return tmp;
+}
+
+TiXmlString operator + (const char* a, const TiXmlString & b)
+{
+	TiXmlString tmp;
+	TiXmlString::size_type a_len = static_cast<TiXmlString::size_type>( strlen(a) );
+	tmp.reserve(a_len + b.length());
+	tmp.append(a, a_len);
+	tmp += b;
+	return tmp;
+}
+
+
+#endif	// TIXML_USE_STL
diff --git a/engines/wintermute/tinystr.h b/engines/wintermute/tinystr.h
new file mode 100644
index 0000000000..89cca33415
--- /dev/null
+++ b/engines/wintermute/tinystr.h
@@ -0,0 +1,305 @@
+/*
+www.sourceforge.net/projects/tinyxml
+
+This software is provided 'as-is', without any express or implied
+warranty. In no event will the authors be held liable for any
+damages arising from the use of this software.
+
+Permission is granted to anyone to use this software for any
+purpose, including commercial applications, and to alter it and
+redistribute it freely, subject to the following restrictions:
+
+1. The origin of this software must not be misrepresented; you must
+not claim that you wrote the original software. If you use this
+software in a product, an acknowledgment in the product documentation
+would be appreciated but is not required.
+
+2. Altered source versions must be plainly marked as such, and
+must not be misrepresented as being the original software.
+
+3. This notice may not be removed or altered from any source
+distribution.
+*/
+
+
+#ifndef TIXML_USE_STL
+
+#ifndef TIXML_STRING_INCLUDED
+#define TIXML_STRING_INCLUDED
+
+#include <assert.h>
+#include <string.h>
+
+/*	The support for explicit isn't that universal, and it isn't really
+	required - it is used to check that the TiXmlString class isn't incorrectly
+	used. Be nice to old compilers and macro it here:
+*/
+#if defined(_MSC_VER) && (_MSC_VER >= 1200 )
+	// Microsoft visual studio, version 6 and higher.
+	#define TIXML_EXPLICIT explicit
+#elif defined(__GNUC__) && (__GNUC__ >= 3 )
+	// GCC version 3 and higher.s
+	#define TIXML_EXPLICIT explicit
+#else
+	#define TIXML_EXPLICIT
+#endif
+
+
+/*
+   TiXmlString is an emulation of a subset of the std::string template.
+   Its purpose is to allow compiling TinyXML on compilers with no or poor STL support.
+   Only the member functions relevant to the TinyXML project have been implemented.
+   The buffer allocation is made by a simplistic power of 2 like mechanism : if we increase
+   a string and there's no more room, we allocate a buffer twice as big as we need.
+*/
+class TiXmlString
+{
+  public :
+	// The size type used
+  	typedef size_t size_type;
+
+	// Error value for find primitive
+	static const size_type npos; // = -1;
+
+
+	// TiXmlString empty constructor
+	TiXmlString () : rep_(&nullrep_)
+	{
+	}
+
+	// TiXmlString copy constructor
+	TiXmlString ( const TiXmlString & copy) : rep_(0)
+	{
+		init(copy.length());
+		memcpy(start(), copy.data(), length());
+	}
+
+	// TiXmlString constructor, based on a string
+	TIXML_EXPLICIT TiXmlString ( const char * copy) : rep_(0)
+	{
+		init( static_cast<size_type>( strlen(copy) ));
+		memcpy(start(), copy, length());
+	}
+
+	// TiXmlString constructor, based on a string
+	TIXML_EXPLICIT TiXmlString ( const char * str, size_type len) : rep_(0)
+	{
+		init(len);
+		memcpy(start(), str, len);
+	}
+
+	// TiXmlString destructor
+	~TiXmlString ()
+	{
+		quit();
+	}
+
+	TiXmlString& operator = (const char * copy)
+	{
+		return assign( copy, (size_type)strlen(copy));
+	}
+
+	TiXmlString& operator = (const TiXmlString & copy)
+	{
+		return assign(copy.start(), copy.length());
+	}
+
+
+	// += operator. Maps to append
+	TiXmlString& operator += (const char * suffix)
+	{
+		return append(suffix, static_cast<size_type>( strlen(suffix) ));
+	}
+
+	// += operator. Maps to append
+	TiXmlString& operator += (char single)
+	{
+		return append(&single, 1);
+	}
+
+	// += operator. Maps to append
+	TiXmlString& operator += (const TiXmlString & suffix)
+	{
+		return append(suffix.data(), suffix.length());
+	}
+
+
+	// Convert a TiXmlString into a null-terminated char *
+	const char * c_str () const { return rep_->str; }
+
+	// Convert a TiXmlString into a char * (need not be null terminated).
+	const char * data () const { return rep_->str; }
+
+	// Return the length of a TiXmlString
+	size_type length () const { return rep_->size; }
+
+	// Alias for length()
+	size_type size () const { return rep_->size; }
+
+	// Checks if a TiXmlString is empty
+	bool empty () const { return rep_->size == 0; }
+
+	// Return capacity of string
+	size_type capacity () const { return rep_->capacity; }
+
+
+	// single char extraction
+	const char& at (size_type index) const
+	{
+		assert( index < length() );
+		return rep_->str[ index ];
+	}
+
+	// [] operator
+	char& operator [] (size_type index) const
+	{
+		assert( index < length() );
+		return rep_->str[ index ];
+	}
+
+	// find a char in a string. Return TiXmlString::npos if not found
+	size_type find (char lookup) const
+	{
+		return find(lookup, 0);
+	}
+
+	// find a char in a string from an offset. Return TiXmlString::npos if not found
+	size_type find (char tofind, size_type offset) const
+	{
+		if (offset >= length()) return npos;
+
+		for (const char* p = c_str() + offset; *p != '\0'; ++p)
+		{
+		   if (*p == tofind) return static_cast< size_type >( p - c_str() );
+		}
+		return npos;
+	}
+
+	void clear ()
+	{
+		//Lee:
+		//The original was just too strange, though correct:
+		//	TiXmlString().swap(*this);
+		//Instead use the quit & re-init:
+		quit();
+		init(0,0);
+	}
+
+	/*	Function to reserve a big amount of data when we know we'll need it. Be aware that this
+		function DOES NOT clear the content of the TiXmlString if any exists.
+	*/
+	void reserve (size_type cap);
+
+	TiXmlString& assign (const char* str, size_type len);
+
+	TiXmlString& append (const char* str, size_type len);
+
+	void swap (TiXmlString& other)
+	{
+		Rep* r = rep_;
+		rep_ = other.rep_;
+		other.rep_ = r;
+	}
+
+  private:
+
+	void init(size_type sz) { init(sz, sz); }
+	void set_size(size_type sz) { rep_->str[ rep_->size = sz ] = '\0'; }
+	char* start() const { return rep_->str; }
+	char* finish() const { return rep_->str + rep_->size; }
+
+	struct Rep
+	{
+		size_type size, capacity;
+		char str[1];
+	};
+
+	void init(size_type sz, size_type cap)
+	{
+		if (cap)
+		{
+			// Lee: the original form:
+			//	rep_ = static_cast<Rep*>(operator new(sizeof(Rep) + cap));
+			// doesn't work in some cases of new being overloaded. Switching
+			// to the normal allocation, although use an 'int' for systems
+			// that are overly picky about structure alignment.
+			const size_type bytesNeeded = sizeof(Rep) + cap;
+			const size_type intsNeeded = ( bytesNeeded + sizeof(int) - 1 ) / sizeof( int ); 
+			rep_ = reinterpret_cast<Rep*>( new int[ intsNeeded ] );
+
+			rep_->str[ rep_->size = sz ] = '\0';
+			rep_->capacity = cap;
+		}
+		else
+		{
+			rep_ = &nullrep_;
+		}
+	}
+
+	void quit()
+	{
+		if (rep_ != &nullrep_)
+		{
+			// The rep_ is really an array of ints. (see the allocator, above).
+			// Cast it back before delete, so the compiler won't incorrectly call destructors.
+			delete [] ( reinterpret_cast<int*>( rep_ ) );
+		}
+	}
+
+	Rep * rep_;
+	static Rep nullrep_;
+
+} ;
+
+
+inline bool operator == (const TiXmlString & a, const TiXmlString & b)
+{
+	return    ( a.length() == b.length() )				// optimization on some platforms
+	       && ( strcmp(a.c_str(), b.c_str()) == 0 );	// actual compare
+}
+inline bool operator < (const TiXmlString & a, const TiXmlString & b)
+{
+	return strcmp(a.c_str(), b.c_str()) < 0;
+}
+
+inline bool operator != (const TiXmlString & a, const TiXmlString & b) { return !(a == b); }
+inline bool operator >  (const TiXmlString & a, const TiXmlString & b) { return b < a; }
+inline bool operator <= (const TiXmlString & a, const TiXmlString & b) { return !(b < a); }
+inline bool operator >= (const TiXmlString & a, const TiXmlString & b) { return !(a < b); }
+
+inline bool operator == (const TiXmlString & a, const char* b) { return strcmp(a.c_str(), b) == 0; }
+inline bool operator == (const char* a, const TiXmlString & b) { return b == a; }
+inline bool operator != (const TiXmlString & a, const char* b) { return !(a == b); }
+inline bool operator != (const char* a, const TiXmlString & b) { return !(b == a); }
+
+TiXmlString operator + (const TiXmlString & a, const TiXmlString & b);
+TiXmlString operator + (const TiXmlString & a, const char* b);
+TiXmlString operator + (const char* a, const TiXmlString & b);
+
+
+/*
+   TiXmlOutStream is an emulation of std::ostream. It is based on TiXmlString.
+   Only the operators that we need for TinyXML have been developped.
+*/
+class TiXmlOutStream : public TiXmlString
+{
+public :
+
+	// TiXmlOutStream << operator.
+	TiXmlOutStream & operator << (const TiXmlString & in)
+	{
+		*this += in;
+		return *this;
+	}
+
+	// TiXmlOutStream << operator.
+	TiXmlOutStream & operator << (const char * in)
+	{
+		*this += in;
+		return *this;
+	}
+
+} ;
+
+#endif	// TIXML_STRING_INCLUDED
+#endif	// TIXML_USE_STL
diff --git a/engines/wintermute/tinyxml.h b/engines/wintermute/tinyxml.h
index ee73173932..a78e981deb 100644
--- a/engines/wintermute/tinyxml.h
+++ b/engines/wintermute/tinyxml.h
@@ -22,7 +22,7 @@ must not be misrepresented as being the original software.
 distribution.
 */
 
-#define TIXML_USE_STL
+//#define TIXML_USE_STL
 
 #ifndef TINYXML_INCLUDED
 #define TINYXML_INCLUDED
diff --git a/engines/wintermute/utils.cpp b/engines/wintermute/utils.cpp
index c69a0068b6..6c5ddb5d40 100644
--- a/engines/wintermute/utils.cpp
+++ b/engines/wintermute/utils.cpp
@@ -238,7 +238,7 @@ char *CBUtils::GetPath(char *Filename) {
 	//path = boost::filesystem::system_complete(path).string();
 	warning("CBUtils::GetPath: (%s), not implemented", Filename);
 	return Filename;
-	char *ret = new char[path.length() + 1];
+	char *ret = new char[path.size() + 1];
 	strcpy(ret, path.c_str());
 
 	return ret;
@@ -247,7 +247,7 @@ char *CBUtils::GetPath(char *Filename) {
 //////////////////////////////////////////////////////////////////////////
 char *CBUtils::GetFilename(char *Filename) {
 	AnsiString path = PathUtil::GetFileName(Filename);
-	char *ret = new char[path.length() + 1];
+	char *ret = new char[path.size() + 1];
 	strcpy(ret, path.c_str());
 	return ret;
 }
@@ -259,12 +259,12 @@ void CBUtils::RGBtoHSL(uint32 RGBColor, byte *OutH, byte *OutS, byte *OutL) {
 	float var_B = (D3DCOLGetB(RGBColor) / 255.0f);
 
 	//Min. value of RGB
-	float var_Min = std::min(var_R, var_G);
-	var_Min = std::min(var_Min, var_B);
+	float var_Min = MIN(var_R, var_G);
+	var_Min = MIN(var_Min, var_B);
 
 	//Max. value of RGB
-	float var_Max = std::max(var_R, var_G);
-	var_Max = std::max(var_Max, var_B);
+	float var_Max = MAX(var_R, var_G);
+	var_Max = MAX(var_Max, var_B);
 
 	//Delta RGB value
 	float del_Max = var_Max - var_Min;
diff --git a/engines/wintermute/wintermute.cpp b/engines/wintermute/wintermute.cpp
index c831baf19b..4f791cabd1 100644
--- a/engines/wintermute/wintermute.cpp
+++ b/engines/wintermute/wintermute.cpp
@@ -31,7 +31,7 @@
 #include "common/fs.h"
 
 #include "engines/util.h"
-
+#include "engines/wintermute/BGame.h"
 #include "engines/wintermute/wintermute.h"
 
 namespace WinterMute {
@@ -103,6 +103,8 @@ namespace WinterMute {
 		debugC(3, kWinterMuteDebugExample | kWinterMuteDebugExample2, "Example debug call two");
 		
 		return Common::kNoError;
+		
+		CBGame game;
 	}
 	
 } // End of namespace WinterMute
\ No newline at end of file
diff --git a/engines/wintermute/wintypes.h b/engines/wintermute/wintypes.h
index 50d6dd16be..c722b92c51 100644
--- a/engines/wintermute/wintypes.h
+++ b/engines/wintermute/wintypes.h
@@ -33,8 +33,8 @@
 #include "common/scummsys.h"
 
 //namespace WinterMute {
-#include <cstdio>
-#include <stdio.h>
+//#include <cstdio>
+//#include <stdio.h>
 #ifndef __WIN32__
 
 #define WINAPI
-- 
cgit v1.2.3