[Scummvm-git-logs] scummvm master -> 924dc6c7697b90b6036985074540a05010da91b7

[aquadran]

This automated email contains information about 1 new commit which have been
pushed to the 'scummvm' repo located at https://api.github.com/repos/scummvm/scummvm .

Summary:
924dc6c769 WINTERMUTE: Restore original variable name


Commit: 924dc6c7697b90b6036985074540a05010da91b7
    https://github.com/scummvm/scummvm/commit/924dc6c7697b90b6036985074540a05010da91b7
Author: Paweł Kołodziejski (aquadran at gmail.com)
Date: 2025-09-03T18:43:36+02:00

Commit Message:
WINTERMUTE: Restore original variable name

Changed paths:
    engines/wintermute/ad/ad_actor.cpp
    engines/wintermute/ad/ad_actor_3dx.cpp
    engines/wintermute/ad/ad_attach_3dx.cpp
    engines/wintermute/ad/ad_entity.cpp
    engines/wintermute/ad/ad_game.cpp
    engines/wintermute/ad/ad_geom_ext.cpp
    engines/wintermute/ad/ad_geom_ext_node.cpp
    engines/wintermute/ad/ad_inventory.cpp
    engines/wintermute/ad/ad_inventory_box.cpp
    engines/wintermute/ad/ad_item.cpp
    engines/wintermute/ad/ad_layer.cpp
    engines/wintermute/ad/ad_node_state.cpp
    engines/wintermute/ad/ad_object.cpp
    engines/wintermute/ad/ad_object_3d.cpp
    engines/wintermute/ad/ad_path.cpp
    engines/wintermute/ad/ad_path3d.cpp
    engines/wintermute/ad/ad_region.cpp
    engines/wintermute/ad/ad_response.cpp
    engines/wintermute/ad/ad_response_box.cpp
    engines/wintermute/ad/ad_response_context.cpp
    engines/wintermute/ad/ad_rot_level.cpp
    engines/wintermute/ad/ad_scale_level.cpp
    engines/wintermute/ad/ad_scene.cpp
    engines/wintermute/ad/ad_scene_geometry.cpp
    engines/wintermute/ad/ad_scene_node.cpp
    engines/wintermute/ad/ad_scene_state.cpp
    engines/wintermute/ad/ad_sentence.cpp
    engines/wintermute/ad/ad_sprite_set.cpp
    engines/wintermute/ad/ad_talk_def.cpp
    engines/wintermute/ad/ad_talk_holder.cpp
    engines/wintermute/ad/ad_talk_node.cpp
    engines/wintermute/ad/ad_waypoint_group.cpp
    engines/wintermute/base/base.cpp
    engines/wintermute/base/base.h
    engines/wintermute/base/base_active_rect.cpp
    engines/wintermute/base/base_engine.h
    engines/wintermute/base/base_frame.cpp
    engines/wintermute/base/base_game.cpp
    engines/wintermute/base/base_object.cpp
    engines/wintermute/base/base_script_holder.cpp
    engines/wintermute/base/base_scriptable.cpp
    engines/wintermute/base/base_sprite.cpp
    engines/wintermute/base/base_string_table.cpp
    engines/wintermute/base/base_sub_frame.cpp
    engines/wintermute/base/base_surface_storage.cpp
    engines/wintermute/base/base_transition_manager.cpp
    engines/wintermute/base/base_viewport.cpp
    engines/wintermute/base/font/base_font_bitmap.cpp
    engines/wintermute/base/font/base_font_storage.cpp
    engines/wintermute/base/font/base_font_truetype.cpp
    engines/wintermute/base/gfx/3dlight.cpp
    engines/wintermute/base/gfx/3dmesh.cpp
    engines/wintermute/base/gfx/base_renderer3d.cpp
    engines/wintermute/base/gfx/base_surface.cpp
    engines/wintermute/base/gfx/opengl/base_render_opengl3d.cpp
    engines/wintermute/base/gfx/opengl/base_render_opengl3d_shader.cpp
    engines/wintermute/base/gfx/opengl/meshx_opengl.cpp
    engines/wintermute/base/gfx/opengl/meshx_opengl_shader.cpp
    engines/wintermute/base/gfx/opengl/shadow_volume_opengl.cpp
    engines/wintermute/base/gfx/opengl/shadow_volume_opengl_shader.cpp
    engines/wintermute/base/gfx/osystem/base_render_osystem.cpp
    engines/wintermute/base/gfx/osystem/base_surface_osystem.cpp
    engines/wintermute/base/gfx/osystem/render_ticket.cpp
    engines/wintermute/base/gfx/xactive_animation.cpp
    engines/wintermute/base/gfx/xanimation_channel.cpp
    engines/wintermute/base/gfx/xanimation_set.cpp
    engines/wintermute/base/gfx/xframe_node.cpp
    engines/wintermute/base/gfx/xmaterial.cpp
    engines/wintermute/base/gfx/xmesh.cpp
    engines/wintermute/base/gfx/xmodel.cpp
    engines/wintermute/base/particles/part_emitter.cpp
    engines/wintermute/base/particles/part_particle.cpp
    engines/wintermute/base/scriptables/debuggable/debuggable_script.cpp
    engines/wintermute/base/scriptables/script.cpp
    engines/wintermute/base/scriptables/script_engine.cpp
    engines/wintermute/base/scriptables/script_ext_array.cpp
    engines/wintermute/base/scriptables/script_ext_directory.cpp
    engines/wintermute/base/scriptables/script_ext_mem_buffer.cpp
    engines/wintermute/base/scriptables/script_ext_string.cpp
    engines/wintermute/base/scriptables/script_stack.cpp
    engines/wintermute/base/scriptables/script_value.cpp
    engines/wintermute/base/sound/base_sound.cpp
    engines/wintermute/base/sound/base_sound_buffer.cpp
    engines/wintermute/base/sound/base_sound_manager.cpp
    engines/wintermute/debugger/watch_instance.cpp
    engines/wintermute/ext/wme_3fstatistics.cpp
    engines/wintermute/ext/wme_blackandwhite.cpp
    engines/wintermute/ext/wme_commandlinehelper.cpp
    engines/wintermute/ext/wme_shadowmanager.cpp
    engines/wintermute/ext/wme_vlink.cpp
    engines/wintermute/platform_osystem.cpp
    engines/wintermute/platform_osystem.h
    engines/wintermute/ui/ui_button.cpp
    engines/wintermute/ui/ui_edit.cpp
    engines/wintermute/ui/ui_entity.cpp
    engines/wintermute/ui/ui_object.cpp
    engines/wintermute/ui/ui_text.cpp
    engines/wintermute/ui/ui_tiled_image.cpp
    engines/wintermute/ui/ui_window.cpp
    engines/wintermute/video/video_player.cpp
    engines/wintermute/video/video_subtitler.cpp
    engines/wintermute/video/video_theora_player.cpp
    engines/wintermute/wintermute.cpp


diff --git a/engines/wintermute/ad/ad_actor.cpp b/engines/wintermute/ad/ad_actor.cpp
index 3c9d9e34a83..4fda047016b 100644
--- a/engines/wintermute/ad/ad_actor.cpp
+++ b/engines/wintermute/ad/ad_actor.cpp
@@ -53,7 +53,7 @@ IMPLEMENT_PERSISTENT(AdActor, false)
 
 //////////////////////////////////////////////////////////////////////////
 AdActor::AdActor(BaseGame *inGame) : AdTalkHolder(inGame) {
-	_path = new AdPath(_gameRef);
+	_path = new AdPath(_game);
 
 	_type = OBJECT_ACTOR;
 	_dir = DI_LEFT;
@@ -114,7 +114,7 @@ AdActor::~AdActor() {
 bool AdActor::loadFile(const char *filename) {
 	char *buffer = (char *)BaseFileManager::getEngineInstance()->readWholeFile(filename);
 	if (buffer == nullptr) {
-		_gameRef->LOG(0, "AdActor::LoadFile failed for file '%s'", filename);
+		_game->LOG(0, "AdActor::LoadFile failed for file '%s'", filename);
 		return STATUS_FAILED;
 	}
 
@@ -123,7 +123,7 @@ bool AdActor::loadFile(const char *filename) {
 	setFilename(filename);
 
 	if (DID_FAIL(ret = loadBuffer(buffer, true))) {
-		_gameRef->LOG(0, "Error parsing ACTOR file '%s'", filename);
+		_game->LOG(0, "Error parsing ACTOR file '%s'", filename);
 	}
 
 
@@ -218,13 +218,13 @@ bool AdActor::loadBuffer(char *buffer, bool complete) {
 
 	if (complete) {
 		if (parser.getCommand(&buffer, commands, &params) != TOKEN_ACTOR) {
-			_gameRef->LOG(0, "'ACTOR' keyword expected.");
+			_game->LOG(0, "'ACTOR' keyword expected.");
 			return STATUS_FAILED;
 		}
 		buffer = params;
 	}
 
-	AdGame *adGame = (AdGame *)_gameRef;
+	AdGame *adGame = (AdGame *)_game;
 	AdSpriteSet *spr = nullptr;
 	int ar = 0, ag = 0, ab = 0, alpha = 0;
 	while ((cmd = parser.getCommand(&buffer, commands, &params)) > 0) {
@@ -280,7 +280,7 @@ bool AdActor::loadBuffer(char *buffer, bool complete) {
 
 		case TOKEN_WALK:
 			SAFE_DELETE(_walkSprite);
-			spr = new AdSpriteSet(_gameRef, this);
+			spr = new AdSpriteSet(_game, this);
 			if (!spr || DID_FAIL(spr->loadBuffer(params, true, adGame->_texWalkLifeTime, CACHE_HALF))) {
 				cmd = PARSERR_GENERIC;
 			} else {
@@ -289,7 +289,7 @@ bool AdActor::loadBuffer(char *buffer, bool complete) {
 			break;
 
 		case TOKEN_TALK:
-			spr = new AdSpriteSet(_gameRef, this);
+			spr = new AdSpriteSet(_game, this);
 			if (!spr || DID_FAIL(spr->loadBuffer(params, true, adGame->_texTalkLifeTime))) {
 				cmd = PARSERR_GENERIC;
 			} else {
@@ -298,7 +298,7 @@ bool AdActor::loadBuffer(char *buffer, bool complete) {
 			break;
 
 		case TOKEN_TALK_SPECIAL:
-			spr = new AdSpriteSet(_gameRef, this);
+			spr = new AdSpriteSet(_game, this);
 			if (!spr || DID_FAIL(spr->loadBuffer(params, true, adGame->_texTalkLifeTime))) {
 				cmd = PARSERR_GENERIC;
 			} else {
@@ -308,7 +308,7 @@ bool AdActor::loadBuffer(char *buffer, bool complete) {
 
 		case TOKEN_STAND:
 			SAFE_DELETE(_standSprite);
-			spr = new AdSpriteSet(_gameRef, this);
+			spr = new AdSpriteSet(_game, this);
 			if (!spr || DID_FAIL(spr->loadBuffer(params, true, adGame->_texStandLifeTime))) {
 				cmd = PARSERR_GENERIC;
 			} else {
@@ -318,7 +318,7 @@ bool AdActor::loadBuffer(char *buffer, bool complete) {
 
 		case TOKEN_TURN_LEFT:
 			SAFE_DELETE(_turnLeftSprite);
-			spr = new AdSpriteSet(_gameRef, this);
+			spr = new AdSpriteSet(_game, this);
 			if (!spr || DID_FAIL(spr->loadBuffer(params, true))) {
 				cmd = PARSERR_GENERIC;
 			} else {
@@ -328,7 +328,7 @@ bool AdActor::loadBuffer(char *buffer, bool complete) {
 
 		case TOKEN_TURN_RIGHT:
 			SAFE_DELETE(_turnRightSprite);
-			spr = new AdSpriteSet(_gameRef, this);
+			spr = new AdSpriteSet(_game, this);
 			if (!spr || DID_FAIL(spr->loadBuffer(params, true))) {
 				cmd = PARSERR_GENERIC;
 			} else {
@@ -342,7 +342,7 @@ bool AdActor::loadBuffer(char *buffer, bool complete) {
 
 		case TOKEN_CURSOR:
 			SAFE_DELETE(_cursor);
-			_cursor = new BaseSprite(_gameRef);
+			_cursor = new BaseSprite(_game);
 			if (!_cursor || DID_FAIL(_cursor->loadFile(params))) {
 				SAFE_DELETE(_cursor);
 				cmd = PARSERR_GENERIC;
@@ -380,8 +380,8 @@ bool AdActor::loadBuffer(char *buffer, bool complete) {
 		case TOKEN_BLOCKED_REGION: {
 			SAFE_DELETE(_blockRegion);
 			SAFE_DELETE(_currentBlockRegion);
-			BaseRegion *rgn = new BaseRegion(_gameRef);
-			BaseRegion *crgn = new BaseRegion(_gameRef);
+			BaseRegion *rgn = new BaseRegion(_game);
+			BaseRegion *crgn = new BaseRegion(_game);
 			if (!rgn || !crgn || DID_FAIL(rgn->loadBuffer(params, false))) {
 				SAFE_DELETE(_blockRegion);
 				SAFE_DELETE(_currentBlockRegion);
@@ -397,8 +397,8 @@ bool AdActor::loadBuffer(char *buffer, bool complete) {
 		case TOKEN_WAYPOINTS: {
 			SAFE_DELETE(_wptGroup);
 			SAFE_DELETE(_currentWptGroup);
-			AdWaypointGroup *wpt = new AdWaypointGroup(_gameRef);
-			AdWaypointGroup *cwpt = new AdWaypointGroup(_gameRef);
+			AdWaypointGroup *wpt = new AdWaypointGroup(_game);
+			AdWaypointGroup *cwpt = new AdWaypointGroup(_game);
 			if (!wpt || !cwpt || DID_FAIL(wpt->loadBuffer(params, false))) {
 				SAFE_DELETE(_wptGroup);
 				SAFE_DELETE(_currentWptGroup);
@@ -428,7 +428,7 @@ bool AdActor::loadBuffer(char *buffer, bool complete) {
 			break;
 
 		case TOKEN_ANIMATION: {
-			AdSpriteSet *anim = new AdSpriteSet(_gameRef, this);
+			AdSpriteSet *anim = new AdSpriteSet(_game, this);
 			if (!anim || DID_FAIL(anim->loadBuffer(params, false))) {
 				cmd = PARSERR_GENERIC;
 			} else {
@@ -442,14 +442,14 @@ bool AdActor::loadBuffer(char *buffer, bool complete) {
 		}
 	}
 	if (cmd == PARSERR_TOKENNOTFOUND) {
-		_gameRef->LOG(0, "Syntax error in ACTOR definition");
+		_game->LOG(0, "Syntax error in ACTOR definition");
 		return STATUS_FAILED;
 	}
 	if (cmd == PARSERR_GENERIC) {
 		if (spr) {
 			delete spr;
 		}
-		_gameRef->LOG(0, "Error loading ACTOR definition");
+		_game->LOG(0, "Error loading ACTOR definition");
 		return STATUS_FAILED;
 	}
 
@@ -504,7 +504,7 @@ void AdActor::goTo(int x, int y, TDirection afterWalkDir) {
 	_targetPoint->x = x;
 	_targetPoint->y = y;
 
-	((AdGame *)_gameRef)->_scene->correctTargetPoint(_posX, _posY, &_targetPoint->x, &_targetPoint->y, true, this);
+	((AdGame *)_game)->_scene->correctTargetPoint(_posX, _posY, &_targetPoint->x, &_targetPoint->y, true, this);
 
 	_state = STATE_SEARCHING_PATH;
 
@@ -521,7 +521,7 @@ bool AdActor::display() {
 	if (_alphaColor != 0) {
 		alpha = _alphaColor;
 	} else {
-		alpha = _shadowable ? ((AdGame *)_gameRef)->_scene->getAlphaAt(_posX, _posY, true) : 0xFFFFFFFF;
+		alpha = _shadowable ? ((AdGame *)_game)->_scene->getAlphaAt(_posX, _posY, true) : 0xFFFFFFFF;
 	}
 
 	float scaleX, scaleY;
@@ -533,7 +533,7 @@ bool AdActor::display() {
 		if (_rotateValid) {
 			rotate = _rotate;
 		} else {
-			rotate = ((AdGame *)_gameRef)->_scene->getRotationAt(_posX, _posY) + _relativeRotate;
+			rotate = ((AdGame *)_game)->_scene->getRotationAt(_posX, _posY) + _relativeRotate;
 		}
 	} else {
 		rotate = 0.0f;
@@ -545,7 +545,7 @@ bool AdActor::display() {
 
 	if (_currentSprite && _active) {
 		bool reg = _registrable;
-		if (_ignoreItems && ((AdGame *)_gameRef)->_selectedItem) {
+		if (_ignoreItems && ((AdGame *)_game)->_selectedItem) {
 			reg = false;
 		}
 
@@ -727,7 +727,7 @@ bool AdActor::update() {
 		//////////////////////////////////////////////////////////////////////////
 	case STATE_SEARCHING_PATH:
 		// keep asking scene for the path
-		if (((AdGame *)_gameRef)->_scene->getPath(BasePoint(_posX, _posY), *_targetPoint, _path, this)) {
+		if (((AdGame *)_game)->_scene->getPath(BasePoint(_posX, _posY), *_targetPoint, _path, this)) {
 			_state = STATE_WAITING_PATH;
 		}
 		break;
@@ -755,7 +755,7 @@ bool AdActor::update() {
 			_tempSprite2 = _sentence->_currentSprite;
 		}
 
-		bool timeIsUp = (_sentence->_sound && _sentence->_soundStarted && (!_sentence->_sound->isPlaying() && !_sentence->_sound->isPaused())) || (!_sentence->_sound && _sentence->_duration <= _gameRef->getTimer()->getTime() - _sentence->_startTime);
+		bool timeIsUp = (_sentence->_sound && _sentence->_soundStarted && (!_sentence->_sound->isPlaying() && !_sentence->_sound->isPaused())) || (!_sentence->_sound && _sentence->_duration <= _game->getTimer()->getTime() - _sentence->_startTime);
 		if (_tempSprite2 == nullptr || _tempSprite2->_finished || (/*_tempSprite2->_looping &&*/ timeIsUp)) {
 			if (timeIsUp) {
 				_sentence->finish();
@@ -767,12 +767,12 @@ bool AdActor::update() {
 				if (_tempSprite2) {
 					_tempSprite2->reset();
 					_currentSprite = _tempSprite2;
-					((AdGame *)_gameRef)->addSentence(_sentence);
+					((AdGame *)_game)->addSentence(_sentence);
 				}
 			}
 		} else {
 			_currentSprite = _tempSprite2;
-			((AdGame *)_gameRef)->addSentence(_sentence);
+			((AdGame *)_game)->addSentence(_sentence);
 		}
 	}
 	break;
@@ -823,7 +823,7 @@ bool AdActor::update() {
 	}
 
 	if (_currentSprite && !already_moved) {
-		_currentSprite->getCurrentFrame(_zoomable ? ((AdGame *)_gameRef)->_scene->getZoomAt(_posX, _posY) : 100, _zoomable ? ((AdGame *)_gameRef)->_scene->getZoomAt(_posX, _posY) : 100);
+		_currentSprite->getCurrentFrame(_zoomable ? ((AdGame *)_game)->_scene->getZoomAt(_posX, _posY) : 100, _zoomable ? ((AdGame *)_game)->_scene->getZoomAt(_posX, _posY) : 100);
 		if (_currentSprite->_changed) {
 			_posX += _currentSprite->_moveX;
 			_posY += _currentSprite->_moveY;
@@ -831,7 +831,7 @@ bool AdActor::update() {
 		}
 	}
 
-	//_gameRef->QuickMessageForm("%s", _currentSprite->_filename);
+	//_game->QuickMessageForm("%s", _currentSprite->_filename);
 
 	updateBlockRegion();
 	_ready = (_state == STATE_READY);
@@ -883,7 +883,7 @@ void AdActor::getNextStep() {
 		return;
 	}
 
-	_currentSprite->getCurrentFrame(_zoomable ? ((AdGame *)_gameRef)->_scene->getZoomAt(_posX, _posY) : 100, _zoomable ? ((AdGame *)_gameRef)->_scene->getZoomAt(_posX, _posY) : 100);
+	_currentSprite->getCurrentFrame(_zoomable ? ((AdGame *)_game)->_scene->getZoomAt(_posX, _posY) : 100, _zoomable ? ((AdGame *)_game)->_scene->getZoomAt(_posX, _posY) : 100);
 	if (!_currentSprite->_changed) {
 		return;
 	}
@@ -904,7 +904,7 @@ void AdActor::getNextStep() {
 		maxStepX--;
 	}
 
-	if (((AdGame *)_gameRef)->_scene->isBlockedAt((int)_pFX, (int)_pFY, true, this)) {
+	if (((AdGame *)_game)->_scene->isBlockedAt((int)_pFX, (int)_pFY, true, this)) {
 		if (_pFCount == 0) {
 			_state = _nextState;
 			_nextState = STATE_READY;
@@ -1016,7 +1016,7 @@ bool AdActor::scCallMethod(ScScript *script, ScStack *stack, ScStack *thisStack,
 		ScValue *val = stack->pop();
 
 		// turn to object?
-		if (val->isNative() && _gameRef->validObject((BaseObject *)val->getNative())) {
+		if (val->isNative() && _game->validObject((BaseObject *)val->getNative())) {
 			BaseObject *obj = (BaseObject *)val->getNative();
 			int angle = (int)(atan2((double)(obj->_posY - _posY), (double)(obj->_posX - _posX)) * (180 / 3.14));
 			dir = (int)angleToDirection(angle);
@@ -1299,11 +1299,11 @@ BaseSprite *AdActor::getTalkStance(const char *stance) {
 	if (_forcedTalkAnimName && !_forcedTalkAnimUsed) {
 		_forcedTalkAnimUsed = true;
 		SAFE_DELETE(_animSprite);
-		_animSprite = new BaseSprite(_gameRef, this);
+		_animSprite = new BaseSprite(_game, this);
 		if (_animSprite) {
 			bool res = _animSprite->loadFile(_forcedTalkAnimName);
 			if (DID_FAIL(res)) {
-				_gameRef->LOG(res, "AdActor::GetTalkStance: error loading talk sprite (object:\"%s\" sprite:\"%s\")", _name, _forcedTalkAnimName);
+				_game->LOG(res, "AdActor::GetTalkStance: error loading talk sprite (object:\"%s\" sprite:\"%s\")", _name, _forcedTalkAnimName);
 				SAFE_DELETE(_animSprite);
 			} else {
 				return _animSprite;
@@ -1488,7 +1488,7 @@ bool AdActor::mergeAnims(const char *animsFilename) {
 
 	char *fileBuffer = (char *)BaseFileManager::getEngineInstance()->readWholeFile(animsFilename);
 	if (fileBuffer == nullptr) {
-		_gameRef->LOG(0, "AdActor::MergeAnims failed for file '%s'", animsFilename);
+		_game->LOG(0, "AdActor::MergeAnims failed for file '%s'", animsFilename);
 		return STATUS_FAILED;
 	}
 
@@ -1502,7 +1502,7 @@ bool AdActor::mergeAnims(const char *animsFilename) {
 	while ((cmd = parser.getCommand(&buffer, commands, &params)) > 0) {
 		switch (cmd) {
 		case TOKEN_ANIMATION: {
-			AdSpriteSet *anim = new AdSpriteSet(_gameRef, this);
+			AdSpriteSet *anim = new AdSpriteSet(_game, this);
 			if (!anim || DID_FAIL(anim->loadBuffer(params, false))) {
 				cmd = PARSERR_GENERIC;
 				ret = STATUS_FAILED;
diff --git a/engines/wintermute/ad/ad_actor_3dx.cpp b/engines/wintermute/ad/ad_actor_3dx.cpp
index 365ca9f84c0..9de4eb36201 100644
--- a/engines/wintermute/ad/ad_actor_3dx.cpp
+++ b/engines/wintermute/ad/ad_actor_3dx.cpp
@@ -86,7 +86,7 @@ AdActor3DX::AdActor3DX(BaseGame *inGame) : AdObject3D(inGame) {
 
 	_talkAnimChannel = 0;
 
-	_gameRef->_renderer3D->enableShadows();
+	_game->_renderer3D->enableShadows();
 
 	_directWalkMode = DIRECT_WALK_NONE;
 	_directTurnMode = DIRECT_TURN_NONE;
@@ -128,11 +128,11 @@ bool AdActor3DX::update() {
 		return true;
 	}
 
-	if (_gameRef->_state == GAME_FROZEN) {
+	if (_game->_state == GAME_FROZEN) {
 		return true;
 	}
 
-	AdGame *adGame = (AdGame *)_gameRef;
+	AdGame *adGame = (AdGame *)_game;
 
 	if (_state == STATE_READY && _stateAnimChannel >= 0 && _xmodel) {
 		_stateAnimChannel = -1;
@@ -170,28 +170,28 @@ bool AdActor3DX::update() {
 			float turnVel = _directTurnVelocity == 0.0f ? _angVelocity : _directTurnVelocity;
 
 			if (_directTurnMode == DIRECT_TURN_CW) {
-				_angle += turnVel * (float)_gameRef->_deltaTime / 1000.f;
+				_angle += turnVel * (float)_game->_deltaTime / 1000.f;
 				_angle = BaseUtils::normalizeAngle(_angle);
 			}
 
 			if (_directTurnMode == DIRECT_TURN_CCW) {
-				_angle -= turnVel * (float)_gameRef->_deltaTime / 1000.f;
+				_angle -= turnVel * (float)_game->_deltaTime / 1000.f;
 				_angle = BaseUtils::normalizeAngle(_angle);
 			}
 
 			float walkVel = _directWalkVelocity == 0.0f ? _velocity : _directWalkVelocity;
 			DXVector3 newPos = _posVector;
 			if (_directWalkMode == DIRECT_WALK_FW) {
-				newPos._x += -sinf(degToRad(_angle)) * walkVel * _scale3D * (float)_gameRef->_deltaTime / 1000.f;
-				newPos._z += -cosf(degToRad(_angle)) * walkVel * _scale3D * (float)_gameRef->_deltaTime / 1000.f;
+				newPos._x += -sinf(degToRad(_angle)) * walkVel * _scale3D * (float)_game->_deltaTime / 1000.f;
+				newPos._z += -cosf(degToRad(_angle)) * walkVel * _scale3D * (float)_game->_deltaTime / 1000.f;
 			}
 
 			if (_directWalkMode == DIRECT_WALK_BK) {
-				newPos._x -= -sinf(degToRad(_angle)) * walkVel * _scale3D * (float)_gameRef->_deltaTime / 1000.f;
-				newPos._z -= -cosf(degToRad(_angle)) * walkVel * _scale3D * (float)_gameRef->_deltaTime / 1000.f;
+				newPos._x -= -sinf(degToRad(_angle)) * walkVel * _scale3D * (float)_game->_deltaTime / 1000.f;
+				newPos._z -= -cosf(degToRad(_angle)) * walkVel * _scale3D * (float)_game->_deltaTime / 1000.f;
 			}
 
-			AdScene *scene = ((AdGame *)_gameRef)->_scene;
+			AdScene *scene = ((AdGame *)_game)->_scene;
 
 			if (scene && scene->_geom) {
 				bool canWalk = false;
@@ -288,7 +288,7 @@ bool AdActor3DX::update() {
 			_tempSkelAnim = _sentence->_currentSkelAnim;
 		}
 
-		bool timeIsUp = (_sentence->_sound && _sentence->_soundStarted && (!_sentence->_sound->isPlaying() && !_sentence->_sound->isPaused())) || (!_sentence->_sound && _sentence->_duration <= _gameRef->getTimer()->getTime() - _sentence->_startTime);
+		bool timeIsUp = (_sentence->_sound && _sentence->_soundStarted && (!_sentence->_sound->isPlaying() && !_sentence->_sound->isPaused())) || (!_sentence->_sound && _sentence->_duration <= _game->getTimer()->getTime() - _sentence->_startTime);
 		if (_tempSkelAnim == nullptr || !_xmodel->isAnimPending(0, _tempSkelAnim) || timeIsUp) {
 			if (timeIsUp) {
 				_sentence->finish();
@@ -309,14 +309,14 @@ bool AdActor3DX::update() {
 						_xmodel->playAnim(0, _idleAnimName, _defaultTransTime, false, _defaultStopTransTime);
 				}
 
-				((AdGame *)_gameRef)->addSentence(_sentence);
+				((AdGame *)_game)->addSentence(_sentence);
 			}
 		} else {
 			if (_tempSkelAnim) {
 				_xmodel->playAnim(0, _tempSkelAnim, _defaultTransTime, false, _defaultStopTransTime);
 			}
 
-			((AdGame *)_gameRef)->addSentence(_sentence);
+			((AdGame *)_game)->addSentence(_sentence);
 		}
 		break;
 	}
@@ -382,32 +382,32 @@ bool AdActor3DX::display() {
 	updateSounds();
 	setupLights();
 
-	_gameRef->_renderer3D->setSpriteBlendMode(_blendMode);
+	_game->_renderer3D->setSpriteBlendMode(_blendMode);
 
 	if (_hasAmbientLightColor) {
-		_gameRef->_renderer3D->setAmbientLightColor(_ambientLightColor);
+		_game->_renderer3D->setAmbientLightColor(_ambientLightColor);
 	}
 
-	TShadowType shadowType = _gameRef->getMaxShadowType(this);
+	TShadowType shadowType = _game->getMaxShadowType(this);
 	if (shadowType == SHADOW_STENCIL) {
 		displayShadowVolume();
-	} else if (_gameRef->_maxShadowType > SHADOW_NONE) {
+	} else if (_game->_maxShadowType > SHADOW_NONE) {
 		bool simpleShadow = shadowType <= SHADOW_SIMPLE;
-		if (!_gameRef->_supportsRealTimeShadows)
+		if (!_game->_supportsRealTimeShadows)
 			simpleShadow = true;
 		if (simpleShadow)
-			_gameRef->_renderer3D->displaySimpleShadow(this);
+			_game->_renderer3D->displaySimpleShadow(this);
 		else
 			displayFlatShadow();
 	}
 
-	_gameRef->_renderer3D->setSpriteBlendMode(_blendMode, true);
-	_gameRef->_renderer3D->setWorldTransform(_worldMatrix);
+	_game->_renderer3D->setSpriteBlendMode(_blendMode, true);
+	_game->_renderer3D->setWorldTransform(_worldMatrix);
 
 	bool res = _xmodel->render();
 
 	if (_registrable) {
-		_gameRef->_renderer->_rectList.add(new BaseActiveRect(_gameRef, this, _xmodel,
+		_game->_renderer->_rectList.add(new BaseActiveRect(_game, this, _xmodel,
 		                                                      _xmodel->_boundingRect.left,
 		                                                      _xmodel->_boundingRect.top,
 		                                                      _xmodel->_boundingRect.right - _xmodel->_boundingRect.left,
@@ -418,17 +418,17 @@ bool AdActor3DX::display() {
 	displayAttachments(true);
 
 	if (_hasAmbientLightColor) {
-		_gameRef->_renderer3D->setDefaultAmbientLightColor();
+		_game->_renderer3D->setDefaultAmbientLightColor();
 	}
 
 	if (_active && _partEmitter) {
-		_gameRef->_renderer3D->setup2D();
+		_game->_renderer3D->setup2D();
 		_partEmitter->display();
 	}
 
 	// accessibility
-	//if (_gameRef->_accessMgr->GetActiveObject() == this) {
-	//	_gameRef->_accessMgr->SetHintRect(&_xmodel->m_BoundingRect);
+	//if (_game->_accessMgr->GetActiveObject() == this) {
+	//	_game->_accessMgr->SetHintRect(&_xmodel->m_BoundingRect);
 	//}
 
 	return res;
@@ -440,7 +440,7 @@ bool AdActor3DX::renderModel() {
 		return true;
 	}
 
-	_gameRef->_renderer3D->setWorldTransform(_worldMatrix);
+	_game->_renderer3D->setWorldTransform(_worldMatrix);
 
 	if (_shadowModel) {
 		_shadowModel->render();
@@ -463,7 +463,7 @@ bool AdActor3DX::displayShadowVolume() {
 		return false;
 	}
 
-	_gameRef->_renderer3D->setWorldTransform(_worldMatrix);
+	_game->_renderer3D->setWorldTransform(_worldMatrix);
 
 	DXVector3 lightPos = DXVector3(_shadowLightPos._x * _scale3D,
 	                               _shadowLightPos._y * _scale3D,
@@ -489,7 +489,7 @@ bool AdActor3DX::displayShadowVolume() {
 	shadowModel->updateShadowVol(getShadowVolume(), &_worldMatrix, &lightVector, extrusionDepth);
 
 	DXMatrix origWorld;
-	_gameRef->_renderer3D->getWorldTransform(&origWorld);
+	_game->_renderer3D->getWorldTransform(&origWorld);
 
 	// handle the attachments
 	for (int32 i = 0; i < _attachments.getSize(); i++) {
@@ -511,7 +511,7 @@ bool AdActor3DX::displayShadowVolume() {
 	}
 
 	// restore model's world matrix and render the shadow volume
-	_gameRef->_renderer3D->setWorldTransform(origWorld);
+	_game->_renderer3D->setWorldTransform(origWorld);
 
 	getShadowVolume()->renderToStencilBuffer();
 
@@ -532,7 +532,7 @@ bool AdActor3DX::displayFlatShadow() {
 	                               _shadowLightPos._y * _scale3D,
 	                               _shadowLightPos._z * _scale3D);
 
-	_gameRef->_renderer3D->getWorldTransform(&origWorld);
+	_game->_renderer3D->getWorldTransform(&origWorld);
 
 	DXVector4 lightVector = { lightPos._x, lightPos._y, lightPos._z, 0 };
 	DXPlane plane = { 0, 1, 0, -_posVector._y };
@@ -540,10 +540,10 @@ bool AdActor3DX::displayFlatShadow() {
 	DXMatrixShadow(&shadowMat, &lightVector, &plane);
 	DXMatrix shadowWorld = _worldMatrix * shadowMat;
 
-	_gameRef->_renderer3D->setWorldTransform(shadowWorld);
+	_game->_renderer3D->setWorldTransform(shadowWorld);
 	_xmodel->renderFlatShadowModel(_shadowColor);
 
-	_gameRef->_renderer3D->setWorldTransform(origWorld);
+	_game->_renderer3D->setWorldTransform(origWorld);
 
 	return true;
 }
@@ -569,7 +569,7 @@ bool AdActor3DX::displayAttachments(bool registerObjects) {
 	}
 
 	DXMatrix origView;
-	_gameRef->_renderer3D->getWorldTransform(&origView);
+	_game->_renderer3D->getWorldTransform(&origView);
 
 	for (int32 i = 0; i < _attachments.getSize(); i++) {
 		AdAttach3DX *at = _attachments[i];
@@ -588,7 +588,7 @@ bool AdActor3DX::displayAttachments(bool registerObjects) {
 		at->displayAttachable(&viewMat, registerObjects);
 	}
 
-	_gameRef->_renderer3D->setWorldTransform(origView);
+	_game->_renderer3D->setWorldTransform(origView);
 
 	return true;
 }
@@ -637,7 +637,7 @@ void AdActor3DX::goTo2D(int x, int y, float targetAngle) {
 	_targetPoint2D->x = x;
 	_targetPoint2D->y = y;
 
-	((AdGame *)_gameRef)->_scene->correctTargetPoint(_posX, _posY, &_targetPoint2D->x, &_targetPoint2D->y, true, this);
+	((AdGame *)_game)->_scene->correctTargetPoint(_posX, _posY, &_targetPoint2D->x, &_targetPoint2D->y, true, this);
 
 	_state = STATE_SEARCHING_PATH;
 }
@@ -665,8 +665,8 @@ void AdActor3DX::getNextStep3D() {
 		turnToStep(_angVelocity);
 
 	DXVector3 newPos = _posVector;
-	newPos._x += -sinf(degToRad(_targetAngle)) * _velocity * _scale3D * (float)_gameRef->_deltaTime / 1000.f;
-	newPos._z += -cosf(degToRad(_targetAngle)) * _velocity * _scale3D * (float)_gameRef->_deltaTime / 1000.f;
+	newPos._x += -sinf(degToRad(_targetAngle)) * _velocity * _scale3D * (float)_game->_deltaTime / 1000.f;
+	newPos._z += -cosf(degToRad(_targetAngle)) * _velocity * _scale3D * (float)_game->_deltaTime / 1000.f;
 
 	DXVector3 origVec, newVec;
 	DXVector3 *currentPos = _path3D->getCurrent();
@@ -709,7 +709,7 @@ void AdActor3DX::initLine3D(DXVector3 startPt, DXVector3 endPt, bool firstStep)
 
 //////////////////////////////////////////////////////////////////////////
 void AdActor3DX::getNextStep2D() {
-	AdGame *adGame = (AdGame *)_gameRef;
+	AdGame *adGame = (AdGame *)_game;
 
 	if (!adGame || !adGame->_scene || !adGame->_scene->_geom || !_path2D || !_path2D->getCurrent()) {
 		_state = _nextState;
@@ -722,8 +722,8 @@ void AdActor3DX::getNextStep2D() {
 	}
 
 	DXVector3 newPos = _posVector;
-	newPos._x += -sinf(degToRad(_targetAngle)) * _velocity * _scale3D * (float)_gameRef->_deltaTime / 1000.f;
-	newPos._z += -cosf(degToRad(_targetAngle)) * _velocity * _scale3D * (float)_gameRef->_deltaTime / 1000.f;
+	newPos._x += -sinf(degToRad(_targetAngle)) * _velocity * _scale3D * (float)_game->_deltaTime / 1000.f;
+	newPos._z += -cosf(degToRad(_targetAngle)) * _velocity * _scale3D * (float)_game->_deltaTime / 1000.f;
 
 	DXVector3 currentPoint;
 	adGame->_scene->_geom->convert2Dto3DTolerant(_path2D->getCurrent()->x, _path2D->getCurrent()->y, &currentPoint);
@@ -755,7 +755,7 @@ void AdActor3DX::getNextStep2D() {
 
 //////////////////////////////////////////////////////////////////////////
 void AdActor3DX::followPath2D() {
-	AdGame *adGameRef = (AdGame *)_gameRef;
+	AdGame *adGameRef = (AdGame *)_game;
 
 	// skip current position
 	_path2D->getFirst();
@@ -815,12 +815,12 @@ bool AdActor3DX::prepareTurn(float targetAngle) {
 //////////////////////////////////////////////////////////////////////////
 bool AdActor3DX::turnToStep(float velocity) {
 	if (_turningLeft) {
-		_angle -= velocity * (float)_gameRef->_deltaTime / 1000.f;
+		_angle -= velocity * (float)_game->_deltaTime / 1000.f;
 		if (_angle < _targetAngle) {
 			_angle = _targetAngle;
 		}
 	} else {
-		_angle += velocity * (float)_gameRef->_deltaTime / 1000.f;
+		_angle += velocity * (float)_game->_deltaTime / 1000.f;
 		if (_angle > _targetAngle) {
 			_angle = _targetAngle;
 		}
@@ -841,7 +841,7 @@ bool AdActor3DX::loadFile(const char *filename) {
 	char *buffer = (char *)BaseFileManager::getEngineInstance()->readWholeFile(filename);
 
 	if (buffer == nullptr) {
-		_gameRef->LOG(0, "AdActor3DX::LoadFile failed for file '%s'", filename);
+		_game->LOG(0, "AdActor3DX::LoadFile failed for file '%s'", filename);
 		return false;
 	}
 
@@ -850,7 +850,7 @@ bool AdActor3DX::loadFile(const char *filename) {
 	bool ret = loadBuffer(buffer, true);
 
 	if (!ret) {
-		_gameRef->LOG(0, "Error parsing ACTOR3D file '%s'", filename);
+		_game->LOG(0, "Error parsing ACTOR3D file '%s'", filename);
 	}
 
 	delete[] buffer;
@@ -943,7 +943,7 @@ bool AdActor3DX::loadBuffer(char *buffer, bool complete) {
 
 	if (complete) {
 		if (parser.getCommand(&buffer, commands, &params) != TOKEN_ACTOR3DX) {
-			_gameRef->LOG(0, "'ACTOR3DX' keyword expected.");
+			_game->LOG(0, "'ACTOR3DX' keyword expected.");
 			return false;
 		}
 
@@ -1081,7 +1081,7 @@ bool AdActor3DX::loadBuffer(char *buffer, bool complete) {
 
 		case TOKEN_MODEL:
 			if (!_xmodel) {
-				_xmodel = new XModel(_gameRef, this);
+				_xmodel = new XModel(_game, this);
 
 				if (!_xmodel || !_xmodel->loadFromFile(params)) {
 					SAFE_DELETE(_xmodel);
@@ -1097,20 +1097,20 @@ bool AdActor3DX::loadBuffer(char *buffer, bool complete) {
 		case TOKEN_SHADOW_MODEL:
 			if (_xmodel) {
 				SAFE_DELETE(_shadowModel);
-				_shadowModel = new XModel(_gameRef, this);
+				_shadowModel = new XModel(_game, this);
 
 				if (!_shadowModel || !_shadowModel->loadFromFile(params, _xmodel)) {
 					SAFE_DELETE(_shadowModel);
 					cmd = PARSERR_GENERIC;
 				}
 			} else {
-				_gameRef->LOG(0, "Error: a MODEL= line must precede shadow model assignment (file: %s)", getFilename());
+				_game->LOG(0, "Error: a MODEL= line must precede shadow model assignment (file: %s)", getFilename());
 			}
 			break;
 
 		case TOKEN_CURSOR:
 			SAFE_DELETE(_cursor);
-			_cursor = new BaseSprite(_gameRef);
+			_cursor = new BaseSprite(_game);
 			if (!_cursor || !_cursor->loadFile(params)) {
 				SAFE_DELETE(_cursor);
 				cmd = PARSERR_GENERIC;
@@ -1133,7 +1133,7 @@ bool AdActor3DX::loadBuffer(char *buffer, bool complete) {
 			if (_xmodel) {
 				_xmodel->parseAnim(params);
 			} else {
-				_gameRef->LOG(0, "Error: a MODEL= line must precede any animation definitions (file: %s)", getFilename());
+				_game->LOG(0, "Error: a MODEL= line must precede any animation definitions (file: %s)", getFilename());
 			}
 			break;
 
@@ -1141,22 +1141,22 @@ bool AdActor3DX::loadBuffer(char *buffer, bool complete) {
 			if (_xmodel)
 				parseEffect(params);
 			else
-				_gameRef->LOG(0, "Error: a MODEL= line must precede any effect definitions (file: %s)", getFilename());
+				_game->LOG(0, "Error: a MODEL= line must precede any effect definitions (file: %s)", getFilename());
 			break;
 
 		case TOKEN_SHADOW_IMAGE:
 			if (_shadowImage)
-				_gameRef->_surfaceStorage->removeSurface(_shadowImage);
+				_game->_surfaceStorage->removeSurface(_shadowImage);
 			_shadowImage = nullptr;
 
-			_shadowImage = _gameRef->_surfaceStorage->addSurface(params);
+			_shadowImage = _game->_surfaceStorage->addSurface(params);
 			break;
 
 		case TOKEN_BLOCKED_REGION: {
 			SAFE_DELETE(_blockRegion);
 			SAFE_DELETE(_currentBlockRegion);
-			BaseRegion *rgn = new BaseRegion(_gameRef);
-			BaseRegion *crgn = new BaseRegion(_gameRef);
+			BaseRegion *rgn = new BaseRegion(_game);
+			BaseRegion *crgn = new BaseRegion(_game);
 			if (!rgn || !crgn || !rgn->loadBuffer(params, false)) {
 				SAFE_DELETE(rgn);
 				SAFE_DELETE(crgn);
@@ -1172,8 +1172,8 @@ bool AdActor3DX::loadBuffer(char *buffer, bool complete) {
 		case TOKEN_WAYPOINTS: {
 			SAFE_DELETE(_wptGroup);
 			SAFE_DELETE(_currentWptGroup);
-			AdWaypointGroup *wpt = new AdWaypointGroup(_gameRef);
-			AdWaypointGroup *cwpt = new AdWaypointGroup(_gameRef);
+			AdWaypointGroup *wpt = new AdWaypointGroup(_game);
+			AdWaypointGroup *cwpt = new AdWaypointGroup(_game);
 			if (!wpt || !cwpt || !wpt->loadBuffer(params, false)) {
 				SAFE_DELETE(wpt);
 				SAFE_DELETE(cwpt);
@@ -1190,16 +1190,16 @@ bool AdActor3DX::loadBuffer(char *buffer, bool complete) {
 	}
 
 	if (cmd == PARSERR_TOKENNOTFOUND) {
-		_gameRef->LOG(0, "Syntax error in ACTOR3DX definition");
+		_game->LOG(0, "Syntax error in ACTOR3DX definition");
 		return false;
 	}
 	if (cmd == PARSERR_GENERIC) {
-		_gameRef->LOG(0, "Error loading ACTOR3DX definition");
+		_game->LOG(0, "Error loading ACTOR3DX definition");
 		return false;
 	}
 
 	if (!_xmodel) {
-		_gameRef->LOG(0, "Error: No model has been loaded for 3D actor");
+		_game->LOG(0, "Error: No model has been loaded for 3D actor");
 		return false;
 	}
 
@@ -1411,7 +1411,7 @@ bool AdActor3DX::scCallMethod(ScScript *script, ScStack *stack, ScStack *thisSta
 	//////////////////////////////////////////////////////////////////////////
 	else if (strcmp(name, "AddAttachment") == 0 || strcmp(name, "AddMesh") == 0) {
 		if (strcmp(name, "AddMesh") == 0)
-			_gameRef->LOG(0, "Warning: AddMesh is now obsolete, use AddAttachment");
+			_game->LOG(0, "Warning: AddMesh is now obsolete, use AddAttachment");
 
 		stack->correctParams(3);
 		const char *filename = stack->pop()->getString();
@@ -1425,7 +1425,7 @@ bool AdActor3DX::scCallMethod(ScScript *script, ScStack *stack, ScStack *thisSta
 				script->runtimeError("Bone '%s' cannot be found", boneName);
 				stack->pushBool(false);
 			} else {
-				AdAttach3DX *at = new AdAttach3DX(_gameRef, this);
+				AdAttach3DX *at = new AdAttach3DX(_game, this);
 				if (!at || !at->init(filename, attachName, boneName)) {
 					script->runtimeError("Error adding attachment");
 					SAFE_DELETE(at);
@@ -1456,7 +1456,7 @@ bool AdActor3DX::scCallMethod(ScScript *script, ScStack *stack, ScStack *thisSta
 	//////////////////////////////////////////////////////////////////////////
 	else if (strcmp(name, "RemoveAttachment") == 0 || strcmp(name, "RemoveMesh") == 0) {
 		if (strcmp(name, "RemoveMesh") == 0) {
-			_gameRef->LOG(0, "Warning: RemoveMesh is now obsolete, use RemoveAttachment");
+			_game->LOG(0, "Warning: RemoveMesh is now obsolete, use RemoveAttachment");
 		}
 
 		stack->correctParams(1);
@@ -1529,7 +1529,7 @@ bool AdActor3DX::scCallMethod(ScScript *script, ScStack *stack, ScStack *thisSta
 		stack->correctParams(2);
 		int x = stack->pop()->getInt();
 		int y = stack->pop()->getInt();
-		AdGame *adGame = (AdGame *)_gameRef;
+		AdGame *adGame = (AdGame *)_game;
 
 		if (isGoToNeeded(x, y)) {
 			// check for adGame->_scene first if it's null
@@ -1584,7 +1584,7 @@ bool AdActor3DX::scCallMethod(ScScript *script, ScStack *stack, ScStack *thisSta
 
 		AdEntity *ent = (AdEntity *)obj;
 
-		AdGame *adGame = (AdGame *)_gameRef;
+		AdGame *adGame = (AdGame *)_game;
 
 		bool goToNeeded = true;
 
@@ -1656,10 +1656,10 @@ bool AdActor3DX::scCallMethod(ScScript *script, ScStack *stack, ScStack *thisSta
 		float angle = 0.0;
 
 		// turn to object?
-		if (val->isNative() && _gameRef->validObject((BaseObject *)val->getNative())) {
+		if (val->isNative() && _game->validObject((BaseObject *)val->getNative())) {
 			BaseObject *obj = (BaseObject *)val->getNative();
 			DXVector3 objPos;
-			((AdGame *)_gameRef)->_scene->_geom->convert2Dto3D(obj->_posX, obj->_posY, &objPos);
+			((AdGame *)_game)->_scene->_geom->convert2Dto3D(obj->_posX, obj->_posY, &objPos);
 			angle = radToDeg(-atan2(objPos._z - _posVector._z, objPos._x - _posVector._x)) - 90;
 		} else {
 			// otherwise turn to direction
@@ -2347,7 +2347,7 @@ bool AdActor3DX::mergeAnimations(const char *filename) {
 
 	bool res = _xmodel->mergeFromFile(filename);
 	if (!res) {
-		_gameRef->LOG(res, "Error: MergeAnims failed for file '%s'", filename);
+		_game->LOG(res, "Error: MergeAnims failed for file '%s'", filename);
 		return res;
 	}
 
@@ -2390,11 +2390,11 @@ bool AdActor3DX::mergeAnimations2(const char *filename) {
 	delete[] bufferOrig;
 
 	if (cmd == PARSERR_TOKENNOTFOUND) {
-		_gameRef->LOG(0, "Syntax error in animation definition file");
+		_game->LOG(0, "Syntax error in animation definition file");
 		return false;
 	}
 	if (cmd == PARSERR_GENERIC) {
-		_gameRef->LOG(0, "Error loading animation definition file");
+		_game->LOG(0, "Error loading animation definition file");
 		return false;
 	}
 
@@ -2454,7 +2454,7 @@ bool AdActor3DX::updatePartEmitter() {
 		return AdObject::updatePartEmitter();
 	}
 
-	AdGame *adGame = (AdGame *)_gameRef;
+	AdGame *adGame = (AdGame *)_game;
 
 	if (!adGame->_scene || !adGame->_scene->_geom) {
 		return false;
@@ -2463,10 +2463,10 @@ bool AdActor3DX::updatePartEmitter() {
 	DXVector3 bonePos;
 	getBonePosition3D(_partBone.c_str(), &bonePos, &_partOffset);
 	int32 x = 0, y = 0;
-	static_cast<AdGame *>(_gameRef)->_scene->_geom->convert3Dto2D(&bonePos, &x, &y);
+	static_cast<AdGame *>(_game)->_scene->_geom->convert3Dto2D(&bonePos, &x, &y);
 
-	_partEmitter->_posX = x - _gameRef->_renderer->_drawOffsetX;
-	_partEmitter->_posY = y - _gameRef->_renderer->_drawOffsetY;
+	_partEmitter->_posX = x - _game->_renderer->_drawOffsetX;
+	_partEmitter->_posY = y - _game->_renderer->_drawOffsetY;
 
 	return _partEmitter->update();
 }
@@ -2503,7 +2503,7 @@ bool AdActor3DX::parseEffect(char *buffer) {
 
 	if (effectFile && material) {
 		if (!_xmodel->setMaterialEffect(material, effectFile)) {
-			_gameRef->LOG(0, "Error assigning effect to material '%s'", material);
+			_game->LOG(0, "Error assigning effect to material '%s'", material);
 		}
 	}
 
diff --git a/engines/wintermute/ad/ad_attach_3dx.cpp b/engines/wintermute/ad/ad_attach_3dx.cpp
index 63075c24af6..4d0b3611b59 100644
--- a/engines/wintermute/ad/ad_attach_3dx.cpp
+++ b/engines/wintermute/ad/ad_attach_3dx.cpp
@@ -58,7 +58,7 @@ bool AdAttach3DX::init(const char *modelFile, const char *name, const char *pare
 	_parentBone = parentBone;
 	setName(name);
 
-	_xmodel = new XModel(_gameRef, _owner);
+	_xmodel = new XModel(_game, _owner);
 	if (!_xmodel) {
 		return false;
 	}
@@ -83,7 +83,7 @@ bool AdAttach3DX::update() {
 
 //////////////////////////////////////////////////////////////////////////
 bool AdAttach3DX::displayAttachable(DXMatrix *viewMat, bool registerObjects) {
-	BaseRenderer3D *renderer = _gameRef->_renderer3D;
+	BaseRenderer3D *renderer = _game->_renderer3D;
 	DXMatrix finalMat;
 	DXMatrixMultiply(&finalMat, &_worldMatrix, viewMat);
 	renderer->setWorldTransform(finalMat);
@@ -92,7 +92,7 @@ bool AdAttach3DX::displayAttachable(DXMatrix *viewMat, bool registerObjects) {
 		_xmodel->render();
 
 		if (registerObjects && _owner && _owner->_registrable) {
-			renderer->_rectList.add(new BaseActiveRect(_gameRef, _owner, _xmodel, _xmodel->_boundingRect.left, _xmodel->_boundingRect.top, _xmodel->_boundingRect.right - _xmodel->_boundingRect.left, _xmodel->_boundingRect.bottom - _xmodel->_boundingRect.top, true));
+			renderer->_rectList.add(new BaseActiveRect(_game, _owner, _xmodel, _xmodel->_boundingRect.left, _xmodel->_boundingRect.top, _xmodel->_boundingRect.right - _xmodel->_boundingRect.left, _xmodel->_boundingRect.bottom - _xmodel->_boundingRect.top, true));
 		}
 	}
 
@@ -101,7 +101,7 @@ bool AdAttach3DX::displayAttachable(DXMatrix *viewMat, bool registerObjects) {
 
 //////////////////////////////////////////////////////////////////////////
 bool AdAttach3DX::displayShadowVol(DXMatrix *modelMat, DXVector3 *light, float extrusionDepth, bool update) {
-	BaseRenderer3D *renderer = _gameRef->_renderer3D;
+	BaseRenderer3D *renderer = _game->_renderer3D;
 	DXMatrix finalMat;
 	DXMatrixMultiply(&finalMat, &_worldMatrix, modelMat);
 
diff --git a/engines/wintermute/ad/ad_entity.cpp b/engines/wintermute/ad/ad_entity.cpp
index 6ff009c2602..7343c8172b5 100644
--- a/engines/wintermute/ad/ad_entity.cpp
+++ b/engines/wintermute/ad/ad_entity.cpp
@@ -81,7 +81,7 @@ AdEntity::AdEntity(BaseGame *inGame) : AdTalkHolder(inGame) {
 
 //////////////////////////////////////////////////////////////////////////
 AdEntity::~AdEntity() {
-	_gameRef->unregisterObject(_region);
+	_game->unregisterObject(_region);
 	SAFE_DELETE(_theora);
 
 	SAFE_DELETE_ARRAY(_item);
@@ -101,7 +101,7 @@ int32 AdEntity::getHintY() const {
 bool AdEntity::loadFile(const char *filename) {
 	char *buffer = (char *)BaseFileManager::getEngineInstance()->readWholeFile(filename);
 	if (buffer == nullptr) {
-		_gameRef->LOG(0, "AdEntity::LoadFile failed for file '%s'", filename);
+		_game->LOG(0, "AdEntity::LoadFile failed for file '%s'", filename);
 		return STATUS_FAILED;
 	}
 
@@ -110,7 +110,7 @@ bool AdEntity::loadFile(const char *filename) {
 	setFilename(filename);
 
 	if (DID_FAIL(ret = loadBuffer(buffer, true))) {
-		_gameRef->LOG(0, "Error parsing ENTITY file '%s'", filename);
+		_game->LOG(0, "Error parsing ENTITY file '%s'", filename);
 	}
 
 
@@ -225,13 +225,13 @@ bool AdEntity::loadBuffer(char *buffer, bool complete) {
 
 	if (complete) {
 		if (parser.getCommand(&buffer, commands, &params) != TOKEN_ENTITY) {
-			_gameRef->LOG(0, "'ENTITY' keyword expected.");
+			_game->LOG(0, "'ENTITY' keyword expected.");
 			return STATUS_FAILED;
 		}
 		buffer = params;
 	}
 
-	AdGame *adGame = (AdGame *)_gameRef;
+	AdGame *adGame = (AdGame *)_game;
 	BaseSprite *spr = nullptr;
 	int ar = 0, ag = 0, ab = 0, alpha = 0;
 	while ((cmd = parser.getCommand(&buffer, commands, &params)) > 0) {
@@ -252,7 +252,7 @@ bool AdEntity::loadBuffer(char *buffer, bool complete) {
 
 		case TOKEN_SPRITE: {
 			SAFE_DELETE(_sprite);
-			spr = new BaseSprite(_gameRef, this);
+			spr = new BaseSprite(_game, this);
 			if (!spr || DID_FAIL(spr->loadFile(params))) {
 				cmd = PARSERR_GENERIC;
 			} else {
@@ -262,7 +262,7 @@ bool AdEntity::loadBuffer(char *buffer, bool complete) {
 		break;
 
 		case TOKEN_TALK: {
-			spr = new BaseSprite(_gameRef, this);
+			spr = new BaseSprite(_game, this);
 			if (!spr || DID_FAIL(spr->loadFile(params, adGame->_texTalkLifeTime))) {
 				cmd = PARSERR_GENERIC;
 			} else {
@@ -272,7 +272,7 @@ bool AdEntity::loadBuffer(char *buffer, bool complete) {
 		break;
 
 		case TOKEN_TALK_SPECIAL: {
-			spr = new BaseSprite(_gameRef, this);
+			spr = new BaseSprite(_game, this);
 			if (!spr || DID_FAIL(spr->loadFile(params, adGame->_texTalkLifeTime))) {
 				cmd = PARSERR_GENERIC;
 			} else {
@@ -338,7 +338,7 @@ bool AdEntity::loadBuffer(char *buffer, bool complete) {
 
 		case TOKEN_CURSOR:
 			SAFE_DELETE(_cursor);
-			_cursor = new BaseSprite(_gameRef);
+			_cursor = new BaseSprite(_game);
 			if (!_cursor || DID_FAIL(_cursor->loadFile(params))) {
 				SAFE_DELETE(_cursor);
 				cmd = PARSERR_GENERIC;
@@ -351,15 +351,15 @@ bool AdEntity::loadBuffer(char *buffer, bool complete) {
 
 		case TOKEN_REGION: {
 			if (_region) {
-				_gameRef->unregisterObject(_region);
+				_game->unregisterObject(_region);
 			}
 			_region = nullptr;
-			BaseRegion *rgn = new BaseRegion(_gameRef);
+			BaseRegion *rgn = new BaseRegion(_game);
 			if (!rgn || DID_FAIL(rgn->loadBuffer(params, false))) {
 				cmd = PARSERR_GENERIC;
 			} else {
 				_region = rgn;
-				_gameRef->registerObject(_region);
+				_game->registerObject(_region);
 			}
 		}
 		break;
@@ -367,8 +367,8 @@ bool AdEntity::loadBuffer(char *buffer, bool complete) {
 		case TOKEN_BLOCKED_REGION: {
 			SAFE_DELETE(_blockRegion);
 			SAFE_DELETE(_currentBlockRegion);
-			BaseRegion *rgn = new BaseRegion(_gameRef);
-			BaseRegion *crgn = new BaseRegion(_gameRef);
+			BaseRegion *rgn = new BaseRegion(_game);
+			BaseRegion *crgn = new BaseRegion(_game);
 			if (!rgn || !crgn || DID_FAIL(rgn->loadBuffer(params, false))) {
 				SAFE_DELETE(_blockRegion);
 				SAFE_DELETE(_currentBlockRegion);
@@ -384,8 +384,8 @@ bool AdEntity::loadBuffer(char *buffer, bool complete) {
 		case TOKEN_WAYPOINTS: {
 			SAFE_DELETE(_wptGroup);
 			SAFE_DELETE(_currentWptGroup);
-			AdWaypointGroup *wpt = new AdWaypointGroup(_gameRef);
-			AdWaypointGroup *cwpt = new AdWaypointGroup(_gameRef);
+			AdWaypointGroup *wpt = new AdWaypointGroup(_game);
+			AdWaypointGroup *cwpt = new AdWaypointGroup(_game);
 			if (!wpt || !cwpt || DID_FAIL(wpt->loadBuffer(params, false))) {
 				SAFE_DELETE(_wptGroup);
 				SAFE_DELETE(_currentWptGroup);
@@ -405,20 +405,20 @@ bool AdEntity::loadBuffer(char *buffer, bool complete) {
 		case TOKEN_SUBTYPE: {
 			if (scumm_stricmp(params, "sound") == 0) {
 				SAFE_DELETE(_sprite);
-				if (_gameRef->_editorMode) {
-					spr = new BaseSprite(_gameRef, this);
+				if (_game->_editorMode) {
+					spr = new BaseSprite(_game, this);
 					if (!spr || DID_FAIL(spr->loadFile("entity_sound.sprite"))) {
 						cmd = PARSERR_GENERIC;
 					} else {
 						_sprite = spr;
 					}
 				}
-				if (_gameRef->_editorMode) {
+				if (_game->_editorMode) {
 					_editorOnly = true;
 				}
 				_zoomable = false;
 				_rotatable = false;
-				_registrable = _gameRef->_editorMode;
+				_registrable = _game->_editorMode;
 				_shadowable = false;
 				_subtype = ENTITY_SOUND;
 			}
@@ -501,11 +501,11 @@ bool AdEntity::loadBuffer(char *buffer, bool complete) {
 		}
 	}
 	if (cmd == PARSERR_TOKENNOTFOUND) {
-		_gameRef->LOG(0, "Syntax error in ENTITY definition");
+		_game->LOG(0, "Syntax error in ENTITY definition");
 		return STATUS_FAILED;
 	}
 	if (cmd == PARSERR_GENERIC) {
-		_gameRef->LOG(0, "Error loading ENTITY definition");
+		_game->LOG(0, "Error loading ENTITY definition");
 		if (spr) {
 			delete spr;
 		}
@@ -513,7 +513,7 @@ bool AdEntity::loadBuffer(char *buffer, bool complete) {
 	}
 
 	if (_region && _sprite) {
-		_gameRef->LOG(0, "Warning: Entity '%s' has both sprite and region.", _name);
+		_game->LOG(0, "Warning: Entity '%s' has both sprite and region.", _name);
 	}
 
 	updatePosition();
@@ -524,7 +524,7 @@ bool AdEntity::loadBuffer(char *buffer, bool complete) {
 	_alphaColor = BYTETORGBA(ar, ag, ab, alpha);
 	_state = STATE_READY;
 
-	if (_item && ((AdGame *)_gameRef)->isItemTaken(_item)) {
+	if (_item && ((AdGame *)_game)->isItemTaken(_item)) {
 		_active = false;
 	}
 
@@ -541,7 +541,7 @@ bool AdEntity::display() {
 		if (_alphaColor != 0) {
 			alpha = _alphaColor;
 		} else {
-			alpha = _shadowable ? ((AdGame *)_gameRef)->_scene->getAlphaAt(_posX, _posY) : 0xFFFFFFFF;
+			alpha = _shadowable ? ((AdGame *)_game)->_scene->getAlphaAt(_posX, _posY) : 0xFFFFFFFF;
 		}
 
 		float scaleX, scaleY;
@@ -552,7 +552,7 @@ bool AdEntity::display() {
 			if (_rotateValid) {
 				rotate = _rotate;
 			} else {
-				rotate = ((AdGame *)_gameRef)->_scene->getRotationAt(_posX, _posY) + _relativeRotate;
+				rotate = ((AdGame *)_game)->_scene->getRotationAt(_posX, _posY) + _relativeRotate;
 			}
 		} else {
 			rotate = 0.0f;
@@ -560,12 +560,12 @@ bool AdEntity::display() {
 
 
 		bool reg = _registrable;
-		if (_ignoreItems && ((AdGame *)_gameRef)->_selectedItem) {
+		if (_ignoreItems && ((AdGame *)_game)->_selectedItem) {
 			reg = false;
 		}
 
 		if (_region && (reg || _editorAlwaysRegister)) {
-			_gameRef->_renderer->_rectList.add(new BaseActiveRect(_gameRef,  _registerAlias, _region, _gameRef->_offsetX, _gameRef->_offsetY));
+			_game->_renderer->_rectList.add(new BaseActiveRect(_game,  _registerAlias, _region, _game->_offsetX, _game->_offsetY));
 		}
 
 		displaySpriteAttachments(true);
@@ -650,7 +650,7 @@ bool AdEntity::update() {
 			_tempSprite2 = _sentence->_currentSprite;
 		}
 
-		bool timeIsUp = (_sentence->_sound && _sentence->_soundStarted && (!_sentence->_sound->isPlaying() && !_sentence->_sound->isPaused())) || (!_sentence->_sound && _sentence->_duration <= _gameRef->getTimer()->getTime() - _sentence->_startTime);
+		bool timeIsUp = (_sentence->_sound && _sentence->_soundStarted && (!_sentence->_sound->isPlaying() && !_sentence->_sound->isPaused())) || (!_sentence->_sound && _sentence->_duration <= _game->getTimer()->getTime() - _sentence->_startTime);
 		if (_tempSprite2 == nullptr || _tempSprite2->_finished || (/*_tempSprite2->_looping &&*/ timeIsUp)) {
 			if (timeIsUp) {
 				_sentence->finish();
@@ -662,11 +662,11 @@ bool AdEntity::update() {
 					_tempSprite2->reset();
 					_currentSprite = _tempSprite2;
 				}
-				((AdGame *)_gameRef)->addSentence(_sentence);
+				((AdGame *)_game)->addSentence(_sentence);
 			}
 		} else {
 			_currentSprite = _tempSprite2;
-			((AdGame *)_gameRef)->addSentence(_sentence);
+			((AdGame *)_game)->addSentence(_sentence);
 		}
 	}
 	break;
@@ -676,7 +676,7 @@ bool AdEntity::update() {
 
 
 	if (_currentSprite) {
-		_currentSprite->getCurrentFrame(_zoomable ? ((AdGame *)_gameRef)->_scene->getZoomAt(_posX, _posY) : 100);
+		_currentSprite->getCurrentFrame(_zoomable ? ((AdGame *)_game)->_scene->getZoomAt(_posX, _posY) : 100);
 		if (_currentSprite->_changed) {
 			_posX += _currentSprite->_moveX;
 			_posY += _currentSprite->_moveY;
@@ -688,7 +688,7 @@ bool AdEntity::update() {
 
 	if (_theora) {
 		int offsetX, offsetY;
-		_gameRef->getOffset(&offsetX, &offsetY);
+		_game->getOffset(&offsetX, &offsetY);
 		_theora->_posX = _posX - offsetX;
 		_theora->_posY = _posY - offsetY;
 
@@ -735,7 +735,7 @@ bool AdEntity::scCallMethod(ScScript *script, ScStack *stack, ScStack *thisStack
 		int startTime = stack->pop()->getInt();
 
 		SAFE_DELETE(_theora);
-		_theora = new VideoTheoraPlayer(_gameRef);
+		_theora = new VideoTheoraPlayer(_game);
 		if (_theora && DID_SUCCEED(_theora->initialize(filename))) {
 			if (!valAlpha->isNULL()) {
 				_theora->setAlphaImage(valAlpha->getString());
@@ -843,8 +843,8 @@ bool AdEntity::scCallMethod(ScScript *script, ScStack *stack, ScStack *thisStack
 			return STATUS_OK;
 		}
 
-		for (int32 i = 0; i < ((AdGame *)_gameRef)->_scene->_layers.getSize(); i++) {
-			AdLayer *layer = ((AdGame *)_gameRef)->_scene->_layers[i];
+		for (int32 i = 0; i < ((AdGame *)_game)->_scene->_layers.getSize(); i++) {
+			AdLayer *layer = ((AdGame *)_game)->_scene->_layers[i];
 			for (int32 j = 0; j < layer->_nodes.getSize(); j++) {
 				if (layer->_nodes[j]->_type == OBJECT_ENTITY && this == layer->_nodes[j]->_entity) {
 					// found source layer and index, looking for target node
@@ -886,8 +886,8 @@ bool AdEntity::scCallMethod(ScScript *script, ScStack *stack, ScStack *thisStack
 	else if (strcmp(name, "GetLayer") == 0 || strcmp(name, "GetIndex") == 0) {
 		stack->correctParams(0);
 
-		for (int32 i = 0; i < ((AdGame *)_gameRef)->_scene->_layers.getSize(); i++) {
-			AdLayer *layer = ((AdGame *)_gameRef)->_scene->_layers[i];
+		for (int32 i = 0; i < ((AdGame *)_game)->_scene->_layers.getSize(); i++) {
+			AdLayer *layer = ((AdGame *)_game)->_scene->_layers[i];
 			for (int32 j = 0; j < layer->_nodes.getSize(); j++) {
 				if (layer->_nodes[j]->_type == OBJECT_ENTITY && this == layer->_nodes[j]->_entity) {
 					if (strcmp(name, "GetLayer") == 0) {
@@ -912,8 +912,8 @@ bool AdEntity::scCallMethod(ScScript *script, ScStack *stack, ScStack *thisStack
 	else if (strcmp(name, "CreateRegion") == 0) {
 		stack->correctParams(0);
 		if (!_region) {
-			_region = new BaseRegion(_gameRef);
-			_gameRef->registerObject(_region);
+			_region = new BaseRegion(_game);
+			_game->registerObject(_region);
 		}
 		if (_region) {
 			stack->pushNative(_region, true);
@@ -930,7 +930,7 @@ bool AdEntity::scCallMethod(ScScript *script, ScStack *stack, ScStack *thisStack
 	else if (strcmp(name, "DeleteRegion") == 0) {
 		stack->correctParams(0);
 		if (_region) {
-			_gameRef->unregisterObject(_region);
+			_game->unregisterObject(_region);
 			_region = nullptr;
 			stack->pushBool(true);
 		} else {
@@ -1269,7 +1269,7 @@ bool AdEntity::setSprite(const char *filename) {
 	}
 
 	SAFE_DELETE(_sprite);
-	BaseSprite *spr = new BaseSprite(_gameRef, this);
+	BaseSprite *spr = new BaseSprite(_game, this);
 	if (!spr || DID_FAIL(spr->loadFile(filename))) {
 		SAFE_DELETE(_sprite);
 		return STATUS_FAILED;
diff --git a/engines/wintermute/ad/ad_game.cpp b/engines/wintermute/ad/ad_game.cpp
index 1a830023c3e..baa5c5ae9aa 100644
--- a/engines/wintermute/ad/ad_game.cpp
+++ b/engines/wintermute/ad/ad_game.cpp
@@ -81,7 +81,7 @@ AdGame::AdGame(const Common::String &gameId) : BaseGame(gameId) {
 	_responseBox = nullptr;
 	_inventoryBox = nullptr;
 
-	_scene = new AdScene(_gameRef);
+	_scene = new AdScene(_game);
 	_scene->setName("");
 	registerObject(_scene);
 
@@ -153,7 +153,7 @@ bool AdGame::cleanup() {
 
 	// remove items
 	for (int32 i = 0; i < _items.getSize(); i++) {
-		_gameRef->unregisterObject(_items[i]);
+		_game->unregisterObject(_items[i]);
 	}
 	_items.removeAll();
 
@@ -169,12 +169,12 @@ bool AdGame::cleanup() {
 
 
 	if (_responseBox) {
-		_gameRef->unregisterObject(_responseBox);
+		_game->unregisterObject(_responseBox);
 		_responseBox = nullptr;
 	}
 
 	if (_inventoryBox) {
-		_gameRef->unregisterObject(_inventoryBox);
+		_game->unregisterObject(_inventoryBox);
 		_inventoryBox = nullptr;
 	}
 
@@ -211,7 +211,7 @@ bool AdGame::initLoop() {
 		changeScene(_scheduledScene, _scheduledFadeIn);
 		SAFE_DELETE_ARRAY(_scheduledScene);
 
-		_gameRef->_activeObject = nullptr;
+		_game->_activeObject = nullptr;
 	}
 
 
@@ -271,10 +271,10 @@ bool AdGame::removeObject(AdObject *object) {
 //////////////////////////////////////////////////////////////////////////
 bool AdGame::changeScene(const char *filename, bool fadeIn) {
 	if (_scene == nullptr) {
-		_scene = new AdScene(_gameRef);
+		_scene = new AdScene(_game);
 		registerObject(_scene);
 	} else {
-		_gameRef->pluginEvents().applyEvent(WME_EVENT_SCENE_SHUTDOWN, _scene);
+		_game->pluginEvents().applyEvent(WME_EVENT_SCENE_SHUTDOWN, _scene);
 		_scene->applyEvent("SceneShutdown", true);
 
 		setPrevSceneName(_scene->_name);
@@ -314,10 +314,10 @@ bool AdGame::changeScene(const char *filename, bool fadeIn) {
 			}
 
 			_scene->loadState();
-			_gameRef->pluginEvents().applyEvent(WME_EVENT_SCENE_INIT, _scene);
+			_game->pluginEvents().applyEvent(WME_EVENT_SCENE_INIT, _scene);
 		}
 		if (fadeIn) {
-			_gameRef->_transMgr->start(TRANSITION_FADE_IN);
+			_game->_transMgr->start(TRANSITION_FADE_IN);
 		}
 		return ret;
 	} else {
@@ -393,7 +393,7 @@ bool AdGame::scCallMethod(ScScript *script, ScStack *stack, ScStack *thisStack,
 	//////////////////////////////////////////////////////////////////////////
 	else if (strcmp(name, "LoadActor") == 0) {
 		stack->correctParams(1);
-		AdActor *act = new AdActor(_gameRef);
+		AdActor *act = new AdActor(_game);
 		if (act && DID_SUCCEED(act->loadFile(stack->pop()->getString()))) {
 			addObject(act);
 			stack->pushNative(act, true);
@@ -413,7 +413,7 @@ bool AdGame::scCallMethod(ScScript *script, ScStack *stack, ScStack *thisStack,
 		// assume that we have an .X model here
 		// wme3d has also support for .ms3d files
 		// but they are deprecated
-		AdActor3DX *act = new AdActor3DX(_gameRef);
+		AdActor3DX *act = new AdActor3DX(_game);
 		if (act && DID_SUCCEED(act->loadFile(stack->pop()->getString()))) {
 			addObject(act);
 			stack->pushNative(act, true);
@@ -430,7 +430,7 @@ bool AdGame::scCallMethod(ScScript *script, ScStack *stack, ScStack *thisStack,
 	//////////////////////////////////////////////////////////////////////////
 	else if (strcmp(name, "LoadEntity") == 0) {
 		stack->correctParams(1);
-		AdEntity *ent = new AdEntity(_gameRef);
+		AdEntity *ent = new AdEntity(_game);
 		if (ent && DID_SUCCEED(ent->loadFile(stack->pop()->getString()))) {
 			addObject(ent);
 			stack->pushNative(ent, true);
@@ -479,7 +479,7 @@ bool AdGame::scCallMethod(ScScript *script, ScStack *stack, ScStack *thisStack,
 		stack->correctParams(1);
 		ScValue *val = stack->pop();
 
-		AdEntity *ent = new AdEntity(_gameRef);
+		AdEntity *ent = new AdEntity(_game);
 		addObject(ent);
 		if (!val->isNULL()) {
 			ent->setName(val->getString());
@@ -495,7 +495,7 @@ bool AdGame::scCallMethod(ScScript *script, ScStack *stack, ScStack *thisStack,
 		stack->correctParams(1);
 		ScValue *val = stack->pop();
 
-		AdItem *item = new AdItem(_gameRef);
+		AdItem *item = new AdItem(_game);
 		addItem(item);
 		if (!val->isNULL()) {
 			item->setName(val->getString());
@@ -566,7 +566,7 @@ bool AdGame::scCallMethod(ScScript *script, ScStack *stack, ScStack *thisStack,
 		ScValue *val4 = stack->pop();
 
 		if (_responseBox) {
-			AdResponse *res = new AdResponse(_gameRef);
+			AdResponse *res = new AdResponse(_game);
 			if (res) {
 				res->_iD = id;
 				res->setText(text);
@@ -819,8 +819,8 @@ bool AdGame::scCallMethod(ScScript *script, ScStack *stack, ScStack *thisStack,
 		stack->correctParams(1);
 		const char *filename = stack->pop()->getString();
 
-		_gameRef->unregisterObject(_responseBox);
-		_responseBox = new AdResponseBox(_gameRef);
+		_game->unregisterObject(_responseBox);
+		_responseBox = new AdResponseBox(_game);
 		if (_responseBox && !DID_FAIL(_responseBox->loadFile(filename))) {
 			registerObject(_responseBox);
 			stack->pushBool(true);
@@ -838,8 +838,8 @@ bool AdGame::scCallMethod(ScScript *script, ScStack *stack, ScStack *thisStack,
 		stack->correctParams(1);
 		const char *filename = stack->pop()->getString();
 
-		_gameRef->unregisterObject(_inventoryBox);
-		_inventoryBox = new AdInventoryBox(_gameRef);
+		_game->unregisterObject(_inventoryBox);
+		_inventoryBox = new AdInventoryBox(_game);
 		if (_inventoryBox && !DID_FAIL(_inventoryBox->loadFile(filename))) {
 			registerObject(_inventoryBox);
 			stack->pushBool(true);
@@ -904,7 +904,7 @@ bool AdGame::scCallMethod(ScScript *script, ScStack *stack, ScStack *thisStack,
 		}
 
 		if (!_sceneViewport) {
-			_sceneViewport = new BaseViewport(_gameRef);
+			_sceneViewport = new BaseViewport(_game);
 		}
 		if (_sceneViewport) {
 			_sceneViewport->setRect(x, y, x + width, y + height);
@@ -1185,7 +1185,7 @@ bool AdGame::scSetProperty(const char *name, ScValue *value) {
 			BaseObject *obj = (BaseObject *)value->getNative();
 			if (obj == this) {
 				_inventoryOwner = _invObject;
-			} else if (_gameRef->validObject(obj)) {
+			} else if (_game->validObject(obj)) {
 				_inventoryOwner = (AdObject *)obj;
 			}
 		}
@@ -1267,7 +1267,7 @@ bool AdGame::externalCall(ScScript *script, ScStack *stack, ScStack *thisStack,
 		stack->correctParams(0);
 		thisObj = thisStack->getTop();
 
-		thisObj->setNative(new AdActor(_gameRef));
+		thisObj->setNative(new AdActor(_game));
 		stack->pushNULL();
 	}
 
@@ -1278,7 +1278,7 @@ bool AdGame::externalCall(ScScript *script, ScStack *stack, ScStack *thisStack,
 		stack->correctParams(0);
 		thisObj = thisStack->getTop();
 
-		thisObj->setNative(new AdEntity(_gameRef));
+		thisObj->setNative(new AdEntity(_game));
 		stack->pushNULL();
 	}
 
@@ -1300,7 +1300,7 @@ bool AdGame::showCursor() {
 		return STATUS_OK;
 	}
 
-	if (_selectedItem && _gameRef->_state == GAME_RUNNING && _stateEx == GAME_NORMAL && _interactive) {
+	if (_selectedItem && _game->_state == GAME_RUNNING && _stateEx == GAME_NORMAL && _interactive) {
 		if (_selectedItem->_cursorCombined) {
 			BaseSprite *origLastCursor = _lastCursor;
 			BaseGame::showCursor();
@@ -1325,7 +1325,7 @@ bool AdGame::showCursor() {
 bool AdGame::loadFile(const char *filename) {
 	char *buffer = (char *)BaseFileManager::getEngineInstance()->readWholeFile(filename);
 	if (buffer == nullptr) {
-		_gameRef->LOG(0, "AdGame::LoadFile failed for file '%s'", filename);
+		_game->LOG(0, "AdGame::LoadFile failed for file '%s'", filename);
 		return STATUS_FAILED;
 	}
 
@@ -1334,7 +1334,7 @@ bool AdGame::loadFile(const char *filename) {
 	setFilename(filename);
 
 	if (DID_FAIL(ret = loadBuffer(buffer, true))) {
-		_gameRef->LOG(0, "Error parsing GAME file '%s'", filename);
+		_game->LOG(0, "Error parsing GAME file '%s'", filename);
 	}
 
 
@@ -1394,7 +1394,7 @@ bool AdGame::loadBuffer(char *buffer, bool complete) {
 				switch (cmd) {
 				case TOKEN_RESPONSE_BOX:
 					SAFE_DELETE(_responseBox);
-					_responseBox = new AdResponseBox(_gameRef);
+					_responseBox = new AdResponseBox(_game);
 					if (_responseBox && !DID_FAIL(_responseBox->loadFile(params2))) {
 						registerObject(_responseBox);
 					} else {
@@ -1405,7 +1405,7 @@ bool AdGame::loadBuffer(char *buffer, bool complete) {
 
 				case TOKEN_INVENTORY_BOX:
 					SAFE_DELETE(_inventoryBox);
-					_inventoryBox = new AdInventoryBox(_gameRef);
+					_inventoryBox = new AdInventoryBox(_game);
 					if (_inventoryBox && !DID_FAIL(_inventoryBox->loadFile(params2))) {
 						registerObject(_inventoryBox);
 					} else {
@@ -1446,7 +1446,7 @@ bool AdGame::loadBuffer(char *buffer, bool complete) {
 					Common::Rect32 rc;
 					parser.scanStr(params2, "%d,%d,%d,%d", &rc.left, &rc.top, &rc.right, &rc.bottom);
 					if (!_sceneViewport) {
-						_sceneViewport = new BaseViewport(_gameRef);
+						_sceneViewport = new BaseViewport(_game);
 					}
 					if (_sceneViewport) {
 						_sceneViewport->setRect(rc.left, rc.top, rc.right, rc.bottom);
@@ -1478,16 +1478,16 @@ bool AdGame::loadBuffer(char *buffer, bool complete) {
 	}
 
 	if (cmd == PARSERR_TOKENNOTFOUND) {
-		_gameRef->LOG(0, "Syntax error in GAME definition");
+		_game->LOG(0, "Syntax error in GAME definition");
 		return STATUS_FAILED;
 	}
 	if (cmd == PARSERR_GENERIC) {
-		_gameRef->LOG(0, "Error loading GAME definition");
+		_game->LOG(0, "Error loading GAME definition");
 		return STATUS_FAILED;
 	}
 
 	if (itemFound && !itemsFound) {
-		_gameRef->LOG(0, "**Warning** Please put the items definition to a separate file.");
+		_game->LOG(0, "**Warning** Please put the items definition to a separate file.");
 	}
 
 	return STATUS_OK;
@@ -1693,7 +1693,7 @@ bool AdGame::handleCustomActionStart(BaseGameCustomAction action) {
 	}
 
 	BasePlatform::setCursorPos(p.x, p.y);
-	setActiveObject(_gameRef->_renderer->getObjectAt(p.x, p.y));
+	setActiveObject(_game->_renderer->getObjectAt(p.x, p.y));
 	onMouseLeftDown();
 	onMouseLeftUp();
 	return true;
@@ -1725,7 +1725,7 @@ bool AdGame::getVersion(byte *verMajor, byte *verMinor, byte *extMajor, byte *ex
 bool AdGame::loadItemsFile(const char *filename, bool merge) {
 	char *buffer = (char *)BaseFileManager::getEngineInstance()->readWholeFile(filename);
 	if (buffer == nullptr) {
-		_gameRef->LOG(0, "AdGame::LoadItemsFile failed for file '%s'", filename);
+		_game->LOG(0, "AdGame::LoadItemsFile failed for file '%s'", filename);
 		return STATUS_FAILED;
 	}
 
@@ -1736,7 +1736,7 @@ bool AdGame::loadItemsFile(const char *filename, bool merge) {
 	//Common::strcpy_s(_filename, filenameSize, filename);
 
 	if (DID_FAIL(ret = loadItemsBuffer(buffer, merge))) {
-		_gameRef->LOG(0, "Error parsing ITEMS file '%s'", filename);
+		_game->LOG(0, "Error parsing ITEMS file '%s'", filename);
 	}
 
 
@@ -1765,7 +1765,7 @@ bool AdGame::loadItemsBuffer(char *buffer, bool merge) {
 	while ((cmd = parser.getCommand(&buffer, commands, &params)) > 0) {
 		switch (cmd) {
 		case TOKEN_ITEM: {
-			AdItem *item = new AdItem(_gameRef);
+			AdItem *item = new AdItem(_game);
 			if (item && !DID_FAIL(item->loadBuffer(params, false))) {
 				// delete item with the same name, if exists
 				if (merge) {
@@ -1788,11 +1788,11 @@ bool AdGame::loadItemsBuffer(char *buffer, bool merge) {
 	}
 
 	if (cmd == PARSERR_TOKENNOTFOUND) {
-		_gameRef->LOG(0, "Syntax error in ITEMS definition");
+		_game->LOG(0, "Syntax error in ITEMS definition");
 		return STATUS_FAILED;
 	}
 	if (cmd == PARSERR_GENERIC) {
-		_gameRef->LOG(0, "Error loading ITEMS definition");
+		_game->LOG(0, "Error loading ITEMS definition");
 		return STATUS_FAILED;
 	}
 
@@ -1819,7 +1819,7 @@ AdSceneState *AdGame::getSceneState(const char *filename, bool saving) {
 	}
 
 	if (saving) {
-		AdSceneState *ret = new AdSceneState(_gameRef);
+		AdSceneState *ret = new AdSceneState(_game);
 		ret->setFilename(filenameCor);
 
 		_sceneStates.add(ret);
@@ -1845,7 +1845,7 @@ bool AdGame::windowLoadHook(UIWindow *win, char **buffer, char **params) {
 	cmd = parser.getCommand(buffer, commands, params);
 	switch (cmd) {
 	case TOKEN_ENTITY_CONTAINER: {
-		UIEntity *ent = new UIEntity(_gameRef);
+		UIEntity *ent = new UIEntity(_game);
 		if (!ent || DID_FAIL(ent->loadBuffer(*params, false))) {
 			SAFE_DELETE(ent);
 			cmd = PARSERR_GENERIC;
@@ -1875,7 +1875,7 @@ bool AdGame::windowScriptMethodHook(UIWindow *win, ScScript *script, ScStack *st
 		stack->correctParams(1);
 		ScValue *val = stack->pop();
 
-		UIEntity *ent = new UIEntity(_gameRef);
+		UIEntity *ent = new UIEntity(_game);
 		if (!val->isNULL()) {
 			ent->setName(val->getString());
 		}
@@ -1971,7 +1971,7 @@ bool AdGame::addBranchResponse(int id) {
 	if (branchResponseUsed(id)) {
 		return STATUS_OK;
 	}
-	AdResponseContext *r = new AdResponseContext(_gameRef);
+	AdResponseContext *r = new AdResponseContext(_game);
 	r->_id = id;
 	r->setContext(_dlgPendingBranches.getSize() > 0 ? _dlgPendingBranches[_dlgPendingBranches.getSize() - 1] : nullptr);
 	_responsesBranch.add(r);
@@ -1999,7 +1999,7 @@ bool AdGame::addGameResponse(int id) {
 	if (gameResponseUsed(id)) {
 		return STATUS_OK;
 	}
-	AdResponseContext *r = new AdResponseContext(_gameRef);
+	AdResponseContext *r = new AdResponseContext(_game);
 	r->_id = id;
 	r->setContext(_dlgPendingBranches.getSize() > 0 ? _dlgPendingBranches[_dlgPendingBranches.getSize() - 1] : nullptr);
 	_responsesGame.add(r);
@@ -2090,16 +2090,16 @@ bool AdGame::displayContent(bool doUpdate, bool displayAll) {
 
 		// process plugin events
 		if (doUpdate)
-			_gameRef->pluginEvents().applyEvent(WME_EVENT_UPDATE, nullptr);
+			_game->pluginEvents().applyEvent(WME_EVENT_UPDATE, nullptr);
 
 		Common::Point32 p;
 		getMousePos(&p);
 
 		_scene->update();
 
-		_gameRef->pluginEvents().applyEvent(WME_EVENT_SCENE_DRAW_BEGIN, _scene);
+		_game->pluginEvents().applyEvent(WME_EVENT_SCENE_DRAW_BEGIN, _scene);
 		_scene->display();
-		_gameRef->pluginEvents().applyEvent(WME_EVENT_SCENE_DRAW_END, _scene);
+		_game->pluginEvents().applyEvent(WME_EVENT_SCENE_DRAW_END, _scene);
 
 		// display in-game windows
 		displayWindows(true);
@@ -2118,7 +2118,7 @@ bool AdGame::displayContent(bool doUpdate, bool displayAll) {
 
 			//m_AccessMgr->DisplayAfterGUI();
 
-			setActiveObject(_gameRef->_renderer->getObjectAt(p.x, p.y));
+			setActiveObject(_game->_renderer->getObjectAt(p.x, p.y));
 
 			// textual info
 			//if (m_AccessGlobalPaused)
@@ -2198,7 +2198,7 @@ AdItem *AdGame::getItemByName(const char *name) const {
 //////////////////////////////////////////////////////////////////////////
 bool AdGame::addItem(AdItem *item) {
 	_items.add(item);
-	return _gameRef->registerObject(item);
+	return _game->registerObject(item);
 }
 
 
@@ -2401,7 +2401,7 @@ bool AdGame::onMouseLeftDown() {
 	}
 
 	if ((_videoSkipButton == VIDEO_SKIP_LEFT || _videoSkipButton == VIDEO_SKIP_BOTH) && isVideoPlaying()) {
-		_gameRef->stopVideo();
+		_game->stopVideo();
 		return STATUS_OK;
 	}
 
@@ -2419,7 +2419,7 @@ bool AdGame::onMouseLeftDown() {
 	}
 
 	if (_activeObject != nullptr) {
-		_gameRef->_capturedObject = _gameRef->_activeObject;
+		_game->_capturedObject = _game->_activeObject;
 	}
 	_mouseLeftDown = true;
 
@@ -2497,7 +2497,7 @@ bool AdGame::onMouseRightDown() {
 	}
 
 	if ((_videoSkipButton == VIDEO_SKIP_RIGHT || _videoSkipButton == VIDEO_SKIP_BOTH) && isVideoPlaying()) {
-		_gameRef->stopVideo();
+		_game->stopVideo();
 		return STATUS_OK;
 	}
 
@@ -2543,7 +2543,7 @@ bool AdGame::onMouseRightUp() {
 //////////////////////////////////////////////////////////////////////////
 bool AdGame::displayDebugInfo() {
 	char str[100];
-	if (_gameRef->_debugDebugMode) {
+	if (_game->_debugDebugMode) {
 		Common::sprintf_s(str, "Mouse: %d, %d (scene: %d, %d)", _mousePos.x, _mousePos.y, _mousePos.x + (_scene ? _scene->getOffsetLeft() : 0), _mousePos.y + (_scene ? _scene->getOffsetTop() : 0));
 		_systemFont->drawText((byte *)str, 0, 90, _renderer->getWidth(), TAL_RIGHT);
 
@@ -2577,18 +2577,18 @@ bool AdGame::getLayerSize(int *layerWidth, int *layerHeight, Common::Rect32 *vie
 		if (_scene->_scroll3DCompatibility) {
 			// backward compatibility hack
 			// WME pre-1.7 expects the camera to only view the top-left part of the scene
-			*layerWidth = _gameRef->_renderer->getWidth();
-			*layerHeight = _gameRef->_renderer->getHeight();
+			*layerWidth = _game->_renderer->getWidth();
+			*layerHeight = _game->_renderer->getHeight();
 		} else
 #endif
 		{
 			*layerWidth = _scene->_mainLayer->_width;
 			*layerHeight = _scene->_mainLayer->_height;
 #ifdef ENABLE_WME3D
-			if (_gameRef->_editorResolutionWidth > 0)
-				*layerWidth = _gameRef->_editorResolutionWidth;
-			if (_gameRef->_editorResolutionHeight > 0)
-				*layerHeight = _gameRef->_editorResolutionHeight;
+			if (_game->_editorResolutionWidth > 0)
+				*layerWidth = _game->_editorResolutionWidth;
+			if (_game->_editorResolutionHeight > 0)
+				*layerHeight = _game->_editorResolutionHeight;
 #endif
 		}
 		return true;
diff --git a/engines/wintermute/ad/ad_geom_ext.cpp b/engines/wintermute/ad/ad_geom_ext.cpp
index 6ba8337fb3b..32eef13fb93 100644
--- a/engines/wintermute/ad/ad_geom_ext.cpp
+++ b/engines/wintermute/ad/ad_geom_ext.cpp
@@ -37,7 +37,7 @@
 namespace Wintermute {
 
 //////////////////////////////////////////////////////////////////////////
-AdGeomExt::AdGeomExt(BaseGame *in_gameRef) : BaseClass(in_gameRef) {
+AdGeomExt::AdGeomExt(BaseGame *in_game) : BaseClass(in_game) {
 }
 
 //////////////////////////////////////////////////////////////////////////
@@ -52,13 +52,13 @@ AdGeomExt::~AdGeomExt() {
 bool AdGeomExt::loadFile(char *filename) {
 	char *buffer = (char *)BaseFileManager::getEngineInstance()->readWholeFile(filename);
 	if (buffer == nullptr) {
-		_gameRef->LOG(0, "AdGeomExt::LoadFile failed for file '%s'", filename);
+		_game->LOG(0, "AdGeomExt::LoadFile failed for file '%s'", filename);
 		return false;
 	}
 
 	bool ret = loadBuffer(buffer);
 	if (!ret) {
-		_gameRef->LOG(0, "Error parsing geometry description file '%s'", filename);
+		_game->LOG(0, "Error parsing geometry description file '%s'", filename);
 	}
 
 	delete[] buffer;
@@ -82,7 +82,7 @@ bool AdGeomExt::loadBuffer(char *buffer) {
 	BaseParser parser;
 
 	if (parser.getCommand(&buffer, commands, &params) != TOKEN_GEOMETRY) {
-		_gameRef->LOG(0, "'GEOMETRY' keyword expected.");
+		_game->LOG(0, "'GEOMETRY' keyword expected.");
 		return false;
 	}
 
@@ -91,7 +91,7 @@ bool AdGeomExt::loadBuffer(char *buffer) {
 	while ((cmd = parser.getCommand(&buffer, commands, &params)) > 0) {
 		switch (cmd) {
 		case TOKEN_NODE: {
-			AdGeomExtNode *node = new AdGeomExtNode(_gameRef);
+			AdGeomExtNode *node = new AdGeomExtNode(_game);
 
 			if (node && node->loadBuffer(params, false)) {
 				_nodes.add(node);
@@ -105,11 +105,11 @@ bool AdGeomExt::loadBuffer(char *buffer) {
 	}
 
 	if (cmd == PARSERR_TOKENNOTFOUND) {
-		_gameRef->LOG(0, "Syntax error in geometry description file");
+		_game->LOG(0, "Syntax error in geometry description file");
 		return false;
 	}
 	if (cmd == PARSERR_GENERIC) {
-		_gameRef->LOG(0, "Error loading geometry description");
+		_game->LOG(0, "Error loading geometry description");
 		return false;
 	}
 
@@ -121,15 +121,15 @@ bool AdGeomExt::loadBuffer(char *buffer) {
 bool AdGeomExt::addStandardNodes() {
 	AdGeomExtNode *node;
 
-	node = new AdGeomExtNode(_gameRef);
+	node = new AdGeomExtNode(_game);
 	node->setupNode("walk_*", GEOM_WALKPLANE, true);
 	_nodes.add(node);
 
-	node = new AdGeomExtNode(_gameRef);
+	node = new AdGeomExtNode(_game);
 	node->setupNode("blk_*", GEOM_BLOCKED, false);
 	_nodes.add(node);
 
-	node = new AdGeomExtNode(_gameRef);
+	node = new AdGeomExtNode(_game);
 	node->setupNode("wpt_*", GEOM_WAYPOINT, false);
 	_nodes.add(node);
 
diff --git a/engines/wintermute/ad/ad_geom_ext_node.cpp b/engines/wintermute/ad/ad_geom_ext_node.cpp
index acfc4b80b3b..0a6411a1027 100644
--- a/engines/wintermute/ad/ad_geom_ext_node.cpp
+++ b/engines/wintermute/ad/ad_geom_ext_node.cpp
@@ -72,7 +72,7 @@ bool AdGeomExtNode::loadBuffer(char *buffer, bool complete) {
 
 	if (complete) {
 		if (parser.getCommand(&buffer, commands, &params) != TOKEN_NODE) {
-			_gameRef->LOG(0, "'NODE' keyword expected.");
+			_game->LOG(0, "'NODE' keyword expected.");
 			return false;
 		}
 
@@ -119,11 +119,11 @@ bool AdGeomExtNode::loadBuffer(char *buffer, bool complete) {
 	}
 
 	if (cmd == PARSERR_TOKENNOTFOUND) {
-		_gameRef->LOG(0, "Syntax error in geometry description file");
+		_game->LOG(0, "Syntax error in geometry description file");
 		return false;
 	}
 	if (cmd == PARSERR_GENERIC) {
-		_gameRef->LOG(0, "Error loading geometry description");
+		_game->LOG(0, "Error loading geometry description");
 		return false;
 	}
 	return true;
diff --git a/engines/wintermute/ad/ad_inventory.cpp b/engines/wintermute/ad/ad_inventory.cpp
index 4ac1fe7192b..f18dd3d5fb2 100644
--- a/engines/wintermute/ad/ad_inventory.cpp
+++ b/engines/wintermute/ad/ad_inventory.cpp
@@ -53,7 +53,7 @@ bool AdInventory::insertItem(const char *name, const char *insertAfter) {
 		return STATUS_FAILED;
 	}
 
-	AdItem *item = ((AdGame *)_gameRef)->getItemByName(name);
+	AdItem *item = ((AdGame *)_game)->getItemByName(name);
 	if (item == nullptr) {
 		return STATUS_FAILED;
 	}
@@ -89,8 +89,8 @@ bool AdInventory::removeItem(const char *name) {
 
 	for (int32 i = 0; i < _takenItems.getSize(); i++) {
 		if (scumm_stricmp(_takenItems[i]->_name, name) == 0) {
-			if (((AdGame *)_gameRef)->_selectedItem == _takenItems[i]) {
-				((AdGame *)_gameRef)->_selectedItem = nullptr;
+			if (((AdGame *)_game)->_selectedItem == _takenItems[i]) {
+				((AdGame *)_game)->_selectedItem = nullptr;
 			}
 			_takenItems.removeAt(i);
 			return STATUS_OK;
@@ -110,8 +110,8 @@ bool AdInventory::removeItem(AdItem *item) {
 
 	for (int32 i = 0; i < _takenItems.getSize(); i++) {
 		if (_takenItems[i] == item) {
-			if (((AdGame *)_gameRef)->_selectedItem == _takenItems[i]) {
-				((AdGame *)_gameRef)->_selectedItem = nullptr;
+			if (((AdGame *)_game)->_selectedItem == _takenItems[i]) {
+				((AdGame *)_game)->_selectedItem = nullptr;
 			}
 			_takenItems.removeAt(i);
 			return STATUS_OK;
diff --git a/engines/wintermute/ad/ad_inventory_box.cpp b/engines/wintermute/ad/ad_inventory_box.cpp
index 6f39638afbb..1fd4db07467 100644
--- a/engines/wintermute/ad/ad_inventory_box.cpp
+++ b/engines/wintermute/ad/ad_inventory_box.cpp
@@ -67,7 +67,7 @@ AdInventoryBox::AdInventoryBox(BaseGame *inGame) : BaseObject(inGame) {
 
 //////////////////////////////////////////////////////////////////////////
 AdInventoryBox::~AdInventoryBox() {
-	_gameRef->unregisterObject(_window);
+	_game->unregisterObject(_window);
 	_window = nullptr;
 
 	SAFE_DELETE(_closeButton);
@@ -102,7 +102,7 @@ bool AdInventoryBox::listen(BaseScriptHolder *param1, uint32 param2) {
 
 //////////////////////////////////////////////////////////////////////////
 bool AdInventoryBox::display() {
-	AdGame *adGame = (AdGame *)_gameRef;
+	AdGame *adGame = (AdGame *)_game;
 
 	if (!_visible) {
 		return STATUS_OK;
@@ -120,8 +120,8 @@ bool AdInventoryBox::display() {
 
 	if (_closeButton) {
 		_closeButton->_posX = _closeButton->_posY = 0;
-		_closeButton->_width = _gameRef->_renderer->getWidth();
-		_closeButton->_height = _gameRef->_renderer->getHeight();
+		_closeButton->_width = _game->_renderer->getWidth();
+		_closeButton->_height = _game->_renderer->getHeight();
 
 		_closeButton->display();
 	}
@@ -136,7 +136,7 @@ bool AdInventoryBox::display() {
 
 	// display items
 	if (_window && _window->_alphaColor != 0) {
-		_gameRef->_renderer->_forceAlphaColor = _window->_alphaColor;
+		_game->_renderer->_forceAlphaColor = _window->_alphaColor;
 	}
 	int yyy = rect.top;
 	for (int j = 0; j < itemsY; j++) {
@@ -145,7 +145,7 @@ bool AdInventoryBox::display() {
 			int itemIndex = _scrollOffset + j * itemsX + i;
 			if (itemIndex >= 0 && itemIndex < adGame->_inventoryOwner->getInventory()->_takenItems.getSize()) {
 				AdItem *item = adGame->_inventoryOwner->getInventory()->_takenItems[itemIndex];
-				if (item != ((AdGame *)_gameRef)->_selectedItem || !_hideSelected) {
+				if (item != ((AdGame *)_game)->_selectedItem || !_hideSelected) {
 					item->update();
 					item->display(xxx, yyy);
 				}
@@ -156,7 +156,7 @@ bool AdInventoryBox::display() {
 		yyy += (_itemHeight + _spacing);
 	}
 	if (_window && _window->_alphaColor != 0) {
-		_gameRef->_renderer->_forceAlphaColor = 0;
+		_game->_renderer->_forceAlphaColor = 0;
 	}
 
 	return STATUS_OK;
@@ -167,7 +167,7 @@ bool AdInventoryBox::display() {
 bool AdInventoryBox::loadFile(const char *filename) {
 	char *buffer = (char *)BaseFileManager::getEngineInstance()->readWholeFile(filename);
 	if (buffer == nullptr) {
-		_gameRef->LOG(0, "AdInventoryBox::LoadFile failed for file '%s'", filename);
+		_game->LOG(0, "AdInventoryBox::LoadFile failed for file '%s'", filename);
 		return STATUS_FAILED;
 	}
 
@@ -176,7 +176,7 @@ bool AdInventoryBox::loadFile(const char *filename) {
 	setFilename(filename);
 
 	if (DID_FAIL(ret = loadBuffer(buffer, true))) {
-		_gameRef->LOG(0, "Error parsing INVENTORY_BOX file '%s'", filename);
+		_game->LOG(0, "Error parsing INVENTORY_BOX file '%s'", filename);
 	}
 
 
@@ -229,7 +229,7 @@ bool AdInventoryBox::loadBuffer(char *buffer, bool complete) {
 	_exclusive = false;
 	if (complete) {
 		if (parser.getCommand(&buffer, commands, &params) != TOKEN_INVENTORY_BOX) {
-			_gameRef->LOG(0, "'INVENTORY_BOX' keyword expected.");
+			_game->LOG(0, "'INVENTORY_BOX' keyword expected.");
 			return STATUS_FAILED;
 		}
 		buffer = params;
@@ -253,12 +253,12 @@ bool AdInventoryBox::loadBuffer(char *buffer, bool complete) {
 
 		case TOKEN_WINDOW:
 			SAFE_DELETE(_window);
-			_window = new UIWindow(_gameRef);
+			_window = new UIWindow(_game);
 			if (!_window || DID_FAIL(_window->loadBuffer(params, false))) {
 				SAFE_DELETE(_window);
 				cmd = PARSERR_GENERIC;
 			} else {
-				_gameRef->registerObject(_window);
+				_game->registerObject(_window);
 			}
 			break;
 
@@ -303,17 +303,17 @@ bool AdInventoryBox::loadBuffer(char *buffer, bool complete) {
 		}
 	}
 	if (cmd == PARSERR_TOKENNOTFOUND) {
-		_gameRef->LOG(0, "Syntax error in INVENTORY_BOX definition");
+		_game->LOG(0, "Syntax error in INVENTORY_BOX definition");
 		return STATUS_FAILED;
 	}
 	if (cmd == PARSERR_GENERIC) {
-		_gameRef->LOG(0, "Error loading INVENTORY_BOX definition");
+		_game->LOG(0, "Error loading INVENTORY_BOX definition");
 		return STATUS_FAILED;
 	}
 
 	if (_exclusive) {
 		SAFE_DELETE(_closeButton);
-		_closeButton = new UIButton(_gameRef);
+		_closeButton = new UIButton(_game);
 		if (_closeButton) {
 			_closeButton->setName("close");
 			_closeButton->setListener(this, _closeButton, 0);
diff --git a/engines/wintermute/ad/ad_item.cpp b/engines/wintermute/ad/ad_item.cpp
index 6b39b4010ac..43f803afb4b 100644
--- a/engines/wintermute/ad/ad_item.cpp
+++ b/engines/wintermute/ad/ad_item.cpp
@@ -83,7 +83,7 @@ AdItem::~AdItem() {
 bool AdItem::loadFile(const char *filename) {
 	char *buffer = (char *)BaseFileManager::getEngineInstance()->readWholeFile(filename);
 	if (buffer == nullptr) {
-		_gameRef->LOG(0, "AdItem::LoadFile failed for file '%s'", filename);
+		_game->LOG(0, "AdItem::LoadFile failed for file '%s'", filename);
 		return STATUS_FAILED;
 	}
 
@@ -92,7 +92,7 @@ bool AdItem::loadFile(const char *filename) {
 	setFilename(filename);
 
 	if (DID_FAIL(ret = loadBuffer(buffer, true))) {
-		_gameRef->LOG(0, "Error parsing ITEM file '%s'", filename);
+		_game->LOG(0, "Error parsing ITEM file '%s'", filename);
 	}
 
 
@@ -167,7 +167,7 @@ bool AdItem::loadBuffer(char *buffer, bool complete) {
 
 	if (complete) {
 		if (parser.getCommand(&buffer, commands, &params) != TOKEN_ITEM) {
-			_gameRef->LOG(0, "'ITEM' keyword expected.");
+			_game->LOG(0, "'ITEM' keyword expected.");
 			return STATUS_FAILED;
 		}
 		buffer = params;
@@ -197,8 +197,8 @@ bool AdItem::loadBuffer(char *buffer, bool complete) {
 		case TOKEN_IMAGE:
 		case TOKEN_SPRITE:
 			SAFE_DELETE(_sprite);
-			_sprite = new BaseSprite(_gameRef, this);
-			if (!_sprite || DID_FAIL(_sprite->loadFile(params, ((AdGame *)_gameRef)->_texItemLifeTime))) {
+			_sprite = new BaseSprite(_game, this);
+			if (!_sprite || DID_FAIL(_sprite->loadFile(params, ((AdGame *)_game)->_texItemLifeTime))) {
 				SAFE_DELETE(_sprite);
 				cmd = PARSERR_GENERIC;
 			}
@@ -207,8 +207,8 @@ bool AdItem::loadBuffer(char *buffer, bool complete) {
 		case TOKEN_IMAGE_HOVER:
 		case TOKEN_SPRITE_HOVER:
 			SAFE_DELETE(_spriteHover);
-			_spriteHover = new BaseSprite(_gameRef, this);
-			if (!_spriteHover || DID_FAIL(_spriteHover->loadFile(params, ((AdGame *)_gameRef)->_texItemLifeTime))) {
+			_spriteHover = new BaseSprite(_game, this);
+			if (!_spriteHover || DID_FAIL(_spriteHover->loadFile(params, ((AdGame *)_game)->_texItemLifeTime))) {
 				SAFE_DELETE(_spriteHover);
 				cmd = PARSERR_GENERIC;
 			}
@@ -245,8 +245,8 @@ bool AdItem::loadBuffer(char *buffer, bool complete) {
 			break;
 
 		case TOKEN_TALK: {
-			BaseSprite *spr = new BaseSprite(_gameRef, this);
-			if (!spr || DID_FAIL(spr->loadFile(params, ((AdGame *)_gameRef)->_texTalkLifeTime))) {
+			BaseSprite *spr = new BaseSprite(_game, this);
+			if (!spr || DID_FAIL(spr->loadFile(params, ((AdGame *)_game)->_texTalkLifeTime))) {
 				cmd = PARSERR_GENERIC;
 			} else {
 				_talkSprites.add(spr);
@@ -255,8 +255,8 @@ bool AdItem::loadBuffer(char *buffer, bool complete) {
 		break;
 
 		case TOKEN_TALK_SPECIAL: {
-			BaseSprite *spr = new BaseSprite(_gameRef, this);
-			if (!spr || DID_FAIL(spr->loadFile(params, ((AdGame *)_gameRef)->_texTalkLifeTime))) {
+			BaseSprite *spr = new BaseSprite(_game, this);
+			if (!spr || DID_FAIL(spr->loadFile(params, ((AdGame *)_game)->_texTalkLifeTime))) {
 				cmd = PARSERR_GENERIC;
 			} else {
 				_talkSpritesEx.add(spr);
@@ -266,8 +266,8 @@ bool AdItem::loadBuffer(char *buffer, bool complete) {
 
 		case TOKEN_CURSOR:
 			SAFE_DELETE(_cursorNormal);
-			_cursorNormal = new BaseSprite(_gameRef);
-			if (!_cursorNormal || DID_FAIL(_cursorNormal->loadFile(params, ((AdGame *)_gameRef)->_texItemLifeTime))) {
+			_cursorNormal = new BaseSprite(_game);
+			if (!_cursorNormal || DID_FAIL(_cursorNormal->loadFile(params, ((AdGame *)_game)->_texItemLifeTime))) {
 				SAFE_DELETE(_cursorNormal);
 				cmd = PARSERR_GENERIC;
 			}
@@ -275,8 +275,8 @@ bool AdItem::loadBuffer(char *buffer, bool complete) {
 
 		case TOKEN_CURSOR_HOVER:
 			SAFE_DELETE(_cursorHover);
-			_cursorHover = new BaseSprite(_gameRef);
-			if (!_cursorHover || DID_FAIL(_cursorHover->loadFile(params, ((AdGame *)_gameRef)->_texItemLifeTime))) {
+			_cursorHover = new BaseSprite(_game);
+			if (!_cursorHover || DID_FAIL(_cursorHover->loadFile(params, ((AdGame *)_game)->_texItemLifeTime))) {
 				SAFE_DELETE(_cursorHover);
 				cmd = PARSERR_GENERIC;
 			}
@@ -311,11 +311,11 @@ bool AdItem::loadBuffer(char *buffer, bool complete) {
 		}
 	}
 	if (cmd == PARSERR_TOKENNOTFOUND) {
-		_gameRef->LOG(0, "Syntax error in ITEM definition");
+		_game->LOG(0, "Syntax error in ITEM definition");
 		return STATUS_FAILED;
 	}
 	if (cmd == PARSERR_GENERIC) {
-		_gameRef->LOG(0, "Error loading ITEM definition");
+		_game->LOG(0, "Error loading ITEM definition");
 		return STATUS_FAILED;
 	}
 
@@ -360,7 +360,7 @@ bool AdItem::update() {
 		//////////////////////////////////////////////////////////////////////////
 	case STATE_READY:
 		if (!_animSprite) {
-			if (_gameRef->_activeObject == this && _spriteHover) {
+			if (_game->_activeObject == this && _spriteHover) {
 				_currentSprite = _spriteHover;
 			} else {
 				_currentSprite = _sprite;
@@ -375,7 +375,7 @@ bool AdItem::update() {
 			_tempSprite2 = _sentence->_currentSprite;
 		}
 
-		bool timeIsUp = (_sentence->_sound && _sentence->_soundStarted && (!_sentence->_sound->isPlaying() && !_sentence->_sound->isPaused())) || (!_sentence->_sound && _sentence->_duration <= _gameRef->getTimer()->getTime() - _sentence->_startTime);
+		bool timeIsUp = (_sentence->_sound && _sentence->_soundStarted && (!_sentence->_sound->isPlaying() && !_sentence->_sound->isPaused())) || (!_sentence->_sound && _sentence->_duration <= _game->getTimer()->getTime() - _sentence->_startTime);
 		if (_tempSprite2 == nullptr || _tempSprite2->_finished || (/*_tempSprite2->_looping &&*/ timeIsUp)) {
 			if (timeIsUp) {
 				_sentence->finish();
@@ -387,11 +387,11 @@ bool AdItem::update() {
 					_tempSprite2->reset();
 					_currentSprite = _tempSprite2;
 				}
-				((AdGame *)_gameRef)->addSentence(_sentence);
+				((AdGame *)_game)->addSentence(_sentence);
 			}
 		} else {
 			_currentSprite = _tempSprite2;
-			((AdGame *)_gameRef)->addSentence(_sentence);
+			((AdGame *)_game)->addSentence(_sentence);
 		}
 	}
 	default:
@@ -432,7 +432,7 @@ bool AdItem::display(int x, int y) {
 		}
 		amountX += _amountOffsetX;
 
-		BaseFont *font = _font ? _font : _gameRef->_systemFont;
+		BaseFont *font = _font ? _font : _game->_systemFont;
 		if (font) {
 			if (_amountString) {
 				font->drawText((byte *)_amountString, amountX, amountY, width, _amountAlign);
@@ -466,7 +466,7 @@ bool AdItem::scCallMethod(ScScript *script, ScStack *stack, ScStack *thisStack,
 		const char *filename = stack->pop()->getString();
 
 		SAFE_DELETE(_spriteHover);
-		BaseSprite *spr = new BaseSprite(_gameRef, this);
+		BaseSprite *spr = new BaseSprite(_game, this);
 		if (!spr || DID_FAIL(spr->loadFile(filename))) {
 			stack->pushBool(false);
 			script->runtimeError("Item.SetHoverSprite failed for file '%s'", filename);
@@ -516,7 +516,7 @@ bool AdItem::scCallMethod(ScScript *script, ScStack *stack, ScStack *thisStack,
 		const char *filename = stack->pop()->getString();
 
 		SAFE_DELETE(_cursorNormal);
-		BaseSprite *spr = new BaseSprite(_gameRef);
+		BaseSprite *spr = new BaseSprite(_game);
 		if (!spr || DID_FAIL(spr->loadFile(filename))) {
 			stack->pushBool(false);
 			script->runtimeError("Item.SetNormalCursor failed for file '%s'", filename);
@@ -581,7 +581,7 @@ bool AdItem::scCallMethod(ScScript *script, ScStack *stack, ScStack *thisStack,
 		const char *filename = stack->pop()->getString();
 
 		SAFE_DELETE(_cursorHover);
-		BaseSprite *spr = new BaseSprite(_gameRef);
+		BaseSprite *spr = new BaseSprite(_game);
 		if (!spr || DID_FAIL(spr->loadFile(filename))) {
 			stack->pushBool(false);
 			script->runtimeError("Item.SetHoverCursor failed for file '%s'", filename);
diff --git a/engines/wintermute/ad/ad_layer.cpp b/engines/wintermute/ad/ad_layer.cpp
index 9be3569973d..3117fc74fd9 100644
--- a/engines/wintermute/ad/ad_layer.cpp
+++ b/engines/wintermute/ad/ad_layer.cpp
@@ -67,7 +67,7 @@ AdLayer::~AdLayer() {
 bool AdLayer::loadFile(const char *filename) {
 	char *buffer = (char *)BaseFileManager::getEngineInstance()->readWholeFile(filename);
 	if (buffer == nullptr) {
-		_gameRef->LOG(0, "AdLayer::LoadFile failed for file '%s'", filename);
+		_game->LOG(0, "AdLayer::LoadFile failed for file '%s'", filename);
 		return STATUS_FAILED;
 	}
 
@@ -76,7 +76,7 @@ bool AdLayer::loadFile(const char *filename) {
 	setFilename(filename);
 
 	if (DID_FAIL(ret = loadBuffer(buffer, true))) {
-		_gameRef->LOG(0, "Error parsing LAYER file '%s'", filename);
+		_game->LOG(0, "Error parsing LAYER file '%s'", filename);
 	}
 
 	delete[] buffer;
@@ -128,7 +128,7 @@ bool AdLayer::loadBuffer(char *buffer, bool complete) {
 
 	if (complete) {
 		if (parser.getCommand(&buffer, commands, &params) != TOKEN_LAYER) {
-			_gameRef->LOG(0, "'LAYER' keyword expected.");
+			_game->LOG(0, "'LAYER' keyword expected.");
 			return STATUS_FAILED;
 		}
 		buffer = params;
@@ -171,8 +171,8 @@ bool AdLayer::loadBuffer(char *buffer, bool complete) {
 			break;
 
 		case TOKEN_REGION: {
-			AdRegion *region = new AdRegion(_gameRef);
-			AdSceneNode *node = new AdSceneNode(_gameRef);
+			AdRegion *region = new AdRegion(_game);
+			AdSceneNode *node = new AdSceneNode(_game);
 			if (!region || !node || DID_FAIL(region->loadBuffer(params, false))) {
 				cmd = PARSERR_GENERIC;
 				SAFE_DELETE(region);
@@ -185,8 +185,8 @@ bool AdLayer::loadBuffer(char *buffer, bool complete) {
 		break;
 
 		case TOKEN_ENTITY: {
-			AdEntity *entity = new AdEntity(_gameRef);
-			AdSceneNode *node = new AdSceneNode(_gameRef);
+			AdEntity *entity = new AdEntity(_game);
+			AdSceneNode *node = new AdSceneNode(_game);
 			if (entity) {
 				entity->_zoomable = false;    // scene entites default to NOT zoom
 			}
@@ -222,7 +222,7 @@ bool AdLayer::loadBuffer(char *buffer, bool complete) {
 		}
 	}
 	if (cmd == PARSERR_TOKENNOTFOUND) {
-		_gameRef->LOG(0, "Syntax error in LAYER definition");
+		_game->LOG(0, "Syntax error in LAYER definition");
 		return STATUS_FAILED;
 	}
 
@@ -278,16 +278,16 @@ bool AdLayer::scCallMethod(ScScript *script, ScStack *stack, ScStack *thisStack,
 		stack->correctParams(1);
 		ScValue *val = stack->pop();
 
-		AdSceneNode *node = new AdSceneNode(_gameRef);
+		AdSceneNode *node = new AdSceneNode(_game);
 		if (strcmp(name, "AddRegion") == 0) {
-			AdRegion *region = new AdRegion(_gameRef);
+			AdRegion *region = new AdRegion(_game);
 			if (!val->isNULL()) {
 				region->setName(val->getString());
 			}
 			node->setRegion(region);
 			stack->pushNative(region, true);
 		} else {
-			AdEntity *entity = new AdEntity(_gameRef);
+			AdEntity *entity = new AdEntity(_game);
 			if (!val->isNULL()) {
 				entity->setName(val->getString());
 			}
@@ -306,16 +306,16 @@ bool AdLayer::scCallMethod(ScScript *script, ScStack *stack, ScStack *thisStack,
 		int32 index = stack->pop()->getInt();
 		ScValue *val = stack->pop();
 
-		AdSceneNode *node = new AdSceneNode(_gameRef);
+		AdSceneNode *node = new AdSceneNode(_game);
 		if (strcmp(name, "InsertRegion") == 0) {
-			AdRegion *region = new AdRegion(_gameRef);
+			AdRegion *region = new AdRegion(_game);
 			if (!val->isNULL()) {
 				region->setName(val->getString());
 			}
 			node->setRegion(region);
 			stack->pushNative(region, true);
 		} else {
-			AdEntity *entity = new AdEntity(_gameRef);
+			AdEntity *entity = new AdEntity(_game);
 			if (!val->isNULL()) {
 				entity->setName(val->getString());
 			}
@@ -466,7 +466,7 @@ bool AdLayer::scSetProperty(const char *name, ScValue *value) {
 		if (_width < 0) {
 			_width = 0;
 		}
-		((AdGame *)_gameRef)->_scene->onLayerResized(this);
+		((AdGame *)_game)->_scene->onLayerResized(this);
 		return STATUS_OK;
 	}
 
@@ -478,7 +478,7 @@ bool AdLayer::scSetProperty(const char *name, ScValue *value) {
 		if (_height < 0) {
 			_height = 0;
 		}
-		((AdGame *)_gameRef)->_scene->onLayerResized(this);
+		((AdGame *)_game)->_scene->onLayerResized(this);
 		return STATUS_OK;
 	}
 
@@ -488,7 +488,7 @@ bool AdLayer::scSetProperty(const char *name, ScValue *value) {
 	else if (strcmp(name, "Active") == 0) {
 		bool b = value->getBool();
 		if (b == false && _main) {
-			_gameRef->LOG(0, "Warning: cannot deactivate scene's main layer");
+			_game->LOG(0, "Warning: cannot deactivate scene's main layer");
 		} else {
 			_active = b;
 		}
diff --git a/engines/wintermute/ad/ad_node_state.cpp b/engines/wintermute/ad/ad_node_state.cpp
index ee47e50efe2..6ca8212bad8 100644
--- a/engines/wintermute/ad/ad_node_state.cpp
+++ b/engines/wintermute/ad/ad_node_state.cpp
@@ -87,7 +87,7 @@ void AdNodeState::setCursor(const char *filename) {
 
 //////////////////////////////////////////////////////////////////////////
 bool AdNodeState::persist(BasePersistenceManager *persistMgr) {
-	persistMgr->transferPtr(TMEMBER_PTR(_gameRef));
+	persistMgr->transferPtr(TMEMBER_PTR(_game));
 
 	persistMgr->transferBool(TMEMBER(_active));
 	persistMgr->transferCharPtr(TMEMBER(_name));
@@ -113,7 +113,7 @@ void AdNodeState::setCaption(const char *caption, int caseVal) {
 	size_t captionSize = strlen(caption) + 1;
 	_caption[caseVal - 1] = new char[captionSize];
 	Common::strcpy_s(_caption[caseVal - 1], captionSize, caption);
-	_gameRef->expandStringByStringTable(&_caption[caseVal - 1]);
+	_game->expandStringByStringTable(&_caption[caseVal - 1]);
 }
 
 
@@ -137,8 +137,8 @@ bool AdNodeState::transferEntity(AdEntity *entity, bool includingSprites, bool s
 	}
 
 	// HACK!
-	if (this->_gameRef != entity->_gameRef) {
-		this->_gameRef = entity->_gameRef;
+	if (this->_game != entity->_game) {
+		this->_game = entity->_game;
 	}
 
 	if (saving) {
diff --git a/engines/wintermute/ad/ad_object.cpp b/engines/wintermute/ad/ad_object.cpp
index c60803ec6bc..1c87279fb81 100644
--- a/engines/wintermute/ad/ad_object.cpp
+++ b/engines/wintermute/ad/ad_object.cpp
@@ -124,26 +124,26 @@ AdObject::~AdObject() {
 	_stickRegion = nullptr;
 
 	if (_font) {
-		_gameRef->_fontStorage->removeFont(_font);
+		_game->_fontStorage->removeFont(_font);
 	}
 
 	if (_inventory) {
-		((AdGame *)_gameRef)->unregisterInventory(_inventory);
+		((AdGame *)_game)->unregisterInventory(_inventory);
 		_inventory = nullptr;
 	}
 
 	if (_partEmitter) {
-		_gameRef->unregisterObject(_partEmitter);
+		_game->unregisterObject(_partEmitter);
 	}
 
 
 	for (int32 i = 0; i < _attachmentsPre.getSize(); i++) {
-		_gameRef->unregisterObject(_attachmentsPre[i]);
+		_game->unregisterObject(_attachmentsPre[i]);
 	}
 	_attachmentsPre.removeAll();
 
 	for (int32 i = 0; i < _attachmentsPost.getSize(); i++) {
-		_gameRef->unregisterObject(_attachmentsPost[i]);
+		_game->unregisterObject(_attachmentsPost[i]);
 	}
 	_attachmentsPost.removeAll();
 }
@@ -152,14 +152,14 @@ AdObject::~AdObject() {
 //////////////////////////////////////////////////////////////////////////
 bool AdObject::playAnim(const char *filename) {
 	SAFE_DELETE(_animSprite);
-	_animSprite = new BaseSprite(_gameRef, this);
+	_animSprite = new BaseSprite(_game, this);
 	if (!_animSprite) {
-		_gameRef->LOG(0, "AdObject::PlayAnim: error creating temp sprite (object:\"%s\" sprite:\"%s\")", _name, filename);
+		_game->LOG(0, "AdObject::PlayAnim: error creating temp sprite (object:\"%s\" sprite:\"%s\")", _name, filename);
 		return STATUS_FAILED;
 	}
 	bool res = _animSprite->loadFile(filename);
 	if (DID_FAIL(res)) {
-		_gameRef->LOG(res, "AdObject::PlayAnim: error loading temp sprite (object:\"%s\" sprite:\"%s\")", _name, filename);
+		_game->LOG(res, "AdObject::PlayAnim: error loading temp sprite (object:\"%s\" sprite:\"%s\")", _name, filename);
 		delete _animSprite;
 		_animSprite = nullptr;
 		return res;
@@ -296,7 +296,7 @@ bool AdObject::scCallMethod(ScScript *script, ScStack *stack, ScStack *thisStack
 	else if (strcmp(name, "StickToRegion") == 0) {
 		stack->correctParams(1);
 
-		AdLayer *main = ((AdGame *)_gameRef)->_scene->_mainLayer;
+		AdLayer *main = ((AdGame *)_game)->_scene->_mainLayer;
 		bool regFound = false;
 
 		int32 i;
@@ -369,8 +369,8 @@ bool AdObject::scCallMethod(ScScript *script, ScStack *stack, ScStack *thisStack
 		stack->correctParams(2);
 
 		if (!_inventory) {
-			_inventory = new AdInventory(_gameRef);
-			((AdGame *)_gameRef)->registerInventory(_inventory);
+			_inventory = new AdInventory(_game);
+			((AdGame *)_game)->registerInventory(_inventory);
 		}
 
 		ScValue *val = stack->pop();
@@ -382,7 +382,7 @@ bool AdObject::scCallMethod(ScScript *script, ScStack *stack, ScStack *thisStack
 				script->runtimeError("Cannot add item '%s' to inventory", itemName);
 			} else {
 				// hide associated entities
-				((AdGame *)_gameRef)->_scene->handleItemAssociations(itemName, false);
+				((AdGame *)_game)->_scene->handleItemAssociations(itemName, false);
 			}
 
 		} else {
@@ -400,8 +400,8 @@ bool AdObject::scCallMethod(ScScript *script, ScStack *stack, ScStack *thisStack
 		stack->correctParams(1);
 
 		if (!_inventory) {
-			_inventory = new AdInventory(_gameRef);
-			((AdGame *)_gameRef)->registerInventory(_inventory);
+			_inventory = new AdInventory(_game);
+			((AdGame *)_game)->registerInventory(_inventory);
 		}
 
 		ScValue *val = stack->pop();
@@ -410,7 +410,7 @@ bool AdObject::scCallMethod(ScScript *script, ScStack *stack, ScStack *thisStack
 				script->runtimeError("Cannot remove item '%s' from inventory", val->getString());
 			} else {
 				// show associated entities
-				((AdGame *)_gameRef)->_scene->handleItemAssociations(val->getString(), true);
+				((AdGame *)_game)->_scene->handleItemAssociations(val->getString(), true);
 			}
 		} else {
 			script->runtimeError("DropItem: item name expected");
@@ -427,13 +427,13 @@ bool AdObject::scCallMethod(ScScript *script, ScStack *stack, ScStack *thisStack
 		stack->correctParams(1);
 
 		if (!_inventory) {
-			_inventory = new AdInventory(_gameRef);
-			((AdGame *)_gameRef)->registerInventory(_inventory);
+			_inventory = new AdInventory(_game);
+			((AdGame *)_game)->registerInventory(_inventory);
 		}
 
 		ScValue *val = stack->pop();
 		if (val->_type == VAL_STRING) {
-			AdItem *item = ((AdGame *)_gameRef)->getItemByName(val->getString());
+			AdItem *item = ((AdGame *)_game)->getItemByName(val->getString());
 			if (item) {
 				stack->pushNative(item, true);
 			} else {
@@ -455,8 +455,8 @@ bool AdObject::scCallMethod(ScScript *script, ScStack *stack, ScStack *thisStack
 		stack->correctParams(1);
 
 		if (!_inventory) {
-			_inventory = new AdInventory(_gameRef);
-			((AdGame *)_gameRef)->registerInventory(_inventory);
+			_inventory = new AdInventory(_game);
+			((AdGame *)_game)->registerInventory(_inventory);
 		}
 
 		ScValue *val = stack->pop();
@@ -503,7 +503,7 @@ bool AdObject::scCallMethod(ScScript *script, ScStack *stack, ScStack *thisStack
 	else if (strcmp(name, "DeleteParticleEmitter") == 0) {
 		stack->correctParams(0);
 		if (_partEmitter) {
-			_gameRef->unregisterObject(_partEmitter);
+			_game->unregisterObject(_partEmitter);
 			_partEmitter = nullptr;
 		}
 		stack->pushNULL();
@@ -522,13 +522,13 @@ bool AdObject::scCallMethod(ScScript *script, ScStack *stack, ScStack *thisStack
 		int offsetY = stack->pop()->getInt();
 
 		bool res;
-		AdEntity *ent = new AdEntity(_gameRef);
+		AdEntity *ent = new AdEntity(_game);
 		if (DID_FAIL(res = ent->loadFile(filename))) {
 			delete ent;
 			script->runtimeError("AddAttachment() failed loading entity '%s'", filename);
 			stack->pushBool(false);
 		} else {
-			_gameRef->registerObject(ent);
+			_game->registerObject(ent);
 
 			ent->_posX = offsetX;
 			ent->_posY = offsetY;
@@ -558,7 +558,7 @@ bool AdObject::scCallMethod(ScScript *script, ScStack *stack, ScStack *thisStack
 			for (int32 i = 0; i < _attachmentsPre.getSize(); i++) {
 				if (_attachmentsPre[i] == obj) {
 					found = true;
-					_gameRef->unregisterObject(_attachmentsPre[i]);
+					_game->unregisterObject(_attachmentsPre[i]);
 					_attachmentsPre.removeAt(i);
 					i--;
 				}
@@ -566,7 +566,7 @@ bool AdObject::scCallMethod(ScScript *script, ScStack *stack, ScStack *thisStack
 			for (int32 i = 0; i < _attachmentsPost.getSize(); i++) {
 				if (_attachmentsPost[i] == obj) {
 					found = true;
-					_gameRef->unregisterObject(_attachmentsPost[i]);
+					_game->unregisterObject(_attachmentsPost[i]);
 					_attachmentsPost.removeAt(i);
 					i--;
 				}
@@ -576,7 +576,7 @@ bool AdObject::scCallMethod(ScScript *script, ScStack *stack, ScStack *thisStack
 			for (int32 i = 0; i < _attachmentsPre.getSize(); i++) {
 				if (_attachmentsPre[i]->_name && scumm_stricmp(_attachmentsPre[i]->_name, attachmentName) == 0) {
 					found = true;
-					_gameRef->unregisterObject(_attachmentsPre[i]);
+					_game->unregisterObject(_attachmentsPre[i]);
 					_attachmentsPre.removeAt(i);
 					i--;
 				}
@@ -584,7 +584,7 @@ bool AdObject::scCallMethod(ScScript *script, ScStack *stack, ScStack *thisStack
 			for (int32 i = 0; i < _attachmentsPost.getSize(); i++) {
 				if (_attachmentsPost[i]->_name && scumm_stricmp(_attachmentsPost[i]->_name, attachmentName) == 0) {
 					found = true;
-					_gameRef->unregisterObject(_attachmentsPost[i]);
+					_game->unregisterObject(_attachmentsPost[i]);
 					_attachmentsPost.removeAt(i);
 					i--;
 				}
@@ -838,10 +838,10 @@ const char *AdObject::scToString() {
 //////////////////////////////////////////////////////////////////////////
 bool AdObject::setFont(const char *filename) {
 	if (_font) {
-		_gameRef->_fontStorage->removeFont(_font);
+		_game->_fontStorage->removeFont(_font);
 	}
 	if (filename) {
-		_font = _gameRef->_fontStorage->addFont(filename);
+		_font = _game->_fontStorage->addFont(filename);
 		return _font == nullptr ? STATUS_FAILED : STATUS_OK;
 	} else {
 		_font = nullptr;
@@ -862,7 +862,7 @@ int32 AdObject::getHeight() {
 		}
 
 		if (_zoomable) {
-			float zoom = ((AdGame *)_gameRef)->_scene->getZoomAt(_posX, _posY);
+			float zoom = ((AdGame *)_game)->_scene->getZoomAt(_posX, _posY);
 			ret = (int32)(ret * zoom / 100);
 		}
 		return ret;
@@ -872,7 +872,7 @@ int32 AdObject::getHeight() {
 //////////////////////////////////////////////////////////////////////////
 void AdObject::talk(const char *text, const char *sound, uint32 duration, const char *stances, TTextAlign Align) {
 	if (!_sentence) {
-		_sentence = new AdSentence(_gameRef);
+		_sentence = new AdSentence(_game);
 	}
 	if (!_sentence) {
 		return;
@@ -886,21 +886,21 @@ void AdObject::talk(const char *text, const char *sound, uint32 duration, const
 	SAFE_DELETE(_sentence->_sound);
 
 	_sentence->setText(text);
-	_gameRef->expandStringByStringTable(&_sentence->_text);
+	_game->expandStringByStringTable(&_sentence->_text);
 	_sentence->setStances(stances);
 	_sentence->_duration = duration;
 	_sentence->_align = Align;
-	_sentence->_startTime = _gameRef->getTimer()->getTime();
+	_sentence->_startTime = _game->getTimer()->getTime();
 	_sentence->_currentStance = -1;
-	_sentence->_font = _font == nullptr ? _gameRef->_systemFont : _font;
+	_sentence->_font = _font == nullptr ? _game->_systemFont : _font;
 	_sentence->_freezable = _freezable;
 
 	// try to locate speech file automatically
 	bool deleteSound = false;
 	if (!sound) {
-		char *key = _gameRef->getKeyFromStringTable(text);
+		char *key = _game->getKeyFromStringTable(text);
 		if (key) {
-			sound = ((AdGame *)_gameRef)->findSpeechFile(key);
+			sound = ((AdGame *)_game)->findSpeechFile(key);
 			delete[] key;
 
 			if (sound) {
@@ -911,7 +911,7 @@ void AdObject::talk(const char *text, const char *sound, uint32 duration, const
 
 	// load sound and set duration appropriately
 	if (sound) {
-		BaseSound *snd = new BaseSound(_gameRef);
+		BaseSound *snd = new BaseSound(_game);
 		if (snd && DID_SUCCEED(snd->setSound(sound, Audio::Mixer::kSpeechSoundType, true))) {
 			_sentence->setSound(snd);
 			if (_sentence->_duration <= 0) {
@@ -927,7 +927,7 @@ void AdObject::talk(const char *text, const char *sound, uint32 duration, const
 
 	// set duration by text length
 	if (_sentence->_duration <= 0) {
-		_sentence->_duration = MAX<int32>((size_t)1000, _gameRef->_subtitlesSpeed * strlen(_sentence->_text));
+		_sentence->_duration = MAX<int32>((size_t)1000, _game->_subtitlesSpeed * strlen(_sentence->_text));
 	}
 
 
@@ -937,18 +937,18 @@ void AdObject::talk(const char *text, const char *sound, uint32 duration, const
 	y = _posY;
 
 	if (!_sceneIndependent && _subtitlesModRelative) {
-		x -= ((AdGame *)_gameRef)->_scene->getOffsetLeft();
-		y -= ((AdGame *)_gameRef)->_scene->getOffsetTop();
+		x -= ((AdGame *)_game)->_scene->getOffsetLeft();
+		y -= ((AdGame *)_game)->_scene->getOffsetTop();
 	}
 
 
 	if (_subtitlesWidth > 0) {
 		width = _subtitlesWidth;
 	} else {
-		if ((x < _gameRef->_renderer->getWidth() / 4 || x > _gameRef->_renderer->getWidth() * 0.75)) {
-			width = MAX(_gameRef->_renderer->getWidth() / 4, MIN(x * 2, (_gameRef->_renderer->getWidth() - x) * 2));
+		if ((x < _game->_renderer->getWidth() / 4 || x > _game->_renderer->getWidth() * 0.75)) {
+			width = MAX(_game->_renderer->getWidth() / 4, MIN(x * 2, (_game->_renderer->getWidth() - x) * 2));
 		} else {
-			width = _gameRef->_renderer->getWidth() / 2;
+			width = _game->_renderer->getWidth() / 2;
 		}
 	}
 
@@ -967,8 +967,8 @@ void AdObject::talk(const char *text, const char *sound, uint32 duration, const
 	}
 
 
-	x = MIN(MAX<int32>(0, x), _gameRef->_renderer->getWidth() - width);
-	y = MIN(MAX<int32>(0, y), _gameRef->_renderer->getHeight() - height);
+	x = MIN(MAX<int32>(0, x), _game->_renderer->getWidth() - width);
+	y = MIN(MAX<int32>(0, y), _game->_renderer->getHeight() - height);
 
 	_sentence->_width = width;
 
@@ -978,8 +978,8 @@ void AdObject::talk(const char *text, const char *sound, uint32 duration, const
 
 
 	if (_subtitlesModRelative) {
-		_sentence->_pos.x += ((AdGame *)_gameRef)->_scene->getOffsetLeft();
-		_sentence->_pos.y += ((AdGame *)_gameRef)->_scene->getOffsetTop();
+		_sentence->_pos.x += ((AdGame *)_game)->_scene->getOffsetLeft();
+		_sentence->_pos.y += ((AdGame *)_game)->_scene->getOffsetTop();
 	}
 
 	_sentence->_fixedPos = !_subtitlesModRelative;
@@ -1007,7 +1007,7 @@ bool AdObject::reset() {
 
 	_state = _nextState = STATE_READY;
 
-	_gameRef->_scEngine->resetObject(this);
+	_game->_scEngine->resetObject(this);
 
 	return STATUS_OK;
 }
@@ -1108,7 +1108,7 @@ bool AdObject::saveAsText(BaseDynamicBuffer *buffer, int indent) {
 
 //////////////////////////////////////////////////////////////////////////
 bool AdObject::updateBlockRegion() {
-	AdGame *adGame = (AdGame *)_gameRef;
+	AdGame *adGame = (AdGame *)_game;
 	if (adGame->_scene) {
 		if (_blockRegion && _currentBlockRegion) {
 			_currentBlockRegion->mimic(_blockRegion, _zoomable ? adGame->_scene->getScaleAt(_posY) : 100.0f, _posX, _posY);
@@ -1124,8 +1124,8 @@ bool AdObject::updateBlockRegion() {
 //////////////////////////////////////////////////////////////////////////
 AdInventory *AdObject::getInventory() {
 	if (!_inventory) {
-		_inventory = new AdInventory(_gameRef);
-		((AdGame *)_gameRef)->registerInventory(_inventory);
+		_inventory = new AdInventory(_game);
+		((AdGame *)_game)->registerInventory(_inventory);
 	}
 	return _inventory;
 }
@@ -1135,7 +1135,7 @@ AdInventory *AdObject::getInventory() {
 bool AdObject::afterMove() {
 	AdRegion *newRegions[MAX_NUM_REGIONS];
 
-	((AdGame *)_gameRef)->_scene->getRegionsAt(_posX, _posY, newRegions, MAX_NUM_REGIONS);
+	((AdGame *)_game)->_scene->getRegionsAt(_posX, _posY, newRegions, MAX_NUM_REGIONS);
 	for (int i = 0; i < MAX_NUM_REGIONS; i++) {
 		if (!newRegions[i]) {
 			break;
@@ -1154,7 +1154,7 @@ bool AdObject::afterMove() {
 	}
 
 	for (int i = 0; i < MAX_NUM_REGIONS; i++) {
-		if (_currentRegions[i] && _gameRef->validObject(_currentRegions[i])) {
+		if (_currentRegions[i] && _game->validObject(_currentRegions[i])) {
 			_currentRegions[i]->applyEvent("ActorLeave");
 		}
 		_currentRegions[i] = newRegions[i];
@@ -1181,7 +1181,7 @@ bool AdObject::getScale(float *scaleX, float *scaleY) {
 		} else if (_scale >= 0) {
 			*scaleX = *scaleY = _scale;
 		} else {
-			*scaleX = *scaleY = ((AdGame *)_gameRef)->_scene->getZoomAt(_posX, _posY) + _relativeScale;
+			*scaleX = *scaleY = ((AdGame *)_game)->_scene->getZoomAt(_posX, _posY) + _relativeScale;
 		}
 	} else {
 		*scaleX = *scaleY = 100;
@@ -1261,9 +1261,9 @@ PartEmitter *AdObject::createParticleEmitter(bool followParent, int offsetX, int
 	_partOffsetY = offsetY;
 
 	if (!_partEmitter) {
-		_partEmitter = new PartEmitter(_gameRef, this);
+		_partEmitter = new PartEmitter(_game, this);
 		if (_partEmitter) {
-			_gameRef->registerObject(_partEmitter);
+			_game->registerObject(_partEmitter);
 		}
 	}
 	updatePartEmitter();
diff --git a/engines/wintermute/ad/ad_object_3d.cpp b/engines/wintermute/ad/ad_object_3d.cpp
index 6d6a7690e35..16068c289d2 100644
--- a/engines/wintermute/ad/ad_object_3d.cpp
+++ b/engines/wintermute/ad/ad_object_3d.cpp
@@ -104,7 +104,7 @@ bool AdObject3D::removeIgnoredLight(char *lightName) {
 
 //////////////////////////////////////////////////////////////////////////
 bool AdObject3D::update() {
-	AdGame *adGame = (AdGame *)_gameRef;
+	AdGame *adGame = (AdGame *)_game;
 
 	// drop to floor
 	if (_dropToFloor && adGame->_scene && adGame->_scene->_geom) {
@@ -125,7 +125,7 @@ bool AdObject3D::update() {
 
 //////////////////////////////////////////////////////////////////////////
 bool AdObject3D::convert3DTo2D(DXMatrix *worldMat, int32 *posX, int32 *posY) {
-	BaseRenderer3D *renderer = _gameRef->_renderer3D;
+	BaseRenderer3D *renderer = _game->_renderer3D;
 	DXMatrix viewMat, projMat;
 	DXVector3 vec2d(0.0f, 0.0f, 0.0f);
 	renderer->getViewTransform(&viewMat);
@@ -136,8 +136,8 @@ bool AdObject3D::convert3DTo2D(DXMatrix *worldMat, int32 *posX, int32 *posY) {
 	DXVector3 origin(0.0f, 0.0f, 0.0f);
 	DXVec3Project(&vec2d, &origin, &viewport, &projMat, &viewMat, worldMat);
 
-	*posX = vec2d._x + _gameRef->_offsetX - _gameRef->_renderer3D->_drawOffsetX;
-	*posY = vec2d._y + _gameRef->_offsetY - _gameRef->_renderer3D->_drawOffsetY;
+	*posX = vec2d._x + _game->_offsetX - _game->_renderer3D->_drawOffsetX;
+	*posY = vec2d._y + _game->_offsetY - _game->_renderer3D->_drawOffsetY;
 
 	return true;
 }
@@ -149,7 +149,7 @@ bool AdObject3D::display() {
 
 //////////////////////////////////////////////////////////////////////////
 bool AdObject3D::setupLights() {
-	AdGame *adGame = (AdGame *)_gameRef;
+	AdGame *adGame = (AdGame *)_game;
 
 	if (adGame->_scene && adGame->_scene->_geom) {
 		return adGame->_scene->_geom->enableLights(_posVector, _ignoredLights);
@@ -406,7 +406,7 @@ bool AdObject3D::scSetProperty(const char *name, ScValue *value) {
 	//////////////////////////////////////////////////////////////////////////
 	else if (strcmp(name, "X") == 0) {
 		_posX = value->getInt();
-		AdGame *adGame = (AdGame *)_gameRef;
+		AdGame *adGame = (AdGame *)_game;
 		DXVector3 pos;
 		if (adGame->_scene->_geom && adGame->_scene->_geom->convert2Dto3D(_posX, _posY, &pos)) {
 			_posVector = pos;
@@ -419,7 +419,7 @@ bool AdObject3D::scSetProperty(const char *name, ScValue *value) {
 	//////////////////////////////////////////////////////////////////////////
 	else if (strcmp(name, "Y") == 0) {
 		_posY = value->getInt();
-		AdGame *adGame = (AdGame *)_gameRef;
+		AdGame *adGame = (AdGame *)_game;
 		DXVector3 pos;
 		if (adGame->_scene->_geom && adGame->_scene->_geom->convert2Dto3D(_posX, _posY, &pos)) {
 			_posVector = pos;
@@ -561,7 +561,7 @@ bool AdObject3D::persist(BasePersistenceManager *persistMgr) {
 
 //////////////////////////////////////////////////////////////////////////
 bool AdObject3D::skipTo(int x, int y, bool tolerant) {
-	AdGame *adGame = (AdGame *)_gameRef;
+	AdGame *adGame = (AdGame *)_game;
 	DXVector3 pos;
 
 	bool success;
@@ -584,7 +584,7 @@ bool AdObject3D::skipTo(int x, int y, bool tolerant) {
 //////////////////////////////////////////////////////////////////////////
 ShadowVolume *AdObject3D::getShadowVolume() {
 	if (_shadowVolume == nullptr)
-		_shadowVolume = _gameRef->_renderer3D->createShadowVolume();
+		_shadowVolume = _game->_renderer3D->createShadowVolume();
 	return _shadowVolume;
 }
 
@@ -594,7 +594,7 @@ bool AdObject3D::getBonePosition2D(const char *boneName, int32 *x, int32 *y) {
 		return false;
 	}
 
-	AdGame *adGame = (AdGame *)_gameRef;
+	AdGame *adGame = (AdGame *)_game;
 	if (!adGame->_scene || !adGame->_scene->_geom)
 		return false;
 
diff --git a/engines/wintermute/ad/ad_path.cpp b/engines/wintermute/ad/ad_path.cpp
index e686a99ca13..23af86d1074 100644
--- a/engines/wintermute/ad/ad_path.cpp
+++ b/engines/wintermute/ad/ad_path.cpp
@@ -107,7 +107,7 @@ bool AdPath::setReady(bool ready) {
 //////////////////////////////////////////////////////////////////////////
 bool AdPath::persist(BasePersistenceManager *persistMgr) {
 
-	persistMgr->transferPtr(TMEMBER_PTR(_gameRef));
+	persistMgr->transferPtr(TMEMBER_PTR(_game));
 
 	persistMgr->transferSint32(TMEMBER(_currIndex));
 	_points.persist(persistMgr);
diff --git a/engines/wintermute/ad/ad_path3d.cpp b/engines/wintermute/ad/ad_path3d.cpp
index af0cf82d740..14c15fc07f4 100644
--- a/engines/wintermute/ad/ad_path3d.cpp
+++ b/engines/wintermute/ad/ad_path3d.cpp
@@ -103,7 +103,7 @@ DXVector3 *AdPath3D::getCurrent() {
 
 //////////////////////////////////////////////////////////////////////////
 bool AdPath3D::persist(BasePersistenceManager *persistMgr) {
-	persistMgr->transferPtr(TMEMBER(_gameRef));
+	persistMgr->transferPtr(TMEMBER(_game));
 
 	persistMgr->transferSint32(TMEMBER(_currIndex));
 	persistMgr->transferBool(TMEMBER(_ready));
diff --git a/engines/wintermute/ad/ad_region.cpp b/engines/wintermute/ad/ad_region.cpp
index 6b89bd8213a..68d9b5bb1df 100644
--- a/engines/wintermute/ad/ad_region.cpp
+++ b/engines/wintermute/ad/ad_region.cpp
@@ -55,7 +55,7 @@ AdRegion::~AdRegion() {
 bool AdRegion::loadFile(const char *filename) {
 	char *buffer = (char *)BaseFileManager::getEngineInstance()->readWholeFile(filename);
 	if (buffer == nullptr) {
-		_gameRef->LOG(0, "AdRegion::LoadFile failed for file '%s'", filename);
+		_game->LOG(0, "AdRegion::LoadFile failed for file '%s'", filename);
 		return STATUS_FAILED;
 	}
 
@@ -64,7 +64,7 @@ bool AdRegion::loadFile(const char *filename) {
 	setFilename(filename);
 
 	if (DID_FAIL(ret = loadBuffer(buffer, true))) {
-		_gameRef->LOG(0, "Error parsing REGION file '%s'", filename);
+		_game->LOG(0, "Error parsing REGION file '%s'", filename);
 	}
 
 
@@ -121,7 +121,7 @@ bool AdRegion::loadBuffer(char *buffer, bool complete) {
 
 	if (complete) {
 		if (parser.getCommand(&buffer, commands, &params) != TOKEN_REGION) {
-			_gameRef->LOG(0, "'REGION' keyword expected.");
+			_game->LOG(0, "'REGION' keyword expected.");
 			return STATUS_FAILED;
 		}
 		buffer = params;
@@ -210,7 +210,7 @@ bool AdRegion::loadBuffer(char *buffer, bool complete) {
 		}
 	}
 	if (cmd == PARSERR_TOKENNOTFOUND) {
-		_gameRef->LOG(0, "Syntax error in REGION definition");
+		_game->LOG(0, "Syntax error in REGION definition");
 		return STATUS_FAILED;
 	}
 
diff --git a/engines/wintermute/ad/ad_response.cpp b/engines/wintermute/ad/ad_response.cpp
index 54a333aff70..a308497c333 100644
--- a/engines/wintermute/ad/ad_response.cpp
+++ b/engines/wintermute/ad/ad_response.cpp
@@ -55,7 +55,7 @@ AdResponse::~AdResponse() {
 	SAFE_DELETE(_iconHover);
 	SAFE_DELETE(_iconPressed);
 	if (_font) {
-		_gameRef->_fontStorage->removeFont(_font);
+		_game->_fontStorage->removeFont(_font);
 	}
 }
 
@@ -70,9 +70,9 @@ void AdResponse::setText(const char *text) {
 //////////////////////////////////////////////////////////////////////////
 bool AdResponse::setIcon(const char *filename) {
 	delete _icon;
-	_icon = new BaseSprite(_gameRef);
+	_icon = new BaseSprite(_game);
 	if (!_icon || DID_FAIL(_icon->loadFile(filename))) {
-		_gameRef->LOG(0, "AdResponse::setIcon failed for file '%s'", filename);
+		_game->LOG(0, "AdResponse::setIcon failed for file '%s'", filename);
 		SAFE_DELETE(_icon);
 		return STATUS_FAILED;
 	}
@@ -82,11 +82,11 @@ bool AdResponse::setIcon(const char *filename) {
 //////////////////////////////////////////////////////////////////////////
 bool AdResponse::setFont(const char *filename) {
 	if (_font) {
-		_gameRef->_fontStorage->removeFont(_font);
+		_game->_fontStorage->removeFont(_font);
 	}
-	_font = _gameRef->_fontStorage->addFont(filename);
+	_font = _game->_fontStorage->addFont(filename);
 	if (!_font) {
-		_gameRef->LOG(0, "AdResponse::setFont failed for file '%s'", filename);
+		_game->LOG(0, "AdResponse::setFont failed for file '%s'", filename);
 		return STATUS_FAILED;
 	}
 	return STATUS_OK;
@@ -95,9 +95,9 @@ bool AdResponse::setFont(const char *filename) {
 //////////////////////////////////////////////////////////////////////////
 bool AdResponse::setIconHover(const char *filename) {
 	SAFE_DELETE(_iconHover);
-	_iconHover = new BaseSprite(_gameRef);
+	_iconHover = new BaseSprite(_game);
 	if (!_iconHover || DID_FAIL(_iconHover->loadFile(filename))) {
-		_gameRef->LOG(0, "AdResponse::setIconHover failed for file '%s'", filename);
+		_game->LOG(0, "AdResponse::setIconHover failed for file '%s'", filename);
 		SAFE_DELETE(_iconHover);
 		return STATUS_FAILED;
 	}
@@ -108,9 +108,9 @@ bool AdResponse::setIconHover(const char *filename) {
 //////////////////////////////////////////////////////////////////////////
 bool AdResponse::setIconPressed(const char *filename) {
 	SAFE_DELETE(_iconPressed);
-	_iconPressed = new BaseSprite(_gameRef);
+	_iconPressed = new BaseSprite(_game);
 	if (!_iconPressed || DID_FAIL(_iconPressed->loadFile(filename))) {
-		_gameRef->LOG(0, "AdResponse::setIconPressed failed for file '%s'", filename);
+		_game->LOG(0, "AdResponse::setIconPressed failed for file '%s'", filename);
 		SAFE_DELETE(_iconPressed);
 		return STATUS_FAILED;
 	}
diff --git a/engines/wintermute/ad/ad_response_box.cpp b/engines/wintermute/ad/ad_response_box.cpp
index 720d09472ef..f74cd852b88 100644
--- a/engines/wintermute/ad/ad_response_box.cpp
+++ b/engines/wintermute/ad/ad_response_box.cpp
@@ -57,7 +57,7 @@ AdResponseBox::AdResponseBox(BaseGame *inGame) : BaseObject(inGame) {
 	_font = _fontHover = nullptr;
 
 	_window = nullptr;
-	_shieldWindow = new UIWindow(_gameRef);
+	_shieldWindow = new UIWindow(_game);
 
 	_horizontal = false;
 	BasePlatform::setRectEmpty(&_responseArea);
@@ -81,10 +81,10 @@ AdResponseBox::~AdResponseBox() {
 	SAFE_DELETE_ARRAY(_lastResponseTextOrig);
 
 	if (_font) {
-		_gameRef->_fontStorage->removeFont(_font);
+		_game->_fontStorage->removeFont(_font);
 	}
 	if (_fontHover) {
-		_gameRef->_fontStorage->removeFont(_fontHover);
+		_game->_fontStorage->removeFont(_fontHover);
 	}
 
 	clearResponses();
@@ -131,7 +131,7 @@ bool AdResponseBox::createButtons() {
 
 	_scrollOffset = 0;
 	for (int32 i = 0; i < _responses.getSize(); i++) {
-		UIButton *btn = new UIButton(_gameRef);
+		UIButton *btn = new UIButton(_game);
 		if (btn) {
 			btn->_parent = _window;
 			btn->_sharedFonts = btn->_sharedImages = true;
@@ -149,15 +149,15 @@ bool AdResponseBox::createButtons() {
 				btn->setCaption(_responses[i]->_text);
 				if (_cursor) {
 					btn->_cursor = _cursor;
-				} else if (_gameRef->_activeCursor) {
-					btn->_cursor = _gameRef->_activeCursor;
+				} else if (_game->_activeCursor) {
+					btn->_cursor = _game->_activeCursor;
 				}
 			}
 			// textual
 			else {
 				btn->setText(_responses[i]->_text);
-				btn->_font = (_font == nullptr) ? _gameRef->_systemFont : _font;
-				btn->_fontHover = (_fontHover == nullptr) ? _gameRef->_systemFont : _fontHover;
+				btn->_font = (_font == nullptr) ? _game->_systemFont : _font;
+				btn->_fontHover = (_fontHover == nullptr) ? _game->_systemFont : _fontHover;
 				btn->_fontPress = btn->_fontHover;
 				btn->_align = _align;
 
@@ -167,7 +167,7 @@ bool AdResponseBox::createButtons() {
 
 				btn->_width = _responseArea.right - _responseArea.left;
 				if (btn->_width <= 0) {
-					btn->_width = _gameRef->_renderer->getWidth();
+					btn->_width = _game->_renderer->getWidth();
 				}
 			}
 
@@ -190,7 +190,7 @@ bool AdResponseBox::createButtons() {
 			_respButtons.add(btn);
 
 			if (_responseArea.bottom - _responseArea.top < btn->_height) {
-				_gameRef->LOG(0, "Warning: Response '%s' is too high to be displayed within response box. Correcting.", _responses[i]->_text);
+				_game->LOG(0, "Warning: Response '%s' is too high to be displayed within response box. Correcting.", _responses[i]->_text);
 				_responseArea.bottom += (btn->_height - (_responseArea.bottom - _responseArea.top));
 			}
 		}
@@ -205,7 +205,7 @@ bool AdResponseBox::createButtons() {
 bool AdResponseBox::loadFile(const char *filename) {
 	char *buffer = (char *)BaseFileManager::getEngineInstance()->readWholeFile(filename);
 	if (buffer == nullptr) {
-		_gameRef->LOG(0, "AdResponseBox::LoadFile failed for file '%s'", filename);
+		_game->LOG(0, "AdResponseBox::LoadFile failed for file '%s'", filename);
 		return STATUS_FAILED;
 	}
 
@@ -214,7 +214,7 @@ bool AdResponseBox::loadFile(const char *filename) {
 	setFilename(filename);
 
 	if (DID_FAIL(ret = loadBuffer(buffer, true))) {
-		_gameRef->LOG(0, "Error parsing RESPONSE_BOX file '%s'", filename);
+		_game->LOG(0, "Error parsing RESPONSE_BOX file '%s'", filename);
 	}
 
 
@@ -262,7 +262,7 @@ bool AdResponseBox::loadBuffer(char *buffer, bool complete) {
 
 	if (complete) {
 		if (parser.getCommand(&buffer, commands, &params) != TOKEN_RESPONSE_BOX) {
-			_gameRef->LOG(0, "'RESPONSE_BOX' keyword expected.");
+			_game->LOG(0, "'RESPONSE_BOX' keyword expected.");
 			return STATUS_FAILED;
 		}
 		buffer = params;
@@ -278,7 +278,7 @@ bool AdResponseBox::loadBuffer(char *buffer, bool complete) {
 
 		case TOKEN_WINDOW:
 			SAFE_DELETE(_window);
-			_window = new UIWindow(_gameRef);
+			_window = new UIWindow(_game);
 			if (!_window || DID_FAIL(_window->loadBuffer(params, false))) {
 				SAFE_DELETE(_window);
 				cmd = PARSERR_GENERIC;
@@ -289,9 +289,9 @@ bool AdResponseBox::loadBuffer(char *buffer, bool complete) {
 
 		case TOKEN_FONT:
 			if (_font) {
-				_gameRef->_fontStorage->removeFont(_font);
+				_game->_fontStorage->removeFont(_font);
 			}
-			_font = _gameRef->_fontStorage->addFont(params);
+			_font = _game->_fontStorage->addFont(params);
 			if (!_font) {
 				cmd = PARSERR_GENERIC;
 			}
@@ -299,9 +299,9 @@ bool AdResponseBox::loadBuffer(char *buffer, bool complete) {
 
 		case TOKEN_FONT_HOVER:
 			if (_fontHover) {
-				_gameRef->_fontStorage->removeFont(_fontHover);
+				_game->_fontStorage->removeFont(_fontHover);
 			}
-			_fontHover = _gameRef->_fontStorage->addFont(params);
+			_fontHover = _game->_fontStorage->addFont(params);
 			if (!_fontHover) {
 				cmd = PARSERR_GENERIC;
 			}
@@ -345,7 +345,7 @@ bool AdResponseBox::loadBuffer(char *buffer, bool complete) {
 
 		case TOKEN_CURSOR:
 			SAFE_DELETE(_cursor);
-			_cursor = new BaseSprite(_gameRef);
+			_cursor = new BaseSprite(_game);
 			if (!_cursor || DID_FAIL(_cursor->loadFile(params))) {
 				SAFE_DELETE(_cursor);
 				cmd = PARSERR_GENERIC;
@@ -357,7 +357,7 @@ bool AdResponseBox::loadBuffer(char *buffer, bool complete) {
 		}
 	}
 	if (cmd == PARSERR_TOKENNOTFOUND) {
-		_gameRef->LOG(0, "Syntax error in RESPONSE_BOX definition");
+		_game->LOG(0, "Syntax error in RESPONSE_BOX definition");
 		return STATUS_FAILED;
 	}
 
@@ -527,8 +527,8 @@ bool AdResponseBox::display() {
 	// go exclusive
 	if (_shieldWindow) {
 		_shieldWindow->_posX = _shieldWindow->_posY = 0;
-		_shieldWindow->_width = _gameRef->_renderer->getWidth();
-		_shieldWindow->_height = _gameRef->_renderer->getHeight();
+		_shieldWindow->_width = _game->_renderer->getWidth();
+		_shieldWindow->_height = _game->_renderer->getHeight();
 
 		_shieldWindow->display();
 	}
@@ -564,8 +564,8 @@ bool AdResponseBox::listen(BaseScriptHolder *param1, uint32 param2) {
 			}
 			handleResponse(_responses[param2]);
 			_waitingScript = nullptr;
-			_gameRef->_state = GAME_RUNNING;
-			((AdGame *)_gameRef)->_stateEx = GAME_NORMAL;
+			_game->_state = GAME_RUNNING;
+			((AdGame *)_game)->_stateEx = GAME_NORMAL;
 			_ready = true;
 			invalidateButtons();
 			clearResponses();
@@ -608,7 +608,7 @@ bool AdResponseBox::persist(BasePersistenceManager *persistMgr) {
 
 //////////////////////////////////////////////////////////////////////////
 bool AdResponseBox::weedResponses() {
-	AdGame *adGame = (AdGame *)_gameRef;
+	AdGame *adGame = (AdGame *)_game;
 
 	for (int32 i = 0; i < _responses.getSize(); i++) {
 		switch (_responses[i]->_responseType) {
@@ -646,7 +646,7 @@ void AdResponseBox::setLastResponseText(const char *text, const char *textOrig)
 bool AdResponseBox::handleResponse(const AdResponse *response) {
 	setLastResponseText(response->_text, response->_textOrig);
 
-	AdGame *adGame = (AdGame *)_gameRef;
+	AdGame *adGame = (AdGame *)_game;
 
 	switch (response->_responseType) {
 	case RESPONSE_ONCE:
diff --git a/engines/wintermute/ad/ad_response_context.cpp b/engines/wintermute/ad/ad_response_context.cpp
index d2bef0ff969..a97dfffc403 100644
--- a/engines/wintermute/ad/ad_response_context.cpp
+++ b/engines/wintermute/ad/ad_response_context.cpp
@@ -48,7 +48,7 @@ AdResponseContext::~AdResponseContext() {
 
 //////////////////////////////////////////////////////////////////////////
 bool AdResponseContext::persist(BasePersistenceManager *persistMgr) {
-	persistMgr->transferPtr(TMEMBER_PTR(_gameRef));
+	persistMgr->transferPtr(TMEMBER_PTR(_game));
 	persistMgr->transferCharPtr(TMEMBER(_context));
 	persistMgr->transferSint32(TMEMBER(_id));
 
diff --git a/engines/wintermute/ad/ad_rot_level.cpp b/engines/wintermute/ad/ad_rot_level.cpp
index 686b8b8d694..79c9e56febc 100644
--- a/engines/wintermute/ad/ad_rot_level.cpp
+++ b/engines/wintermute/ad/ad_rot_level.cpp
@@ -54,7 +54,7 @@ AdRotLevel::~AdRotLevel() {
 bool AdRotLevel::loadFile(const char *filename) {
 	char *buffer = (char *)BaseFileManager::getEngineInstance()->readWholeFile(filename);
 	if (buffer == nullptr) {
-		_gameRef->LOG(0, "AdRotLevel::LoadFile failed for file '%s'", filename);
+		_game->LOG(0, "AdRotLevel::LoadFile failed for file '%s'", filename);
 		return STATUS_FAILED;
 	}
 
@@ -63,7 +63,7 @@ bool AdRotLevel::loadFile(const char *filename) {
 	setFilename(filename);
 
 	if (DID_FAIL(ret = loadBuffer(buffer, true))) {
-		_gameRef->LOG(0, "Error parsing ROTATION_LEVEL file '%s'", filename);
+		_game->LOG(0, "Error parsing ROTATION_LEVEL file '%s'", filename);
 	}
 
 
@@ -96,7 +96,7 @@ bool AdRotLevel::loadBuffer(char *buffer, bool complete) {
 
 	if (complete) {
 		if (parser.getCommand(&buffer, commands, &params) != TOKEN_ROTATION_LEVEL) {
-			_gameRef->LOG(0, "'ROTATION_LEVEL' keyword expected.");
+			_game->LOG(0, "'ROTATION_LEVEL' keyword expected.");
 			return STATUS_FAILED;
 		}
 		buffer = params;
@@ -130,7 +130,7 @@ bool AdRotLevel::loadBuffer(char *buffer, bool complete) {
 		}
 	}
 	if (cmd == PARSERR_TOKENNOTFOUND) {
-		_gameRef->LOG(0, "Syntax error in ROTATION_LEVEL definition");
+		_game->LOG(0, "Syntax error in ROTATION_LEVEL definition");
 		return STATUS_FAILED;
 	}
 
diff --git a/engines/wintermute/ad/ad_scale_level.cpp b/engines/wintermute/ad/ad_scale_level.cpp
index a67ef57cff2..ad776abfd74 100644
--- a/engines/wintermute/ad/ad_scale_level.cpp
+++ b/engines/wintermute/ad/ad_scale_level.cpp
@@ -51,7 +51,7 @@ AdScaleLevel::~AdScaleLevel() {
 bool AdScaleLevel::loadFile(const char *filename) {
 	char *buffer = (char *)BaseFileManager::getEngineInstance()->readWholeFile(filename);
 	if (buffer == nullptr) {
-		_gameRef->LOG(0, "AdScaleLevel::LoadFile failed for file '%s'", filename);
+		_game->LOG(0, "AdScaleLevel::LoadFile failed for file '%s'", filename);
 		return STATUS_FAILED;
 	}
 
@@ -60,7 +60,7 @@ bool AdScaleLevel::loadFile(const char *filename) {
 	setFilename(filename);
 
 	if (DID_FAIL(ret = loadBuffer(buffer, true))) {
-		_gameRef->LOG(0, "Error parsing SCALE_LEVEL file '%s'", filename);
+		_game->LOG(0, "Error parsing SCALE_LEVEL file '%s'", filename);
 	}
 
 
@@ -93,7 +93,7 @@ bool AdScaleLevel::loadBuffer(char *buffer, bool complete) {
 
 	if (complete) {
 		if (parser.getCommand(&buffer, commands, &params) != TOKEN_SCALE_LEVEL) {
-			_gameRef->LOG(0, "'SCALE_LEVEL' keyword expected.");
+			_game->LOG(0, "'SCALE_LEVEL' keyword expected.");
 			return STATUS_FAILED;
 		}
 		buffer = params;
@@ -127,7 +127,7 @@ bool AdScaleLevel::loadBuffer(char *buffer, bool complete) {
 		}
 	}
 	if (cmd == PARSERR_TOKENNOTFOUND) {
-		_gameRef->LOG(0, "Syntax error in SCALE_LEVEL definition");
+		_game->LOG(0, "Syntax error in SCALE_LEVEL definition");
 		return STATUS_FAILED;
 	}
 
diff --git a/engines/wintermute/ad/ad_scene.cpp b/engines/wintermute/ad/ad_scene.cpp
index fa71f91e4a1..9c1258bec3b 100644
--- a/engines/wintermute/ad/ad_scene.cpp
+++ b/engines/wintermute/ad/ad_scene.cpp
@@ -83,7 +83,7 @@ AdScene::AdScene(BaseGame *inGame) : BaseObject(inGame) {
 //////////////////////////////////////////////////////////////////////////
 AdScene::~AdScene() {
 	cleanup();
-	_gameRef->unregisterObject(_fader);
+	_game->unregisterObject(_fader);
 	SAFE_DELETE(_pfTarget);
 }
 
@@ -147,8 +147,8 @@ void AdScene::setDefaults() {
 
 	_shieldWindow = nullptr;
 
-	_fader = new BaseFader(_gameRef);
-	_gameRef->registerObject(_fader);
+	_fader = new BaseFader(_game);
+	_game->registerObject(_fader);
 
 #ifdef ENABLE_WME3D
 	_fov = -1.0f;
@@ -181,27 +181,27 @@ void AdScene::cleanup() {
 
 	SAFE_DELETE(_shieldWindow);
 
-	_gameRef->unregisterObject(_fader);
+	_game->unregisterObject(_fader);
 	_fader = nullptr;
 
 	for (int32 i = 0; i < _layers.getSize(); i++) {
-		_gameRef->unregisterObject(_layers[i]);
+		_game->unregisterObject(_layers[i]);
 	}
 	_layers.removeAll();
 
 
 	for (int32 i = 0; i < _waypointGroups.getSize(); i++) {
-		_gameRef->unregisterObject(_waypointGroups[i]);
+		_game->unregisterObject(_waypointGroups[i]);
 	}
 	_waypointGroups.removeAll();
 
 	for (int32 i = 0; i < _scaleLevels.getSize(); i++) {
-		_gameRef->unregisterObject(_scaleLevels[i]);
+		_game->unregisterObject(_scaleLevels[i]);
 	}
 	_scaleLevels.removeAll();
 
 	for (int32 i = 0; i < _rotLevels.getSize(); i++) {
-		_gameRef->unregisterObject(_rotLevels[i]);
+		_game->unregisterObject(_rotLevels[i]);
 	}
 	_rotLevels.removeAll();
 
@@ -213,7 +213,7 @@ void AdScene::cleanup() {
 	_pfPointsNum = 0;
 
 	for (int32 i = 0; i < _objects.getSize(); i++) {
-		_gameRef->unregisterObject(_objects[i]);
+		_game->unregisterObject(_objects[i]);
 	}
 	_objects.removeAll();
 
@@ -288,7 +288,7 @@ bool AdScene::getPath(const BasePoint &source, const BasePoint &target, AdPath *
 				pfAddWaypointGroup(_objects[i]->_currentWptGroup, requester);
 			}
 		}
-		AdGame *adGame = (AdGame *)_gameRef;
+		AdGame *adGame = (AdGame *)_game;
 		for (int32 i = 0; i < adGame->_objects.getSize(); i++) {
 			if (adGame->_objects[i]->_active && adGame->_objects[i] != requester && adGame->_objects[i]->_currentWptGroup) {
 				pfAddWaypointGroup(adGame->_objects[i]->_currentWptGroup, requester);
@@ -344,7 +344,7 @@ float AdScene::getZoomAt(int x, int y) {
 
 //////////////////////////////////////////////////////////////////////////
 uint32 AdScene::getAlphaAt(int x, int y, bool colorCheck) {
-	if (!_gameRef->_debugDebugMode) {
+	if (!_game->_debugDebugMode) {
 		colorCheck = false;
 	}
 
@@ -382,7 +382,7 @@ bool AdScene::isBlockedAt(int x, int y, bool checkFreeObjects, BaseObject *reque
 				}
 			}
 		}
-		AdGame *adGame = (AdGame *)_gameRef;
+		AdGame *adGame = (AdGame *)_game;
 		for (int32 i = 0; i < adGame->_objects.getSize(); i++) {
 			if (adGame->_objects[i]->_active && adGame->_objects[i] != requester && adGame->_objects[i]->_currentBlockRegion) {
 				if (adGame->_objects[i]->_currentBlockRegion->pointInRegion(x, y)) {
@@ -429,7 +429,7 @@ bool AdScene::isWalkableAt(int x, int y, bool checkFreeObjects, BaseObject *requ
 				}
 			}
 		}
-		AdGame *adGame = (AdGame *)_gameRef;
+		AdGame *adGame = (AdGame *)_game;
 		for (int32 i = 0; i < adGame->_objects.getSize(); i++) {
 			if (adGame->_objects[i]->_active && adGame->_objects[i] != requester && adGame->_objects[i]->_currentBlockRegion) {
 				if (adGame->_objects[i]->_currentBlockRegion->pointInRegion(x, y)) {
@@ -555,16 +555,16 @@ void AdScene::pathFinderStep() {
 bool AdScene::initLoop() {
 #ifdef _DEBUGxxxx
 	int nu_steps = 0;
-	uint32 start = _gameRef->_currentTime;
+	uint32 start = _game->_currentTime;
 	while (!_pfReady && g_system->getMillis() - start <= _pfMaxTime) {
 		PathFinderStep();
 		nu_steps++;
 	}
 	if (nu_steps > 0) {
-		_gameRef->LOG(0, "STAT: PathFinder iterations in one loop: %d (%s)  _pfMaxTime=%d", nu_steps, _pfReady ? "finished" : "not yet done", _pfMaxTime);
+		_game->LOG(0, "STAT: PathFinder iterations in one loop: %d (%s)  _pfMaxTime=%d", nu_steps, _pfReady ? "finished" : "not yet done", _pfMaxTime);
 	}
 #else
-	uint32 start = _gameRef->_currentTime;
+	uint32 start = _game->_currentTime;
 	while (!_pfReady && g_system->getMillis() - start <= _pfMaxTime) {
 		pathFinderStep();
 	}
@@ -583,7 +583,7 @@ bool AdScene::initLoop() {
 bool AdScene::loadFile(const char *filename) {
 	char *buffer = (char *)BaseFileManager::getEngineInstance()->readWholeFile(filename);
 	if (buffer == nullptr) {
-		_gameRef->LOG(0, "AdScene::LoadFile failed for file '%s'", filename);
+		_game->LOG(0, "AdScene::LoadFile failed for file '%s'", filename);
 		return STATUS_FAILED;
 	}
 
@@ -592,7 +592,7 @@ bool AdScene::loadFile(const char *filename) {
 	setFilename(filename);
 
 	if (DID_FAIL(ret = loadBuffer(buffer, true))) {
-		_gameRef->LOG(0, "Error parsing SCENE file '%s'", filename);
+		_game->LOG(0, "Error parsing SCENE file '%s'", filename);
 	}
 
 	setFilename(filename);
@@ -716,7 +716,7 @@ bool AdScene::loadBuffer(char *buffer, bool complete) {
 
 	if (complete) {
 		if (parser.getCommand(&buffer, commands, &params) != TOKEN_SCENE) {
-			_gameRef->LOG(0, "'SCENE' keyword expected.");
+			_game->LOG(0, "'SCENE' keyword expected.");
 			return STATUS_FAILED;
 		}
 		buffer = params;
@@ -745,12 +745,12 @@ bool AdScene::loadBuffer(char *buffer, bool complete) {
 			break;
 
 		case TOKEN_LAYER: {
-			AdLayer *layer = new AdLayer(_gameRef);
+			AdLayer *layer = new AdLayer(_game);
 			if (!layer || DID_FAIL(layer->loadBuffer(params, false))) {
 				cmd = PARSERR_GENERIC;
 				SAFE_DELETE(layer);
 			} else {
-				_gameRef->registerObject(layer);
+				_game->registerObject(layer);
 				_layers.add(layer);
 				if (layer->_main) {
 					_mainLayer = layer;
@@ -762,43 +762,43 @@ bool AdScene::loadBuffer(char *buffer, bool complete) {
 		break;
 
 		case TOKEN_WAYPOINTS: {
-			AdWaypointGroup *wpt = new AdWaypointGroup(_gameRef);
+			AdWaypointGroup *wpt = new AdWaypointGroup(_game);
 			if (!wpt || DID_FAIL(wpt->loadBuffer(params, false))) {
 				cmd = PARSERR_GENERIC;
 				SAFE_DELETE(wpt);
 			} else {
-				_gameRef->registerObject(wpt);
+				_game->registerObject(wpt);
 				_waypointGroups.add(wpt);
 			}
 		}
 		break;
 
 		case TOKEN_SCALE_LEVEL: {
-			AdScaleLevel *sl = new AdScaleLevel(_gameRef);
+			AdScaleLevel *sl = new AdScaleLevel(_game);
 			if (!sl || DID_FAIL(sl->loadBuffer(params, false))) {
 				cmd = PARSERR_GENERIC;
 				SAFE_DELETE(sl);
 			} else {
-				_gameRef->registerObject(sl);
+				_game->registerObject(sl);
 				_scaleLevels.add(sl);
 			}
 		}
 		break;
 
 		case TOKEN_ROTATION_LEVEL: {
-			AdRotLevel *rl = new AdRotLevel(_gameRef);
+			AdRotLevel *rl = new AdRotLevel(_game);
 			if (!rl || DID_FAIL(rl->loadBuffer(params, false))) {
 				cmd = PARSERR_GENERIC;
 				SAFE_DELETE(rl);
 			} else {
-				_gameRef->registerObject(rl);
+				_game->registerObject(rl);
 				_rotLevels.add(rl);
 			}
 		}
 		break;
 
 		case TOKEN_ENTITY: {
-			AdEntity *entity = new AdEntity(_gameRef);
+			AdEntity *entity = new AdEntity(_game);
 			if (!entity || DID_FAIL(entity->loadBuffer(params, false))) {
 				cmd = PARSERR_GENERIC;
 				SAFE_DELETE(entity);
@@ -810,7 +810,7 @@ bool AdScene::loadBuffer(char *buffer, bool complete) {
 
 		case TOKEN_CURSOR:
 			SAFE_DELETE(_cursor);
-			_cursor = new BaseSprite(_gameRef);
+			_cursor = new BaseSprite(_game);
 			if (!_cursor || DID_FAIL(_cursor->loadFile(params))) {
 				SAFE_DELETE(_cursor);
 				cmd = PARSERR_GENERIC;
@@ -820,10 +820,10 @@ bool AdScene::loadBuffer(char *buffer, bool complete) {
 #ifdef ENABLE_WME3D
 		case TOKEN_GEOMETRY:
 			SAFE_DELETE(_geom);
-			if (!_gameRef->_useD3D) {
+			if (!_game->_useD3D) {
 				break;
 			}
-			_geom = new AdSceneGeometry(_gameRef);
+			_geom = new AdSceneGeometry(_game);
 			if (!_geom || !_geom->loadFile(params)) {
 				SAFE_DELETE(_geom);
 				cmd = PARSERR_GENERIC;
@@ -926,7 +926,7 @@ bool AdScene::loadBuffer(char *buffer, bool complete) {
 #ifdef ENABLE_WME3D
 		case TOKEN_EDITOR_SHOW_GEOMETRY:
 			parser.scanStr(params, "%b", &_showGeometry);
-			if (!_gameRef->_editorMode)
+			if (!_game->_editorMode)
 				_showGeometry = false;
 			break;
 #endif
@@ -943,7 +943,7 @@ bool AdScene::loadBuffer(char *buffer, bool complete) {
 			Common::Rect32 rc;
 			parser.scanStr(params, "%d,%d,%d,%d", &rc.left, &rc.top, &rc.right, &rc.bottom);
 			if (!_viewport) {
-				_viewport = new BaseViewport(_gameRef);
+				_viewport = new BaseViewport(_game);
 			}
 			if (_viewport) {
 				_viewport->setRect(rc.left, rc.top, rc.right, rc.bottom, true);
@@ -1014,12 +1014,12 @@ bool AdScene::loadBuffer(char *buffer, bool complete) {
 		}
 	}
 	if (cmd == PARSERR_TOKENNOTFOUND) {
-		_gameRef->LOG(0, "Syntax error in SCENE definition");
+		_game->LOG(0, "Syntax error in SCENE definition");
 		return STATUS_FAILED;
 	}
 
 	if (_mainLayer == nullptr) {
-		_gameRef->LOG(0, "Warning: scene '%s' has no main layer.", getFilename());
+		_game->LOG(0, "Warning: scene '%s' has no main layer.", getFilename());
 	}
 
 #ifdef ENABLE_WME3D
@@ -1041,8 +1041,8 @@ bool AdScene::loadBuffer(char *buffer, bool complete) {
 		}
 
 		if (_geom->_activeCamera >= 0 && _geom->_activeCamera < _geom->_cameras.getSize()) {
-			_gameRef->_renderer->setup3D(_geom->_cameras[_geom->_activeCamera]);
-			_gameRef->_renderer->setScreenViewport();
+			_game->_renderer->setup3D(_geom->_cameras[_geom->_activeCamera]);
+			_game->_renderer->setScreenViewport();
 			_geom->render(false);
 		}
 	}
@@ -1064,17 +1064,17 @@ bool AdScene::traverseNodes(bool doUpdate) {
 		return STATUS_OK;
 	}
 
-	AdGame *adGame = (AdGame *)_gameRef;
+	AdGame *adGame = (AdGame *)_game;
 
 
 	//////////////////////////////////////////////////////////////////////////
 	// prepare viewport
 	bool popViewport = false;
-	if (_viewport && !_gameRef->_editorMode) {
-		_gameRef->pushViewport(_viewport);
+	if (_viewport && !_game->_editorMode) {
+		_game->pushViewport(_viewport);
 		popViewport = true;
-	} else if (adGame->_sceneViewport && !_gameRef->_editorMode) {
-		_gameRef->pushViewport(adGame->_sceneViewport);
+	} else if (adGame->_sceneViewport && !_game->_editorMode) {
+		_game->pushViewport(adGame->_sceneViewport);
 		popViewport = true;
 	}
 
@@ -1083,23 +1083,23 @@ bool AdScene::traverseNodes(bool doUpdate) {
 	// *** adjust scroll offset
 	if (doUpdate) {
 		/*
-		if (_autoScroll && _gameRef->_mainObject != nullptr)
+		if (_autoScroll && _game->_mainObject != nullptr)
 		{
-		    ScrollToObject(_gameRef->_mainObject);
+		    ScrollToObject(_game->_mainObject);
 		}
 		*/
 
 		if (_autoScroll) {
 			// adjust horizontal scroll
-			if (_gameRef->getTimer()->getTime() - _lastTimeH >= _scrollTimeH) {
+			if (_game->getTimer()->getTime() - _lastTimeH >= _scrollTimeH) {
 
 				// Cap the amount of catch-up to avoid jittery characters.
-				int timesMissed = (_gameRef->getTimer()->getTime() - _lastTimeH) / _scrollTimeH;
+				int timesMissed = (_game->getTimer()->getTime() - _lastTimeH) / _scrollTimeH;
 				if (timesMissed > 2) {
 					timesMissed = 2;
 				}
 
-				_lastTimeH = _gameRef->getTimer()->getTime();
+				_lastTimeH = _game->getTimer()->getTime();
 				if (_offsetLeft < _targetOffsetLeft) {
 					_offsetLeft += _scrollPixelsH * timesMissed;
 					_offsetLeft = MIN(_offsetLeft, _targetOffsetLeft);
@@ -1110,15 +1110,15 @@ bool AdScene::traverseNodes(bool doUpdate) {
 			}
 
 			// adjust vertical scroll
-			if (_gameRef->getTimer()->getTime() - _lastTimeV >= _scrollTimeV) {
+			if (_game->getTimer()->getTime() - _lastTimeV >= _scrollTimeV) {
 
 				// Cap the amount of catch-up to avoid jittery characters.
-				int timesMissed = (_gameRef->getTimer()->getTime() - _lastTimeV) / _scrollTimeV;
+				int timesMissed = (_game->getTimer()->getTime() - _lastTimeV) / _scrollTimeV;
 				if (timesMissed > 2) {
 					timesMissed = 2;
 				}
 
-				_lastTimeV = _gameRef->getTimer()->getTime();
+				_lastTimeV = _game->getTimer()->getTime();
 				if (_offsetTop < _targetOffsetTop) {
 					_offsetTop += _scrollPixelsV * timesMissed;
 					_offsetTop = MIN(_offsetTop, _targetOffsetTop);
@@ -1153,13 +1153,13 @@ bool AdScene::traverseNodes(bool doUpdate) {
 	double heightRatio = scrollableY <= 0 ? 0 : ((double)(_offsetTop)  / (double)scrollableY);
 
 	int origX, origY;
-	_gameRef->getOffset(&origX, &origY);
+	_game->getOffset(&origX, &origY);
 
 
 
 	//////////////////////////////////////////////////////////////////////////
 	// *** display/update everything
-	_gameRef->_renderer->setup2D();
+	_game->_renderer->setup2D();
 
 	// for each layer
 #ifdef ENABLE_WME3D
@@ -1174,14 +1174,14 @@ bool AdScene::traverseNodes(bool doUpdate) {
 
 		// make layer exclusive
 		if (!doUpdate) {
-			if (_layers[j]->_closeUp && !_gameRef->_editorMode) {
+			if (_layers[j]->_closeUp && !_game->_editorMode) {
 				if (!_shieldWindow) {
-					_shieldWindow = new UIWindow(_gameRef);
+					_shieldWindow = new UIWindow(_game);
 				}
 				if (_shieldWindow) {
 					_shieldWindow->_posX = _shieldWindow->_posY = 0;
-					_shieldWindow->_width = _gameRef->_renderer->getWidth();
-					_shieldWindow->_height = _gameRef->_renderer->getHeight();
+					_shieldWindow->_width = _game->_renderer->getWidth();
+					_shieldWindow->_height = _game->_renderer->getHeight();
 					_shieldWindow->display();
 				}
 			}
@@ -1190,27 +1190,27 @@ bool AdScene::traverseNodes(bool doUpdate) {
 		if (_paralaxScrolling) {
 			int offsetX = (int)(widthRatio  * (_layers[j]->_width  - viewportWidth) - viewportX);
 			int offsetY = (int)(heightRatio * (_layers[j]->_height - viewportHeight) - viewportY);
-			_gameRef->setOffset(offsetX, offsetY);
+			_game->setOffset(offsetX, offsetY);
 
-			_gameRef->_offsetPercentX = (float)offsetX / ((float)_layers[j]->_width - viewportWidth) * 100.0f;
-			_gameRef->_offsetPercentY = (float)offsetY / ((float)_layers[j]->_height - viewportHeight) * 100.0f;
+			_game->_offsetPercentX = (float)offsetX / ((float)_layers[j]->_width - viewportWidth) * 100.0f;
+			_game->_offsetPercentY = (float)offsetY / ((float)_layers[j]->_height - viewportHeight) * 100.0f;
 
-			//_gameRef->QuickMessageForm("%d %f", OffsetX+ViewportX, _gameRef->_offsetPercentX);
+			//_game->QuickMessageForm("%d %f", OffsetX+ViewportX, _game->_offsetPercentX);
 		} else {
-			_gameRef->setOffset(_offsetLeft - viewportX, _offsetTop - viewportY);
+			_game->setOffset(_offsetLeft - viewportX, _offsetTop - viewportY);
 
-			_gameRef->_offsetPercentX = (float)(_offsetLeft - viewportX) / ((float)_layers[j]->_width - viewportWidth) * 100.0f;
-			_gameRef->_offsetPercentY = (float)(_offsetTop - viewportY) / ((float)_layers[j]->_height - viewportHeight) * 100.0f;
+			_game->_offsetPercentX = (float)(_offsetLeft - viewportX) / ((float)_layers[j]->_width - viewportWidth) * 100.0f;
+			_game->_offsetPercentY = (float)(_offsetTop - viewportY) / ((float)_layers[j]->_height - viewportHeight) * 100.0f;
 		}
 
 #ifdef ENABLE_WME3D
 		// render depth info for stencil shadows
 		if (!doUpdate && _geom && _layers[j]->_main) {
-			_gameRef->getOffset(&mainOffsetX, &mainOffsetY);
+			_game->getOffset(&mainOffsetX, &mainOffsetY);
 
-			TShadowType shadowType = _gameRef->getMaxShadowType();
+			TShadowType shadowType = _game->getMaxShadowType();
 			if (shadowType >= SHADOW_STENCIL) {
-				_gameRef->renderShadowGeometry();
+				_game->renderShadowGeometry();
 			}
 		}
 #endif
@@ -1220,9 +1220,9 @@ bool AdScene::traverseNodes(bool doUpdate) {
 			AdSceneNode *node = _layers[j]->_nodes[k];
 			switch (node->_type) {
 			case OBJECT_ENTITY:
-				if (node->_entity->_active && (_gameRef->_editorMode || !node->_entity->_editorOnly)) {
+				if (node->_entity->_active && (_game->_editorMode || !node->_entity->_editorOnly)) {
 #ifndef ENABLE_WME3D
-					_gameRef->_renderer->setup2D();
+					_game->_renderer->setup2D();
 
 					if (doUpdate) {
 						node->_entity->update();
@@ -1231,9 +1231,9 @@ bool AdScene::traverseNodes(bool doUpdate) {
 					}
 #else
 					if (node->_entity->_is3D) {
-						_gameRef->_renderer->setup3D();
+						_game->_renderer->setup3D();
 					} else {
-						_gameRef->_renderer->setup2D();
+						_game->_renderer->setup2D();
 					}
 
 					// only display 3D if geometry is set
@@ -1281,14 +1281,14 @@ bool AdScene::traverseNodes(bool doUpdate) {
 #ifdef ENABLE_WME3D
 	// display hidden geometry
 	if (!doUpdate && _geom) {
-		_gameRef->setOffset(mainOffsetX, mainOffsetY);
+		_game->setOffset(mainOffsetX, mainOffsetY);
 		_geom->render(_showGeometry);
 	}
 #endif
 
 	// restore state
-	_gameRef->setOffset(origX, origY);
-	_gameRef->_renderer->setup2D();
+	_game->setOffset(origX, origY);
+	_game->_renderer->setup2D();
 
 	// display/update fader
 	if (_fader) {
@@ -1300,7 +1300,7 @@ bool AdScene::traverseNodes(bool doUpdate) {
 	}
 
 	if (popViewport) {
-		_gameRef->popViewport();
+		_game->popViewport();
 	}
 
 	return STATUS_OK;
@@ -1312,7 +1312,7 @@ bool AdScene::display3DContent(DXMatrix &viewMat, DXMatrix &projMat) {
 	if (!_geom)
 		return STATUS_FAILED;
 
-	_gameRef->_renderer3D->setup3DCustom(viewMat, projMat);
+	_game->_renderer3D->setup3DCustom(viewMat, projMat);
 
 	// for each layer
 	for (int32 j = 0; j < _layers.getSize(); j++) {
@@ -1320,9 +1320,9 @@ bool AdScene::display3DContent(DXMatrix &viewMat, DXMatrix &projMat) {
 			continue;
 
 		// render depth info for stencil shadows
-		TShadowType shadowType = _gameRef->getMaxShadowType();
+		TShadowType shadowType = _game->getMaxShadowType();
 		if (shadowType >= SHADOW_STENCIL) {
-			_gameRef->renderShadowGeometry();
+			_game->renderShadowGeometry();
 		}
 
 
@@ -1356,7 +1356,7 @@ bool AdScene::display() {
 
 //////////////////////////////////////////////////////////////////////////
 bool AdScene::updateFreeObjects() {
-	AdGame *adGame = (AdGame *)_gameRef;
+	AdGame *adGame = (AdGame *)_game;
 #ifdef ENABLE_WME3D
 	bool is3DSet = false;
 #endif
@@ -1370,7 +1370,7 @@ bool AdScene::updateFreeObjects() {
 #ifdef ENABLE_WME3D
 		if (adGame->_objects[i]->_is3D && _geom) {
 			if (_geom->_activeCamera >= 0 && _geom->_activeCamera < _geom->_cameras.getSize()) {
-				_gameRef->_renderer->setup3D(_geom->_cameras[_geom->_activeCamera], !is3DSet);
+				_game->_renderer->setup3D(_geom->_cameras[_geom->_activeCamera], !is3DSet);
 				is3DSet = true;
 			}
 		}
@@ -1387,7 +1387,7 @@ bool AdScene::updateFreeObjects() {
 #ifdef ENABLE_WME3D
 		if (_objects[i]->_is3D && _geom) {
 			if (_geom->_activeCamera >= 0 && _geom->_activeCamera < _geom->_cameras.getSize()) {
-				_gameRef->_renderer->setup3D(_geom->_cameras[_geom->_activeCamera], !is3DSet);
+				_game->_renderer->setup3D(_geom->_cameras[_geom->_activeCamera], !is3DSet);
 				is3DSet = true;
 			}
 		}
@@ -1398,8 +1398,8 @@ bool AdScene::updateFreeObjects() {
 	}
 
 
-	if (_autoScroll && _gameRef->_mainObject != nullptr) {
-		scrollToObject(_gameRef->_mainObject);
+	if (_autoScroll && _game->_mainObject != nullptr) {
+		scrollToObject(_game->_mainObject);
 	}
 
 
@@ -1409,7 +1409,7 @@ bool AdScene::updateFreeObjects() {
 
 //////////////////////////////////////////////////////////////////////////
 bool AdScene::displayRegionContent(AdRegion *region, bool display3DOnly) {
-	AdGame *adGame = (AdGame *)_gameRef;
+	AdGame *adGame = (AdGame *)_game;
 	BaseArray<AdObject *> objects;
 	AdObject *obj;
 
@@ -1441,18 +1441,18 @@ bool AdScene::displayRegionContent(AdRegion *region, bool display3DOnly) {
 		}
 
 #ifndef ENABLE_WME3D
-		_gameRef->_renderer->setup2D();
+		_game->_renderer->setup2D();
 #else
 		if (objects[i]->_is3D && _geom) {
 			if (_geom->_activeCamera >= 0 && _geom->_activeCamera < _geom->_cameras.getSize()) {
-				_gameRef->_renderer->setup3D(_geom->_cameras[_geom->_activeCamera]);
+				_game->_renderer->setup3D(_geom->_cameras[_geom->_activeCamera]);
 			}
 		} else {
-			_gameRef->_renderer->setup2D();
+			_game->_renderer->setup2D();
 		}
 #endif
 
-		if (_gameRef->_editorMode || !obj->_editorOnly) {
+		if (_game->_editorMode || !obj->_editorOnly) {
 			obj->display();
 		}
 		obj->_drawn = true;
@@ -1461,7 +1461,7 @@ bool AdScene::displayRegionContent(AdRegion *region, bool display3DOnly) {
 
 	// display design only objects
 	if (!display3DOnly) {
-		if (_gameRef->_editorMode && region == nullptr) {
+		if (_game->_editorMode && region == nullptr) {
 			for (int32 i = 0; i < _objects.getSize(); i++) {
 				if (_objects[i]->_active && _objects[i]->_editorOnly) {
 					_objects[i]->display();
@@ -1491,7 +1491,7 @@ int AdScene::compareObjs(const void *obj1, const void *obj2) {
 
 //////////////////////////////////////////////////////////////////////////
 bool AdScene::displayRegionContentOld(AdRegion *region) {
-	AdGame *adGame = (AdGame *)_gameRef;
+	AdGame *adGame = (AdGame *)_game;
 	AdObject *obj;
 
 	// display all objects in region sorted by _posY
@@ -1518,17 +1518,17 @@ bool AdScene::displayRegionContentOld(AdRegion *region) {
 
 		if (obj != nullptr) {
 #ifndef ENABLE_WME3D
-			_gameRef->_renderer->setup2D();
+			_game->_renderer->setup2D();
 #else
 			if (obj->_is3D && _geom) {
 				if (_geom->_activeCamera >= 0 && _geom->_activeCamera < _geom->_cameras.getSize()) {
-					_gameRef->_renderer->setup3D(_geom->_cameras[_geom->_activeCamera]);
+					_game->_renderer->setup3D(_geom->_cameras[_geom->_activeCamera]);
 				}
 			} else {
-				_gameRef->_renderer->setup2D();
+				_game->_renderer->setup2D();
 			}
 #endif
-			if (_gameRef->_editorMode || !obj->_editorOnly) {
+			if (_game->_editorMode || !obj->_editorOnly) {
 				obj->display();
 			}
 			obj->_drawn = true;
@@ -1537,7 +1537,7 @@ bool AdScene::displayRegionContentOld(AdRegion *region) {
 
 
 	// design only objects
-	if (_gameRef->_editorMode && region == nullptr) {
+	if (_game->_editorMode && region == nullptr) {
 		for (int32 i = 0; i < _objects.getSize(); i++) {
 			if (_objects[i]->_active && _objects[i]->_editorOnly) {
 				_objects[i]->display();
@@ -1570,7 +1570,7 @@ void AdScene::scrollTo(int offsetX, int offsetY) {
 	_targetOffsetTop = MIN(_targetOffsetTop, _height - viewportHeight);
 
 
-	if (_gameRef->_mainObject && _gameRef->_mainObject->_is3D) {
+	if (_game->_mainObject && _game->_mainObject->_is3D) {
 		if (abs(origOffsetLeft - _targetOffsetLeft) < 5) {
 			_targetOffsetLeft = origOffsetLeft;
 		}
@@ -1625,7 +1625,7 @@ bool AdScene::scCallMethod(ScScript *script, ScStack *stack, ScStack *thisStack,
 	//////////////////////////////////////////////////////////////////////////
 	if (strcmp(name, "LoadActor") == 0) {
 		stack->correctParams(1);
-		AdActor *act = new AdActor(_gameRef);
+		AdActor *act = new AdActor(_game);
 		if (act && DID_SUCCEED(act->loadFile(stack->pop()->getString()))) {
 			addObject(act);
 			stack->pushNative(act, true);
@@ -1642,7 +1642,7 @@ bool AdScene::scCallMethod(ScScript *script, ScStack *stack, ScStack *thisStack,
 	//////////////////////////////////////////////////////////////////////////
 	if (strcmp(name, "LoadActor3D") == 0) {
 		stack->correctParams(1);
-		AdActor3DX *act = new AdActor3DX(_gameRef);
+		AdActor3DX *act = new AdActor3DX(_game);
 		if (act && DID_SUCCEED(act->loadFile(stack->pop()->getString()))) {
 			addObject(act);
 			stack->pushNative(act, true);
@@ -1658,7 +1658,7 @@ bool AdScene::scCallMethod(ScScript *script, ScStack *stack, ScStack *thisStack,
 	//////////////////////////////////////////////////////////////////////////
 	else if (strcmp(name, "LoadEntity") == 0) {
 		stack->correctParams(1);
-		AdEntity *ent = new AdEntity(_gameRef);
+		AdEntity *ent = new AdEntity(_game);
 		if (ent && DID_SUCCEED(ent->loadFile(stack->pop()->getString()))) {
 			addObject(ent);
 			stack->pushNative(ent, true);
@@ -1676,7 +1676,7 @@ bool AdScene::scCallMethod(ScScript *script, ScStack *stack, ScStack *thisStack,
 		stack->correctParams(1);
 		ScValue *val = stack->pop();
 
-		AdEntity *ent = new AdEntity(_gameRef);
+		AdEntity *ent = new AdEntity(_game);
 		addObject(ent);
 		if (!val->isNULL()) {
 			ent->setName(val->getString());
@@ -2218,14 +2218,14 @@ bool AdScene::scCallMethod(ScScript *script, ScStack *stack, ScStack *thisStack,
 		int height = stack->pop()->getInt();
 
 		if (width <= 0) {
-			width = _gameRef->_renderer->getWidth();
+			width = _game->_renderer->getWidth();
 		}
 		if (height <= 0) {
-			height = _gameRef->_renderer->getHeight();
+			height = _game->_renderer->getHeight();
 		}
 
 		if (!_viewport) {
-			_viewport = new BaseViewport(_gameRef);
+			_viewport = new BaseViewport(_game);
 		}
 		if (_viewport) {
 			_viewport->setRect(x, y, x + width, y + height);
@@ -2243,7 +2243,7 @@ bool AdScene::scCallMethod(ScScript *script, ScStack *stack, ScStack *thisStack,
 		stack->correctParams(1);
 		ScValue *val = stack->pop();
 
-		AdLayer *layer = new AdLayer(_gameRef);
+		AdLayer *layer = new AdLayer(_game);
 		if (!val->isNULL()) {
 			layer->setName(val->getString());
 		}
@@ -2252,7 +2252,7 @@ bool AdScene::scCallMethod(ScScript *script, ScStack *stack, ScStack *thisStack,
 			layer->_height = _mainLayer->_height;
 		}
 		_layers.add(layer);
-		_gameRef->registerObject(layer);
+		_game->registerObject(layer);
 
 		stack->pushNative(layer, true);
 		return STATUS_OK;
@@ -2266,7 +2266,7 @@ bool AdScene::scCallMethod(ScScript *script, ScStack *stack, ScStack *thisStack,
 		int32 index = stack->pop()->getInt();
 		ScValue *val = stack->pop();
 
-		AdLayer *layer = new AdLayer(_gameRef);
+		AdLayer *layer = new AdLayer(_game);
 		if (!val->isNULL()) {
 			layer->setName(val->getString());
 		}
@@ -2283,7 +2283,7 @@ bool AdScene::scCallMethod(ScScript *script, ScStack *stack, ScStack *thisStack,
 			_layers.add(layer);
 		}
 
-		_gameRef->registerObject(layer);
+		_game->registerObject(layer);
 
 		stack->pushNative(layer, true);
 		return STATUS_OK;
@@ -2325,7 +2325,7 @@ bool AdScene::scCallMethod(ScScript *script, ScStack *stack, ScStack *thisStack,
 		for (int32 i = 0; i < _layers.getSize(); i++) {
 			if (_layers[i] == toDelete) {
 				_layers.removeAt(i);
-				_gameRef->unregisterObject(toDelete);
+				_game->unregisterObject(toDelete);
 				break;
 			}
 		}
@@ -2421,7 +2421,7 @@ ScValue *AdScene::scGetProperty(const Common::String &name) {
 		int32 viewportX;
 		getViewportOffset(&viewportX);
 
-		_scValue->setInt(_gameRef->_mousePos.x + _offsetLeft - viewportX);
+		_scValue->setInt(_game->_mousePos.x + _offsetLeft - viewportX);
 		return _scValue;
 	}
 
@@ -2432,7 +2432,7 @@ ScValue *AdScene::scGetProperty(const Common::String &name) {
 		int32 viewportY;
 		getViewportOffset(nullptr, &viewportY);
 
-		_scValue->setInt(_gameRef->_mousePos.y + _offsetTop - viewportY);
+		_scValue->setInt(_game->_mousePos.y + _offsetTop - viewportY);
 		return _scValue;
 	}
 
@@ -2763,7 +2763,7 @@ const char *AdScene::scToString() {
 //////////////////////////////////////////////////////////////////////////
 bool AdScene::addObject(AdObject *object) {
 	_objects.add(object);
-	return _gameRef->registerObject(object);
+	return _game->registerObject(object);
 }
 
 
@@ -2772,7 +2772,7 @@ bool AdScene::removeObject(AdObject *object) {
 	for (int32 i = 0; i < _objects.getSize(); i++) {
 		if (_objects[i] == object) {
 			_objects.removeAt(i);
-			return _gameRef->unregisterObject(object);
+			return _game->unregisterObject(object);
 		}
 	}
 	return STATUS_FAILED;
@@ -3280,15 +3280,15 @@ void AdScene::pfPointsAdd(int x, int y, int distance) {
 
 //////////////////////////////////////////////////////////////////////////
 bool AdScene::getViewportOffset(int32 *offsetX, int32 *offsetY) {
-	AdGame *adGame = (AdGame *)_gameRef;
-	if (_viewport && !_gameRef->_editorMode) {
+	AdGame *adGame = (AdGame *)_game;
+	if (_viewport && !_game->_editorMode) {
 		if (offsetX) {
 			*offsetX = _viewport->_offsetX;
 		}
 		if (offsetY) {
 			*offsetY = _viewport->_offsetY;
 		}
-	} else if (adGame->_sceneViewport && !_gameRef->_editorMode) {
+	} else if (adGame->_sceneViewport && !_game->_editorMode) {
 		if (offsetX) {
 			*offsetX = adGame->_sceneViewport->_offsetX;
 		}
@@ -3309,15 +3309,15 @@ bool AdScene::getViewportOffset(int32 *offsetX, int32 *offsetY) {
 
 //////////////////////////////////////////////////////////////////////////
 bool AdScene::getViewportSize(int32 *width, int32 *height) {
-	AdGame *adGame = (AdGame *)_gameRef;
-	if (_viewport && !_gameRef->_editorMode) {
+	AdGame *adGame = (AdGame *)_game;
+	if (_viewport && !_game->_editorMode) {
 		if (width) {
 			*width  = _viewport->getWidth();
 		}
 		if (height) {
 			*height = _viewport->getHeight();
 		}
-	} else if (adGame->_sceneViewport && !_gameRef->_editorMode) {
+	} else if (adGame->_sceneViewport && !_game->_editorMode) {
 		if (width) {
 			*width  = adGame->_sceneViewport->getWidth();
 		}
@@ -3326,10 +3326,10 @@ bool AdScene::getViewportSize(int32 *width, int32 *height) {
 		}
 	} else {
 		if (width) {
-			*width  = _gameRef->_renderer->getWidth();
+			*width  = _game->_renderer->getWidth();
 		}
 		if (height) {
-			*height = _gameRef->_renderer->getHeight();
+			*height = _game->_renderer->getHeight();
 		}
 	}
 	return STATUS_OK;
@@ -3434,7 +3434,7 @@ bool AdScene::persistState(bool saving) {
 		return STATUS_OK;
 	}
 
-	AdGame *adGame = (AdGame *)_gameRef;
+	AdGame *adGame = (AdGame *)_game;
 	AdSceneState *state = adGame->getSceneState(getFilename(), saving);
 	if (!state) {
 		return STATUS_OK;
@@ -3714,7 +3714,7 @@ bool AdScene::getSceneObjects(BaseArray<AdObject *> &objects, bool interactiveOn
 
 //////////////////////////////////////////////////////////////////////////
 bool AdScene::getRegionObjects(AdRegion *region, BaseArray<AdObject *> &objects, bool interactiveOnly) {
-	AdGame *adGame = (AdGame *)_gameRef;
+	AdGame *adGame = (AdGame *)_game;
 	AdObject *obj;
 
 	// global objects
diff --git a/engines/wintermute/ad/ad_scene_geometry.cpp b/engines/wintermute/ad/ad_scene_geometry.cpp
index dd478ce1a49..c4a9d5bafcf 100644
--- a/engines/wintermute/ad/ad_scene_geometry.cpp
+++ b/engines/wintermute/ad/ad_scene_geometry.cpp
@@ -118,7 +118,7 @@ void AdSceneGeometry::cleanup() {
 	_waypointGroups.removeAll();
 
 	for (i = 0; i < _cameras.getSize(); i++) {
-		BaseRenderer3D *renderer = _gameRef->_renderer3D;
+		BaseRenderer3D *renderer = _game->_renderer3D;
 		if (renderer->_camera == _cameras[i])
 			renderer->_camera = nullptr;
 		delete _cameras[i];
@@ -143,7 +143,7 @@ void AdSceneGeometry::cleanup() {
 
 //////////////////////////////////////////////////////////////////////////
 AdGeomExt *AdSceneGeometry::getGeometryExtension(char *filename) {
-	AdGeomExt *ret = new AdGeomExt(_gameRef);
+	AdGeomExt *ret = new AdGeomExt(_game);
 
 	AnsiString path = PathUtil::getDirectoryName(filename);
 	AnsiString name = PathUtil::getFileNameWithoutExtension(filename);
@@ -168,7 +168,7 @@ bool AdSceneGeometry::loadFile(const char *filename) {
 
 	// load waypoint graphics from resources
 	if (!_wptMarker) {
-		_wptMarker = new BaseSprite(_gameRef);
+		_wptMarker = new BaseSprite(_game);
 		if (_wptMarker) {
 			if (!_wptMarker->loadFile("wpt.sprite")) {
 				delete _wptMarker;
@@ -180,13 +180,13 @@ bool AdSceneGeometry::loadFile(const char *filename) {
 	Common::String extenstionCheck(filename);
 	extenstionCheck.toLowercase();
 	if (!extenstionCheck.hasSuffix(".3ds")) {
-		_gameRef->LOG(0, "Error: no suitable loader found for file '%s'", filename);
+		_game->LOG(0, "Error: no suitable loader found for file '%s'", filename);
 		return false;
 	}
 
 	AdGeomExt *geomExt = getGeometryExtension(const_cast<char *>(filename));
 
-	Loader3DS *loader = new Loader3DS(_gameRef);
+	Loader3DS *loader = new Loader3DS(_game);
 	if (!loader->parseFile(filename)) {
 		delete loader;
 		delete geomExt;
@@ -206,9 +206,9 @@ bool AdSceneGeometry::loadFile(const char *filename) {
 
 		switch (extNode->_type) {
 		case GEOM_WALKPLANE: {
-				AdWalkplane *plane = new AdWalkplane(_gameRef);
+				AdWalkplane *plane = new AdWalkplane(_game);
 				plane->setName(loader->getMeshName(i).c_str());
-				plane->_mesh = _gameRef->_renderer3D->createMesh3DS();
+				plane->_mesh = _game->_renderer3D->createMesh3DS();
 				if (!loader->loadMesh(i, plane->_mesh)) {
 					delete plane->_mesh;
 					delete plane;
@@ -225,9 +225,9 @@ bool AdSceneGeometry::loadFile(const char *filename) {
 			break;
 
 		case GEOM_BLOCKED: {
-				AdBlock *block = new AdBlock(_gameRef);
+				AdBlock *block = new AdBlock(_game);
 				block->setName(loader->getMeshName(i).c_str());
-				block->_mesh = _gameRef->_renderer3D->createMesh3DS();
+				block->_mesh = _game->_renderer3D->createMesh3DS();
 				if (!loader->loadMesh(i, block->_mesh)) {
 					delete block->_mesh;
 					delete block;
@@ -244,7 +244,7 @@ bool AdSceneGeometry::loadFile(const char *filename) {
 			break;
 
 		case GEOM_WAYPOINT: {
-				Mesh3DS *mesh = _gameRef->_renderer3D->createMesh3DS();
+				Mesh3DS *mesh = _game->_renderer3D->createMesh3DS();
 				if (!loader->loadMesh(i, mesh)) {
 					delete mesh;
 					delete loader;
@@ -252,7 +252,7 @@ bool AdSceneGeometry::loadFile(const char *filename) {
 					return false;
 				} else {
 					if (_waypointGroups.getSize() == 0) {
-						_waypointGroups.add(new AdWaypointGroup3D(_gameRef));
+						_waypointGroups.add(new AdWaypointGroup3D(_game));
 					}
 					_waypointGroups[0]->addFromMesh(mesh);
 					delete mesh;
@@ -261,9 +261,9 @@ bool AdSceneGeometry::loadFile(const char *filename) {
 			break;
 
 		case GEOM_GENERIC: {
-				AdGeneric *generic = new AdGeneric(_gameRef);
+				AdGeneric *generic = new AdGeneric(_game);
 				generic->setName(loader->getMeshName(i).c_str());
-				generic->_mesh = _gameRef->_renderer3D->createMesh3DS();
+				generic->_mesh = _game->_renderer3D->createMesh3DS();
 				if (!loader->loadMesh(i, generic->_mesh)) {
 					delete generic->_mesh;
 					delete generic;
@@ -283,7 +283,7 @@ bool AdSceneGeometry::loadFile(const char *filename) {
 
 	// load cameras
 	for (i = 0; i < loader->getNumCameras(); i++) {
-		Camera3D *camera = new Camera3D(_gameRef);
+		Camera3D *camera = new Camera3D(_game);
 		if (!loader->loadCamera(i, camera)) {
 			delete camera;
 			delete loader;
@@ -295,7 +295,7 @@ bool AdSceneGeometry::loadFile(const char *filename) {
 
 	// load lights
 	for (i = 0; i < loader->getNumLights(); i++) {
-		Light3D *light = new Light3D(_gameRef);
+		Light3D *light = new Light3D(_game);
 		if (!loader->loadLight(i, light)) {
 			delete light;
 			delete loader;
@@ -343,7 +343,7 @@ bool AdSceneGeometry::dropWaypoints() {
 //////////////////////////////////////////////////////////////////////////
 bool AdSceneGeometry::setActiveCamera(int camera, float fov, float nearClipPlane, float farClipPlane) {
 	if (camera < 0 || camera >= _cameras.getSize()) {
-		_gameRef->LOG(0, "Warning: Camera %d is out of bounds.", camera);
+		_game->LOG(0, "Warning: Camera %d is out of bounds.", camera);
 		return false;
 	} else {
 		_activeCamera = camera;
@@ -369,7 +369,7 @@ bool AdSceneGeometry::setActiveCamera(const char *camera, float fov, float nearC
 			return setActiveCamera(i, fov, nearClipPlane, farClipPlane);
 	}
 
-	_gameRef->LOG(0, "Warning: Camera '%s' not found.", camera);
+	_game->LOG(0, "Warning: Camera '%s' not found.", camera);
 	return false;
 }
 
@@ -385,7 +385,7 @@ Camera3D *AdSceneGeometry::getActiveCamera() {
 //////////////////////////////////////////////////////////////////////////
 bool AdSceneGeometry::setActiveLight(int32 light) {
 	if (light < 0 || light >= _lights.getSize()) {
-		_gameRef->LOG(0, "Warning: Light %d is out of bounds.", light);
+		_game->LOG(0, "Warning: Light %d is out of bounds.", light);
 		return false;
 	} else {
 		_activeLight = light;
@@ -401,7 +401,7 @@ bool AdSceneGeometry::setActiveLight(char *light) {
 		}
 	}
 
-	_gameRef->LOG(0, "Warning: Light '%s' not found.", light);
+	_game->LOG(0, "Warning: Light '%s' not found.", light);
 	return false;
 }
 
@@ -412,7 +412,7 @@ DXMatrix *AdSceneGeometry::getViewMatrix() {
 
 //////////////////////////////////////////////////////////////////////////
 bool AdSceneGeometry::storeDrawingParams() {
-    BaseRenderer3D *renderer = _gameRef->_renderer3D;
+    BaseRenderer3D *renderer = _game->_renderer3D;
 
 	// store values
 	_drawingViewport = renderer->getViewPort();
@@ -421,7 +421,7 @@ bool AdSceneGeometry::storeDrawingParams() {
 	renderer->getViewTransform(&_lastViewMat);
 	renderer->getProjectionTransform(&_lastProjMat);
 
-	AdScene *scene = ((AdGame *)_gameRef)->_scene;
+	AdScene *scene = ((AdGame *)_game)->_scene;
 	if (scene) {
 		_lastScrollX = scene->getOffsetLeft();
 		_lastScrollY = scene->getOffsetTop();
@@ -431,18 +431,18 @@ bool AdSceneGeometry::storeDrawingParams() {
 	}
 
 	Common::Rect32 rc;
-	_gameRef->getCurrentViewportRect(&rc);
+	_game->getCurrentViewportRect(&rc);
 	float width = (float)rc.right - (float)rc.left;
 	float height = (float)rc.bottom - (float)rc.top;
 
 	// margins
 	int mleft = rc.left;
-	int mright = _gameRef->_renderer3D->getWidth() - width - rc.left;
+	int mright = _game->_renderer3D->getWidth() - width - rc.left;
 	int mtop = rc.top;
-	int mbottom = _gameRef->_renderer3D->getHeight() - height - rc.top;
+	int mbottom = _game->_renderer3D->getHeight() - height - rc.top;
 
-	_lastOffsetX = _gameRef->_offsetX + (mleft - mright) / 2;
-	_lastOffsetY = _gameRef->_offsetY + (mtop - mbottom) / 2;
+	_lastOffsetX = _game->_offsetX + (mleft - mright) / 2;
+	_lastOffsetY = _game->_offsetY + (mtop - mbottom) / 2;
 
 	_lastValuesInitialized = true;
 
@@ -454,7 +454,7 @@ bool AdSceneGeometry::render(bool render) {
 	// store values
 	storeDrawingParams();
 	if (render) {
-		_gameRef->_renderer3D->renderSceneGeometry(_planes, _blocks, _generics, _lights, getActiveCamera());
+		_game->_renderer3D->renderSceneGeometry(_planes, _blocks, _generics, _lights, getActiveCamera());
 	}
 
 	return true;
@@ -464,7 +464,7 @@ bool AdSceneGeometry::render(bool render) {
 bool AdSceneGeometry::renderShadowGeometry() {
 	storeDrawingParams();
 
-	_gameRef->_renderer3D->renderShadowGeometry(_planes, _blocks, _generics, getActiveCamera());
+	_game->_renderer3D->renderShadowGeometry(_planes, _blocks, _generics, getActiveCamera());
 	return true;
 }
 
@@ -680,7 +680,7 @@ bool AdSceneGeometry::convert2Dto3DTolerant(int x, int y, DXVector3 *pos) {
 
 //////////////////////////////////////////////////////////////////////////
 bool AdSceneGeometry::convert2Dto3D(int x, int y, DXVector3 *pos) {
-	BaseRenderer3D *renderer = _gameRef->_renderer3D;
+	BaseRenderer3D *renderer = _game->_renderer3D;
 
 	if (!_lastValuesInitialized) {
 		_drawingViewport = renderer->getViewPort();
@@ -691,7 +691,7 @@ bool AdSceneGeometry::convert2Dto3D(int x, int y, DXVector3 *pos) {
 	float layerWidth, layerHeight;
 	float modWidth, modHeight;
 	bool customViewport;
-	_gameRef->_renderer3D->getProjectionParams(&resWidth, &resHeight, &layerWidth, &layerHeight, &modWidth, &modHeight, &customViewport);
+	_game->_renderer3D->getProjectionParams(&resWidth, &resHeight, &layerWidth, &layerHeight, &modWidth, &modHeight, &customViewport);
 
 	// modify coordinates according to viewport settings
 	int mleft = _drawingViewport._x;
@@ -881,8 +881,8 @@ float AdSceneGeometry::getPointsDist(DXVector3 p1, DXVector3 p2) {
 
 //////////////////////////////////////////////////////////////////////////
 bool AdSceneGeometry::initLoop() {
-	uint32 start = _gameRef->_currentTime;
-	while (!_PFReady && _gameRef->_currentTime - start <= _PFMaxTime) {
+	uint32 start = _game->_currentTime;
+	while (!_PFReady && _game->_currentTime - start <= _PFMaxTime) {
 		pathFinderStep();
 	}
 
@@ -892,7 +892,7 @@ bool AdSceneGeometry::initLoop() {
 //////////////////////////////////////////////////////////////////////////
 bool AdSceneGeometry::createLights() {
 	// disable all lights
-	BaseRenderer3D *renderer = _gameRef->_renderer3D;
+	BaseRenderer3D *renderer = _game->_renderer3D;
 	int32 maxLights = renderer->getMaxActiveLights();
 	for (int32 i = 0; i < maxLights; i++) {
 		renderer->lightEnable(i, false);
@@ -908,7 +908,7 @@ bool AdSceneGeometry::createLights() {
 //////////////////////////////////////////////////////////////////////////
 bool AdSceneGeometry::enableLights(DXVector3 point, BaseArray<char *> &ignoreLights) {
 	const int maxLightCount = 100;
-	BaseRenderer3D *renderer = _gameRef->_renderer3D;
+	BaseRenderer3D *renderer = _game->_renderer3D;
 	int maxLights = renderer->getMaxActiveLights();
 
 	int32 numActiveLights = 0;
@@ -925,7 +925,7 @@ bool AdSceneGeometry::enableLights(DXVector3 point, BaseArray<char *> &ignoreLig
 		}
 	} else {
 		if (!_maxLightsWarning) {
-			_gameRef->LOG(0, "Warning: Using more lights than the hardware supports (%d)", maxLights);
+			_game->LOG(0, "Warning: Using more lights than the hardware supports (%d)", maxLights);
 			_maxLightsWarning = true;
 		}
 
@@ -1267,7 +1267,7 @@ bool AdSceneGeometry::persist(BasePersistenceManager *persistMgr) {
 			}
 
 			if (!found) {
-				Light3D *light = new Light3D(_gameRef);
+				Light3D *light = new Light3D(_game);
 				light->persist(persistMgr);
 				delete light;
 			}
@@ -1299,7 +1299,7 @@ bool AdSceneGeometry::persist(BasePersistenceManager *persistMgr) {
 				}
 			}
 			if (!found) {
-				AdBlock *block = new AdBlock(_gameRef);
+				AdBlock *block = new AdBlock(_game);
 				block->persist(persistMgr);
 				delete block;
 			}
@@ -1330,7 +1330,7 @@ bool AdSceneGeometry::persist(BasePersistenceManager *persistMgr) {
 				}
 			}
 			if (!found) {
-				AdWalkplane *plane = new AdWalkplane(_gameRef);
+				AdWalkplane *plane = new AdWalkplane(_game);
 				plane->persist(persistMgr);
 				delete plane;
 			}
@@ -1361,7 +1361,7 @@ bool AdSceneGeometry::persist(BasePersistenceManager *persistMgr) {
 				}
 			}
 			if (!found) {
-				AdGeneric *generic = new AdGeneric(_gameRef);
+				AdGeneric *generic = new AdGeneric(_game);
 				generic->persist(persistMgr);
 				delete generic;
 			}
diff --git a/engines/wintermute/ad/ad_scene_node.cpp b/engines/wintermute/ad/ad_scene_node.cpp
index 1e64baf4110..5b6d4800797 100644
--- a/engines/wintermute/ad/ad_scene_node.cpp
+++ b/engines/wintermute/ad/ad_scene_node.cpp
@@ -42,10 +42,10 @@ AdSceneNode::AdSceneNode(BaseGame *inGame) : BaseObject(inGame) {
 
 //////////////////////////////////////////////////////////////////////////
 AdSceneNode::~AdSceneNode() {
-	_gameRef->unregisterObject(_region);
+	_game->unregisterObject(_region);
 	_region = nullptr;
 
-	_gameRef->unregisterObject(_entity);
+	_game->unregisterObject(_entity);
 	_entity = nullptr;
 }
 
@@ -54,7 +54,7 @@ AdSceneNode::~AdSceneNode() {
 bool AdSceneNode::setEntity(AdEntity *entity) {
 	_type = OBJECT_ENTITY;
 	_entity = entity;
-	return _gameRef->registerObject(entity);
+	return _game->registerObject(entity);
 }
 
 
@@ -62,7 +62,7 @@ bool AdSceneNode::setEntity(AdEntity *entity) {
 bool AdSceneNode::setRegion(AdRegion *region) {
 	_type = OBJECT_REGION;
 	_region = region;
-	return _gameRef->registerObject(region);
+	return _game->registerObject(region);
 }
 
 
diff --git a/engines/wintermute/ad/ad_scene_state.cpp b/engines/wintermute/ad/ad_scene_state.cpp
index c11ea8a323d..25195d17aa8 100644
--- a/engines/wintermute/ad/ad_scene_state.cpp
+++ b/engines/wintermute/ad/ad_scene_state.cpp
@@ -80,7 +80,7 @@ AdNodeState *AdSceneState::getNodeState(const char *name, bool saving) {
 	}
 
 	if (saving) {
-		AdNodeState *ret = new AdNodeState(_gameRef);
+		AdNodeState *ret = new AdNodeState(_game);
 		ret->setName(name);
 		_nodeStates.add(ret);
 
diff --git a/engines/wintermute/ad/ad_sentence.cpp b/engines/wintermute/ad/ad_sentence.cpp
index 7bf1a5d1d1c..83894086168 100644
--- a/engines/wintermute/ad/ad_sentence.cpp
+++ b/engines/wintermute/ad/ad_sentence.cpp
@@ -56,7 +56,7 @@ AdSentence::AdSentence(BaseGame *inGame) : BaseClass(inGame) {
 	_font = nullptr;
 
 	_pos.x = _pos.y = 0;
-	_width = _gameRef->_renderer->getWidth();
+	_width = _game->_renderer->getWidth();
 
 	_align = (TTextAlign)TAL_CENTER;
 
@@ -193,18 +193,18 @@ bool AdSentence::display() {
 		_soundStarted = true;
 	}
 
-	if (_gameRef->_subtitles) {
+	if (_game->_subtitles) {
 		int32 x = _pos.x;
 		int32 y = _pos.y;
 
 		if (!_fixedPos) {
-			x = x - ((AdGame *)_gameRef)->_scene->getOffsetLeft();
-			y = y - ((AdGame *)_gameRef)->_scene->getOffsetTop();
+			x = x - ((AdGame *)_game)->_scene->getOffsetLeft();
+			y = y - ((AdGame *)_game)->_scene->getOffsetTop();
 		}
 
 
 		x = MAX<int32>(x, 0);
-		x = MIN(x, _gameRef->_renderer->getWidth() - _width);
+		x = MIN(x, _game->_renderer->getWidth() - _width);
 		y = MAX<int32>(y, 0);
 
 		_font->drawText((byte *)_text, x, y, _width, _align);
@@ -237,7 +237,7 @@ bool AdSentence::finish() {
 //////////////////////////////////////////////////////////////////////////
 bool AdSentence::persist(BasePersistenceManager *persistMgr) {
 
-	persistMgr->transferPtr(TMEMBER_PTR(_gameRef));
+	persistMgr->transferPtr(TMEMBER_PTR(_game));
 
 	persistMgr->transferSint32(TMEMBER_INT(_align));
 	persistMgr->transferSint32(TMEMBER(_currentStance));
@@ -280,12 +280,12 @@ bool AdSentence::setupTalkFile(const char *soundFilename) {
 		return STATUS_OK;    // no talk def file found
 	}
 
-	_talkDef = new AdTalkDef(_gameRef);
+	_talkDef = new AdTalkDef(_game);
 	if (!_talkDef || DID_FAIL(_talkDef->loadFile(talkDefFileName.c_str()))) {
 		SAFE_DELETE(_talkDef);
 		return STATUS_FAILED;
 	}
-	//_gameRef->LOG(0, "Using .talk file: %s", TalkDefFile);
+	//_game->LOG(0, "Using .talk file: %s", TalkDefFile);
 
 	return STATUS_OK;
 }
@@ -302,9 +302,9 @@ bool AdSentence::update(TDirection dir) {
 
 	/*
 	if (_sound) CurrentTime = _sound->GetPositionTime();
-	else CurrentTime = _gameRef->getTimer()->getTime() - _startTime;
+	else CurrentTime = _game->getTimer()->getTime() - _startTime;
 	*/
-	currentTime = _gameRef->getTimer()->getTime() - _startTime;
+	currentTime = _game->getTimer()->getTime() - _startTime;
 
 	bool talkNodeFound = false;
 	for (int32 i = 0; i < _talkDef->_nodes.getSize(); i++) {
@@ -343,7 +343,7 @@ bool AdSentence::update(TDirection dir) {
 //////////////////////////////////////////////////////////////////////////
 bool AdSentence::canSkip() {
 	// prevent accidental sentence skipping (TODO make configurable)
-	return (_gameRef->getTimer()->getTime() - _startTime) > 300;
+	return (_game->getTimer()->getTime() - _startTime) > 300;
 }
 
 } // End of namespace Wintermute
diff --git a/engines/wintermute/ad/ad_sprite_set.cpp b/engines/wintermute/ad/ad_sprite_set.cpp
index d3de893a6d7..900d5b19afa 100644
--- a/engines/wintermute/ad/ad_sprite_set.cpp
+++ b/engines/wintermute/ad/ad_sprite_set.cpp
@@ -61,14 +61,14 @@ AdSpriteSet::~AdSpriteSet() {
 bool AdSpriteSet::loadFile(const char *filename, int lifeTime, TSpriteCacheType cacheType) {
 	char *buffer = (char *)BaseFileManager::getEngineInstance()->readWholeFile(filename);
 	if (buffer == nullptr) {
-		_gameRef->LOG(0, "AdSpriteSet::LoadFile failed for file '%s'", filename);
+		_game->LOG(0, "AdSpriteSet::LoadFile failed for file '%s'", filename);
 		return STATUS_FAILED;
 	}
 
 	bool ret;
 
 	if (DID_FAIL(ret = loadBuffer(buffer, true))) {
-		_gameRef->LOG(0, "Error parsing SPRITESET file '%s'", filename);
+		_game->LOG(0, "Error parsing SPRITESET file '%s'", filename);
 	}
 
 	delete[] buffer;
@@ -114,7 +114,7 @@ bool AdSpriteSet::loadBuffer(char *buffer, bool complete, int lifeTime, TSpriteC
 
 	if (complete) {
 		if (parser.getCommand(&buffer, commands, &params) != TOKEN_SPRITESET) {
-			_gameRef->LOG(0, "'SPRITESET' keyword expected.");
+			_game->LOG(0, "'SPRITESET' keyword expected.");
 			return STATUS_FAILED;
 		}
 		buffer = params;
@@ -135,7 +135,7 @@ bool AdSpriteSet::loadBuffer(char *buffer, bool complete, int lifeTime, TSpriteC
 
 		case TOKEN_LEFT:
 			SAFE_DELETE(_sprites[DI_LEFT]);
-			spr = new BaseSprite(_gameRef,  _owner);
+			spr = new BaseSprite(_game,  _owner);
 			if (!spr || DID_FAIL(spr->loadFile(params, lifeTime, cacheType))) {
 				cmd = PARSERR_GENERIC;
 			} else {
@@ -145,7 +145,7 @@ bool AdSpriteSet::loadBuffer(char *buffer, bool complete, int lifeTime, TSpriteC
 
 		case TOKEN_RIGHT:
 			SAFE_DELETE(_sprites[DI_RIGHT]);
-			spr = new BaseSprite(_gameRef,  _owner);
+			spr = new BaseSprite(_game,  _owner);
 			if (!spr || DID_FAIL(spr->loadFile(params, lifeTime, cacheType))) {
 				cmd = PARSERR_GENERIC;
 			} else {
@@ -155,7 +155,7 @@ bool AdSpriteSet::loadBuffer(char *buffer, bool complete, int lifeTime, TSpriteC
 
 		case TOKEN_UP:
 			SAFE_DELETE(_sprites[DI_UP]);
-			spr = new BaseSprite(_gameRef,  _owner);
+			spr = new BaseSprite(_game,  _owner);
 			if (!spr || DID_FAIL(spr->loadFile(params, lifeTime, cacheType))) {
 				cmd = PARSERR_GENERIC;
 			} else {
@@ -165,7 +165,7 @@ bool AdSpriteSet::loadBuffer(char *buffer, bool complete, int lifeTime, TSpriteC
 
 		case TOKEN_DOWN:
 			SAFE_DELETE(_sprites[DI_DOWN]);
-			spr = new BaseSprite(_gameRef,  _owner);
+			spr = new BaseSprite(_game,  _owner);
 			if (!spr || DID_FAIL(spr->loadFile(params, lifeTime, cacheType))) {
 				cmd = PARSERR_GENERIC;
 			} else {
@@ -175,7 +175,7 @@ bool AdSpriteSet::loadBuffer(char *buffer, bool complete, int lifeTime, TSpriteC
 
 		case TOKEN_UP_LEFT:
 			SAFE_DELETE(_sprites[DI_UPLEFT]);
-			spr = new BaseSprite(_gameRef,  _owner);
+			spr = new BaseSprite(_game,  _owner);
 			if (!spr || DID_FAIL(spr->loadFile(params, lifeTime, cacheType))) {
 				cmd = PARSERR_GENERIC;
 			} else {
@@ -185,7 +185,7 @@ bool AdSpriteSet::loadBuffer(char *buffer, bool complete, int lifeTime, TSpriteC
 
 		case TOKEN_UP_RIGHT:
 			SAFE_DELETE(_sprites[DI_UPRIGHT]);
-			spr = new BaseSprite(_gameRef,  _owner);
+			spr = new BaseSprite(_game,  _owner);
 			if (!spr || DID_FAIL(spr->loadFile(params, lifeTime, cacheType))) {
 				cmd = PARSERR_GENERIC;
 			} else {
@@ -195,7 +195,7 @@ bool AdSpriteSet::loadBuffer(char *buffer, bool complete, int lifeTime, TSpriteC
 
 		case TOKEN_DOWN_LEFT:
 			SAFE_DELETE(_sprites[DI_DOWNLEFT]);
-			spr = new BaseSprite(_gameRef,  _owner);
+			spr = new BaseSprite(_game,  _owner);
 			if (!spr || DID_FAIL(spr->loadFile(params, lifeTime, cacheType))) {
 				cmd = PARSERR_GENERIC;
 			} else {
@@ -205,7 +205,7 @@ bool AdSpriteSet::loadBuffer(char *buffer, bool complete, int lifeTime, TSpriteC
 
 		case TOKEN_DOWN_RIGHT:
 			SAFE_DELETE(_sprites[DI_DOWNRIGHT]);
-			spr = new BaseSprite(_gameRef,  _owner);
+			spr = new BaseSprite(_game,  _owner);
 			if (!spr || DID_FAIL(spr->loadFile(params, lifeTime, cacheType))) {
 				cmd = PARSERR_GENERIC;
 			} else {
@@ -222,12 +222,12 @@ bool AdSpriteSet::loadBuffer(char *buffer, bool complete, int lifeTime, TSpriteC
 		}
 	}
 	if (cmd == PARSERR_TOKENNOTFOUND) {
-		_gameRef->LOG(0, "Syntax error in SPRITESET definition");
+		_game->LOG(0, "Syntax error in SPRITESET definition");
 		return STATUS_FAILED;
 	}
 
 	if (cmd == PARSERR_GENERIC) {
-		_gameRef->LOG(0, "Error loading SPRITESET definition");
+		_game->LOG(0, "Error loading SPRITESET definition");
 		if (spr) {
 			delete spr;
 		}
diff --git a/engines/wintermute/ad/ad_talk_def.cpp b/engines/wintermute/ad/ad_talk_def.cpp
index e5f51cef587..ce3b522806b 100644
--- a/engines/wintermute/ad/ad_talk_def.cpp
+++ b/engines/wintermute/ad/ad_talk_def.cpp
@@ -69,7 +69,7 @@ AdTalkDef::~AdTalkDef() {
 bool AdTalkDef::loadFile(const char *filename) {
 	char *buffer = (char *)BaseFileManager::getEngineInstance()->readWholeFile(filename);
 	if (buffer == nullptr) {
-		_gameRef->LOG(0, "AdTalkDef::LoadFile failed for file '%s'", filename);
+		_game->LOG(0, "AdTalkDef::LoadFile failed for file '%s'", filename);
 		return STATUS_FAILED;
 	}
 
@@ -78,7 +78,7 @@ bool AdTalkDef::loadFile(const char *filename) {
 	setFilename(filename);
 
 	if (DID_FAIL(ret = loadBuffer(buffer, true))) {
-		_gameRef->LOG(0, "Error parsing TALK file '%s'", filename);
+		_game->LOG(0, "Error parsing TALK file '%s'", filename);
 	}
 
 	delete[] buffer;
@@ -114,7 +114,7 @@ bool AdTalkDef::loadBuffer(char *buffer, bool complete) {
 
 	if (complete) {
 		if (parser.getCommand(&buffer, commands, &params) != TOKEN_TALK) {
-			_gameRef->LOG(0, "'TALK' keyword expected.");
+			_game->LOG(0, "'TALK' keyword expected.");
 			return STATUS_FAILED;
 		}
 		buffer = params;
@@ -129,7 +129,7 @@ bool AdTalkDef::loadBuffer(char *buffer, bool complete) {
 			break;
 
 		case TOKEN_ACTION: {
-			AdTalkNode *node = new AdTalkNode(_gameRef);
+			AdTalkNode *node = new AdTalkNode(_game);
 			if (node && DID_SUCCEED(node->loadBuffer(params, false))) {
 				_nodes.add(node);
 			} else {
@@ -149,7 +149,7 @@ bool AdTalkDef::loadBuffer(char *buffer, bool complete) {
 
 		case TOKEN_DEFAULT_SPRITESET: {
 			SAFE_DELETE(_defaultSpriteSet);
-			_defaultSpriteSet = new AdSpriteSet(_gameRef);
+			_defaultSpriteSet = new AdSpriteSet(_game);
 			if (!_defaultSpriteSet || DID_FAIL(_defaultSpriteSet->loadBuffer(params, false))) {
 				SAFE_DELETE(_defaultSpriteSet);
 				cmd = PARSERR_GENERIC;
@@ -167,12 +167,12 @@ bool AdTalkDef::loadBuffer(char *buffer, bool complete) {
 		}
 	}
 	if (cmd == PARSERR_TOKENNOTFOUND) {
-		_gameRef->LOG(0, "Syntax error in TALK definition");
+		_game->LOG(0, "Syntax error in TALK definition");
 		return STATUS_FAILED;
 	}
 
 	if (cmd == PARSERR_GENERIC) {
-		_gameRef->LOG(0, "Error loading TALK definition");
+		_game->LOG(0, "Error loading TALK definition");
 		return STATUS_FAILED;
 	}
 
@@ -180,14 +180,14 @@ bool AdTalkDef::loadBuffer(char *buffer, bool complete) {
 	SAFE_DELETE(_defaultSpriteSet);
 
 	if (_defaultSpriteFilename) {
-		_defaultSprite = new BaseSprite(_gameRef);
+		_defaultSprite = new BaseSprite(_game);
 		if (!_defaultSprite || DID_FAIL(_defaultSprite->loadFile(_defaultSpriteFilename))) {
 			return STATUS_FAILED;
 		}
 	}
 
 	if (_defaultSpriteSetFilename) {
-		_defaultSpriteSet = new AdSpriteSet(_gameRef);
+		_defaultSpriteSet = new AdSpriteSet(_game);
 		if (!_defaultSpriteSet || DID_FAIL(_defaultSpriteSet->loadFile(_defaultSpriteSetFilename))) {
 			return STATUS_FAILED;
 		}
@@ -242,7 +242,7 @@ bool AdTalkDef::saveAsText(BaseDynamicBuffer *buffer, int indent) {
 //////////////////////////////////////////////////////////////////////////
 bool AdTalkDef::loadDefaultSprite() {
 	if (_defaultSpriteFilename && !_defaultSprite) {
-		_defaultSprite = new BaseSprite(_gameRef);
+		_defaultSprite = new BaseSprite(_game);
 		if (!_defaultSprite || DID_FAIL(_defaultSprite->loadFile(_defaultSpriteFilename))) {
 			SAFE_DELETE(_defaultSprite);
 			return STATUS_FAILED;
@@ -250,7 +250,7 @@ bool AdTalkDef::loadDefaultSprite() {
 			return STATUS_OK;
 		}
 	} else if (_defaultSpriteSetFilename && !_defaultSpriteSet) {
-		_defaultSpriteSet = new AdSpriteSet(_gameRef);
+		_defaultSpriteSet = new AdSpriteSet(_game);
 		if (!_defaultSpriteSet || DID_FAIL(_defaultSpriteSet->loadFile(_defaultSpriteSetFilename))) {
 			SAFE_DELETE(_defaultSpriteSet);
 			return STATUS_FAILED;
diff --git a/engines/wintermute/ad/ad_talk_holder.cpp b/engines/wintermute/ad/ad_talk_holder.cpp
index c49da94ae62..cb4eaae1916 100644
--- a/engines/wintermute/ad/ad_talk_holder.cpp
+++ b/engines/wintermute/ad/ad_talk_holder.cpp
@@ -73,11 +73,11 @@ BaseSprite *AdTalkHolder::getTalkStance(const char *stance) {
 	if (_forcedTalkAnimName && !_forcedTalkAnimUsed) {
 		_forcedTalkAnimUsed = true;
 		SAFE_DELETE(_animSprite);
-		_animSprite = new BaseSprite(_gameRef, this);
+		_animSprite = new BaseSprite(_game, this);
 		if (_animSprite) {
 			bool res = _animSprite->loadFile(_forcedTalkAnimName);
 			if (DID_FAIL(res)) {
-				_gameRef->LOG(res, "AdTalkHolder::GetTalkStance: error loading talk sprite (object:\"%s\" sprite:\"%s\")", _name, _forcedTalkAnimName);
+				_game->LOG(res, "AdTalkHolder::GetTalkStance: error loading talk sprite (object:\"%s\" sprite:\"%s\")", _name, _forcedTalkAnimName);
 				SAFE_DELETE(_animSprite);
 			} else {
 				return _animSprite;
@@ -147,7 +147,7 @@ bool AdTalkHolder::scCallMethod(ScScript *script, ScStack *stack, ScStack *thisS
 			stack->pushBool(true);
 		} else {
 			const char *filename = val->getString();
-			BaseSprite *spr = new BaseSprite(_gameRef, this);
+			BaseSprite *spr = new BaseSprite(_game, this);
 			if (!spr || DID_FAIL(spr->loadFile(filename))) {
 				script->runtimeError("SetSprite method failed for file '%s'", filename);
 				stack->pushBool(false);
@@ -199,7 +199,7 @@ bool AdTalkHolder::scCallMethod(ScScript *script, ScStack *stack, ScStack *thisS
 		const char *filename = stack->pop()->getString();
 		bool ex = stack->pop()->getBool();
 
-		BaseSprite *spr = new BaseSprite(_gameRef, this);
+		BaseSprite *spr = new BaseSprite(_game, this);
 		if (!spr || DID_FAIL(spr->loadFile(filename))) {
 			stack->pushBool(false);
 			script->runtimeError("AddTalkSprite method failed for file '%s'", filename);
@@ -281,7 +281,7 @@ bool AdTalkHolder::scCallMethod(ScScript *script, ScStack *stack, ScStack *thisS
 
 		BaseScriptable *arr;
 		stack->pushInt(0);
-		arr = makeSXArray(_gameRef, stack);
+		arr = makeSXArray(_game, stack);
 		for (int32 i = 0; i < sprites.getSize(); i++) {
 			stack->pushString(sprites[i]->getFilename());
 			((SXArray *)arr)->push(stack->pop());
@@ -302,7 +302,7 @@ bool AdTalkHolder::scCallMethod(ScScript *script, ScStack *stack, ScStack *thisS
 		bool setCurrent = false;
 		bool setTemp2 = false;
 
-		BaseSprite *spr = new BaseSprite(_gameRef, this);
+		BaseSprite *spr = new BaseSprite(_game, this);
 		if (!spr || DID_FAIL(spr->loadFile(filename))) {
 			stack->pushBool(false);
 			script->runtimeError("SetTalkSprite method failed for file '%s'", filename);
diff --git a/engines/wintermute/ad/ad_talk_node.cpp b/engines/wintermute/ad/ad_talk_node.cpp
index 9d34c8ccfdd..213cbbe63d4 100644
--- a/engines/wintermute/ad/ad_talk_node.cpp
+++ b/engines/wintermute/ad/ad_talk_node.cpp
@@ -92,7 +92,7 @@ bool AdTalkNode::loadBuffer(char *buffer, bool complete) {
 
 	if (complete) {
 		if (parser.getCommand(&buffer, commands, &params) != TOKEN_ACTION) {
-			_gameRef->LOG(0, "'ACTION' keyword expected.");
+			_game->LOG(0, "'ACTION' keyword expected.");
 			return STATUS_FAILED;
 		}
 		buffer = params;
@@ -114,7 +114,7 @@ bool AdTalkNode::loadBuffer(char *buffer, bool complete) {
 
 		case TOKEN_SPRITESET: {
 			delete _spriteSet;
-			_spriteSet = new AdSpriteSet(_gameRef);
+			_spriteSet = new AdSpriteSet(_game);
 			if (!_spriteSet || DID_FAIL(_spriteSet->loadBuffer(params, false))) {
 				SAFE_DELETE(_spriteSet);
 				cmd = PARSERR_GENERIC;
@@ -135,7 +135,7 @@ bool AdTalkNode::loadBuffer(char *buffer, bool complete) {
 			break;
 
 		case TOKEN_COMMENT:
-			if (_gameRef->_editorMode) {
+			if (_game->_editorMode) {
 				BaseUtils::setString(&_comment, params);
 			}
 			break;
@@ -149,12 +149,12 @@ bool AdTalkNode::loadBuffer(char *buffer, bool complete) {
 		}
 	}
 	if (cmd == PARSERR_TOKENNOTFOUND) {
-		_gameRef->LOG(0, "Syntax error in ACTION definition");
+		_game->LOG(0, "Syntax error in ACTION definition");
 		return STATUS_FAILED;
 	}
 
 	if (cmd == PARSERR_GENERIC) {
-		_gameRef->LOG(0, "Error loading ACTION definition");
+		_game->LOG(0, "Error loading ACTION definition");
 		return STATUS_FAILED;
 	}
 
@@ -166,7 +166,7 @@ bool AdTalkNode::loadBuffer(char *buffer, bool complete) {
 
 	if (_preCache && _spriteFilename) {
 		SAFE_DELETE(_sprite);
-		_sprite = new BaseSprite(_gameRef);
+		_sprite = new BaseSprite(_game);
 		if (!_sprite || DID_FAIL(_sprite->loadFile(_spriteFilename))) {
 			return STATUS_FAILED;
 		}
@@ -174,7 +174,7 @@ bool AdTalkNode::loadBuffer(char *buffer, bool complete) {
 
 	if (_preCache && _spriteSetFilename) {
 		SAFE_DELETE(_spriteSet);
-		_spriteSet = new AdSpriteSet(_gameRef);
+		_spriteSet = new AdSpriteSet(_game);
 		if (!_spriteSet || DID_FAIL(_spriteSet->loadFile(_spriteSetFilename))) {
 			return STATUS_FAILED;
 		}
@@ -238,7 +238,7 @@ bool AdTalkNode::saveAsText(BaseDynamicBuffer *buffer, int indent) {
 //////////////////////////////////////////////////////////////////////////
 bool AdTalkNode::loadSprite() {
 	if (_spriteFilename && !_sprite) {
-		_sprite = new BaseSprite(_gameRef);
+		_sprite = new BaseSprite(_game);
 		if (!_sprite || DID_FAIL(_sprite->loadFile(_spriteFilename))) {
 			SAFE_DELETE(_sprite);
 			return STATUS_FAILED;
@@ -246,7 +246,7 @@ bool AdTalkNode::loadSprite() {
 			return STATUS_OK;
 		}
 	} else if (_spriteSetFilename && !_spriteSet) {
-		_spriteSet = new AdSpriteSet(_gameRef);
+		_spriteSet = new AdSpriteSet(_game);
 		if (!_spriteSet || DID_FAIL(_spriteSet->loadFile(_spriteSetFilename))) {
 			SAFE_DELETE(_spriteSet);
 			return STATUS_FAILED;
diff --git a/engines/wintermute/ad/ad_waypoint_group.cpp b/engines/wintermute/ad/ad_waypoint_group.cpp
index 22b4e86d0a1..7d95f290d04 100644
--- a/engines/wintermute/ad/ad_waypoint_group.cpp
+++ b/engines/wintermute/ad/ad_waypoint_group.cpp
@@ -67,7 +67,7 @@ void AdWaypointGroup::cleanup() {
 bool AdWaypointGroup::loadFile(const char *filename) {
 	char *buffer = (char *)BaseFileManager::getEngineInstance()->readWholeFile(filename);
 	if (buffer == nullptr) {
-		_gameRef->LOG(0, "AdWaypointGroup::LoadFile failed for file '%s'", filename);
+		_game->LOG(0, "AdWaypointGroup::LoadFile failed for file '%s'", filename);
 		return STATUS_FAILED;
 	}
 
@@ -76,7 +76,7 @@ bool AdWaypointGroup::loadFile(const char *filename) {
 	setFilename(filename);
 
 	if (DID_FAIL(ret = loadBuffer(buffer, true))) {
-		_gameRef->LOG(0, "Error parsing WAYPOINTS file '%s'", filename);
+		_game->LOG(0, "Error parsing WAYPOINTS file '%s'", filename);
 	}
 
 
@@ -115,7 +115,7 @@ bool AdWaypointGroup::loadBuffer(char *buffer, bool complete) {
 
 	if (complete) {
 		if (parser.getCommand(&buffer, commands, &params) != TOKEN_WAYPOINTS) {
-			_gameRef->LOG(0, "'WAYPOINTS' keyword expected.");
+			_game->LOG(0, "'WAYPOINTS' keyword expected.");
 			return STATUS_FAILED;
 		}
 		buffer = params;
@@ -161,7 +161,7 @@ bool AdWaypointGroup::loadBuffer(char *buffer, bool complete) {
 		}
 	}
 	if (cmd == PARSERR_TOKENNOTFOUND) {
-		_gameRef->LOG(0, "Syntax error in WAYPOINTS definition");
+		_game->LOG(0, "Syntax error in WAYPOINTS definition");
 		return STATUS_FAILED;
 	}
 
diff --git a/engines/wintermute/base/base.cpp b/engines/wintermute/base/base.cpp
index f011f8ddc09..8ce19ced616 100644
--- a/engines/wintermute/base/base.cpp
+++ b/engines/wintermute/base/base.cpp
@@ -36,14 +36,14 @@ namespace Wintermute {
 
 //////////////////////////////////////////////////////////////////////
 BaseClass::BaseClass(BaseGame *gameOwner) {
-	_gameRef = gameOwner;
+	_game = gameOwner;
 	_persistable = true;
 }
 
 
 //////////////////////////////////////////////////////////////////////////
 BaseClass::BaseClass() {
-	_gameRef = nullptr;
+	_game = nullptr;
 	_persistable = true;
 }
 
@@ -95,7 +95,7 @@ bool BaseClass::parseEditorProperty(char *buffer, bool complete) {
 	TOKEN_TABLE_END
 
 
-	if (!_gameRef->_editorMode) {
+	if (!_game->_editorMode) {
 		return STATUS_OK;
 	}
 
diff --git a/engines/wintermute/base/base.h b/engines/wintermute/base/base.h
index 0e9a2bebc74..d1c1d5e275c 100644
--- a/engines/wintermute/base/base.h
+++ b/engines/wintermute/base/base.h
@@ -49,7 +49,7 @@ public:
 	bool parseEditorProperty(char *buffer, bool complete = true);
 	virtual bool saveAsText(BaseDynamicBuffer *buffer, int indent = 0);
 	BaseClass();
-	BaseGame *_gameRef;
+	BaseGame *_game;
 	BaseClass(BaseGame *GameOwner);
 	virtual ~BaseClass();
 
diff --git a/engines/wintermute/base/base_active_rect.cpp b/engines/wintermute/base/base_active_rect.cpp
index 44996721ac8..d521fd89728 100644
--- a/engines/wintermute/base/base_active_rect.cpp
+++ b/engines/wintermute/base/base_active_rect.cpp
@@ -115,7 +115,7 @@ BaseActiveRect::~BaseActiveRect() {
 void BaseActiveRect::clipRect() {
 	Common::Rect32 rc;
 	bool customViewport;
-	_gameRef->getCurrentViewportRect(&rc, &customViewport);
+	_game->getCurrentViewportRect(&rc, &customViewport);
 	BaseRenderer *rend = BaseEngine::getRenderer();
 
 	if (!customViewport) {
diff --git a/engines/wintermute/base/base_engine.h b/engines/wintermute/base/base_engine.h
index 2d2e7347cca..7ace2bbfbdf 100644
--- a/engines/wintermute/base/base_engine.h
+++ b/engines/wintermute/base/base_engine.h
@@ -61,7 +61,7 @@ public:
 	~BaseEngine() override;
 	static void createInstance(const Common::String &targetName, const Common::String &gameId, Common::Language lang, WMETargetExecutable targetExecutable, uint32 flags);
 
-	void setGameRef(BaseGame *gameRef) { _gameRef = gameRef; }
+	void setGameRef(BaseGame *game) { _gameRef = game; }
 
 	Common::RandomSource *getRandomSource() { return _rnd; }
 	uint32 randInt(int from, int to);
diff --git a/engines/wintermute/base/base_frame.cpp b/engines/wintermute/base/base_frame.cpp
index 7b11000eefe..54217a9e9d9 100644
--- a/engines/wintermute/base/base_frame.cpp
+++ b/engines/wintermute/base/base_frame.cpp
@@ -82,7 +82,7 @@ bool BaseFrame::draw(int x, int y, BaseObject *registerOwner, float zoomX, float
 	for (int32 i = 0; i < _subframes.getSize(); i++) {
 		// filter out subframes unsupported by current renderer
 		if (!allFrames) {
-			if ((_subframes[i]->_2DOnly && _gameRef->_useD3D) || (_subframes[i]->_3DOnly && !_gameRef->_useD3D))
+			if ((_subframes[i]->_2DOnly && _game->_useD3D) || (_subframes[i]->_3DOnly && !_game->_useD3D))
 				continue;
 		}
 		res = _subframes[i]->draw(x, y, registerOwner, zoomX, zoomY, precise, alpha, rotate, blendMode);
@@ -101,7 +101,7 @@ bool BaseFrame::oneTimeDisplay(BaseObject *owner, bool muted) {
 		}
 		_sound->play();
 		/*
-		if (_gameRef->_state == GAME_FROZEN) {
+		if (_game->_state == GAME_FROZEN) {
 		    _sound->Pause(true);
 		}
 		*/
@@ -246,7 +246,7 @@ bool BaseFrame::loadBuffer(char *buffer, int lifeTime, bool keepLoaded) {
 			break;
 
 		case TOKEN_SUBFRAME: {
-			BaseSubFrame *subframe = new BaseSubFrame(_gameRef);
+			BaseSubFrame *subframe = new BaseSubFrame(_game);
 			if (!subframe || DID_FAIL(subframe->loadBuffer(params, lifeTime, keepLoaded))) {
 				delete subframe;
 				cmd = PARSERR_GENERIC;
@@ -260,7 +260,7 @@ bool BaseFrame::loadBuffer(char *buffer, int lifeTime, bool keepLoaded) {
 			if (_sound) {
 				SAFE_DELETE(_sound);
 			}
-			_sound = new BaseSound(_gameRef);
+			_sound = new BaseSound(_game);
 			if (!_sound || DID_FAIL(_sound->setSound(params, Audio::Mixer::kSFXSoundType, false))) {
 				if (BaseEngine::instance().getSoundMgr()->_soundAvailable) {
 					BaseEngine::LOG(0, "Error loading sound '%s'.", params);
@@ -305,7 +305,7 @@ bool BaseFrame::loadBuffer(char *buffer, int lifeTime, bool keepLoaded) {
 	}
 
 
-	BaseSubFrame *sub = new BaseSubFrame(_gameRef);
+	BaseSubFrame *sub = new BaseSubFrame(_game);
 	if (surface_file != nullptr) {
 		if (customTrans) {
 			sub->setSurface(surface_file, false, r, g, b, lifeTime, keepLoaded);
@@ -455,7 +455,7 @@ bool BaseFrame::scCallMethod(ScScript *script, ScStack *stack, ScStack *thisStac
 		SAFE_DELETE(_sound);
 
 		if (!val->isNULL()) {
-			_sound = new BaseSound(_gameRef);
+			_sound = new BaseSound(_game);
 			if (!_sound || DID_FAIL(_sound->setSound(val->getString(), Audio::Mixer::kSFXSoundType, false))) {
 				stack->pushBool(false);
 				SAFE_DELETE(_sound);
@@ -520,7 +520,7 @@ bool BaseFrame::scCallMethod(ScScript *script, ScStack *stack, ScStack *thisStac
 			filename = val->getString();
 		}
 
-		BaseSubFrame *sub = new BaseSubFrame(_gameRef);
+		BaseSubFrame *sub = new BaseSubFrame(_game);
 		if (filename != nullptr) {
 			sub->setSurface(filename);
 			sub->setDefaultRect();
@@ -547,7 +547,7 @@ bool BaseFrame::scCallMethod(ScScript *script, ScStack *stack, ScStack *thisStac
 			filename = val->getString();
 		}
 
-		BaseSubFrame *sub = new BaseSubFrame(_gameRef);
+		BaseSubFrame *sub = new BaseSubFrame(_game);
 		if (filename != nullptr) {
 			sub->setSurface(filename);
 		}
@@ -625,7 +625,7 @@ bool BaseFrame::scCallMethod(ScScript *script, ScStack *stack, ScStack *thisStac
 //////////////////////////////////////////////////////////////////////////
 ScValue *BaseFrame::scGetProperty(const Common::String &name) {
 	if (!_scValue) {
-		_scValue = new ScValue(_gameRef);
+		_scValue = new ScValue(_game);
 	}
 	_scValue->setNULL();
 
diff --git a/engines/wintermute/base/base_game.cpp b/engines/wintermute/base/base_game.cpp
index d9052410db6..0537b63421b 100644
--- a/engines/wintermute/base/base_game.cpp
+++ b/engines/wintermute/base/base_game.cpp
@@ -709,7 +709,7 @@ bool BaseGame::initLoop() {
 		_framesRendered  = 0;
 		_fpsTime = 0;
 	}
-	//_gameRef->LOG(0, "%d", _fps);
+	//_game->LOG(0, "%d", _fps);
 
 	getMousePos(&_mousePos);
 
@@ -764,7 +764,7 @@ void BaseGame::getOffset(int *offsetX, int *offsetY) const {
 bool BaseGame::loadFile(const char *filename) {
 	char *buffer = (char *)BaseFileManager::getEngineInstance()->readWholeFile(filename);
 	if (buffer == nullptr) {
-		_gameRef->LOG(0, "BaseGame::LoadFile failed for file '%s'", filename);
+		_game->LOG(0, "BaseGame::LoadFile failed for file '%s'", filename);
 		return STATUS_FAILED;
 	}
 
@@ -773,7 +773,7 @@ bool BaseGame::loadFile(const char *filename) {
 	setFilename(filename);
 
 	if (DID_FAIL(ret = loadBuffer(buffer, true))) {
-		_gameRef->LOG(0, "Error parsing GAME file '%s'", filename);
+		_game->LOG(0, "Error parsing GAME file '%s'", filename);
 	}
 
 	delete[] buffer;
@@ -894,7 +894,7 @@ bool BaseGame::loadBuffer(char *buffer, bool complete) {
 
 	if (complete) {
 		if (parser.getCommand(&buffer, commands, &params) != TOKEN_GAME) {
-			_gameRef->LOG(0, "'GAME' keyword expected.");
+			_game->LOG(0, "'GAME' keyword expected.");
 			return STATUS_FAILED;
 		}
 		buffer = params;
@@ -922,7 +922,7 @@ bool BaseGame::loadBuffer(char *buffer, bool complete) {
 			}
 			_systemFont = nullptr;
 
-			_systemFont = _gameRef->_fontStorage->addFont(params);
+			_systemFont = _game->_fontStorage->addFont(params);
 			break;
 
 		case TOKEN_VIDEO_FONT:
@@ -931,7 +931,7 @@ bool BaseGame::loadBuffer(char *buffer, bool complete) {
 			}
 			_videoFont = nullptr;
 
-			_videoFont = _gameRef->_fontStorage->addFont(params);
+			_videoFont = _game->_fontStorage->addFont(params);
 			break;
 
 
@@ -942,13 +942,13 @@ bool BaseGame::loadBuffer(char *buffer, bool complete) {
 			}
 			_shadowImage = nullptr;
 
-			_shadowImage = _gameRef->_surfaceStorage->addSurface(params);
+			_shadowImage = _game->_surfaceStorage->addSurface(params);
 			break;
 #endif
 
 		case TOKEN_CURSOR:
 			SAFE_DELETE(_cursor);
-			_cursor = new BaseSprite(_gameRef);
+			_cursor = new BaseSprite(_game);
 			if (!_cursor || DID_FAIL(_cursor->loadFile(params))) {
 				SAFE_DELETE(_cursor);
 				cmd = PARSERR_GENERIC;
@@ -957,7 +957,7 @@ bool BaseGame::loadBuffer(char *buffer, bool complete) {
 
 		case TOKEN_ACTIVE_CURSOR:
 			SAFE_DELETE(_activeCursor);
-			_activeCursor = new BaseSprite(_gameRef);
+			_activeCursor = new BaseSprite(_game);
 			if (!_activeCursor || DID_FAIL(_activeCursor->loadFile(params))) {
 				SAFE_DELETE(_activeCursor);
 				cmd = PARSERR_GENERIC;
@@ -966,7 +966,7 @@ bool BaseGame::loadBuffer(char *buffer, bool complete) {
 
 		case TOKEN_NONINTERACTIVE_CURSOR:
 			SAFE_DELETE(_cursorNoninteractive);
-			_cursorNoninteractive = new BaseSprite(_gameRef);
+			_cursorNoninteractive = new BaseSprite(_game);
 			if (!_cursorNoninteractive || DID_FAIL(_cursorNoninteractive->loadFile(params))) {
 				SAFE_DELETE(_cursorNoninteractive);
 				cmd = PARSERR_GENERIC;
@@ -1075,20 +1075,20 @@ bool BaseGame::loadBuffer(char *buffer, bool complete) {
 	_renderer->setLoadingScreen(loadImageName.c_str(), loadImageX, loadImageY);
 
 	if (!_systemFont) {
-		_systemFont = _gameRef->_fontStorage->addFont("system_font.fnt");
+		_systemFont = _game->_fontStorage->addFont("system_font.fnt");
 	}
 #ifdef ENABLE_WME3D
 	if (!_shadowImage) {
-		_shadowImage = _gameRef->_surfaceStorage->addSurface("shadow.png");
+		_shadowImage = _game->_surfaceStorage->addSurface("shadow.png");
 	}
 #endif
 
 	if (cmd == PARSERR_TOKENNOTFOUND) {
-		_gameRef->LOG(0, "Syntax error in GAME definition");
+		_game->LOG(0, "Syntax error in GAME definition");
 		return STATUS_FAILED;
 	}
 	if (cmd == PARSERR_GENERIC) {
-		_gameRef->LOG(0, "Error loading GAME definition");
+		_game->LOG(0, "Error loading GAME definition");
 		return STATUS_FAILED;
 	}
 
@@ -1133,7 +1133,7 @@ bool BaseGame::scCallMethod(ScScript *script, ScStack *stack, ScStack *thisStack
 	// RunScript
 	//////////////////////////////////////////////////////////////////////////
 	else if (strcmp(name, "RunScript") == 0) {
-		_gameRef->LOG(0, "**Warning** The 'RunScript' method is now obsolete. Use 'AttachScript' instead (same syntax)");
+		_game->LOG(0, "**Warning** The 'RunScript' method is now obsolete. Use 'AttachScript' instead (same syntax)");
 		stack->correctParams(1);
 		if (DID_FAIL(addScript(stack->pop()->getString()))) {
 			stack->pushBool(false);
@@ -1216,7 +1216,7 @@ bool BaseGame::scCallMethod(ScScript *script, ScStack *stack, ScStack *thisStack
 	//////////////////////////////////////////////////////////////////////////
 	else if (strcmp(name, "LoadWindow") == 0) {
 		stack->correctParams(1);
-		UIWindow *win = new UIWindow(_gameRef);
+		UIWindow *win = new UIWindow(_game);
 		if (win && DID_SUCCEED(win->loadFile(stack->pop()->getString()))) {
 			_windows.add(win);
 			registerObject(win);
@@ -1483,7 +1483,7 @@ bool BaseGame::scCallMethod(ScScript *script, ScStack *stack, ScStack *thisStack
 			return STATUS_OK;
 		}
 
-		_musicCrossfadeStartTime = _gameRef->getLiveTimer()->getTime();
+		_musicCrossfadeStartTime = _game->getLiveTimer()->getTime();
 		_musicCrossfadeChannel1 = channel1;
 		_musicCrossfadeChannel2 = channel2;
 		_musicCrossfadeLength = fadeLength;
@@ -1515,7 +1515,7 @@ bool BaseGame::scCallMethod(ScScript *script, ScStack *stack, ScStack *thisStack
 			return STATUS_OK;
 		}
 
-		_musicCrossfadeStartTime = _gameRef->getLiveTimer()->getTime();
+		_musicCrossfadeStartTime = _game->getLiveTimer()->getTime();
 		_musicCrossfadeChannel1 = channel;
 		_musicCrossfadeChannel2 = channel;
 		_musicCrossfadeLength = fadeLength;
@@ -1540,7 +1540,7 @@ bool BaseGame::scCallMethod(ScScript *script, ScStack *stack, ScStack *thisStack
 		int length = 0;
 		const char *filename = stack->pop()->getString();
 
-		BaseSound *sound = new BaseSound(_gameRef);
+		BaseSound *sound = new BaseSound(_game);
 		if (sound && DID_SUCCEED(sound->setSound(filename, Audio::Mixer::kMusicSoundType, true))) {
 			length = sound->getLength();
 			delete sound;
@@ -1619,8 +1619,8 @@ bool BaseGame::scCallMethod(ScScript *script, ScStack *stack, ScStack *thisStack
 			type = (int)VID_PLAY_STRETCH;
 		}
 
-		if (DID_SUCCEED(_gameRef->_videoPlayer->initialize(filename, subtitleFile))) {
-			if (DID_SUCCEED(_gameRef->_videoPlayer->play((TVideoPlayback)type, xVal, yVal, freezeMusic))) {
+		if (DID_SUCCEED(_game->_videoPlayer->initialize(filename, subtitleFile))) {
+			if (DID_SUCCEED(_game->_videoPlayer->play((TVideoPlayback)type, xVal, yVal, freezeMusic))) {
 				stack->pushBool(true);
 				script->sleep(0);
 			} else {
@@ -1832,7 +1832,7 @@ bool BaseGame::scCallMethod(ScScript *script, ScStack *stack, ScStack *thisStack
 		stack->pushInt(time.tm_mon + 1);
 		stack->pushInt(time.tm_year + 1900);
 		stack->pushInt(6);
-		BaseScriptable *date = makeSXDate(_gameRef, stack);
+		BaseScriptable *date = makeSXDate(_game, stack);
 		stack->pushNative(date, false);
 
 		Common::String desc = SaveLoad::getSaveSlotDescription(slot);
@@ -1841,10 +1841,10 @@ bool BaseGame::scCallMethod(ScScript *script, ScStack *stack, ScStack *thisStack
 		BaseScriptable *obj;
 		if (BaseEngine::instance().isFoxTail(FOXTAIL_1_2_527, FOXTAIL_LATEST_VERSION)) {
 			stack->pushInt(2);
-			obj = makeSXArray(_gameRef, stack);
+			obj = makeSXArray(_game, stack);
 		} else {
 			stack->pushInt(0);
-			obj = makeSXObject(_gameRef, stack);
+			obj = makeSXObject(_game, stack);
 			obj->scSetProperty("Description", stack->pop());
 			obj->scSetProperty("Timestamp", stack->pop());
 		}
@@ -1883,7 +1883,7 @@ bool BaseGame::scCallMethod(ScScript *script, ScStack *stack, ScStack *thisStack
 	//////////////////////////////////////////////////////////////////////////
 	else if (strcmp(name, "SetGlobalSFXVolume") == 0) {
 		stack->correctParams(1);
-		_gameRef->_soundMgr->setVolumePercent(Audio::Mixer::kSFXSoundType, (byte)stack->pop()->getInt());
+		_game->_soundMgr->setVolumePercent(Audio::Mixer::kSFXSoundType, (byte)stack->pop()->getInt());
 		stack->pushNULL();
 		return STATUS_OK;
 	}
@@ -1893,7 +1893,7 @@ bool BaseGame::scCallMethod(ScScript *script, ScStack *stack, ScStack *thisStack
 	//////////////////////////////////////////////////////////////////////////
 	else if (strcmp(name, "SetGlobalSpeechVolume") == 0) {
 		stack->correctParams(1);
-		_gameRef->_soundMgr->setVolumePercent(Audio::Mixer::kSpeechSoundType, (byte)stack->pop()->getInt());
+		_game->_soundMgr->setVolumePercent(Audio::Mixer::kSpeechSoundType, (byte)stack->pop()->getInt());
 		stack->pushNULL();
 		return STATUS_OK;
 	}
@@ -1903,7 +1903,7 @@ bool BaseGame::scCallMethod(ScScript *script, ScStack *stack, ScStack *thisStack
 	//////////////////////////////////////////////////////////////////////////
 	else if (strcmp(name, "SetGlobalMusicVolume") == 0) {
 		stack->correctParams(1);
-		_gameRef->_soundMgr->setVolumePercent(Audio::Mixer::kMusicSoundType, (byte)stack->pop()->getInt());
+		_game->_soundMgr->setVolumePercent(Audio::Mixer::kMusicSoundType, (byte)stack->pop()->getInt());
 		stack->pushNULL();
 		return STATUS_OK;
 	}
@@ -1913,7 +1913,7 @@ bool BaseGame::scCallMethod(ScScript *script, ScStack *stack, ScStack *thisStack
 	//////////////////////////////////////////////////////////////////////////
 	else if (strcmp(name, "SetGlobalMasterVolume") == 0) {
 		stack->correctParams(1);
-		_gameRef->_soundMgr->setMasterVolumePercent((byte)stack->pop()->getInt());
+		_game->_soundMgr->setMasterVolumePercent((byte)stack->pop()->getInt());
 		stack->pushNULL();
 		return STATUS_OK;
 	}
@@ -2118,10 +2118,10 @@ bool BaseGame::scCallMethod(ScScript *script, ScStack *stack, ScStack *thisStack
 		}
 
 		// redraw before taking screenshot
-		_gameRef->displayContent(false);
+		_game->displayContent(false);
 
 		bool ret = false;
-		BaseImage *image = _gameRef->_renderer->takeScreenshot();
+		BaseImage *image = _game->_renderer->takeScreenshot();
 		if (image) {
 			ret = image->saveBMPFile(filename);
 			delete image;
@@ -2141,10 +2141,10 @@ bool BaseGame::scCallMethod(ScScript *script, ScStack *stack, ScStack *thisStack
 		int sizeY = stack->pop()->getInt(_renderer->getHeight());
 
 		// redraw before taking screenshot
-		_gameRef->displayContent(false);
+		_game->displayContent(false);
 
 		bool ret = false;
-		BaseImage *image = _gameRef->_renderer->takeScreenshot(sizeX, sizeY);
+		BaseImage *image = _game->_renderer->takeScreenshot(sizeX, sizeY);
 		if (image) {
 			ret = image->saveBMPFile(filename);
 			delete image;
@@ -2161,7 +2161,7 @@ bool BaseGame::scCallMethod(ScScript *script, ScStack *stack, ScStack *thisStack
 		stack->correctParams(1);
 		ScValue *val = stack->pop();
 
-		UIWindow *win = new UIWindow(_gameRef);
+		UIWindow *win = new UIWindow(_game);
 		_windows.add(win);
 		registerObject(win);
 		if (!val->isNULL()) {
@@ -2323,8 +2323,8 @@ bool BaseGame::scCallMethod(ScScript *script, ScStack *stack, ScStack *thisStack
 			SAFE_DELETE(_loadingIcon);
 		} else {
 			displayContent(false, true);
-			_gameRef->_renderer->flip();
-			_gameRef->_renderer->initLoop();
+			_game->_renderer->flip();
+			_game->_renderer->initLoop();
 		}
 		stack->pushNULL();
 
@@ -2613,10 +2613,10 @@ bool BaseGame::scCallMethod(ScScript *script, ScStack *stack, ScStack *thisStack
 		BaseScriptable *obj;
 		if (BaseEngine::instance().isFoxTail(FOXTAIL_1_2_527, FOXTAIL_LATEST_VERSION)) {
 			stack->pushInt(2);
-			obj = makeSXArray(_gameRef, stack);
+			obj = makeSXArray(_game, stack);
 		} else {
 			stack->pushInt(0);
-			obj = makeSXObject(_gameRef, stack);
+			obj = makeSXObject(_game, stack);
 			obj->scSetProperty("w", stack->pop());
 			obj->scSetProperty("h", stack->pop());
 		}
@@ -2672,7 +2672,7 @@ bool BaseGame::scCallMethod(ScScript *script, ScStack *stack, ScStack *thisStack
 		BaseFileManager::getEngineInstance()->listMatchingFiles(fnames, pattern);
 
 		stack->pushInt(0);
-		BaseScriptable *arr = makeSXArray(_gameRef, stack);
+		BaseScriptable *arr = makeSXArray(_game, stack);
 		for (uint32 i = 0; i < fnames.size(); i++) {
 			stack->pushString(fnames[i].c_str());
 			((SXArray *)arr)->push(stack->pop());
@@ -2833,7 +2833,7 @@ ScValue *BaseGame::scGetProperty(const Common::String &name) {
 	// SFXVolume
 	//////////////////////////////////////////////////////////////////////////
 	else if (name == "SFXVolume") {
-		_gameRef->LOG(0, "**Warning** The SFXVolume attribute is obsolete");
+		_game->LOG(0, "**Warning** The SFXVolume attribute is obsolete");
 		_scValue->setInt(_soundMgr->getVolumePercent(Audio::Mixer::kSFXSoundType));
 		return _scValue;
 	}
@@ -2842,7 +2842,7 @@ ScValue *BaseGame::scGetProperty(const Common::String &name) {
 	// SpeechVolume
 	//////////////////////////////////////////////////////////////////////////
 	else if (name == "SpeechVolume") {
-		_gameRef->LOG(0, "**Warning** The SpeechVolume attribute is obsolete");
+		_game->LOG(0, "**Warning** The SpeechVolume attribute is obsolete");
 		_scValue->setInt(_soundMgr->getVolumePercent(Audio::Mixer::kSpeechSoundType));
 		return _scValue;
 	}
@@ -2851,7 +2851,7 @@ ScValue *BaseGame::scGetProperty(const Common::String &name) {
 	// MusicVolume
 	//////////////////////////////////////////////////////////////////////////
 	else if (name == "MusicVolume") {
-		_gameRef->LOG(0, "**Warning** The MusicVolume attribute is obsolete");
+		_game->LOG(0, "**Warning** The MusicVolume attribute is obsolete");
 		_scValue->setInt(_soundMgr->getVolumePercent(Audio::Mixer::kMusicSoundType));
 		return _scValue;
 	}
@@ -2860,7 +2860,7 @@ ScValue *BaseGame::scGetProperty(const Common::String &name) {
 	// MasterVolume
 	//////////////////////////////////////////////////////////////////////////
 	else if (name == "MasterVolume") {
-		_gameRef->LOG(0, "**Warning** The MasterVolume attribute is obsolete");
+		_game->LOG(0, "**Warning** The MasterVolume attribute is obsolete");
 		_scValue->setInt(_soundMgr->getMasterVolumePercent());
 		return _scValue;
 	}
@@ -3006,7 +3006,7 @@ ScValue *BaseGame::scGetProperty(const Common::String &name) {
 	// Direct3DDevice
 	//////////////////////////////////////////////////////////////////////////
 	else if (name == "Direct3DDevice") {
-		if (_gameRef->_useD3D)
+		if (_game->_useD3D)
 			_scValue->setInt((int)('D3DH'));
 		else
 			_scValue->setNULL();
@@ -3017,7 +3017,7 @@ ScValue *BaseGame::scGetProperty(const Common::String &name) {
 	// DirectDrawInterface
 	//////////////////////////////////////////////////////////////////////////
 	else if (name == "DirectDrawInterface") {
-		if (!_gameRef->_useD3D)
+		if (!_game->_useD3D)
 			_scValue->setInt((int)('DDIH'));
 		else
 			_scValue->setNULL();
@@ -3098,7 +3098,7 @@ ScValue *BaseGame::scGetProperty(const Common::String &name) {
 	//////////////////////////////////////////////////////////////////////////
 	else if (name == "MaxActiveLights") {
 		if (_useD3D) {
-			BaseRenderer3D *renderer = _gameRef->_renderer3D;
+			BaseRenderer3D *renderer = _game->_renderer3D;
 			_scValue->setInt(renderer->getMaxActiveLights());
 		} else {
 			_scValue->setInt(0);
@@ -3381,8 +3381,8 @@ bool BaseGame::scSetProperty(const char *name, ScValue *value) {
 	// SFXVolume
 	//////////////////////////////////////////////////////////////////////////
 	else if (strcmp(name, "SFXVolume") == 0) {
-		_gameRef->LOG(0, "**Warning** The SFXVolume attribute is obsolete");
-		_gameRef->_soundMgr->setVolumePercent(Audio::Mixer::kSFXSoundType, (byte)value->getInt());
+		_game->LOG(0, "**Warning** The SFXVolume attribute is obsolete");
+		_game->_soundMgr->setVolumePercent(Audio::Mixer::kSFXSoundType, (byte)value->getInt());
 		return STATUS_OK;
 	}
 
@@ -3390,8 +3390,8 @@ bool BaseGame::scSetProperty(const char *name, ScValue *value) {
 	// SpeechVolume
 	//////////////////////////////////////////////////////////////////////////
 	else if (strcmp(name, "SpeechVolume") == 0) {
-		_gameRef->LOG(0, "**Warning** The SpeechVolume attribute is obsolete");
-		_gameRef->_soundMgr->setVolumePercent(Audio::Mixer::kSpeechSoundType, (byte)value->getInt());
+		_game->LOG(0, "**Warning** The SpeechVolume attribute is obsolete");
+		_game->_soundMgr->setVolumePercent(Audio::Mixer::kSpeechSoundType, (byte)value->getInt());
 		return STATUS_OK;
 	}
 
@@ -3399,8 +3399,8 @@ bool BaseGame::scSetProperty(const char *name, ScValue *value) {
 	// MusicVolume
 	//////////////////////////////////////////////////////////////////////////
 	else if (strcmp(name, "MusicVolume") == 0) {
-		_gameRef->LOG(0, "**Warning** The MusicVolume attribute is obsolete");
-		_gameRef->_soundMgr->setVolumePercent(Audio::Mixer::kMusicSoundType, (byte)value->getInt());
+		_game->LOG(0, "**Warning** The MusicVolume attribute is obsolete");
+		_game->_soundMgr->setVolumePercent(Audio::Mixer::kMusicSoundType, (byte)value->getInt());
 		return STATUS_OK;
 	}
 
@@ -3408,8 +3408,8 @@ bool BaseGame::scSetProperty(const char *name, ScValue *value) {
 	// MasterVolume
 	//////////////////////////////////////////////////////////////////////////
 	else if (strcmp(name, "MasterVolume") == 0) {
-		_gameRef->LOG(0, "**Warning** The MasterVolume attribute is obsolete");
-		_gameRef->_soundMgr->setMasterVolumePercent((byte)value->getInt());
+		_game->LOG(0, "**Warning** The MasterVolume attribute is obsolete");
+		_game->_soundMgr->setMasterVolumePercent((byte)value->getInt());
 		return STATUS_OK;
 	}
 
@@ -3711,7 +3711,7 @@ bool BaseGame::externalCall(ScScript *script, ScStack *stack, ScStack *thisStack
 	//////////////////////////////////////////////////////////////////////////
 	if (strcmp(name, "LOG") == 0) {
 		stack->correctParams(1);
-		_gameRef->LOG(0, "sc: %s", stack->pop()->getString());
+		_game->LOG(0, "sc: %s", stack->pop()->getString());
 		stack->pushNULL();
 	}
 
@@ -3721,7 +3721,7 @@ bool BaseGame::externalCall(ScScript *script, ScStack *stack, ScStack *thisStack
 	else if (strcmp(name, "String") == 0) {
 		thisObj = thisStack->getTop();
 
-		thisObj->setNative(makeSXString(_gameRef,  stack));
+		thisObj->setNative(makeSXString(_game,  stack));
 		stack->pushNULL();
 	}
 
@@ -3731,7 +3731,7 @@ bool BaseGame::externalCall(ScScript *script, ScStack *stack, ScStack *thisStack
 	else if (strcmp(name, "MemBuffer") == 0) {
 		thisObj = thisStack->getTop();
 
-		thisObj->setNative(makeSXMemBuffer(_gameRef,  stack));
+		thisObj->setNative(makeSXMemBuffer(_game,  stack));
 		stack->pushNULL();
 	}
 
@@ -3741,7 +3741,7 @@ bool BaseGame::externalCall(ScScript *script, ScStack *stack, ScStack *thisStack
 	else if (strcmp(name, "File") == 0) {
 		thisObj = thisStack->getTop();
 
-		thisObj->setNative(makeSXFile(_gameRef,  stack));
+		thisObj->setNative(makeSXFile(_game,  stack));
 		stack->pushNULL();
 	}
 
@@ -3751,7 +3751,7 @@ bool BaseGame::externalCall(ScScript *script, ScStack *stack, ScStack *thisStack
 	else if (strcmp(name, "Directory") == 0) {
 		thisObj = thisStack->getTop();
 
-		thisObj->setNative(makeSXDirectory(_gameRef));
+		thisObj->setNative(makeSXDirectory(_game));
 		stack->pushNULL();
 	}
 
@@ -3761,7 +3761,7 @@ bool BaseGame::externalCall(ScScript *script, ScStack *stack, ScStack *thisStack
 	else if (strcmp(name, "Date") == 0) {
 		thisObj = thisStack->getTop();
 
-		thisObj->setNative(makeSXDate(_gameRef,  stack));
+		thisObj->setNative(makeSXDate(_game,  stack));
 		stack->pushNULL();
 	}
 
@@ -3771,7 +3771,7 @@ bool BaseGame::externalCall(ScScript *script, ScStack *stack, ScStack *thisStack
 	else if (strcmp(name, "Array") == 0) {
 		thisObj = thisStack->getTop();
 
-		thisObj->setNative(makeSXArray(_gameRef,  stack));
+		thisObj->setNative(makeSXArray(_game,  stack));
 		stack->pushNULL();
 	}
 
@@ -3781,7 +3781,7 @@ bool BaseGame::externalCall(ScScript *script, ScStack *stack, ScStack *thisStack
 	else if (strcmp(name, "Object") == 0) {
 		thisObj = thisStack->getTop();
 
-		thisObj->setNative(makeSXObject(_gameRef,  stack));
+		thisObj->setNative(makeSXObject(_game,  stack));
 		stack->pushNULL();
 	}
 
@@ -4027,7 +4027,7 @@ bool BaseGame::externalCall(ScScript *script, ScStack *stack, ScStack *thisStack
 		// There is no way to makeSXArray() with exactly 1 given element
 		// That's why we are creating empty Array and SXArray::push() later
 		stack->pushInt(0);
-		BaseScriptable *arr = makeSXArray(_gameRef, stack);
+		BaseScriptable *arr = makeSXArray(_game, stack);
 
 		// Iterating string copy, replacing delimeter with '\0' and pushing matches
 		// Only non-empty matches should be pushed
@@ -4077,7 +4077,7 @@ bool BaseGame::externalCall(ScScript *script, ScStack *stack, ScStack *thisStack
 	//////////////////////////////////////////////////////////////////////////
 	// Plugins: emulate object constructors from known "wme_*.dll" plugins
 	//////////////////////////////////////////////////////////////////////////
-	else if(!DID_FAIL(EmulatePluginCall(_gameRef, stack, thisStack, name))) {
+	else if(!DID_FAIL(EmulatePluginCall(_game, stack, thisStack, name))) {
 		return STATUS_OK;
 	}
 
@@ -4099,7 +4099,7 @@ bool BaseGame::showCursor() {
 		return STATUS_OK;
 	}
 
-	if (!_interactive && _gameRef->_state == GAME_RUNNING) {
+	if (!_interactive && _game->_state == GAME_RUNNING) {
 		if (_cursorNoninteractive) {
 			return drawCursor(_cursorNoninteractive);
 		}
@@ -4120,13 +4120,13 @@ bool BaseGame::showCursor() {
 
 //////////////////////////////////////////////////////////////////////////
 bool BaseGame::saveGame(int32 slot, const char *desc, bool quickSave) {
-	return SaveLoad::saveGame(slot, desc, quickSave, _gameRef);
+	return SaveLoad::saveGame(slot, desc, quickSave, _game);
 }
 
 
 //////////////////////////////////////////////////////////////////////////
 bool BaseGame::loadGame(uint32 slot) {
-	//_gameRef->LOG(0, "Load start %d", BaseUtils::GetUsedMemMB());
+	//_game->LOG(0, "Load start %d", BaseUtils::GetUsedMemMB());
 
 	_loading = false;
 	_scheduledLoadSlot = -1;
@@ -4139,7 +4139,7 @@ bool BaseGame::loadGame(uint32 slot) {
 
 //////////////////////////////////////////////////////////////////////////
 bool BaseGame::loadGame(const char *filename) {
-	return SaveLoad::loadGame(filename, _gameRef);
+	return SaveLoad::loadGame(filename, _game);
 }
 
 //////////////////////////////////////////////////////////////////////////
@@ -4181,7 +4181,7 @@ bool BaseGame::playMusic(int channel, const char *filename, bool looping, uint32
 	delete _music[channel];
 	_music[channel] = nullptr;
 
-	_music[channel] = new BaseSound(_gameRef);
+	_music[channel] = new BaseSound(_game);
 	if (_music[channel] && DID_SUCCEED(_music[channel]->setSound(filename, Audio::Mixer::kMusicSoundType, true))) {
 		if (_musicStartTime[channel]) {
 			_music[channel]->setPositionTime(_musicStartTime[channel]);
@@ -4265,7 +4265,7 @@ bool BaseGame::updateMusicCrossfade() {
 	if (!_musicCrossfadeRunning) {
 		return STATUS_OK;
 	}
-	if (_gameRef->_state == GAME_FROZEN) {
+	if (_game->_state == GAME_FROZEN) {
 		return STATUS_OK;
 	}
 
@@ -4285,7 +4285,7 @@ bool BaseGame::updateMusicCrossfade() {
 		_music[_musicCrossfadeChannel2]->play();
 	}
 
-	uint32 currentTime = _gameRef->getLiveTimer()->getTime() - _musicCrossfadeStartTime;
+	uint32 currentTime = _game->getLiveTimer()->getTime() - _musicCrossfadeStartTime;
 
 	if (currentTime >= _musicCrossfadeLength) {
 		_musicCrossfadeRunning = false;
@@ -4445,10 +4445,10 @@ bool BaseGame::focusWindow(UIWindow *window) {
 				_windows.removeAt(i);
 				_windows.add(window);
 
-				_gameRef->_focusedWindow = window;
+				_game->_focusedWindow = window;
 			}
 
-			if (window->_mode == WINDOW_NORMAL && prev != window && _gameRef->validObject(prev) && (prev->_mode == WINDOW_EXCLUSIVE || prev->_mode == WINDOW_SYSTEM_EXCLUSIVE)) {
+			if (window->_mode == WINDOW_NORMAL && prev != window && _game->validObject(prev) && (prev->_mode == WINDOW_EXCLUSIVE || prev->_mode == WINDOW_SYSTEM_EXCLUSIVE)) {
 				return focusWindow(prev);
 			} else {
 				return STATUS_OK;
@@ -4512,10 +4512,10 @@ bool BaseGame::handleKeypress(Common::Event *event, bool printable) {
 // TODO
 
 	if (_focusedWindow) {
-		if (!_gameRef->_focusedWindow->handleKeypress(event, _keyboardState->isCurrentPrintable())) {
+		if (!_game->_focusedWindow->handleKeypress(event, _keyboardState->isCurrentPrintable())) {
 			/*if (event->type != SDL_TEXTINPUT) {*/
-			if (_gameRef->_focusedWindow->canHandleEvent("Keypress")) {
-				_gameRef->_focusedWindow->applyEvent("Keypress");
+			if (_game->_focusedWindow->canHandleEvent("Keypress")) {
+				_game->_focusedWindow->applyEvent("Keypress");
 			} else {
 				applyEvent("Keypress");
 			}
@@ -4539,14 +4539,14 @@ void BaseGame::handleKeyRelease(Common::Event *event) {
 bool BaseGame::handleMouseWheel(int32 delta) {
 	bool handled = false;
 	if (_focusedWindow) {
-		handled = _gameRef->_focusedWindow->handleMouseWheel(delta);
+		handled = _game->_focusedWindow->handleMouseWheel(delta);
 
 		if (!handled) {
-			if (delta < 0 && _gameRef->_focusedWindow->canHandleEvent("MouseWheelDown")) {
-				_gameRef->_focusedWindow->applyEvent("MouseWheelDown");
+			if (delta < 0 && _game->_focusedWindow->canHandleEvent("MouseWheelDown")) {
+				_game->_focusedWindow->applyEvent("MouseWheelDown");
 				handled = true;
-			} else if (_gameRef->_focusedWindow->canHandleEvent("MouseWheelUp")) {
-				_gameRef->_focusedWindow->applyEvent("MouseWheelUp");
+			} else if (_game->_focusedWindow->canHandleEvent("MouseWheelUp")) {
+				_game->_focusedWindow->applyEvent("MouseWheelUp");
 				handled = true;
 			}
 
@@ -4622,7 +4622,7 @@ void BaseGame::setWindowTitle() {
 //////////////////////////////////////////////////////////////////////////
 bool BaseGame::setActiveObject(BaseObject *obj) {
 	// not-active when game is frozen
-	if (obj && !_gameRef->_interactive && !obj->_nonIntMouseEvents) {
+	if (obj && !_game->_interactive && !obj->_nonIntMouseEvents) {
 		obj = nullptr;
 	}
 
@@ -4662,7 +4662,7 @@ bool BaseGame::pushViewport(BaseViewport *viewport) {
 bool BaseGame::popViewport() {
 	_viewportSP--;
 	if (_viewportSP < -1) {
-		_gameRef->LOG(0, "Fatal: Viewport stack underflow!");
+		_game->LOG(0, "Fatal: Viewport stack underflow!");
 	}
 
 	if (_viewportSP >= 0 && _viewportSP < _viewportStack.getSize()) {
@@ -4790,7 +4790,7 @@ void BaseGame::DEBUG_DumpClassRegistry() {
 
 	f->close();
 	delete f;
-	_gameRef->quickMessage("Classes dump completed.");
+	_game->quickMessage("Classes dump completed.");
 }
 
 
@@ -4816,7 +4816,7 @@ bool BaseGame::setWaitCursor(const char *filename) {
 	delete _cursorNoninteractive;
 	_cursorNoninteractive = nullptr;
 
-	_cursorNoninteractive = new BaseSprite(_gameRef);
+	_cursorNoninteractive = new BaseSprite(_game);
 	if (!_cursorNoninteractive || DID_FAIL(_cursorNoninteractive->loadFile(filename))) {
 		SAFE_DELETE(_cursorNoninteractive);
 		return STATUS_FAILED;
@@ -5063,7 +5063,7 @@ bool BaseGame::onPaint() {
 bool BaseGame::onWindowClose() {
 	if (canHandleEvent("QuitGame")) {
 		if (_state != GAME_FROZEN) {
-			_gameRef->applyEvent("QuitGame");
+			_game->applyEvent("QuitGame");
 		}
 		return STATUS_OK;
 	} else {
@@ -5077,12 +5077,12 @@ bool BaseGame::displayDebugInfo() {
 	char str[strLength];
 
 	if (_debugShowFPS) {
-		Common::sprintf_s(str, "FPS: %d", _gameRef->_fps);
+		Common::sprintf_s(str, "FPS: %d", _game->_fps);
 		_systemFont->drawText((byte *)str, 0, 0, 100, TAL_LEFT);
 	}
 
-	if (_gameRef->_debugDebugMode) {
-		if (!_gameRef->_renderer->isWindowed()) {
+	if (_game->_debugDebugMode) {
+		if (!_game->_renderer->isWindowed()) {
 			Common::sprintf_s(str, "Mode: %dx%dx%d", _renderer->getWidth(), _renderer->getHeight(), _renderer->getBPP());
 		} else {
 			Common::sprintf_s(str, "Mode: %dx%d windowed", _renderer->getWidth(), _renderer->getHeight());
@@ -5102,7 +5102,7 @@ bool BaseGame::displayDebugInfo() {
 
 
 		Common::sprintf_s(str, "Timer: %d", getTimer()->getTime());
-		_gameRef->_systemFont->drawText((byte *)str, 0, 130, _renderer->getWidth(), TAL_RIGHT);
+		_game->_systemFont->drawText((byte *)str, 0, 130, _renderer->getWidth(), TAL_RIGHT);
 
 		if (_activeObject != nullptr) {
 			_systemFont->drawText((const byte *)_activeObject->_name, 0, 150, _renderer->getWidth(), TAL_RIGHT);
@@ -5178,9 +5178,9 @@ void BaseGame::getMousePos(Common::Point32 *pos) {
 	if (_renderer->_windowed && ::IsZoomed(_renderer->_window)) {
 	    Common::Rect rc;
 	    ::GetClientRect(_renderer->_window, &rc);
-	    Pos->x *= _gameRef->_renderer->_realWidth;
+	    Pos->x *= _game->_renderer->_realWidth;
 	    Pos->x /= (rc.right - rc.left);
-	    Pos->y *= _gameRef->_renderer->_realHeight;
+	    Pos->y *= _game->_renderer->_realHeight;
 	    Pos->y /= (rc.bottom - rc.top);
 	}
 	*/
diff --git a/engines/wintermute/base/base_object.cpp b/engines/wintermute/base/base_object.cpp
index e3d4272830d..656db26245d 100644
--- a/engines/wintermute/base/base_object.cpp
+++ b/engines/wintermute/base/base_object.cpp
@@ -72,7 +72,7 @@ BaseObject::BaseObject(BaseGame *inGame) : BaseScriptHolder(inGame) {
 
 	_soundEvent = nullptr;
 
-	_iD = _gameRef->getSequence();
+	_iD = _game->getSequence();
 
 	BasePlatform::setRectEmpty(&_rect);
 	_rectSet = false;
@@ -135,8 +135,8 @@ BaseObject::~BaseObject() {
 
 //////////////////////////////////////////////////////////////////////////
 bool BaseObject::cleanup() {
-	if (_gameRef && _gameRef->_activeObject == this) {
-		_gameRef->_activeObject = nullptr;
+	if (_game && _game->_activeObject == this) {
+		_game->_activeObject = nullptr;
 	}
 
 	BaseScriptHolder::cleanup();
@@ -157,7 +157,7 @@ bool BaseObject::cleanup() {
 	SAFE_DELETE(_shadowModel);
 
 	if (_shadowImage) {
-		_gameRef->_surfaceStorage->removeSurface(_shadowImage);
+		_game->_surfaceStorage->removeSurface(_shadowImage);
 		_shadowImage = nullptr;
 	}
 #endif
@@ -182,7 +182,7 @@ void BaseObject::setCaption(const char *caption, int caseVal) {
 	size_t captionSize = strlen(caption) + 1;
 	_caption[caseVal - 1] = new char[captionSize];
 	Common::strcpy_s(_caption[caseVal - 1], captionSize, caption);
-	_gameRef->expandStringByStringTable(&_caption[caseVal - 1]);
+	_game->expandStringByStringTable(&_caption[caseVal - 1]);
 }
 
 
@@ -517,12 +517,12 @@ bool BaseObject::scCallMethod(ScScript *script, ScStack *stack, ScStack *thisSta
 		ScValue *val = stack->pop();
 
 		if (_shadowImage) {
-			_gameRef->_surfaceStorage->removeSurface(_shadowImage);
+			_game->_surfaceStorage->removeSurface(_shadowImage);
 			_shadowImage = nullptr;
 		}
 
 		if (val->isString()) {
-			_shadowImage = _gameRef->_surfaceStorage->addSurface(val->getString());
+			_shadowImage = _game->_surfaceStorage->addSurface(val->getString());
 			stack->pushBool(_shadowImage != nullptr);
 		} else {
 			stack->pushBool(true);
@@ -1043,7 +1043,7 @@ const char *BaseObject::scToString() {
 //////////////////////////////////////////////////////////////////////////
 bool BaseObject::showCursor() {
 	if (_cursor) {
-		return _gameRef->drawCursor(_cursor);
+		return _game->drawCursor(_cursor);
 	} else {
 		return STATUS_FAILED;
 	}
@@ -1130,7 +1130,7 @@ bool BaseObject::persist(BasePersistenceManager *persistMgr) {
 			if (persistMgr->checkVersion(1, 6, 1)) {
 				persistMgr->transferString(TMEMBER(tempString));
 				if (!tempString.empty()) {
-					_shadowImage = _gameRef->_surfaceStorage->addSurface(tempString);
+					_shadowImage = _game->_surfaceStorage->addSurface(tempString);
 				}
 			}
 		}
@@ -1154,7 +1154,7 @@ bool BaseObject::setCursor(const char *filename) {
 	}
 
 	_sharedCursors = false;
-	_cursor = new BaseSprite(_gameRef);
+	_cursor = new BaseSprite(_game);
 	if (!_cursor || DID_FAIL(_cursor->loadFile(filename))) {
 		SAFE_DELETE(_cursor);
 		return STATUS_FAILED;
@@ -1167,7 +1167,7 @@ bool BaseObject::setCursor(const char *filename) {
 //////////////////////////////////////////////////////////////////////////
 bool BaseObject::setActiveCursor(const char *filename) {
 	SAFE_DELETE(_activeCursor);
-	_activeCursor = new BaseSprite(_gameRef);
+	_activeCursor = new BaseSprite(_game);
 	if (!_activeCursor || DID_FAIL(_activeCursor->loadFile(filename))) {
 		SAFE_DELETE(_activeCursor);
 		return STATUS_FAILED;
@@ -1205,10 +1205,10 @@ bool BaseObject::handleMouseWheel(int32 delta) {
 bool BaseObject::playSFX(const char *filename, bool looping, bool playNow, const char *eventName, uint32 loopStart) {
 	// just play loaded sound
 	if (filename == nullptr && _sFX) {
-		if (_gameRef->_editorMode || _sFXStart) {
+		if (_game->_editorMode || _sFXStart) {
 			_sFX->setVolumePercent(_sFXVolume);
 			_sFX->setPositionTime(_sFXStart);
-			if (!_gameRef->_editorMode) {
+			if (!_game->_editorMode) {
 				_sFXStart = 0;
 			}
 		}
@@ -1230,7 +1230,7 @@ bool BaseObject::playSFX(const char *filename, bool looping, bool playNow, const
 	// create new sound
 	delete _sFX;
 
-	_sFX = new BaseSound(_gameRef);
+	_sFX = new BaseSound(_game);
 	if (_sFX && DID_SUCCEED(_sFX->setSound(filename, Audio::Mixer::kSFXSoundType, true))) {
 		_sFX->setVolumePercent(_sFXVolume);
 		if (_sFXStart) {
@@ -1332,7 +1332,7 @@ bool BaseObject::updateOneSound(BaseSound *sound) {
 
 	if (sound) {
 		if (_autoSoundPanning) {
-			ret = sound->setPan(_gameRef->_soundMgr->posToPan(_posX  - _gameRef->_offsetX, _posY - _gameRef->_offsetY));
+			ret = sound->setPan(_game->_soundMgr->posToPan(_posX  - _game->_offsetX, _posY - _game->_offsetY));
 		}
 
 		ret = sound->applyFX(_sFXType, _sFXParam1, _sFXParam2, _sFXParam3, _sFXParam4);
@@ -1399,7 +1399,7 @@ bool BaseObject::renderModel() {
 	DXMatrix objectMat;
 	getMatrix(&objectMat);
 
-	_gameRef->_renderer3D->setWorldTransform(objectMat);
+	_game->_renderer3D->setWorldTransform(objectMat);
 
 	if (_xmodel)
 		return _xmodel->render();
diff --git a/engines/wintermute/base/base_script_holder.cpp b/engines/wintermute/base/base_script_holder.cpp
index 16c62a05bae..3da2b7c0529 100644
--- a/engines/wintermute/base/base_script_holder.cpp
+++ b/engines/wintermute/base/base_script_holder.cpp
@@ -98,7 +98,7 @@ bool BaseScriptHolder::applyEvent(const char *eventName, bool unbreakable) {
 		}
 	}
 	if (numHandlers > 0 && unbreakable) {
-		_gameRef->_scEngine->tickUnbreakable();
+		_game->_scEngine->tickUnbreakable();
 	}
 
 	return ret;
@@ -306,14 +306,14 @@ bool BaseScriptHolder::addScript(const char *filename) {
 		}
 	}
 
-	ScScript *scr =  _gameRef->_scEngine->runScript(filename, this);
+	ScScript *scr =  _game->_scEngine->runScript(filename, this);
 	if (!scr) {
-		if (_gameRef->_editorForceScripts) {
+		if (_game->_editorForceScripts) {
 			// editor hack
 #if EXTENDED_DEBUGGER_ENABLED
-			scr = new DebuggableScript(_gameRef, _gameRef->_scEngine);
+			scr = new DebuggableScript(_game, _game->_scEngine);
 #else
-			scr = new ScScript(_gameRef, _gameRef->_scEngine);
+			scr = new ScScript(_game, _game->_scEngine);
 #endif
 			size_t filenameSize = strlen(filename) + 1;
 			scr->_filename = new char[filenameSize];
@@ -321,7 +321,7 @@ bool BaseScriptHolder::addScript(const char *filename) {
 			scr->_state = SCRIPT_ERROR;
 			scr->_owner = this;
 			_scripts.add(scr);
-			_gameRef->_scEngine->_scripts.add(scr);
+			_game->_scEngine->_scripts.add(scr);
 
 			return STATUS_OK;
 		}
@@ -430,7 +430,7 @@ bool BaseScriptHolder::parseProperty(char *buffer, bool complete) {
 	}
 
 
-	ScValue *val = new ScValue(_gameRef);
+	ScValue *val = new ScValue(_game);
 	val->setString(propValue);
 	scSetProperty(propName, val);
 
@@ -461,9 +461,9 @@ ScScript *BaseScriptHolder::invokeMethodThread(const char *methodName) {
 			debuggableEngine = dynamic_cast<DebuggableScEngine*>(_scripts[i]->_engine);
 			// TODO: Not pretty
 			assert(debuggableEngine);
-			ScScript *thread = new DebuggableScript(_gameRef,  debuggableEngine);
+			ScScript *thread = new DebuggableScript(_game,  debuggableEngine);
 #else
-			ScScript *thread = new ScScript(_gameRef,  _scripts[i]->_engine);
+			ScScript *thread = new ScScript(_game,  _scripts[i]->_engine);
 #endif
 			if (thread) {
 				bool ret = thread->createMethodThread(_scripts[i], methodName);
diff --git a/engines/wintermute/base/base_scriptable.cpp b/engines/wintermute/base/base_scriptable.cpp
index 101dbaa4231..e0d28e3ccbd 100644
--- a/engines/wintermute/base/base_scriptable.cpp
+++ b/engines/wintermute/base/base_scriptable.cpp
@@ -41,7 +41,7 @@ BaseScriptable::BaseScriptable(BaseGame *inGame, bool noValue, bool persistable)
 	if (noValue) {
 		_scValue = nullptr;
 	} else {
-		_scValue = new ScValue(_gameRef);
+		_scValue = new ScValue(_game);
 	}
 
 	_persistable = persistable;
@@ -76,7 +76,7 @@ bool BaseScriptable::scCallMethod(ScScript *script, ScStack *stack, ScStack *thi
 //////////////////////////////////////////////////////////////////////////
 ScValue *BaseScriptable::scGetProperty(const Common::String &name) {
 	if (!_scProp) {
-		_scProp = new ScValue(_gameRef);
+		_scProp = new ScValue(_game);
 	}
 	if (_scProp) {
 		return _scProp->getProp(name.c_str()); // TODO: Change to Common::String
@@ -89,7 +89,7 @@ ScValue *BaseScriptable::scGetProperty(const Common::String &name) {
 //////////////////////////////////////////////////////////////////////////
 bool BaseScriptable::scSetProperty(const char *name, ScValue *value) {
 	if (!_scProp) {
-		_scProp = new ScValue(_gameRef);
+		_scProp = new ScValue(_game);
 	}
 	if (_scProp) {
 		return _scProp->setProp(name, value);
@@ -150,7 +150,7 @@ void BaseScriptable::scSetBool(bool val) {
 
 //////////////////////////////////////////////////////////////////////////
 bool BaseScriptable::persist(BasePersistenceManager *persistMgr) {
-	persistMgr->transferPtr(TMEMBER_PTR(_gameRef));
+	persistMgr->transferPtr(TMEMBER_PTR(_game));
 	persistMgr->transferSint32(TMEMBER(_refCount));
 	persistMgr->transferPtr(TMEMBER_PTR(_scProp));
 	persistMgr->transferPtr(TMEMBER_PTR(_scValue));
diff --git a/engines/wintermute/base/base_sprite.cpp b/engines/wintermute/base/base_sprite.cpp
index 0afbe1c3c0f..b63b4fd662f 100644
--- a/engines/wintermute/base/base_sprite.cpp
+++ b/engines/wintermute/base/base_sprite.cpp
@@ -126,7 +126,7 @@ bool BaseSprite::draw(int x, int y, BaseObject *registerOwner, float zoomX, floa
 bool BaseSprite::loadFile(const Common::String &filename, int lifeTime, TSpriteCacheType cacheType) {
 	if (!BaseFileManager::getEngineInstance()->hasFile(filename)) {
 		BaseEngine::LOG(0, "BaseSprite::LoadFile failed for file '%s'", filename.c_str());
-		if (_gameRef->_debugDebugMode) {
+		if (_game->_debugDebugMode) {
 			return loadFile("invalid_debug.bmp", lifeTime, cacheType);
 		} else {
 			return loadFile("invalid.bmp", lifeTime, cacheType);
@@ -140,8 +140,8 @@ bool BaseSprite::loadFile(const Common::String &filename, int lifeTime, TSpriteC
 	ext.toLowercase();
 	filePrefix.toLowercase();
 	if (filePrefix.hasPrefix("savegame:") || (ext == "bmp") || (ext == "tga") || (ext == "png") || (ext == "jpg")) {
-		BaseFrame *frame = new BaseFrame(_gameRef);
-		BaseSubFrame *subframe = new BaseSubFrame(_gameRef);
+		BaseFrame *frame = new BaseFrame(_game);
+		BaseSubFrame *subframe = new BaseSubFrame(_game);
 		subframe->setSurface(filename, true, 0, 0, 0, lifeTime, true);
 		if (subframe->_surface == nullptr) {
 			BaseEngine::LOG(0, "Error loading simple sprite '%s'", filename.c_str());
@@ -267,7 +267,7 @@ bool BaseSprite::loadBuffer(char *buffer, bool complete, int lifeTime, TSpriteCa
 			break;
 
 		case TOKEN_EDITOR_BG_FILE:
-			if (_gameRef->_editorMode) {
+			if (_game->_editorMode) {
 				SAFE_DELETE_ARRAY(_editorBgFile);
 				size_t editorBgFileSize = strlen(params) + 1;
 				_editorBgFile = new char[editorBgFileSize];
@@ -295,7 +295,7 @@ bool BaseSprite::loadBuffer(char *buffer, bool complete, int lifeTime, TSpriteCa
 				frameLifeTime = -1;
 			}
 
-			frame = new BaseFrame(_gameRef);
+			frame = new BaseFrame(_game);
 
 			if (DID_FAIL(frame->loadBuffer(params, frameLifeTime, _streamedKeepLoaded))) {
 				delete frame;
@@ -356,7 +356,7 @@ void BaseSprite::reset() {
 
 //////////////////////////////////////////////////////////////////////
 bool BaseSprite::getCurrentFrame(float zoomX, float zoomY) {
-	//if (_owner && _owner->_freezable && _gameRef->_state == GAME_FROZEN) return true;
+	//if (_owner && _owner->_freezable && _game->_state == GAME_FROZEN) return true;
 
 	if (_currentFrame == -1) {
 		return false;
@@ -364,9 +364,9 @@ bool BaseSprite::getCurrentFrame(float zoomX, float zoomY) {
 
 	uint32 timer;
 	if (_owner && _owner->_freezable) {
-		timer = _gameRef->getTimer()->getTime();
+		timer = _game->getTimer()->getTime();
 	} else {
-		timer = _gameRef->getLiveTimer()->getTime();
+		timer = _game->getLiveTimer()->getTime();
 	}
 
 	int lastFrame = _currentFrame;
@@ -427,11 +427,11 @@ bool BaseSprite::display(int x, int y, BaseObject *registerVal, float zoomX, flo
 			killAllSounds();
 		}
 		applyEvent("FrameChanged");
-		_frames[_currentFrame]->oneTimeDisplay(_owner, _gameRef->_editorMode && _editorMuted);
+		_frames[_currentFrame]->oneTimeDisplay(_owner, _game->_editorMode && _editorMuted);
 	}
 
 	// draw frame
-	return _frames[_currentFrame]->draw(x - _gameRef->_offsetX, y - _gameRef->_offsetY, registerVal, zoomX, zoomY, _precise, alpha, _editorAllFrames, rotate, blendMode);
+	return _frames[_currentFrame]->draw(x - _game->_offsetX, y - _game->_offsetY, registerVal, zoomX, zoomY, _precise, alpha, _editorAllFrames, rotate, blendMode);
 }
 
 
@@ -615,9 +615,9 @@ bool BaseSprite::scCallMethod(ScScript *script, ScStack *stack, ScStack *thisSta
 			filename = val->getString();
 		}
 
-		BaseFrame *frame = new BaseFrame(_gameRef);
+		BaseFrame *frame = new BaseFrame(_game);
 		if (filename != nullptr) {
-			BaseSubFrame *sub = new BaseSubFrame(_gameRef);
+			BaseSubFrame *sub = new BaseSubFrame(_game);
 			if (DID_SUCCEED(sub->setSurface(filename))) {
 				sub->setDefaultRect();
 				frame->_subframes.add(sub);
@@ -647,9 +647,9 @@ bool BaseSprite::scCallMethod(ScScript *script, ScStack *stack, ScStack *thisSta
 			filename = val->getString();
 		}
 
-		BaseFrame *frame = new BaseFrame(_gameRef);
+		BaseFrame *frame = new BaseFrame(_game);
 		if (filename != nullptr) {
-			BaseSubFrame *sub = new BaseSubFrame(_gameRef);
+			BaseSubFrame *sub = new BaseSubFrame(_game);
 			if (DID_SUCCEED(sub->setSurface(filename))) {
 				frame->_subframes.add(sub);
 			} else {
diff --git a/engines/wintermute/base/base_string_table.cpp b/engines/wintermute/base/base_string_table.cpp
index c8918c87562..03a2c3c2684 100644
--- a/engines/wintermute/base/base_string_table.cpp
+++ b/engines/wintermute/base/base_string_table.cpp
@@ -53,7 +53,7 @@ bool BaseStringTable::addString(const char *key, const char *val, bool reportDup
 	}
 
 	if (scumm_stricmp(key, "@right-to-left") == 0) {
-		_gameRef->_textRTL = true;
+		_game->_textRTL = true;
 		return STATUS_OK;
 	}
 
@@ -240,13 +240,13 @@ bool BaseStringTable::loadFile(const char *filename, bool clearOld) {
 
 	if (size > 3 && buffer[0] == '\xEF' && buffer[1] == '\xBB' && buffer[2] == '\xBF') {
 		pos += 3;
-		if (_gameRef->_textEncoding != TEXT_UTF8) {
-			_gameRef->_textEncoding = TEXT_UTF8;
-			//_gameRef->_textEncoding = TEXT_ANSI;
+		if (_game->_textEncoding != TEXT_UTF8) {
+			_game->_textEncoding = TEXT_UTF8;
+			//_game->_textEncoding = TEXT_ANSI;
 			BaseEngine::LOG(0, "  UTF8 file detected, switching to UTF8 text encoding");
 		}
 	} else {
-		_gameRef->_textEncoding = TEXT_ANSI;
+		_game->_textEncoding = TEXT_ANSI;
 	}
 
 	uint32 lineLength = 0;
diff --git a/engines/wintermute/base/base_sub_frame.cpp b/engines/wintermute/base/base_sub_frame.cpp
index ca4b33156e6..ec8644faae2 100644
--- a/engines/wintermute/base/base_sub_frame.cpp
+++ b/engines/wintermute/base/base_sub_frame.cpp
@@ -72,7 +72,7 @@ BaseSubFrame::BaseSubFrame(BaseGame *inGame) : BaseScriptable(inGame, true) {
 //////////////////////////////////////////////////////////////////////////
 BaseSubFrame::~BaseSubFrame() {
 	if (_surface) {
-		_gameRef->_surfaceStorage->removeSurface(_surface);
+		_game->_surfaceStorage->removeSurface(_surface);
 	}
 	SAFE_DELETE_ARRAY(_surfaceFilename);
 }
@@ -247,12 +247,12 @@ bool BaseSubFrame::draw(int x, int y, BaseObject *registerOwner, float zoomX, fl
 
 	if (registerOwner != nullptr && !_decoration) {
 		if (zoomX == Graphics::kDefaultZoomX && zoomY == Graphics::kDefaultZoomY) {
-			BaseEngine::getRenderer()->_rectList.add(new BaseActiveRect(_gameRef,  registerOwner, this, x - _hotspotX + getRect().left, y  - _hotspotY + getRect().top, getRect().right - getRect().left, getRect().bottom - getRect().top, zoomX, zoomY, precise));
+			BaseEngine::getRenderer()->_rectList.add(new BaseActiveRect(_game,  registerOwner, this, x - _hotspotX + getRect().left, y  - _hotspotY + getRect().top, getRect().right - getRect().left, getRect().bottom - getRect().top, zoomX, zoomY, precise));
 		} else {
-			BaseEngine::getRenderer()->_rectList.add(new BaseActiveRect(_gameRef,  registerOwner, this, (int)(x - (_hotspotX + getRect().left) * (zoomX / 100)), (int)(y - (_hotspotY + getRect().top) * (zoomY / 100)), (int)((getRect().right - getRect().left) * (zoomX / 100)), (int)((getRect().bottom - getRect().top) * (zoomY / 100)), zoomX, zoomY, precise));
+			BaseEngine::getRenderer()->_rectList.add(new BaseActiveRect(_game,  registerOwner, this, (int)(x - (_hotspotX + getRect().left) * (zoomX / 100)), (int)(y - (_hotspotY + getRect().top) * (zoomY / 100)), (int)((getRect().right - getRect().left) * (zoomX / 100)), (int)((getRect().bottom - getRect().top) * (zoomY / 100)), zoomX, zoomY, precise));
 		}
 	}
-	if (_gameRef->_suspendedRendering) {
+	if (_game->_suspendedRendering) {
 		return STATUS_OK;
 	}
 
@@ -493,7 +493,7 @@ bool BaseSubFrame::scCallMethod(ScScript *script, ScStack *stack, ScStack *thisS
 
 		if (val->isNULL()) {
 			if (_surface) {
-				_gameRef->_surfaceStorage->removeSurface(_surface);
+				_game->_surfaceStorage->removeSurface(_surface);
 			}
 			SAFE_DELETE_ARRAY(_surfaceFilename);
 			stack->pushBool(true);
@@ -517,7 +517,7 @@ bool BaseSubFrame::scCallMethod(ScScript *script, ScStack *stack, ScStack *thisS
 //////////////////////////////////////////////////////////////////////////
 ScValue *BaseSubFrame::scGetProperty(const Common::String &name) {
 	if (!_scValue) {
-		_scValue = new ScValue(_gameRef);
+		_scValue = new ScValue(_game);
 	}
 	_scValue->setNULL();
 
@@ -685,13 +685,13 @@ const char *BaseSubFrame::scToString() {
 //////////////////////////////////////////////////////////////////////////
 bool BaseSubFrame::setSurface(const Common::String &filename, bool defaultCK, byte ckRed, byte ckGreen, byte ckBlue, int lifeTime, bool keepLoaded) {
 	if (_surface) {
-		_gameRef->_surfaceStorage->removeSurface(_surface);
+		_game->_surfaceStorage->removeSurface(_surface);
 		_surface = nullptr;
 	}
 
 	SAFE_DELETE_ARRAY(_surfaceFilename);
 
-	_surface = _gameRef->_surfaceStorage->addSurface(filename, defaultCK, ckRed, ckGreen, ckBlue, lifeTime, keepLoaded);
+	_surface = _game->_surfaceStorage->addSurface(filename, defaultCK, ckRed, ckGreen, ckBlue, lifeTime, keepLoaded);
 	if (_surface) {
 		_surfaceFilename = new char[filename.size() + 1];
 		Common::strcpy_s(_surfaceFilename, filename.size() + 1, filename.c_str());
@@ -716,7 +716,7 @@ bool BaseSubFrame::setSurfaceSimple() {
 		_surface = nullptr;
 		return STATUS_OK;
 	}
-	_surface = _gameRef->_surfaceStorage->addSurface(_surfaceFilename, _cKDefault, _cKRed, _cKGreen, _cKBlue, _lifeTime, _keepLoaded);
+	_surface = _game->_surfaceStorage->addSurface(_surfaceFilename, _cKDefault, _cKRed, _cKGreen, _cKBlue, _lifeTime, _keepLoaded);
 	if (_surface) {
 		return STATUS_OK;
 	} else {
diff --git a/engines/wintermute/base/base_surface_storage.cpp b/engines/wintermute/base/base_surface_storage.cpp
index 3ce51f12940..41ee90f447f 100644
--- a/engines/wintermute/base/base_surface_storage.cpp
+++ b/engines/wintermute/base/base_surface_storage.cpp
@@ -67,16 +67,16 @@ bool BaseSurfaceStorage::cleanup(bool warn) {
 
 //////////////////////////////////////////////////////////////////////////
 bool BaseSurfaceStorage::initLoop() {
-	if (_gameRef->_smartCache && _gameRef->getLiveTimer()->getTime() - _lastCleanupTime >= _gameRef->_surfaceGCCycleTime) {
-		_lastCleanupTime = _gameRef->getLiveTimer()->getTime();
+	if (_game->_smartCache && _game->getLiveTimer()->getTime() - _lastCleanupTime >= _game->_surfaceGCCycleTime) {
+		_lastCleanupTime = _game->getLiveTimer()->getTime();
 		sortSurfaces();
 		for (int32 i = 0; i < _surfaces.getSize(); i++) {
 			if (_surfaces[i]->_lifeTime <= 0) {
 				break;
 			}
 
-			if (_surfaces[i]->_lifeTime > 0 && _surfaces[i]->_valid && (int)(_gameRef->getLiveTimer()->getTime() - _surfaces[i]->_lastUsedTime) >= _surfaces[i]->_lifeTime) {
-				//_gameRef->QuickMessageForm("Invalidating: %s", _surfaces[i]->_filename);
+			if (_surfaces[i]->_lifeTime > 0 && _surfaces[i]->_valid && (int)(_game->getLiveTimer()->getTime() - _surfaces[i]->_lastUsedTime) >= _surfaces[i]->_lifeTime) {
+				//_game->QuickMessageForm("Invalidating: %s", _surfaces[i]->_filename);
 				_surfaces[i]->invalidate();
 			}
 		}
@@ -114,7 +114,7 @@ BaseSurface *BaseSurfaceStorage::addSurface(const Common::String &filename, bool
 		if (filename.size()) {
 			BaseEngine::LOG(0, "Missing image: '%s'", filename.c_str());
 		}
-		if (_gameRef->_debugDebugMode) {
+		if (_game->_debugDebugMode) {
 			return addSurface("invalid_debug.bmp", defaultCK, ckRed, ckGreen, ckBlue, lifeTime, keepLoaded);
 		} else {
 			return addSurface("invalid.bmp", defaultCK, ckRed, ckGreen, ckBlue, lifeTime, keepLoaded);
@@ -160,7 +160,7 @@ bool BaseSurfaceStorage::persist(BasePersistenceManager *persistMgr)
 
 	if (!persistMgr->getIsSaving()) cleanup(false);
 
-	persistMgr->transfer(TMEMBER(_gameRef));
+	persistMgr->transfer(TMEMBER(_game));
 
 	//_surfaces.persist(persistMgr);
 
diff --git a/engines/wintermute/base/base_transition_manager.cpp b/engines/wintermute/base/base_transition_manager.cpp
index b4636fccd78..2ab89cb53a4 100644
--- a/engines/wintermute/base/base_transition_manager.cpp
+++ b/engines/wintermute/base/base_transition_manager.cpp
@@ -69,8 +69,8 @@ bool BaseTransitionMgr::start(TTransitionType type, bool nonInteractive) {
 
 	if (nonInteractive) {
 		_preserveInteractive = true;
-		_origInteractive = _gameRef->_interactive;
-		_gameRef->_interactive = false;
+		_origInteractive = _game->_interactive;
+		_game->_interactive = false;
 	} /*else _preserveInteractive */;
 
 
@@ -128,7 +128,7 @@ bool BaseTransitionMgr::update() {
 
 	if (isReady()) {
 		if (_preserveInteractive) {
-			_gameRef->_interactive = _origInteractive;
+			_game->_interactive = _origInteractive;
 		}
 	}
 	return STATUS_OK;
diff --git a/engines/wintermute/base/base_viewport.cpp b/engines/wintermute/base/base_viewport.cpp
index 90dacdcb68b..61da3e1352a 100644
--- a/engines/wintermute/base/base_viewport.cpp
+++ b/engines/wintermute/base/base_viewport.cpp
@@ -52,7 +52,7 @@ BaseViewport::~BaseViewport() {
 //////////////////////////////////////////////////////////////////////////
 bool BaseViewport::persist(BasePersistenceManager *persistMgr) {
 
-	persistMgr->transferPtr(TMEMBER_PTR(_gameRef));
+	persistMgr->transferPtr(TMEMBER_PTR(_game));
 
 	persistMgr->transferPtr(TMEMBER_PTR(_mainObject));
 	persistMgr->transferSint32(TMEMBER(_offsetX));
diff --git a/engines/wintermute/base/font/base_font_bitmap.cpp b/engines/wintermute/base/font/base_font_bitmap.cpp
index a2e8f3734dd..9731dd000f2 100644
--- a/engines/wintermute/base/font/base_font_bitmap.cpp
+++ b/engines/wintermute/base/font/base_font_bitmap.cpp
@@ -84,7 +84,7 @@ int BaseFontBitmap::getTextHeight(const byte *text, int width) {
 int BaseFontBitmap::getTextWidth(const byte *text, int maxLength) {
 	AnsiString str;
 
-	if (_gameRef->_textEncoding == TEXT_UTF8) {
+	if (_game->_textEncoding == TEXT_UTF8) {
 		WideString wstr = StringUtil::utf8ToWide(Utf8String((const char *)text));
 		str = StringUtil::wideToAnsi(wstr);
 	} else {
@@ -117,7 +117,7 @@ int BaseFontBitmap::textHeightDraw(const byte *text, int x, int y, int width, TT
 
 	AnsiString str;
 
-	if (_gameRef->_textEncoding == TEXT_UTF8) {
+	if (_game->_textEncoding == TEXT_UTF8) {
 		WideString wstr = StringUtil::utf8ToWide(Utf8String((const char *)text));
 		str = StringUtil::wideToAnsi(wstr);
 	} else {
@@ -146,13 +146,13 @@ int BaseFontBitmap::textHeightDraw(const byte *text, int x, int y, int width, TT
 #endif
 
 	if (draw) {
-		_gameRef->_renderer->startSpriteBatch();
+		_game->_renderer->startSpriteBatch();
 	}
 
 	while (!done) {
 		if (maxHeight > 0 && (numLines + 1)*_tileHeight > maxHeight) {
 			if (draw) {
-				_gameRef->_renderer->endSpriteBatch();
+				_game->_renderer->endSpriteBatch();
 			}
 			return numLines * _tileHeight;
 		}
@@ -233,7 +233,7 @@ int BaseFontBitmap::textHeightDraw(const byte *text, int x, int y, int width, TT
 	}
 
 	if (draw) {
-		_gameRef->_renderer->endSpriteBatch();
+		_game->_renderer->endSpriteBatch();
 	}
 
 	return numLines * _tileHeight;
@@ -281,7 +281,7 @@ void BaseFontBitmap::drawChar(byte c, int x, int y) {
 bool BaseFontBitmap::loadFile(const Common::String &filename) {
 	char *buffer = (char *)BaseFileManager::getEngineInstance()->readWholeFile(filename);
 	if (buffer == nullptr) {
-		_gameRef->LOG(0, "BaseFontBitmap::LoadFile failed for file '%s'", filename.c_str());
+		_game->LOG(0, "BaseFontBitmap::LoadFile failed for file '%s'", filename.c_str());
 		return STATUS_FAILED;
 	}
 
@@ -290,7 +290,7 @@ bool BaseFontBitmap::loadFile(const Common::String &filename) {
 	setFilename(filename.c_str());
 
 	if (DID_FAIL(ret = loadBuffer(buffer))) {
-		_gameRef->LOG(0, "Error parsing FONT file '%s'", filename.c_str());
+		_game->LOG(0, "Error parsing FONT file '%s'", filename.c_str());
 	}
 
 	delete[] buffer;
@@ -349,7 +349,7 @@ bool BaseFontBitmap::loadBuffer(char *buffer) {
 	BaseParser parser;
 
 	if (parser.getCommand(&buffer, commands, &params) != TOKEN_FONT) {
-		_gameRef->LOG(0, "'FONT' keyword expected.");
+		_game->LOG(0, "'FONT' keyword expected.");
 		return STATUS_FAILED;
 	}
 	buffer = params;
@@ -451,20 +451,20 @@ bool BaseFontBitmap::loadBuffer(char *buffer) {
 
 	}
 	if (cmd == PARSERR_TOKENNOTFOUND) {
-		_gameRef->LOG(0, "Syntax error in FONT definition");
+		_game->LOG(0, "Syntax error in FONT definition");
 		return STATUS_FAILED;
 	}
 
 	if (spriteFile != nullptr) {
 		SAFE_DELETE(_sprite);
-		_sprite = new BaseSprite(_gameRef, this);
+		_sprite = new BaseSprite(_game, this);
 		if (!_sprite || DID_FAIL(_sprite->loadFile(spriteFile))) {
 			SAFE_DELETE(_sprite);
 		}
 	}
 
 	if (surfaceFile != nullptr && !_sprite) {
-		_subframe = new BaseSubFrame(_gameRef);
+		_subframe = new BaseSubFrame(_game);
 		if (customTrans) {
 			_subframe->setSurface(surfaceFile, false, r, g, b);
 		} else {
@@ -479,7 +479,7 @@ bool BaseFontBitmap::loadBuffer(char *buffer) {
 
 
 	if (((_subframe == nullptr || _subframe->_surface == nullptr) && _sprite == nullptr) || _numColumns == 0 || _tileWidth == 0 || _tileHeight == 0) {
-		_gameRef->LOG(0, "Incomplete font definition");
+		_game->LOG(0, "Incomplete font definition");
 		return STATUS_FAILED;
 	}
 
@@ -612,10 +612,10 @@ bool BaseFontBitmap::getWidths() {
 	}
 	surf->endPixelOp();
 	/*
-	_gameRef->LOG(0, "----- %s ------", _filename);
+	_game->LOG(0, "----- %s ------", _filename);
 	for(int j=0; j<16; j++)
 	{
-	_gameRef->LOG(0, "%02d %02d %02d %02d %02d %02d %02d %02d %02d %02d %02d %02d %02d %02d %02d %02d", _widths[j*16+0], _widths[j*16+1], _widths[j*16+2], _widths[j*16+3], _widths[j*16+4], _widths[j*16+5], _widths[j*16+6], _widths[j*16+7], _widths[j*16+8], _widths[j*16+9], _widths[j*16+10], _widths[j*16+11], _widths[j*16+12], _widths[j*16+13], _widths[j*16+14], _widths[j*16+15]);
+		_game->LOG(0, "%02d %02d %02d %02d %02d %02d %02d %02d %02d %02d %02d %02d %02d %02d %02d %02d", _widths[j*16+0], _widths[j*16+1], _widths[j*16+2], _widths[j*16+3], _widths[j*16+4], _widths[j*16+5], _widths[j*16+6], _widths[j*16+7], _widths[j*16+8], _widths[j*16+9], _widths[j*16+10], _widths[j*16+11], _widths[j*16+12], _widths[j*16+13], _widths[j*16+14], _widths[j*16+15]);
 	}
 	*/
 	return STATUS_OK;
diff --git a/engines/wintermute/base/font/base_font_storage.cpp b/engines/wintermute/base/font/base_font_storage.cpp
index ebd89e56257..a983bcafeb3 100644
--- a/engines/wintermute/base/font/base_font_storage.cpp
+++ b/engines/wintermute/base/font/base_font_storage.cpp
@@ -51,7 +51,7 @@ BaseFontStorage::~BaseFontStorage() {
 bool BaseFontStorage::cleanup(bool warn) {
 	for (int32 i = 0; i < _fonts.getSize(); i++) {
 		if (warn)
-			_gameRef->LOG(0, "Removing orphan font '%s'", _fonts[i]->getFilename());
+			_game->LOG(0, "Removing orphan font '%s'", _fonts[i]->getFilename());
 		delete _fonts[i];
 	}
 	_fonts.removeAll();
@@ -81,7 +81,7 @@ BaseFont *BaseFontStorage::addFont(const Common::String &filename) {
 	}
 
 	/*
-	BaseFont* font = new BaseFont(_gameRef);
+	BaseFont* font = new BaseFont(_game);
 	if (!font) return nullptr;
 
 	if (DID_FAIL(font->loadFile(filename))) {
@@ -94,7 +94,7 @@ BaseFont *BaseFontStorage::addFont(const Common::String &filename) {
 	    return font;
 	}
 	*/
-	BaseFont *font = BaseFont::createFromFile(_gameRef,  filename);
+	BaseFont *font = BaseFont::createFromFile(_game,  filename);
 	if (font) {
 		font->_refCount = 1;
 		_fonts.add(font);
@@ -130,7 +130,7 @@ bool BaseFontStorage::persist(BasePersistenceManager *persistMgr) {
 		cleanup(false);
 	}
 
-	persistMgr->transferPtr(TMEMBER_PTR(_gameRef));
+	persistMgr->transferPtr(TMEMBER_PTR(_game));
 	_fonts.persist(persistMgr);
 
 	return STATUS_OK;
diff --git a/engines/wintermute/base/font/base_font_truetype.cpp b/engines/wintermute/base/font/base_font_truetype.cpp
index f38bcbd0152..c1e49f08511 100644
--- a/engines/wintermute/base/font/base_font_truetype.cpp
+++ b/engines/wintermute/base/font/base_font_truetype.cpp
@@ -101,7 +101,7 @@ void BaseFontTT::initLoop() {
 int BaseFontTT::getTextWidth(const byte *text, int maxLength) {
 	WideString textStr;
 
-	if (_gameRef->_textEncoding == TEXT_UTF8) {
+	if (_game->_textEncoding == TEXT_UTF8) {
 		textStr = StringUtil::utf8ToWide((const char *)text);
 	} else {
 		textStr = StringUtil::ansiToWide((const char *)text, _charset);
@@ -122,7 +122,7 @@ int BaseFontTT::getTextWidth(const byte *text, int maxLength) {
 int BaseFontTT::getTextHeight(const byte *text, int width) {
 	WideString textStr;
 
-	if (_gameRef->_textEncoding == TEXT_UTF8) {
+	if (_game->_textEncoding == TEXT_UTF8) {
 		textStr = StringUtil::utf8ToWide((const char *)text);
 	} else {
 		textStr = StringUtil::ansiToWide((const char *)text, _charset);
@@ -147,7 +147,7 @@ void BaseFontTT::drawText(const byte *text, int x, int y, int width, TTextAlign
 	// TODO: Why do we still insist on Widestrings everywhere?
 	// HACK: J.U.L.I.A. uses CP1252, we need to fix that,
 	// And we still don't have any UTF8-support.
-	if (_gameRef->_textEncoding == TEXT_UTF8) {
+	if (_game->_textEncoding == TEXT_UTF8) {
 		textStr = StringUtil::utf8ToWide((const char *)text);
 	} else {
 		textStr = StringUtil::ansiToWide((const char *)text, _charset);
@@ -158,7 +158,7 @@ void BaseFontTT::drawText(const byte *text, int x, int y, int width, TTextAlign
 	}
 	//text = text.substr(0, MaxLength); // TODO: Remove
 
-	BaseRenderer *renderer = _gameRef->_renderer;
+	BaseRenderer *renderer = _game->_renderer;
 
 	// find cached surface, if exists
 	uint32 minUseTime = INT_MAX_VALUE;
@@ -258,13 +258,13 @@ BaseSurface *BaseFontTT::renderTextToTexture(const WideString &text, int width,
 	//debugC(kWintermuteDebugFont, "%s %d %d %d %d", text.c_str(), RGBCOLGetR(_layers[0]->_color), RGBCOLGetG(_layers[0]->_color), RGBCOLGetB(_layers[0]->_color), RGBCOLGetA(_layers[0]->_color));
 //	void drawAlphaString(Surface *dst, const Common::String &str, int x, int y, int w, uint32 color, TextAlign align = kTextAlignLeft, int deltax = 0, bool useEllipsis = true) const;
 	Graphics::Surface *surface = new Graphics::Surface();
-	surface->create((uint16)width, (uint16)(_lineHeight * lines.size()), _gameRef->_renderer->getPixelFormat());
+	surface->create((uint16)width, (uint16)(_lineHeight * lines.size()), _game->_renderer->getPixelFormat());
 	uint32 useColor = 0xffffffff;
 	Common::Array<WideString>::iterator it;
 	int heightOffset = 0;
 	for (it = lines.begin(); it != lines.end(); ++it) {
 		WideString str;
-		if (_gameRef->_textRTL) {
+		if (_game->_textRTL) {
 			str = Common::convertBiDiU32String(*it, Common::BIDI_PAR_RTL);
 		} else {
 			str = Common::convertBiDiU32String(*it, Common::BIDI_PAR_LTR);
@@ -273,7 +273,7 @@ BaseSurface *BaseFontTT::renderTextToTexture(const WideString &text, int width,
 		heightOffset += (int)_lineHeight;
 	}
 
-	BaseSurface *retSurface = _gameRef->_renderer->createSurface();
+	BaseSurface *retSurface = _game->_renderer->createSurface();
 	retSurface->create(surface->w, surface->h);
 	retSurface->putSurface(*surface, true);
 	surface->free();
@@ -293,7 +293,7 @@ int BaseFontTT::getLetterHeight() {
 bool BaseFontTT::loadFile(const Common::String &filename) {
 	char *buffer = (char *)BaseFileManager::getEngineInstance()->readWholeFile(filename);
 	if (buffer == nullptr) {
-		_gameRef->LOG(0, "BaseFontTT::LoadFile failed for file '%s'", filename.c_str());
+		_game->LOG(0, "BaseFontTT::LoadFile failed for file '%s'", filename.c_str());
 		return STATUS_FAILED;
 	}
 
@@ -302,7 +302,7 @@ bool BaseFontTT::loadFile(const Common::String &filename) {
 	setFilename(filename.c_str());
 
 	if (DID_FAIL(ret = loadBuffer(buffer))) {
-		_gameRef->LOG(0, "Error parsing TTFONT file '%s'", filename.c_str());
+		_game->LOG(0, "Error parsing TTFONT file '%s'", filename.c_str());
 	}
 
 	delete[] buffer;
@@ -349,7 +349,7 @@ bool BaseFontTT::loadBuffer(char *buffer) {
 	BaseParser parser;
 
 	if (parser.getCommand(&buffer, commands, &params) != TOKEN_TTFONT) {
-		_gameRef->LOG(0, "'TTFONT' keyword expected.");
+		_game->LOG(0, "'TTFONT' keyword expected.");
 		return STATUS_FAILED;
 	}
 	buffer = params;
@@ -421,7 +421,7 @@ bool BaseFontTT::loadBuffer(char *buffer) {
 		}
 	}
 	if (cmd == PARSERR_TOKENNOTFOUND) {
-		_gameRef->LOG(0, "Syntax error in TTFONT definition");
+		_game->LOG(0, "Syntax error in TTFONT definition");
 		return STATUS_FAILED;
 	}
 
diff --git a/engines/wintermute/base/gfx/3dlight.cpp b/engines/wintermute/base/gfx/3dlight.cpp
index f5692e3f28e..52f588b3a12 100644
--- a/engines/wintermute/base/gfx/3dlight.cpp
+++ b/engines/wintermute/base/gfx/3dlight.cpp
@@ -61,10 +61,10 @@ bool Light3D::setLight(int index) {
 	diffuse._z = RGBCOLGetB(_diffuseColor) / 256.0f;
 	diffuse._w = 1.0f;
 
-	_gameRef->_renderer3D->setLightParameters(index, _pos, _target - _pos, diffuse, _isSpotlight);
+	_game->_renderer3D->setLightParameters(index, _pos, _target - _pos, diffuse, _isSpotlight);
 
 	if (_active) {
-		_gameRef->_renderer3D->lightEnable(index, true);
+		_game->_renderer3D->lightEnable(index, true);
 	}
 
 	return true;
diff --git a/engines/wintermute/base/gfx/3dmesh.cpp b/engines/wintermute/base/gfx/3dmesh.cpp
index 5b6d0595666..8959e59aaee 100644
--- a/engines/wintermute/base/gfx/3dmesh.cpp
+++ b/engines/wintermute/base/gfx/3dmesh.cpp
@@ -74,7 +74,7 @@ bool Mesh3DS::createVertexBuffer() {
 	int vbSize = _numFaces * sizeof(Mesh3DSVertex) * 3;
 	_vb = DXBuffer(vbSize);
 	if (_vb.ptr() == nullptr) {
-		_gameRef->LOG(0, "Error creating vertex buffer.");
+		_game->LOG(0, "Error creating vertex buffer.");
 		return false;
 	} else
 		return true;
@@ -91,7 +91,7 @@ bool Mesh3DS::fillVertexBuffer(uint32 color) {
 	int vbSize = _numFaces * sizeof(Mesh3DSVertex) * 3;
 	_vb = DXBuffer(vbSize);
 	if (_vb.ptr() == nullptr) {
-		_gameRef->LOG(0, "Error creating vertex buffer.");
+		_game->LOG(0, "Error creating vertex buffer.");
 		return false;
 	}
 
diff --git a/engines/wintermute/base/gfx/base_renderer3d.cpp b/engines/wintermute/base/gfx/base_renderer3d.cpp
index 3cb528a0f6e..d326acab684 100644
--- a/engines/wintermute/base/gfx/base_renderer3d.cpp
+++ b/engines/wintermute/base/gfx/base_renderer3d.cpp
@@ -67,14 +67,14 @@ bool BaseRenderer3D::getProjectionParams(float *resWidth, float *resHeight, floa
 	*resWidth = _width;
 	*resHeight = _height;
 
-	if (_gameRef->_editorResolutionWidth > 0)
-		*resWidth = _gameRef->_editorResolutionWidth;
-	if (_gameRef->_editorResolutionHeight > 0)
-		*resHeight = _gameRef->_editorResolutionHeight;
+	if (_game->_editorResolutionWidth > 0)
+		*resWidth = _game->_editorResolutionWidth;
+	if (_game->_editorResolutionHeight > 0)
+		*resHeight = _game->_editorResolutionHeight;
 
 	int lWidth, lHeight;
 	Common::Rect32 sceneViewport;
-	_gameRef->getLayerSize(&lWidth, &lHeight, &sceneViewport, customViewport);
+	_game->getLayerSize(&lWidth, &lHeight, &sceneViewport, customViewport);
 	*layerWidth = (float)lWidth;
 	*layerHeight = (float)lHeight;
 
diff --git a/engines/wintermute/base/gfx/base_surface.cpp b/engines/wintermute/base/gfx/base_surface.cpp
index f162eae6f2e..1bc461e52d0 100644
--- a/engines/wintermute/base/gfx/base_surface.cpp
+++ b/engines/wintermute/base/gfx/base_surface.cpp
@@ -85,7 +85,7 @@ bool BaseSurface::invalidate() {
 
 //////////////////////////////////////////////////////////////////////////
 bool BaseSurface::prepareToDraw() {
-	_lastUsedTime = _gameRef->getLiveTimer()->getTime();
+	_lastUsedTime = _game->getLiveTimer()->getTime();
 
 	if (!_valid) {
 		//_gameRef->LOG(0, "Reviving: %s", _filename);
diff --git a/engines/wintermute/base/gfx/opengl/base_render_opengl3d.cpp b/engines/wintermute/base/gfx/opengl/base_render_opengl3d.cpp
index e69f235bec9..e57d920cd04 100644
--- a/engines/wintermute/base/gfx/opengl/base_render_opengl3d.cpp
+++ b/engines/wintermute/base/gfx/opengl/base_render_opengl3d.cpp
@@ -120,7 +120,7 @@ bool BaseRenderOpenGL3D::initRenderer(int width, int height, bool windowed) {
 
 	_active = true;
 
-	_gameRef->_supportsRealTimeShadows = true;
+	_game->_supportsRealTimeShadows = true;
 
 	return true;
 }
@@ -163,7 +163,7 @@ bool BaseRenderOpenGL3D::flip() {
 }
 
 bool BaseRenderOpenGL3D::clear() {
-	if(!_gameRef->_editorMode) {
+	if(!_game->_editorMode) {
 		glViewport(0, _height, _width, _height);
 	}
 	glClearColor(0.0f, 0.0f, 0.0f, 1.0f);
@@ -245,7 +245,7 @@ bool BaseRenderOpenGL3D::setup3D(Camera3D *camera, bool force) {
 		bool fogEnabled;
 		uint32 fogColor;
 		float fogStart, fogEnd;
-		_gameRef->getFogParams(&fogEnabled, &fogColor, &fogStart, &fogEnd);
+		_game->getFogParams(&fogEnabled, &fogColor, &fogStart, &fogEnd);
 		if (fogEnabled) {
 			glEnable(GL_FOG);
 			GLfloat color[4] = { RGBCOLGetR(fogColor) / 255.0f,
@@ -279,7 +279,7 @@ void BaseRenderOpenGL3D::setAmbientLightRenderState() {
 		g = RGBCOLGetG(_ambientLightColor);
 		b = RGBCOLGetB(_ambientLightColor);
 	} else {
-		uint32 color = _gameRef->getAmbientLightColor();
+		uint32 color = _game->getAmbientLightColor();
 
 		a = RGBCOLGetA(color);
 		r = RGBCOLGetR(color);
@@ -508,7 +508,7 @@ bool BaseRenderOpenGL3D::setProjection() {
 	getProjectionParams(&resWidth, &resHeight, &layerWidth, &layerHeight, &modWidth, &modHeight, &customViewport);
 
 	Common::Rect32 rc;
-	_gameRef->getCurrentViewportRect(&rc);
+	_game->getCurrentViewportRect(&rc);
 	float viewportWidth = (float)rc.right - (float)rc.left;
 	float viewportHeight = (float)rc.bottom - (float)rc.top;
 
@@ -523,8 +523,8 @@ bool BaseRenderOpenGL3D::setProjection() {
 	float scaleMod = resHeight / viewportHeight;
 	float scaleRatio = MAX(layerWidth / resWidth, layerHeight / resHeight) /** 1.05*/;
 
-	float offsetX = (float)_gameRef->_offsetX;
-	float offsetY = (float)_gameRef->_offsetY;
+	float offsetX = (float)_game->_offsetX;
+	float offsetY = (float)_game->_offsetY;
 
 	if (!customViewport) {
 		offsetX -= _drawOffsetX;
@@ -660,7 +660,7 @@ void BaseRenderOpenGL3D::displaySimpleShadow(BaseObject *object) {
 	if (object->_shadowImage) {
 		shadowImage = object->_shadowImage;
 	} else {
-		shadowImage = _gameRef->_shadowImage;
+		shadowImage = _game->_shadowImage;
 	}
 
 	if (!shadowImage) {
@@ -802,7 +802,7 @@ void BaseRenderOpenGL3D::renderSceneGeometry(const BaseArray<AdWalkplane *> &pla
 	DXMatrixIdentity(&matIdentity);
 
 	if (camera)
-		_gameRef->_renderer3D->setup3D(camera, true);
+		_game->_renderer3D->setup3D(camera, true);
 
 	setWorldTransform(matIdentity);
 
@@ -840,7 +840,7 @@ void BaseRenderOpenGL3D::renderSceneGeometry(const BaseArray<AdWalkplane *> &pla
 	}
 
 	// render waypoints
-	AdScene *scene = ((AdGame *)_gameRef)->_scene;
+	AdScene *scene = ((AdGame *)_game)->_scene;
 	AdSceneGeometry *geom = scene->_geom;
 	if (geom && geom->_wptMarker) {
 		DXMatrix viewMat, projMat, worldMat;
@@ -873,7 +873,7 @@ void BaseRenderOpenGL3D::renderShadowGeometry(const BaseArray<AdWalkplane *> &pl
 	DXMatrixIdentity(&matIdentity);
 
 	if (camera)
-		_gameRef->_renderer3D->setup3D(camera, true);
+		_game->_renderer3D->setup3D(camera, true);
 
 	setWorldTransform(matIdentity);
 
@@ -1128,19 +1128,19 @@ void BaseRenderOpenGL3D::postfilter() {
 }
 
 BaseSurface *BaseRenderOpenGL3D::createSurface() {
-	return new BaseSurfaceOpenGL3D(_gameRef, this);
+	return new BaseSurfaceOpenGL3D(_game, this);
 }
 
 Mesh3DS *BaseRenderOpenGL3D::createMesh3DS() {
-	return new Mesh3DSOpenGL(_gameRef);
+	return new Mesh3DSOpenGL(_game);
 }
 
 XMesh *BaseRenderOpenGL3D::createXMesh() {
-	return new XMeshOpenGL(_gameRef);
+	return new XMeshOpenGL(_game);
 }
 
 ShadowVolume *BaseRenderOpenGL3D::createShadowVolume() {
-	return new ShadowVolumeOpenGL(_gameRef);
+	return new ShadowVolumeOpenGL(_game);
 }
 
 // ScummVM specific ends <--
diff --git a/engines/wintermute/base/gfx/opengl/base_render_opengl3d_shader.cpp b/engines/wintermute/base/gfx/opengl/base_render_opengl3d_shader.cpp
index 2e7dcf7dbdb..30e0fdd9e05 100644
--- a/engines/wintermute/base/gfx/opengl/base_render_opengl3d_shader.cpp
+++ b/engines/wintermute/base/gfx/opengl/base_render_opengl3d_shader.cpp
@@ -204,7 +204,7 @@ bool BaseRenderOpenGL3DShader::initRenderer(int width, int height, bool windowed
 
 	_active = true;
 
-	_gameRef->_supportsRealTimeShadows = true;
+	_game->_supportsRealTimeShadows = true;
 
 	return true;
 }
@@ -241,7 +241,7 @@ bool BaseRenderOpenGL3DShader::flip() {
 }
 
 bool BaseRenderOpenGL3DShader::clear() {
-	if(!_gameRef->_editorMode) {
+	if(!_game->_editorMode) {
 		glViewport(0, _height, _width, _height);
 	}
 	glClearColor(0.0f, 0.0f, 0.0f, 1.0f);
@@ -307,7 +307,7 @@ bool BaseRenderOpenGL3DShader::setup3D(Camera3D *camera, bool force) {
 		uint32 fogColor;
 		float fogStart, fogEnd;
 
-		_gameRef->getFogParams(&fogEnabled, &fogColor, &fogStart, &fogEnd);
+		_game->getFogParams(&fogEnabled, &fogColor, &fogStart, &fogEnd);
 		if (fogEnabled) {
 			Math::Vector4d color;
 			color.x() = RGBCOLGetR(fogColor) / 255.0f;
@@ -368,7 +368,7 @@ void BaseRenderOpenGL3DShader::setAmbientLightRenderState() {
 		g = RGBCOLGetG(_ambientLightColor);
 		b = RGBCOLGetB(_ambientLightColor);
 	} else {
-		uint32 color = _gameRef->getAmbientLightColor();
+		uint32 color = _game->getAmbientLightColor();
 
 		a = RGBCOLGetA(color);
 		r = RGBCOLGetR(color);
@@ -594,7 +594,7 @@ bool BaseRenderOpenGL3DShader::setProjection() {
 	getProjectionParams(&resWidth, &resHeight, &layerWidth, &layerHeight, &modWidth, &modHeight, &customViewport);
 
 	Common::Rect32 rc;
-	_gameRef->getCurrentViewportRect(&rc);
+	_game->getCurrentViewportRect(&rc);
 	float viewportWidth = (float)rc.right - (float)rc.left;
 	float viewportHeight = (float)rc.bottom - (float)rc.top;
 
@@ -609,8 +609,8 @@ bool BaseRenderOpenGL3DShader::setProjection() {
 	float scaleMod = resHeight / viewportHeight;
 	float scaleRatio = MAX(layerWidth / resWidth, layerHeight / resHeight) /** 1.05*/;
 
-	float offsetX = (float)_gameRef->_offsetX;
-	float offsetY = (float)_gameRef->_offsetY;
+	float offsetX = (float)_game->_offsetX;
+	float offsetY = (float)_game->_offsetY;
 
 	if (!customViewport) {
 		offsetX -= _drawOffsetX;
@@ -758,7 +758,7 @@ void BaseRenderOpenGL3DShader::displaySimpleShadow(BaseObject *object) {
 	if (object->_shadowImage) {
 		shadowImage = object->_shadowImage;
 	} else {
-		shadowImage = _gameRef->_shadowImage;
+		shadowImage = _game->_shadowImage;
 	}
 
 	if (!shadowImage) {
@@ -897,7 +897,7 @@ void BaseRenderOpenGL3DShader::renderSceneGeometry(const BaseArray<AdWalkplane *
 	DXMatrixIdentity(&matIdentity);
 
 	if (camera)
-		_gameRef->_renderer3D->setup3D(camera, true);
+		_game->_renderer3D->setup3D(camera, true);
 	
 	setWorldTransform(matIdentity);
 
@@ -928,7 +928,7 @@ void BaseRenderOpenGL3DShader::renderSceneGeometry(const BaseArray<AdWalkplane *
 	}
 
 	// render waypoints
-	AdScene *scene = ((AdGame *)_gameRef)->_scene;
+	AdScene *scene = ((AdGame *)_game)->_scene;
 	AdSceneGeometry *geom = scene->_geom;
 	if (geom && geom->_wptMarker) {
 		DXMatrix viewMat, projMat, worldMat;
@@ -958,7 +958,7 @@ void BaseRenderOpenGL3DShader::renderShadowGeometry(const BaseArray<AdWalkplane
 	DXMatrixIdentity(&matIdentity);
 
 	if (camera)
-		_gameRef->_renderer3D->setup3D(camera, true);
+		_game->_renderer3D->setup3D(camera, true);
 
 	setWorldTransform(matIdentity);
 
@@ -1134,19 +1134,19 @@ void BaseRenderOpenGL3DShader::postfilter() {
 }
 
 BaseSurface *BaseRenderOpenGL3DShader::createSurface() {
-	return new BaseSurfaceOpenGL3D(_gameRef, this);
+	return new BaseSurfaceOpenGL3D(_game, this);
 }
 
 Mesh3DS *BaseRenderOpenGL3DShader::createMesh3DS() {
-	return new Mesh3DSOpenGLShader(_gameRef, _geometryShader);
+	return new Mesh3DSOpenGLShader(_game, _geometryShader);
 }
 
 XMesh *BaseRenderOpenGL3DShader::createXMesh() {
-	return new XMeshOpenGLShader(_gameRef, _xmodelShader, _flatShadowShader);
+	return new XMeshOpenGLShader(_game, _xmodelShader, _flatShadowShader);
 }
 
 ShadowVolume *BaseRenderOpenGL3DShader::createShadowVolume() {
-	return new ShadowVolumeOpenGLShader(_gameRef, _shadowVolumeShader, _shadowMaskShader);
+	return new ShadowVolumeOpenGLShader(_game, _shadowVolumeShader, _shadowMaskShader);
 }
 
 // ScummVM specific ends <--
diff --git a/engines/wintermute/base/gfx/opengl/meshx_opengl.cpp b/engines/wintermute/base/gfx/opengl/meshx_opengl.cpp
index 120144dd99a..108a5ea9c88 100644
--- a/engines/wintermute/base/gfx/opengl/meshx_opengl.cpp
+++ b/engines/wintermute/base/gfx/opengl/meshx_opengl.cpp
@@ -57,7 +57,7 @@ bool XMeshOpenGL::render(XModel *model) {
 
 	// For WME DX, mesh model is not visible, possible it's clipped.
 	// For OpenGL, mesh is visible, skip draw it here instead in core.
-	if (!_gameRef->_renderer3D->_camera)
+	if (!_game->_renderer3D->_camera)
 		return false;
 
 	auto fvf = _blendedMesh->getFVF();
@@ -159,7 +159,7 @@ bool XMeshOpenGL::renderFlatShadowModel(uint32 shadowColor) {
 
 	// For WME DX, mesh model is not visible, possible it's clipped.
 	// For OpenGL, mesh is visible, skip draw it here instead in core.
-	if (!_gameRef->_renderer3D->_camera)
+	if (!_game->_renderer3D->_camera)
 		return false;
 
 	// W/A for the scene with the table in the laboratory where the engine switches to flat shadows.
diff --git a/engines/wintermute/base/gfx/opengl/meshx_opengl_shader.cpp b/engines/wintermute/base/gfx/opengl/meshx_opengl_shader.cpp
index 71d911965a3..b20b29bca67 100644
--- a/engines/wintermute/base/gfx/opengl/meshx_opengl_shader.cpp
+++ b/engines/wintermute/base/gfx/opengl/meshx_opengl_shader.cpp
@@ -83,7 +83,7 @@ bool XMeshOpenGLShader::render(XModel *model) {
 
 	// For WME DX, mesh model is not visible, possible it's clipped.
 	// For OpenGL, mesh is visible, skip draw it here instead in core.
-	if (!_gameRef->_renderer3D->_camera)
+	if (!_game->_renderer3D->_camera)
 		return false;
 
 	auto fvf = _blendedMesh->getFVF();
@@ -179,7 +179,7 @@ bool XMeshOpenGLShader::renderFlatShadowModel(uint32 shadowColor) {
 
 	// For WME DX, mesh model is not visible, possible it's clipped.
 	// For OpenGL, mesh is visible, skip draw it here instead in core.
-	if (!_gameRef->_renderer3D->_camera)
+	if (!_game->_renderer3D->_camera)
 		return false;
 
 	// W/A for the scene with the table in the laboratory where the engine switches to flat shadows.
diff --git a/engines/wintermute/base/gfx/opengl/shadow_volume_opengl.cpp b/engines/wintermute/base/gfx/opengl/shadow_volume_opengl.cpp
index 9e98fe6ed99..30074038b44 100644
--- a/engines/wintermute/base/gfx/opengl/shadow_volume_opengl.cpp
+++ b/engines/wintermute/base/gfx/opengl/shadow_volume_opengl.cpp
@@ -49,7 +49,7 @@ ShadowVolumeOpenGL::~ShadowVolumeOpenGL() {
 bool ShadowVolumeOpenGL::render() {
 	glBindTexture(GL_TEXTURE_2D, 0);
 	glDisable(GL_TEXTURE_2D);
-	_gameRef->_renderer3D->_lastTexture = nullptr;
+	_game->_renderer3D->_lastTexture = nullptr;
 
 	glColor4f(1.0f, 1.0f, 1.0f, 1.0f);
 	glEnableClientState(GL_VERTEX_ARRAY);
@@ -124,7 +124,7 @@ bool ShadowVolumeOpenGL::renderToScene() {
 
 	glBindTexture(GL_TEXTURE_2D, 0);
 
-	BaseRenderOpenGL3D *renderer = dynamic_cast<BaseRenderOpenGL3D *>(_gameRef->_renderer3D);
+	BaseRenderOpenGL3D *renderer = dynamic_cast<BaseRenderOpenGL3D *>(_game->_renderer3D);
 	renderer->setProjection2D();
 
 	glFrontFace(GL_CW);
@@ -145,7 +145,7 @@ bool ShadowVolumeOpenGL::renderToScene() {
 	glEnable(GL_DEPTH_TEST);
 	glDisable(GL_STENCIL_TEST);
 
-	_gameRef->_renderer3D->setup3D(nullptr, true);
+	_game->_renderer3D->setup3D(nullptr, true);
 
 	// clear stencil buffer
 	glClearStencil(0);
@@ -156,7 +156,7 @@ bool ShadowVolumeOpenGL::renderToScene() {
 
 //////////////////////////////////////////////////////////////////////////
 bool ShadowVolumeOpenGL::initMask() {
-	auto *rend = _gameRef->_renderer3D;
+	auto *rend = _game->_renderer3D;
 
 	// bottom left
 	_shadowMask[0].x = 0.0f;
diff --git a/engines/wintermute/base/gfx/opengl/shadow_volume_opengl_shader.cpp b/engines/wintermute/base/gfx/opengl/shadow_volume_opengl_shader.cpp
index 304fc860b05..0c906a43648 100644
--- a/engines/wintermute/base/gfx/opengl/shadow_volume_opengl_shader.cpp
+++ b/engines/wintermute/base/gfx/opengl/shadow_volume_opengl_shader.cpp
@@ -67,7 +67,7 @@ ShadowVolumeOpenGLShader::~ShadowVolumeOpenGLShader() {
 bool ShadowVolumeOpenGLShader::render() {
 	glBindTexture(GL_TEXTURE_2D, 0);
 	glDisable(GL_TEXTURE_2D);
-	_gameRef->_renderer3D->_lastTexture = nullptr;
+	_game->_renderer3D->_lastTexture = nullptr;
 
 	Math::Vector4d colorValue;
 	colorValue.x() = 1.0f;
@@ -149,7 +149,7 @@ bool ShadowVolumeOpenGLShader::renderToScene() {
 
 	glBindTexture(GL_TEXTURE_2D, 0);
 
-	BaseRenderOpenGL3DShader *renderer = dynamic_cast<BaseRenderOpenGL3DShader *>(_gameRef->_renderer3D);
+	BaseRenderOpenGL3DShader *renderer = dynamic_cast<BaseRenderOpenGL3DShader *>(_game->_renderer3D);
 	renderer->_shadowMaskShader->use();
 	renderer->setProjection2D(renderer->_shadowMaskShader);
 
@@ -164,7 +164,7 @@ bool ShadowVolumeOpenGLShader::renderToScene() {
 	glEnable(GL_DEPTH_TEST);
 	glDisable(GL_STENCIL_TEST);
 
-	_gameRef->_renderer3D->setup3D(nullptr, true);
+	_game->_renderer3D->setup3D(nullptr, true);
 
 	// clear stencil buffer
 	glClearStencil(0);
@@ -175,7 +175,7 @@ bool ShadowVolumeOpenGLShader::renderToScene() {
 
 //////////////////////////////////////////////////////////////////////////
 bool ShadowVolumeOpenGLShader::initMask() {
-	auto *rend = _gameRef->_renderer3D;
+	auto *rend = _game->_renderer3D;
 	ShadowVertexShader shadowMask[4];
 
 	// bottom left
diff --git a/engines/wintermute/base/gfx/osystem/base_render_osystem.cpp b/engines/wintermute/base/gfx/osystem/base_render_osystem.cpp
index 83bfae42094..3becf6e6861 100644
--- a/engines/wintermute/base/gfx/osystem/base_render_osystem.cpp
+++ b/engines/wintermute/base/gfx/osystem/base_render_osystem.cpp
@@ -234,7 +234,7 @@ void BaseRenderOSystem::fadeToColor(byte r, byte g, byte b, byte a) {
 	Common::Rect fillRect;
 
 	Common::Rect32 rc;
-	_gameRef->getCurrentViewportRect(&rc);
+	_game->getCurrentViewportRect(&rc);
 	fillRect.left = (int16)rc.left;
 	fillRect.top = (int16)rc.top;
 	fillRect.setWidth((int16)(rc.right - rc.left));
@@ -519,7 +519,7 @@ void BaseRenderOSystem::pointToScreen(Common::Point32 *point) {
 }
 
 BaseSurface *BaseRenderOSystem::createSurface() {
-	return new BaseSurfaceOSystem(_gameRef);
+	return new BaseSurfaceOSystem(_game);
 }
 
 void BaseRenderOSystem::endSaveLoad() {
diff --git a/engines/wintermute/base/gfx/osystem/base_surface_osystem.cpp b/engines/wintermute/base/gfx/osystem/base_surface_osystem.cpp
index 4dc4ef365ff..220971ae9ee 100644
--- a/engines/wintermute/base/gfx/osystem/base_surface_osystem.cpp
+++ b/engines/wintermute/base/gfx/osystem/base_surface_osystem.cpp
@@ -61,7 +61,7 @@ BaseSurfaceOSystem::BaseSurfaceOSystem(BaseGame *inGame) : BaseSurface(inGame) {
 BaseSurfaceOSystem::~BaseSurfaceOSystem() {
 	if (_surface) {
 		if (_valid)
-			_gameRef->addMem(-_width * _height * 4);
+			_game->addMem(-_width * _height * 4);
 		_surface->free();
 		delete _surface;
 		_surface = nullptr;
@@ -73,7 +73,7 @@ BaseSurfaceOSystem::~BaseSurfaceOSystem() {
 		_alphaMask = nullptr;
 	}
 
-	BaseRenderOSystem *renderer = static_cast<BaseRenderOSystem *>(_gameRef->_renderer);
+	BaseRenderOSystem *renderer = static_cast<BaseRenderOSystem *>(_game->_renderer);
 	renderer->invalidateTicketsFromSurface(this);
 }
 
@@ -113,7 +113,7 @@ bool BaseSurfaceOSystem::finishLoad() {
 
 	if (_surface) {
 		if (_valid)
-			_gameRef->addMem(-_width * _height * 4);
+			_game->addMem(-_width * _height * 4);
 		_surface->free();
 		delete _surface;
 		_surface = nullptr;
@@ -136,7 +136,7 @@ bool BaseSurfaceOSystem::finishLoad() {
 		_surface->copyFrom(*image->getSurface());
 	}
 
-	_gameRef->addMem(_width * _height * 4);
+	_game->addMem(_width * _height * 4);
 
 	if (_filename.matchString("savegame:*g", true)) {
 		uint8 r, g, b, a;
@@ -211,14 +211,14 @@ bool BaseSurfaceOSystem::finishLoad() {
 //////////////////////////////////////////////////////////////////////////
 bool BaseSurfaceOSystem::create(int width, int height) {
 	if (_valid)
-		_gameRef->addMem(-_width * _height * 4);
+		_game->addMem(-_width * _height * 4);
 	_surface->free();
 
 	_width = width;
 	_height = height;
 
 	_surface->create(_width, _height, g_system->getScreenFormat());
-	_gameRef->addMem(_width * _height * 4);
+	_game->addMem(_width * _height * 4);
 
 	_valid = true;
 
@@ -232,7 +232,7 @@ bool BaseSurfaceOSystem::invalidate() {
 	}
 
 	if (_valid) {
-		_gameRef->addMem(-_width * _height * 4);
+		_game->addMem(-_width * _height * 4);
 		_surface->free();
 		_valid = false;
 	}
@@ -273,10 +273,10 @@ bool BaseSurfaceOSystem::startPixelOp() {
 
 //////////////////////////////////////////////////////////////////////////
 bool BaseSurfaceOSystem::endPixelOp() {
-	_lastUsedTime = _gameRef->getLiveTimer()->getTime();
+	_lastUsedTime = _game->getLiveTimer()->getTime();
 	_pixelOpReady = false;
 	if (_surfaceModified) {
-		BaseRenderOSystem *renderer = static_cast<BaseRenderOSystem *>(_gameRef->_renderer);
+		BaseRenderOSystem *renderer = static_cast<BaseRenderOSystem *>(_game->_renderer);
 		renderer->invalidateTicketsFromSurface(this);
 		_surfaceModified = false;
 	}
@@ -330,9 +330,9 @@ bool BaseSurfaceOSystem::displayTiled(int x, int y, Common::Rect32 rect, int num
 
 //////////////////////////////////////////////////////////////////////////
 bool BaseSurfaceOSystem::drawSprite(int x, int y, Common::Rect32 *rect, Common::Rect32 *newRect, Graphics::TransformStruct transform) {
-	BaseRenderOSystem *renderer = static_cast<BaseRenderOSystem *>(_gameRef->_renderer);
+	BaseRenderOSystem *renderer = static_cast<BaseRenderOSystem *>(_game->_renderer);
 
-	_lastUsedTime = _gameRef->getLiveTimer()->getTime();
+	_lastUsedTime = _game->getLiveTimer()->getTime();
 
 	// TODO: Skip this check if we can reuse an existing ticket?
 	if (!_valid) {
@@ -398,7 +398,7 @@ bool BaseSurfaceOSystem::putSurface(const Graphics::Surface &surface, bool hasAl
 	} else {
 		_alphaType = _alphaMaskType;
 	}
-	BaseRenderOSystem *renderer = static_cast<BaseRenderOSystem *>(_gameRef->_renderer);
+	BaseRenderOSystem *renderer = static_cast<BaseRenderOSystem *>(_game->_renderer);
 	renderer->invalidateTicketsFromSurface(this);
 
 	return STATUS_OK;
diff --git a/engines/wintermute/base/gfx/osystem/render_ticket.cpp b/engines/wintermute/base/gfx/osystem/render_ticket.cpp
index a0fed8a9269..6f65d35dd37 100644
--- a/engines/wintermute/base/gfx/osystem/render_ticket.cpp
+++ b/engines/wintermute/base/gfx/osystem/render_ticket.cpp
@@ -59,11 +59,11 @@ RenderTicket::RenderTicket(BaseSurfaceOSystem *owner, const Graphics::Surface *s
 		// (Mirroring should most likely be done before rotation. See also
 		// TransformTools.)
 		if (_transform._angle != Graphics::kDefaultAngle) {
-			_surface = temp.rotoscale(transform, owner->_gameRef->getBilinearFiltering());
+			_surface = temp.rotoscale(transform, owner->_game->getBilinearFiltering());
 		} else if ((dstRect->width() != srcRect->width() ||
 			    dstRect->height() != srcRect->height()) &&
 			    _transform._numTimesX * _transform._numTimesY == 1) {
-			_surface = temp.scale(dstRect->width(), dstRect->height(), owner->_gameRef->getBilinearFiltering());
+			_surface = temp.scale(dstRect->width(), dstRect->height(), owner->_game->getBilinearFiltering());
 		} else {
 			_surface = new Graphics::Surface();
 			_surface->copyFrom(temp);
diff --git a/engines/wintermute/base/gfx/xactive_animation.cpp b/engines/wintermute/base/gfx/xactive_animation.cpp
index 3fbf4aa5d9a..3f6f3d6f439 100644
--- a/engines/wintermute/base/gfx/xactive_animation.cpp
+++ b/engines/wintermute/base/gfx/xactive_animation.cpp
@@ -55,7 +55,7 @@ ActiveAnimation::~ActiveAnimation() {
 //////////////////////////////////////////////////////////////////////////
 bool ActiveAnimation::start(AnimationSet *animation, bool looping) {
 	_animation = animation;
-	_startTime = _gameRef->_currentTime;
+	_startTime = _game->_currentTime;
 	_looping = looping;
 	_finished = false;
 	_currentFrame = -1;
@@ -65,7 +65,7 @@ bool ActiveAnimation::start(AnimationSet *animation, bool looping) {
 
 //////////////////////////////////////////////////////////////////////////
 bool ActiveAnimation::resetStartTime() {
-	_startTime = _gameRef->_currentTime;
+	_startTime = _game->_currentTime;
 	return true;
 }
 
@@ -79,12 +79,12 @@ bool ActiveAnimation::update(int slot, bool prevFrameOnly, float lerpValue, bool
 	}
 
 	uint32 localTime = 0;
-	//_gameRef->LOG(0, "%s %d %d %f %d", _animation->_name, slot, prevFrameOnly, lerpValue, forceStartFrame);
+	//_game->LOG(0, "%s %d %d %f %d", _animation->_name, slot, prevFrameOnly, lerpValue, forceStartFrame);
 	if (prevFrameOnly) {
 		localTime = _lastLocalTime;
 	} else {
 		if (!_finished) {
-			localTime = _gameRef->_currentTime - _startTime;
+			localTime = _game->_currentTime - _startTime;
 			if (localTime > _animation->getTotalTime()) {
 				if (_looping) {
 					if (_animation->getTotalTime() == 0) {
@@ -124,7 +124,7 @@ bool ActiveAnimation::update(int slot, bool prevFrameOnly, float lerpValue, bool
 
 		_currentFrame = frame;
 	}
-	//_gameRef->LOG(0, "%s %d %f", _animation->_name, localTime, lerpValue);
+	//_game->LOG(0, "%s %d %f", _animation->_name, localTime, lerpValue);
 	return _animation->update(slot, localTime, lerpValue);
 }
 
diff --git a/engines/wintermute/base/gfx/xanimation_channel.cpp b/engines/wintermute/base/gfx/xanimation_channel.cpp
index 2352d962e0a..a47f61512ae 100644
--- a/engines/wintermute/base/gfx/xanimation_channel.cpp
+++ b/engines/wintermute/base/gfx/xanimation_channel.cpp
@@ -56,7 +56,7 @@ bool AnimationChannel::playAnim(AnimationSet *animSet, uint32 transitionTime, ui
 
 	ActiveAnimation *anim = nullptr;
 	if (animSet != nullptr) {
-		anim = new ActiveAnimation(_gameRef, _model);
+		anim = new ActiveAnimation(_game, _model);
 		anim->start(animSet, animSet->_looping);
 	}
 
@@ -73,7 +73,7 @@ bool AnimationChannel::playAnim(AnimationSet *animSet, uint32 transitionTime, ui
 			_anim[1] = anim;
 			_transitioning = (anim != nullptr);
 			_transtitionTime = transitionTime;
-			_transitionStart = _gameRef->_currentTime;
+			_transitionStart = _game->_currentTime;
 		} else {
 			_anim[0] = anim;
 			SAFE_DELETE(_anim[1]);
@@ -99,7 +99,7 @@ bool AnimationChannel::stopAnim(uint32 transitionTime) {
 
 		_transitioning = true;
 		_transtitionTime = transitionTime;
-		_transitionStart = _gameRef->_currentTime;
+		_transitionStart = _game->_currentTime;
 	}
 
 	return true;
@@ -108,7 +108,7 @@ bool AnimationChannel::stopAnim(uint32 transitionTime) {
 //////////////////////////////////////////////////////////////////////////
 bool AnimationChannel::update(bool debug) {
 	if (_transitioning) {
-		uint32 delta = _gameRef->_currentTime - _transitionStart;
+		uint32 delta = _game->_currentTime - _transitionStart;
 
 		if (delta >= _transtitionTime) {
 			_transitioning = false;
@@ -124,7 +124,7 @@ bool AnimationChannel::update(bool debug) {
 				return _anim[0]->update();
 			}
 		} else {
-			float lerpValue = float(_gameRef->_currentTime - _transitionStart) / float(_transtitionTime);
+			float lerpValue = float(_game->_currentTime - _transitionStart) / float(_transtitionTime);
 
 			if (_anim[0]) {
 				_anim[0]->update(0, true, lerpValue);
@@ -193,7 +193,7 @@ bool AnimationChannel::persist(BasePersistenceManager *persistMgr) {
 
 		if (!persistMgr->getIsSaving()) {
 			if (animExists)
-				_anim[i] = new ActiveAnimation(_gameRef, _model);
+				_anim[i] = new ActiveAnimation(_game, _model);
 			else
 				_anim[i] = nullptr;
 		}
diff --git a/engines/wintermute/base/gfx/xanimation_set.cpp b/engines/wintermute/base/gfx/xanimation_set.cpp
index b81e14de8e5..01964e693be 100644
--- a/engines/wintermute/base/gfx/xanimation_set.cpp
+++ b/engines/wintermute/base/gfx/xanimation_set.cpp
@@ -80,7 +80,7 @@ bool AnimationSet::addEvent(AnimationEvent *event) {
 	} else {
 		int frameTime = getFrameTime();
 		if (frameTime < 0) {
-			_gameRef->LOG(0, "Error adding animation event %s, no keyframes found", event->_eventName);
+			_game->LOG(0, "Error adding animation event %s, no keyframes found", event->_eventName);
 			SAFE_DELETE(event);
 			return false;
 		}
diff --git a/engines/wintermute/base/gfx/xframe_node.cpp b/engines/wintermute/base/gfx/xframe_node.cpp
index af5d33c5836..b4cc3adfbaf 100644
--- a/engines/wintermute/base/gfx/xframe_node.cpp
+++ b/engines/wintermute/base/gfx/xframe_node.cpp
@@ -98,7 +98,7 @@ void FrameNode::setTransformation(int slot, DXVector3 pos, DXVector3 scale, DXQu
 
 //////////////////////////////////////////////////////////////////////////
 bool FrameNode::loadFromXData(const Common::String &filename, XModel *model, XFileData *xobj) {
-	_gameRef->miniUpdate();
+	_game->miniUpdate();
 
 	bool res = true;
 
@@ -111,7 +111,7 @@ bool FrameNode::loadFromXData(const Common::String &filename, XModel *model, XFi
 	}
 
 	if (objectType == kXClassMesh) { // load a child mesh
-		XMesh *mesh = _gameRef->_renderer3D->createXMesh();
+		XMesh *mesh = _game->_renderer3D->createXMesh();
 		res = mesh->loadFromXData(filename, xobj);
 		if (res) {
 			_meshes.add(mesh);
@@ -137,7 +137,7 @@ bool FrameNode::loadFromXData(const Common::String &filename, XModel *model, XFi
 	} else if (objectType == kXClassAnimation) { // load a single animation (shouldn't happen here)
 		return model->loadAnimation(filename, xobj);
 	} else if (objectType == kXClassFrame) { // create a new child frame
-		FrameNode *childFrame = new FrameNode(_gameRef);
+		FrameNode *childFrame = new FrameNode(_game);
 
 		// get the name of the child frame
 		res = XModel::loadName(childFrame, xobj);
diff --git a/engines/wintermute/base/gfx/xmaterial.cpp b/engines/wintermute/base/gfx/xmaterial.cpp
index feeec5b7c0e..ee51c14158f 100644
--- a/engines/wintermute/base/gfx/xmaterial.cpp
+++ b/engines/wintermute/base/gfx/xmaterial.cpp
@@ -56,7 +56,7 @@ Material::Material(BaseGame *inGame) : BaseNamedObject(inGame) {
 //////////////////////////////////////////////////////////////////////////
 Material::~Material() {
 	if (_surface && _ownedSurface) {
-		_gameRef->_surfaceStorage->removeSurface(_surface);
+		_game->_surfaceStorage->removeSurface(_surface);
 	}
 
 	_sprite = nullptr; // ref only
@@ -88,10 +88,10 @@ bool Material::setTexture(const Common::String &filename, bool adoptName) {
 	_textureFilename = filename;
 
 	if (_surface && _ownedSurface) {
-		_gameRef->_surfaceStorage->removeSurface(_surface);
+		_game->_surfaceStorage->removeSurface(_surface);
 	}
 
-	_surface = _gameRef->_surfaceStorage->addSurface(_textureFilename);
+	_surface = _game->_surfaceStorage->addSurface(_textureFilename);
 	_ownedSurface = true;
 	_sprite = nullptr;
 
@@ -106,7 +106,7 @@ bool Material::setSprite(BaseSprite *sprite, bool adoptName) {
 
 	_textureFilename = sprite->getFilename();
 	if (_surface && _ownedSurface) {
-		_gameRef->_surfaceStorage->removeSurface(_surface);
+		_game->_surfaceStorage->removeSurface(_surface);
 	}
 
 	_surface = nullptr;
@@ -126,7 +126,7 @@ bool Material::setTheora(VideoTheoraPlayer *theora, bool adoptName) {
 	_textureFilename = theora->_filename;
 
 	if (_surface && _ownedSurface) {
-		_gameRef->_surfaceStorage->removeSurface(_surface);
+		_game->_surfaceStorage->removeSurface(_surface);
 	}
 
 	_surface = nullptr;
diff --git a/engines/wintermute/base/gfx/xmesh.cpp b/engines/wintermute/base/gfx/xmesh.cpp
index ecbeb7335db..e147238ec24 100644
--- a/engines/wintermute/base/gfx/xmesh.cpp
+++ b/engines/wintermute/base/gfx/xmesh.cpp
@@ -113,7 +113,7 @@ bool XMesh::loadFromXData(const Common::String &filename, XFileData *xobj) {
 	// check for materials
 	if ((bufMaterials.ptr() == nullptr) || (numMaterials == 0)) {
 		// no materials are found, create default material
-		Material *mat = new Material(_gameRef);
+		Material *mat = new Material(_game);
 		mat->_material._diffuse.color._r = 0.5f;
 		mat->_material._diffuse.color._g = 0.5f;
 		mat->_material._diffuse.color._b = 0.5f;
@@ -125,7 +125,7 @@ bool XMesh::loadFromXData(const Common::String &filename, XFileData *xobj) {
 		// load the materials
 		DXMaterial *fileMats = (DXMaterial *)bufMaterials.ptr();
 		for (uint i = 0; i < numMaterials; i++) {
-			Material *mat = new Material(_gameRef);
+			Material *mat = new Material(_game);
 			mat->_material = fileMats[i];
 			mat->_material._ambient = mat->_material._diffuse;
 
diff --git a/engines/wintermute/base/gfx/xmodel.cpp b/engines/wintermute/base/gfx/xmodel.cpp
index 4860a9a6788..6e20e1a9062 100644
--- a/engines/wintermute/base/gfx/xmodel.cpp
+++ b/engines/wintermute/base/gfx/xmodel.cpp
@@ -117,7 +117,7 @@ void XModel::cleanup(bool complete) {
 bool XModel::loadFromFile(const Common::String &filename, XModel *parentModel) {
 	cleanup(false);
 
-	XFile *xfile = new XFile(_gameRef);
+	XFile *xfile = new XFile(_game);
 	if (!xfile)
 		return false;
 
@@ -134,7 +134,7 @@ bool XModel::loadFromFile(const Common::String &filename, XModel *parentModel) {
 	}
 
 	// get top level objects
-	_rootFrame = new FrameNode(_gameRef);
+	_rootFrame = new FrameNode(_game);
 
 	uint32 numChildren = 0;
 	xfile->getEnum().getChildren(numChildren);
@@ -161,7 +161,7 @@ bool XModel::loadFromFile(const Common::String &filename, XModel *parentModel) {
 
 	// setup animation channels
 	for (int i = 0; i < X_NUM_ANIMATION_CHANNELS; ++i) {
-		_channels[i] = new AnimationChannel(_gameRef, this);
+		_channels[i] = new AnimationChannel(_game, this);
 	}
 
 	setFilename(filename.c_str());
@@ -178,7 +178,7 @@ bool XModel::mergeFromFile(const Common::String &filename) {
 		return false;
 	}
 
-	XFile *xfile = new XFile(_gameRef);
+	XFile *xfile = new XFile(_game);
 	if (!xfile)
 		return false;
 
@@ -233,7 +233,7 @@ bool XModel::loadAnimationSet(const Common::String &filename, XFileData *xobj) {
 	bool res = true;
 
 	// create the animation set object
-	AnimationSet *animSet = new AnimationSet(_gameRef, this);
+	AnimationSet *animSet = new AnimationSet(_game, this);
 	res = loadName(animSet, xobj);
 	if (!res) {
 		SAFE_DELETE(animSet);
@@ -253,7 +253,7 @@ bool XModel::loadAnimationSet(const Common::String &filename, XFileData *xobj) {
 	xobj->getChildren(numChildren);
 
 	for (uint32 i = 0; i < numChildren; i++) {
-		_gameRef->miniUpdate();
+		_game->miniUpdate();
 
 		res = xobj->getChild(i, xchildData);
 		if (res) {
@@ -284,7 +284,7 @@ bool XModel::loadAnimation(const Common::String &filename, XFileData *xobj, Anim
 	// if no parent anim set is specified, create one
 	bool newAnimSet = false;
 	if (parentAnimSet == nullptr) {
-		parentAnimSet = new AnimationSet(_gameRef, this);
+		parentAnimSet = new AnimationSet(_game, this);
 
 		parentAnimSet->setName(PathUtil::getFileName(filename).c_str());
 
@@ -292,7 +292,7 @@ bool XModel::loadAnimation(const Common::String &filename, XFileData *xobj, Anim
 	}
 
 	// create the new object
-	Animation *anim = new Animation(_gameRef);
+	Animation *anim = new Animation(_game);
 
 	// load the animation
 	uint32 numChildren = 0;
@@ -468,7 +468,7 @@ bool XModel::updateShadowVol(ShadowVolume *shadow, DXMatrix *modelMat, DXVector3
 
 //////////////////////////////////////////////////////////////////////////
 bool XModel::render() {
-	BaseRenderer3D *renderer = _gameRef->_renderer3D;
+	BaseRenderer3D *renderer = _game->_renderer3D;
 
 	if (_rootFrame) {
 		// set culling
@@ -488,7 +488,7 @@ bool XModel::render() {
 
 		// remember scene offset
 		Common::Rect32 rc;
-		_gameRef->getCurrentViewportRect(&rc);
+		_game->getCurrentViewportRect(&rc);
 		float width = (float)rc.right - (float)rc.left;
 		float height = (float)rc.bottom - (float)rc.top;
 
@@ -498,8 +498,8 @@ bool XModel::render() {
 		int mtop = rc.top;
 		int mbottom = renderer->getHeight() - height - rc.top;
 
-		_lastOffsetX = _gameRef->_offsetX + (mleft - mright) / 2;
-		_lastOffsetY = _gameRef->_offsetY + (mtop - mbottom) / 2;
+		_lastOffsetX = _game->_offsetX + (mleft - mright) / 2;
+		_lastOffsetY = _game->_offsetY + (mtop - mbottom) / 2;
 
 		// update bounding box and 2D bounding rectangle
 		updateBoundingRect();
@@ -513,9 +513,9 @@ bool XModel::render() {
 bool XModel::renderFlatShadowModel(uint32 shadowColor) {
 	if (_rootFrame) {
 		if(_owner && !_owner->_drawBackfaces) {
-			_gameRef->_renderer3D->enableCulling();
+			_game->_renderer3D->enableCulling();
 		} else {
-			_gameRef->_renderer3D->disableCulling();
+			_game->_renderer3D->disableCulling();
 		}
 
 		return _rootFrame->renderFlatShadowModel(shadowColor);
@@ -549,15 +549,15 @@ bool XModel::isTransparentAt(int x, int y) {
 	x += _lastOffsetX;
 	y += _lastOffsetY;
 
-	BaseRenderer3D *renderer = _gameRef->_renderer3D;
-	if (!_gameRef->_renderer3D->_camera)
+	BaseRenderer3D *renderer = _game->_renderer3D;
+	if (!_game->_renderer3D->_camera)
 		return true;
 
 	float resWidth, resHeight;
 	float layerWidth, layerHeight;
 	float modWidth, modHeight;
 	bool customViewport;
-	_gameRef->_renderer3D->getProjectionParams(&resWidth, &resHeight, &layerWidth, &layerHeight, &modWidth, &modHeight, &customViewport);
+	_game->_renderer3D->getProjectionParams(&resWidth, &resHeight, &layerWidth, &layerHeight, &modWidth, &modHeight, &customViewport);
 
 	x -= _drawingViewport._x + modWidth;
 	y -= _drawingViewport._y + modHeight;
@@ -609,7 +609,7 @@ void XModel::updateBoundingRect() {
 	_boundingRect.left = _boundingRect.top = INT_MAX_VALUE;
 	_boundingRect.right = _boundingRect.bottom = INT_MIN_VALUE;
 
-	BaseRenderer3D *renderer = _gameRef->_renderer3D;
+	BaseRenderer3D *renderer = _game->_renderer3D;
 
 	DXMatrix viewMat, projMat, worldMat;
 	DXVector3 vec2d(0, 0, 0);
@@ -706,7 +706,7 @@ bool XModel::parseAnim(char *buffer) {
 
 			AnimationSet *anim = getAnimationSetByName(name);
 			if (!anim) {
-				_gameRef->LOG(0, "Error: Animation '%s' cannot be found in the model.", name);
+				_game->LOG(0, "Error: Animation '%s' cannot be found in the model.", name);
 			}
 			break;
 		}
@@ -718,7 +718,7 @@ bool XModel::parseAnim(char *buffer) {
 
 		case TOKEN_EVENT:
 			if (!name) {
-				_gameRef->LOG(0, "Error: NAME filed must precede any EVENT fields in actor definition files.");
+				_game->LOG(0, "Error: NAME filed must precede any EVENT fields in actor definition files.");
 			} else {
 				AnimationSet *anim = getAnimationSetByName(name);
 				if (anim)
@@ -799,7 +799,7 @@ bool XModel::setMaterialSprite(const char *materialName, const char *spriteFilen
 		return false;
 	}
 
-	BaseSprite *sprite = new BaseSprite(_gameRef);
+	BaseSprite *sprite = new BaseSprite(_game);
 	if (!sprite || !sprite->loadFile(spriteFilename)) {
 		SAFE_DELETE(sprite);
 		return false;
@@ -834,7 +834,7 @@ bool XModel::setMaterialTheora(const char *materialName, const char *theoraFilen
 		return false;
 	}
 
-	VideoTheoraPlayer *theora = new VideoTheoraPlayer(_gameRef);
+	VideoTheoraPlayer *theora = new VideoTheoraPlayer(_game);
 	if (!theora || theora->initialize(theoraFilename)) {
 		SAFE_DELETE(theora);
 		return false;
@@ -869,7 +869,7 @@ bool XModel::setMaterialEffect(const char *materialName, const char *effectFilen
 		return false;
 
 
-	Effect3D *effect = new Effect3D(_gameRef);
+	Effect3D *effect = new Effect3D(_game);
 	if (!effect->createFromFile(effectFilename)) {
 		SAFE_DELETE(effect);
 		return false;
@@ -966,7 +966,7 @@ bool XModel::initializeSimple() {
 		}
 
 		if (_matSprites[i]->_effectFile) {
-			Effect3D *effect = new Effect3D(_gameRef);
+			Effect3D *effect = new Effect3D(_game);
 			if (effect->createFromFile(_matSprites[i]->_effectFile)) {
 				_matSprites[i]->_effect = effect;
 				_rootFrame->setMaterialEffect(_matSprites[i]->_matName, _matSprites[i]->_effect, _matSprites[i]->_effectParams);
@@ -1043,7 +1043,7 @@ bool XModel::persist(BasePersistenceManager *persistMgr) {
 			persistMgr->transferCharPtr(TMEMBER(animName));
 			AnimationSet *animSet = getAnimationSetByName(animName);
 			if (!animSet) {
-				animSet = new AnimationSet(_gameRef, this);
+				animSet = new AnimationSet(_game, this);
 				needsDelete = true;
 			}
 
diff --git a/engines/wintermute/base/particles/part_emitter.cpp b/engines/wintermute/base/particles/part_emitter.cpp
index a9006f3bb51..73eeb1f58dc 100644
--- a/engines/wintermute/base/particles/part_emitter.cpp
+++ b/engines/wintermute/base/particles/part_emitter.cpp
@@ -294,7 +294,7 @@ bool PartEmitter::updateInternal(uint32 currentTime, uint32 timerDelta) {
 				if (firstDeadIndex >= 0) {
 					particle = _particles[firstDeadIndex];
 				} else {
-					particle = new PartParticle(_gameRef);
+					particle = new PartParticle(_game);
 					_particles.add(particle);
 				}
 				initParticle(particle, currentTime, timerDelta);
@@ -415,7 +415,7 @@ PartForce *PartEmitter::addForceByName(const Common::String &name) {
 		}
 	}
 	if (!force) {
-		force = new PartForce(_gameRef);
+		force = new PartForce(_game);
 		if (force) {
 			force->setName(name.c_str());
 			_forces.add(force);
@@ -1231,7 +1231,7 @@ bool PartEmitter::persist(BasePersistenceManager *persistMgr) {
 	} else {
 		persistMgr->transferUint32(TMEMBER(numForces));
 		for (uint32 i = 0; i < numForces; i++) {
-			PartForce *force = new PartForce(_gameRef);
+			PartForce *force = new PartForce(_game);
 			force->persist(persistMgr);
 			_forces.add(force);
 		}
@@ -1247,7 +1247,7 @@ bool PartEmitter::persist(BasePersistenceManager *persistMgr) {
 	} else {
 		persistMgr->transferUint32(TMEMBER(numParticles));
 		for (uint32 i = 0; i < numParticles; i++) {
-			PartParticle *particle = new PartParticle(_gameRef);
+			PartParticle *particle = new PartParticle(_game);
 			particle->persist(persistMgr);
 			_particles.add(particle);
 		}
diff --git a/engines/wintermute/base/particles/part_particle.cpp b/engines/wintermute/base/particles/part_particle.cpp
index ed304e82e7e..f9cb947da5b 100644
--- a/engines/wintermute/base/particles/part_particle.cpp
+++ b/engines/wintermute/base/particles/part_particle.cpp
@@ -78,7 +78,7 @@ bool PartParticle::setSprite(const Common::String &filename) {
 	SAFE_DELETE(_sprite);
 
 	SystemClassRegistry::getInstance()->_disabled = true;
-	_sprite = new BaseSprite(_gameRef, (BaseObject*)_gameRef);
+	_sprite = new BaseSprite(_game, (BaseObject*)_game);
 	if (_sprite && DID_SUCCEED(_sprite->loadFile(filename))) {
 		SystemClassRegistry::getInstance()->_disabled = false;
 		return STATUS_OK;
diff --git a/engines/wintermute/base/scriptables/debuggable/debuggable_script.cpp b/engines/wintermute/base/scriptables/debuggable/debuggable_script.cpp
index bfe59209688..71dcdbd791d 100644
--- a/engines/wintermute/base/scriptables/debuggable/debuggable_script.cpp
+++ b/engines/wintermute/base/scriptables/debuggable/debuggable_script.cpp
@@ -94,7 +94,7 @@ ScValue *DebuggableScript::resolveName(const Common::String &name) {
 	cstr[255] = '\0'; // We 0-terminate it just in case it's > 256 chars.
 
 	ScValue *value = getVar(cstr);
-	ScValue *res = new ScValue(_gameRef);
+	ScValue *res = new ScValue(_game);
 
 	if (value == nullptr) {
 		return res;
diff --git a/engines/wintermute/base/scriptables/script.cpp b/engines/wintermute/base/scriptables/script.cpp
index 6c12375ea49..eaea1254a26 100644
--- a/engines/wintermute/base/scriptables/script.cpp
+++ b/engines/wintermute/base/scriptables/script.cpp
@@ -144,13 +144,13 @@ bool ScScript::initScript() {
 	readHeader();
 
 	if (_header.magic != SCRIPT_MAGIC) {
-		_gameRef->LOG(0, "File '%s' is not a valid compiled script", _filename);
+		_game->LOG(0, "File '%s' is not a valid compiled script", _filename);
 		cleanup();
 		return STATUS_FAILED;
 	}
 
 	if (_header.version > SCRIPT_VERSION) {
-		_gameRef->LOG(0, "Script '%s' has a wrong version %d.%d (expected %d.%d)", _filename, _header.version / 256, _header.version % 256, SCRIPT_VERSION / 256, SCRIPT_VERSION % 256);
+		_game->LOG(0, "Script '%s' has a wrong version %d.%d (expected %d.%d)", _filename, _header.version / 256, _header.version % 256, SCRIPT_VERSION / 256, SCRIPT_VERSION % 256);
 		cleanup();
 		return STATUS_FAILED;
 	}
@@ -158,13 +158,13 @@ bool ScScript::initScript() {
 	initTables();
 
 	// init stacks
-	_scopeStack = new ScStack(_gameRef);
-	_callStack  = new ScStack(_gameRef);
-	_thisStack  = new ScStack(_gameRef);
-	_stack      = new ScStack(_gameRef);
+	_scopeStack = new ScStack(_game);
+	_callStack  = new ScStack(_game);
+	_thisStack  = new ScStack(_game);
+	_stack      = new ScStack(_game);
 
-	_operand    = new ScValue(_gameRef);
-	_reg1       = new ScValue(_gameRef);
+	_operand    = new ScValue(_game);
+	_reg1       = new ScValue(_game);
 
 
 	// skip to the beginning
@@ -281,7 +281,7 @@ bool ScScript::create(const char *filename, byte *buffer, uint32 size, BaseScrip
 	}
 
 	// establish global variables table
-	_globals = new ScValue(_gameRef);
+	_globals = new ScValue(_game);
 
 	_owner = owner;
 
@@ -534,7 +534,7 @@ bool ScScript::executeInstruction() {
 	uint32 dw;
 	const char *str = nullptr;
 
-	//ScValue* op = new ScValue(_gameRef);
+	//ScValue* op = new ScValue(_game);
 	_operand->cleanup();
 
 	ScValue *op1;
@@ -659,7 +659,7 @@ bool ScScript::executeInstruction() {
 #ifdef ENABLE_FOXTAIL
 				} else if (BaseEngine::instance().isFoxTail() && strcmp(methodName, "LoadItems") == 0 && strcmp(_threadEvent,"AfterLoad") == 0) {
 					_stack->correctParams(0);
-					_gameRef->LOG(0, "Method '%s' is called in unbreakable mode of '%s' event and was ignored", methodName, _threadEvent);
+					_game->LOG(0, "Method '%s' is called in unbreakable mode of '%s' event and was ignored", methodName, _threadEvent);
 					_stack->pushNULL();
 #endif
 				} else {
@@ -682,7 +682,7 @@ bool ScScript::executeInstruction() {
 			        }
 			        else{
 			            // not an internal nor external, try for native function
-			            _gameRef->ExternalCall(this, _stack, _thisStack, val->getString());
+			            _game->ExternalCall(this, _stack, _thisStack, val->getString());
 			        }
 			    }
 			    else{
@@ -716,7 +716,7 @@ bool ScScript::executeInstruction() {
 		if (f) {
 			externalCall(_stack, _thisStack, f);
 		} else {
-			_gameRef->externalCall(this, _stack, _thisStack, _symbols[symbolIndex]);
+			_game->externalCall(this, _stack, _thisStack, _symbols[symbolIndex]);
 		}
 
 		break;
@@ -1136,7 +1136,7 @@ bool ScScript::executeInstruction() {
 
 	}
 	default:
-		_gameRef->LOG(0, "Fatal: Invalid instruction %d ('%s', line %d, IP:0x%lx)\n", inst, _filename, _currentLine, _iP - sizeof(uint32));
+		_game->LOG(0, "Fatal: Invalid instruction %d ('%s', line %d, IP:0x%lx)\n", inst, _filename, _currentLine, _iP - sizeof(uint32));
 		_state = SCRIPT_FINISHED;
 		ret = STATUS_FAILED;
 	} // switch(instruction)
@@ -1197,8 +1197,8 @@ ScValue *ScScript::getVar(char *name) {
 
 	if (ret == nullptr) {
 		//RuntimeError("Variable '%s' is inaccessible in the current block. Consider changing the script.", name);
-		_gameRef->LOG(0, "Warning: variable '%s' is inaccessible in the current block. Consider changing the script (script:%s, line:%d)", name, _filename, _currentLine);
-		ScValue *val = new ScValue(_gameRef);
+		_game->LOG(0, "Warning: variable '%s' is inaccessible in the current block. Consider changing the script (script:%s, line:%d)", name, _filename, _currentLine);
+		ScValue *val = new ScValue(_game);
 		ScValue *scope = _scopeStack->getTop();
 		if (scope) {
 			scope->setProp(name, val);
@@ -1242,11 +1242,11 @@ bool ScScript::sleep(uint32 duration) {
 	}
 
 	_state = SCRIPT_SLEEPING;
-	if (_gameRef->_state == GAME_FROZEN) {
+	if (_game->_state == GAME_FROZEN) {
 		_waitTime = g_system->getMillis() + duration;
 		_waitFrozen = true;
 	} else {
-		_waitTime = _gameRef->getTimer()->getTime() + duration;
+		_waitTime = _game->getTimer()->getTime() + duration;
 		_waitFrozen = false;
 	}
 	return STATUS_OK;
@@ -1286,8 +1286,8 @@ void ScScript::runtimeError(const char *fmt, ...) {
 	warning("Runtime error. Script '%s', line %d", _filename, _currentLine);
 	warning("  %s", buff);
 
-	if (!_gameRef->_suppressScriptErrors) {
-		_gameRef->quickMessage("Script runtime error. View log for details.");
+	if (!_game->_suppressScriptErrors) {
+		_game->quickMessage("Script runtime error. View log for details.");
 	}
 }
 
@@ -1295,7 +1295,7 @@ void ScScript::runtimeError(const char *fmt, ...) {
 //////////////////////////////////////////////////////////////////////////
 bool ScScript::persist(BasePersistenceManager *persistMgr) {
 
-	persistMgr->transferPtr(TMEMBER_PTR(_gameRef));
+	persistMgr->transferPtr(TMEMBER_PTR(_game));
 
 	// buffer
 	if (persistMgr->getIsSaving()) {
@@ -1370,7 +1370,7 @@ void ScScript::afterLoad() {
 	if (_buffer == nullptr) {
 		byte *buffer = _engine->getCompiledScript(_filename, &_bufferSize);
 		if (!buffer) {
-			_gameRef->LOG(0, "Error reinitializing script '%s' after load. Script will be terminated.", _filename);
+			_game->LOG(0, "Error reinitializing script '%s' after load. Script will be terminated.", _filename);
 			_state = SCRIPT_ERROR;
 			return;
 		}
@@ -1399,9 +1399,9 @@ ScScript *ScScript::invokeEventHandler(const Common::String &eventName, bool unb
 	DebuggableScEngine* debuggableEngine;
 	debuggableEngine = dynamic_cast<DebuggableScEngine*>(_engine);
 	assert(debuggableEngine);
-	ScScript *thread = new DebuggableScript(_gameRef,  debuggableEngine);
+	ScScript *thread = new DebuggableScript(_game,  debuggableEngine);
 #else
-	ScScript *thread = new ScScript(_gameRef,  _engine);
+	ScScript *thread = new ScScript(_game,  _engine);
 #endif
 	if (thread) {
 		bool ret = thread->createThread(this, pos, eventName);
@@ -1446,7 +1446,7 @@ bool ScScript::canHandleMethod(const Common::String &methodName) const {
 //////////////////////////////////////////////////////////////////////////
 bool ScScript::pause() {
 	if (_state == SCRIPT_PAUSED) {
-		_gameRef->LOG(0, "Attempting to pause a paused script ('%s', line %d)", _filename, _currentLine);
+		_game->LOG(0, "Attempting to pause a paused script ('%s', line %d)", _filename, _currentLine);
 		return STATUS_FAILED;
 	}
 
@@ -1486,7 +1486,7 @@ bool ScScript::externalCall(ScStack *stack, ScStack *thisStack, ScScript::TExter
 	//////////////////////////////////////////////////////////////////////////
 	// Externals: emulate external functions used in known games
 	//////////////////////////////////////////////////////////////////////////
-	if (!DID_FAIL(EmulateExternalCall(_gameRef, stack, thisStack, function))) {
+	if (!DID_FAIL(EmulateExternalCall(_game, stack, thisStack, function))) {
 		return STATUS_OK;
 	}
 
diff --git a/engines/wintermute/base/scriptables/script_engine.cpp b/engines/wintermute/base/scriptables/script_engine.cpp
index 82013916514..f218f841748 100644
--- a/engines/wintermute/base/scriptables/script_engine.cpp
+++ b/engines/wintermute/base/scriptables/script_engine.cpp
@@ -42,35 +42,35 @@ IMPLEMENT_PERSISTENT(ScEngine, true)
 #define COMPILER_DLL "dcscomp.dll"
 //////////////////////////////////////////////////////////////////////////
 ScEngine::ScEngine(BaseGame *inGame) : BaseClass(inGame) {
-	_gameRef->LOG(0, "Initializing scripting engine...");
+	_game->LOG(0, "Initializing scripting engine...");
 
 	if (_compilerAvailable) {
-		_gameRef->LOG(0, "  Script compiler bound successfuly");
+		_game->LOG(0, "  Script compiler bound successfuly");
 	} else {
-		_gameRef->LOG(0, "  Script compiler is NOT available");
+		_game->LOG(0, "  Script compiler is NOT available");
 	}
 
-	_globals = new ScValue(_gameRef);
+	_globals = new ScValue(_game);
 
 
 	// register 'Game' as global variable
 	if (!_globals->propExists("Game")) {
-		ScValue val(_gameRef);
-		val.setNative(_gameRef,  true);
+		ScValue val(_game);
+		val.setNative(_game,  true);
 		_globals->setProp("Game", &val);
 	}
 
 	// register 'Math' as global variable
 	if (!_globals->propExists("Math")) {
-		ScValue val(_gameRef);
-		val.setNative(_gameRef->_mathClass, true);
+		ScValue val(_game);
+		val.setNative(_game->_mathClass, true);
 		_globals->setProp("Math", &val);
 	}
 
 	// register 'Directory' as global variable
 	if (!_globals->propExists("Directory")) {
-		ScValue val(_gameRef);
-		val.setNative(_gameRef->_directoryClass, true);
+		ScValue val(_game);
+		val.setNative(_game->_directoryClass, true);
 		_globals->setProp("Directory", &val);
 	}
 
@@ -90,7 +90,7 @@ ScEngine::ScEngine(BaseGame *inGame) : BaseClass(inGame) {
 
 //////////////////////////////////////////////////////////////////////////
 ScEngine::~ScEngine() {
-	_gameRef->LOG(0, "Shutting down scripting engine");
+	_game->LOG(0, "Shutting down scripting engine");
 
 	disableProfiling();
 
@@ -155,18 +155,18 @@ ScScript *ScEngine::runScript(const char *filename, BaseScriptHolder *owner) {
 	debuggableEngine = dynamic_cast<DebuggableScEngine*>(this);
 	// TODO: Not pretty
 	assert(debuggableEngine);
-	ScScript *script = new DebuggableScript(_gameRef, debuggableEngine);
+	ScScript *script = new DebuggableScript(_game, debuggableEngine);
 #else
-	ScScript *script = new ScScript(_gameRef, this);
+	ScScript *script = new ScScript(_game, this);
 #endif
 	bool ret = script->create(filename, compBuffer, compSize, owner);
 	if (DID_FAIL(ret)) {
-		_gameRef->LOG(ret, "Error running script '%s'...", filename);
+		_game->LOG(ret, "Error running script '%s'...", filename);
 		delete script;
 		return nullptr;
 	} else {
 		// publish the "self" pseudo-variable
-		ScValue val(_gameRef);
+		ScValue val(_game);
 		if (owner) {
 			val.setNative(owner, true);
 		} else {
@@ -215,7 +215,7 @@ byte *ScEngine::getCompiledScript(const char *filename, uint32 *outSize, bool ig
 
 	byte *buffer = BaseEngine::instance().getFileManager()->readWholeFile(filename, &size);
 	if (!buffer) {
-		_gameRef->LOG(0, "ScEngine::GetCompiledScript - error opening script '%s'", filename);
+		_game->LOG(0, "ScEngine::GetCompiledScript - error opening script '%s'", filename);
 		return nullptr;
 	}
 
@@ -225,7 +225,7 @@ byte *ScEngine::getCompiledScript(const char *filename, uint32 *outSize, bool ig
 		compSize = size;
 	} else {
 		if (!_compilerAvailable) {
-			_gameRef->LOG(0, "ScEngine::GetCompiledScript - script '%s' needs to be compiled but compiler is not available", filename);
+			_game->LOG(0, "ScEngine::GetCompiledScript - script '%s' needs to be compiled but compiler is not available", filename);
 			delete[] buffer;
 			return nullptr;
 		}
@@ -283,18 +283,18 @@ bool ScEngine::tick() {
 		case SCRIPT_WAITING: {
 			/*
 			bool obj_found=false;
-			for(int j=0; j<_gameRef->_regObjects.size(); j++)
+			for(int j=0; j<_game->_regObjects.size(); j++)
 			{
-			    if (_gameRef->_regObjects[j] == _scripts[i]->_waitObject)
+			    if (_game->_regObjects[j] == _scripts[i]->_waitObject)
 			    {
-			        if (_gameRef->_regObjects[j]->IsReady()) _scripts[i]->Run();
+			        if (_game->_regObjects[j]->IsReady()) _scripts[i]->Run();
 			        obj_found = true;
 			        break;
 			    }
 			}
 			if (!obj_found) _scripts[i]->finish(); // _waitObject no longer exists
 			*/
-			if (_gameRef->validObject(_scripts[i]->_waitObject)) {
+			if (_game->validObject(_scripts[i]->_waitObject)) {
 				if (_scripts[i]->_waitObject->isReady()) {
 					_scripts[i]->run();
 				}
@@ -310,7 +310,7 @@ bool ScEngine::tick() {
 					_scripts[i]->run();
 				}
 			} else {
-				if (_scripts[i]->_waitTime <= _gameRef->getTimer()->getTime()) {
+				if (_scripts[i]->_waitTime <= _game->getTimer()->getTime()) {
 					_scripts[i]->run();
 				}
 			}
@@ -493,7 +493,7 @@ bool ScEngine::resetObject(BaseObject *Object) {
 	// terminate all scripts waiting for this object
 	for (int32 i = 0; i < _scripts.getSize(); i++) {
 		if (_scripts[i]->_state == SCRIPT_WAITING && _scripts[i]->_waitObject == Object) {
-			if (!_gameRef->_compatKillMethodThreads) {
+			if (!_game->_compatKillMethodThreads) {
 				resetScript(_scripts[i]);
 			}
 
@@ -521,7 +521,7 @@ bool ScEngine::persist(BasePersistenceManager *persistMgr) {
 		cleanup();
 	}
 
-	persistMgr->transferPtr(TMEMBER_PTR(_gameRef));
+	persistMgr->transferPtr(TMEMBER_PTR(_game));
 	persistMgr->transferPtr(TMEMBER_PTR(_currentScript));
 	persistMgr->transferPtr(TMEMBER_PTR(_globals));
 	_scripts.persist(persistMgr);
@@ -640,11 +640,11 @@ void ScEngine::dumpStats() {
 
 	    TimeVector::reverse_iterator tit;
 
-	    _gameRef->LOG(0, "***** Script profiling information: *****");
-	    _gameRef->LOG(0, "  %-40s %fs", "Total execution time", (float)totalTime / 1000);
+	    _game->LOG(0, "***** Script profiling information: *****");
+	    _game->LOG(0, "  %-40s %fs", "Total execution time", (float)totalTime / 1000);
 
 	    for (tit = times.rbegin(); tit != times.rend(); ++tit) {
-	        _gameRef->LOG(0, "  %-40s %fs (%f%%)", tit->second.c_str(), (float)tit->first / 1000, (float)tit->first / (float)totalTime * 100);
+	        _game->LOG(0, "  %-40s %fs (%f%%)", tit->second.c_str(), (float)tit->first / 1000, (float)tit->first / (float)totalTime * 100);
 	    }*/
 }
 
diff --git a/engines/wintermute/base/scriptables/script_ext_array.cpp b/engines/wintermute/base/scriptables/script_ext_array.cpp
index d760194279b..f93d42710d6 100644
--- a/engines/wintermute/base/scriptables/script_ext_array.cpp
+++ b/engines/wintermute/base/scriptables/script_ext_array.cpp
@@ -43,7 +43,7 @@ BaseScriptable *makeSXArray(BaseGame *inGame, ScStack *stack) {
 //////////////////////////////////////////////////////////////////////////
 SXArray::SXArray(BaseGame *inGame, ScStack *stack) : BaseScriptable(inGame) {
 	_length = 0;
-	_values = new ScValue(_gameRef);
+	_values = new ScValue(_game);
 
 	int numParams = stack->pop()->getInt(0);
 
@@ -62,7 +62,7 @@ SXArray::SXArray(BaseGame *inGame, ScStack *stack) : BaseScriptable(inGame) {
 //////////////////////////////////////////////////////////////////////////
 SXArray::SXArray(BaseGame *inGame) : BaseScriptable(inGame) {
 	_length = 0;
-	_values = new ScValue(_gameRef);
+	_values = new ScValue(_game);
 }
 
 
diff --git a/engines/wintermute/base/scriptables/script_ext_directory.cpp b/engines/wintermute/base/scriptables/script_ext_directory.cpp
index cc3d2cb5d96..00a74c3c0fe 100644
--- a/engines/wintermute/base/scriptables/script_ext_directory.cpp
+++ b/engines/wintermute/base/scriptables/script_ext_directory.cpp
@@ -103,7 +103,7 @@ bool SXDirectory::scCallMethod(ScScript *script, ScStack *stack, ScStack *thisSt
 		stack->pop()->getString();
 
 		stack->pushInt(0);
-		BaseScriptable *array = makeSXArray(_gameRef, stack);
+		BaseScriptable *array = makeSXArray(_game, stack);
 
 		if (strcmp(dirName, "saves") == 0 && strcmp(name, "GetFiles") == 0) {
 			// used in "Tale of The Lost Bride and A Hidden Treasure"
@@ -149,7 +149,7 @@ bool SXDirectory::scCallMethod(ScScript *script, ScStack *stack, ScStack *thisSt
 		warning("Directory.GetDrives is not implemented! Returning empty array...");
 
 		stack->pushInt(0);
- 		stack->pushNative(makeSXArray(_gameRef, stack), false);
+ 		stack->pushNative(makeSXArray(_game, stack), false);
  		return STATUS_OK;
 	} else {
 		return STATUS_FAILED;
diff --git a/engines/wintermute/base/scriptables/script_ext_mem_buffer.cpp b/engines/wintermute/base/scriptables/script_ext_mem_buffer.cpp
index 5e9803204d3..c4b054529c7 100644
--- a/engines/wintermute/base/scriptables/script_ext_mem_buffer.cpp
+++ b/engines/wintermute/base/scriptables/script_ext_mem_buffer.cpp
@@ -278,7 +278,7 @@ bool SXMemBuffer::scCallMethod(ScScript *script, ScStack *stack, ScStack *thisSt
 			stack->pushNULL();
 		} else {
 			void *pointer = *(void **)((byte *)_buffer + start);
-			SXMemBuffer *buf = new SXMemBuffer(_gameRef,  pointer);
+			SXMemBuffer *buf = new SXMemBuffer(_game,  pointer);
 			stack->pushNative(buf, false);
 		}
 		return STATUS_OK;
diff --git a/engines/wintermute/base/scriptables/script_ext_string.cpp b/engines/wintermute/base/scriptables/script_ext_string.cpp
index 32acfa274c1..d62b67086f9 100644
--- a/engines/wintermute/base/scriptables/script_ext_string.cpp
+++ b/engines/wintermute/base/scriptables/script_ext_string.cpp
@@ -120,7 +120,7 @@ bool SXString::scCallMethod(ScScript *script, ScStack *stack, ScStack *thisStack
 
 		//try {
 		WideString str;
-		if (_gameRef->_textEncoding == TEXT_UTF8) {
+		if (_game->_textEncoding == TEXT_UTF8) {
 			str = StringUtil::utf8ToWide(_string);
 		} else {
 			str = StringUtil::ansiToWide(_string);
@@ -128,7 +128,7 @@ bool SXString::scCallMethod(ScScript *script, ScStack *stack, ScStack *thisStack
 
 		WideString subStr = str.substr(start, end - start + 1);
 
-		if (_gameRef->_textEncoding == TEXT_UTF8) {
+		if (_game->_textEncoding == TEXT_UTF8) {
 			stack->pushString(StringUtil::wideToUtf8(subStr).c_str());
 		} else {
 			stack->pushString(StringUtil::wideToAnsi(subStr).c_str());
@@ -161,7 +161,7 @@ bool SXString::scCallMethod(ScScript *script, ScStack *stack, ScStack *thisStack
 
 //		try {
 		WideString str;
-		if (_gameRef->_textEncoding == TEXT_UTF8) {
+		if (_game->_textEncoding == TEXT_UTF8) {
 			str = StringUtil::utf8ToWide(_string);
 		} else {
 			str = StringUtil::ansiToWide(_string);
@@ -169,7 +169,7 @@ bool SXString::scCallMethod(ScScript *script, ScStack *stack, ScStack *thisStack
 
 		WideString subStr = str.substr(start, len);
 
-		if (_gameRef->_textEncoding == TEXT_UTF8) {
+		if (_game->_textEncoding == TEXT_UTF8) {
 			stack->pushString(StringUtil::wideToUtf8(subStr).c_str());
 		} else {
 			stack->pushString(StringUtil::wideToAnsi(subStr).c_str());
@@ -188,7 +188,7 @@ bool SXString::scCallMethod(ScScript *script, ScStack *stack, ScStack *thisStack
 		stack->correctParams(0);
 
 		WideString str;
-		if (_gameRef->_textEncoding == TEXT_UTF8) {
+		if (_game->_textEncoding == TEXT_UTF8) {
 			str = StringUtil::utf8ToWide(_string);
 		} else {
 			str = StringUtil::ansiToWide(_string);
@@ -196,7 +196,7 @@ bool SXString::scCallMethod(ScScript *script, ScStack *stack, ScStack *thisStack
 
 		str.toUppercase();
 
-		if (_gameRef->_textEncoding == TEXT_UTF8) {
+		if (_game->_textEncoding == TEXT_UTF8) {
 			stack->pushString(StringUtil::wideToUtf8(str).c_str());
 		} else {
 			stack->pushString(StringUtil::wideToAnsi(str).c_str());
@@ -212,7 +212,7 @@ bool SXString::scCallMethod(ScScript *script, ScStack *stack, ScStack *thisStack
 		stack->correctParams(0);
 
 		WideString str;
-		if (_gameRef->_textEncoding == TEXT_UTF8) {
+		if (_game->_textEncoding == TEXT_UTF8) {
 			str = StringUtil::utf8ToWide(_string);
 		} else {
 			str = StringUtil::ansiToWide(_string);
@@ -220,7 +220,7 @@ bool SXString::scCallMethod(ScScript *script, ScStack *stack, ScStack *thisStack
 
 		str.toLowercase();
 
-		if (_gameRef->_textEncoding == TEXT_UTF8) {
+		if (_game->_textEncoding == TEXT_UTF8) {
 			stack->pushString(StringUtil::wideToUtf8(str).c_str());
 		} else {
 			stack->pushString(StringUtil::wideToAnsi(str).c_str());
@@ -239,14 +239,14 @@ bool SXString::scCallMethod(ScScript *script, ScStack *stack, ScStack *thisStack
 		int index = stack->pop()->getInt();
 
 		WideString str;
-		if (_gameRef->_textEncoding == TEXT_UTF8) {
+		if (_game->_textEncoding == TEXT_UTF8) {
 			str = StringUtil::utf8ToWide(_string);
 		} else {
 			str = StringUtil::ansiToWide(_string);
 		}
 
 		WideString toFind;
-		if (_gameRef->_textEncoding == TEXT_UTF8) {
+		if (_game->_textEncoding == TEXT_UTF8) {
 			toFind = StringUtil::utf8ToWide(strToFind);
 		} else {
 			toFind = StringUtil::ansiToWide(strToFind);
@@ -289,7 +289,7 @@ bool SXString::scCallMethod(ScScript *script, ScStack *stack, ScStack *thisStack
 			Common::strlcpy(separators, val->getString(), MAX_PATH_LENGTH);
 		}
 
-		SXArray *array = new SXArray(_gameRef);
+		SXArray *array = new SXArray(_game);
 		if (!array) {
 			stack->pushNULL();
 			return STATUS_OK;
@@ -297,14 +297,14 @@ bool SXString::scCallMethod(ScScript *script, ScStack *stack, ScStack *thisStack
 
 
 		WideString str;
-		if (_gameRef->_textEncoding == TEXT_UTF8) {
+		if (_game->_textEncoding == TEXT_UTF8) {
 			str = StringUtil::utf8ToWide(_string);
 		} else {
 			str = StringUtil::ansiToWide(_string);
 		}
 
 		WideString delims;
-		if (_gameRef->_textEncoding == TEXT_UTF8) {
+		if (_game->_textEncoding == TEXT_UTF8) {
 			delims = StringUtil::utf8ToWide(separators);
 		} else {
 			delims = StringUtil::ansiToWide(separators);
@@ -330,10 +330,10 @@ bool SXString::scCallMethod(ScScript *script, ScStack *stack, ScStack *thisStack
 		for (Common::Array<WideString>::iterator it = parts.begin(); it != parts.end(); ++it) {
 			WideString &part = (*it);
 
-			if (_gameRef->_textEncoding == TEXT_UTF8) {
-				val = new ScValue(_gameRef,  StringUtil::wideToUtf8(part).c_str());
+			if (_game->_textEncoding == TEXT_UTF8) {
+				val = new ScValue(_game,  StringUtil::wideToUtf8(part).c_str());
 			} else {
-				val = new ScValue(_gameRef,  StringUtil::wideToAnsi(part).c_str());
+				val = new ScValue(_game,  StringUtil::wideToAnsi(part).c_str());
 			}
 
 			array->push(val);
@@ -364,7 +364,7 @@ ScValue *SXString::scGetProperty(const Common::String &name) {
 	// Length (RO)
 	//////////////////////////////////////////////////////////////////////////
 	else if (name == "Length") {
-		if (_gameRef->_textEncoding == TEXT_UTF8) {
+		if (_game->_textEncoding == TEXT_UTF8) {
 			WideString wstr = StringUtil::utf8ToWide(_string);
 			_scValue->setInt(wstr.size());
 		} else {
@@ -393,7 +393,7 @@ bool SXString::scSetProperty(const char *name, ScValue *value) {
 	if (strcmp(name, "Capacity") == 0) {
 		int32 newCap = (uint32)value->getInt();
 		if (newCap < (int32)(strlen(_string) + 1)) {
-			_gameRef->LOG(0, "Warning: cannot lower string capacity");
+			_game->LOG(0, "Warning: cannot lower string capacity");
 		} else if (newCap != _capacity) {
 			char *newStr = new char[newCap]();
 			if (newStr) {
diff --git a/engines/wintermute/base/scriptables/script_stack.cpp b/engines/wintermute/base/scriptables/script_stack.cpp
index 65bf3055779..d3d432c4e22 100644
--- a/engines/wintermute/base/scriptables/script_stack.cpp
+++ b/engines/wintermute/base/scriptables/script_stack.cpp
@@ -41,7 +41,7 @@ ScStack::ScStack(BaseGame *inGame) : BaseClass(inGame) {
 
 //////////////////////////////////////////////////////////////////////////
 ScStack::~ScStack() {
-	//_gameRef->LOG(0, "STAT: Stack size: %d, SP=%d", _values.size(), _sP);
+	//_game->LOG(0, "STAT: Stack size: %d, SP=%d", _values.size(), _sP);
 
 	for (int32 i = 0; i < _values.getSize(); i++) {
 		delete _values[i];
@@ -53,7 +53,7 @@ ScStack::~ScStack() {
 //////////////////////////////////////////////////////////////////////////
 ScValue *ScStack::pop() {
 	if (_sP < 0) {
-		_gameRef->LOG(0, "Fatal: Stack underflow");
+		_game->LOG(0, "Fatal: Stack underflow");
 		return nullptr;
 	}
 
@@ -69,7 +69,7 @@ void ScStack::push(ScValue *val) {
 		_values[_sP]->cleanup();
 		_values[_sP]->copy(val);
 	} else {
-		ScValue *copyVal = new ScValue(_gameRef);
+		ScValue *copyVal = new ScValue(_game);
 		copyVal->copy(val);
 		_values.add(copyVal);
 	}
@@ -81,7 +81,7 @@ ScValue *ScStack::getPushValue() {
 	_sP++;
 
 	if (_sP >= _values.getSize()) {
-		ScValue *val = new ScValue(_gameRef);
+		ScValue *val = new ScValue(_game);
 		_values.add(val);
 	}
 	_values[_sP]->cleanup();
@@ -126,7 +126,7 @@ void ScStack::correctParams(uint32 expectedParams) {
 	} else if (expectedParams > nuParams) { // need more params
 		while (expectedParams > nuParams) {
 			//Push(null_val);
-			ScValue *nullVal = new ScValue(_gameRef);
+			ScValue *nullVal = new ScValue(_game);
 			nullVal->setNULL();
 			_values.insertAt(_sP - nuParams + 1, nullVal);
 			nuParams++;
@@ -180,7 +180,7 @@ void ScStack::pushNative(BaseScriptable *val, bool persistent) {
 //////////////////////////////////////////////////////////////////////////
 bool ScStack::persist(BasePersistenceManager *persistMgr) {
 
-	persistMgr->transferPtr(TMEMBER_PTR(_gameRef));
+	persistMgr->transferPtr(TMEMBER_PTR(_game));
 
 	persistMgr->transferSint32(TMEMBER(_sP));
 	_values.persist(persistMgr);
diff --git a/engines/wintermute/base/scriptables/script_value.cpp b/engines/wintermute/base/scriptables/script_value.cpp
index 62b5a0220ea..7fe07d5f78e 100644
--- a/engines/wintermute/base/scriptables/script_value.cpp
+++ b/engines/wintermute/base/scriptables/script_value.cpp
@@ -161,16 +161,16 @@ ScValue *ScValue::getProp(const char *name) {
 	}
 
 	if (_type == VAL_STRING && strcmp(name, "Length") == 0) {
-		_gameRef->_scValue->_type = VAL_INT;
+		_game->_scValue->_type = VAL_INT;
 
-		if (_gameRef->_textEncoding == TEXT_ANSI) {
-			_gameRef->_scValue->setInt(strlen(_valString));
+		if (_game->_textEncoding == TEXT_ANSI) {
+			_game->_scValue->setInt(strlen(_valString));
 		} else {
 			WideString wstr = StringUtil::utf8ToWide(_valString);
-			_gameRef->_scValue->setInt(wstr.size());
+			_game->_scValue->setInt(wstr.size());
 		}
 
-		return _gameRef->_scValue;
+		return _game->_scValue;
 	}
 
 	ScValue *ret = nullptr;
@@ -224,7 +224,7 @@ bool ScValue::setProp(const char *name, ScValue *val, bool copyWhole, bool setAs
 			newVal = _valIter->_value;
 		}
 		if (!newVal) {
-			newVal = new ScValue(_gameRef);
+			newVal = new ScValue(_game);
 		} else {
 			newVal->cleanup();
 		}
@@ -243,7 +243,7 @@ bool ScValue::setProp(const char *name, ScValue *val, bool copyWhole, bool setAs
 		    delete _valIter->_value;
 		    _valIter->_value = nullptr;
 		}
-		ScValue* val = new ScValue(_gameRef);
+		ScValue* val = new ScValue(_game);
 		val->Copy(Val, CopyWhole);
 		val->_isConstVar = SetAsConst;
 		_valObject[Name] = val;
@@ -699,7 +699,7 @@ TValType ScValue::getType() {
 
 //////////////////////////////////////////////////////////////////////////
 void ScValue::copy(ScValue *orig, bool copyWhole) {
-	_gameRef = orig->_gameRef;
+	_game = orig->_game;
 
 	if (_valNative && !_persistent) {
 		_valNative->_refCount--;
@@ -736,7 +736,7 @@ void ScValue::copy(ScValue *orig, bool copyWhole) {
 	if (orig->_type == VAL_OBJECT && orig->_valObject.size() > 0) {
 		orig->_valIter = orig->_valObject.begin();
 		while (orig->_valIter != orig->_valObject.end()) {
-			_valObject[orig->_valIter->_key] = new ScValue(_gameRef);
+			_valObject[orig->_valIter->_key] = new ScValue(_game);
 			_valObject[orig->_valIter->_key]->copy(orig->_valIter->_value);
 			orig->_valIter++;
 		}
@@ -782,7 +782,7 @@ void ScValue::setValue(ScValue *val) {
 
 //////////////////////////////////////////////////////////////////////////
 bool ScValue::persist(BasePersistenceManager *persistMgr) {
-	persistMgr->transferPtr(TMEMBER_PTR(_gameRef));
+	persistMgr->transferPtr(TMEMBER_PTR(_game));
 
 	persistMgr->transferBool(TMEMBER(_persistent));
 	persistMgr->transferBool(TMEMBER(_isConstVar));
@@ -976,7 +976,7 @@ int ScValue::compareStrict(ScValue *val1, ScValue *val2, bool enableFloatCompare
 
 //////////////////////////////////////////////////////////////////////////
 bool ScValue::setProperty(const char *propName, int32 value) {
-	ScValue *val = new ScValue(_gameRef,  value);
+	ScValue *val = new ScValue(_game,  value);
 	bool ret =  DID_SUCCEED(setProp(propName, val));
 	delete val;
 	return ret;
@@ -984,7 +984,7 @@ bool ScValue::setProperty(const char *propName, int32 value) {
 
 //////////////////////////////////////////////////////////////////////////
 bool ScValue::setProperty(const char *propName, const char *value) {
-	ScValue *val = new ScValue(_gameRef,  value);
+	ScValue *val = new ScValue(_game,  value);
 	bool ret =  DID_SUCCEED(setProp(propName, val));
 	delete val;
 	return ret;
@@ -992,7 +992,7 @@ bool ScValue::setProperty(const char *propName, const char *value) {
 
 //////////////////////////////////////////////////////////////////////////
 bool ScValue::setProperty(const char *propName, double value) {
-	ScValue *val = new ScValue(_gameRef,  value);
+	ScValue *val = new ScValue(_game,  value);
 	bool ret =  DID_SUCCEED(setProp(propName, val));
 	delete val;
 	return ret;
@@ -1001,7 +1001,7 @@ bool ScValue::setProperty(const char *propName, double value) {
 
 //////////////////////////////////////////////////////////////////////////
 bool ScValue::setProperty(const char *propName, bool value) {
-	ScValue *val = new ScValue(_gameRef,  value);
+	ScValue *val = new ScValue(_game,  value);
 	bool ret =  DID_SUCCEED(setProp(propName, val));
 	delete val;
 	return ret;
@@ -1010,7 +1010,7 @@ bool ScValue::setProperty(const char *propName, bool value) {
 
 //////////////////////////////////////////////////////////////////////////
 bool ScValue::setProperty(const char *propName) {
-	ScValue *val = new ScValue(_gameRef);
+	ScValue *val = new ScValue(_game);
 	bool ret =  DID_SUCCEED(setProp(propName, val));
 	delete val;
 	return ret;
diff --git a/engines/wintermute/base/sound/base_sound.cpp b/engines/wintermute/base/sound/base_sound.cpp
index c4b866efbf2..9d39f26ca99 100644
--- a/engines/wintermute/base/sound/base_sound.cpp
+++ b/engines/wintermute/base/sound/base_sound.cpp
@@ -56,7 +56,7 @@ BaseSound::BaseSound(BaseGame *inGame) : BaseClass(inGame) {
 //////////////////////////////////////////////////////////////////////////
 BaseSound::~BaseSound() {
 	if (_sound) {
-		_gameRef->_soundMgr->removeSound(_sound);
+		_game->_soundMgr->removeSound(_sound);
 	}
 	_sound = nullptr;
 }
@@ -64,12 +64,12 @@ BaseSound::~BaseSound() {
 //////////////////////////////////////////////////////////////////////////
 bool BaseSound::setSound(const Common::String &filename, Audio::Mixer::SoundType type, bool streamed) {
 	if (_sound) {
-		_gameRef->_soundMgr->removeSound(_sound);
+		_game->_soundMgr->removeSound(_sound);
 		_sound = nullptr;
 	}
 	_soundFilename = Common::String(); // Set empty
 
-	_sound = _gameRef->_soundMgr->addSound(filename, type, streamed);
+	_sound = _game->_soundMgr->addSound(filename, type, streamed);
 	if (_sound) {
 		_soundFilename = filename;
 
@@ -84,7 +84,7 @@ bool BaseSound::setSound(const Common::String &filename, Audio::Mixer::SoundType
 
 //////////////////////////////////////////////////////////////////////////
 bool BaseSound::setSoundSimple() {
-	_sound = _gameRef->_soundMgr->addSound(_soundFilename, _soundType, _soundStreamed);
+	_sound = _game->_soundMgr->addSound(_soundFilename, _soundType, _soundStreamed);
 	if (_sound) {
 		if (_soundPosition) {
 			_sound->setPosition(_soundPosition);
@@ -173,7 +173,7 @@ bool BaseSound::persist(BasePersistenceManager *persistMgr) {
 		_sFXParam1 = _sFXParam2 = _sFXParam3 = _sFXParam4 = 0;
 	}
 
-	persistMgr->transferPtr(TMEMBER_PTR(_gameRef));
+	persistMgr->transferPtr(TMEMBER_PTR(_game));
 
 	persistMgr->transferString(TMEMBER(_soundFilename));
 	persistMgr->transferBool(TMEMBER(_soundLooping));
diff --git a/engines/wintermute/base/sound/base_sound_buffer.cpp b/engines/wintermute/base/sound/base_sound_buffer.cpp
index 53a1839de5f..70d782da0d5 100644
--- a/engines/wintermute/base/sound/base_sound_buffer.cpp
+++ b/engines/wintermute/base/sound/base_sound_buffer.cpp
@@ -97,7 +97,7 @@ bool BaseSoundBuffer::loadFromFile(const Common::String &filename, bool forceRel
 	// Load a file, but avoid having the File-manager handle the disposal of it.
 	Common::SeekableReadStream *file = BaseFileManager::getEngineInstance()->openFile(filename, true, false);
 	if (!file) {
-		_gameRef->LOG(0, "Error opening sound file '%s'", filename.c_str());
+		_game->LOG(0, "Error opening sound file '%s'", filename.c_str());
 		return STATUS_FAILED;
 	}
 	Common::String strFilename(filename);
@@ -224,7 +224,7 @@ void BaseSoundBuffer::updateVolume() {
 
 //////////////////////////////////////////////////////////////////////////
 bool BaseSoundBuffer::setVolume(int volume) {
-	_volume = volume * _gameRef->_soundMgr->getMasterVolume() / 255;
+	_volume = volume * _game->_soundMgr->getMasterVolume() / 255;
 	if (_stream && _handle) {
 		byte vol = (byte)(_volume);
 		g_system->getMixer()->setChannelVolume(*_handle, vol);
diff --git a/engines/wintermute/base/sound/base_sound_manager.cpp b/engines/wintermute/base/sound/base_sound_manager.cpp
index 8f065f61cef..7167340ba83 100644
--- a/engines/wintermute/base/sound/base_sound_manager.cpp
+++ b/engines/wintermute/base/sound/base_sound_manager.cpp
@@ -115,7 +115,7 @@ BaseSoundBuffer *BaseSoundMgr::addSound(const Common::String &filename, Audio::M
 		}
 	}
 
-	sound = new BaseSoundBuffer(_gameRef);
+	sound = new BaseSoundBuffer(_game);
 	if (!sound) {
 		return nullptr;
 	}
diff --git a/engines/wintermute/debugger/watch_instance.cpp b/engines/wintermute/debugger/watch_instance.cpp
index 7a83e1360d5..552191ebdda 100644
--- a/engines/wintermute/debugger/watch_instance.cpp
+++ b/engines/wintermute/debugger/watch_instance.cpp
@@ -34,7 +34,7 @@ void WatchInstance::evaluate() {
 		if (!_watch->getFilename().compareTo(_script->_filename)) {
 
 			if(_lastValue == nullptr) {
-				_lastValue = new ScValue(_script->_gameRef);
+				_lastValue = new ScValue(_script->_game);
 				// ^^ This here is NULL by default
 			}
 			ScValue* currentValue = _script->resolveName(_watch->getSymbol());
diff --git a/engines/wintermute/ext/wme_3fstatistics.cpp b/engines/wintermute/ext/wme_3fstatistics.cpp
index 0588e18f516..442a9121f79 100644
--- a/engines/wintermute/ext/wme_3fstatistics.cpp
+++ b/engines/wintermute/ext/wme_3fstatistics.cpp
@@ -56,7 +56,7 @@ SX3fStatistics::SX3fStatistics(BaseGame *inGame, ScStack *stack) : BaseScriptabl
 
 	_repeat = 0;
 
-	_gameRef->LOG(0, "new Statistics(\"%s\", \"%s\", \"%s\", \"%s\")", _baseUrl.c_str(), _chapter.c_str(), _language.c_str(), _buildNum.c_str());
+	_game->LOG(0, "new Statistics(\"%s\", \"%s\", \"%s\", \"%s\")", _baseUrl.c_str(), _chapter.c_str(), _language.c_str(), _buildNum.c_str());
 }
 
 //////////////////////////////////////////////////////////////////////////
@@ -102,7 +102,7 @@ bool SX3fStatistics::scCallMethod(ScScript *script, ScStack *stack, ScStack *thi
 	if (strcmp(name, "Send") == 0) {
 		stack->correctParams(1);
 		const char *message = stack->pop()->getString();
-		_gameRef->LOG(0, "Send(\"%s\")", message);
+		_game->LOG(0, "Send(\"%s\")", message);
 
 		// do nothing
 
diff --git a/engines/wintermute/ext/wme_blackandwhite.cpp b/engines/wintermute/ext/wme_blackandwhite.cpp
index 506b6a1a40d..0f44c1cd7f4 100644
--- a/engines/wintermute/ext/wme_blackandwhite.cpp
+++ b/engines/wintermute/ext/wme_blackandwhite.cpp
@@ -83,7 +83,7 @@ bool SXBlackAndWhite::scCallMethod(ScScript *script, ScStack *stack, ScStack *th
 		stack->correctParams(0);
 
 		_postFilterMode = kPostFilterSepia;
-		_gameRef->_renderer3D->setPostfilter(_postFilterMode);
+		_game->_renderer3D->setPostfilter(_postFilterMode);
 
 		stack->pushBool(true);
 		return STATUS_OK;
@@ -96,7 +96,7 @@ bool SXBlackAndWhite::scCallMethod(ScScript *script, ScStack *stack, ScStack *th
 		stack->correctParams(0);
 
 		_postFilterMode = kPostFilterBlackAndWhite;
-		_gameRef->_renderer3D->setPostfilter(_postFilterMode);
+		_game->_renderer3D->setPostfilter(_postFilterMode);
 
 		stack->pushBool(true);
 		return STATUS_OK;
@@ -109,7 +109,7 @@ bool SXBlackAndWhite::scCallMethod(ScScript *script, ScStack *stack, ScStack *th
 		stack->correctParams(0);
 
 		_postFilterMode = kPostFilterOff;
-		_gameRef->_renderer3D->setPostfilter(_postFilterMode);
+		_game->_renderer3D->setPostfilter(_postFilterMode);
 
 		stack->pushBool(true);
 		return STATUS_OK;
@@ -241,7 +241,7 @@ bool SXBlackAndWhite::persist(BasePersistenceManager *persistMgr) {
 
 	persistMgr->transferSint32(TMEMBER_INT(_postFilterMode));
 	if (!persistMgr->getIsSaving()) {
-		_gameRef->_renderer3D->setPostfilter(_postFilterMode);
+		_game->_renderer3D->setPostfilter(_postFilterMode);
 	}
 
 	return STATUS_OK;
diff --git a/engines/wintermute/ext/wme_commandlinehelper.cpp b/engines/wintermute/ext/wme_commandlinehelper.cpp
index c0c2bf004eb..47028f4e7fd 100644
--- a/engines/wintermute/ext/wme_commandlinehelper.cpp
+++ b/engines/wintermute/ext/wme_commandlinehelper.cpp
@@ -45,7 +45,7 @@ BaseScriptable *makeSXCommandLineHelper(BaseGame *inGame, ScStack *stack) {
 //////////////////////////////////////////////////////////////////////////
 SXCommandLineHelper::SXCommandLineHelper(BaseGame *inGame, ScStack *stack) : BaseScriptable(inGame) {
 	stack->correctParams(0);
-	_gameRef->LOG(0, "new SXCommandLineHelper()");
+	_game->LOG(0, "new SXCommandLineHelper()");
 }
 
 
diff --git a/engines/wintermute/ext/wme_shadowmanager.cpp b/engines/wintermute/ext/wme_shadowmanager.cpp
index d31ce9bd940..31b450c7fd5 100644
--- a/engines/wintermute/ext/wme_shadowmanager.cpp
+++ b/engines/wintermute/ext/wme_shadowmanager.cpp
@@ -49,7 +49,7 @@ SXShadowManager::SXShadowManager(BaseGame *inGame, ScStack *stack) : BaseScripta
 	event._type = WME_EVENT_UPDATE;
 	event._callback = callback;
 	event._plugin = this;
-	_gameRef->pluginEvents().subscribeEvent(event);
+	_game->pluginEvents().subscribeEvent(event);
 	
 	_defaultLightPos = DXVector3(1.0f, 200.0f, 1.0f);
 	_minShadow = 0.1f;
@@ -64,7 +64,7 @@ SXShadowManager::~SXShadowManager() {
 	event._type = WME_EVENT_UPDATE;
 	event._callback = callback;
 	event._plugin = this;
-	_gameRef->pluginEvents().unsubscribeEvent(event);
+	_game->pluginEvents().unsubscribeEvent(event);
 }
 
 //////////////////////////////////////////////////////////////////////////
@@ -344,7 +344,7 @@ bool SXShadowManager::persist(BasePersistenceManager *persistMgr) {
 		event._type = WME_EVENT_UPDATE;
 		event._callback = callback;
 		event._plugin = this;
-		_gameRef->pluginEvents().subscribeEvent(event);
+		_game->pluginEvents().subscribeEvent(event);
 
 		// Actor and light lists is not get restored, plugin is not designed to work this way.
 		// Lists get refreshed by game script on scene change.
@@ -364,7 +364,7 @@ bool SXShadowManager::persist(BasePersistenceManager *persistMgr) {
 void SXShadowManager::callback(void *eventData1, void *eventData2) {
 	SXShadowManager *shadowManager = (SXShadowManager *)eventData2;
 
-	uint32 time = shadowManager->_gameRef->scGetProperty("CurrentTime")->getInt();
+	uint32 time = shadowManager->_game->scGetProperty("CurrentTime")->getInt();
 	if (time - shadowManager->_lastTime > 20) {
 		shadowManager->_lastTime = time;
 		shadowManager->update();
@@ -373,7 +373,7 @@ void SXShadowManager::callback(void *eventData1, void *eventData2) {
 
 void SXShadowManager::update() {
 	if (_useSmartShadows) {
-		AdGame *adGame = (AdGame *)_gameRef;
+		AdGame *adGame = (AdGame *)_game;
 		if (!adGame->_scene || !adGame->_scene->_geom)
 			return;
 
@@ -414,9 +414,9 @@ void SXShadowManager::update() {
 }
 
 void SXShadowManager::run() {
-	_lastTime = _gameRef->scGetProperty("CurrentTime")->getInt();
+	_lastTime = _game->scGetProperty("CurrentTime")->getInt();
 	_lights.clear();
-	AdGame *adGame = (AdGame *)_gameRef;
+	AdGame *adGame = (AdGame *)_game;
 	if (!adGame->_scene || !adGame->_scene->_geom)
 		return;
 	for (int32 l = 0; l < adGame->_scene->_geom->_lights.getSize(); l++) {
diff --git a/engines/wintermute/ext/wme_vlink.cpp b/engines/wintermute/ext/wme_vlink.cpp
index 31653e29803..627c415a8c0 100644
--- a/engines/wintermute/ext/wme_vlink.cpp
+++ b/engines/wintermute/ext/wme_vlink.cpp
@@ -100,7 +100,7 @@ bool SXVlink::scCallMethod(ScScript *script, ScStack *stack, ScStack *thisStack,
 		const char *path = stack->pop()->getString();
 
 #ifdef USE_BINK
-		_gameRef->freeze();
+		_game->freeze();
 		((WintermuteEngine *)g_engine)->savingEnable(false);
 
 		// Load a file, but avoid having the File-manager handle the disposal of it.
@@ -108,11 +108,11 @@ bool SXVlink::scCallMethod(ScScript *script, ScStack *stack, ScStack *thisStack,
 		if (file) {
 			_videoDecoder = new Video::BinkDecoder();
 			if (_videoDecoder && _videoDecoder->loadStream(file) && _videoDecoder->isVideoLoaded()) {
-				_videoDecoder->setOutputPixelFormat(Graphics::PixelFormat(_gameRef->_renderer->getPixelFormat()));
-				BaseSurface *texture = _gameRef->_renderer->createSurface();
+				_videoDecoder->setOutputPixelFormat(Graphics::PixelFormat(_game->_renderer->getPixelFormat()));
+				BaseSurface *texture = _game->_renderer->createSurface();
 				texture->create(_videoDecoder->getWidth(), _videoDecoder->getHeight());
 
-				_gameRef->_renderer->setup2D();
+				_game->_renderer->setup2D();
 
 				_frame = -1;
 				_updateNeeded = false;
@@ -131,7 +131,7 @@ bool SXVlink::scCallMethod(ScScript *script, ScStack *stack, ScStack *thisStack,
 						}
 						texture->display(0, 0, Common::Rect32(texture->getWidth(), texture->getHeight()));
 						_updateNeeded = false;
-						_gameRef->_renderer->flip();
+						_game->_renderer->flip();
 					}
 					g_system->delayMillis(10);
 
@@ -145,7 +145,7 @@ bool SXVlink::scCallMethod(ScScript *script, ScStack *stack, ScStack *thisStack,
 						} else if (event.type == Common::EVENT_LBUTTONDOWN) {
 							_videoFinished = true;
 						} else if (event.type == Common::EVENT_SCREEN_CHANGED) {
-							_gameRef->_renderer->onWindowChange();
+							_game->_renderer->onWindowChange();
 						}
 					}
 				} while (!g_engine->shouldQuit() && !_videoFinished);
@@ -164,7 +164,7 @@ bool SXVlink::scCallMethod(ScScript *script, ScStack *stack, ScStack *thisStack,
 		}
 
 		((WintermuteEngine *)g_engine)->savingEnable(true);
-		_gameRef->unfreeze();
+		_game->unfreeze();
 #else
 		warning("SXVlink::Play(%s) Bink playback not compiled in", path);
 #endif
diff --git a/engines/wintermute/platform_osystem.cpp b/engines/wintermute/platform_osystem.cpp
index 50408ab664d..cb91da25514 100644
--- a/engines/wintermute/platform_osystem.cpp
+++ b/engines/wintermute/platform_osystem.cpp
@@ -35,18 +35,18 @@
 
 namespace Wintermute {
 
-BaseGame *BasePlatform::_gameRef = nullptr;
+BaseGame *BasePlatform::_game = nullptr;
 WintermuteEngine *BasePlatform::_engineRef = nullptr;
 
 #define CLASS_NAME "GF_FRAME"
 int BasePlatform::initialize(WintermuteEngine *engineRef, BaseGame *inGame, int argc, char *argv[]) {
-	_gameRef = inGame;
+	_game = inGame;
 	_engineRef = engineRef;
 	return true;
 }
 
 void BasePlatform::deinit() {
-	_gameRef = nullptr;
+	_game = nullptr;
 	_engineRef = nullptr;
 }
 
@@ -55,90 +55,90 @@ void BasePlatform::handleEvent(Common::Event *event) {
 	switch (event->type) {
 
 	case Common::EVENT_LBUTTONDOWN:
-		if (_gameRef) {
-			if (_gameRef->isLeftDoubleClick()) {
-				_gameRef->onMouseLeftDblClick();
+		if (_game) {
+			if (_game->isLeftDoubleClick()) {
+				_game->onMouseLeftDblClick();
 			} else {
-				_gameRef->onMouseLeftDown();
+				_game->onMouseLeftDown();
 			}
 		}
 		break;
 	case Common::EVENT_RBUTTONDOWN:
-		if (_gameRef) {
-			if (_gameRef->isRightDoubleClick()) {
-				_gameRef->onMouseRightDblClick();
+		if (_game) {
+			if (_game->isRightDoubleClick()) {
+				_game->onMouseRightDblClick();
 			} else {
-				_gameRef->onMouseRightDown();
+				_game->onMouseRightDown();
 			}
 		}
 		break;
 	case Common::EVENT_MBUTTONDOWN:
-		if (_gameRef) {
-			_gameRef->onMouseMiddleDown();
+		if (_game) {
+			_game->onMouseMiddleDown();
 		}
 		break;
 	case Common::EVENT_LBUTTONUP:
-		if (_gameRef) {
-			_gameRef->onMouseLeftUp();
+		if (_game) {
+			_game->onMouseLeftUp();
 		}
 		break;
 	case Common::EVENT_RBUTTONUP:
-		if (_gameRef) {
-			_gameRef->onMouseRightUp();
+		if (_game) {
+			_game->onMouseRightUp();
 		}
 		break;
 	case Common::EVENT_MBUTTONUP:
-		if (_gameRef) {
-			_gameRef->onMouseMiddleUp();
+		if (_game) {
+			_game->onMouseMiddleUp();
 		}
 		break;
 	case Common::EVENT_KEYDOWN:
-		if (_gameRef) {
-			_gameRef->handleKeypress(event);
+		if (_game) {
+			_game->handleKeypress(event);
 		}
 		break;
 	case Common::EVENT_KEYUP:
-		if (_gameRef) {
-			_gameRef->handleKeyRelease(event);
+		if (_game) {
+			_game->handleKeyRelease(event);
 		}
 		break;
 	case Common::EVENT_WHEELUP:
 	case Common::EVENT_WHEELDOWN:
-		if (_gameRef) {
-			_gameRef->handleMouseWheel(event->type == Common::EVENT_WHEELUP ? 1 : -1);
+		if (_game) {
+			_game->handleMouseWheel(event->type == Common::EVENT_WHEELUP ? 1 : -1);
 		}
 		break;
 	case Common::EVENT_CUSTOM_ENGINE_ACTION_START:
-		if (_gameRef) {
-			_gameRef->handleCustomActionStart((BaseGameCustomAction)event->customType);
+		if (_game) {
+			_game->handleCustomActionStart((BaseGameCustomAction)event->customType);
 		}
 		break;
 	case Common::EVENT_CUSTOM_ENGINE_ACTION_END:
-		if (_gameRef) {
-			_gameRef->handleCustomActionEnd((BaseGameCustomAction)event->customType);
+		if (_game) {
+			_game->handleCustomActionEnd((BaseGameCustomAction)event->customType);
 		}
 		break;
 	case Common::EVENT_SCREEN_CHANGED:
-		if (_gameRef) {
-			_gameRef->_renderer->onWindowChange();
+		if (_game) {
+			_game->_renderer->onWindowChange();
 		}
 		break;
-// Focus-events have been removed (_gameRef->onActivate originally)
+// Focus-events have been removed (_game->onActivate originally)
 	case Common::EVENT_RETURN_TO_LAUNCHER:
-		_gameRef->_quitting = true;
+		_game->_quitting = true;
 		break;
 	case Common::EVENT_QUIT:
 // Block kept in case we want to support autoSaveOnExit.
 // Originally this was the behaviour for WME Lite on iOS:
-//		if (_gameRef) {
-//			_gameRef->AutoSaveOnExit();
-//			_gameRef->_quitting = true;
+//		if (_game) {
+//			_game->AutoSaveOnExit();
+//			_game->_quitting = true;
 //		}
 
 // The engine CAN query for closing, but we disable it for now, as the EVENT_QUIT-event
 // can't be stopped.
-//		if (_gameRef) {
-//			_gameRef->onWindowClose();
+//		if (_game) {
+//			_game->onWindowClose();
 //		}
 		break;
 	default:
diff --git a/engines/wintermute/platform_osystem.h b/engines/wintermute/platform_osystem.h
index 397452f8f8b..7fe55d39ad2 100644
--- a/engines/wintermute/platform_osystem.h
+++ b/engines/wintermute/platform_osystem.h
@@ -62,7 +62,7 @@ public:
 
 private:
 	// Set by initialize on game-startup, the object referred to is also deleted by deinit in WintermuteEngine
-	static BaseGame *_gameRef;
+	static BaseGame *_game;
 	static WintermuteEngine *_engineRef;
 };
 
diff --git a/engines/wintermute/ui/ui_button.cpp b/engines/wintermute/ui/ui_button.cpp
index 310fe4981cc..6e39e5ec2df 100644
--- a/engines/wintermute/ui/ui_button.cpp
+++ b/engines/wintermute/ui/ui_button.cpp
@@ -79,16 +79,16 @@ UIButton::~UIButton() {
 
 	if (!_sharedFonts) {
 		if (_fontHover) {
-			_gameRef->_fontStorage->removeFont(_fontHover);
+			_game->_fontStorage->removeFont(_fontHover);
 		}
 		if (_fontPress) {
-			_gameRef->_fontStorage->removeFont(_fontPress);
+			_game->_fontStorage->removeFont(_fontPress);
 		}
 		if (_fontDisable) {
-			_gameRef->_fontStorage->removeFont(_fontDisable);
+			_game->_fontStorage->removeFont(_fontDisable);
 		}
 		if (_fontFocus) {
-			_gameRef->_fontStorage->removeFont(_fontFocus);
+			_game->_fontStorage->removeFont(_fontFocus);
 		}
 	}
 
@@ -105,7 +105,7 @@ UIButton::~UIButton() {
 bool UIButton::loadFile(const char *filename) {
 	char *buffer = (char *)BaseFileManager::getEngineInstance()->readWholeFile(filename);
 	if (buffer == nullptr) {
-		_gameRef->LOG(0, "UIButton::LoadFile failed for file '%s'", filename);
+		_game->LOG(0, "UIButton::LoadFile failed for file '%s'", filename);
 		return STATUS_FAILED;
 	}
 
@@ -114,7 +114,7 @@ bool UIButton::loadFile(const char *filename) {
 	setFilename(filename);
 
 	if (DID_FAIL(ret = loadBuffer(buffer, true))) {
-		_gameRef->LOG(0, "Error parsing BUTTON file '%s'", filename);
+		_game->LOG(0, "Error parsing BUTTON file '%s'", filename);
 	}
 
 	delete[] buffer;
@@ -208,7 +208,7 @@ bool UIButton::loadBuffer(char *buffer, bool complete) {
 
 	if (complete) {
 		if (parser.getCommand(&buffer, commands, &params) != TOKEN_BUTTON) {
-			_gameRef->LOG(0, "'BUTTON' keyword expected.");
+			_game->LOG(0, "'BUTTON' keyword expected.");
 			return STATUS_FAILED;
 		}
 		buffer = params;
@@ -232,7 +232,7 @@ bool UIButton::loadBuffer(char *buffer, bool complete) {
 
 		case TOKEN_BACK:
 			SAFE_DELETE(_back);
-			_back = new UITiledImage(_gameRef);
+			_back = new UITiledImage(_game);
 			if (!_back || DID_FAIL(_back->loadFile(params))) {
 				SAFE_DELETE(_back);
 				cmd = PARSERR_GENERIC;
@@ -241,7 +241,7 @@ bool UIButton::loadBuffer(char *buffer, bool complete) {
 
 		case TOKEN_BACK_HOVER:
 			SAFE_DELETE(_backHover);
-			_backHover = new UITiledImage(_gameRef);
+			_backHover = new UITiledImage(_game);
 			if (!_backHover || DID_FAIL(_backHover->loadFile(params))) {
 				SAFE_DELETE(_backHover);
 				cmd = PARSERR_GENERIC;
@@ -250,7 +250,7 @@ bool UIButton::loadBuffer(char *buffer, bool complete) {
 
 		case TOKEN_BACK_PRESS:
 			SAFE_DELETE(_backPress);
-			_backPress = new UITiledImage(_gameRef);
+			_backPress = new UITiledImage(_game);
 			if (!_backPress || DID_FAIL(_backPress->loadFile(params))) {
 				SAFE_DELETE(_backPress);
 				cmd = PARSERR_GENERIC;
@@ -259,7 +259,7 @@ bool UIButton::loadBuffer(char *buffer, bool complete) {
 
 		case TOKEN_BACK_DISABLE:
 			SAFE_DELETE(_backDisable);
-			_backDisable = new UITiledImage(_gameRef);
+			_backDisable = new UITiledImage(_game);
 			if (!_backDisable || DID_FAIL(_backDisable->loadFile(params))) {
 				SAFE_DELETE(_backDisable);
 				cmd = PARSERR_GENERIC;
@@ -268,7 +268,7 @@ bool UIButton::loadBuffer(char *buffer, bool complete) {
 
 		case TOKEN_BACK_FOCUS:
 			SAFE_DELETE(_backFocus);
-			_backFocus = new UITiledImage(_gameRef);
+			_backFocus = new UITiledImage(_game);
 			if (!_backFocus || DID_FAIL(_backFocus->loadFile(params))) {
 				SAFE_DELETE(_backFocus);
 				cmd = PARSERR_GENERIC;
@@ -277,7 +277,7 @@ bool UIButton::loadBuffer(char *buffer, bool complete) {
 
 		case TOKEN_IMAGE:
 			SAFE_DELETE(_image);
-			_image = new BaseSprite(_gameRef);
+			_image = new BaseSprite(_game);
 			if (!_image || DID_FAIL(_image->loadFile(params))) {
 				SAFE_DELETE(_image);
 				cmd = PARSERR_GENERIC;
@@ -286,7 +286,7 @@ bool UIButton::loadBuffer(char *buffer, bool complete) {
 
 		case TOKEN_IMAGE_HOVER:
 			SAFE_DELETE(_imageHover);
-			_imageHover = new BaseSprite(_gameRef);
+			_imageHover = new BaseSprite(_game);
 			if (!_imageHover || DID_FAIL(_imageHover->loadFile(params))) {
 				SAFE_DELETE(_imageHover);
 				cmd = PARSERR_GENERIC;
@@ -295,7 +295,7 @@ bool UIButton::loadBuffer(char *buffer, bool complete) {
 
 		case TOKEN_IMAGE_PRESS:
 			SAFE_DELETE(_imagePress);
-			_imagePress = new BaseSprite(_gameRef);
+			_imagePress = new BaseSprite(_game);
 			if (!_imagePress || DID_FAIL(_imagePress->loadFile(params))) {
 				SAFE_DELETE(_imagePress);
 				cmd = PARSERR_GENERIC;
@@ -304,7 +304,7 @@ bool UIButton::loadBuffer(char *buffer, bool complete) {
 
 		case TOKEN_IMAGE_DISABLE:
 			SAFE_DELETE(_imageDisable);
-			_imageDisable = new BaseSprite(_gameRef);
+			_imageDisable = new BaseSprite(_game);
 			if (!_imageDisable || DID_FAIL(_imageDisable->loadFile(params))) {
 				SAFE_DELETE(_imageDisable);
 				cmd = PARSERR_GENERIC;
@@ -313,7 +313,7 @@ bool UIButton::loadBuffer(char *buffer, bool complete) {
 
 		case TOKEN_IMAGE_FOCUS:
 			SAFE_DELETE(_imageFocus);
-			_imageFocus = new BaseSprite(_gameRef);
+			_imageFocus = new BaseSprite(_game);
 			if (!_imageFocus || DID_FAIL(_imageFocus->loadFile(params))) {
 				SAFE_DELETE(_imageFocus);
 				cmd = PARSERR_GENERIC;
@@ -322,9 +322,9 @@ bool UIButton::loadBuffer(char *buffer, bool complete) {
 
 		case TOKEN_FONT:
 			if (_font) {
-				_gameRef->_fontStorage->removeFont(_font);
+				_game->_fontStorage->removeFont(_font);
 			}
-			_font = _gameRef->_fontStorage->addFont(params);
+			_font = _game->_fontStorage->addFont(params);
 			if (!_font) {
 				cmd = PARSERR_GENERIC;
 			}
@@ -332,9 +332,9 @@ bool UIButton::loadBuffer(char *buffer, bool complete) {
 
 		case TOKEN_FONT_HOVER:
 			if (_fontHover) {
-				_gameRef->_fontStorage->removeFont(_fontHover);
+				_game->_fontStorage->removeFont(_fontHover);
 			}
-			_fontHover = _gameRef->_fontStorage->addFont(params);
+			_fontHover = _game->_fontStorage->addFont(params);
 			if (!_fontHover) {
 				cmd = PARSERR_GENERIC;
 			}
@@ -342,9 +342,9 @@ bool UIButton::loadBuffer(char *buffer, bool complete) {
 
 		case TOKEN_FONT_PRESS:
 			if (_fontPress) {
-				_gameRef->_fontStorage->removeFont(_fontPress);
+				_game->_fontStorage->removeFont(_fontPress);
 			}
-			_fontPress = _gameRef->_fontStorage->addFont(params);
+			_fontPress = _game->_fontStorage->addFont(params);
 			if (!_fontPress) {
 				cmd = PARSERR_GENERIC;
 			}
@@ -352,9 +352,9 @@ bool UIButton::loadBuffer(char *buffer, bool complete) {
 
 		case TOKEN_FONT_DISABLE:
 			if (_fontDisable) {
-				_gameRef->_fontStorage->removeFont(_fontDisable);
+				_game->_fontStorage->removeFont(_fontDisable);
 			}
-			_fontDisable = _gameRef->_fontStorage->addFont(params);
+			_fontDisable = _game->_fontStorage->addFont(params);
 			if (!_fontDisable) {
 				cmd = PARSERR_GENERIC;
 			}
@@ -362,9 +362,9 @@ bool UIButton::loadBuffer(char *buffer, bool complete) {
 
 		case TOKEN_FONT_FOCUS:
 			if (_fontFocus) {
-				_gameRef->_fontStorage->removeFont(_fontFocus);
+				_game->_fontStorage->removeFont(_fontFocus);
 			}
-			_fontFocus = _gameRef->_fontStorage->addFont(params);
+			_fontFocus = _game->_fontStorage->addFont(params);
 			if (!_fontFocus) {
 				cmd = PARSERR_GENERIC;
 			}
@@ -372,7 +372,7 @@ bool UIButton::loadBuffer(char *buffer, bool complete) {
 
 		case TOKEN_TEXT:
 			setText(params);
-			_gameRef->expandStringByStringTable(&_text);
+			_game->expandStringByStringTable(&_text);
 			break;
 
 		case TOKEN_TEXT_ALIGN:
@@ -403,7 +403,7 @@ bool UIButton::loadBuffer(char *buffer, bool complete) {
 
 		case TOKEN_CURSOR:
 			SAFE_DELETE(_cursor);
-			_cursor = new BaseSprite(_gameRef);
+			_cursor = new BaseSprite(_game);
 			if (!_cursor || DID_FAIL(_cursor->loadFile(params))) {
 				SAFE_DELETE(_cursor);
 				cmd = PARSERR_GENERIC;
@@ -451,11 +451,11 @@ bool UIButton::loadBuffer(char *buffer, bool complete) {
 		}
 	}
 	if (cmd == PARSERR_TOKENNOTFOUND) {
-		_gameRef->LOG(0, "Syntax error in BUTTON definition");
+		_game->LOG(0, "Syntax error in BUTTON definition");
 		return STATUS_FAILED;
 	}
 	if (cmd == PARSERR_GENERIC) {
-		_gameRef->LOG(0, "Error loading BUTTON definition");
+		_game->LOG(0, "Error loading BUTTON definition");
 		return STATUS_FAILED;
 	}
 
@@ -618,7 +618,7 @@ void UIButton::correctSize() {
 		if (_font)
 			textHeight = _font->getTextHeight((byte *)_text, _width);
 		else
-			textHeight = _gameRef->_systemFont->getTextHeight((byte *)_text, _width);
+			textHeight = _game->_systemFont->getTextHeight((byte *)_text, _width);
 
 		if (textHeight > _height) {
 			_height = textHeight;
@@ -647,10 +647,10 @@ bool UIButton::display(int offsetX, int offsetY) {
 
 	//RECT rect;
 	//rect.setRect(OffsetX + _posX, OffsetY + _posY, OffsetX+_posX+_width, OffsetY+_posY+_height);
-	//_hover = (!_disable && BasePlatform::ptInRect(&rect, _gameRef->_mousePos)!=FALSE);
-	_hover = (!_disable && _gameRef->_activeObject == this && (_gameRef->_interactive || _gameRef->_state == GAME_SEMI_FROZEN));
+	//_hover = (!_disable && BasePlatform::ptInRect(&rect, _game->_mousePos)!=FALSE);
+	_hover = (!_disable && _game->_activeObject == this && (_game->_interactive || _game->_state == GAME_SEMI_FROZEN));
 
-	if ((_press && _hover && !_gameRef->_mouseLeftDown) ||
+	if ((_press && _hover && !_game->_mouseLeftDown) ||
 			(_oneTimePress && g_system->getMillis() - _oneTimePressTime >= 100)) {
 		press();
 	}
@@ -708,7 +708,7 @@ bool UIButton::display(int offsetX, int offsetY) {
 		if (_font) {
 			font = _font;
 		} else {
-			font = _gameRef->_systemFont;
+			font = _game->_systemFont;
 		}
 	}
 
@@ -736,7 +736,7 @@ bool UIButton::display(int offsetX, int offsetY) {
 	}
 
 	if (!_pixelPerfect || !_image) {
-		_gameRef->_renderer->_rectList.add(new BaseActiveRect(_gameRef, this, nullptr, offsetX + _posX, offsetY + _posY, _width, _height, 100, 100, false));
+		_game->_renderer->_rectList.add(new BaseActiveRect(_game, this, nullptr, offsetX + _posX, offsetY + _posY, _width, _height, 100, 100, false));
 	}
 
 	// reset unused sprites
@@ -762,7 +762,7 @@ bool UIButton::display(int offsetX, int offsetY) {
 	}*/
 	}
 
-	_press = _hover && _gameRef->_mouseLeftDown && _gameRef->_capturedObject == this;
+	_press = _hover && _game->_mouseLeftDown && _game->_capturedObject == this;
 
 	return STATUS_OK;
 }
@@ -794,13 +794,13 @@ bool UIButton::scCallMethod(ScScript *script, ScStack *stack, ScStack *thisStack
 		ScValue *val = stack->pop();
 
 		if (_fontDisable) {
-			_gameRef->_fontStorage->removeFont(_fontDisable);
+			_game->_fontStorage->removeFont(_fontDisable);
 		}
 		if (val->isNULL()) {
 			_fontDisable = nullptr;
 			stack->pushBool(true);
 		} else {
-			_fontDisable = _gameRef->_fontStorage->addFont(val->getString());
+			_fontDisable = _game->_fontStorage->addFont(val->getString());
 			stack->pushBool(_fontDisable != nullptr);
 		}
 		return STATUS_OK;
@@ -814,13 +814,13 @@ bool UIButton::scCallMethod(ScScript *script, ScStack *stack, ScStack *thisStack
 		ScValue *val = stack->pop();
 
 		if (_fontHover) {
-			_gameRef->_fontStorage->removeFont(_fontHover);
+			_game->_fontStorage->removeFont(_fontHover);
 		}
 		if (val->isNULL()) {
 			_fontHover = nullptr;
 			stack->pushBool(true);
 		} else {
-			_fontHover = _gameRef->_fontStorage->addFont(val->getString());
+			_fontHover = _game->_fontStorage->addFont(val->getString());
 			stack->pushBool(_fontHover != nullptr);
 		}
 		return STATUS_OK;
@@ -834,13 +834,13 @@ bool UIButton::scCallMethod(ScScript *script, ScStack *stack, ScStack *thisStack
 		ScValue *val = stack->pop();
 
 		if (_fontPress) {
-			_gameRef->_fontStorage->removeFont(_fontPress);
+			_game->_fontStorage->removeFont(_fontPress);
 		}
 		if (val->isNULL()) {
 			_fontPress = nullptr;
 			stack->pushBool(true);
 		} else {
-			_fontPress = _gameRef->_fontStorage->addFont(val->getString());
+			_fontPress = _game->_fontStorage->addFont(val->getString());
 			stack->pushBool(_fontPress != nullptr);
 		}
 		return STATUS_OK;
@@ -854,13 +854,13 @@ bool UIButton::scCallMethod(ScScript *script, ScStack *stack, ScStack *thisStack
 		ScValue *val = stack->pop();
 
 		if (_fontFocus) {
-			_gameRef->_fontStorage->removeFont(_fontFocus);
+			_game->_fontStorage->removeFont(_fontFocus);
 		}
 		if (val->isNULL()) {
 			_fontFocus = nullptr;
 			stack->pushBool(true);
 		} else {
-			_fontFocus = _gameRef->_fontStorage->addFont(val->getString());
+			_fontFocus = _game->_fontStorage->addFont(val->getString());
 			stack->pushBool(_fontFocus != nullptr);
 		}
 		return STATUS_OK;
@@ -888,7 +888,7 @@ bool UIButton::scCallMethod(ScScript *script, ScStack *stack, ScStack *thisStack
 		stack->correctParams(1);
 
 		delete _imageDisable;
-		_imageDisable = new BaseSprite(_gameRef);
+		_imageDisable = new BaseSprite(_game);
 		const char *filename = stack->pop()->getString();
 		if (!_imageDisable || DID_FAIL(_imageDisable->loadFile(filename))) {
 			SAFE_DELETE(_imageDisable);
@@ -936,7 +936,7 @@ bool UIButton::scCallMethod(ScScript *script, ScStack *stack, ScStack *thisStack
 		stack->correctParams(1);
 
 		SAFE_DELETE(_imageHover);
-		_imageHover = new BaseSprite(_gameRef);
+		_imageHover = new BaseSprite(_game);
 		const char *filename = stack->pop()->getString();
 		if (!_imageHover || DID_FAIL(_imageHover->loadFile(filename))) {
 			SAFE_DELETE(_imageHover);
@@ -983,7 +983,7 @@ bool UIButton::scCallMethod(ScScript *script, ScStack *stack, ScStack *thisStack
 		stack->correctParams(1);
 
 		SAFE_DELETE(_imagePress);
-		_imagePress = new BaseSprite(_gameRef);
+		_imagePress = new BaseSprite(_game);
 		const char *filename = stack->pop()->getString();
 		if (!_imagePress || DID_FAIL(_imagePress->loadFile(filename))) {
 			SAFE_DELETE(_imagePress);
@@ -1030,7 +1030,7 @@ bool UIButton::scCallMethod(ScScript *script, ScStack *stack, ScStack *thisStack
 		stack->correctParams(1);
 
 		SAFE_DELETE(_imageFocus);
-		_imageFocus = new BaseSprite(_gameRef);
+		_imageFocus = new BaseSprite(_game);
 		const char *filename = stack->pop()->getString();
 		if (!_imageFocus || DID_FAIL(_imageFocus->loadFile(filename))) {
 			SAFE_DELETE(_imageFocus);
diff --git a/engines/wintermute/ui/ui_edit.cpp b/engines/wintermute/ui/ui_edit.cpp
index be5f41791a8..d1abb4e4b81 100644
--- a/engines/wintermute/ui/ui_edit.cpp
+++ b/engines/wintermute/ui/ui_edit.cpp
@@ -84,7 +84,7 @@ UIEdit::UIEdit(BaseGame *inGame) : UIObject(inGame) {
 UIEdit::~UIEdit() {
 	if (!_sharedFonts) {
 		if (_fontSelected) {
-			_gameRef->_fontStorage->removeFont(_fontSelected);
+			_game->_fontStorage->removeFont(_fontSelected);
 		}
 	}
 
@@ -96,7 +96,7 @@ UIEdit::~UIEdit() {
 bool UIEdit::loadFile(const char *filename) {
 	char *buffer = (char *)BaseFileManager::getEngineInstance()->readWholeFile(filename);
 	if (buffer == nullptr) {
-		_gameRef->LOG(0, "UIEdit::LoadFile failed for file '%s'", filename);
+		_game->LOG(0, "UIEdit::LoadFile failed for file '%s'", filename);
 		return STATUS_FAILED;
 	}
 
@@ -105,7 +105,7 @@ bool UIEdit::loadFile(const char *filename) {
 	setFilename(filename);
 
 	if (DID_FAIL(ret = loadBuffer(buffer, true))) {
-		_gameRef->LOG(0, "Error parsing EDIT file '%s'", filename);
+		_game->LOG(0, "Error parsing EDIT file '%s'", filename);
 	}
 
 	delete[] buffer;
@@ -171,7 +171,7 @@ bool UIEdit::loadBuffer(char *buffer, bool complete) {
 
 	if (complete) {
 		if (parser.getCommand(&buffer, commands, &params) != TOKEN_EDIT) {
-			_gameRef->LOG(0, "'EDIT' keyword expected.");
+			_game->LOG(0, "'EDIT' keyword expected.");
 			return STATUS_FAILED;
 		}
 		buffer = params;
@@ -191,7 +191,7 @@ bool UIEdit::loadBuffer(char *buffer, bool complete) {
 
 		case TOKEN_BACK:
 			SAFE_DELETE(_back);
-			_back = new UITiledImage(_gameRef);
+			_back = new UITiledImage(_game);
 			if (!_back || DID_FAIL(_back->loadFile(params))) {
 				SAFE_DELETE(_back);
 				cmd = PARSERR_GENERIC;
@@ -200,7 +200,7 @@ bool UIEdit::loadBuffer(char *buffer, bool complete) {
 
 		case TOKEN_IMAGE:
 			SAFE_DELETE(_image);
-			_image = new BaseSprite(_gameRef);
+			_image = new BaseSprite(_game);
 			if (!_image || DID_FAIL(_image->loadFile(params))) {
 				SAFE_DELETE(_image);
 				cmd = PARSERR_GENERIC;
@@ -209,9 +209,9 @@ bool UIEdit::loadBuffer(char *buffer, bool complete) {
 
 		case TOKEN_FONT:
 			if (_font) {
-				_gameRef->_fontStorage->removeFont(_font);
+				_game->_fontStorage->removeFont(_font);
 			}
-			_font = _gameRef->_fontStorage->addFont(params);
+			_font = _game->_fontStorage->addFont(params);
 			if (!_font) {
 				cmd = PARSERR_GENERIC;
 			}
@@ -219,9 +219,9 @@ bool UIEdit::loadBuffer(char *buffer, bool complete) {
 
 		case TOKEN_FONT_SELECTED:
 			if (_fontSelected) {
-				_gameRef->_fontStorage->removeFont(_fontSelected);
+				_game->_fontStorage->removeFont(_fontSelected);
 			}
-			_fontSelected = _gameRef->_fontStorage->addFont(params);
+			_fontSelected = _game->_fontStorage->addFont(params);
 			if (!_fontSelected) {
 				cmd = PARSERR_GENERIC;
 			}
@@ -229,7 +229,7 @@ bool UIEdit::loadBuffer(char *buffer, bool complete) {
 
 		case TOKEN_TEXT:
 			setText(params);
-			_gameRef->expandStringByStringTable(&_text);
+			_game->expandStringByStringTable(&_text);
 			break;
 
 		case TOKEN_X:
@@ -258,7 +258,7 @@ bool UIEdit::loadBuffer(char *buffer, bool complete) {
 
 		case TOKEN_CURSOR:
 			SAFE_DELETE(_cursor);
-			_cursor = new BaseSprite(_gameRef);
+			_cursor = new BaseSprite(_game);
 			if (!_cursor || DID_FAIL(_cursor->loadFile(params))) {
 				SAFE_DELETE(_cursor);
 				cmd = PARSERR_GENERIC;
@@ -298,11 +298,11 @@ bool UIEdit::loadBuffer(char *buffer, bool complete) {
 		}
 	}
 	if (cmd == PARSERR_TOKENNOTFOUND) {
-		_gameRef->LOG(0, "Syntax error in EDIT definition");
+		_game->LOG(0, "Syntax error in EDIT definition");
 		return STATUS_FAILED;
 	}
 	if (cmd == PARSERR_GENERIC) {
-		_gameRef->LOG(0, "Error loading EDIT definition");
+		_game->LOG(0, "Error loading EDIT definition");
 		return STATUS_FAILED;
 	}
 
@@ -385,9 +385,9 @@ bool UIEdit::scCallMethod(ScScript *script, ScStack *stack, ScStack *thisStack,
 		stack->correctParams(1);
 
 		if (_fontSelected) {
-			_gameRef->_fontStorage->removeFont(_fontSelected);
+			_game->_fontStorage->removeFont(_fontSelected);
 		}
-		_fontSelected = _gameRef->_fontStorage->addFont(stack->pop()->getString());
+		_fontSelected = _game->_fontStorage->addFont(stack->pop()->getString());
 		stack->pushBool(_fontSelected != nullptr);
 
 		return STATUS_OK;
@@ -461,7 +461,7 @@ ScValue *UIEdit::scGetProperty(const Common::String &name) {
 	// Text
 	//////////////////////////////////////////////////////////////////////////
 	else if (name == "Text") {
-		if (_gameRef->_textEncoding == TEXT_UTF8) {
+		if (_game->_textEncoding == TEXT_UTF8) {
 			WideString wstr = StringUtil::ansiToWide(_text);
 			_scValue->setString(StringUtil::wideToUtf8(wstr).c_str());
 		} else {
@@ -532,7 +532,7 @@ bool UIEdit::scSetProperty(const char *name, ScValue *value) {
 	// Text
 	//////////////////////////////////////////////////////////////////////////
 	else if (strcmp(name, "Text") == 0) {
-		if (_gameRef->_textEncoding == TEXT_UTF8) {
+		if (_game->_textEncoding == TEXT_UTF8) {
 			WideString wstr = StringUtil::utf8ToWide(value->getString());
 			setText(StringUtil::wideToAnsi(wstr).c_str());
 		} else {
@@ -571,8 +571,8 @@ bool UIEdit::display(int offsetX, int offsetY) {
 
 
 	// hack!
-	TTextEncoding OrigEncoding = _gameRef->_textEncoding;
-	_gameRef->_textEncoding = TEXT_ANSI;
+	TTextEncoding OrigEncoding = _game->_textEncoding;
+	_game->_textEncoding = TEXT_ANSI;
 
 	if (_back) {
 		_back->display(offsetX + _posX, offsetY + _posY, _width, _height);
@@ -588,7 +588,7 @@ bool UIEdit::display(int offsetX, int offsetY) {
 	if (_font) {
 		font = _font;
 	} else {
-		font = _gameRef->_systemFont;
+		font = _game->_systemFont;
 	}
 
 	if (_fontSelected) {
@@ -654,7 +654,7 @@ bool UIEdit::display(int offsetX, int offsetY) {
 		width = _posX + _width + offsetX - _frameWidth;
 		height = MAX(font->getLetterHeight(), sfont->getLetterHeight());
 
-		if (_gameRef->_textRTL) {
+		if (_game->_textRTL) {
 			xxx += alignOffset;
 		}
 
@@ -724,7 +724,7 @@ bool UIEdit::display(int offsetX, int offsetY) {
 	}
 
 
-	_gameRef->_renderer->_rectList.add(new BaseActiveRect(_gameRef,  this, nullptr, offsetX + _posX, offsetY + _posY, _width, _height, 100, 100, false));
+	_game->_renderer->_rectList.add(new BaseActiveRect(_game,  this, nullptr, offsetX + _posX, offsetY + _posY, _width, _height, 100, 100, false));
 
 /*	if (Game->m_AccessMgr->GetActiveObject() == this) {
 		RECT rc;
@@ -732,7 +732,7 @@ bool UIEdit::display(int offsetX, int offsetY) {
 		Game->m_AccessMgr->SetHintRect(&rc, true);
 	}*/
 
-	_gameRef->_textEncoding = OrigEncoding;
+	_game->_textEncoding = OrigEncoding;
 
 	return STATUS_OK;
 }
@@ -761,9 +761,9 @@ bool UIEdit::handleKeypress(Common::Event *event, bool printable) {
 	case Common::KEYCODE_RIGHT:
 	case Common::KEYCODE_DOWN:
 		if (event->kbd.keycode == Common::KEYCODE_HOME) {
-			_selEnd = _gameRef->_textRTL ? strlen(_text) : 0;
+			_selEnd = _game->_textRTL ? strlen(_text) : 0;
 		} else if (event->kbd.keycode == Common::KEYCODE_END) {
-			_selEnd = _gameRef->_textRTL ? 0 : strlen(_text);
+			_selEnd = _game->_textRTL ? 0 : strlen(_text);
 		} else if (event->kbd.keycode == Common::KEYCODE_LEFT ||
 				   event->kbd.keycode == Common::KEYCODE_UP) {
 			_selEnd--;
@@ -779,7 +779,7 @@ bool UIEdit::handleKeypress(Common::Event *event, bool printable) {
 	// Delete right
 	case Common::KEYCODE_DELETE:
 		if (_selStart == _selEnd) {
-			if (_gameRef->_textRTL) {
+			if (_game->_textRTL) {
 				deleteChars(_selStart - 1, _selStart);
 				_selEnd--;
 				if (_selEnd < 0) {
@@ -800,7 +800,7 @@ bool UIEdit::handleKeypress(Common::Event *event, bool printable) {
 	// Delete left
 	case Common::KEYCODE_BACKSPACE:
 		if (_selStart == _selEnd) {
-			if (_gameRef->_textRTL) {
+			if (_game->_textRTL) {
 				deleteChars(_selStart, _selStart + 1);
 			} else {
 				deleteChars(_selStart - 1, _selStart);
@@ -836,7 +836,7 @@ bool UIEdit::handleKeypress(Common::Event *event, bool printable) {
 		wstr += (char)event->kbd.ascii;
 		_selEnd += insertChars(_selEnd, (const byte *)StringUtil::wideToAnsi(wstr).c_str(), 1);
 
-		if (_gameRef->_textRTL) {
+		if (_game->_textRTL) {
 			_selEnd = _selStart;
 		} else {
 			_selStart = _selEnd;
diff --git a/engines/wintermute/ui/ui_entity.cpp b/engines/wintermute/ui/ui_entity.cpp
index 86f9d2679ac..969a737545c 100644
--- a/engines/wintermute/ui/ui_entity.cpp
+++ b/engines/wintermute/ui/ui_entity.cpp
@@ -50,7 +50,7 @@ UIEntity::UIEntity(BaseGame *inGame) : UIObject(inGame) {
 //////////////////////////////////////////////////////////////////////////
 UIEntity::~UIEntity() {
 	if (_entity) {
-		_gameRef->unregisterObject(_entity);
+		_game->unregisterObject(_entity);
 	}
 	_entity = nullptr;
 }
@@ -60,7 +60,7 @@ UIEntity::~UIEntity() {
 bool UIEntity::loadFile(const char *filename) {
 	char *buffer = (char *)BaseFileManager::getEngineInstance()->readWholeFile(filename);
 	if (buffer == nullptr) {
-		_gameRef->LOG(0, "UIEntity::LoadFile failed for file '%s'", filename);
+		_game->LOG(0, "UIEntity::LoadFile failed for file '%s'", filename);
 		return STATUS_FAILED;
 	}
 
@@ -69,7 +69,7 @@ bool UIEntity::loadFile(const char *filename) {
 	setFilename(filename);
 
 	if (DID_FAIL(ret = loadBuffer(buffer, true))) {
-		_gameRef->LOG(0, "Error parsing ENTITY container file '%s'", filename);
+		_game->LOG(0, "Error parsing ENTITY container file '%s'", filename);
 	}
 
 
@@ -112,7 +112,7 @@ bool UIEntity::loadBuffer(char *buffer, bool complete) {
 
 	if (complete) {
 		if (parser.getCommand(&buffer, commands, &params) != TOKEN_ENTITY_CONTAINER) {
-			_gameRef->LOG(0, "'ENTITY_CONTAINER' keyword expected.");
+			_game->LOG(0, "'ENTITY_CONTAINER' keyword expected.");
 			return STATUS_FAILED;
 		}
 		buffer = params;
@@ -165,17 +165,17 @@ bool UIEntity::loadBuffer(char *buffer, bool complete) {
 		}
 	}
 	if (cmd == PARSERR_TOKENNOTFOUND) {
-		_gameRef->LOG(0, "Syntax error in ENTITY_CONTAINER definition");
+		_game->LOG(0, "Syntax error in ENTITY_CONTAINER definition");
 		return STATUS_FAILED;
 	}
 	if (cmd == PARSERR_GENERIC) {
-		_gameRef->LOG(0, "Error loading ENTITY_CONTAINER definition");
+		_game->LOG(0, "Error loading ENTITY_CONTAINER definition");
 		return STATUS_FAILED;
 	}
 
 	correctSize();
 
-	if (_gameRef->_editorMode) {
+	if (_game->_editorMode) {
 		_width = 50;
 		_height = 50;
 	}
@@ -221,9 +221,9 @@ bool UIEntity::saveAsText(BaseDynamicBuffer *buffer, int indent) {
 //////////////////////////////////////////////////////////////////////////
 bool UIEntity::setEntity(const char *filename) {
 	if (_entity) {
-		_gameRef->unregisterObject(_entity);
+		_game->unregisterObject(_entity);
 	}
-	_entity = new AdEntity(_gameRef);
+	_entity = new AdEntity(_game);
 	if (!_entity || DID_FAIL(_entity->loadFile(filename))) {
 		SAFE_DELETE(_entity);
 		return STATUS_FAILED;
@@ -231,7 +231,7 @@ bool UIEntity::setEntity(const char *filename) {
 		_entity->_nonIntMouseEvents = true;
 		_entity->_sceneIndependent = true;
 		_entity->makeFreezable(false);
-		_gameRef->registerObject(_entity);
+		_game->registerObject(_entity);
 	}
 	return STATUS_OK;
 }
diff --git a/engines/wintermute/ui/ui_object.cpp b/engines/wintermute/ui/ui_object.cpp
index 21a52c784d9..c4d38b225d0 100644
--- a/engines/wintermute/ui/ui_object.cpp
+++ b/engines/wintermute/ui/ui_object.cpp
@@ -72,7 +72,7 @@ UIObject::UIObject(BaseGame *inGame) : BaseObject(inGame) {
 
 //////////////////////////////////////////////////////////////////////////
 UIObject::~UIObject() {
-	if (!_gameRef->_loadInProgress) {
+	if (!_game->_loadInProgress) {
 		SystemClassRegistry::getInstance()->enumInstances(BaseGame::invalidateValues, "ScValue", (void *)this);
 	}
 
@@ -80,7 +80,7 @@ UIObject::~UIObject() {
 		delete _back;
 	}
 	if (_font && !_sharedFonts) {
-		_gameRef->_fontStorage->removeFont(_font);
+		_game->_fontStorage->removeFont(_font);
 	}
 
 	if (_image && !_sharedImages) {
@@ -162,13 +162,13 @@ bool UIObject::scCallMethod(ScScript *script, ScStack *stack, ScStack *thisStack
 		ScValue *val = stack->pop();
 
 		if (_font) {
-			_gameRef->_fontStorage->removeFont(_font);
+			_game->_fontStorage->removeFont(_font);
 		}
 		if (val->isNULL()) {
 			_font = nullptr;
 			stack->pushBool(true);
 		} else {
-			_font = _gameRef->_fontStorage->addFont(val->getString());
+			_font = _game->_fontStorage->addFont(val->getString());
 			stack->pushBool(_font != nullptr);
 		}
 		return STATUS_OK;
@@ -189,7 +189,7 @@ bool UIObject::scCallMethod(ScScript *script, ScStack *stack, ScStack *thisStack
 			return STATUS_OK;
 		}
 
-		_image = new BaseSprite(_gameRef);
+		_image = new BaseSprite(_game);
 		if (!_image || DID_FAIL(_image->loadFile(val->getString()))) {
 			SAFE_DELETE(_image);
 			stack->pushBool(false);
@@ -529,14 +529,14 @@ const char *UIObject::scToString() {
 
 //////////////////////////////////////////////////////////////////////////
 bool UIObject::isFocused() {
-	if (!_gameRef->_focusedWindow) {
+	if (!_game->_focusedWindow) {
 		return false;
 	}
-	if (_gameRef->_focusedWindow == this) {
+	if (_game->_focusedWindow == this) {
 		return true;
 	}
 
-	UIObject *obj = _gameRef->_focusedWindow;
+	UIObject *obj = _game->_focusedWindow;
 	while (obj) {
 		if (obj == this) {
 			return true;
@@ -578,7 +578,7 @@ bool UIObject::focus() {
 				}
 			} else {
 				if (obj->_type == UI_WINDOW) {
-					_gameRef->focusWindow((UIWindow *)obj);
+					_game->focusWindow((UIWindow *)obj);
 				}
 			}
 
diff --git a/engines/wintermute/ui/ui_text.cpp b/engines/wintermute/ui/ui_text.cpp
index 8196e3bf144..1a6e94cb8c3 100644
--- a/engines/wintermute/ui/ui_text.cpp
+++ b/engines/wintermute/ui/ui_text.cpp
@@ -69,7 +69,7 @@ bool UIText::display(int offsetX, int offsetY) {
 
 	BaseFont *font = _font;
 	if (!font) {
-		font = _gameRef->_systemFont;
+		font = _game->_systemFont;
 	}
 
 	if (_back) {
@@ -94,7 +94,7 @@ bool UIText::display(int offsetX, int offsetY) {
 		font->drawText((byte *)_text, offsetX + _posX, offsetY + _posY + textOffset, _width, _textAlign, _height);
 	}
 
-	//_gameRef->_renderer->_rectList.add(new BaseActiveRect(_gameRef,  this, NULL, OffsetX + _posX, OffsetY + _posY, _width, _height, 100, 100, false));
+	//_game->_renderer->_rectList.add(new BaseActiveRect(_game,  this, NULL, OffsetX + _posX, OffsetY + _posY, _width, _height, 100, 100, false));
 
 	return STATUS_OK;
 }
@@ -105,7 +105,7 @@ bool UIText::display(int offsetX, int offsetY) {
 bool UIText::loadFile(const char *filename) {
 	char *buffer = (char *)BaseFileManager::getEngineInstance()->readWholeFile(filename);
 	if (buffer == nullptr) {
-		_gameRef->LOG(0, "UIText::LoadFile failed for file '%s'", filename);
+		_game->LOG(0, "UIText::LoadFile failed for file '%s'", filename);
 		return STATUS_FAILED;
 	}
 
@@ -114,7 +114,7 @@ bool UIText::loadFile(const char *filename) {
 	setFilename(filename);
 
 	if (DID_FAIL(ret = loadBuffer(buffer, true))) {
-		_gameRef->LOG(0, "Error parsing STATIC file '%s'", filename);
+		_game->LOG(0, "Error parsing STATIC file '%s'", filename);
 	}
 
 	delete[] buffer;
@@ -176,7 +176,7 @@ bool UIText::loadBuffer(char *buffer, bool complete) {
 
 	if (complete) {
 		if (parser.getCommand(&buffer, commands, &params) != TOKEN_STATIC) {
-			_gameRef->LOG(0, "'STATIC' keyword expected.");
+			_game->LOG(0, "'STATIC' keyword expected.");
 			return STATUS_FAILED;
 		}
 		buffer = params;
@@ -200,7 +200,7 @@ bool UIText::loadBuffer(char *buffer, bool complete) {
 
 		case TOKEN_BACK:
 			SAFE_DELETE(_back);
-			_back = new UITiledImage(_gameRef);
+			_back = new UITiledImage(_game);
 			if (!_back || DID_FAIL(_back->loadFile(params))) {
 				SAFE_DELETE(_back);
 				cmd = PARSERR_GENERIC;
@@ -209,7 +209,7 @@ bool UIText::loadBuffer(char *buffer, bool complete) {
 
 		case TOKEN_IMAGE:
 			SAFE_DELETE(_image);
-			_image = new BaseSprite(_gameRef);
+			_image = new BaseSprite(_game);
 			if (!_image || DID_FAIL(_image->loadFile(params))) {
 				SAFE_DELETE(_image);
 				cmd = PARSERR_GENERIC;
@@ -218,9 +218,9 @@ bool UIText::loadBuffer(char *buffer, bool complete) {
 
 		case TOKEN_FONT:
 			if (_font) {
-				_gameRef->_fontStorage->removeFont(_font);
+				_game->_fontStorage->removeFont(_font);
 			}
-			_font = _gameRef->_fontStorage->addFont(params);
+			_font = _game->_fontStorage->addFont(params);
 			if (!_font) {
 				cmd = PARSERR_GENERIC;
 			}
@@ -228,7 +228,7 @@ bool UIText::loadBuffer(char *buffer, bool complete) {
 
 		case TOKEN_TEXT:
 			setText(params);
-			_gameRef->expandStringByStringTable(&_text);
+			_game->expandStringByStringTable(&_text);
 			break;
 
 		case TOKEN_TEXT_ALIGN:
@@ -269,7 +269,7 @@ bool UIText::loadBuffer(char *buffer, bool complete) {
 
 		case TOKEN_CURSOR:
 			SAFE_DELETE(_cursor);
-			_cursor = new BaseSprite(_gameRef);
+			_cursor = new BaseSprite(_game);
 			if (!_cursor || DID_FAIL(_cursor->loadFile(params))) {
 				SAFE_DELETE(_cursor);
 				cmd = PARSERR_GENERIC;
@@ -301,11 +301,11 @@ bool UIText::loadBuffer(char *buffer, bool complete) {
 		}
 	}
 	if (cmd == PARSERR_TOKENNOTFOUND) {
-		_gameRef->LOG(0, "Syntax error in STATIC definition");
+		_game->LOG(0, "Syntax error in STATIC definition");
 		return STATUS_FAILED;
 	}
 	if (cmd == PARSERR_GENERIC) {
-		_gameRef->LOG(0, "Error loading STATIC definition");
+		_game->LOG(0, "Error loading STATIC definition");
 		return STATUS_FAILED;
 	}
 
diff --git a/engines/wintermute/ui/ui_tiled_image.cpp b/engines/wintermute/ui/ui_tiled_image.cpp
index 31d2b8890e6..3b68caf2d4b 100644
--- a/engines/wintermute/ui/ui_tiled_image.cpp
+++ b/engines/wintermute/ui/ui_tiled_image.cpp
@@ -74,7 +74,7 @@ bool UITiledImage::display(int x, int y, int width, int height) {
 	int nuColumns = (width - (_middleLeft.right - _middleLeft.left) - (_middleRight.right - _middleRight.left)) / tileWidth;
 	int nuRows = (height - (_upMiddle.bottom - _upMiddle.top) - (_downMiddle.bottom - _downMiddle.top)) / tileHeight;
 
-	_gameRef->_renderer->startSpriteBatch();
+	_game->_renderer->startSpriteBatch();
 
 	// top left/right
 	_image->_surface->displayTrans(x,                                                       y, _upLeft);
@@ -105,7 +105,7 @@ bool UITiledImage::display(int x, int y, int width, int height) {
 		_image->_surface->displayTiled(xxx, yyy, _middleMiddle, nuColumns, nuRows);
 	}
 
-	_gameRef->_renderer->endSpriteBatch();
+	_game->_renderer->endSpriteBatch();
 
 	return STATUS_OK;
 }
@@ -115,7 +115,7 @@ bool UITiledImage::display(int x, int y, int width, int height) {
 bool UITiledImage::loadFile(const char *filename) {
 	char *buffer = (char *)BaseFileManager::getEngineInstance()->readWholeFile(filename);
 	if (buffer == nullptr) {
-		_gameRef->LOG(0, "UITiledImage::LoadFile failed for file '%s'", filename);
+		_game->LOG(0, "UITiledImage::LoadFile failed for file '%s'", filename);
 		return STATUS_FAILED;
 	}
 
@@ -124,7 +124,7 @@ bool UITiledImage::loadFile(const char *filename) {
 	setFilename(filename);
 
 	if (DID_FAIL(ret = loadBuffer(buffer, true))) {
-		_gameRef->LOG(0, "Error parsing TILED_IMAGE file '%s'", filename);
+		_game->LOG(0, "Error parsing TILED_IMAGE file '%s'", filename);
 	}
 
 
@@ -180,7 +180,7 @@ bool UITiledImage::loadBuffer(char *buffer, bool complete) {
 
 	if (complete) {
 		if (parser.getCommand(&buffer, commands, &params) != TOKEN_TILED_IMAGE) {
-			_gameRef->LOG(0, "'TILED_IMAGE' keyword expected.");
+			_game->LOG(0, "'TILED_IMAGE' keyword expected.");
 			return STATUS_FAILED;
 		}
 		buffer = params;
@@ -196,7 +196,7 @@ bool UITiledImage::loadBuffer(char *buffer, bool complete) {
 
 		case TOKEN_IMAGE:
 			SAFE_DELETE(_image);
-			_image = new BaseSubFrame(_gameRef);
+			_image = new BaseSubFrame(_game);
 			if (!_image || DID_FAIL(_image->setSurface(params))) {
 				SAFE_DELETE(_image);
 				cmd = PARSERR_GENERIC;
@@ -258,11 +258,11 @@ bool UITiledImage::loadBuffer(char *buffer, bool complete) {
 		}
 	}
 	if (cmd == PARSERR_TOKENNOTFOUND) {
-		_gameRef->LOG(0, "Syntax error in TILED_IMAGE definition");
+		_game->LOG(0, "Syntax error in TILED_IMAGE definition");
 		return STATUS_FAILED;
 	}
 	if (cmd == PARSERR_GENERIC) {
-		_gameRef->LOG(0, "Error loading TILED_IMAGE definition");
+		_game->LOG(0, "Error loading TILED_IMAGE definition");
 		return STATUS_FAILED;
 	}
 
diff --git a/engines/wintermute/ui/ui_window.cpp b/engines/wintermute/ui/ui_window.cpp
index 36d42e500c2..e69c1688f10 100644
--- a/engines/wintermute/ui/ui_window.cpp
+++ b/engines/wintermute/ui/ui_window.cpp
@@ -102,7 +102,7 @@ void UIWindow::cleanup() {
 	SAFE_DELETE(_viewport);
 	delete _backInactive;
 	if (!_sharedFonts && _fontInactive) {
-		_gameRef->_fontStorage->removeFont(_fontInactive);
+		_game->_fontStorage->removeFont(_fontInactive);
 	}
 	if (!_sharedImages && _imageInactive) {
 		delete _imageInactive;
@@ -120,26 +120,26 @@ bool UIWindow::display(int offsetX, int offsetY) {
 	// go exclusive
 	if (_mode == WINDOW_EXCLUSIVE || _mode == WINDOW_SYSTEM_EXCLUSIVE) {
 		if (!_shieldWindow) {
-			_shieldWindow = new UIWindow(_gameRef);
+			_shieldWindow = new UIWindow(_game);
 		}
 		if (_shieldWindow) {
 			_shieldWindow->_posX = _shieldWindow->_posY = 0;
-			_shieldWindow->_width = _gameRef->_renderer->getWidth();
-			_shieldWindow->_height = _gameRef->_renderer->getHeight();
+			_shieldWindow->_width = _game->_renderer->getWidth();
+			_shieldWindow->_height = _game->_renderer->getHeight();
 
 			_shieldWindow->display();
 		}
 	} else if (_isMenu) {
 		if (!_shieldButton) {
-			_shieldButton = new UIButton(_gameRef);
+			_shieldButton = new UIButton(_game);
 			_shieldButton->setName("close");
 			_shieldButton->setListener(this, _shieldButton, 0);
 			_shieldButton->_parent = this;
 		}
 
 		_shieldButton->_posX = _shieldButton->_posY = 0;
-		_shieldButton->_width = _gameRef->_renderer->getWidth();
-		_shieldButton->_height = _gameRef->_renderer->getHeight();
+		_shieldButton->_width = _game->_renderer->getWidth();
+		_shieldButton->_height = _game->_renderer->getHeight();
 
 		_shieldButton->display();
 	}
@@ -153,15 +153,15 @@ bool UIWindow::display(int offsetX, int offsetY) {
 		byte fadeG = RGBCOLGetG(_fadeColor);
 		byte fadeB = RGBCOLGetB(_fadeColor);
 		byte fadeA = RGBCOLGetA(_fadeColor);
-		_gameRef->_renderer->fadeToColor(fadeR, fadeG, fadeB, fadeA);
+		_game->_renderer->fadeToColor(fadeR, fadeG, fadeB, fadeA);
 	}
 
 	if (_dragging) {
-		_posX += (_gameRef->_mousePos.x - _dragFrom.x);
-		_posY += (_gameRef->_mousePos.y - _dragFrom.y);
+		_posX += (_game->_mousePos.x - _dragFrom.x);
+		_posY += (_game->_mousePos.y - _dragFrom.y);
 
-		_dragFrom.x = _gameRef->_mousePos.x;
-		_dragFrom.y = _gameRef->_mousePos.y;
+		_dragFrom.x = _game->_mousePos.x;
+		_dragFrom.y = _game->_mousePos.y;
 	}
 
 	if (!_focusedWidget || (!_focusedWidget->_canFocus || _focusedWidget->_disable || !_focusedWidget->_visible)) {
@@ -171,11 +171,11 @@ bool UIWindow::display(int offsetX, int offsetY) {
 	bool popViewport = false;
 	if (_clipContents) {
 		if (!_viewport) {
-			_viewport = new BaseViewport(_gameRef);
+			_viewport = new BaseViewport(_game);
 		}
 		if (_viewport) {
 			_viewport->setRect(_posX + offsetX, _posY + offsetY, _posX + _width + offsetX, _posY + _height + offsetY);
-			_gameRef->pushViewport(_viewport);
+			_game->pushViewport(_viewport);
 			popViewport = true;
 		}
 	}
@@ -198,7 +198,7 @@ bool UIWindow::display(int offsetX, int offsetY) {
 	}
 
 	if (_alphaColor != 0) {
-		_gameRef->_renderer->_forceAlphaColor = _alphaColor;
+		_game->_renderer->_forceAlphaColor = _alphaColor;
 	}
 	if (back) {
 		back->display(_posX + offsetX, _posY + offsetY, _width, _height);
@@ -212,7 +212,7 @@ bool UIWindow::display(int offsetX, int offsetY) {
 	}
 
 	if (!_transparent && !image) {
-		_gameRef->_renderer->_rectList.add(new BaseActiveRect(_gameRef,  this, nullptr, _posX + offsetX, _posY + offsetY, _width, _height, 100, 100, false));
+		_game->_renderer->_rectList.add(new BaseActiveRect(_game,  this, nullptr, _posX + offsetX, _posY + offsetY, _width, _height, 100, 100, false));
 	}
 
 	for (int32 i = 0; i < _widgets.getSize(); i++) {
@@ -220,11 +220,11 @@ bool UIWindow::display(int offsetX, int offsetY) {
 	}
 
 	if (_alphaColor != 0) {
-		_gameRef->_renderer->_forceAlphaColor = 0;
+		_game->_renderer->_forceAlphaColor = 0;
 	}
 
 	if (popViewport) {
-		_gameRef->popViewport();
+		_game->popViewport();
 	}
 
 	return STATUS_OK;
@@ -235,7 +235,7 @@ bool UIWindow::display(int offsetX, int offsetY) {
 bool UIWindow::loadFile(const char *filename) {
 	char *buffer = (char *)BaseFileManager::getEngineInstance()->readWholeFile(filename);
 	if (buffer == nullptr) {
-		_gameRef->LOG(0, "UIWindow::LoadFile failed for file '%s'", filename);
+		_game->LOG(0, "UIWindow::LoadFile failed for file '%s'", filename);
 		return STATUS_FAILED;
 	}
 
@@ -244,7 +244,7 @@ bool UIWindow::loadFile(const char *filename) {
 	setFilename(filename);
 
 	if (DID_FAIL(ret = loadBuffer(buffer, true))) {
-		_gameRef->LOG(0, "Error parsing WINDOW file '%s'", filename);
+		_game->LOG(0, "Error parsing WINDOW file '%s'", filename);
 	}
 
 	delete[] buffer;
@@ -341,7 +341,7 @@ bool UIWindow::loadBuffer(char *buffer, bool complete) {
 
 	if (complete) {
 		if (parser.getCommand(&buffer, commands, &params) != TOKEN_WINDOW) {
-			_gameRef->LOG(0, "'WINDOW' keyword expected.");
+			_game->LOG(0, "'WINDOW' keyword expected.");
 			return STATUS_FAILED;
 		}
 		buffer = params;
@@ -365,7 +365,7 @@ bool UIWindow::loadBuffer(char *buffer, bool complete) {
 
 		case TOKEN_BACK:
 			SAFE_DELETE(_back);
-			_back = new UITiledImage(_gameRef);
+			_back = new UITiledImage(_game);
 			if (!_back || DID_FAIL(_back->loadFile(params))) {
 				SAFE_DELETE(_back);
 				cmd = PARSERR_GENERIC;
@@ -374,7 +374,7 @@ bool UIWindow::loadBuffer(char *buffer, bool complete) {
 
 		case TOKEN_BACK_INACTIVE:
 			delete _backInactive;
-			_backInactive = new UITiledImage(_gameRef);
+			_backInactive = new UITiledImage(_game);
 			if (!_backInactive || DID_FAIL(_backInactive->loadFile(params))) {
 				SAFE_DELETE(_backInactive);
 				cmd = PARSERR_GENERIC;
@@ -383,7 +383,7 @@ bool UIWindow::loadBuffer(char *buffer, bool complete) {
 
 		case TOKEN_IMAGE:
 			SAFE_DELETE(_image);
-			_image = new BaseSprite(_gameRef);
+			_image = new BaseSprite(_game);
 			if (!_image || DID_FAIL(_image->loadFile(params))) {
 				SAFE_DELETE(_image);
 				cmd = PARSERR_GENERIC;
@@ -392,7 +392,7 @@ bool UIWindow::loadBuffer(char *buffer, bool complete) {
 
 		case TOKEN_IMAGE_INACTIVE:
 			SAFE_DELETE(_imageInactive);
-			_imageInactive = new BaseSprite(_gameRef);
+			_imageInactive = new BaseSprite(_game);
 			if (!_imageInactive || DID_FAIL(_imageInactive->loadFile(params))) {
 				SAFE_DELETE(_imageInactive);
 				cmd = PARSERR_GENERIC;
@@ -401,9 +401,9 @@ bool UIWindow::loadBuffer(char *buffer, bool complete) {
 
 		case TOKEN_FONT:
 			if (_font) {
-				_gameRef->_fontStorage->removeFont(_font);
+				_game->_fontStorage->removeFont(_font);
 			}
-			_font = _gameRef->_fontStorage->addFont(params);
+			_font = _game->_fontStorage->addFont(params);
 			if (!_font) {
 				cmd = PARSERR_GENERIC;
 			}
@@ -411,9 +411,9 @@ bool UIWindow::loadBuffer(char *buffer, bool complete) {
 
 		case TOKEN_FONT_INACTIVE:
 			if (_fontInactive) {
-				_gameRef->_fontStorage->removeFont(_fontInactive);
+				_game->_fontStorage->removeFont(_fontInactive);
 			}
-			_fontInactive = _gameRef->_fontStorage->addFont(params);
+			_fontInactive = _game->_fontStorage->addFont(params);
 			if (!_fontInactive) {
 				cmd = PARSERR_GENERIC;
 			}
@@ -421,7 +421,7 @@ bool UIWindow::loadBuffer(char *buffer, bool complete) {
 
 		case TOKEN_TITLE:
 			setText(params);
-			_gameRef->expandStringByStringTable(&_text);
+			_game->expandStringByStringTable(&_text);
 			break;
 
 		case TOKEN_TITLE_ALIGN:
@@ -460,7 +460,7 @@ bool UIWindow::loadBuffer(char *buffer, bool complete) {
 
 		case TOKEN_CURSOR:
 			SAFE_DELETE(_cursor);
-			_cursor = new BaseSprite(_gameRef);
+			_cursor = new BaseSprite(_game);
 			if (!_cursor || DID_FAIL(_cursor->loadFile(params))) {
 				SAFE_DELETE(_cursor);
 				cmd = PARSERR_GENERIC;
@@ -468,7 +468,7 @@ bool UIWindow::loadBuffer(char *buffer, bool complete) {
 			break;
 
 		case TOKEN_BUTTON: {
-			UIButton *btn = new UIButton(_gameRef);
+			UIButton *btn = new UIButton(_game);
 			if (!btn || DID_FAIL(btn->loadBuffer(params, false))) {
 				SAFE_DELETE(btn);
 				cmd = PARSERR_GENERIC;
@@ -480,7 +480,7 @@ bool UIWindow::loadBuffer(char *buffer, bool complete) {
 		break;
 
 		case TOKEN_STATIC: {
-			UIText *text = new UIText(_gameRef);
+			UIText *text = new UIText(_game);
 			if (!text || DID_FAIL(text->loadBuffer(params, false))) {
 				SAFE_DELETE(text);
 				cmd = PARSERR_GENERIC;
@@ -492,7 +492,7 @@ bool UIWindow::loadBuffer(char *buffer, bool complete) {
 		break;
 
 		case TOKEN_EDIT: {
-			UIEdit *edit = new UIEdit(_gameRef);
+			UIEdit *edit = new UIEdit(_game);
 			if (!edit || DID_FAIL(edit->loadBuffer(params, false))) {
 				SAFE_DELETE(edit);
 				cmd = PARSERR_GENERIC;
@@ -504,7 +504,7 @@ bool UIWindow::loadBuffer(char *buffer, bool complete) {
 		break;
 
 		case TOKEN_WINDOW: {
-			UIWindow *win = new UIWindow(_gameRef);
+			UIWindow *win = new UIWindow(_game);
 			if (!win || DID_FAIL(win->loadBuffer(params, false))) {
 				SAFE_DELETE(win);
 				cmd = PARSERR_GENERIC;
@@ -574,17 +574,17 @@ bool UIWindow::loadBuffer(char *buffer, bool complete) {
 			break;
 
 		default:
-			if (DID_FAIL(_gameRef->windowLoadHook(this, &buffer, &params))) {
+			if (DID_FAIL(_game->windowLoadHook(this, &buffer, &params))) {
 				cmd = PARSERR_GENERIC;
 			}
 		}
 	}
 	if (cmd == PARSERR_TOKENNOTFOUND) {
-		_gameRef->LOG(0, "Syntax error in WINDOW definition");
+		_game->LOG(0, "Syntax error in WINDOW definition");
 		return STATUS_FAILED;
 	}
 	if (cmd == PARSERR_GENERIC) {
-		_gameRef->LOG(0, "Error loading WINDOW definition");
+		_game->LOG(0, "Error loading WINDOW definition");
 		return STATUS_FAILED;
 	}
 
@@ -782,9 +782,9 @@ bool UIWindow::scCallMethod(ScScript *script, ScStack *stack, ScStack *thisStack
 		stack->correctParams(1);
 
 		if (_fontInactive) {
-			_gameRef->_fontStorage->removeFont(_fontInactive);
+			_game->_fontStorage->removeFont(_fontInactive);
 		}
-		_fontInactive = _gameRef->_fontStorage->addFont(stack->pop()->getString());
+		_fontInactive = _game->_fontStorage->addFont(stack->pop()->getString());
 		stack->pushBool(_fontInactive != nullptr);
 
 		return STATUS_OK;
@@ -797,7 +797,7 @@ bool UIWindow::scCallMethod(ScScript *script, ScStack *stack, ScStack *thisStack
 		stack->correctParams(1);
 
 		SAFE_DELETE(_imageInactive);
-		_imageInactive = new BaseSprite(_gameRef);
+		_imageInactive = new BaseSprite(_game);
 		const char *filename = stack->pop()->getString();
 		if (!_imageInactive || DID_FAIL(_imageInactive->loadFile(filename))) {
 			SAFE_DELETE(_imageInactive);
@@ -874,8 +874,8 @@ bool UIWindow::scCallMethod(ScScript *script, ScStack *stack, ScStack *thisStack
 	//////////////////////////////////////////////////////////////////////////
 	else if (strcmp(name, "Center") == 0) {
 		stack->correctParams(0);
-		_posX = (_gameRef->_renderer->getWidth() - _width) / 2;
-		_posY = (_gameRef->_renderer->getHeight() - _height) / 2;
+		_posX = (_game->_renderer->getWidth() - _width) / 2;
+		_posY = (_game->_renderer->getHeight() - _height) / 2;
 		stack->pushNULL();
 		return STATUS_OK;
 	}
@@ -904,7 +904,7 @@ bool UIWindow::scCallMethod(ScScript *script, ScStack *stack, ScStack *thisStack
 		stack->correctParams(1);
 		ScValue *val = stack->pop();
 
-		UIButton *btn = new UIButton(_gameRef);
+		UIButton *btn = new UIButton(_game);
 		if (!val->isNULL()) {
 			btn->setName(val->getString());
 		}
@@ -923,7 +923,7 @@ bool UIWindow::scCallMethod(ScScript *script, ScStack *stack, ScStack *thisStack
 		stack->correctParams(1);
 		ScValue *val = stack->pop();
 
-		UIText *sta = new UIText(_gameRef);
+		UIText *sta = new UIText(_game);
 		if (!val->isNULL()) {
 			sta->setName(val->getString());
 		}
@@ -942,7 +942,7 @@ bool UIWindow::scCallMethod(ScScript *script, ScStack *stack, ScStack *thisStack
 		stack->correctParams(1);
 		ScValue *val = stack->pop();
 
-		UIEdit *edi = new UIEdit(_gameRef);
+		UIEdit *edi = new UIEdit(_game);
 		if (!val->isNULL()) {
 			edi->setName(val->getString());
 		}
@@ -961,7 +961,7 @@ bool UIWindow::scCallMethod(ScScript *script, ScStack *stack, ScStack *thisStack
 		stack->correctParams(1);
 		ScValue *val = stack->pop();
 
-		UIWindow *win = new UIWindow(_gameRef);
+		UIWindow *win = new UIWindow(_game);
 		if (!val->isNULL()) {
 			win->setName(val->getString());
 		}
@@ -992,7 +992,7 @@ bool UIWindow::scCallMethod(ScScript *script, ScStack *stack, ScStack *thisStack
 		}
 		stack->pushNULL();
 		return STATUS_OK;
-	} else if DID_SUCCEED(_gameRef->windowScriptMethodHook(this, script, stack, name)) {
+	} else if DID_SUCCEED(_game->windowScriptMethodHook(this, script, stack, name)) {
 		return STATUS_OK;
 	}
 
@@ -1224,9 +1224,9 @@ bool UIWindow::handleMouse(TMouseEvent event, TMouseButton button) {
 			getTotalOffset(&offsetX, &offsetY);
 			BasePlatform::offsetRect(&dragRect, _posX + offsetX, _posY + offsetY);
 
-			if (BasePlatform::ptInRect(&dragRect, _gameRef->_mousePos)) {
-				_dragFrom.x = _gameRef->_mousePos.x;
-				_dragFrom.y = _gameRef->_mousePos.y;
+			if (BasePlatform::ptInRect(&dragRect, _game->_mousePos)) {
+				_dragFrom.x = _game->_mousePos.x;
+				_dragFrom.y = _game->_mousePos.y;
 				_dragging = true;
 			}
 		}
@@ -1334,7 +1334,7 @@ bool UIWindow::goExclusive() {
 		_mode = WINDOW_EXCLUSIVE;
 		_visible = true;
 		_disable = false;
-		_gameRef->focusWindow(this);
+		_game->focusWindow(this);
 		return STATUS_OK;
 	} else {
 		return STATUS_FAILED;
@@ -1355,9 +1355,9 @@ bool UIWindow::goSystemExclusive() {
 	_ready = false;
 	_visible = true;
 	_disable = false;
-	_gameRef->focusWindow(this);
+	_game->focusWindow(this);
 
-	_gameRef->freeze(_pauseMusic);
+	_game->freeze(_pauseMusic);
 	return STATUS_OK;
 }
 
@@ -1365,7 +1365,7 @@ bool UIWindow::goSystemExclusive() {
 //////////////////////////////////////////////////////////////////////////
 bool UIWindow::close() {
 	if (_mode == WINDOW_SYSTEM_EXCLUSIVE) {
-		_gameRef->unfreeze();
+		_game->unfreeze();
 	}