WINTERMUTE: Clean up byte/char casts in loading/parsing

30 files changed, 283 insertions, 283 deletions

diff --git a/engines/wintermute/ad/ad_actor.cpp b/engines/wintermute/ad/ad_actor.cpp
index 94df17c543..967270b9bd 100644
--- a/engines/wintermute/ad/ad_actor.cpp
+++ b/engines/wintermute/ad/ad_actor.cpp
@@ -119,7 +119,7 @@ AdActor::~AdActor() {
 
 //////////////////////////////////////////////////////////////////////////
 bool AdActor::loadFile(const char *filename) {
-	byte *buffer = BaseFileManager::getEngineInstance()->readWholeFile(filename);
+	char *buffer = (char *)BaseFileManager::getEngineInstance()->readWholeFile(filename);
 	if (buffer == nullptr) {
 		_gameRef->LOG(0, "AdActor::LoadFile failed for file '%s'", filename);
 		return STATUS_FAILED;
@@ -179,7 +179,7 @@ TOKEN_DEF(EDITOR_PROPERTY)
 TOKEN_DEF(ANIMATION)
 TOKEN_DEF_END
 //////////////////////////////////////////////////////////////////////////
-bool AdActor::loadBuffer(byte *buffer, bool complete) {
+bool AdActor::loadBuffer(char *buffer, bool complete) {
 	TOKEN_TABLE_START(commands)
 	TOKEN_TABLE(ACTOR)
 	TOKEN_TABLE(X)
@@ -219,12 +219,12 @@ bool AdActor::loadBuffer(byte *buffer, bool complete) {
 	TOKEN_TABLE(ANIMATION)
 	TOKEN_TABLE_END
 
-	byte *params;
+	char *params;
 	int cmd;
 	BaseParser parser;
 
 	if (complete) {
-		if (parser.getCommand((char **)&buffer, commands, (char **)&params) != TOKEN_ACTOR) {
+		if (parser.getCommand(&buffer, commands, &params) != TOKEN_ACTOR) {
 			_gameRef->LOG(0, "'ACTOR' keyword expected.");
 			return STATUS_FAILED;
 		}
@@ -234,55 +234,55 @@ bool AdActor::loadBuffer(byte *buffer, bool complete) {
 	AdGame *adGame = (AdGame *)_gameRef;
 	AdSpriteSet *spr = nullptr;
 	int ar = 0, ag = 0, ab = 0, alpha = 0;
-	while ((cmd = parser.getCommand((char **)&buffer, commands, (char **)&params)) > 0) {
+	while ((cmd = parser.getCommand(&buffer, commands, &params)) > 0) {
 		switch (cmd) {
 		case TOKEN_TEMPLATE:
-			if (DID_FAIL(loadFile((char *)params))) {
+			if (DID_FAIL(loadFile(params))) {
 				cmd = PARSERR_GENERIC;
 			}
 			break;
 
 		case TOKEN_X:
-			parser.scanStr((char *)params, "%d", &_posX);
+			parser.scanStr(params, "%d", &_posX);
 			break;
 
 		case TOKEN_Y:
-			parser.scanStr((char *)params, "%d", &_posY);
+			parser.scanStr(params, "%d", &_posY);
 			break;
 
 		case TOKEN_NAME:
-			setName((char *)params);
+			setName(params);
 			break;
 
 		case TOKEN_CAPTION:
-			setCaption((char *)params);
+			setCaption(params);
 			break;
 
 		case TOKEN_FONT:
-			setFont((char *)params);
+			setFont(params);
 			break;
 
 		case TOKEN_SCALABLE:
-			parser.scanStr((char *)params, "%b", &_zoomable);
+			parser.scanStr(params, "%b", &_zoomable);
 			break;
 
 		case TOKEN_ROTABLE:
 		case TOKEN_ROTATABLE:
-			parser.scanStr((char *)params, "%b", &_rotatable);
+			parser.scanStr(params, "%b", &_rotatable);
 			break;
 
 		case TOKEN_REGISTRABLE:
 		case TOKEN_INTERACTIVE:
-			parser.scanStr((char *)params, "%b", &_registrable);
+			parser.scanStr(params, "%b", &_registrable);
 			break;
 
 		case TOKEN_SHADOWABLE:
 		case TOKEN_COLORABLE:
-			parser.scanStr((char *)params, "%b", &_shadowable);
+			parser.scanStr(params, "%b", &_shadowable);
 			break;
 
 		case TOKEN_ACTIVE:
-			parser.scanStr((char *)params, "%b", &_active);
+			parser.scanStr(params, "%b", &_active);
 			break;
 
 		case TOKEN_WALK:
@@ -348,7 +348,7 @@ bool AdActor::loadBuffer(byte *buffer, bool complete) {
 			break;
 
 		case TOKEN_SCRIPT:
-			addScript((char *)params);
+			addScript(params);
 			break;
 
 		case TOKEN_CURSOR:
@@ -362,12 +362,12 @@ bool AdActor::loadBuffer(byte *buffer, bool complete) {
 			break;
 
 		case TOKEN_SOUND_VOLUME:
-			parser.scanStr((char *)params, "%d", &_sFXVolume);
+			parser.scanStr(params, "%d", &_sFXVolume);
 			break;
 
 		case TOKEN_SCALE: {
 			int s;
-			parser.scanStr((char *)params, "%d", &s);
+			parser.scanStr(params, "%d", &s);
 			_scale = (float)s;
 
 		}
@@ -375,14 +375,14 @@ bool AdActor::loadBuffer(byte *buffer, bool complete) {
 
 		case TOKEN_RELATIVE_SCALE: {
 			int s;
-			parser.scanStr((char *)params, "%d", &s);
+			parser.scanStr(params, "%d", &s);
 			_relativeScale = (float)s;
 
 		}
 		break;
 
 		case TOKEN_SOUND_PANNING:
-			parser.scanStr((char *)params, "%b", &_autoSoundPanning);
+			parser.scanStr(params, "%b", &_autoSoundPanning);
 			break;
 
 		case TOKEN_PROPERTY:
@@ -432,15 +432,15 @@ bool AdActor::loadBuffer(byte *buffer, bool complete) {
 		break;
 
 		case TOKEN_IGNORE_ITEMS:
-			parser.scanStr((char *)params, "%b", &_ignoreItems);
+			parser.scanStr(params, "%b", &_ignoreItems);
 			break;
 
 		case TOKEN_ALPHA_COLOR:
-			parser.scanStr((char *)params, "%d,%d,%d", &ar, &ag, &ab);
+			parser.scanStr(params, "%d,%d,%d", &ar, &ag, &ab);
 			break;
 
 		case TOKEN_ALPHA:
-			parser.scanStr((char *)params, "%d", &alpha);
+			parser.scanStr(params, "%d", &alpha);
 			break;
 
 		case TOKEN_EDITOR_PROPERTY:
@@ -1410,20 +1410,20 @@ bool AdActor::mergeAnims(const char *animsFilename) {
 	TOKEN_TABLE_END
 
 
-	byte *fileBuffer = BaseFileManager::getEngineInstance()->readWholeFile(animsFilename);
+	char *fileBuffer = (char *)BaseFileManager::getEngineInstance()->readWholeFile(animsFilename);
 	if (fileBuffer == nullptr) {
 		_gameRef->LOG(0, "AdActor::MergeAnims failed for file '%s'", animsFilename);
 		return STATUS_FAILED;
 	}
 
-	byte *buffer = fileBuffer;
-	byte *params;
+	char *buffer = fileBuffer;
+	char *params;
 	int cmd;
 	BaseParser parser;
 
 	bool ret = STATUS_OK;
 
-	while ((cmd = parser.getCommand((char **)&buffer, commands, (char **)&params)) > 0) {
+	while ((cmd = parser.getCommand(&buffer, commands, &params)) > 0) {
 		switch (cmd) {
 		case TOKEN_ANIMATION: {
 			AdSpriteSet *anim = new AdSpriteSet(_gameRef, this);
diff --git a/engines/wintermute/ad/ad_actor.h b/engines/wintermute/ad/ad_actor.h
index 582b41b8b0..e836dd72cf 100644
--- a/engines/wintermute/ad/ad_actor.h
+++ b/engines/wintermute/ad/ad_actor.h
@@ -57,7 +57,7 @@ public:
 	AdActor(BaseGame *inGame/*=nullptr*/);
 	virtual ~AdActor();
 	bool loadFile(const char *filename);
-	bool loadBuffer(byte *buffer, bool complete = true);
+	bool loadBuffer(char *buffer, bool complete = true);
 
 
 private:
diff --git a/engines/wintermute/ad/ad_entity.cpp b/engines/wintermute/ad/ad_entity.cpp
index 388accf34f..2c0e13a4dc 100644
--- a/engines/wintermute/ad/ad_entity.cpp
+++ b/engines/wintermute/ad/ad_entity.cpp
@@ -100,7 +100,7 @@ const char *AdEntity::getItemName() const {
 
 //////////////////////////////////////////////////////////////////////////
 bool AdEntity::loadFile(const char *filename) {
-	byte *buffer = BaseFileManager::getEngineInstance()->readWholeFile(filename);
+	char *buffer = (char *)BaseFileManager::getEngineInstance()->readWholeFile(filename);
 	if (buffer == nullptr) {
 		_gameRef->LOG(0, "AdEntity::LoadFile failed for file '%s'", filename);
 		return STATUS_FAILED;
@@ -166,7 +166,7 @@ TOKEN_DEF(WALK_TO_DIR)
 TOKEN_DEF(SAVE_STATE)
 TOKEN_DEF_END
 //////////////////////////////////////////////////////////////////////////
-bool AdEntity::loadBuffer(byte *buffer, bool complete) {
+bool AdEntity::loadBuffer(char *buffer, bool complete) {
 	TOKEN_TABLE_START(commands)
 	TOKEN_TABLE(ENTITY)
 	TOKEN_TABLE(SPRITE)
@@ -212,12 +212,12 @@ bool AdEntity::loadBuffer(byte *buffer, bool complete) {
 	TOKEN_TABLE(SAVE_STATE)
 	TOKEN_TABLE_END
 
-	byte *params;
+	char *params;
 	int cmd;
 	BaseParser parser;
 
 	if (complete) {
-		if (parser.getCommand((char **)&buffer, commands, (char **)&params) != TOKEN_ENTITY) {
+		if (parser.getCommand(&buffer, commands, &params) != TOKEN_ENTITY) {
 			_gameRef->LOG(0, "'ENTITY' keyword expected.");
 			return STATUS_FAILED;
 		}
@@ -227,27 +227,27 @@ bool AdEntity::loadBuffer(byte *buffer, bool complete) {
 	AdGame *adGame = (AdGame *)_gameRef;
 	BaseSprite *spr = nullptr;
 	int ar = 0, ag = 0, ab = 0, alpha = 0;
-	while ((cmd = parser.getCommand((char **)&buffer, commands, (char **)&params)) > 0) {
+	while ((cmd = parser.getCommand(&buffer, commands, &params)) > 0) {
 		switch (cmd) {
 		case TOKEN_TEMPLATE:
-			if (DID_FAIL(loadFile((char *)params))) {
+			if (DID_FAIL(loadFile(params))) {
 				cmd = PARSERR_GENERIC;
 			}
 			break;
 
 		case TOKEN_X:
-			parser.scanStr((char *)params, "%d", &_posX);
+			parser.scanStr(params, "%d", &_posX);
 			break;
 
 		case TOKEN_Y:
-			parser.scanStr((char *)params, "%d", &_posY);
+			parser.scanStr(params, "%d", &_posY);
 			break;
 
 		case TOKEN_SPRITE: {
 			delete _sprite;
 			_sprite = nullptr;
 			spr = new BaseSprite(_gameRef, this);
-			if (!spr || DID_FAIL(spr->loadFile((char *)params))) {
+			if (!spr || DID_FAIL(spr->loadFile(params))) {
 				cmd = PARSERR_GENERIC;
 			} else {
 				_sprite = spr;
@@ -257,7 +257,7 @@ bool AdEntity::loadBuffer(byte *buffer, bool complete) {
 
 		case TOKEN_TALK: {
 			spr = new BaseSprite(_gameRef, this);
-			if (!spr || DID_FAIL(spr->loadFile((char *)params, adGame->_texTalkLifeTime))) {
+			if (!spr || DID_FAIL(spr->loadFile(params, adGame->_texTalkLifeTime))) {
 				cmd = PARSERR_GENERIC;
 			} else {
 				_talkSprites.add(spr);
@@ -267,7 +267,7 @@ bool AdEntity::loadBuffer(byte *buffer, bool complete) {
 
 		case TOKEN_TALK_SPECIAL: {
 			spr = new BaseSprite(_gameRef, this);
-			if (!spr || DID_FAIL(spr->loadFile((char *)params, adGame->_texTalkLifeTime))) {
+			if (!spr || DID_FAIL(spr->loadFile(params, adGame->_texTalkLifeTime))) {
 				cmd = PARSERR_GENERIC;
 			} else {
 				_talkSpritesEx.add(spr);
@@ -276,28 +276,28 @@ bool AdEntity::loadBuffer(byte *buffer, bool complete) {
 		break;
 
 		case TOKEN_NAME:
-			setName((char *)params);
+			setName(params);
 			break;
 
 		case TOKEN_ITEM:
-			setItem((char *)params);
+			setItem(params);
 			break;
 
 		case TOKEN_CAPTION:
-			setCaption((char *)params);
+			setCaption(params);
 			break;
 
 		case TOKEN_FONT:
-			setFont((char *)params);
+			setFont(params);
 			break;
 
 		case TOKEN_SCALABLE:
-			parser.scanStr((char *)params, "%b", &_zoomable);
+			parser.scanStr(params, "%b", &_zoomable);
 			break;
 
 		case TOKEN_SCALE: {
 			int s;
-			parser.scanStr((char *)params, "%d", &s);
+			parser.scanStr(params, "%d", &s);
 			_scale = (float)s;
 
 		}
@@ -305,7 +305,7 @@ bool AdEntity::loadBuffer(byte *buffer, bool complete) {
 
 		case TOKEN_RELATIVE_SCALE: {
 			int s;
-			parser.scanStr((char *)params, "%d", &s);
+			parser.scanStr(params, "%d", &s);
 			_relativeScale = (float)s;
 
 		}
@@ -313,27 +313,27 @@ bool AdEntity::loadBuffer(byte *buffer, bool complete) {
 
 		case TOKEN_ROTABLE:
 		case TOKEN_ROTATABLE:
-			parser.scanStr((char *)params, "%b", &_rotatable);
+			parser.scanStr(params, "%b", &_rotatable);
 			break;
 
 		case TOKEN_REGISTRABLE:
 		case TOKEN_INTERACTIVE:
-			parser.scanStr((char *)params, "%b", &_registrable);
+			parser.scanStr(params, "%b", &_registrable);
 			break;
 
 		case TOKEN_SHADOWABLE:
 		case TOKEN_COLORABLE:
-			parser.scanStr((char *)params, "%b", &_shadowable);
+			parser.scanStr(params, "%b", &_shadowable);
 			break;
 
 		case TOKEN_ACTIVE:
-			parser.scanStr((char *)params, "%b", &_active);
+			parser.scanStr(params, "%b", &_active);
 			break;
 
 		case TOKEN_CURSOR:
 			delete _cursor;
 			_cursor = new BaseSprite(_gameRef);
-			if (!_cursor || DID_FAIL(_cursor->loadFile((char *)params))) {
+			if (!_cursor || DID_FAIL(_cursor->loadFile(params))) {
 				delete _cursor;
 				_cursor = nullptr;
 				cmd = PARSERR_GENERIC;
@@ -341,7 +341,7 @@ bool AdEntity::loadBuffer(byte *buffer, bool complete) {
 			break;
 
 		case TOKEN_EDITOR_SELECTED:
-			parser.scanStr((char *)params, "%b", &_editorSelected);
+			parser.scanStr(params, "%b", &_editorSelected);
 			break;
 
 		case TOKEN_REGION: {
@@ -402,11 +402,11 @@ bool AdEntity::loadBuffer(byte *buffer, bool complete) {
 		break;
 
 		case TOKEN_SCRIPT:
-			addScript((char *)params);
+			addScript(params);
 			break;
 
 		case TOKEN_SUBTYPE: {
-			if (scumm_stricmp((char *)params, "sound") == 0) {
+			if (scumm_stricmp(params, "sound") == 0) {
 				delete _sprite;
 				_sprite = nullptr;
 				if (_gameRef->_editorMode) {
@@ -430,23 +430,23 @@ bool AdEntity::loadBuffer(byte *buffer, bool complete) {
 		break;
 
 		case TOKEN_SOUND:
-			playSFX((char *)params, false, false);
+			playSFX(params, false, false);
 			break;
 
 		case TOKEN_SOUND_START_TIME:
-			parser.scanStr((char *)params, "%d", &_sFXStart);
+			parser.scanStr(params, "%d", &_sFXStart);
 			break;
 
 		case TOKEN_SOUND_VOLUME:
-			parser.scanStr((char *)params, "%d", &_sFXVolume);
+			parser.scanStr(params, "%d", &_sFXVolume);
 			break;
 
 		case TOKEN_SOUND_PANNING:
-			parser.scanStr((char *)params, "%b", &_autoSoundPanning);
+			parser.scanStr(params, "%b", &_autoSoundPanning);
 			break;
 
 		case TOKEN_SAVE_STATE:
-			parser.scanStr((char *)params, "%b", &_saveState);
+			parser.scanStr(params, "%b", &_saveState);
 			break;
 
 		case TOKEN_PROPERTY:
@@ -454,15 +454,15 @@ bool AdEntity::loadBuffer(byte *buffer, bool complete) {
 			break;
 
 		case TOKEN_IGNORE_ITEMS:
-			parser.scanStr((char *)params, "%b", &_ignoreItems);
+			parser.scanStr(params, "%b", &_ignoreItems);
 			break;
 
 		case TOKEN_ALPHA_COLOR:
-			parser.scanStr((char *)params, "%d,%d,%d", &ar, &ag, &ab);
+			parser.scanStr(params, "%d,%d,%d", &ar, &ag, &ab);
 			break;
 
 		case TOKEN_ALPHA:
-			parser.scanStr((char *)params, "%d", &alpha);
+			parser.scanStr(params, "%d", &alpha);
 			break;
 
 		case TOKEN_EDITOR_PROPERTY:
@@ -470,16 +470,16 @@ bool AdEntity::loadBuffer(byte *buffer, bool complete) {
 			break;
 
 		case TOKEN_WALK_TO_X:
-			parser.scanStr((char *)params, "%d", &_walkToX);
+			parser.scanStr(params, "%d", &_walkToX);
 			break;
 
 		case TOKEN_WALK_TO_Y:
-			parser.scanStr((char *)params, "%d", &_walkToY);
+			parser.scanStr(params, "%d", &_walkToY);
 			break;
 
 		case TOKEN_WALK_TO_DIR: {
 			int i;
-			parser.scanStr((char *)params, "%d", &i);
+			parser.scanStr(params, "%d", &i);
 			if (i < 0) {
 				i = 0;
 			}
diff --git a/engines/wintermute/ad/ad_entity.h b/engines/wintermute/ad/ad_entity.h
index bdbd271667..c4d60e86f3 100644
--- a/engines/wintermute/ad/ad_entity.h
+++ b/engines/wintermute/ad/ad_entity.h
@@ -48,7 +48,7 @@ public:
 	AdEntity(BaseGame *inGame);
 	virtual ~AdEntity();
 	bool loadFile(const char *filename);
-	bool loadBuffer(byte *buffer, bool complete = true);
+	bool loadBuffer(char *buffer, bool complete = true);
 
 	int32 getWalkToX() const;
 	int32 getWalkToY() const;
diff --git a/engines/wintermute/ad/ad_game.cpp b/engines/wintermute/ad/ad_game.cpp
index d5799e851b..86f470b8c3 100644
--- a/engines/wintermute/ad/ad_game.cpp
+++ b/engines/wintermute/ad/ad_game.cpp
@@ -1245,7 +1245,7 @@ bool AdGame::showCursor() {
 
 //////////////////////////////////////////////////////////////////////////
 bool AdGame::loadFile(const char *filename) {
-	byte *buffer = BaseFileManager::getEngineInstance()->readWholeFile(filename);
+	char *buffer = (char *)BaseFileManager::getEngineInstance()->readWholeFile(filename);
 	if (buffer == nullptr) {
 		_gameRef->LOG(0, "AdGame::LoadFile failed for file '%s'", filename);
 		return STATUS_FAILED;
@@ -1281,7 +1281,7 @@ TOKEN_DEF(STARTUP_SCENE)
 TOKEN_DEF(DEBUG_STARTUP_SCENE)
 TOKEN_DEF_END
 //////////////////////////////////////////////////////////////////////////
-bool AdGame::loadBuffer(byte *buffer, bool complete) {
+bool AdGame::loadBuffer(char *buffer, bool complete) {
 	TOKEN_TABLE_START(commands)
 	TOKEN_TABLE(GAME)
 	TOKEN_TABLE(AD_GAME)
@@ -1295,14 +1295,14 @@ bool AdGame::loadBuffer(byte *buffer, bool complete) {
 	TOKEN_TABLE(DEBUG_STARTUP_SCENE)
 	TOKEN_TABLE_END
 
-	byte *params;
-	byte *params2;
+	char *params;
+	char *params2;
 	int cmd = 1;
 	BaseParser parser;
 
 	bool itemFound = false, itemsFound = false;
 
-	while (cmd > 0 && (cmd = parser.getCommand((char **)&buffer, commands, (char **)&params)) > 0) {
+	while (cmd > 0 && (cmd = parser.getCommand(&buffer, commands, &params)) > 0) {
 		switch (cmd) {
 		case TOKEN_GAME:
 			if (DID_FAIL(BaseGame::loadBuffer(params, false))) {
@@ -1311,12 +1311,12 @@ bool AdGame::loadBuffer(byte *buffer, bool complete) {
 			break;
 
 		case TOKEN_AD_GAME:
-			while (cmd > 0 && (cmd = parser.getCommand((char **)&params, commands, (char **)&params2)) > 0) {
+			while (cmd > 0 && (cmd = parser.getCommand(&params, commands, &params2)) > 0) {
 				switch (cmd) {
 				case TOKEN_RESPONSE_BOX:
 					delete _responseBox;
 					_responseBox = new AdResponseBox(_gameRef);
-					if (_responseBox && !DID_FAIL(_responseBox->loadFile((char *)params2))) {
+					if (_responseBox && !DID_FAIL(_responseBox->loadFile(params2))) {
 						registerObject(_responseBox);
 					} else {
 						delete _responseBox;
@@ -1328,7 +1328,7 @@ bool AdGame::loadBuffer(byte *buffer, bool complete) {
 				case TOKEN_INVENTORY_BOX:
 					delete _inventoryBox;
 					_inventoryBox = new AdInventoryBox(_gameRef);
-					if (_inventoryBox && !DID_FAIL(_inventoryBox->loadFile((char *)params2))) {
+					if (_inventoryBox && !DID_FAIL(_inventoryBox->loadFile(params2))) {
 						registerObject(_inventoryBox);
 					} else {
 						delete _inventoryBox;
@@ -1339,7 +1339,7 @@ bool AdGame::loadBuffer(byte *buffer, bool complete) {
 
 				case TOKEN_ITEMS:
 					itemsFound = true;
-					BaseUtils::setString(&_itemsFile, (char *)params2);
+					BaseUtils::setString(&_itemsFile, params2);
 					if (DID_FAIL(loadItemsFile(_itemsFile))) {
 						delete[] _itemsFile;
 						_itemsFile = nullptr;
@@ -1348,9 +1348,9 @@ bool AdGame::loadBuffer(byte *buffer, bool complete) {
 					break;
 
 				case TOKEN_TALK_SKIP_BUTTON:
-					if (scumm_stricmp((char *)params2, "right") == 0) {
+					if (scumm_stricmp(params2, "right") == 0) {
 						_talkSkipButton = TALK_SKIP_RIGHT;
-					} else if (scumm_stricmp((char *)params2, "both") == 0) {
+					} else if (scumm_stricmp(params2, "both") == 0) {
 						_talkSkipButton = TALK_SKIP_BOTH;
 					} else {
 						_talkSkipButton = TALK_SKIP_LEFT;
@@ -1359,7 +1359,7 @@ bool AdGame::loadBuffer(byte *buffer, bool complete) {
 
 				case TOKEN_SCENE_VIEWPORT: {
 					Rect32 rc;
-					parser.scanStr((char *)params2, "%d,%d,%d,%d", &rc.left, &rc.top, &rc.right, &rc.bottom);
+					parser.scanStr(params2, "%d,%d,%d,%d", &rc.left, &rc.top, &rc.right, &rc.bottom);
 					if (!_sceneViewport) {
 						_sceneViewport = new BaseViewport(_gameRef);
 					}
@@ -1374,11 +1374,11 @@ bool AdGame::loadBuffer(byte *buffer, bool complete) {
 					break;
 
 				case TOKEN_STARTUP_SCENE:
-					BaseUtils::setString(&_startupScene, (char *)params2);
+					BaseUtils::setString(&_startupScene, params2);
 					break;
 
 				case TOKEN_DEBUG_STARTUP_SCENE:
-					BaseUtils::setString(&_debugStartupScene, (char *)params2);
+					BaseUtils::setString(&_debugStartupScene, params2);
 					break;
 				}
 			}
@@ -1518,7 +1518,7 @@ bool AdGame::getVersion(byte *verMajor, byte *verMinor, byte *extMajor, byte *ex
 
 //////////////////////////////////////////////////////////////////////////
 bool AdGame::loadItemsFile(const char *filename, bool merge) {
-	byte *buffer = BaseFileManager::getEngineInstance()->readWholeFile(filename);
+	char *buffer = (char *)BaseFileManager::getEngineInstance()->readWholeFile(filename);
 	if (buffer == nullptr) {
 		_gameRef->LOG(0, "AdGame::LoadItemsFile failed for file '%s'", filename);
 		return STATUS_FAILED;
@@ -1541,12 +1541,12 @@ bool AdGame::loadItemsFile(const char *filename, bool merge) {
 
 
 //////////////////////////////////////////////////////////////////////////
-bool AdGame::loadItemsBuffer(byte *buffer, bool merge) {
+bool AdGame::loadItemsBuffer(char *buffer, bool merge) {
 	TOKEN_TABLE_START(commands)
 	TOKEN_TABLE(ITEM)
 	TOKEN_TABLE_END
 
-	byte *params;
+	char *params;
 	int cmd;
 	BaseParser parser;
 
@@ -1556,7 +1556,7 @@ bool AdGame::loadItemsBuffer(byte *buffer, bool merge) {
 		}
 	}
 
-	while ((cmd = parser.getCommand((char **)&buffer, commands, (char **)&params)) > 0) {
+	while ((cmd = parser.getCommand(&buffer, commands, &params)) > 0) {
 		switch (cmd) {
 		case TOKEN_ITEM: {
 			AdItem *item = new AdItem(_gameRef);
@@ -1637,7 +1637,7 @@ bool AdGame::windowLoadHook(UIWindow *win, char **buffer, char **params) {
 	switch (cmd) {
 	case TOKEN_ENTITY_CONTAINER: {
 		UIEntity *ent = new UIEntity(_gameRef);
-		if (!ent || DID_FAIL(ent->loadBuffer((byte *)*params, false))) {
+		if (!ent || DID_FAIL(ent->loadBuffer(*params, false))) {
 			delete ent;
 			ent = nullptr;
 			cmd = PARSERR_GENERIC;
diff --git a/engines/wintermute/ad/ad_game.h b/engines/wintermute/ad/ad_game.h
index cb5147501d..019f2e6478 100644
--- a/engines/wintermute/ad/ad_game.h
+++ b/engines/wintermute/ad/ad_game.h
@@ -120,10 +120,10 @@ public:
 	BaseArray<AdObject *> _objects;
 
 	virtual bool loadFile(const char *filename);
-	virtual bool loadBuffer(byte *buffer, bool complete = true);
+	virtual bool loadBuffer(char *buffer, bool complete = true);
 
 	bool loadItemsFile(const char *filename, bool merge = false);
-	bool loadItemsBuffer(byte *buffer, bool merge = false);
+	bool loadItemsBuffer(char *buffer, bool merge = false);
 
 	// scripting interface
 	virtual ScValue *scGetProperty(const Common::String &name) override;
diff --git a/engines/wintermute/ad/ad_inventory_box.cpp b/engines/wintermute/ad/ad_inventory_box.cpp
index 313da99a28..4c904e78eb 100644
--- a/engines/wintermute/ad/ad_inventory_box.cpp
+++ b/engines/wintermute/ad/ad_inventory_box.cpp
@@ -165,7 +165,7 @@ bool AdInventoryBox::display() {
 
 //////////////////////////////////////////////////////////////////////////
 bool AdInventoryBox::loadFile(const char *filename) {
-	byte *buffer = BaseFileManager::getEngineInstance()->readWholeFile(filename);
+	char *buffer = (char *)BaseFileManager::getEngineInstance()->readWholeFile(filename);
 	if (buffer == nullptr) {
 		_gameRef->LOG(0, "AdInventoryBox::LoadFile failed for file '%s'", filename);
 		return STATUS_FAILED;
@@ -203,7 +203,7 @@ TOKEN_DEF(HIDE_SELECTED)
 TOKEN_DEF(EDITOR_PROPERTY)
 TOKEN_DEF_END
 //////////////////////////////////////////////////////////////////////////
-bool AdInventoryBox::loadBuffer(byte *buffer, bool complete) {
+bool AdInventoryBox::loadBuffer(char *buffer, bool complete) {
 	TOKEN_TABLE_START(commands)
 	TOKEN_TABLE(INVENTORY_BOX)
 	TOKEN_TABLE(TEMPLATE)
@@ -221,34 +221,34 @@ bool AdInventoryBox::loadBuffer(byte *buffer, bool complete) {
 	TOKEN_TABLE(EDITOR_PROPERTY)
 	TOKEN_TABLE_END
 
-	byte *params;
+	char *params;
 	int cmd = 2;
 	BaseParser parser;
 	bool alwaysVisible = false;
 
 	_exclusive = false;
 	if (complete) {
-		if (parser.getCommand((char **)&buffer, commands, (char **)&params) != TOKEN_INVENTORY_BOX) {
+		if (parser.getCommand(&buffer, commands, &params) != TOKEN_INVENTORY_BOX) {
 			_gameRef->LOG(0, "'INVENTORY_BOX' keyword expected.");
 			return STATUS_FAILED;
 		}
 		buffer = params;
 	}
 
-	while (cmd > 0 && (cmd = parser.getCommand((char **)&buffer, commands, (char **)&params)) > 0) {
+	while (cmd > 0 && (cmd = parser.getCommand(&buffer, commands, &params)) > 0) {
 		switch (cmd) {
 		case TOKEN_TEMPLATE:
-			if (DID_FAIL(loadFile((char *)params))) {
+			if (DID_FAIL(loadFile(params))) {
 				cmd = PARSERR_GENERIC;
 			}
 			break;
 
 		case TOKEN_NAME:
-			setName((char *)params);
+			setName(params);
 			break;
 
 		case TOKEN_CAPTION:
-			setCaption((char *)params);
+			setCaption(params);
 			break;
 
 		case TOKEN_WINDOW:
@@ -264,35 +264,35 @@ bool AdInventoryBox::loadBuffer(byte *buffer, bool complete) {
 			break;
 
 		case TOKEN_AREA:
-			parser.scanStr((char *)params, "%d,%d,%d,%d", &_itemsArea.left, &_itemsArea.top, &_itemsArea.right, &_itemsArea.bottom);
+			parser.scanStr(params, "%d,%d,%d,%d", &_itemsArea.left, &_itemsArea.top, &_itemsArea.right, &_itemsArea.bottom);
 			break;
 
 		case TOKEN_EXCLUSIVE:
-			parser.scanStr((char *)params, "%b", &_exclusive);
+			parser.scanStr(params, "%b", &_exclusive);
 			break;
 
 		case TOKEN_HIDE_SELECTED:
-			parser.scanStr((char *)params, "%b", &_hideSelected);
+			parser.scanStr(params, "%b", &_hideSelected);
 			break;
 
 		case TOKEN_ALWAYS_VISIBLE:
-			parser.scanStr((char *)params, "%b", &alwaysVisible);
+			parser.scanStr(params, "%b", &alwaysVisible);
 			break;
 
 		case TOKEN_SPACING:
-			parser.scanStr((char *)params, "%d", &_spacing);
+			parser.scanStr(params, "%d", &_spacing);
 			break;
 
 		case TOKEN_ITEM_WIDTH:
-			parser.scanStr((char *)params, "%d", &_itemWidth);
+			parser.scanStr(params, "%d", &_itemWidth);
 			break;
 
 		case TOKEN_ITEM_HEIGHT:
-			parser.scanStr((char *)params, "%d", &_itemHeight);
+			parser.scanStr(params, "%d", &_itemHeight);
 			break;
 
 		case TOKEN_SCROLL_BY:
-			parser.scanStr((char *)params, "%d", &_scrollBy);
+			parser.scanStr(params, "%d", &_scrollBy);
 			break;
 
 		case TOKEN_EDITOR_PROPERTY:
diff --git a/engines/wintermute/ad/ad_inventory_box.h b/engines/wintermute/ad/ad_inventory_box.h
index f65bd8d8f0..4d576625b2 100644
--- a/engines/wintermute/ad/ad_inventory_box.h
+++ b/engines/wintermute/ad/ad_inventory_box.h
@@ -51,7 +51,7 @@ public:
 	AdInventoryBox(BaseGame *inGame);
 	virtual ~AdInventoryBox();
 	bool loadFile(const char *filename);
-	bool loadBuffer(byte *buffer, bool complete = true);
+	bool loadBuffer(char *buffer, bool complete = true);
 	virtual bool saveAsText(BaseDynamicBuffer *buffer, int indent) override;
 private:
 	bool _exclusive;
diff --git a/engines/wintermute/ad/ad_item.cpp b/engines/wintermute/ad/ad_item.cpp
index 7d05461169..f9741d1ed2 100644
--- a/engines/wintermute/ad/ad_item.cpp
+++ b/engines/wintermute/ad/ad_item.cpp
@@ -84,7 +84,7 @@ AdItem::~AdItem() {
 
 //////////////////////////////////////////////////////////////////////////
 bool AdItem::loadFile(const char *filename) {
-	byte *buffer = BaseFileManager::getEngineInstance()->readWholeFile(filename);
+	char *buffer = (char *)BaseFileManager::getEngineInstance()->readWholeFile(filename);
 	if (buffer == nullptr) {
 		_gameRef->LOG(0, "AdItem::LoadFile failed for file '%s'", filename);
 		return STATUS_FAILED;
@@ -134,7 +134,7 @@ TOKEN_DEF(AMOUNT_STRING)
 TOKEN_DEF(AMOUNT)
 TOKEN_DEF_END
 //////////////////////////////////////////////////////////////////////////
-bool AdItem::loadBuffer(byte *buffer, bool complete) {
+bool AdItem::loadBuffer(char *buffer, bool complete) {
 	TOKEN_TABLE_START(commands)
 	TOKEN_TABLE(ITEM)
 	TOKEN_TABLE(TEMPLATE)
@@ -164,12 +164,12 @@ bool AdItem::loadBuffer(byte *buffer, bool complete) {
 	TOKEN_TABLE(AMOUNT)
 	TOKEN_TABLE_END
 
-	byte *params;
+	char *params;
 	int cmd = 2;
 	BaseParser parser;
 
 	if (complete) {
-		if (parser.getCommand((char **)&buffer, commands, (char **)&params) != TOKEN_ITEM) {
+		if (parser.getCommand(&buffer, commands, &params) != TOKEN_ITEM) {
 			_gameRef->LOG(0, "'ITEM' keyword expected.");
 			return STATUS_FAILED;
 		}
@@ -177,31 +177,31 @@ bool AdItem::loadBuffer(byte *buffer, bool complete) {
 	}
 
 	int ar = 0, ag = 0, ab = 0, alpha = 255;
-	while (cmd > 0 && (cmd = parser.getCommand((char **)&buffer, commands, (char **)&params)) > 0) {
+	while (cmd > 0 && (cmd = parser.getCommand(&buffer, commands, &params)) > 0) {
 		switch (cmd) {
 		case TOKEN_TEMPLATE:
-			if (DID_FAIL(loadFile((char *)params))) {
+			if (DID_FAIL(loadFile(params))) {
 				cmd = PARSERR_GENERIC;
 			}
 			break;
 
 		case TOKEN_NAME:
-			setName((char *)params);
+			setName(params);
 			break;
 
 		case TOKEN_FONT:
-			setFont((char *)params);
+			setFont(params);
 			break;
 
 		case TOKEN_CAPTION:
-			setCaption((char *)params);
+			setCaption(params);
 			break;
 
 		case TOKEN_IMAGE:
 		case TOKEN_SPRITE:
 			delete _sprite;
 			_sprite = new BaseSprite(_gameRef, this);
-			if (!_sprite || DID_FAIL(_sprite->loadFile((char *)params, ((AdGame *)_gameRef)->_texItemLifeTime))) {
+			if (!_sprite || DID_FAIL(_sprite->loadFile(params, ((AdGame *)_gameRef)->_texItemLifeTime))) {
 				delete _sprite;
 				cmd = PARSERR_GENERIC;
 			}
@@ -211,32 +211,32 @@ bool AdItem::loadBuffer(byte *buffer, bool complete) {
 		case TOKEN_SPRITE_HOVER:
 			delete _spriteHover;
 			_spriteHover = new BaseSprite(_gameRef, this);
-			if (!_spriteHover || DID_FAIL(_spriteHover->loadFile((char *)params, ((AdGame *)_gameRef)->_texItemLifeTime))) {
+			if (!_spriteHover || DID_FAIL(_spriteHover->loadFile(params, ((AdGame *)_gameRef)->_texItemLifeTime))) {
 				delete _spriteHover;
 				cmd = PARSERR_GENERIC;
 			}
 			break;
 
 		case TOKEN_AMOUNT:
-			parser.scanStr((char *)params, "%d", &_amount);
+			parser.scanStr(params, "%d", &_amount);
 			break;
 
 		case TOKEN_DISPLAY_AMOUNT:
-			parser.scanStr((char *)params, "%b", &_displayAmount);
+			parser.scanStr(params, "%b", &_displayAmount);
 			break;
 
 		case TOKEN_AMOUNT_OFFSET_X:
-			parser.scanStr((char *)params, "%d", &_amountOffsetX);
+			parser.scanStr(params, "%d", &_amountOffsetX);
 			break;
 
 		case TOKEN_AMOUNT_OFFSET_Y:
-			parser.scanStr((char *)params, "%d", &_amountOffsetY);
+			parser.scanStr(params, "%d", &_amountOffsetY);
 			break;
 
 		case TOKEN_AMOUNT_ALIGN:
-			if (scumm_stricmp((char *)params, "left") == 0) {
+			if (scumm_stricmp(params, "left") == 0) {
 				_amountAlign = TAL_LEFT;
-			} else if (scumm_stricmp((char *)params, "right") == 0) {
+			} else if (scumm_stricmp(params, "right") == 0) {
 				_amountAlign = TAL_RIGHT;
 			} else {
 				_amountAlign = TAL_CENTER;
@@ -244,12 +244,12 @@ bool AdItem::loadBuffer(byte *buffer, bool complete) {
 			break;
 
 		case TOKEN_AMOUNT_STRING:
-			BaseUtils::setString(&_amountString, (char *)params);
+			BaseUtils::setString(&_amountString, params);
 			break;
 
 		case TOKEN_TALK: {
 			BaseSprite *spr = new BaseSprite(_gameRef, this);
-			if (!spr || DID_FAIL(spr->loadFile((char *)params, ((AdGame *)_gameRef)->_texTalkLifeTime))) {
+			if (!spr || DID_FAIL(spr->loadFile(params, ((AdGame *)_gameRef)->_texTalkLifeTime))) {
 				cmd = PARSERR_GENERIC;
 			} else {
 				_talkSprites.add(spr);
@@ -259,7 +259,7 @@ bool AdItem::loadBuffer(byte *buffer, bool complete) {
 
 		case TOKEN_TALK_SPECIAL: {
 			BaseSprite *spr = new BaseSprite(_gameRef, this);
-			if (!spr || DID_FAIL(spr->loadFile((char *)params, ((AdGame *)_gameRef)->_texTalkLifeTime))) {
+			if (!spr || DID_FAIL(spr->loadFile(params, ((AdGame *)_gameRef)->_texTalkLifeTime))) {
 				cmd = PARSERR_GENERIC;
 			} else {
 				_talkSpritesEx.add(spr);
@@ -270,7 +270,7 @@ bool AdItem::loadBuffer(byte *buffer, bool complete) {
 		case TOKEN_CURSOR:
 			delete _cursorNormal;
 			_cursorNormal = new BaseSprite(_gameRef);
-			if (!_cursorNormal || DID_FAIL(_cursorNormal->loadFile((char *)params, ((AdGame *)_gameRef)->_texItemLifeTime))) {
+			if (!_cursorNormal || DID_FAIL(_cursorNormal->loadFile(params, ((AdGame *)_gameRef)->_texItemLifeTime))) {
 				delete _cursorNormal;
 				_cursorNormal = nullptr;
 				cmd = PARSERR_GENERIC;
@@ -280,7 +280,7 @@ bool AdItem::loadBuffer(byte *buffer, bool complete) {
 		case TOKEN_CURSOR_HOVER:
 			delete _cursorHover;
 			_cursorHover = new BaseSprite(_gameRef);
-			if (!_cursorHover || DID_FAIL(_cursorHover->loadFile((char *)params, ((AdGame *)_gameRef)->_texItemLifeTime))) {
+			if (!_cursorHover || DID_FAIL(_cursorHover->loadFile(params, ((AdGame *)_gameRef)->_texItemLifeTime))) {
 				delete _cursorHover;
 				_cursorHover = nullptr;
 				cmd = PARSERR_GENERIC;
@@ -288,11 +288,11 @@ bool AdItem::loadBuffer(byte *buffer, bool complete) {
 			break;
 
 		case TOKEN_CURSOR_COMBINED:
-			parser.scanStr((char *)params, "%b", &_cursorCombined);
+			parser.scanStr(params, "%b", &_cursorCombined);
 			break;
 
 		case TOKEN_SCRIPT:
-			addScript((char *)params);
+			addScript(params);
 			break;
 
 		case TOKEN_PROPERTY:
@@ -300,11 +300,11 @@ bool AdItem::loadBuffer(byte *buffer, bool complete) {
 			break;
 
 		case TOKEN_ALPHA_COLOR:
-			parser.scanStr((char *)params, "%d,%d,%d", &ar, &ag, &ab);
+			parser.scanStr(params, "%d,%d,%d", &ar, &ag, &ab);
 			break;
 
 		case TOKEN_ALPHA:
-			parser.scanStr((char *)params, "%d", &alpha);
+			parser.scanStr(params, "%d", &alpha);
 			break;
 
 		case TOKEN_EDITOR_PROPERTY:
diff --git a/engines/wintermute/ad/ad_item.h b/engines/wintermute/ad/ad_item.h
index f074e5ac4e..935ea5d73d 100644
--- a/engines/wintermute/ad/ad_item.h
+++ b/engines/wintermute/ad/ad_item.h
@@ -50,7 +50,7 @@ public:
 	AdItem(BaseGame *inGame);
 	virtual ~AdItem();
 	bool loadFile(const char *filename);
-	bool loadBuffer(byte *buffer, bool complete = true);
+	bool loadBuffer(char *buffer, bool complete = true);
 
 	// scripting interface
 	virtual ScValue *scGetProperty(const Common::String &name) override;
diff --git a/engines/wintermute/ad/ad_layer.cpp b/engines/wintermute/ad/ad_layer.cpp
index c833b59163..752700d0d4 100644
--- a/engines/wintermute/ad/ad_layer.cpp
+++ b/engines/wintermute/ad/ad_layer.cpp
@@ -62,7 +62,7 @@ AdLayer::~AdLayer() {
 
 //////////////////////////////////////////////////////////////////////////
 bool AdLayer::loadFile(const char *filename) {
-	byte *buffer = BaseFileManager::getEngineInstance()->readWholeFile(filename);
+	char *buffer = (char *)BaseFileManager::getEngineInstance()->readWholeFile(filename);
 	if (buffer == nullptr) {
 		_gameRef->LOG(0, "AdLayer::LoadFile failed for file '%s'", filename);
 		return STATUS_FAILED;
@@ -100,7 +100,7 @@ TOKEN_DEF(CLOSE_UP)
 TOKEN_DEF(EDITOR_PROPERTY)
 TOKEN_DEF_END
 //////////////////////////////////////////////////////////////////////////
-bool AdLayer::loadBuffer(byte *buffer, bool complete) {
+bool AdLayer::loadBuffer(char *buffer, bool complete) {
 	TOKEN_TABLE_START(commands)
 	TOKEN_TABLE(LAYER)
 	TOKEN_TABLE(TEMPLATE)
@@ -119,52 +119,52 @@ bool AdLayer::loadBuffer(byte *buffer, bool complete) {
 	TOKEN_TABLE(EDITOR_PROPERTY)
 	TOKEN_TABLE_END
 
-	byte *params;
+	char *params;
 	int cmd;
 	BaseParser parser;
 
 	if (complete) {
-		if (parser.getCommand((char **)&buffer, commands, (char **)&params) != TOKEN_LAYER) {
+		if (parser.getCommand(&buffer, commands, &params) != TOKEN_LAYER) {
 			_gameRef->LOG(0, "'LAYER' keyword expected.");
 			return STATUS_FAILED;
 		}
 		buffer = params;
 	}
 
-	while ((cmd = parser.getCommand((char **)&buffer, commands, (char **)&params)) > 0) {
+	while ((cmd = parser.getCommand(&buffer, commands, &params)) > 0) {
 		switch (cmd) {
 		case TOKEN_TEMPLATE:
-			if (DID_FAIL(loadFile((char *)params))) {
+			if (DID_FAIL(loadFile(params))) {
 				cmd = PARSERR_GENERIC;
 			}
 			break;
 
 		case TOKEN_NAME:
-			setName((char *)params);
+			setName(params);
 			break;
 
 		case TOKEN_CAPTION:
-			setCaption((char *)params);
+			setCaption(params);
 			break;
 
 		case TOKEN_MAIN:
-			parser.scanStr((char *)params, "%b", &_main);
+			parser.scanStr(params, "%b", &_main);
 			break;
 
 		case TOKEN_CLOSE_UP:
-			parser.scanStr((char *)params, "%b", &_closeUp);
+			parser.scanStr(params, "%b", &_closeUp);
 			break;
 
 		case TOKEN_WIDTH:
-			parser.scanStr((char *)params, "%d", &_width);
+			parser.scanStr(params, "%d", &_width);
 			break;
 
 		case TOKEN_HEIGHT:
-			parser.scanStr((char *)params, "%d", &_height);
+			parser.scanStr(params, "%d", &_height);
 			break;
 
 		case TOKEN_ACTIVE:
-			parser.scanStr((char *)params, "%b", &_active);
+			parser.scanStr(params, "%b", &_active);
 			break;
 
 		case TOKEN_REGION: {
@@ -203,11 +203,11 @@ bool AdLayer::loadBuffer(byte *buffer, bool complete) {
 		break;
 
 		case TOKEN_EDITOR_SELECTED:
-			parser.scanStr((char *)params, "%b", &_editorSelected);
+			parser.scanStr(params, "%b", &_editorSelected);
 			break;
 
 		case TOKEN_SCRIPT:
-			addScript((char *)params);
+			addScript(params);
 			break;
 
 		case TOKEN_PROPERTY:
diff --git a/engines/wintermute/ad/ad_layer.h b/engines/wintermute/ad/ad_layer.h
index b260b919fd..af7c3a364c 100644
--- a/engines/wintermute/ad/ad_layer.h
+++ b/engines/wintermute/ad/ad_layer.h
@@ -43,7 +43,7 @@ public:
 	virtual ~AdLayer();
 	BaseArray<AdSceneNode *> _nodes;
 	bool loadFile(const char *filename);
-	bool loadBuffer(byte *buffer, bool complete = true);
+	bool loadBuffer(char *buffer, bool complete = true);
 	virtual bool saveAsText(BaseDynamicBuffer *buffer, int indent) override;
 
 	// scripting interface
diff --git a/engines/wintermute/ad/ad_region.cpp b/engines/wintermute/ad/ad_region.cpp
index bc9ac903c6..1c0cf41e86 100644
--- a/engines/wintermute/ad/ad_region.cpp
+++ b/engines/wintermute/ad/ad_region.cpp
@@ -69,7 +69,7 @@ bool AdRegion::hasDecoration() const {
 
 //////////////////////////////////////////////////////////////////////////
 bool AdRegion::loadFile(const char *filename) {
-	byte *buffer = BaseFileManager::getEngineInstance()->readWholeFile(filename);
+	char *buffer = (char *)BaseFileManager::getEngineInstance()->readWholeFile(filename);
 	if (buffer == nullptr) {
 		_gameRef->LOG(0, "AdRegion::LoadFile failed for file '%s'", filename);
 		return STATUS_FAILED;
@@ -110,7 +110,7 @@ TOKEN_DEF(PROPERTY)
 TOKEN_DEF(EDITOR_PROPERTY)
 TOKEN_DEF_END
 //////////////////////////////////////////////////////////////////////////
-bool AdRegion::loadBuffer(byte *buffer, bool complete) {
+bool AdRegion::loadBuffer(char *buffer, bool complete) {
 	TOKEN_TABLE_START(commands)
 	TOKEN_TABLE(REGION)
 	TOKEN_TABLE(TEMPLATE)
@@ -131,12 +131,12 @@ bool AdRegion::loadBuffer(byte *buffer, bool complete) {
 	TOKEN_TABLE(EDITOR_PROPERTY)
 	TOKEN_TABLE_END
 
-	byte *params;
+	char *params;
 	int cmd;
 	BaseParser parser;
 
 	if (complete) {
-		if (parser.getCommand((char **)&buffer, commands, (char **)&params) != TOKEN_REGION) {
+		if (parser.getCommand(&buffer, commands, &params) != TOKEN_REGION) {
 			_gameRef->LOG(0, "'REGION' keyword expected.");
 			return STATUS_FAILED;
 		}
@@ -150,67 +150,67 @@ bool AdRegion::loadBuffer(byte *buffer, bool complete) {
 
 	int ar = 255, ag = 255, ab = 255, alpha = 255;
 
-	while ((cmd = parser.getCommand((char **)&buffer, commands, (char **)&params)) > 0) {
+	while ((cmd = parser.getCommand(&buffer, commands, &params)) > 0) {
 		switch (cmd) {
 		case TOKEN_TEMPLATE:
-			if (DID_FAIL(loadFile((char *)params))) {
+			if (DID_FAIL(loadFile(params))) {
 				cmd = PARSERR_GENERIC;
 			}
 			break;
 
 		case TOKEN_NAME:
-			setName((char *)params);
+			setName(params);
 			break;
 
 		case TOKEN_CAPTION:
-			setCaption((char *)params);
+			setCaption(params);
 			break;
 
 		case TOKEN_ACTIVE:
-			parser.scanStr((char *)params, "%b", &_active);
+			parser.scanStr(params, "%b", &_active);
 			break;
 
 		case TOKEN_BLOCKED:
-			parser.scanStr((char *)params, "%b", &_blocked);
+			parser.scanStr(params, "%b", &_blocked);
 			break;
 
 		case TOKEN_DECORATION:
-			parser.scanStr((char *)params, "%b", &_decoration);
+			parser.scanStr(params, "%b", &_decoration);
 			break;
 
 		case TOKEN_ZOOM:
 		case TOKEN_SCALE: {
 			int j;
-			parser.scanStr((char *)params, "%d", &j);
+			parser.scanStr(params, "%d", &j);
 			_zoom = (float)j;
 		}
 		break;
 
 		case TOKEN_POINT: {
 			int x, y;
-			parser.scanStr((char *)params, "%d,%d", &x, &y);
+			parser.scanStr(params, "%d,%d", &x, &y);
 			_points.add(new BasePoint(x, y));
 		}
 		break;
 
 		case TOKEN_ALPHA_COLOR:
-			parser.scanStr((char *)params, "%d,%d,%d", &ar, &ag, &ab);
+			parser.scanStr(params, "%d,%d,%d", &ar, &ag, &ab);
 			break;
 
 		case TOKEN_ALPHA:
-			parser.scanStr((char *)params, "%d", &alpha);
+			parser.scanStr(params, "%d", &alpha);
 			break;
 
 		case TOKEN_EDITOR_SELECTED:
-			parser.scanStr((char *)params, "%b", &_editorSelected);
+			parser.scanStr(params, "%b", &_editorSelected);
 			break;
 
 		case TOKEN_EDITOR_SELECTED_POINT:
-			parser.scanStr((char *)params, "%d", &_editorSelectedPoint);
+			parser.scanStr(params, "%d", &_editorSelectedPoint);
 			break;
 
 		case TOKEN_SCRIPT:
-			addScript((char *)params);
+			addScript(params);
 			break;
 
 		case TOKEN_PROPERTY:
diff --git a/engines/wintermute/ad/ad_region.h b/engines/wintermute/ad/ad_region.h
index 637c742c9c..f3674dcbfb 100644
--- a/engines/wintermute/ad/ad_region.h
+++ b/engines/wintermute/ad/ad_region.h
@@ -40,7 +40,7 @@ public:
 	AdRegion(BaseGame *inGame);
 	virtual ~AdRegion();
 	bool loadFile(const char *filename);
-	bool loadBuffer(byte *buffer, bool complete = true);
+	bool loadBuffer(char *buffer, bool complete = true);
 	virtual bool saveAsText(BaseDynamicBuffer *buffer, int indent) override;
 
 	bool hasDecoration() const;
diff --git a/engines/wintermute/ad/ad_response_box.cpp b/engines/wintermute/ad/ad_response_box.cpp
index 9fcc33e2d1..2a5adb9234 100644
--- a/engines/wintermute/ad/ad_response_box.cpp
+++ b/engines/wintermute/ad/ad_response_box.cpp
@@ -217,7 +217,7 @@ bool AdResponseBox::createButtons() {
 
 //////////////////////////////////////////////////////////////////////////
 bool AdResponseBox::loadFile(const char *filename) {
-	byte *buffer = BaseFileManager::getEngineInstance()->readWholeFile(filename);
+	char *buffer = (char *)BaseFileManager::getEngineInstance()->readWholeFile(filename);
 	if (buffer == nullptr) {
 		_gameRef->LOG(0, "AdResponseBox::LoadFile failed for file '%s'", filename);
 		return STATUS_FAILED;
@@ -253,7 +253,7 @@ TOKEN_DEF(VERTICAL_ALIGN)
 TOKEN_DEF(EDITOR_PROPERTY)
 TOKEN_DEF_END
 //////////////////////////////////////////////////////////////////////////
-bool AdResponseBox::loadBuffer(byte *buffer, bool complete) {
+bool AdResponseBox::loadBuffer(char *buffer, bool complete) {
 	TOKEN_TABLE_START(commands)
 	TOKEN_TABLE(RESPONSE_BOX)
 	TOKEN_TABLE(TEMPLATE)
@@ -270,22 +270,22 @@ bool AdResponseBox::loadBuffer(byte *buffer, bool complete) {
 	TOKEN_TABLE_END
 
 
-	byte *params;
+	char *params;
 	int cmd;
 	BaseParser parser;
 
 	if (complete) {
-		if (parser.getCommand((char **)&buffer, commands, (char **)&params) != TOKEN_RESPONSE_BOX) {
+		if (parser.getCommand(&buffer, commands, &params) != TOKEN_RESPONSE_BOX) {
 			_gameRef->LOG(0, "'RESPONSE_BOX' keyword expected.");
 			return STATUS_FAILED;
 		}
 		buffer = params;
 	}
 
-	while ((cmd = parser.getCommand((char **)&buffer, commands, (char **)&params)) > 0) {
+	while ((cmd = parser.getCommand(&buffer, commands, &params)) > 0) {
 		switch (cmd) {
 		case TOKEN_TEMPLATE:
-			if (DID_FAIL(loadFile((char *)params))) {
+			if (DID_FAIL(loadFile(params))) {
 				cmd = PARSERR_GENERIC;
 			}
 			break;
@@ -306,7 +306,7 @@ bool AdResponseBox::loadBuffer(byte *buffer, bool complete) {
 			if (_font) {
 				_gameRef->_fontStorage->removeFont(_font);
 			}
-			_font = _gameRef->_fontStorage->addFont((char *)params);
+			_font = _gameRef->_fontStorage->addFont(params);
 			if (!_font) {
 				cmd = PARSERR_GENERIC;
 			}
@@ -316,24 +316,24 @@ bool AdResponseBox::loadBuffer(byte *buffer, bool complete) {
 			if (_fontHover) {
 				_gameRef->_fontStorage->removeFont(_fontHover);
 			}
-			_fontHover = _gameRef->_fontStorage->addFont((char *)params);
+			_fontHover = _gameRef->_fontStorage->addFont(params);
 			if (!_fontHover) {
 				cmd = PARSERR_GENERIC;
 			}
 			break;
 
 		case TOKEN_AREA:
-			parser.scanStr((char *)params, "%d,%d,%d,%d", &_responseArea.left, &_responseArea.top, &_responseArea.right, &_responseArea.bottom);
+			parser.scanStr(params, "%d,%d,%d,%d", &_responseArea.left, &_responseArea.top, &_responseArea.right, &_responseArea.bottom);
 			break;
 
 		case TOKEN_HORIZONTAL:
-			parser.scanStr((char *)params, "%b", &_horizontal);
+			parser.scanStr(params, "%b", &_horizontal);
 			break;
 
 		case TOKEN_TEXT_ALIGN:
-			if (scumm_stricmp((char *)params, "center") == 0) {
+			if (scumm_stricmp(params, "center") == 0) {
 				_align = TAL_CENTER;
-			} else if (scumm_stricmp((char *)params, "right") == 0) {
+			} else if (scumm_stricmp(params, "right") == 0) {
 				_align = TAL_RIGHT;
 			} else {
 				_align = TAL_LEFT;
@@ -341,9 +341,9 @@ bool AdResponseBox::loadBuffer(byte *buffer, bool complete) {
 			break;
 
 		case TOKEN_VERTICAL_ALIGN:
-			if (scumm_stricmp((char *)params, "top") == 0) {
+			if (scumm_stricmp(params, "top") == 0) {
 				_verticalAlign = VAL_TOP;
-			} else if (scumm_stricmp((char *)params, "center") == 0) {
+			} else if (scumm_stricmp(params, "center") == 0) {
 				_verticalAlign = VAL_CENTER;
 			} else {
 				_verticalAlign = VAL_BOTTOM;
@@ -351,7 +351,7 @@ bool AdResponseBox::loadBuffer(byte *buffer, bool complete) {
 			break;
 
 		case TOKEN_SPACING:
-			parser.scanStr((char *)params, "%d", &_spacing);
+			parser.scanStr(params, "%d", &_spacing);
 			break;
 
 		case TOKEN_EDITOR_PROPERTY:
@@ -361,7 +361,7 @@ bool AdResponseBox::loadBuffer(byte *buffer, bool complete) {
 		case TOKEN_CURSOR:
 			delete _cursor;
 			_cursor = new BaseSprite(_gameRef);
-			if (!_cursor || DID_FAIL(_cursor->loadFile((char *)params))) {
+			if (!_cursor || DID_FAIL(_cursor->loadFile(params))) {
 				delete _cursor;
 				_cursor = nullptr;
 				cmd = PARSERR_GENERIC;
diff --git a/engines/wintermute/ad/ad_response_box.h b/engines/wintermute/ad/ad_response_box.h
index 7598e8b569..9469bfda43 100644
--- a/engines/wintermute/ad/ad_response_box.h
+++ b/engines/wintermute/ad/ad_response_box.h
@@ -72,7 +72,7 @@ public:
 	virtual ~AdResponseBox();
 
 	bool loadFile(const char *filename);
-	bool loadBuffer(byte *buffer, bool complete = true);
+	bool loadBuffer(char *buffer, bool complete = true);
 	virtual bool saveAsText(BaseDynamicBuffer *buffer, int indent) override;
 
 	UIWindow *getResponseWindow();
diff --git a/engines/wintermute/ad/ad_rot_level.cpp b/engines/wintermute/ad/ad_rot_level.cpp
index d925b0d57a..b5bdc8ebe9 100644
--- a/engines/wintermute/ad/ad_rot_level.cpp
+++ b/engines/wintermute/ad/ad_rot_level.cpp
@@ -53,7 +53,7 @@ AdRotLevel::~AdRotLevel() {
 
 //////////////////////////////////////////////////////////////////////////
 bool AdRotLevel::loadFile(const char *filename) {
-	byte *buffer = BaseFileManager::getEngineInstance()->readWholeFile(filename);
+	char *buffer = (char *)BaseFileManager::getEngineInstance()->readWholeFile(filename);
 	if (buffer == nullptr) {
 		_gameRef->LOG(0, "AdRotLevel::LoadFile failed for file '%s'", filename);
 		return STATUS_FAILED;
@@ -82,7 +82,7 @@ TOKEN_DEF(ROTATION)
 TOKEN_DEF(EDITOR_PROPERTY)
 TOKEN_DEF_END
 //////////////////////////////////////////////////////////////////////////
-bool AdRotLevel::loadBuffer(byte *buffer, bool complete) {
+bool AdRotLevel::loadBuffer(char *buffer, bool complete) {
 	TOKEN_TABLE_START(commands)
 	TOKEN_TABLE(ROTATION_LEVEL)
 	TOKEN_TABLE(TEMPLATE)
@@ -91,33 +91,33 @@ bool AdRotLevel::loadBuffer(byte *buffer, bool complete) {
 	TOKEN_TABLE(EDITOR_PROPERTY)
 	TOKEN_TABLE_END
 
-	byte *params;
+	char *params;
 	int cmd;
 	BaseParser parser;
 
 	if (complete) {
-		if (parser.getCommand((char **)&buffer, commands, (char **)&params) != TOKEN_ROTATION_LEVEL) {
+		if (parser.getCommand(&buffer, commands, &params) != TOKEN_ROTATION_LEVEL) {
 			_gameRef->LOG(0, "'ROTATION_LEVEL' keyword expected.");
 			return STATUS_FAILED;
 		}
 		buffer = params;
 	}
 
-	while ((cmd = parser.getCommand((char **)&buffer, commands, (char **)&params)) > 0) {
+	while ((cmd = parser.getCommand(&buffer, commands, &params)) > 0) {
 		switch (cmd) {
 		case TOKEN_TEMPLATE:
-			if (DID_FAIL(loadFile((char *)params))) {
+			if (DID_FAIL(loadFile(params))) {
 				cmd = PARSERR_GENERIC;
 			}
 			break;
 
 		case TOKEN_X:
-			parser.scanStr((char *)params, "%d", &_posX);
+			parser.scanStr(params, "%d", &_posX);
 			break;
 
 		case TOKEN_ROTATION: {
 			int i;
-			parser.scanStr((char *)params, "%d", &i);
+			parser.scanStr(params, "%d", &i);
 			_rotation = (float)i;
 		}
 		break;
diff --git a/engines/wintermute/ad/ad_rot_level.h b/engines/wintermute/ad/ad_rot_level.h
index fe2d1691cd..47c621845a 100644
--- a/engines/wintermute/ad/ad_rot_level.h
+++ b/engines/wintermute/ad/ad_rot_level.h
@@ -42,7 +42,7 @@ public:
 	float getRotation() const { return _rotation; }
 	virtual bool saveAsText(BaseDynamicBuffer *buffer, int indent) override;
 	bool loadFile(const char *filename);
-	bool loadBuffer(byte *buffer, bool complete = true);
+	bool loadBuffer(char *buffer, bool complete = true);
 };
 
 } // End of namespace Wintermute
diff --git a/engines/wintermute/ad/ad_scale_level.cpp b/engines/wintermute/ad/ad_scale_level.cpp
index 59e6d57787..aa7f6f89cf 100644
--- a/engines/wintermute/ad/ad_scale_level.cpp
+++ b/engines/wintermute/ad/ad_scale_level.cpp
@@ -54,7 +54,7 @@ float AdScaleLevel::getScale() const {
 
 //////////////////////////////////////////////////////////////////////////
 bool AdScaleLevel::loadFile(const char *filename) {
-	byte *buffer = BaseFileManager::getEngineInstance()->readWholeFile(filename);
+	char *buffer = (char *)BaseFileManager::getEngineInstance()->readWholeFile(filename);
 	if (buffer == nullptr) {
 		_gameRef->LOG(0, "AdScaleLevel::LoadFile failed for file '%s'", filename);
 		return STATUS_FAILED;
@@ -83,7 +83,7 @@ TOKEN_DEF(SCALE)
 TOKEN_DEF(EDITOR_PROPERTY)
 TOKEN_DEF_END
 //////////////////////////////////////////////////////////////////////////
-bool AdScaleLevel::loadBuffer(byte *buffer, bool complete) {
+bool AdScaleLevel::loadBuffer(char *buffer, bool complete) {
 	TOKEN_TABLE_START(commands)
 	TOKEN_TABLE(SCALE_LEVEL)
 	TOKEN_TABLE(TEMPLATE)
@@ -92,33 +92,33 @@ bool AdScaleLevel::loadBuffer(byte *buffer, bool complete) {
 	TOKEN_TABLE(EDITOR_PROPERTY)
 	TOKEN_TABLE_END
 
-	byte *params;
+	char *params;
 	int cmd;
 	BaseParser parser;
 
 	if (complete) {
-		if (parser.getCommand((char **)&buffer, commands, (char **)&params) != TOKEN_SCALE_LEVEL) {
+		if (parser.getCommand(&buffer, commands, &params) != TOKEN_SCALE_LEVEL) {
 			_gameRef->LOG(0, "'SCALE_LEVEL' keyword expected.");
 			return STATUS_FAILED;
 		}
 		buffer = params;
 	}
 
-	while ((cmd = parser.getCommand((char **)&buffer, commands, (char **)&params)) > 0) {
+	while ((cmd = parser.getCommand(&buffer, commands, &params)) > 0) {
 		switch (cmd) {
 		case TOKEN_TEMPLATE:
-			if (DID_FAIL(loadFile((char *)params))) {
+			if (DID_FAIL(loadFile(params))) {
 				cmd = PARSERR_GENERIC;
 			}
 			break;
 
 		case TOKEN_Y:
-			parser.scanStr((char *)params, "%d", &_posY);
+			parser.scanStr(params, "%d", &_posY);
 			break;
 
 		case TOKEN_SCALE: {
 			int i;
-			parser.scanStr((char *)params, "%d", &i);
+			parser.scanStr(params, "%d", &i);
 			_scale = (float)i;
 		}
 		break;
diff --git a/engines/wintermute/ad/ad_scale_level.h b/engines/wintermute/ad/ad_scale_level.h
index b2dd7aa91f..768e79bbf7 100644
--- a/engines/wintermute/ad/ad_scale_level.h
+++ b/engines/wintermute/ad/ad_scale_level.h
@@ -41,7 +41,7 @@ public:
 	virtual ~AdScaleLevel();
 	virtual bool saveAsText(BaseDynamicBuffer *buffer, int indent) override;
 	bool loadFile(const char *filename);
-	bool loadBuffer(byte *buffer, bool complete = true);
+	bool loadBuffer(char *buffer, bool complete = true);
 	float getScale() const;
 private:
 	float _scale;
diff --git a/engines/wintermute/ad/ad_scene.cpp b/engines/wintermute/ad/ad_scene.cpp
index 46badee92b..f5726cd7ad 100644
--- a/engines/wintermute/ad/ad_scene.cpp
+++ b/engines/wintermute/ad/ad_scene.cpp
@@ -538,7 +538,7 @@ bool AdScene::initLoop() {
 
 //////////////////////////////////////////////////////////////////////////
 bool AdScene::loadFile(const char *filename) {
-	byte *buffer = BaseFileManager::getEngineInstance()->readWholeFile(filename);
+	char *buffer = (char *)BaseFileManager::getEngineInstance()->readWholeFile(filename);
 	if (buffer == nullptr) {
 		_gameRef->LOG(0, "AdScene::LoadFile failed for file '%s'", filename);
 		return STATUS_FAILED;
@@ -600,7 +600,7 @@ TOKEN_DEF(PERSISTENT_STATE)
 TOKEN_DEF(EDITOR_PROPERTY)
 TOKEN_DEF_END
 //////////////////////////////////////////////////////////////////////////
-bool AdScene::loadBuffer(byte *buffer, bool complete) {
+bool AdScene::loadBuffer(char *buffer, bool complete) {
 	TOKEN_TABLE_START(commands)
 	TOKEN_TABLE(SCENE)
 	TOKEN_TABLE(TEMPLATE)
@@ -643,12 +643,12 @@ bool AdScene::loadBuffer(byte *buffer, bool complete) {
 
 	cleanup();
 
-	byte *params;
+	char *params;
 	int cmd;
 	BaseParser parser;
 
 	if (complete) {
-		if (parser.getCommand((char **)&buffer, commands, (char **)&params) != TOKEN_SCENE) {
+		if (parser.getCommand(&buffer, commands, &params) != TOKEN_SCENE) {
 			_gameRef->LOG(0, "'SCENE' keyword expected.");
 			return STATUS_FAILED;
 		}
@@ -659,20 +659,20 @@ bool AdScene::loadBuffer(byte *buffer, bool complete) {
 	char camera[MAX_PATH_LENGTH] = "";
 	/* float waypointHeight = -1.0f; */
 
-	while ((cmd = parser.getCommand((char **)&buffer, commands, (char **)&params)) > 0) {
+	while ((cmd = parser.getCommand(&buffer, commands, &params)) > 0) {
 		switch (cmd) {
 		case TOKEN_TEMPLATE:
-			if (DID_FAIL(loadFile((char *)params))) {
+			if (DID_FAIL(loadFile(params))) {
 				cmd = PARSERR_GENERIC;
 			}
 			break;
 
 		case TOKEN_NAME:
-			setName((char *)params);
+			setName(params);
 			break;
 
 		case TOKEN_CAPTION:
-			setCaption((char *)params);
+			setCaption(params);
 			break;
 
 		case TOKEN_LAYER: {
@@ -747,7 +747,7 @@ bool AdScene::loadBuffer(byte *buffer, bool complete) {
 		case TOKEN_CURSOR:
 			delete _cursor;
 			_cursor = new BaseSprite(_gameRef);
-			if (!_cursor || DID_FAIL(_cursor->loadFile((char *)params))) {
+			if (!_cursor || DID_FAIL(_cursor->loadFile(params))) {
 				delete _cursor;
 				_cursor = nullptr;
 				cmd = PARSERR_GENERIC;
@@ -755,99 +755,99 @@ bool AdScene::loadBuffer(byte *buffer, bool complete) {
 			break;
 
 		case TOKEN_CAMERA:
-			Common::strlcpy(camera, (char *)params, MAX_PATH_LENGTH);
+			Common::strlcpy(camera, params, MAX_PATH_LENGTH);
 			break;
 
 		case TOKEN_EDITOR_MARGIN_H:
-			parser.scanStr((char *)params, "%d", &_editorMarginH);
+			parser.scanStr(params, "%d", &_editorMarginH);
 			break;
 
 		case TOKEN_EDITOR_MARGIN_V:
-			parser.scanStr((char *)params, "%d", &_editorMarginV);
+			parser.scanStr(params, "%d", &_editorMarginV);
 			break;
 
 		case TOKEN_EDITOR_COLOR_FRAME:
-			parser.scanStr((char *)params, "%d,%d,%d,%d", &ar, &ag, &ab, &aa);
+			parser.scanStr(params, "%d,%d,%d,%d", &ar, &ag, &ab, &aa);
 			_editorColFrame = BYTETORGBA(ar, ag, ab, aa);
 			break;
 
 		case TOKEN_EDITOR_COLOR_ENTITY:
-			parser.scanStr((char *)params, "%d,%d,%d,%d", &ar, &ag, &ab, &aa);
+			parser.scanStr(params, "%d,%d,%d,%d", &ar, &ag, &ab, &aa);
 			_editorColEntity = BYTETORGBA(ar, ag, ab, aa);
 			break;
 
 		case TOKEN_EDITOR_COLOR_ENTITY_SEL:
-			parser.scanStr((char *)params, "%d,%d,%d,%d", &ar, &ag, &ab, &aa);
+			parser.scanStr(params, "%d,%d,%d,%d", &ar, &ag, &ab, &aa);
 			_editorColEntitySel = BYTETORGBA(ar, ag, ab, aa);
 			break;
 
 		case TOKEN_EDITOR_COLOR_REGION_SEL:
-			parser.scanStr((char *)params, "%d,%d,%d,%d", &ar, &ag, &ab, &aa);
+			parser.scanStr(params, "%d,%d,%d,%d", &ar, &ag, &ab, &aa);
 			_editorColRegionSel = BYTETORGBA(ar, ag, ab, aa);
 			break;
 
 		case TOKEN_EDITOR_COLOR_DECORATION_SEL:
-			parser.scanStr((char *)params, "%d,%d,%d,%d", &ar, &ag, &ab, &aa);
+			parser.scanStr(params, "%d,%d,%d,%d", &ar, &ag, &ab, &aa);
 			_editorColDecorSel = BYTETORGBA(ar, ag, ab, aa);
 			break;
 
 		case TOKEN_EDITOR_COLOR_BLOCKED_SEL:
-			parser.scanStr((char *)params, "%d,%d,%d,%d", &ar, &ag, &ab, &aa);
+			parser.scanStr(params, "%d,%d,%d,%d", &ar, &ag, &ab, &aa);
 			_editorColBlockedSel = BYTETORGBA(ar, ag, ab, aa);
 			break;
 
 		case TOKEN_EDITOR_COLOR_WAYPOINTS_SEL:
-			parser.scanStr((char *)params, "%d,%d,%d,%d", &ar, &ag, &ab, &aa);
+			parser.scanStr(params, "%d,%d,%d,%d", &ar, &ag, &ab, &aa);
 			_editorColWaypointsSel = BYTETORGBA(ar, ag, ab, aa);
 			break;
 
 		case TOKEN_EDITOR_COLOR_REGION:
-			parser.scanStr((char *)params, "%d,%d,%d,%d", &ar, &ag, &ab, &aa);
+			parser.scanStr(params, "%d,%d,%d,%d", &ar, &ag, &ab, &aa);
 			_editorColRegion = BYTETORGBA(ar, ag, ab, aa);
 			break;
 
 		case TOKEN_EDITOR_COLOR_DECORATION:
-			parser.scanStr((char *)params, "%d,%d,%d,%d", &ar, &ag, &ab, &aa);
+			parser.scanStr(params, "%d,%d,%d,%d", &ar, &ag, &ab, &aa);
 			_editorColDecor = BYTETORGBA(ar, ag, ab, aa);
 			break;
 
 		case TOKEN_EDITOR_COLOR_BLOCKED:
-			parser.scanStr((char *)params, "%d,%d,%d,%d", &ar, &ag, &ab, &aa);
+			parser.scanStr(params, "%d,%d,%d,%d", &ar, &ag, &ab, &aa);
 			_editorColBlocked = BYTETORGBA(ar, ag, ab, aa);
 			break;
 
 		case TOKEN_EDITOR_COLOR_WAYPOINTS:
-			parser.scanStr((char *)params, "%d,%d,%d,%d", &ar, &ag, &ab, &aa);
+			parser.scanStr(params, "%d,%d,%d,%d", &ar, &ag, &ab, &aa);
 			_editorColWaypoints = BYTETORGBA(ar, ag, ab, aa);
 			break;
 
 		case TOKEN_EDITOR_COLOR_SCALE:
-			parser.scanStr((char *)params, "%d,%d,%d,%d", &ar, &ag, &ab, &aa);
+			parser.scanStr(params, "%d,%d,%d,%d", &ar, &ag, &ab, &aa);
 			_editorColScale = BYTETORGBA(ar, ag, ab, aa);
 			break;
 
 		case TOKEN_EDITOR_SHOW_REGIONS:
-			parser.scanStr((char *)params, "%b", &_editorShowRegions);
+			parser.scanStr(params, "%b", &_editorShowRegions);
 			break;
 
 		case TOKEN_EDITOR_SHOW_BLOCKED:
-			parser.scanStr((char *)params, "%b", &_editorShowBlocked);
+			parser.scanStr(params, "%b", &_editorShowBlocked);
 			break;
 
 		case TOKEN_EDITOR_SHOW_DECORATION:
-			parser.scanStr((char *)params, "%b", &_editorShowDecor);
+			parser.scanStr(params, "%b", &_editorShowDecor);
 			break;
 
 		case TOKEN_EDITOR_SHOW_ENTITIES:
-			parser.scanStr((char *)params, "%b", &_editorShowEntities);
+			parser.scanStr(params, "%b", &_editorShowEntities);
 			break;
 
 		case TOKEN_EDITOR_SHOW_SCALE:
-			parser.scanStr((char *)params, "%b", &_editorShowScale);
+			parser.scanStr(params, "%b", &_editorShowScale);
 			break;
 
 		case TOKEN_SCRIPT:
-			addScript((char *)params);
+			addScript(params);
 			break;
 
 		case TOKEN_PROPERTY:
@@ -856,7 +856,7 @@ bool AdScene::loadBuffer(byte *buffer, bool complete) {
 
 		case TOKEN_VIEWPORT: {
 			Rect32 rc;
-			parser.scanStr((char *)params, "%d,%d,%d,%d", &rc.left, &rc.top, &rc.right, &rc.bottom);
+			parser.scanStr(params, "%d,%d,%d,%d", &rc.left, &rc.top, &rc.right, &rc.bottom);
 			if (!_viewport) {
 				_viewport = new BaseViewport(_gameRef);
 			}
@@ -866,11 +866,11 @@ bool AdScene::loadBuffer(byte *buffer, bool complete) {
 		}
 
 		case TOKEN_PERSISTENT_STATE:
-			parser.scanStr((char *)params, "%b", &_persistentState);
+			parser.scanStr(params, "%b", &_persistentState);
 			break;
 
 		case TOKEN_PERSISTENT_STATE_SPRITES:
-			parser.scanStr((char *)params, "%b", &_persistentStateSprites);
+			parser.scanStr(params, "%b", &_persistentStateSprites);
 			break;
 
 		case TOKEN_EDITOR_PROPERTY:
diff --git a/engines/wintermute/ad/ad_scene.h b/engines/wintermute/ad/ad_scene.h
index 5beb10e546..1f35a776b5 100644
--- a/engines/wintermute/ad/ad_scene.h
+++ b/engines/wintermute/ad/ad_scene.h
@@ -124,7 +124,7 @@ public:
 	BaseArray<AdObject *> _objects;
 	BaseArray<AdWaypointGroup *> _waypointGroups;
 	bool loadFile(const char *filename);
-	bool loadBuffer(byte *buffer, bool complete = true);
+	bool loadBuffer(char *buffer, bool complete = true);
 	int32 _width;
 	int32 _height;
 	bool addObject(AdObject *Object);
diff --git a/engines/wintermute/ad/ad_sprite_set.cpp b/engines/wintermute/ad/ad_sprite_set.cpp
index 9eb3bd0686..dd920492de 100644
--- a/engines/wintermute/ad/ad_sprite_set.cpp
+++ b/engines/wintermute/ad/ad_sprite_set.cpp
@@ -60,7 +60,7 @@ AdSpriteSet::~AdSpriteSet() {
 
 //////////////////////////////////////////////////////////////////////////
 bool AdSpriteSet::loadFile(const char *filename, int lifeTime, TSpriteCacheType cacheType) {
-	byte *buffer = BaseFileManager::getEngineInstance()->readWholeFile(filename);
+	char *buffer = (char *)BaseFileManager::getEngineInstance()->readWholeFile(filename);
 	if (buffer == nullptr) {
 		_gameRef->LOG(0, "AdSpriteSet::LoadFile failed for file '%s'", filename);
 		return STATUS_FAILED;
@@ -93,7 +93,7 @@ TOKEN_DEF(TEMPLATE)
 TOKEN_DEF(EDITOR_PROPERTY)
 TOKEN_DEF_END
 //////////////////////////////////////////////////////////////////////////
-bool AdSpriteSet::loadBuffer(byte *buffer, bool complete, int lifeTime, TSpriteCacheType cacheType) {
+bool AdSpriteSet::loadBuffer(char *buffer, bool complete, int lifeTime, TSpriteCacheType cacheType) {
 	TOKEN_TABLE_START(commands)
 	TOKEN_TABLE(SPRITESET)
 	TOKEN_TABLE(NAME)
@@ -109,12 +109,12 @@ bool AdSpriteSet::loadBuffer(byte *buffer, bool complete, int lifeTime, TSpriteC
 	TOKEN_TABLE(EDITOR_PROPERTY)
 	TOKEN_TABLE_END
 
-	byte *params;
+	char *params;
 	int cmd;
 	BaseParser parser;
 
 	if (complete) {
-		if (parser.getCommand((char **)&buffer, commands, (char **)&params) != TOKEN_SPRITESET) {
+		if (parser.getCommand(&buffer, commands, &params) != TOKEN_SPRITESET) {
 			_gameRef->LOG(0, "'SPRITESET' keyword expected.");
 			return STATUS_FAILED;
 		}
@@ -122,23 +122,23 @@ bool AdSpriteSet::loadBuffer(byte *buffer, bool complete, int lifeTime, TSpriteC
 	}
 
 	BaseSprite *spr = nullptr;
-	while ((cmd = parser.getCommand((char **)&buffer, commands, (char **)&params)) > 0) {
+	while ((cmd = parser.getCommand(&buffer, commands, &params)) > 0) {
 		switch (cmd) {
 		case TOKEN_TEMPLATE:
-			if (DID_FAIL(loadFile((char *)params, lifeTime, cacheType))) {
+			if (DID_FAIL(loadFile(params, lifeTime, cacheType))) {
 				cmd = PARSERR_GENERIC;
 			}
 			break;
 
 		case TOKEN_NAME:
-			setName((char *)params);
+			setName(params);
 			break;
 
 		case TOKEN_LEFT:
 			delete _sprites[DI_LEFT];
 			_sprites[DI_LEFT] = nullptr;
 			spr = new BaseSprite(_gameRef,  _owner);
-			if (!spr || DID_FAIL(spr->loadFile((char *)params, lifeTime, cacheType))) {
+			if (!spr || DID_FAIL(spr->loadFile(params, lifeTime, cacheType))) {
 				cmd = PARSERR_GENERIC;
 			} else {
 				_sprites[DI_LEFT] = spr;
@@ -149,7 +149,7 @@ bool AdSpriteSet::loadBuffer(byte *buffer, bool complete, int lifeTime, TSpriteC
 			delete _sprites[DI_RIGHT];
 			_sprites[DI_RIGHT] = nullptr;
 			spr = new BaseSprite(_gameRef,  _owner);
-			if (!spr || DID_FAIL(spr->loadFile((char *)params, lifeTime, cacheType))) {
+			if (!spr || DID_FAIL(spr->loadFile(params, lifeTime, cacheType))) {
 				cmd = PARSERR_GENERIC;
 			} else {
 				_sprites[DI_RIGHT] = spr;
@@ -160,7 +160,7 @@ bool AdSpriteSet::loadBuffer(byte *buffer, bool complete, int lifeTime, TSpriteC
 			delete _sprites[DI_UP];
 			_sprites[DI_UP] = nullptr;
 			spr = new BaseSprite(_gameRef,  _owner);
-			if (!spr || DID_FAIL(spr->loadFile((char *)params, lifeTime, cacheType))) {
+			if (!spr || DID_FAIL(spr->loadFile(params, lifeTime, cacheType))) {
 				cmd = PARSERR_GENERIC;
 			} else {
 				_sprites[DI_UP] = spr;
@@ -171,7 +171,7 @@ bool AdSpriteSet::loadBuffer(byte *buffer, bool complete, int lifeTime, TSpriteC
 			delete _sprites[DI_DOWN];
 			_sprites[DI_DOWN] = nullptr;
 			spr = new BaseSprite(_gameRef,  _owner);
-			if (!spr || DID_FAIL(spr->loadFile((char *)params, lifeTime, cacheType))) {
+			if (!spr || DID_FAIL(spr->loadFile(params, lifeTime, cacheType))) {
 				cmd = PARSERR_GENERIC;
 			} else {
 				_sprites[DI_DOWN] = spr;
@@ -182,7 +182,7 @@ bool AdSpriteSet::loadBuffer(byte *buffer, bool complete, int lifeTime, TSpriteC
 			delete _sprites[DI_UPLEFT];
 			_sprites[DI_UPLEFT] = nullptr;
 			spr = new BaseSprite(_gameRef,  _owner);
-			if (!spr || DID_FAIL(spr->loadFile((char *)params, lifeTime, cacheType))) {
+			if (!spr || DID_FAIL(spr->loadFile(params, lifeTime, cacheType))) {
 				cmd = PARSERR_GENERIC;
 			} else {
 				_sprites[DI_UPLEFT] = spr;
@@ -193,7 +193,7 @@ bool AdSpriteSet::loadBuffer(byte *buffer, bool complete, int lifeTime, TSpriteC
 			delete _sprites[DI_UPRIGHT];
 			_sprites[DI_UPRIGHT] = nullptr;
 			spr = new BaseSprite(_gameRef,  _owner);
-			if (!spr || DID_FAIL(spr->loadFile((char *)params, lifeTime, cacheType))) {
+			if (!spr || DID_FAIL(spr->loadFile(params, lifeTime, cacheType))) {
 				cmd = PARSERR_GENERIC;
 			} else {
 				_sprites[DI_UPRIGHT] = spr;
@@ -204,7 +204,7 @@ bool AdSpriteSet::loadBuffer(byte *buffer, bool complete, int lifeTime, TSpriteC
 			delete _sprites[DI_DOWNLEFT];
 			_sprites[DI_DOWNLEFT] = nullptr;
 			spr = new BaseSprite(_gameRef,  _owner);
-			if (!spr || DID_FAIL(spr->loadFile((char *)params, lifeTime, cacheType))) {
+			if (!spr || DID_FAIL(spr->loadFile(params, lifeTime, cacheType))) {
 				cmd = PARSERR_GENERIC;
 			} else {
 				_sprites[DI_DOWNLEFT] = spr;
@@ -215,7 +215,7 @@ bool AdSpriteSet::loadBuffer(byte *buffer, bool complete, int lifeTime, TSpriteC
 			delete _sprites[DI_DOWNRIGHT];
 			_sprites[DI_DOWNRIGHT] = nullptr;
 			spr = new BaseSprite(_gameRef,  _owner);
-			if (!spr || DID_FAIL(spr->loadFile((char *)params, lifeTime, cacheType))) {
+			if (!spr || DID_FAIL(spr->loadFile(params, lifeTime, cacheType))) {
 				cmd = PARSERR_GENERIC;
 			} else {
 				_sprites[DI_DOWNRIGHT] = spr;
diff --git a/engines/wintermute/ad/ad_sprite_set.h b/engines/wintermute/ad/ad_sprite_set.h
index ef5ef3a94f..ece71f7adb 100644
--- a/engines/wintermute/ad/ad_sprite_set.h
+++ b/engines/wintermute/ad/ad_sprite_set.h
@@ -44,7 +44,7 @@ public:
 	AdSpriteSet(BaseGame *inGame, BaseObject *owner = nullptr);
 	virtual ~AdSpriteSet();
 	bool loadFile(const char *filename, int lifeTime = -1, TSpriteCacheType cacheType = CACHE_ALL);
-	bool loadBuffer(byte *buffer, bool complete = true, int lifeTime = -1, TSpriteCacheType cacheType = CACHE_ALL);
+	bool loadBuffer(char *buffer, bool complete = true, int lifeTime = -1, TSpriteCacheType cacheType = CACHE_ALL);
 	BaseSprite *_sprites[NUM_DIRECTIONS];
 };
 
diff --git a/engines/wintermute/ad/ad_talk_def.cpp b/engines/wintermute/ad/ad_talk_def.cpp
index f10a0e2fb9..1fdeed418f 100644
--- a/engines/wintermute/ad/ad_talk_def.cpp
+++ b/engines/wintermute/ad/ad_talk_def.cpp
@@ -71,7 +71,7 @@ AdTalkDef::~AdTalkDef() {
 
 //////////////////////////////////////////////////////////////////////////
 bool AdTalkDef::loadFile(const char *filename) {
-	byte *buffer = BaseFileManager::getEngineInstance()->readWholeFile(filename);
+	char *buffer = (char *)BaseFileManager::getEngineInstance()->readWholeFile(filename);
 	if (buffer == nullptr) {
 		_gameRef->LOG(0, "AdTalkDef::LoadFile failed for file '%s'", filename);
 		return STATUS_FAILED;
@@ -101,7 +101,7 @@ TOKEN_DEF(DEFAULT_SPRITE)
 TOKEN_DEF(EDITOR_PROPERTY)
 TOKEN_DEF_END
 //////////////////////////////////////////////////////////////////////////
-bool AdTalkDef::loadBuffer(byte *buffer, bool complete) {
+bool AdTalkDef::loadBuffer(char *buffer, bool complete) {
 	TOKEN_TABLE_START(commands)
 	TOKEN_TABLE(TALK)
 	TOKEN_TABLE(TEMPLATE)
@@ -112,22 +112,22 @@ bool AdTalkDef::loadBuffer(byte *buffer, bool complete) {
 	TOKEN_TABLE(EDITOR_PROPERTY)
 	TOKEN_TABLE_END
 
-	byte *params;
+	char *params;
 	int cmd;
 	BaseParser parser;
 
 	if (complete) {
-		if (parser.getCommand((char **)&buffer, commands, (char **)&params) != TOKEN_TALK) {
+		if (parser.getCommand(&buffer, commands, &params) != TOKEN_TALK) {
 			_gameRef->LOG(0, "'TALK' keyword expected.");
 			return STATUS_FAILED;
 		}
 		buffer = params;
 	}
 
-	while ((cmd = parser.getCommand((char **)&buffer, commands, (char **)&params)) > 0) {
+	while ((cmd = parser.getCommand(&buffer, commands, &params)) > 0) {
 		switch (cmd) {
 		case TOKEN_TEMPLATE:
-			if (DID_FAIL(loadFile((char *)params))) {
+			if (DID_FAIL(loadFile(params))) {
 				cmd = PARSERR_GENERIC;
 			}
 			break;
@@ -145,11 +145,11 @@ bool AdTalkDef::loadBuffer(byte *buffer, bool complete) {
 		break;
 
 		case TOKEN_DEFAULT_SPRITE:
-			BaseUtils::setString(&_defaultSpriteFilename, (char *)params);
+			BaseUtils::setString(&_defaultSpriteFilename, params);
 			break;
 
 		case TOKEN_DEFAULT_SPRITESET_FILE:
-			BaseUtils::setString(&_defaultSpriteSetFilename, (char *)params);
+			BaseUtils::setString(&_defaultSpriteSetFilename, params);
 			break;
 
 		case TOKEN_DEFAULT_SPRITESET: {
diff --git a/engines/wintermute/ad/ad_talk_def.h b/engines/wintermute/ad/ad_talk_def.h
index 726eefbe4c..5711906b4b 100644
--- a/engines/wintermute/ad/ad_talk_def.h
+++ b/engines/wintermute/ad/ad_talk_def.h
@@ -46,7 +46,7 @@ public:
 	AdTalkDef(BaseGame *inGame);
 	virtual ~AdTalkDef();
 	bool loadFile(const char *filename);
-	bool loadBuffer(byte *buffer, bool complete = true);
+	bool loadBuffer(char *buffer, bool complete = true);
 	BaseArray<AdTalkNode *> _nodes;
 	char *_defaultSpriteFilename;
 	BaseSprite *_defaultSprite;
diff --git a/engines/wintermute/ad/ad_talk_node.cpp b/engines/wintermute/ad/ad_talk_node.cpp
index ce86dccd8e..eca4535288 100644
--- a/engines/wintermute/ad/ad_talk_node.cpp
+++ b/engines/wintermute/ad/ad_talk_node.cpp
@@ -79,7 +79,7 @@ TOKEN_DEF(PRECACHE)
 TOKEN_DEF(EDITOR_PROPERTY)
 TOKEN_DEF_END
 //////////////////////////////////////////////////////////////////////////
-bool AdTalkNode::loadBuffer(byte *buffer, bool complete) {
+bool AdTalkNode::loadBuffer(char *buffer, bool complete) {
 	TOKEN_TABLE_START(commands)
 	TOKEN_TABLE(ACTION)
 	TOKEN_TABLE(SPRITESET_FILE)
@@ -92,12 +92,12 @@ bool AdTalkNode::loadBuffer(byte *buffer, bool complete) {
 	TOKEN_TABLE(EDITOR_PROPERTY)
 	TOKEN_TABLE_END
 
-	byte *params;
+	char *params;
 	int cmd;
 	BaseParser parser;
 
 	if (complete) {
-		if (parser.getCommand((char **)&buffer, commands, (char **)&params) != TOKEN_ACTION) {
+		if (parser.getCommand(&buffer, commands, &params) != TOKEN_ACTION) {
 			_gameRef->LOG(0, "'ACTION' keyword expected.");
 			return STATUS_FAILED;
 		}
@@ -108,14 +108,14 @@ bool AdTalkNode::loadBuffer(byte *buffer, bool complete) {
 	_playToEnd = false;
 	_preCache = false;
 
-	while ((cmd = parser.getCommand((char **)&buffer, commands, (char **)&params)) > 0) {
+	while ((cmd = parser.getCommand(&buffer, commands, &params)) > 0) {
 		switch (cmd) {
 		case TOKEN_SPRITE:
-			BaseUtils::setString(&_spriteFilename, (char *)params);
+			BaseUtils::setString(&_spriteFilename, params);
 			break;
 
 		case TOKEN_SPRITESET_FILE:
-			BaseUtils::setString(&_spriteSetFilename, (char *)params);
+			BaseUtils::setString(&_spriteSetFilename, params);
 			break;
 
 		case TOKEN_SPRITESET: {
@@ -130,20 +130,20 @@ bool AdTalkNode::loadBuffer(byte *buffer, bool complete) {
 		break;
 
 		case TOKEN_START_TIME:
-			parser.scanStr((char *)params, "%d", &_startTime);
+			parser.scanStr(params, "%d", &_startTime);
 			break;
 
 		case TOKEN_END_TIME:
-			parser.scanStr((char *)params, "%d", &_endTime);
+			parser.scanStr(params, "%d", &_endTime);
 			break;
 
 		case TOKEN_PRECACHE:
-			parser.scanStr((char *)params, "%b", &_preCache);
+			parser.scanStr(params, "%b", &_preCache);
 			break;
 
 		case TOKEN_COMMENT:
 			if (_gameRef->_editorMode) {
-				BaseUtils::setString(&_comment, (char *)params);
+				BaseUtils::setString(&_comment, params);
 			}
 			break;
 
diff --git a/engines/wintermute/ad/ad_talk_node.h b/engines/wintermute/ad/ad_talk_node.h
index 01dfb6b4ff..7a014b2d9f 100644
--- a/engines/wintermute/ad/ad_talk_node.h
+++ b/engines/wintermute/ad/ad_talk_node.h
@@ -46,7 +46,7 @@ public:
 
 	AdTalkNode(BaseGame *inGame);
 	virtual ~AdTalkNode();
-	bool loadBuffer(byte *buffer, bool complete = true);
+	bool loadBuffer(char *buffer, bool complete = true);
 	virtual bool saveAsText(BaseDynamicBuffer *buffer, int indent = 0) override;
 	char *_spriteFilename;
 	BaseSprite *_sprite;
diff --git a/engines/wintermute/ad/ad_waypoint_group.cpp b/engines/wintermute/ad/ad_waypoint_group.cpp
index cc7982cb9d..f7735a4d9b 100644
--- a/engines/wintermute/ad/ad_waypoint_group.cpp
+++ b/engines/wintermute/ad/ad_waypoint_group.cpp
@@ -66,7 +66,7 @@ void AdWaypointGroup::cleanup() {
 
 //////////////////////////////////////////////////////////////////////////
 bool AdWaypointGroup::loadFile(const char *filename) {
-	byte *buffer = BaseFileManager::getEngineInstance()->readWholeFile(filename);
+	char *buffer = (char *)BaseFileManager::getEngineInstance()->readWholeFile(filename);
 	if (buffer == nullptr) {
 		_gameRef->LOG(0, "AdWaypointGroup::LoadFile failed for file '%s'", filename);
 		return STATUS_FAILED;
@@ -98,7 +98,7 @@ TOKEN_DEF(PROPERTY)
 TOKEN_DEF(EDITOR_PROPERTY)
 TOKEN_DEF_END
 //////////////////////////////////////////////////////////////////////////
-bool AdWaypointGroup::loadBuffer(byte *buffer, bool complete) {
+bool AdWaypointGroup::loadBuffer(char *buffer, bool complete) {
 	TOKEN_TABLE_START(commands)
 	TOKEN_TABLE(WAYPOINTS)
 	TOKEN_TABLE(TEMPLATE)
@@ -110,43 +110,43 @@ bool AdWaypointGroup::loadBuffer(byte *buffer, bool complete) {
 	TOKEN_TABLE(EDITOR_PROPERTY)
 	TOKEN_TABLE_END
 
-	byte *params;
+	char *params;
 	int cmd;
 	BaseParser parser;
 
 	if (complete) {
-		if (parser.getCommand((char **)&buffer, commands, (char **)&params) != TOKEN_WAYPOINTS) {
+		if (parser.getCommand(&buffer, commands, &params) != TOKEN_WAYPOINTS) {
 			_gameRef->LOG(0, "'WAYPOINTS' keyword expected.");
 			return STATUS_FAILED;
 		}
 		buffer = params;
 	}
 
-	while ((cmd = parser.getCommand((char **)&buffer, commands, (char **)&params)) > 0) {
+	while ((cmd = parser.getCommand(&buffer, commands, &params)) > 0) {
 		switch (cmd) {
 		case TOKEN_TEMPLATE:
-			if (DID_FAIL(loadFile((char *)params))) {
+			if (DID_FAIL(loadFile(params))) {
 				cmd = PARSERR_GENERIC;
 			}
 			break;
 
 		case TOKEN_NAME:
-			setName((char *)params);
+			setName(params);
 			break;
 
 		case TOKEN_POINT: {
 			int x, y;
-			parser.scanStr((char *)params, "%d,%d", &x, &y);
+			parser.scanStr(params, "%d,%d", &x, &y);
 			_points.add(new BasePoint(x, y));
 		}
 		break;
 
 		case TOKEN_EDITOR_SELECTED:
-			parser.scanStr((char *)params, "%b", &_editorSelected);
+			parser.scanStr(params, "%b", &_editorSelected);
 			break;
 
 		case TOKEN_EDITOR_SELECTED_POINT:
-			parser.scanStr((char *)params, "%d", &_editorSelectedPoint);
+			parser.scanStr(params, "%d", &_editorSelectedPoint);
 			break;
 
 		case TOKEN_PROPERTY:
diff --git a/engines/wintermute/ad/ad_waypoint_group.h b/engines/wintermute/ad/ad_waypoint_group.h
index af97a21290..47fd611be6 100644
--- a/engines/wintermute/ad/ad_waypoint_group.h
+++ b/engines/wintermute/ad/ad_waypoint_group.h
@@ -41,7 +41,7 @@ public:
 	virtual bool saveAsText(BaseDynamicBuffer *buffer, int indent) override;
 	AdWaypointGroup(BaseGame *inGame);
 	bool loadFile(const char *filename);
-	bool loadBuffer(byte *buffer, bool complete = true);
+	bool loadBuffer(char *buffer, bool complete = true);
 	virtual ~AdWaypointGroup();
 
 	bool _active;