[Scummvm-git-logs] scummvm master -> 6576b4883ac09ee841ad55effcd1f87f70a062b8

[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:
6576b4883a WINTERMUTE: Restore macro to make code aligned with original


Commit: 6576b4883ac09ee841ad55effcd1f87f70a062b8
    https://github.com/scummvm/scummvm/commit/6576b4883ac09ee841ad55effcd1f87f70a062b8
Author: Paweł Kołodziejski (aquadran at gmail.com)
Date: 2025-09-03T12:03:16+02:00

Commit Message:
WINTERMUTE: Restore macro to make code aligned with original

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_block.cpp
    engines/wintermute/ad/ad_entity.cpp
    engines/wintermute/ad/ad_game.cpp
    engines/wintermute/ad/ad_generic.cpp
    engines/wintermute/ad/ad_geom_ext.cpp
    engines/wintermute/ad/ad_geom_ext_node.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_response.cpp
    engines/wintermute/ad/ad_response_box.cpp
    engines/wintermute/ad/ad_response_context.cpp
    engines/wintermute/ad/ad_scene.cpp
    engines/wintermute/ad/ad_scene_geometry.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_walkplane.cpp
    engines/wintermute/base/base.cpp
    engines/wintermute/base/base_file_manager.cpp
    engines/wintermute/base/base_frame.cpp
    engines/wintermute/base/base_game.cpp
    engines/wintermute/base/base_named_object.cpp
    engines/wintermute/base/base_object.cpp
    engines/wintermute/base/base_persistence_manager.cpp
    engines/wintermute/base/base_region.cpp
    engines/wintermute/base/base_script_holder.cpp
    engines/wintermute/base/base_scriptable.cpp
    engines/wintermute/base/base_sprite.cpp
    engines/wintermute/base/base_sub_frame.cpp
    engines/wintermute/base/font/base_font_bitmap.cpp
    engines/wintermute/base/font/base_font_truetype.cpp
    engines/wintermute/base/gfx/3deffect_params.cpp
    engines/wintermute/base/gfx/3dmesh.cpp
    engines/wintermute/base/gfx/base_renderer.cpp
    engines/wintermute/base/gfx/skin_mesh_helper.cpp
    engines/wintermute/base/gfx/xanimation_channel.cpp
    engines/wintermute/base/gfx/xanimation_set.cpp
    engines/wintermute/base/gfx/xfile.cpp
    engines/wintermute/base/gfx/xframe_node.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/script.cpp
    engines/wintermute/base/scriptables/script_engine.cpp
    engines/wintermute/base/scriptables/script_ext_array.cpp
    engines/wintermute/base/scriptables/script_ext_file.cpp
    engines/wintermute/base/scriptables/script_ext_string.cpp
    engines/wintermute/base/sound/base_sound_buffer.cpp
    engines/wintermute/dcgf.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_theora_player.cpp


diff --git a/engines/wintermute/ad/ad_actor.cpp b/engines/wintermute/ad/ad_actor.cpp
index 7d257b48fcc..e91bc3d85bd 100644
--- a/engines/wintermute/ad/ad_actor.cpp
+++ b/engines/wintermute/ad/ad_actor.cpp
@@ -44,6 +44,7 @@
 #include "engines/wintermute/base/scriptables/script_stack.h"
 #include "engines/wintermute/base/particles/part_emitter.h"
 #include "engines/wintermute/base/base_engine.h"
+#include "engines/wintermute/dcgf.h"
 
 namespace Wintermute {
 
@@ -82,19 +83,13 @@ bool AdActor::setDefaultAnimNames() {
 
 //////////////////////////////////////////////////////////////////////////
 AdActor::~AdActor() {
-	delete _path;
-	_path = nullptr;
-	delete _targetPoint;
-	_targetPoint = nullptr;
+	SAFE_DELETE(_path);
+	SAFE_DELETE(_targetPoint);
 
-	delete _walkSprite;
-	_walkSprite = nullptr;
-	delete _standSprite;
-	_standSprite = nullptr;
-	delete _turnLeftSprite;
-	_turnLeftSprite = nullptr;
-	delete _turnRightSprite;
-	_turnRightSprite = nullptr;
+	SAFE_DELETE(_walkSprite);
+	SAFE_DELETE(_standSprite);
+	SAFE_DELETE(_turnLeftSprite);
+	SAFE_DELETE(_turnRightSprite);
 
 	_animSprite2 = nullptr; // ref only
 
@@ -109,8 +104,7 @@ AdActor::~AdActor() {
 	_talkSpritesEx.removeAll();
 
 	for (int32 i = 0; i < _anims.getSize(); i++) {
-		delete _anims[i];
-		_anims[i] = nullptr;
+		SAFE_DELETE(_anims[i]);
 	}
 	_anims.removeAll();
 }
@@ -285,8 +279,7 @@ bool AdActor::loadBuffer(char *buffer, bool complete) {
 			break;
 
 		case TOKEN_WALK:
-			delete _walkSprite;
-			_walkSprite = nullptr;
+			SAFE_DELETE(_walkSprite);
 			spr = new AdSpriteSet(_gameRef, this);
 			if (!spr || DID_FAIL(spr->loadBuffer(params, true, adGame->_texWalkLifeTime, CACHE_HALF))) {
 				cmd = PARSERR_GENERIC;
@@ -314,8 +307,7 @@ bool AdActor::loadBuffer(char *buffer, bool complete) {
 			break;
 
 		case TOKEN_STAND:
-			delete _standSprite;
-			_standSprite = nullptr;
+			SAFE_DELETE(_standSprite);
 			spr = new AdSpriteSet(_gameRef, this);
 			if (!spr || DID_FAIL(spr->loadBuffer(params, true, adGame->_texStandLifeTime))) {
 				cmd = PARSERR_GENERIC;
@@ -325,8 +317,7 @@ bool AdActor::loadBuffer(char *buffer, bool complete) {
 			break;
 
 		case TOKEN_TURN_LEFT:
-			delete _turnLeftSprite;
-			_turnLeftSprite = nullptr;
+			SAFE_DELETE(_turnLeftSprite);
 			spr = new AdSpriteSet(_gameRef, this);
 			if (!spr || DID_FAIL(spr->loadBuffer(params, true))) {
 				cmd = PARSERR_GENERIC;
@@ -336,8 +327,7 @@ bool AdActor::loadBuffer(char *buffer, bool complete) {
 			break;
 
 		case TOKEN_TURN_RIGHT:
-			delete _turnRightSprite;
-			_turnRightSprite = nullptr;
+			SAFE_DELETE(_turnRightSprite);
 			spr = new AdSpriteSet(_gameRef, this);
 			if (!spr || DID_FAIL(spr->loadBuffer(params, true))) {
 				cmd = PARSERR_GENERIC;
@@ -351,11 +341,10 @@ bool AdActor::loadBuffer(char *buffer, bool complete) {
 			break;
 
 		case TOKEN_CURSOR:
-			delete _cursor;
+			SAFE_DELETE(_cursor);
 			_cursor = new BaseSprite(_gameRef);
 			if (!_cursor || DID_FAIL(_cursor->loadFile(params))) {
-				delete _cursor;
-				_cursor = nullptr;
+				SAFE_DELETE(_cursor);
 				cmd = PARSERR_GENERIC;
 			}
 			break;
@@ -389,17 +378,13 @@ bool AdActor::loadBuffer(char *buffer, bool complete) {
 			break;
 
 		case TOKEN_BLOCKED_REGION: {
-			delete _blockRegion;
-			_blockRegion = nullptr;
-			delete _currentBlockRegion;
-			_currentBlockRegion = nullptr;
+			SAFE_DELETE(_blockRegion);
+			SAFE_DELETE(_currentBlockRegion);
 			BaseRegion *rgn = new BaseRegion(_gameRef);
 			BaseRegion *crgn = new BaseRegion(_gameRef);
 			if (!rgn || !crgn || DID_FAIL(rgn->loadBuffer(params, false))) {
-				delete _blockRegion;
-				_blockRegion = nullptr;
-				delete _currentBlockRegion;
-				_currentBlockRegion = nullptr;
+				SAFE_DELETE(_blockRegion);
+				SAFE_DELETE(_currentBlockRegion);
 				cmd = PARSERR_GENERIC;
 			} else {
 				_blockRegion = rgn;
@@ -410,17 +395,13 @@ bool AdActor::loadBuffer(char *buffer, bool complete) {
 		break;
 
 		case TOKEN_WAYPOINTS: {
-			delete _wptGroup;
-			_wptGroup = nullptr;
-			delete _currentWptGroup;
-			_currentWptGroup = nullptr;
+			SAFE_DELETE(_wptGroup);
+			SAFE_DELETE(_currentWptGroup);
 			AdWaypointGroup *wpt = new AdWaypointGroup(_gameRef);
 			AdWaypointGroup *cwpt = new AdWaypointGroup(_gameRef);
 			if (!wpt || !cwpt || DID_FAIL(wpt->loadBuffer(params, false))) {
-				delete _wptGroup;
-				_wptGroup = nullptr;
-				delete _currentWptGroup;
-				_currentWptGroup = nullptr;
+				SAFE_DELETE(_wptGroup);
+				SAFE_DELETE(_currentWptGroup);
 				cmd = PARSERR_GENERIC;
 			} else {
 				_wptGroup = wpt;
@@ -609,8 +590,7 @@ bool AdActor::update() {
 
 	if (_state == STATE_READY) {
 		if (_animSprite) {
-			delete _animSprite;
-			_animSprite = nullptr;
+			SAFE_DELETE(_animSprite);
 		}
 		if (_animSprite2) {
 			_animSprite2 = nullptr;
@@ -1145,8 +1125,7 @@ bool AdActor::scCallMethod(ScScript *script, ScStack *stack, ScStack *thisStack,
 					_animSprite2 = nullptr;
 				}
 
-				delete _anims[i];
-				_anims[i] = nullptr;
+				SAFE_DELETE(_anims[i]);
 				_anims.removeAt(i);
 				i--;
 				found = true;
@@ -1320,14 +1299,13 @@ BaseSprite *AdActor::getTalkStance(const char *stance) {
 	// forced stance?
 	if (_forcedTalkAnimName && !_forcedTalkAnimUsed) {
 		_forcedTalkAnimUsed = true;
-		delete _animSprite;
+		SAFE_DELETE(_animSprite);
 		_animSprite = new BaseSprite(_gameRef, 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);
-				delete _animSprite;
-				_animSprite = nullptr;
+				SAFE_DELETE(_animSprite);
 			} else {
 				return _animSprite;
 			}
diff --git a/engines/wintermute/ad/ad_actor_3dx.cpp b/engines/wintermute/ad/ad_actor_3dx.cpp
index aabeb659043..8b3dafefd1d 100644
--- a/engines/wintermute/ad/ad_actor_3dx.cpp
+++ b/engines/wintermute/ad/ad_actor_3dx.cpp
@@ -57,6 +57,7 @@
 #include "engines/wintermute/base/sound/base_sound.h"
 #include "engines/wintermute/utils/path_util.h"
 #include "engines/wintermute/utils/utils.h"
+#include "engines/wintermute/dcgf.h"
 
 namespace Wintermute {
 
@@ -115,13 +116,10 @@ AdActor3DX::~AdActor3DX() {
 	}
 	_transitionTimes.removeAll();
 
-	delete _path2D;
-	_path2D = nullptr;
-	delete _path3D;
-	_path3D = nullptr;
+	SAFE_DELETE(_path2D);
+	SAFE_DELETE(_path3D);
 
-	delete _targetPoint2D;
-	_targetPoint2D = nullptr;
+	SAFE_DELETE(_targetPoint2D);
 }
 
 //////////////////////////////////////////////////////////////////////////
@@ -142,8 +140,7 @@ bool AdActor3DX::update() {
 
 	if (_sentence && _state != STATE_TALKING) {
 		_sentence->finish();
-		delete _sentence;
-		_sentence = nullptr;
+		SAFE_DELETE(_sentence);
 
 		// kill talking anim
 		if (_talkAnimChannel > 0)
@@ -960,10 +957,8 @@ bool AdActor3DX::loadBuffer(char *buffer, bool complete) {
 		buffer = params;
 	}
 
-	delete _xmodel;
-	_xmodel = nullptr;
-	delete _shadowModel;
-	_shadowModel = nullptr;
+	SAFE_DELETE(_xmodel);
+	SAFE_DELETE(_shadowModel);
 
 	while ((cmd = parser.getCommand(&buffer, commands, &params)) > 0) {
 		switch (cmd) {
@@ -1096,8 +1091,7 @@ bool AdActor3DX::loadBuffer(char *buffer, bool complete) {
 				_xmodel = new XModel(_gameRef, this);
 
 				if (!_xmodel || !_xmodel->loadFromFile(params)) {
-					delete _xmodel;
-					_xmodel = nullptr;
+					SAFE_DELETE(_xmodel);
 					cmd = PARSERR_GENERIC;
 				}
 			} else {
@@ -1109,12 +1103,11 @@ bool AdActor3DX::loadBuffer(char *buffer, bool complete) {
 
 		case TOKEN_SHADOW_MODEL:
 			if (_xmodel) {
-				delete _shadowModel;
+				SAFE_DELETE(_shadowModel);
 				_shadowModel = new XModel(_gameRef, this);
 
 				if (!_shadowModel || !_shadowModel->loadFromFile(params, _xmodel)) {
-					delete _shadowModel;
-					_shadowModel = nullptr;
+					SAFE_DELETE(_shadowModel);
 					cmd = PARSERR_GENERIC;
 				}
 			} else {
@@ -1123,11 +1116,10 @@ bool AdActor3DX::loadBuffer(char *buffer, bool complete) {
 			break;
 
 		case TOKEN_CURSOR:
-			delete _cursor;
+			SAFE_DELETE(_cursor);
 			_cursor = new BaseSprite(_gameRef);
 			if (!_cursor || !_cursor->loadFile(params)) {
-				delete _cursor;
-				_cursor = nullptr;
+				SAFE_DELETE(_cursor);
 				cmd = PARSERR_GENERIC;
 			}
 			break;
@@ -1168,15 +1160,13 @@ bool AdActor3DX::loadBuffer(char *buffer, bool complete) {
 			break;
 
 		case TOKEN_BLOCKED_REGION: {
-			delete _blockRegion;
-			_blockRegion = nullptr;
-			delete _currentBlockRegion;
-			_currentBlockRegion = nullptr;
+			SAFE_DELETE(_blockRegion);
+			SAFE_DELETE(_currentBlockRegion);
 			BaseRegion *rgn = new BaseRegion(_gameRef);
 			BaseRegion *crgn = new BaseRegion(_gameRef);
 			if (!rgn || !crgn || !rgn->loadBuffer(params, false)) {
-				delete rgn;
-				delete crgn;
+				SAFE_DELETE(rgn);
+				SAFE_DELETE(crgn);
 				cmd = PARSERR_GENERIC;
 			} else {
 				_blockRegion = rgn;
@@ -1187,15 +1177,13 @@ bool AdActor3DX::loadBuffer(char *buffer, bool complete) {
 		}
 
 		case TOKEN_WAYPOINTS: {
-			delete _wptGroup;
-			_wptGroup = nullptr;
-			delete _currentWptGroup;
-			_currentWptGroup = nullptr;
+			SAFE_DELETE(_wptGroup);
+			SAFE_DELETE(_currentWptGroup);
 			AdWaypointGroup *wpt = new AdWaypointGroup(_gameRef);
 			AdWaypointGroup *cwpt = new AdWaypointGroup(_gameRef);
 			if (!wpt || !cwpt || !wpt->loadBuffer(params, false)) {
-				delete wpt;
-				delete cwpt;
+				SAFE_DELETE(wpt);
+				SAFE_DELETE(cwpt);
 				cmd = PARSERR_GENERIC;
 			} else {
 				_wptGroup = wpt;
@@ -1447,13 +1435,13 @@ bool AdActor3DX::scCallMethod(ScScript *script, ScStack *stack, ScStack *thisSta
 				AdAttach3DX *at = new AdAttach3DX(_gameRef, this);
 				if (!at || !at->init(filename, attachName, boneName)) {
 					script->runtimeError("Error adding attachment");
-					delete at;
+					SAFE_DELETE(at);
 					stack->pushBool(false);
 				} else {
 					bool isSet = false;
 					for (int32 i = 0; i < _attachments.getSize(); i++) {
 						if (scumm_stricmp(_attachments[i]->_name, attachName) == 0) {
-							delete _attachments[i];
+							SAFE_DELETE(_attachments[i]);
 							_attachments[i] = at;
 							isSet = true;
 							break;
@@ -1487,7 +1475,7 @@ bool AdActor3DX::scCallMethod(ScScript *script, ScStack *stack, ScStack *thisSta
 			bool isFound = false;
 			for (int32 i = 0; i < _attachments.getSize(); i++) {
 				if (scumm_stricmp(_attachments[i]->_name, attachmentName) == 0) {
-					delete _attachments[i];
+					SAFE_DELETE(_attachments[i]);
 					_attachments.removeAt(i);
 					isFound = true;
 					break;
@@ -2530,8 +2518,8 @@ bool AdActor3DX::parseEffect(char *buffer) {
 		}
 	}
 
-	delete[] effectFile;
-	delete[] material;
+	SAFE_DELETE_ARRAY(effectFile);
+	SAFE_DELETE_ARRAY(material);
 
 	return true;
 }
diff --git a/engines/wintermute/ad/ad_attach_3dx.cpp b/engines/wintermute/ad/ad_attach_3dx.cpp
index 2c5227c7753..ef195377357 100644
--- a/engines/wintermute/ad/ad_attach_3dx.cpp
+++ b/engines/wintermute/ad/ad_attach_3dx.cpp
@@ -34,6 +34,7 @@
 #include "engines/wintermute/base/scriptables/script.h"
 #include "engines/wintermute/base/scriptables/script_stack.h"
 #include "engines/wintermute/base/scriptables/script_value.h"
+#include "engines/wintermute/dcgf.h"
 
 namespace Wintermute {
 
@@ -52,8 +53,7 @@ AdAttach3DX::~AdAttach3DX() {
 
 //////////////////////////////////////////////////////////////////////////
 bool AdAttach3DX::init(const char *modelFile, const char *name, const char *parentBone) {
-	delete _xmodel;
-	_xmodel = nullptr;
+	SAFE_DELETE(_xmodel);
 
 	_parentBone = parentBone;
 	setName(name);
@@ -65,8 +65,7 @@ bool AdAttach3DX::init(const char *modelFile, const char *name, const char *pare
 
 	bool res = _xmodel->loadFromFile(modelFile);
 	if (!res) {
-		delete _xmodel;
-		_xmodel = nullptr;
+		SAFE_DELETE(_xmodel);
 	}
 
 	return res;
diff --git a/engines/wintermute/ad/ad_block.cpp b/engines/wintermute/ad/ad_block.cpp
index b92d93bdab4..a478686bbd9 100644
--- a/engines/wintermute/ad/ad_block.cpp
+++ b/engines/wintermute/ad/ad_block.cpp
@@ -28,6 +28,7 @@
 #include "engines/wintermute/ad/ad_block.h"
 #include "engines/wintermute/base/base_persistence_manager.h"
 #include "engines/wintermute/base/gfx/3dmesh.h"
+#include "engines/wintermute/dcgf.h"
 
 namespace Wintermute {
 
@@ -40,8 +41,7 @@ AdBlock::AdBlock(BaseGame *inGame) : BaseScriptable(inGame, false, false) {
 
 //////////////////////////////////////////////////////////////////////////
 AdBlock::~AdBlock() {
-	delete _mesh;
-	_mesh = nullptr;
+	SAFE_DELETE(_mesh);
 }
 
 //////////////////////////////////////////////////////////////////////////
diff --git a/engines/wintermute/ad/ad_entity.cpp b/engines/wintermute/ad/ad_entity.cpp
index ff9c47eb841..fa1cfa90f00 100644
--- a/engines/wintermute/ad/ad_entity.cpp
+++ b/engines/wintermute/ad/ad_entity.cpp
@@ -53,6 +53,7 @@
 #include "engines/wintermute/video/video_theora_player.h"
 #include "engines/wintermute/utils/utils.h"
 #include "engines/wintermute/platform_osystem.h"
+#include "engines/wintermute/dcgf.h"
 
 #include "common/str.h"
 
@@ -81,12 +82,9 @@ AdEntity::AdEntity(BaseGame *inGame) : AdTalkHolder(inGame) {
 //////////////////////////////////////////////////////////////////////////
 AdEntity::~AdEntity() {
 	_gameRef->unregisterObject(_region);
+	SAFE_DELETE(_theora);
 
-	delete _theora;
-	_theora = nullptr;
-
-	delete[] _item;
-	_item = nullptr;
+	SAFE_DELETE_ARRAY(_item);
 }
 
 #ifdef ENABLE_FOXTAIL
@@ -253,8 +251,7 @@ bool AdEntity::loadBuffer(char *buffer, bool complete) {
 			break;
 
 		case TOKEN_SPRITE: {
-			delete _sprite;
-			_sprite = nullptr;
+			SAFE_DELETE(_sprite);
 			spr = new BaseSprite(_gameRef, this);
 			if (!spr || DID_FAIL(spr->loadFile(params))) {
 				cmd = PARSERR_GENERIC;
@@ -340,11 +337,10 @@ bool AdEntity::loadBuffer(char *buffer, bool complete) {
 			break;
 
 		case TOKEN_CURSOR:
-			delete _cursor;
+			SAFE_DELETE(_cursor);
 			_cursor = new BaseSprite(_gameRef);
 			if (!_cursor || DID_FAIL(_cursor->loadFile(params))) {
-				delete _cursor;
-				_cursor = nullptr;
+				SAFE_DELETE(_cursor);
 				cmd = PARSERR_GENERIC;
 			}
 			break;
@@ -369,17 +365,13 @@ bool AdEntity::loadBuffer(char *buffer, bool complete) {
 		break;
 
 		case TOKEN_BLOCKED_REGION: {
-			delete _blockRegion;
-			_blockRegion = nullptr;
-			delete _currentBlockRegion;
-			_currentBlockRegion = nullptr;
+			SAFE_DELETE(_blockRegion);
+			SAFE_DELETE(_currentBlockRegion);
 			BaseRegion *rgn = new BaseRegion(_gameRef);
 			BaseRegion *crgn = new BaseRegion(_gameRef);
 			if (!rgn || !crgn || DID_FAIL(rgn->loadBuffer(params, false))) {
-				delete _blockRegion;
-				_blockRegion = nullptr;
-				delete _currentBlockRegion;
-				_currentBlockRegion = nullptr;
+				SAFE_DELETE(_blockRegion);
+				SAFE_DELETE(_currentBlockRegion);
 				cmd = PARSERR_GENERIC;
 			} else {
 				_blockRegion = rgn;
@@ -390,17 +382,13 @@ bool AdEntity::loadBuffer(char *buffer, bool complete) {
 		break;
 
 		case TOKEN_WAYPOINTS: {
-			delete _wptGroup;
-			_wptGroup = nullptr;
-			delete _currentWptGroup;
-			_currentWptGroup = nullptr;
+			SAFE_DELETE(_wptGroup);
+			SAFE_DELETE(_currentWptGroup);
 			AdWaypointGroup *wpt = new AdWaypointGroup(_gameRef);
 			AdWaypointGroup *cwpt = new AdWaypointGroup(_gameRef);
 			if (!wpt || !cwpt || DID_FAIL(wpt->loadBuffer(params, false))) {
-				delete _wptGroup;
-				_wptGroup = nullptr;
-				delete _currentWptGroup;
-				_currentWptGroup = nullptr;
+				SAFE_DELETE(_wptGroup);
+				SAFE_DELETE(_currentWptGroup);
 				cmd = PARSERR_GENERIC;
 			} else {
 				_wptGroup = wpt;
@@ -416,8 +404,7 @@ bool AdEntity::loadBuffer(char *buffer, bool complete) {
 
 		case TOKEN_SUBTYPE: {
 			if (scumm_stricmp(params, "sound") == 0) {
-				delete _sprite;
-				_sprite = nullptr;
+				SAFE_DELETE(_sprite);
 				if (_gameRef->_editorMode) {
 					spr = new BaseSprite(_gameRef, this);
 					if (!spr || DID_FAIL(spr->loadFile("entity_sound.sprite"))) {
@@ -625,12 +612,11 @@ bool AdEntity::update() {
 	_currentSprite = nullptr;
 
 	if (_state == STATE_READY && _animSprite) {
-		delete _animSprite;
-		_animSprite = nullptr;
+		SAFE_DELETE(_animSprite);
 	}
 
 	// finished playing animation?
-	if (_state == STATE_PLAYING_ANIM && _animSprite != nullptr && _animSprite->isFinished()) {
+	if (_state == STATE_PLAYING_ANIM && _animSprite != nullptr && _animSprite->_finished) {
 		_state = STATE_READY;
 		_currentSprite = _animSprite;
 	}
@@ -709,8 +695,7 @@ bool AdEntity::update() {
 		_theora->update();
 		if (_theora->isFinished()) {
 			_theora->stop();
-			delete _theora;
-			_theora = nullptr;
+			SAFE_DELETE(_theora);
 		}
 	}
 
@@ -749,7 +734,7 @@ bool AdEntity::scCallMethod(ScScript *script, ScStack *stack, ScStack *thisStack
 		ScValue *valAlpha = stack->pop();
 		int startTime = stack->pop()->getInt();
 
-		delete _theora;
+		SAFE_DELETE(_theora);
 		_theora = new VideoTheoraPlayer(_gameRef);
 		if (_theora && DID_SUCCEED(_theora->initialize(filename))) {
 			if (!valAlpha->isNULL()) {
@@ -773,8 +758,7 @@ bool AdEntity::scCallMethod(ScScript *script, ScStack *stack, ScStack *thisStack
 		stack->correctParams(0);
 		if (_theora) {
 			_theora->stop();
-			delete _theora;
-			_theora = nullptr;
+			SAFE_DELETE(_theora);
 			stack->pushBool(true);
 		} else {
 			stack->pushBool(false);
@@ -1284,12 +1268,10 @@ bool AdEntity::setSprite(const char *filename) {
 		_currentSprite = nullptr;
 	}
 
-	delete _sprite;
-	_sprite = nullptr;
+	SAFE_DELETE(_sprite);
 	BaseSprite *spr = new BaseSprite(_gameRef, this);
 	if (!spr || DID_FAIL(spr->loadFile(filename))) {
-		delete _sprite;
-		_sprite = nullptr;
+		SAFE_DELETE(_sprite);
 		return STATUS_FAILED;
 	} else {
 		_sprite = spr;
diff --git a/engines/wintermute/ad/ad_game.cpp b/engines/wintermute/ad/ad_game.cpp
index 05da76078e4..956832cdad5 100644
--- a/engines/wintermute/ad/ad_game.cpp
+++ b/engines/wintermute/ad/ad_game.cpp
@@ -67,6 +67,7 @@
 #include "engines/wintermute/video/video_player.h"
 #include "engines/wintermute/video/video_theora_player.h"
 #include "engines/wintermute/platform_osystem.h"
+#include "engines/wintermute/dcgf.h"
 
 #include "common/config-manager.h"
 #include "common/str.h"
@@ -177,20 +178,13 @@ bool AdGame::cleanup() {
 		_inventoryBox = nullptr;
 	}
 
-	delete[] _prevSceneName;
-	delete[] _prevSceneFilename;
-	delete[] _scheduledScene;
-	delete[] _debugStartupScene;
-	delete[] _itemsFile;
-	_prevSceneName = nullptr;
-	_prevSceneFilename = nullptr;
-	_scheduledScene = nullptr;
-	_debugStartupScene = nullptr;
-	_startupScene = nullptr;
-	_itemsFile = nullptr;
+	SAFE_DELETE_ARRAY(_prevSceneName);
+	SAFE_DELETE_ARRAY(_prevSceneFilename);
+	SAFE_DELETE_ARRAY(_scheduledScene);
+	SAFE_DELETE_ARRAY(_debugStartupScene);
+	SAFE_DELETE_ARRAY(_itemsFile);
 
-	delete _sceneViewport;
-	_sceneViewport = nullptr;
+	SAFE_DELETE(_sceneViewport);
 
 	for (int32 i = 0; i < _sceneStates.getSize(); i++) {
 		delete _sceneStates[i];
@@ -215,8 +209,7 @@ bool AdGame::cleanup() {
 bool AdGame::initLoop() {
 	if (_scheduledScene && _transMgr->isReady()) {
 		changeScene(_scheduledScene, _scheduledFadeIn);
-		delete[] _scheduledScene;
-		_scheduledScene = nullptr;
+		SAFE_DELETE_ARRAY(_scheduledScene);
 
 		_gameRef->_activeObject = nullptr;
 	}
@@ -404,8 +397,7 @@ bool AdGame::scCallMethod(ScScript *script, ScStack *stack, ScStack *thisStack,
 			addObject(act);
 			stack->pushNative(act, true);
 		} else {
-			delete act;
-			act = nullptr;
+			SAFE_DELETE(act);
 			stack->pushNULL();
 		}
 		return STATUS_OK;
@@ -425,8 +417,7 @@ bool AdGame::scCallMethod(ScScript *script, ScStack *stack, ScStack *thisStack,
 			addObject(act);
 			stack->pushNative(act, true);
 		} else {
-			delete act;
-			act = nullptr;
+			SAFE_DELETE(act);
 			stack->pushNULL();
 		}
 		return STATUS_OK;
@@ -443,8 +434,7 @@ bool AdGame::scCallMethod(ScScript *script, ScStack *stack, ScStack *thisStack,
 			addObject(ent);
 			stack->pushNative(ent, true);
 		} else {
-			delete ent;
-			ent = nullptr;
+			SAFE_DELETE(ent);
 			stack->pushNULL();
 		}
 		return STATUS_OK;
@@ -834,8 +824,7 @@ bool AdGame::scCallMethod(ScScript *script, ScStack *stack, ScStack *thisStack,
 			registerObject(_responseBox);
 			stack->pushBool(true);
 		} else {
-			delete _responseBox;
-			_responseBox = nullptr;
+			SAFE_DELETE(_responseBox);
 			stack->pushBool(false);
 		}
 		return STATUS_OK;
@@ -854,8 +843,7 @@ bool AdGame::scCallMethod(ScScript *script, ScStack *stack, ScStack *thisStack,
 			registerObject(_inventoryBox);
 			stack->pushBool(true);
 		} else {
-			delete _inventoryBox;
-			_inventoryBox = nullptr;
+			SAFE_DELETE(_inventoryBox);
 			stack->pushBool(false);
 		}
 		return STATUS_OK;
@@ -1253,8 +1241,7 @@ bool AdGame::scSetProperty(const char *name, ScValue *value) {
 	//////////////////////////////////////////////////////////////////////////
 	else if (strcmp(name, "StartupScene") == 0) {
 		if (value == nullptr) {
-			delete[] _startupScene;
-			_startupScene = nullptr;
+			SAFE_DELETE_ARRAY(_startupScene);
 		} else {
 			BaseUtils::setString(&_startupScene, value->getString());
 		}
@@ -1405,25 +1392,23 @@ bool AdGame::loadBuffer(char *buffer, bool complete) {
 			while (cmd > 0 && (cmd = parser.getCommand(&params, commands, &params2)) > 0) {
 				switch (cmd) {
 				case TOKEN_RESPONSE_BOX:
-					delete _responseBox;
+					SAFE_DELETE(_responseBox);
 					_responseBox = new AdResponseBox(_gameRef);
 					if (_responseBox && !DID_FAIL(_responseBox->loadFile(params2))) {
 						registerObject(_responseBox);
 					} else {
-						delete _responseBox;
-						_responseBox = nullptr;
+						SAFE_DELETE(_responseBox);
 						cmd = PARSERR_GENERIC;
 					}
 					break;
 
 				case TOKEN_INVENTORY_BOX:
-					delete _inventoryBox;
+					SAFE_DELETE(_inventoryBox);
 					_inventoryBox = new AdInventoryBox(_gameRef);
 					if (_inventoryBox && !DID_FAIL(_inventoryBox->loadFile(params2))) {
 						registerObject(_inventoryBox);
 					} else {
-						delete _inventoryBox;
-						_inventoryBox = nullptr;
+						SAFE_DELETE(_inventoryBox);
 						cmd = PARSERR_GENERIC;
 					}
 					break;
@@ -1432,8 +1417,7 @@ bool AdGame::loadBuffer(char *buffer, bool complete) {
 					itemsFound = true;
 					BaseUtils::setString(&_itemsFile, params2);
 					if (DID_FAIL(loadItemsFile(_itemsFile))) {
-						delete[] _itemsFile;
-						_itemsFile = nullptr;
+						SAFE_DELETE_ARRAY(_itemsFile);
 						cmd = PARSERR_GENERIC;
 					}
 					break;
@@ -1570,8 +1554,7 @@ bool AdGame::persist(BasePersistenceManager *persistMgr) {
 
 //////////////////////////////////////////////////////////////////////////
 void AdGame::setPrevSceneName(const char *name) {
-	delete[] _prevSceneName;
-	_prevSceneName = nullptr;
+	SAFE_DELETE_ARRAY(_prevSceneName);
 	if (name) {
 		size_t nameSize = strlen(name) + 1;
 		_prevSceneName = new char[nameSize];
@@ -1582,8 +1565,7 @@ void AdGame::setPrevSceneName(const char *name) {
 
 //////////////////////////////////////////////////////////////////////////
 void AdGame::setPrevSceneFilename(const char *name) {
-	delete[] _prevSceneFilename;
-	_prevSceneFilename = nullptr;
+	SAFE_DELETE_ARRAY(_prevSceneFilename);
 	if (name) {
 		size_t nameSize = strlen(name) + 1;
 		_prevSceneFilename = new char[nameSize];
@@ -1594,8 +1576,7 @@ void AdGame::setPrevSceneFilename(const char *name) {
 
 //////////////////////////////////////////////////////////////////////////
 bool AdGame::scheduleChangeScene(const char *filename, bool fadeIn) {
-	delete[] _scheduledScene;
-	_scheduledScene = nullptr;
+	SAFE_DELETE_ARRAY(_scheduledScene);
 
 	if (_scene && !_scene->_initialized) {
 		return changeScene(filename, fadeIn);
@@ -1794,8 +1775,7 @@ bool AdGame::loadItemsBuffer(char *buffer, bool merge) {
 				}
 				addItem(item);
 			} else {
-				delete item;
-				item = nullptr;
+				SAFE_DELETE(item);
 				cmd = PARSERR_GENERIC;
 			}
 		}
@@ -1866,8 +1846,7 @@ bool AdGame::windowLoadHook(UIWindow *win, char **buffer, char **params) {
 	case TOKEN_ENTITY_CONTAINER: {
 		UIEntity *ent = new UIEntity(_gameRef);
 		if (!ent || DID_FAIL(ent->loadBuffer(*params, false))) {
-			delete ent;
-			ent = nullptr;
+			SAFE_DELETE(ent);
 			cmd = PARSERR_GENERIC;
 		} else {
 			ent->_parent = win;
@@ -2095,8 +2074,7 @@ bool AdGame::displayContent(bool doUpdate, bool displayAll) {
 			_theoraPlayer->display();
 		}
 		if (_theoraPlayer->isFinished()) {
-			delete _theoraPlayer;
-			_theoraPlayer = nullptr;
+			SAFE_DELETE(_theoraPlayer);
 		}
 	} else {
 
@@ -2150,8 +2128,7 @@ bool AdGame::displayContent(bool doUpdate, bool displayAll) {
 	if (_loadingIcon) {
 		_loadingIcon->display(_loadingIconX, _loadingIconY);
 		if (!_loadingIconPersistent) {
-			delete _loadingIcon;
-			_loadingIcon = nullptr;
+			SAFE_DELETE(_loadingIcon);
 		}
 	}
 
diff --git a/engines/wintermute/ad/ad_generic.cpp b/engines/wintermute/ad/ad_generic.cpp
index ecb58e1c46a..9be0c75a184 100644
--- a/engines/wintermute/ad/ad_generic.cpp
+++ b/engines/wintermute/ad/ad_generic.cpp
@@ -28,6 +28,7 @@
 #include "engines/wintermute/ad/ad_generic.h"
 #include "engines/wintermute/base/base_persistence_manager.h"
 #include "engines/wintermute/base/gfx/3dmesh.h"
+#include "engines/wintermute/dcgf.h"
 
 namespace Wintermute {
 
@@ -40,8 +41,7 @@ AdGeneric::AdGeneric(BaseGame *inGame) : BaseScriptable(inGame, false, false) {
 
 //////////////////////////////////////////////////////////////////////////
 AdGeneric::~AdGeneric() {
-	delete _mesh;
-	_mesh = nullptr;
+	SAFE_DELETE(_mesh);
 }
 
 //////////////////////////////////////////////////////////////////////////
diff --git a/engines/wintermute/ad/ad_geom_ext.cpp b/engines/wintermute/ad/ad_geom_ext.cpp
index 793401198dd..6ba8337fb3b 100644
--- a/engines/wintermute/ad/ad_geom_ext.cpp
+++ b/engines/wintermute/ad/ad_geom_ext.cpp
@@ -32,6 +32,7 @@
 #include "engines/wintermute/base/base_game.h"
 #include "engines/wintermute/base/base_parser.h"
 #include "engines/wintermute/utils/utils.h"
+#include "engines/wintermute/dcgf.h"
 
 namespace Wintermute {
 
@@ -42,8 +43,7 @@ AdGeomExt::AdGeomExt(BaseGame *in_gameRef) : BaseClass(in_gameRef) {
 //////////////////////////////////////////////////////////////////////////
 AdGeomExt::~AdGeomExt() {
 	for (int32 i = 0; i < _nodes.getSize(); i++) {
-		delete _nodes[i];
-		_nodes[i] = nullptr;
+		SAFE_DELETE(_nodes[i]);
 	}
 	_nodes.removeAll();
 }
@@ -96,10 +96,7 @@ bool AdGeomExt::loadBuffer(char *buffer) {
 			if (node && node->loadBuffer(params, false)) {
 				_nodes.add(node);
 			} else {
-				if (node) {
-					delete node;
-				}
-
+				SAFE_DELETE(node);
 				cmd = PARSERR_GENERIC;
 				}
 			}
diff --git a/engines/wintermute/ad/ad_geom_ext_node.cpp b/engines/wintermute/ad/ad_geom_ext_node.cpp
index 4122eb8e577..acfc4b80b3b 100644
--- a/engines/wintermute/ad/ad_geom_ext_node.cpp
+++ b/engines/wintermute/ad/ad_geom_ext_node.cpp
@@ -31,6 +31,7 @@
 #include "engines/wintermute/base/base_game.h"
 #include "engines/wintermute/base/base_parser.h"
 #include "engines/wintermute/utils/utils.h"
+#include "engines/wintermute/dcgf.h"
 
 namespace Wintermute {
 
@@ -43,8 +44,7 @@ AdGeomExtNode::AdGeomExtNode(BaseGame *inGame) : BaseClass(inGame) {
 
 //////////////////////////////////////////////////////////////////////////
 AdGeomExtNode::~AdGeomExtNode() {
-	delete[] _namePattern;
-	_namePattern = nullptr;
+	SAFE_DELETE_ARRAY(_namePattern);
 }
 
 TOKEN_DEF_START
diff --git a/engines/wintermute/ad/ad_inventory_box.cpp b/engines/wintermute/ad/ad_inventory_box.cpp
index 33efdf80baf..6f39638afbb 100644
--- a/engines/wintermute/ad/ad_inventory_box.cpp
+++ b/engines/wintermute/ad/ad_inventory_box.cpp
@@ -38,6 +38,8 @@
 #include "engines/wintermute/ui/ui_button.h"
 #include "engines/wintermute/ui/ui_window.h"
 #include "engines/wintermute/platform_osystem.h"
+#include "engines/wintermute/dcgf.h"
+
 #include "common/str.h"
 #include "common/rect.h"
 
@@ -68,8 +70,7 @@ AdInventoryBox::~AdInventoryBox() {
 	_gameRef->unregisterObject(_window);
 	_window = nullptr;
 
-	delete _closeButton;
-	_closeButton = nullptr;
+	SAFE_DELETE(_closeButton);
 }
 
 
@@ -251,11 +252,10 @@ bool AdInventoryBox::loadBuffer(char *buffer, bool complete) {
 			break;
 
 		case TOKEN_WINDOW:
-			delete _window;
+			SAFE_DELETE(_window);
 			_window = new UIWindow(_gameRef);
 			if (!_window || DID_FAIL(_window->loadBuffer(params, false))) {
-				delete _window;
-				_window = nullptr;
+				SAFE_DELETE(_window);
 				cmd = PARSERR_GENERIC;
 			} else {
 				_gameRef->registerObject(_window);
@@ -312,7 +312,7 @@ bool AdInventoryBox::loadBuffer(char *buffer, bool complete) {
 	}
 
 	if (_exclusive) {
-		delete _closeButton;
+		SAFE_DELETE(_closeButton);
 		_closeButton = new UIButton(_gameRef);
 		if (_closeButton) {
 			_closeButton->setName("close");
diff --git a/engines/wintermute/ad/ad_item.cpp b/engines/wintermute/ad/ad_item.cpp
index 8e6a93afa70..f2fc57b0afc 100644
--- a/engines/wintermute/ad/ad_item.cpp
+++ b/engines/wintermute/ad/ad_item.cpp
@@ -40,6 +40,8 @@
 #include "engines/wintermute/base/scriptables/script_value.h"
 #include "engines/wintermute/utils/utils.h"
 #include "engines/wintermute/platform_osystem.h"
+#include "engines/wintermute/dcgf.h"
+
 #include "common/str.h"
 
 namespace Wintermute {
@@ -69,15 +71,11 @@ AdItem::AdItem(BaseGame *inGame) : AdTalkHolder(inGame) {
 
 //////////////////////////////////////////////////////////////////////////
 AdItem::~AdItem() {
-	delete _spriteHover;
-	_spriteHover = nullptr;
-	delete _cursorNormal;
-	_cursorNormal = nullptr;
-	delete _cursorHover;
-	_cursorHover = nullptr;
+	SAFE_DELETE(_spriteHover);
+	SAFE_DELETE(_cursorNormal);
+	SAFE_DELETE(_cursorHover);
 
-	delete[] _amountString;
-	_amountString = nullptr;
+	SAFE_DELETE_ARRAY(_amountString);
 }
 
 
@@ -198,22 +196,20 @@ bool AdItem::loadBuffer(char *buffer, bool complete) {
 
 		case TOKEN_IMAGE:
 		case TOKEN_SPRITE:
-			delete _sprite;
+			SAFE_DELETE(_sprite);
 			_sprite = new BaseSprite(_gameRef, this);
 			if (!_sprite || DID_FAIL(_sprite->loadFile(params, ((AdGame *)_gameRef)->_texItemLifeTime))) {
-				delete _sprite;
-				_sprite = nullptr;
+				SAFE_DELETE(_sprite);
 				cmd = PARSERR_GENERIC;
 			}
 			break;
 
 		case TOKEN_IMAGE_HOVER:
 		case TOKEN_SPRITE_HOVER:
-			delete _spriteHover;
+			SAFE_DELETE(_spriteHover);
 			_spriteHover = new BaseSprite(_gameRef, this);
 			if (!_spriteHover || DID_FAIL(_spriteHover->loadFile(params, ((AdGame *)_gameRef)->_texItemLifeTime))) {
-				delete _spriteHover;
-				_spriteHover = nullptr;
+				SAFE_DELETE(_spriteHover);
 				cmd = PARSERR_GENERIC;
 			}
 			break;
@@ -269,21 +265,19 @@ bool AdItem::loadBuffer(char *buffer, bool complete) {
 		break;
 
 		case TOKEN_CURSOR:
-			delete _cursorNormal;
+			SAFE_DELETE(_cursorNormal);
 			_cursorNormal = new BaseSprite(_gameRef);
 			if (!_cursorNormal || DID_FAIL(_cursorNormal->loadFile(params, ((AdGame *)_gameRef)->_texItemLifeTime))) {
-				delete _cursorNormal;
-				_cursorNormal = nullptr;
+				SAFE_DELETE(_cursorNormal);
 				cmd = PARSERR_GENERIC;
 			}
 			break;
 
 		case TOKEN_CURSOR_HOVER:
-			delete _cursorHover;
+			SAFE_DELETE(_cursorHover);
 			_cursorHover = new BaseSprite(_gameRef);
 			if (!_cursorHover || DID_FAIL(_cursorHover->loadFile(params, ((AdGame *)_gameRef)->_texItemLifeTime))) {
-				delete _cursorHover;
-				_cursorHover = nullptr;
+				SAFE_DELETE(_cursorHover);
 				cmd = PARSERR_GENERIC;
 			}
 			break;
@@ -339,8 +333,7 @@ bool AdItem::update() {
 	_currentSprite = nullptr;
 
 	if (_state == STATE_READY && _animSprite) {
-		delete _animSprite;
-		_animSprite = nullptr;
+		SAFE_DELETE(_animSprite);
 	}
 
 	// finished playing animation?
@@ -472,8 +465,7 @@ bool AdItem::scCallMethod(ScScript *script, ScStack *stack, ScStack *thisStack,
 
 		const char *filename = stack->pop()->getString();
 
-		delete _spriteHover;
-		_spriteHover = nullptr;
+		SAFE_DELETE(_spriteHover);
 		BaseSprite *spr = new BaseSprite(_gameRef, this);
 		if (!spr || DID_FAIL(spr->loadFile(filename))) {
 			stack->pushBool(false);
@@ -523,8 +515,7 @@ bool AdItem::scCallMethod(ScScript *script, ScStack *stack, ScStack *thisStack,
 
 		const char *filename = stack->pop()->getString();
 
-		delete _cursorNormal;
-		_cursorNormal = nullptr;
+		SAFE_DELETE(_cursorNormal);
 		BaseSprite *spr = new BaseSprite(_gameRef);
 		if (!spr || DID_FAIL(spr->loadFile(filename))) {
 			stack->pushBool(false);
@@ -589,8 +580,7 @@ bool AdItem::scCallMethod(ScScript *script, ScStack *stack, ScStack *thisStack,
 
 		const char *filename = stack->pop()->getString();
 
-		delete _cursorHover;
-		_cursorHover = nullptr;
+		SAFE_DELETE(_cursorHover);
 		BaseSprite *spr = new BaseSprite(_gameRef);
 		if (!spr || DID_FAIL(spr->loadFile(filename))) {
 			stack->pushBool(false);
@@ -789,12 +779,10 @@ bool AdItem::scSetProperty(const char *name, ScValue *value) {
 	// AmountString
 	//////////////////////////////////////////////////////////////////////////
 	else if (strcmp(name, "AmountString") == 0) {
-		if (value->isNULL()) {
-			delete[] _amountString;
-			_amountString = nullptr;
-		} else {
+		if (value->isNULL())
+			SAFE_DELETE_ARRAY(_amountString);
+		else
 			BaseUtils::setString(&_amountString, value->getString());
-		}
 		return STATUS_OK;
 	}
 
diff --git a/engines/wintermute/ad/ad_layer.cpp b/engines/wintermute/ad/ad_layer.cpp
index b1f400f9dff..9be3569973d 100644
--- a/engines/wintermute/ad/ad_layer.cpp
+++ b/engines/wintermute/ad/ad_layer.cpp
@@ -37,6 +37,8 @@
 #include "engines/wintermute/base/scriptables/script.h"
 #include "engines/wintermute/base/scriptables/script_stack.h"
 #include "engines/wintermute/platform_osystem.h"
+#include "engines/wintermute/dcgf.h"
+
 #include "common/str.h"
 
 namespace Wintermute {
@@ -173,8 +175,8 @@ bool AdLayer::loadBuffer(char *buffer, bool complete) {
 			AdSceneNode *node = new AdSceneNode(_gameRef);
 			if (!region || !node || DID_FAIL(region->loadBuffer(params, false))) {
 				cmd = PARSERR_GENERIC;
-				delete region;
-				delete node;
+				SAFE_DELETE(region);
+				SAFE_DELETE(node);
 			} else {
 				node->setRegion(region);
 				_nodes.add(node);
@@ -190,8 +192,8 @@ bool AdLayer::loadBuffer(char *buffer, bool complete) {
 			}
 			if (!entity || !node || DID_FAIL(entity->loadBuffer(params, false))) {
 				cmd = PARSERR_GENERIC;
-				delete entity;
-				delete node;
+				SAFE_DELETE(entity);
+				SAFE_DELETE(node);
 			} else {
 				node->setEntity(entity);
 				_nodes.add(node);
@@ -361,8 +363,7 @@ bool AdLayer::scCallMethod(ScScript *script, ScStack *stack, ScStack *thisStack,
 
 		for (int32 i = 0; i < _nodes.getSize(); i++) {
 			if (_nodes[i] == toDelete) {
-				delete _nodes[i];
-				_nodes[i] = nullptr;
+				SAFE_DELETE(_nodes[i]);
 				_nodes.removeAt(i);
 				break;
 			}
diff --git a/engines/wintermute/ad/ad_node_state.cpp b/engines/wintermute/ad/ad_node_state.cpp
index a81a0cb5f95..ee47e50efe2 100644
--- a/engines/wintermute/ad/ad_node_state.cpp
+++ b/engines/wintermute/ad/ad_node_state.cpp
@@ -31,6 +31,7 @@
 #include "engines/wintermute/base/base_sprite.h"
 #include "engines/wintermute/utils/utils.h"
 #include "engines/wintermute/platform_osystem.h"
+#include "engines/wintermute/dcgf.h"
 
 #include "common/str.h"
 
@@ -54,39 +55,32 @@ AdNodeState::AdNodeState(BaseGame *inGame) : BaseClass(inGame) {
 
 //////////////////////////////////////////////////////////////////////////
 AdNodeState::~AdNodeState() {
-	delete[] _name;
-	_name = nullptr;
-	delete[] _filename;
-	_filename = nullptr;
-	delete[] _cursor;
-	_cursor = nullptr;
+	SAFE_DELETE_ARRAY(_name);
+	SAFE_DELETE_ARRAY(_filename);
+	SAFE_DELETE_ARRAY(_cursor);
 	for (int i = 0; i < 7; i++) {
-		delete[] _caption[i];
-		_caption[i] = nullptr;
+		SAFE_DELETE_ARRAY(_caption[i]);
 	}
 }
 
 
 //////////////////////////////////////////////////////////////////////////
 void AdNodeState::setName(const char *name) {
-	delete[] _name;
-	_name = nullptr;
+	SAFE_DELETE_ARRAY(_name);
 	BaseUtils::setString(&_name, name);
 }
 
 
 //////////////////////////////////////////////////////////////////////////
 void AdNodeState::setFilename(const char *filename) {
-	delete[] _filename;
-	_filename = nullptr;
+	SAFE_DELETE_ARRAY(_filename);
 	BaseUtils::setString(&_filename, filename);
 }
 
 
 //////////////////////////////////////////////////////////////////////////
 void AdNodeState::setCursor(const char *filename) {
-	delete[] _cursor;
-	_cursor = nullptr;
+	SAFE_DELETE_ARRAY(_cursor);
 	BaseUtils::setString(&_cursor, filename);
 }
 
@@ -115,7 +109,7 @@ void AdNodeState::setCaption(const char *caption, int caseVal) {
 	if (caseVal < 1 || caseVal > 7)
 		return;
 
-	delete[] _caption[caseVal - 1];
+	SAFE_DELETE_ARRAY(_caption[caseVal - 1]);
 	size_t captionSize = strlen(caption) + 1;
 	_caption[caseVal - 1] = new char[captionSize];
 	Common::strcpy_s(_caption[caseVal - 1], captionSize, caption);
diff --git a/engines/wintermute/ad/ad_object.cpp b/engines/wintermute/ad/ad_object.cpp
index 71a79c75693..0ec7c26c1c6 100644
--- a/engines/wintermute/ad/ad_object.cpp
+++ b/engines/wintermute/ad/ad_object.cpp
@@ -48,6 +48,7 @@
 #include "engines/wintermute/base/scriptables/script_stack.h"
 #include "engines/wintermute/base/scriptables/script_value.h"
 #include "engines/wintermute/base/sound/base_sound.h"
+#include "engines/wintermute/dcgf.h"
 
 #include "common/str.h"
 #include "common/util.h"
@@ -109,22 +110,15 @@ AdObject::AdObject(BaseGame *inGame) : BaseObject(inGame) {
 //////////////////////////////////////////////////////////////////////////
 AdObject::~AdObject() {
 	_currentSprite = nullptr; // reference only, don't delete
-	delete _animSprite;
-	_animSprite = nullptr;
-	delete _sentence;
-	_sentence = nullptr;
-	delete[] _forcedTalkAnimName;
-	_forcedTalkAnimName = nullptr;
+	SAFE_DELETE(_animSprite);
+	SAFE_DELETE(_sentence);
+	SAFE_DELETE_ARRAY(_forcedTalkAnimName);
 
-	delete _blockRegion;
-	_blockRegion = nullptr;
-	delete _wptGroup;
-	_wptGroup = nullptr;
+	SAFE_DELETE(_blockRegion);
+	SAFE_DELETE(_wptGroup);
 
-	delete _currentBlockRegion;
-	_currentBlockRegion = nullptr;
-	delete _currentWptGroup;
-	_currentWptGroup = nullptr;
+	SAFE_DELETE(_currentBlockRegion);
+	SAFE_DELETE(_currentWptGroup);
 
 	_tempSprite2 = nullptr; // reference only
 	_stickRegion = nullptr;
@@ -157,7 +151,7 @@ AdObject::~AdObject() {
 
 //////////////////////////////////////////////////////////////////////////
 bool AdObject::playAnim(const char *filename) {
-	delete _animSprite;
+	SAFE_DELETE(_animSprite);
 	_animSprite = new BaseSprite(_gameRef, this);
 	if (!_animSprite) {
 		_gameRef->LOG(0, "AdObject::PlayAnim: error creating temp sprite (object:\"%s\" sprite:\"%s\")", _name, filename);
@@ -252,7 +246,7 @@ bool AdObject::scCallMethod(ScScript *script, ScStack *stack, ScStack *thisStack
 	else if (strcmp(name, "ForceTalkAnim") == 0) {
 		stack->correctParams(1);
 		const char *animName = stack->pop()->getString();
-		delete[] _forcedTalkAnimName;
+		SAFE_DELETE_ARRAY(_forcedTalkAnimName);
 		size_t animNameSize = strlen(animName) + 1;
 		_forcedTalkAnimName = new char[animNameSize];
 		Common::strcpy_s(_forcedTalkAnimName, animNameSize, animName);
@@ -886,13 +880,11 @@ void AdObject::talk(const char *text, const char *sound, uint32 duration, const
 	}
 
 	if (_forcedTalkAnimName && _forcedTalkAnimUsed) {
-		delete[] _forcedTalkAnimName;
-		_forcedTalkAnimName = nullptr;
+		SAFE_DELETE_ARRAY(_forcedTalkAnimName);
 		_forcedTalkAnimUsed = false;
 	}
 
-	delete(_sentence->_sound);
-	_sentence->_sound = nullptr;
+	SAFE_DELETE(_sentence->_sound);
 
 	_sentence->setText(text);
 	_gameRef->expandStringByStringTable(&_sentence->_text);
@@ -1007,8 +999,7 @@ void AdObject::talk(const char *text, const char *sound, uint32 duration, const
 //////////////////////////////////////////////////////////////////////////
 bool AdObject::reset() {
 	if (_state == STATE_PLAYING_ANIM && _animSprite != nullptr) {
-		delete _animSprite;
-		_animSprite = nullptr;
+		SAFE_DELETE(_animSprite);
 	} else if (_state == STATE_TALKING && _sentence) {
 		_sentence->finish();
 	}
diff --git a/engines/wintermute/ad/ad_object_3d.cpp b/engines/wintermute/ad/ad_object_3d.cpp
index 509d05e58e1..37dd8f7999b 100644
--- a/engines/wintermute/ad/ad_object_3d.cpp
+++ b/engines/wintermute/ad/ad_object_3d.cpp
@@ -65,8 +65,7 @@ AdObject3D::AdObject3D(BaseGame *inGame) : AdObject(inGame) {
 //////////////////////////////////////////////////////////////////////////
 AdObject3D::~AdObject3D() {
 	_tempSkelAnim = nullptr; // ref only
-	delete _shadowVolume;
-	_shadowVolume = nullptr;
+	SAFE_DELETE(_shadowVolume);
 
 	clearIgnoredLights();
 }
diff --git a/engines/wintermute/ad/ad_response.cpp b/engines/wintermute/ad/ad_response.cpp
index 09cbd8b9c76..54a333aff70 100644
--- a/engines/wintermute/ad/ad_response.cpp
+++ b/engines/wintermute/ad/ad_response.cpp
@@ -30,6 +30,7 @@
 #include "engines/wintermute/base/base_sprite.h"
 #include "engines/wintermute/base/font/base_font_storage.h"
 #include "engines/wintermute/utils/utils.h"
+#include "engines/wintermute/dcgf.h"
 
 namespace Wintermute {
 
@@ -48,16 +49,11 @@ AdResponse::AdResponse(BaseGame *inGame) : BaseObject(inGame) {
 
 //////////////////////////////////////////////////////////////////////////
 AdResponse::~AdResponse() {
-	delete[] _text;
-	_text = nullptr;
-	delete[] _textOrig;
-	_textOrig = nullptr;
-	delete _icon;
-	_icon = nullptr;
-	delete _iconHover;
-	_iconHover = nullptr;
-	delete _iconPressed;
-	_iconPressed = nullptr;
+	SAFE_DELETE_ARRAY(_text);
+	SAFE_DELETE_ARRAY(_textOrig);
+	SAFE_DELETE(_icon);
+	SAFE_DELETE(_iconHover);
+	SAFE_DELETE(_iconPressed);
 	if (_font) {
 		_gameRef->_fontStorage->removeFont(_font);
 	}
@@ -77,8 +73,7 @@ bool AdResponse::setIcon(const char *filename) {
 	_icon = new BaseSprite(_gameRef);
 	if (!_icon || DID_FAIL(_icon->loadFile(filename))) {
 		_gameRef->LOG(0, "AdResponse::setIcon failed for file '%s'", filename);
-		delete _icon;
-		_icon = nullptr;
+		SAFE_DELETE(_icon);
 		return STATUS_FAILED;
 	}
 	return STATUS_OK;
@@ -99,12 +94,11 @@ bool AdResponse::setFont(const char *filename) {
 
 //////////////////////////////////////////////////////////////////////////
 bool AdResponse::setIconHover(const char *filename) {
-	delete _iconHover;
+	SAFE_DELETE(_iconHover);
 	_iconHover = new BaseSprite(_gameRef);
 	if (!_iconHover || DID_FAIL(_iconHover->loadFile(filename))) {
 		_gameRef->LOG(0, "AdResponse::setIconHover failed for file '%s'", filename);
-		delete _iconHover;
-		_iconHover = nullptr;
+		SAFE_DELETE(_iconHover);
 		return STATUS_FAILED;
 	}
 	return STATUS_OK;
@@ -113,12 +107,11 @@ bool AdResponse::setIconHover(const char *filename) {
 
 //////////////////////////////////////////////////////////////////////////
 bool AdResponse::setIconPressed(const char *filename) {
-	delete _iconPressed;
+	SAFE_DELETE(_iconPressed);
 	_iconPressed = new BaseSprite(_gameRef);
 	if (!_iconPressed || DID_FAIL(_iconPressed->loadFile(filename))) {
 		_gameRef->LOG(0, "AdResponse::setIconPressed failed for file '%s'", filename);
-		delete _iconPressed;
-		_iconPressed = nullptr;
+		SAFE_DELETE(_iconPressed);
 		return STATUS_FAILED;
 	}
 	return STATUS_OK;
diff --git a/engines/wintermute/ad/ad_response_box.cpp b/engines/wintermute/ad/ad_response_box.cpp
index 9c103203252..720d09472ef 100644
--- a/engines/wintermute/ad/ad_response_box.cpp
+++ b/engines/wintermute/ad/ad_response_box.cpp
@@ -44,6 +44,8 @@
 #include "engines/wintermute/utils/utils.h"
 #include "engines/wintermute/platform_osystem.h"
 #include "engines/wintermute/wintermute.h"
+#include "engines/wintermute/dcgf.h"
+
 #include "common/str.h"
 
 namespace Wintermute {
@@ -73,15 +75,10 @@ AdResponseBox::AdResponseBox(BaseGame *inGame) : BaseObject(inGame) {
 
 //////////////////////////////////////////////////////////////////////////
 AdResponseBox::~AdResponseBox() {
-
-	delete _window;
-	_window = nullptr;
-	delete _shieldWindow;
-	_shieldWindow = nullptr;
-	delete[] _lastResponseText;
-	_lastResponseText = nullptr;
-	delete[] _lastResponseTextOrig;
-	_lastResponseTextOrig = nullptr;
+	SAFE_DELETE(_window);
+	SAFE_DELETE(_shieldWindow);
+	SAFE_DELETE_ARRAY(_lastResponseText);
+	SAFE_DELETE_ARRAY(_lastResponseTextOrig);
 
 	if (_font) {
 		_gameRef->_fontStorage->removeFont(_font);
@@ -280,11 +277,10 @@ bool AdResponseBox::loadBuffer(char *buffer, bool complete) {
 			break;
 
 		case TOKEN_WINDOW:
-			delete _window;
+			SAFE_DELETE(_window);
 			_window = new UIWindow(_gameRef);
 			if (!_window || DID_FAIL(_window->loadBuffer(params, false))) {
-				delete _window;
-				_window = nullptr;
+				SAFE_DELETE(_window);
 				cmd = PARSERR_GENERIC;
 			} else if (_shieldWindow) {
 				_shieldWindow->_parent = _window;
@@ -348,11 +344,10 @@ bool AdResponseBox::loadBuffer(char *buffer, bool complete) {
 			break;
 
 		case TOKEN_CURSOR:
-			delete _cursor;
+			SAFE_DELETE(_cursor);
 			_cursor = new BaseSprite(_gameRef);
 			if (!_cursor || DID_FAIL(_cursor->loadFile(params))) {
-				delete _cursor;
-				_cursor = nullptr;
+				SAFE_DELETE(_cursor);
 				cmd = PARSERR_GENERIC;
 			}
 			break;
diff --git a/engines/wintermute/ad/ad_response_context.cpp b/engines/wintermute/ad/ad_response_context.cpp
index 40f0f155173..d2bef0ff969 100644
--- a/engines/wintermute/ad/ad_response_context.cpp
+++ b/engines/wintermute/ad/ad_response_context.cpp
@@ -27,6 +27,7 @@
 
 #include "engines/wintermute/ad/ad_response_context.h"
 #include "engines/wintermute/base/base_persistence_manager.h"
+#include "engines/wintermute/dcgf.h"
 
 namespace Wintermute {
 
@@ -41,8 +42,7 @@ AdResponseContext::AdResponseContext(BaseGame *inGame) : BaseClass(inGame) {
 
 //////////////////////////////////////////////////////////////////////////
 AdResponseContext::~AdResponseContext() {
-	delete[] _context;
-	_context = nullptr;
+	SAFE_DELETE_ARRAY(_context);
 }
 
 
@@ -57,8 +57,7 @@ bool AdResponseContext::persist(BasePersistenceManager *persistMgr) {
 
 //////////////////////////////////////////////////////////////////////////
 void AdResponseContext::setContext(const char *context) {
-	delete[] _context;
-	_context = nullptr;
+	SAFE_DELETE_ARRAY(_context);
 	if (context) {
 		size_t contextSize = strlen(context) + 1;
 		_context = new char [contextSize];
diff --git a/engines/wintermute/ad/ad_scene.cpp b/engines/wintermute/ad/ad_scene.cpp
index 869ccb1a39b..6098314b3f4 100644
--- a/engines/wintermute/ad/ad_scene.cpp
+++ b/engines/wintermute/ad/ad_scene.cpp
@@ -59,6 +59,7 @@
 #include "engines/wintermute/ui/ui_window.h"
 #include "engines/wintermute/utils/utils.h"
 #include "engines/wintermute/wintermute.h"
+#include "engines/wintermute/dcgf.h"
 
 #ifdef ENABLE_WME3D
 #include "engines/wintermute/ad/ad_actor_3dx.h"
@@ -83,8 +84,7 @@ AdScene::AdScene(BaseGame *inGame) : BaseObject(inGame) {
 AdScene::~AdScene() {
 	cleanup();
 	_gameRef->unregisterObject(_fader);
-	delete _pfTarget;
-	_pfTarget = nullptr;
+	SAFE_DELETE(_pfTarget);
 }
 
 
@@ -179,8 +179,7 @@ void AdScene::cleanup() {
 
 	_mainLayer = nullptr; // reference only
 
-	delete _shieldWindow;
-	_shieldWindow = nullptr;
+	SAFE_DELETE(_shieldWindow);
 
 	_gameRef->unregisterObject(_fader);
 	_fader = nullptr;
@@ -219,11 +218,9 @@ void AdScene::cleanup() {
 	_objects.removeAll();
 
 #ifdef ENABLE_WME3D
-	delete _geom;
-	_geom = nullptr;
+	SAFE_DELETE(_geom);
 #endif
-	delete _viewport;
-	_viewport = nullptr;
+	SAFE_DELETE(_viewport);
 
 	setDefaults();
 }
@@ -751,7 +748,7 @@ bool AdScene::loadBuffer(char *buffer, bool complete) {
 			AdLayer *layer = new AdLayer(_gameRef);
 			if (!layer || DID_FAIL(layer->loadBuffer(params, false))) {
 				cmd = PARSERR_GENERIC;
-				delete layer;
+				SAFE_DELETE(layer);
 			} else {
 				_gameRef->registerObject(layer);
 				_layers.add(layer);
@@ -768,7 +765,7 @@ bool AdScene::loadBuffer(char *buffer, bool complete) {
 			AdWaypointGroup *wpt = new AdWaypointGroup(_gameRef);
 			if (!wpt || DID_FAIL(wpt->loadBuffer(params, false))) {
 				cmd = PARSERR_GENERIC;
-				delete wpt;
+				SAFE_DELETE(wpt);
 			} else {
 				_gameRef->registerObject(wpt);
 				_waypointGroups.add(wpt);
@@ -780,7 +777,7 @@ bool AdScene::loadBuffer(char *buffer, bool complete) {
 			AdScaleLevel *sl = new AdScaleLevel(_gameRef);
 			if (!sl || DID_FAIL(sl->loadBuffer(params, false))) {
 				cmd = PARSERR_GENERIC;
-				delete sl;
+				SAFE_DELETE(sl);
 			} else {
 				_gameRef->registerObject(sl);
 				_scaleLevels.add(sl);
@@ -792,7 +789,7 @@ bool AdScene::loadBuffer(char *buffer, bool complete) {
 			AdRotLevel *rl = new AdRotLevel(_gameRef);
 			if (!rl || DID_FAIL(rl->loadBuffer(params, false))) {
 				cmd = PARSERR_GENERIC;
-				delete rl;
+				SAFE_DELETE(rl);
 			} else {
 				_gameRef->registerObject(rl);
 				_rotLevels.add(rl);
@@ -804,7 +801,7 @@ bool AdScene::loadBuffer(char *buffer, bool complete) {
 			AdEntity *entity = new AdEntity(_gameRef);
 			if (!entity || DID_FAIL(entity->loadBuffer(params, false))) {
 				cmd = PARSERR_GENERIC;
-				delete entity;
+				SAFE_DELETE(entity);
 			} else {
 				addObject(entity);
 			}
@@ -812,25 +809,23 @@ bool AdScene::loadBuffer(char *buffer, bool complete) {
 		break;
 
 		case TOKEN_CURSOR:
-			delete _cursor;
+			SAFE_DELETE(_cursor);
 			_cursor = new BaseSprite(_gameRef);
 			if (!_cursor || DID_FAIL(_cursor->loadFile(params))) {
-				delete _cursor;
+				SAFE_DELETE(_cursor);
 				cmd = PARSERR_GENERIC;
 			}
 			break;
 
 #ifdef ENABLE_WME3D
 		case TOKEN_GEOMETRY:
-			delete _geom;
-			_geom = nullptr;
+			SAFE_DELETE(_geom);
 			if (!_gameRef->_useD3D) {
 				break;
 			}
 			_geom = new AdSceneGeometry(_gameRef);
-			if (_geom == nullptr || !_geom->loadFile(params)) {
-				delete _geom;
-				_geom = nullptr;
+			if (!_geom || !_geom->loadFile(params)) {
+				SAFE_DELETE(_geom);
 				cmd = PARSERR_GENERIC;
 			}
 			break;
diff --git a/engines/wintermute/ad/ad_scene_geometry.cpp b/engines/wintermute/ad/ad_scene_geometry.cpp
index 787c2f06797..272802a4e96 100644
--- a/engines/wintermute/ad/ad_scene_geometry.cpp
+++ b/engines/wintermute/ad/ad_scene_geometry.cpp
@@ -53,6 +53,7 @@
 #include "engines/wintermute/utils/utils.h"
 #include "engines/wintermute/system/sys_class_registry.h"
 #include "engines/wintermute/wintermute.h"
+#include "engines/wintermute/dcgf.h"
 
 namespace Wintermute {
 
@@ -89,8 +90,7 @@ AdSceneGeometry::AdSceneGeometry(BaseGame *gameRef) : BaseObject(gameRef) {
 //////////////////////////////////////////////////////////////////////////
 AdSceneGeometry::~AdSceneGeometry() {
 	cleanup();
-	delete _wptMarker;
-	_wptMarker = nullptr;
+	SAFE_DELETE(_wptMarker);
 }
 
 //////////////////////////////////////////////////////////////////////////
diff --git a/engines/wintermute/ad/ad_scene_state.cpp b/engines/wintermute/ad/ad_scene_state.cpp
index 834f7be72e8..c11ea8a323d 100644
--- a/engines/wintermute/ad/ad_scene_state.cpp
+++ b/engines/wintermute/ad/ad_scene_state.cpp
@@ -29,6 +29,8 @@
 #include "engines/wintermute/ad/ad_node_state.h"
 #include "engines/wintermute/persistent.h"
 #include "engines/wintermute/platform_osystem.h"
+#include "engines/wintermute/dcgf.h"
+
 #include "common/str.h"
 
 namespace Wintermute {
@@ -43,8 +45,7 @@ AdSceneState::AdSceneState(BaseGame *inGame) : BaseClass(inGame) {
 
 //////////////////////////////////////////////////////////////////////////
 AdSceneState::~AdSceneState() {
-	delete[] _filename;
-	_filename = nullptr;
+	SAFE_DELETE_ARRAY(_filename);
 
 	for (int32 i = 0; i < _nodeStates.getSize(); i++) {
 		delete _nodeStates[i];
@@ -64,7 +65,7 @@ bool AdSceneState::persist(BasePersistenceManager *persistMgr) {
 
 //////////////////////////////////////////////////////////////////////////
 void AdSceneState::setFilename(const char *filename) {
-	delete[] _filename;
+	SAFE_DELETE_ARRAY(_filename);
 	size_t filenameSize = strlen(filename) + 1;
 	_filename = new char [filenameSize];
 	Common::strcpy_s(_filename, filenameSize, filename);
diff --git a/engines/wintermute/ad/ad_sentence.cpp b/engines/wintermute/ad/ad_sentence.cpp
index dcd926d19ae..7bf1a5d1d1c 100644
--- a/engines/wintermute/ad/ad_sentence.cpp
+++ b/engines/wintermute/ad/ad_sentence.cpp
@@ -37,6 +37,7 @@
 #include "engines/wintermute/base/font/base_font.h"
 #include "engines/wintermute/base/gfx/base_renderer.h"
 #include "engines/wintermute/base/sound/base_sound.h"
+#include "engines/wintermute/dcgf.h"
 
 namespace Wintermute {
 
@@ -72,16 +73,11 @@ AdSentence::AdSentence(BaseGame *inGame) : BaseClass(inGame) {
 
 //////////////////////////////////////////////////////////////////////////
 AdSentence::~AdSentence() {
-	delete _sound;
-	_sound = nullptr;
-	delete[] _text;
-	_text = nullptr;
-	delete[] _stances;
-	_stances = nullptr;
-	delete[] _tempStance;
-	_tempStance = nullptr;
-	delete _talkDef;
-	_talkDef = nullptr;
+	SAFE_DELETE(_sound);
+	SAFE_DELETE_ARRAY(_text);
+	SAFE_DELETE_ARRAY(_stances);
+	SAFE_DELETE_ARRAY(_tempStance);
+	SAFE_DELETE(_talkDef);
 
 	_currentSprite = nullptr; // ref only
 	_currentSkelAnim = nullptr;
@@ -223,7 +219,7 @@ void AdSentence::setSound(BaseSound *sound) {
 	if (!sound) {
 		return;
 	}
-	delete _sound;
+	SAFE_DELETE(_sound);
 	_sound = sound;
 	_soundStarted = false;
 }
@@ -267,8 +263,7 @@ bool AdSentence::persist(BasePersistenceManager *persistMgr) {
 
 //////////////////////////////////////////////////////////////////////////
 bool AdSentence::setupTalkFile(const char *soundFilename) {
-	delete _talkDef;
-	_talkDef = nullptr;
+	SAFE_DELETE(_talkDef);
 	_currentSprite = nullptr;
 
 	if (!soundFilename) {
@@ -287,8 +282,7 @@ bool AdSentence::setupTalkFile(const char *soundFilename) {
 
 	_talkDef = new AdTalkDef(_gameRef);
 	if (!_talkDef || DID_FAIL(_talkDef->loadFile(talkDefFileName.c_str()))) {
-		delete _talkDef;
-		_talkDef = nullptr;
+		SAFE_DELETE(_talkDef);
 		return STATUS_FAILED;
 	}
 	//_gameRef->LOG(0, "Using .talk file: %s", TalkDefFile);
diff --git a/engines/wintermute/ad/ad_sprite_set.cpp b/engines/wintermute/ad/ad_sprite_set.cpp
index e6d42d90a71..d3de893a6d7 100644
--- a/engines/wintermute/ad/ad_sprite_set.cpp
+++ b/engines/wintermute/ad/ad_sprite_set.cpp
@@ -31,6 +31,7 @@
 #include "engines/wintermute/base/base_file_manager.h"
 #include "engines/wintermute/base/base_parser.h"
 #include "engines/wintermute/base/base_sprite.h"
+#include "engines/wintermute/dcgf.h"
 
 namespace Wintermute {
 
@@ -49,8 +50,7 @@ AdSpriteSet::AdSpriteSet(BaseGame *inGame, BaseObject *owner) : BaseObject(inGam
 //////////////////////////////////////////////////////////////////////////
 AdSpriteSet::~AdSpriteSet() {
 	for (int i = 0; i < NUM_DIRECTIONS; i++) {
-		delete _sprites[i];
-		_sprites[i] = nullptr;
+		SAFE_DELETE(_sprites[i]);
 	}
 
 	_owner = nullptr;
@@ -134,8 +134,7 @@ bool AdSpriteSet::loadBuffer(char *buffer, bool complete, int lifeTime, TSpriteC
 			break;
 
 		case TOKEN_LEFT:
-			delete _sprites[DI_LEFT];
-			_sprites[DI_LEFT] = nullptr;
+			SAFE_DELETE(_sprites[DI_LEFT]);
 			spr = new BaseSprite(_gameRef,  _owner);
 			if (!spr || DID_FAIL(spr->loadFile(params, lifeTime, cacheType))) {
 				cmd = PARSERR_GENERIC;
@@ -145,8 +144,7 @@ bool AdSpriteSet::loadBuffer(char *buffer, bool complete, int lifeTime, TSpriteC
 			break;
 
 		case TOKEN_RIGHT:
-			delete _sprites[DI_RIGHT];
-			_sprites[DI_RIGHT] = nullptr;
+			SAFE_DELETE(_sprites[DI_RIGHT]);
 			spr = new BaseSprite(_gameRef,  _owner);
 			if (!spr || DID_FAIL(spr->loadFile(params, lifeTime, cacheType))) {
 				cmd = PARSERR_GENERIC;
@@ -156,8 +154,7 @@ bool AdSpriteSet::loadBuffer(char *buffer, bool complete, int lifeTime, TSpriteC
 			break;
 
 		case TOKEN_UP:
-			delete _sprites[DI_UP];
-			_sprites[DI_UP] = nullptr;
+			SAFE_DELETE(_sprites[DI_UP]);
 			spr = new BaseSprite(_gameRef,  _owner);
 			if (!spr || DID_FAIL(spr->loadFile(params, lifeTime, cacheType))) {
 				cmd = PARSERR_GENERIC;
@@ -167,8 +164,7 @@ bool AdSpriteSet::loadBuffer(char *buffer, bool complete, int lifeTime, TSpriteC
 			break;
 
 		case TOKEN_DOWN:
-			delete _sprites[DI_DOWN];
-			_sprites[DI_DOWN] = nullptr;
+			SAFE_DELETE(_sprites[DI_DOWN]);
 			spr = new BaseSprite(_gameRef,  _owner);
 			if (!spr || DID_FAIL(spr->loadFile(params, lifeTime, cacheType))) {
 				cmd = PARSERR_GENERIC;
@@ -178,8 +174,7 @@ bool AdSpriteSet::loadBuffer(char *buffer, bool complete, int lifeTime, TSpriteC
 			break;
 
 		case TOKEN_UP_LEFT:
-			delete _sprites[DI_UPLEFT];
-			_sprites[DI_UPLEFT] = nullptr;
+			SAFE_DELETE(_sprites[DI_UPLEFT]);
 			spr = new BaseSprite(_gameRef,  _owner);
 			if (!spr || DID_FAIL(spr->loadFile(params, lifeTime, cacheType))) {
 				cmd = PARSERR_GENERIC;
@@ -189,8 +184,7 @@ bool AdSpriteSet::loadBuffer(char *buffer, bool complete, int lifeTime, TSpriteC
 			break;
 
 		case TOKEN_UP_RIGHT:
-			delete _sprites[DI_UPRIGHT];
-			_sprites[DI_UPRIGHT] = nullptr;
+			SAFE_DELETE(_sprites[DI_UPRIGHT]);
 			spr = new BaseSprite(_gameRef,  _owner);
 			if (!spr || DID_FAIL(spr->loadFile(params, lifeTime, cacheType))) {
 				cmd = PARSERR_GENERIC;
@@ -200,8 +194,7 @@ bool AdSpriteSet::loadBuffer(char *buffer, bool complete, int lifeTime, TSpriteC
 			break;
 
 		case TOKEN_DOWN_LEFT:
-			delete _sprites[DI_DOWNLEFT];
-			_sprites[DI_DOWNLEFT] = nullptr;
+			SAFE_DELETE(_sprites[DI_DOWNLEFT]);
 			spr = new BaseSprite(_gameRef,  _owner);
 			if (!spr || DID_FAIL(spr->loadFile(params, lifeTime, cacheType))) {
 				cmd = PARSERR_GENERIC;
@@ -211,8 +204,7 @@ bool AdSpriteSet::loadBuffer(char *buffer, bool complete, int lifeTime, TSpriteC
 			break;
 
 		case TOKEN_DOWN_RIGHT:
-			delete _sprites[DI_DOWNRIGHT];
-			_sprites[DI_DOWNRIGHT] = nullptr;
+			SAFE_DELETE(_sprites[DI_DOWNRIGHT]);
 			spr = new BaseSprite(_gameRef,  _owner);
 			if (!spr || DID_FAIL(spr->loadFile(params, lifeTime, cacheType))) {
 				cmd = PARSERR_GENERIC;
diff --git a/engines/wintermute/ad/ad_talk_def.cpp b/engines/wintermute/ad/ad_talk_def.cpp
index 772f09994c9..e5f51cef587 100644
--- a/engines/wintermute/ad/ad_talk_def.cpp
+++ b/engines/wintermute/ad/ad_talk_def.cpp
@@ -34,6 +34,7 @@
 #include "engines/wintermute/base/base_sprite.h"
 #include "engines/wintermute/base/base_file_manager.h"
 #include "engines/wintermute/utils/utils.h"
+#include "engines/wintermute/dcgf.h"
 
 namespace Wintermute {
 
@@ -56,15 +57,11 @@ AdTalkDef::~AdTalkDef() {
 	}
 	_nodes.removeAll();
 
-	delete[] _defaultSpriteFilename;
-	_defaultSpriteFilename = nullptr;
-	delete _defaultSprite;
-	_defaultSprite = nullptr;
+	SAFE_DELETE_ARRAY(_defaultSpriteFilename);
+	SAFE_DELETE(_defaultSprite);
 
-	delete[] _defaultSpriteSetFilename;
-	_defaultSpriteSetFilename = nullptr;
-	delete _defaultSpriteSet;
-	_defaultSpriteSet = nullptr;
+	SAFE_DELETE_ARRAY(_defaultSpriteSetFilename);
+	SAFE_DELETE(_defaultSpriteSet);
 }
 
 
@@ -136,7 +133,7 @@ bool AdTalkDef::loadBuffer(char *buffer, bool complete) {
 			if (node && DID_SUCCEED(node->loadBuffer(params, false))) {
 				_nodes.add(node);
 			} else {
-				delete node;
+				SAFE_DELETE(node);
 				cmd = PARSERR_GENERIC;
 			}
 		}
@@ -151,11 +148,10 @@ bool AdTalkDef::loadBuffer(char *buffer, bool complete) {
 			break;
 
 		case TOKEN_DEFAULT_SPRITESET: {
-			delete _defaultSpriteSet;
+			SAFE_DELETE(_defaultSpriteSet);
 			_defaultSpriteSet = new AdSpriteSet(_gameRef);
 			if (!_defaultSpriteSet || DID_FAIL(_defaultSpriteSet->loadBuffer(params, false))) {
-				delete _defaultSpriteSet;
-				_defaultSpriteSet = nullptr;
+				SAFE_DELETE(_defaultSpriteSet);
 				cmd = PARSERR_GENERIC;
 			}
 		}
@@ -180,10 +176,8 @@ bool AdTalkDef::loadBuffer(char *buffer, bool complete) {
 		return STATUS_FAILED;
 	}
 
-	delete _defaultSprite;
-	_defaultSprite = nullptr;
-	delete _defaultSpriteSet;
-	_defaultSpriteSet = nullptr;
+	SAFE_DELETE(_defaultSprite);
+	SAFE_DELETE(_defaultSpriteSet);
 
 	if (_defaultSpriteFilename) {
 		_defaultSprite = new BaseSprite(_gameRef);
@@ -250,8 +244,7 @@ bool AdTalkDef::loadDefaultSprite() {
 	if (_defaultSpriteFilename && !_defaultSprite) {
 		_defaultSprite = new BaseSprite(_gameRef);
 		if (!_defaultSprite || DID_FAIL(_defaultSprite->loadFile(_defaultSpriteFilename))) {
-			delete _defaultSprite;
-			_defaultSprite = nullptr;
+			SAFE_DELETE(_defaultSprite);
 			return STATUS_FAILED;
 		} else {
 			return STATUS_OK;
@@ -259,8 +252,7 @@ bool AdTalkDef::loadDefaultSprite() {
 	} else if (_defaultSpriteSetFilename && !_defaultSpriteSet) {
 		_defaultSpriteSet = new AdSpriteSet(_gameRef);
 		if (!_defaultSpriteSet || DID_FAIL(_defaultSpriteSet->loadFile(_defaultSpriteSetFilename))) {
-			delete _defaultSpriteSet;
-			_defaultSpriteSet = nullptr;
+			SAFE_DELETE(_defaultSpriteSet);
 			return STATUS_FAILED;
 		} else {
 			return STATUS_OK;
diff --git a/engines/wintermute/ad/ad_talk_holder.cpp b/engines/wintermute/ad/ad_talk_holder.cpp
index 20aaa8d7c88..c49da94ae62 100644
--- a/engines/wintermute/ad/ad_talk_holder.cpp
+++ b/engines/wintermute/ad/ad_talk_holder.cpp
@@ -35,6 +35,8 @@
 #include "engines/wintermute/base/scriptables/script_stack.h"
 #include "engines/wintermute/base/scriptables/script_ext_array.h"
 #include "engines/wintermute/platform_osystem.h"
+#include "engines/wintermute/dcgf.h"
+
 #include "common/str.h"
 
 namespace Wintermute {
@@ -49,8 +51,7 @@ AdTalkHolder::AdTalkHolder(BaseGame *inGame) : AdObject(inGame) {
 
 //////////////////////////////////////////////////////////////////////////
 AdTalkHolder::~AdTalkHolder() {
-	delete _sprite;
-	_sprite = nullptr;
+	SAFE_DELETE(_sprite);
 
 	for (int32 i = 0; i < _talkSprites.getSize(); i++) {
 		delete _talkSprites[i];
@@ -71,14 +72,13 @@ BaseSprite *AdTalkHolder::getTalkStance(const char *stance) {
 	// forced stance?
 	if (_forcedTalkAnimName && !_forcedTalkAnimUsed) {
 		_forcedTalkAnimUsed = true;
-		delete _animSprite;
+		SAFE_DELETE(_animSprite);
 		_animSprite = new BaseSprite(_gameRef, 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);
-				delete _animSprite;
-				_animSprite = nullptr;
+				SAFE_DELETE(_animSprite);
 			} else {
 				return _animSprite;
 			}
@@ -137,8 +137,7 @@ bool AdTalkHolder::scCallMethod(ScScript *script, ScStack *stack, ScStack *thisS
 			setCurrent = true;
 		}
 
-		delete _sprite;
-		_sprite = nullptr;
+		SAFE_DELETE(_sprite);
 
 		if (val->isNULL()) {
 			_sprite = nullptr;
diff --git a/engines/wintermute/ad/ad_talk_node.cpp b/engines/wintermute/ad/ad_talk_node.cpp
index 5d07ebfe6e5..d47b0709d72 100644
--- a/engines/wintermute/ad/ad_talk_node.cpp
+++ b/engines/wintermute/ad/ad_talk_node.cpp
@@ -32,6 +32,8 @@
 #include "engines/wintermute/base/base_game.h"
 #include "engines/wintermute/base/base_sprite.h"
 #include "engines/wintermute/utils/utils.h"
+#include "engines/wintermute/dcgf.h"
+
 namespace Wintermute {
 
 IMPLEMENT_PERSISTENT(AdTalkNode, false)
@@ -52,16 +54,11 @@ AdTalkNode::AdTalkNode(BaseGame *inGame) : BaseClass(inGame) {
 
 //////////////////////////////////////////////////////////////////////////
 AdTalkNode::~AdTalkNode() {
-	delete[] _spriteFilename;
-	_spriteFilename = nullptr;
-	delete _sprite;
-	_sprite = nullptr;
-	delete[] _spriteSetFilename;
-	_spriteSetFilename = nullptr;
-	delete _spriteSet;
-	_spriteSet = nullptr;
-	delete _comment;
-	_comment = nullptr;
+	SAFE_DELETE_ARRAY(_spriteFilename);
+	SAFE_DELETE(_sprite);
+	SAFE_DELETE_ARRAY(_spriteSetFilename);
+	SAFE_DELETE(_spriteSet);
+	SAFE_DELETE_ARRAY(_comment);
 }
 
 TOKEN_DEF_START
@@ -119,8 +116,7 @@ bool AdTalkNode::loadBuffer(char *buffer, bool complete) {
 			delete _spriteSet;
 			_spriteSet = new AdSpriteSet(_gameRef);
 			if (!_spriteSet || DID_FAIL(_spriteSet->loadBuffer(params, false))) {
-				delete _spriteSet;
-				_spriteSet = nullptr;
+				SAFE_DELETE(_spriteSet);
 				cmd = PARSERR_GENERIC;
 			}
 		}
@@ -169,7 +165,7 @@ bool AdTalkNode::loadBuffer(char *buffer, bool complete) {
 	}
 
 	if (_preCache && _spriteFilename) {
-		delete _sprite;
+		SAFE_DELETE(_sprite);
 		_sprite = new BaseSprite(_gameRef);
 		if (!_sprite || DID_FAIL(_sprite->loadFile(_spriteFilename))) {
 			return STATUS_FAILED;
@@ -177,7 +173,7 @@ bool AdTalkNode::loadBuffer(char *buffer, bool complete) {
 	}
 
 	if (_preCache && _spriteSetFilename) {
-		delete _spriteSet;
+		SAFE_DELETE(_spriteSet);
 		_spriteSet = new AdSpriteSet(_gameRef);
 		if (!_spriteSet || DID_FAIL(_spriteSet->loadFile(_spriteSetFilename))) {
 			return STATUS_FAILED;
@@ -244,8 +240,7 @@ bool AdTalkNode::loadSprite() {
 	if (_spriteFilename && !_sprite) {
 		_sprite = new BaseSprite(_gameRef);
 		if (!_sprite || DID_FAIL(_sprite->loadFile(_spriteFilename))) {
-			delete _sprite;
-			_sprite = nullptr;
+			SAFE_DELETE(_sprite);
 			return STATUS_FAILED;
 		} else {
 			return STATUS_OK;
@@ -253,8 +248,7 @@ bool AdTalkNode::loadSprite() {
 	} else if (_spriteSetFilename && !_spriteSet) {
 		_spriteSet = new AdSpriteSet(_gameRef);
 		if (!_spriteSet || DID_FAIL(_spriteSet->loadFile(_spriteSetFilename))) {
-			delete _spriteSet;
-			_spriteSet = nullptr;
+			SAFE_DELETE(_spriteSet);
 			return STATUS_FAILED;
 		} else {
 			return STATUS_OK;
diff --git a/engines/wintermute/ad/ad_walkplane.cpp b/engines/wintermute/ad/ad_walkplane.cpp
index 41a8c8abfcb..0a61eb5094c 100644
--- a/engines/wintermute/ad/ad_walkplane.cpp
+++ b/engines/wintermute/ad/ad_walkplane.cpp
@@ -28,6 +28,7 @@
 #include "engines/wintermute/ad/ad_walkplane.h"
 #include "engines/wintermute/base/base_persistence_manager.h"
 #include "engines/wintermute/base/gfx/3dmesh.h"
+#include "engines/wintermute/dcgf.h"
 
 namespace Wintermute {
 
@@ -40,8 +41,7 @@ AdWalkplane::AdWalkplane(BaseGame *inGame) : BaseScriptable(inGame, false, false
 
 //////////////////////////////////////////////////////////////////////////
 AdWalkplane::~AdWalkplane() {
-	delete _mesh;
-	_mesh = nullptr;
+	SAFE_DELETE(_mesh);
 }
 
 //////////////////////////////////////////////////////////////////////////
diff --git a/engines/wintermute/base/base.cpp b/engines/wintermute/base/base.cpp
index df51d2789d9..f011f8ddc09 100644
--- a/engines/wintermute/base/base.cpp
+++ b/engines/wintermute/base/base.cpp
@@ -30,6 +30,7 @@
 #include "engines/wintermute/base/base_engine.h"
 #include "engines/wintermute/base/base_parser.h"
 #include "engines/wintermute/base/base_dynamic_buffer.h"
+#include "engines/wintermute/dcgf.h"
 
 namespace Wintermute {
 
@@ -117,14 +118,14 @@ bool BaseClass::parseEditorProperty(char *buffer, bool complete) {
 	while ((cmd = parser.getCommand(&buffer, commands, &params)) > 0) {
 		switch (cmd) {
 		case TOKEN_NAME: {
-			delete[] propName;
+			SAFE_DELETE_ARRAY(propName);
 			size_t propNameSize = strlen(params) + 1;
 			propName = new char[propNameSize];
 			Common::strcpy_s(propName, propNameSize, params);
 			break;
 		}
 		case TOKEN_VALUE: {
-			delete[] propValue;
+			SAFE_DELETE_ARRAY(propValue);
 			size_t propValueSize = strlen(params) + 1;
 			propValue = new char[propValueSize];
 			Common::strcpy_s(propValue, propValueSize, params);
@@ -136,14 +137,14 @@ bool BaseClass::parseEditorProperty(char *buffer, bool complete) {
 
 	}
 	if (cmd == PARSERR_TOKENNOTFOUND) {
-		delete[] propName;
-		delete[] propValue;
+		SAFE_DELETE_ARRAY(propName);
+		SAFE_DELETE_ARRAY(propValue);
 		BaseEngine::LOG(0, "Syntax error in EDITOR_PROPERTY definition");
 		return STATUS_FAILED;
 	}
 	if (cmd == PARSERR_GENERIC || propName == nullptr || propValue == nullptr) {
-		delete[] propName;
-		delete[] propValue;
+		SAFE_DELETE_ARRAY(propName);
+		SAFE_DELETE_ARRAY(propValue);
 		BaseEngine::LOG(0, "Error loading EDITOR_PROPERTY definition");
 		return STATUS_FAILED;
 	}
@@ -151,8 +152,8 @@ bool BaseClass::parseEditorProperty(char *buffer, bool complete) {
 
 	setEditorProp(propName, propValue);
 
-	delete[] propName;
-	delete[] propValue;
+	SAFE_DELETE_ARRAY(propName);
+	SAFE_DELETE_ARRAY(propValue);
 
 	return STATUS_OK;
 }
diff --git a/engines/wintermute/base/base_file_manager.cpp b/engines/wintermute/base/base_file_manager.cpp
index 4f6aea7dc03..67567eba738 100644
--- a/engines/wintermute/base/base_file_manager.cpp
+++ b/engines/wintermute/base/base_file_manager.cpp
@@ -34,6 +34,8 @@
 #include "engines/wintermute/base/base.h"
 #include "engines/wintermute/base/base_engine.h"
 #include "engines/wintermute/wintermute.h"
+#include "engines/wintermute/dcgf.h"
+
 #include "common/algorithm.h"
 #include "common/debug.h"
 #include "common/str.h"
@@ -85,8 +87,7 @@ bool BaseFileManager::cleanup() {
 	_packages.clear();
 
 	// get rid of the resources:
-	delete _resources;
-	_resources = NULL;
+	SAFE_DELETE(_resources);
 
 	return STATUS_OK;
 }
diff --git a/engines/wintermute/base/base_frame.cpp b/engines/wintermute/base/base_frame.cpp
index 758364614d5..7b11000eefe 100644
--- a/engines/wintermute/base/base_frame.cpp
+++ b/engines/wintermute/base/base_frame.cpp
@@ -38,6 +38,8 @@
 #include "engines/wintermute/base/scriptables/script_value.h"
 #include "engines/wintermute/base/scriptables/script.h"
 #include "engines/wintermute/base/scriptables/script_stack.h"
+#include "engines/wintermute/dcgf.h"
+
 #include "common/str.h"
 
 namespace Wintermute {
@@ -59,8 +61,7 @@ BaseFrame::BaseFrame(BaseGame *inGame) : BaseScriptable(inGame, true) {
 
 //////////////////////////////////////////////////////////////////////
 BaseFrame::~BaseFrame() {
-	delete _sound;
-	_sound = nullptr;
+	SAFE_DELETE(_sound);
 
 	for (int32 i = 0; i < _subframes.getSize(); i++) {
 		delete _subframes[i];
@@ -68,8 +69,7 @@ BaseFrame::~BaseFrame() {
 	_subframes.removeAll();
 
 	for (int32 i = 0; i < _applyEvent.getSize(); i++) {
-		delete[] _applyEvent[i];
-		_applyEvent[i] = nullptr;
+		SAFE_DELETE_ARRAY(_applyEvent[i]);
 	}
 	_applyEvent.removeAll();
 }
@@ -258,16 +258,14 @@ bool BaseFrame::loadBuffer(char *buffer, int lifeTime, bool keepLoaded) {
 
 		case TOKEN_SOUND: {
 			if (_sound) {
-				delete _sound;
-				_sound = nullptr;
+				SAFE_DELETE(_sound);
 			}
 			_sound = new BaseSound(_gameRef);
 			if (!_sound || DID_FAIL(_sound->setSound(params, Audio::Mixer::kSFXSoundType, false))) {
 				if (BaseEngine::instance().getSoundMgr()->_soundAvailable) {
 					BaseEngine::LOG(0, "Error loading sound '%s'.", params);
 				}
-				delete _sound;
-				_sound = nullptr;
+				SAFE_DELETE(_sound);
 			}
 		}
 		break;
@@ -454,15 +452,13 @@ bool BaseFrame::scCallMethod(ScScript *script, ScStack *stack, ScStack *thisStac
 	if (strcmp(name, "SetSound") == 0) {
 		stack->correctParams(1);
 		ScValue *val = stack->pop();
-		delete _sound;
-		_sound = nullptr;
+		SAFE_DELETE(_sound);
 
 		if (!val->isNULL()) {
 			_sound = new BaseSound(_gameRef);
 			if (!_sound || DID_FAIL(_sound->setSound(val->getString(), Audio::Mixer::kSFXSoundType, false))) {
 				stack->pushBool(false);
-				delete _sound;
-				_sound = nullptr;
+				SAFE_DELETE(_sound);
 			} else {
 				stack->pushBool(true);
 			}
diff --git a/engines/wintermute/base/base_game.cpp b/engines/wintermute/base/base_game.cpp
index 517da26d01c..70b09837e82 100644
--- a/engines/wintermute/base/base_game.cpp
+++ b/engines/wintermute/base/base_game.cpp
@@ -277,40 +277,25 @@ BaseGame::~BaseGame() {
 
 	cleanup();
 
-	delete _mathClass;
-	delete _directoryClass;
-
-	delete _transMgr;
-	delete _scEngine;
-	delete _fontStorage;
-	delete _surfaceStorage;
-	delete _videoPlayer;
-	delete _theoraPlayer;
-	delete _soundMgr;
-
-	delete _renderer;
-	delete _musicSystem;
-	delete _settings;
-
-	_mathClass = nullptr;
-	_directoryClass = nullptr;
-
-	_transMgr = nullptr;
-	_scEngine = nullptr;
-	_fontStorage = nullptr;
-	_surfaceStorage = nullptr;
-	_videoPlayer = nullptr;
-	_theoraPlayer = nullptr;
-	_soundMgr = nullptr;
+	SAFE_DELETE(_mathClass);
+	SAFE_DELETE(_directoryClass);
+
+	SAFE_DELETE(_transMgr);
+	SAFE_DELETE(_scEngine);
+	SAFE_DELETE(_fontStorage);
+	SAFE_DELETE(_surfaceStorage);
+	SAFE_DELETE(_videoPlayer);
+	SAFE_DELETE(_theoraPlayer);
+	SAFE_DELETE(_soundMgr);
 	//SAFE_DELETE(_keyboardState);
 
-	_renderer = nullptr;
-	_musicSystem = nullptr;
-	_settings = nullptr;
+	SAFE_DELETE(_renderer);
+	//SAFE_DELETE(m_AccessMgr);
+	SAFE_DELETE(_musicSystem);
+	SAFE_DELETE(_settings);
 
 #ifdef ENABLE_HEROCRAFT
-	delete _rndHc;
-	_rndHc = nullptr;
+	SAFE_DELETE(_rndHc);
 #endif
 
 	DEBUG_DebugDisable();
@@ -320,8 +305,7 @@ BaseGame::~BaseGame() {
 
 //////////////////////////////////////////////////////////////////////////
 bool BaseGame::cleanup() {
-	delete _loadingIcon;
-	_loadingIcon = nullptr;
+	SAFE_DELETE(_loadingIcon);
 
 	deleteSaveThumbnail();
 
@@ -334,25 +318,20 @@ bool BaseGame::cleanup() {
 	_fader = nullptr;
 
 	for (int32 i = 0; i < _regObjects.getSize(); i++) {
-		delete _regObjects[i];
-		_regObjects[i] = nullptr;
+		SAFE_DELETE(_regObjects[i]);
 	}
 	_regObjects.removeAll();
 
 	_windows.removeAll(); // refs only
 	_focusedWindow = nullptr; // ref only
+	//m_AccessShieldWin = nullptr;
 
-	delete _cursorNoninteractive;
-	_cursorNoninteractive = nullptr;
-	delete _cursor;
-	_cursor = nullptr;
-	delete _activeCursor;
-	_activeCursor = nullptr;
+	SAFE_DELETE(_cursorNoninteractive);
+	SAFE_DELETE(_cursor);
+	SAFE_DELETE(_activeCursor);
 
-	delete _scValue;
-	_scValue = nullptr;
-	delete _sFX;
-	_sFX = nullptr;
+	SAFE_DELETE(_scValue);
+	SAFE_DELETE(_sFX);
 
 	for (int32 i = 0; i < _scripts.getSize(); i++) {
 		_scripts[i]->_owner = nullptr;
@@ -384,15 +363,15 @@ bool BaseGame::cleanup() {
 	setName(nullptr);
 	setFilename(nullptr);
 	for (int i = 0; i < 7; i++) {
-		delete[] _caption[i];
-		_caption[i] = nullptr;
+		SAFE_DELETE_ARRAY(_caption[i]);
 	}
 
 	_lastCursor = nullptr;
 
-	delete _keyboardState;
-	_keyboardState = nullptr;
+	SAFE_DELETE(_keyboardState);
 
+	//if(m_AccessMgr) m_AccessMgr->SetActiveObject(NULL);
+	
 	return STATUS_OK;
 }
 
@@ -513,13 +492,14 @@ bool BaseGame::initialize1() {
 	if (loaded == true) {
 		return STATUS_OK;
 	} else {
-		delete _mathClass;
 		delete _directoryClass;
+		delete _mathClass;
 		delete _keyboardState;
 		delete _transMgr;
 		delete _surfaceStorage;
 		delete _fontStorage;
 		delete _soundMgr;
+		//delete m_AccessMgr;
 		delete _scEngine;
 		delete _videoPlayer;
 		return STATUS_FAILED;
@@ -949,32 +929,28 @@ bool BaseGame::loadBuffer(char *buffer, bool complete) {
 #endif
 
 		case TOKEN_CURSOR:
-			delete _cursor;
+			SAFE_DELETE(_cursor);
 			_cursor = new BaseSprite(_gameRef);
 			if (!_cursor || DID_FAIL(_cursor->loadFile(params))) {
-				delete _cursor;
-				_cursor = nullptr;
+				SAFE_DELETE(_cursor);
 				cmd = PARSERR_GENERIC;
 			}
 			break;
 
 		case TOKEN_ACTIVE_CURSOR:
-			delete _activeCursor;
-			_activeCursor = nullptr;
+			SAFE_DELETE(_activeCursor);
 			_activeCursor = new BaseSprite(_gameRef);
 			if (!_activeCursor || DID_FAIL(_activeCursor->loadFile(params))) {
-				delete _activeCursor;
-				_activeCursor = nullptr;
+				SAFE_DELETE(_activeCursor);
 				cmd = PARSERR_GENERIC;
 			}
 			break;
 
 		case TOKEN_NONINTERACTIVE_CURSOR:
-			delete _cursorNoninteractive;
+			SAFE_DELETE(_cursorNoninteractive);
 			_cursorNoninteractive = new BaseSprite(_gameRef);
 			if (!_cursorNoninteractive || DID_FAIL(_cursorNoninteractive->loadFile(params))) {
-				delete _cursorNoninteractive;
-				_cursorNoninteractive = nullptr;
+				SAFE_DELETE(_cursorNoninteractive);
 				cmd = PARSERR_GENERIC;
 			}
 			break;
@@ -1362,7 +1338,7 @@ bool BaseGame::scCallMethod(ScScript *script, ScStack *stack, ScStack *thisStack
 			type = (int)VID_PLAY_STRETCH;
 		}
 
-		delete _theoraPlayer;
+		SAFE_DELETE(_theoraPlayer);
 		_theoraPlayer = new VideoTheoraPlayer(this);
 		if (_theoraPlayer && DID_SUCCEED(_theoraPlayer->initialize(filename, subtitleFile))) {
 			_theoraPlayer->_dontDropFrames = !dropFrames;
@@ -1374,8 +1350,7 @@ bool BaseGame::scCallMethod(ScScript *script, ScStack *stack, ScStack *thisStack
 			}
 		} else {
 			stack->pushBool(false);
-			delete _theoraPlayer;
-			_theoraPlayer = nullptr;
+			SAFE_DELETE(_theoraPlayer);
 		}
 
 		return STATUS_OK;
@@ -1705,8 +1680,7 @@ bool BaseGame::scCallMethod(ScScript *script, ScStack *stack, ScStack *thisStack
 	//////////////////////////////////////////////////////////////////////////
 	else if (strcmp(name, "RemoveActiveCursor") == 0) {
 		stack->correctParams(0);
-		delete _activeCursor;
-		_activeCursor = nullptr;
+		SAFE_DELETE(_activeCursor);
 		stack->pushNULL();
 
 		return STATUS_OK;
@@ -1968,9 +1942,7 @@ bool BaseGame::scCallMethod(ScScript *script, ScStack *stack, ScStack *thisStack
 	//////////////////////////////////////////////////////////////////////////
 	else if (strcmp(name, "RemoveWaitCursor") == 0) {
 		stack->correctParams(0);
-		delete _cursorNoninteractive;
-		_cursorNoninteractive = nullptr;
-
+		SAFE_DELETE(_cursorNoninteractive);
 		stack->pushNULL();
 
 		return STATUS_OK;
@@ -2024,11 +1996,10 @@ bool BaseGame::scCallMethod(ScScript *script, ScStack *stack, ScStack *thisStack
 		_loadingIconY = stack->pop()->getInt();
 		_loadingIconPersistent = stack->pop()->getBool();
 
-		delete _loadingIcon;
+		SAFE_DELETE(_loadingIcon);
 		_loadingIcon = new BaseSprite(this);
 		if (!_loadingIcon || DID_FAIL(_loadingIcon->loadFile(filename))) {
-			delete _loadingIcon;
-			_loadingIcon = nullptr;
+			SAFE_DELETE(_loadingIcon);
 		} else {
 			displayContent(false, true);
 			_gameRef->_renderer->flip();
@@ -2044,8 +2015,7 @@ bool BaseGame::scCallMethod(ScScript *script, ScStack *stack, ScStack *thisStack
 	//////////////////////////////////////////////////////////////////////////
 	else if (strcmp(name, "HideLoadingIcon") == 0) {
 		stack->correctParams(0);
-		delete _loadingIcon;
-		_loadingIcon = nullptr;
+		SAFE_DELETE(_loadingIcon);
 		stack->pushNULL();
 		return STATUS_OK;
 	}
@@ -4349,8 +4319,7 @@ bool BaseGame::setWaitCursor(const char *filename) {
 
 	_cursorNoninteractive = new BaseSprite(_gameRef);
 	if (!_cursorNoninteractive || DID_FAIL(_cursorNoninteractive->loadFile(filename))) {
-		delete _cursorNoninteractive;
-		_cursorNoninteractive = nullptr;
+		SAFE_DELETE(_cursorNoninteractive);
 		return STATUS_FAILED;
 	} else {
 		return STATUS_OK;
@@ -4375,8 +4344,7 @@ bool BaseGame::stopVideo() {
 	}
 	if (_theoraPlayer && _theoraPlayer->isPlaying()) {
 		_theoraPlayer->stop();
-		delete _theoraPlayer;
-		_theoraPlayer = nullptr;
+		SAFE_DELETE(_theoraPlayer);
 	}
 	return STATUS_OK;
 }
@@ -4412,8 +4380,7 @@ bool BaseGame::storeSaveThumbnail() {
 
 //////////////////////////////////////////////////////////////////////////
 void BaseGame::deleteSaveThumbnail() {
-	delete _cachedThumbnail;
-	_cachedThumbnail = nullptr;
+	SAFE_DELETE(_cachedThumbnail);
 }
 
 
diff --git a/engines/wintermute/base/base_named_object.cpp b/engines/wintermute/base/base_named_object.cpp
index 40cf6a100d7..9369ac67a54 100644
--- a/engines/wintermute/base/base_named_object.cpp
+++ b/engines/wintermute/base/base_named_object.cpp
@@ -26,6 +26,7 @@
  */
 
 #include "engines/wintermute/base/base_named_object.h"
+#include "engines/wintermute/dcgf.h"
 
 namespace Wintermute {
 
@@ -47,15 +48,13 @@ BaseNamedObject::BaseNamedObject(TDynamicConstructor, TDynamicConstructor) {
 
 //////////////////////////////////////////////////////////////////////////
 BaseNamedObject::~BaseNamedObject() {
-	delete[] _name;
-	_name = nullptr;
+	SAFE_DELETE_ARRAY(_name);
 }
 
 
 //////////////////////////////////////////////////////////////////////
 void BaseNamedObject::setName(const char *name) {
-	delete[] _name;
-	_name = nullptr;
+	SAFE_DELETE_ARRAY(_name);
 
 	if (name == nullptr) {
 		return;
diff --git a/engines/wintermute/base/base_object.cpp b/engines/wintermute/base/base_object.cpp
index cbb34e9fa81..fdf1cc203a9 100644
--- a/engines/wintermute/base/base_object.cpp
+++ b/engines/wintermute/base/base_object.cpp
@@ -34,6 +34,7 @@
 #include "engines/wintermute/base/base_game.h"
 #include "engines/wintermute/base/base_sprite.h"
 #include "engines/wintermute/platform_osystem.h"
+#include "engines/wintermute/dcgf.h"
 
 #ifdef ENABLE_WME3D
 #include "engines/wintermute/base/base_engine.h"
@@ -139,28 +140,21 @@ bool BaseObject::cleanup() {
 	}
 
 	BaseScriptHolder::cleanup();
-	delete[] _soundEvent;
-	_soundEvent = nullptr;
+	SAFE_DELETE_ARRAY(_soundEvent);
 
 	if (!_sharedCursors) {
-		delete _cursor;
-		_cursor = nullptr;
-		delete _activeCursor;
-		_activeCursor = nullptr;
+		SAFE_DELETE(_cursor);
+		SAFE_DELETE(_activeCursor);
 	}
-	delete _sFX;
-	_sFX = nullptr;
+	SAFE_DELETE(_sFX);
 
 	for (int i = 0; i < 7; i++) {
-		delete[] _caption[i];
-		_caption[i] = nullptr;
+		SAFE_DELETE_ARRAY(_caption[i]);
 	}
 
 #ifdef ENABLE_WME3D
-	delete _xmodel;
-	_xmodel = nullptr;
-	delete _shadowModel;
-	_shadowModel = nullptr;
+	SAFE_DELETE(_xmodel);
+	SAFE_DELETE(_shadowModel);
 
 	if (_shadowImage) {
 		_gameRef->_surfaceStorage->removeSurface(_shadowImage);
@@ -184,7 +178,7 @@ void BaseObject::setCaption(const char *caption, int caseVal) {
 	if (caseVal < 1 || caseVal > 7)
 		return;
 
-	delete[] _caption[caseVal - 1];
+	SAFE_DELETE_ARRAY(_caption[caseVal - 1]);
 	size_t captionSize = strlen(caption) + 1;
 	_caption[caseVal - 1] = new char[captionSize];
 	Common::strcpy_s(_caption[caseVal - 1], captionSize, caption);
@@ -257,8 +251,7 @@ bool BaseObject::scCallMethod(ScScript *script, ScStack *stack, ScStack *thisSta
 	else if (strcmp(name, "RemoveCursor") == 0) {
 		stack->correctParams(0);
 		if (!_sharedCursors) {
-			delete _cursor;
-			_cursor = nullptr;
+			SAFE_DELETE(_cursor);
 		} else {
 			_cursor = nullptr;
 
@@ -1157,15 +1150,13 @@ bool BaseObject::persist(BasePersistenceManager *persistMgr) {
 //////////////////////////////////////////////////////////////////////////
 bool BaseObject::setCursor(const char *filename) {
 	if (!_sharedCursors) {
-		delete _cursor;
-		_cursor = nullptr;
+		SAFE_DELETE(_cursor);
 	}
 
 	_sharedCursors = false;
 	_cursor = new BaseSprite(_gameRef);
 	if (!_cursor || DID_FAIL(_cursor->loadFile(filename))) {
-		delete _cursor;
-		_cursor = nullptr;
+		SAFE_DELETE(_cursor);
 		return STATUS_FAILED;
 	} else {
 		return STATUS_OK;
@@ -1175,11 +1166,10 @@ bool BaseObject::setCursor(const char *filename) {
 
 //////////////////////////////////////////////////////////////////////////
 bool BaseObject::setActiveCursor(const char *filename) {
-	delete _activeCursor;
+	SAFE_DELETE(_activeCursor);
 	_activeCursor = new BaseSprite(_gameRef);
 	if (!_activeCursor || DID_FAIL(_activeCursor->loadFile(filename))) {
-		delete _activeCursor;
-		_activeCursor = nullptr;
+		SAFE_DELETE(_activeCursor);
 		return STATUS_FAILED;
 	} else {
 		return STATUS_OK;
@@ -1258,8 +1248,7 @@ bool BaseObject::playSFX(const char *filename, bool looping, bool playNow, const
 			return STATUS_OK;
 		}
 	} else {
-		delete _sFX;
-		_sFX = nullptr;
+		SAFE_DELETE(_sFX);
 		return STATUS_FAILED;
 	}
 }
@@ -1270,8 +1259,7 @@ bool BaseObject::stopSFX(bool deleteSound) {
 	if (_sFX) {
 		_sFX->stop();
 		if (deleteSound) {
-			delete _sFX;
-			_sFX = nullptr;
+			SAFE_DELETE(_sFX);
 		}
 		return STATUS_OK;
 	} else {
@@ -1376,8 +1364,7 @@ bool BaseObject::isReady() {
 
 //////////////////////////////////////////////////////////////////////////
 void BaseObject::setSoundEvent(const char *eventName) {
-	delete[] _soundEvent;
-	_soundEvent = nullptr;
+	SAFE_DELETE_ARRAY(_soundEvent);
 	if (eventName) {
 		size_t soundEventSize = strlen(eventName) + 1;
 		_soundEvent = new char[soundEventSize];
diff --git a/engines/wintermute/base/base_persistence_manager.cpp b/engines/wintermute/base/base_persistence_manager.cpp
index 79095f32a62..6e48f4e070f 100644
--- a/engines/wintermute/base/base_persistence_manager.cpp
+++ b/engines/wintermute/base/base_persistence_manager.cpp
@@ -123,20 +123,16 @@ void BasePersistenceManager::cleanup() {
 
 	_thumbnailDataSize = 0;
 	if (_thumbnailData) {
-		delete[] _thumbnailData;
-		_thumbnailData = nullptr;
+		SAFE_DELETE_ARRAY(_thumbnailData);
 	}
 
 	_scummVMThumbSize = 0;
 	if (_scummVMThumbnailData) {
-		delete[] _scummVMThumbnailData;
-		_scummVMThumbnailData = nullptr;
+		SAFE_DELETE_ARRAY(_scummVMThumbnailData);
 	}
 
-	delete _loadStream;
-	delete _saveStream;
-	_loadStream = nullptr;
-	_saveStream = nullptr;
+	SAFE_DELETE(_loadStream);
+	SAFE_DELETE(_saveStream);
 }
 
 Common::String BasePersistenceManager::getFilenameForSlot(int slot) const {
@@ -298,8 +294,7 @@ bool BasePersistenceManager::initSave(const Common::String &desc) {
 
 
 		// in any case, destroy the cached thumbnail once used
-		delete _gameRef->_cachedThumbnail;
-		_gameRef->_cachedThumbnail = nullptr;
+		SAFE_DELETE(_gameRef->_cachedThumbnail);
 
 		uint32 dataOffset = _offset +
 		                    sizeof(uint32) + // data offset
diff --git a/engines/wintermute/base/base_region.cpp b/engines/wintermute/base/base_region.cpp
index 1e67474a9e7..544aa65d946 100644
--- a/engines/wintermute/base/base_region.cpp
+++ b/engines/wintermute/base/base_region.cpp
@@ -35,6 +35,7 @@
 #include "engines/wintermute/base/scriptables/script_value.h"
 #include "engines/wintermute/base/base_file_manager.h"
 #include "engines/wintermute/platform_osystem.h"
+#include "engines/wintermute/dcgf.h"
 
 namespace Wintermute {
 
@@ -290,9 +291,7 @@ bool BaseRegion::scCallMethod(ScScript *script, ScStack *stack, ScStack *thisSta
 		int index = stack->pop()->getInt();
 
 		if (index >= 0 && index < _points.getSize()) {
-			delete _points[index];
-			_points[index] = nullptr;
-
+			SAFE_DELETE(_points[index]);
 			_points.removeAt(index);
 			createRegion();
 
diff --git a/engines/wintermute/base/base_script_holder.cpp b/engines/wintermute/base/base_script_holder.cpp
index 606b27a0e80..75cecbe5a7b 100644
--- a/engines/wintermute/base/base_script_holder.cpp
+++ b/engines/wintermute/base/base_script_holder.cpp
@@ -33,6 +33,7 @@
 #include "engines/wintermute/base/scriptables/script_engine.h"
 #include "engines/wintermute/base/scriptables/script.h"
 #include "engines/wintermute/base/scriptables/script_stack.h"
+#include "engines/wintermute/dcgf.h"
 
 namespace Wintermute {
 
@@ -55,8 +56,7 @@ BaseScriptHolder::~BaseScriptHolder() {
 
 //////////////////////////////////////////////////////////////////////////
 bool BaseScriptHolder::cleanup() {
-	delete[] _filename;
-	_filename = nullptr;
+	SAFE_DELETE_ARRAY(_filename);
 
 	for (int32 i = 0; i < _scripts.getSize(); i++) {
 		_scripts[i]->finish(true);
@@ -398,14 +398,14 @@ bool BaseScriptHolder::parseProperty(char *buffer, bool complete) {
 	while ((cmd = parser.getCommand(&buffer, commands, &params)) > 0) {
 		switch (cmd) {
 		case TOKEN_NAME: {
-			delete[] propName;
+			SAFE_DELETE_ARRAY(propName);
 			size_t propNameSize = strlen(params) + 1;
 			propName = new char[propNameSize];
 			Common::strcpy_s(propName, propNameSize, params);
 			break;
 		}
 		case TOKEN_VALUE: {
-			delete[] propValue;
+			SAFE_DELETE_ARRAY(propValue);
 			size_t propValueSize = strlen(params) + 1;
 			propValue = new char[propValueSize];
 			Common::strcpy_s(propValue, propValueSize, params);
@@ -417,14 +417,14 @@ bool BaseScriptHolder::parseProperty(char *buffer, bool complete) {
 
 	}
 	if (cmd == PARSERR_TOKENNOTFOUND) {
-		delete[] propName;
-		delete[] propValue;
+		SAFE_DELETE_ARRAY(propName);
+		SAFE_DELETE_ARRAY(propValue);
 		BaseEngine::LOG(0, "Syntax error in PROPERTY definition");
 		return STATUS_FAILED;
 	}
 	if (cmd == PARSERR_GENERIC || propName == nullptr || propValue == nullptr) {
-		delete[] propName;
-		delete[] propValue;
+		SAFE_DELETE_ARRAY(propName);
+		SAFE_DELETE_ARRAY(propValue);
 		BaseEngine::LOG(0, "Error loading PROPERTY definition");
 		return STATUS_FAILED;
 	}
@@ -435,8 +435,8 @@ bool BaseScriptHolder::parseProperty(char *buffer, bool complete) {
 	scSetProperty(propName, val);
 
 	delete val;
-	delete[] propName;
-	delete[] propValue;
+	SAFE_DELETE_ARRAY(propName);
+	SAFE_DELETE_ARRAY(propValue);
 
 	return STATUS_OK;
 }
diff --git a/engines/wintermute/base/base_scriptable.cpp b/engines/wintermute/base/base_scriptable.cpp
index a362659800d..101dbaa4231 100644
--- a/engines/wintermute/base/base_scriptable.cpp
+++ b/engines/wintermute/base/base_scriptable.cpp
@@ -28,6 +28,7 @@
 #include "engines/wintermute/base/base_scriptable.h"
 #include "engines/wintermute/base/scriptables/script_value.h"
 #include "engines/wintermute/base/base_persistence_manager.h"
+#include "engines/wintermute/dcgf.h"
 
 namespace Wintermute {
 
@@ -52,10 +53,8 @@ BaseScriptable::BaseScriptable(BaseGame *inGame, bool noValue, bool persistable)
 //////////////////////////////////////////////////////////////////////////
 BaseScriptable::~BaseScriptable() {
 	//if (_refCount>0) BaseEngine::LOG(0, "Warning: Destroying object, _refCount=%d", _refCount);
-	delete _scValue;
-	_scValue = nullptr;
-	delete _scProp;
-	_scProp = nullptr;
+	SAFE_DELETE(_scValue);
+	SAFE_DELETE(_scProp);
 }
 
 
diff --git a/engines/wintermute/base/base_sprite.cpp b/engines/wintermute/base/base_sprite.cpp
index 2e149b988e5..b4fbda15865 100644
--- a/engines/wintermute/base/base_sprite.cpp
+++ b/engines/wintermute/base/base_sprite.cpp
@@ -41,6 +41,7 @@
 #include "engines/wintermute/base/scriptables/script.h"
 #include "engines/wintermute/base/scriptables/script_stack.h"
 #include "engines/wintermute/detection.h"
+#include "engines/wintermute/dcgf.h"
 
 namespace Wintermute {
 
@@ -94,8 +95,7 @@ void BaseSprite::cleanup() {
 	}
 	_frames.removeAll();
 
-	delete[] _editorBgFile;
-	_editorBgFile = nullptr;
+	SAFE_DELETE_ARRAY(_editorBgFile);
 
 	setDefaults();
 }
@@ -276,7 +276,7 @@ bool BaseSprite::loadBuffer(char *buffer, bool complete, int lifeTime, TSpriteCa
 
 		case TOKEN_EDITOR_BG_FILE:
 			if (_gameRef->_editorMode) {
-				delete[] _editorBgFile;
+				SAFE_DELETE_ARRAY(_editorBgFile);
 				size_t editorBgFileSize = strlen(params) + 1;
 				_editorBgFile = new char[editorBgFileSize];
 				Common::strcpy_s(_editorBgFile, editorBgFileSize, params);
diff --git a/engines/wintermute/base/base_sub_frame.cpp b/engines/wintermute/base/base_sub_frame.cpp
index e1911bf7652..b91eec967c5 100644
--- a/engines/wintermute/base/base_sub_frame.cpp
+++ b/engines/wintermute/base/base_sub_frame.cpp
@@ -37,6 +37,7 @@
 #include "engines/wintermute/base/scriptables/script_value.h"
 #include "engines/wintermute/base/scriptables/script_stack.h"
 #include "engines/wintermute/platform_osystem.h"
+#include "engines/wintermute/dcgf.h"
 
 namespace Wintermute {
 
@@ -73,8 +74,7 @@ BaseSubFrame::~BaseSubFrame() {
 	if (_surface) {
 		_gameRef->_surfaceStorage->removeSurface(_surface);
 	}
-	delete[] _surfaceFilename;
-	_surfaceFilename = nullptr;
+	SAFE_DELETE_ARRAY(_surfaceFilename);
 }
 
 
@@ -121,8 +121,7 @@ bool BaseSubFrame::loadBuffer(char *buffer, int lifeTime, bool keepLoaded) {
 	BasePlatform::setRectEmpty(&rect);
 	char *surfaceFile = nullptr;
 
-	delete _surface;
-	_surface = nullptr;
+	SAFE_DELETE(_surface);
 
 	while ((cmd = parser.getCommand(&buffer, commands, &params)) > 0) {
 		switch (cmd) {
@@ -495,8 +494,7 @@ bool BaseSubFrame::scCallMethod(ScScript *script, ScStack *stack, ScStack *thisS
 			if (_surface) {
 				_gameRef->_surfaceStorage->removeSurface(_surface);
 			}
-			delete[] _surfaceFilename;
-			_surfaceFilename = nullptr;
+			SAFE_DELETE_ARRAY(_surfaceFilename);
 			stack->pushBool(true);
 		} else {
 			const char *filename = val->getString();
@@ -690,8 +688,7 @@ bool BaseSubFrame::setSurface(const Common::String &filename, bool defaultCK, by
 		_surface = nullptr;
 	}
 
-	delete[] _surfaceFilename;
-	_surfaceFilename = nullptr;
+	SAFE_DELETE_ARRAY(_surfaceFilename);
 
 	_surface = _gameRef->_surfaceStorage->addSurface(filename, defaultCK, ckRed, ckGreen, ckBlue, lifeTime, keepLoaded);
 	if (_surface) {
diff --git a/engines/wintermute/base/font/base_font_bitmap.cpp b/engines/wintermute/base/font/base_font_bitmap.cpp
index ac13328e7b1..a2e8f3734dd 100644
--- a/engines/wintermute/base/font/base_font_bitmap.cpp
+++ b/engines/wintermute/base/font/base_font_bitmap.cpp
@@ -38,6 +38,7 @@
 #include "engines/wintermute/base/base_sprite.h"
 #include "engines/wintermute/base/base_file_manager.h"
 #include "engines/wintermute/platform_osystem.h"
+#include "engines/wintermute/dcgf.h"
 
 namespace Wintermute {
 
@@ -62,10 +63,8 @@ BaseFontBitmap::BaseFontBitmap(BaseGame *inGame) : BaseFont(inGame) {
 
 //////////////////////////////////////////////////////////////////////
 BaseFontBitmap::~BaseFontBitmap() {
-	delete _subframe;
-	_subframe = nullptr;
-	delete _sprite;
-	_sprite = nullptr;
+	SAFE_DELETE(_subframe);
+	SAFE_DELETE(_sprite);
 }
 
 
@@ -457,11 +456,10 @@ bool BaseFontBitmap::loadBuffer(char *buffer) {
 	}
 
 	if (spriteFile != nullptr) {
-		delete _sprite;
+		SAFE_DELETE(_sprite);
 		_sprite = new BaseSprite(_gameRef, this);
 		if (!_sprite || DID_FAIL(_sprite->loadFile(spriteFile))) {
-			delete _sprite;
-			_sprite = nullptr;
+			SAFE_DELETE(_sprite);
 		}
 	}
 
diff --git a/engines/wintermute/base/font/base_font_truetype.cpp b/engines/wintermute/base/font/base_font_truetype.cpp
index 80254f31c42..f38bcbd0152 100644
--- a/engines/wintermute/base/font/base_font_truetype.cpp
+++ b/engines/wintermute/base/font/base_font_truetype.cpp
@@ -36,6 +36,8 @@
 #include "engines/wintermute/utils/utils.h"
 #include "engines/wintermute/platform_osystem.h"
 #include "engines/wintermute/wintermute.h"
+#include "engines/wintermute/dcgf.h"
+
 #include "graphics/fonts/ttf.h"
 #include "graphics/fontman.h"
 #include "common/unicode-bidi.h"
@@ -73,10 +75,10 @@ BaseFontTT::~BaseFontTT() {
 	}
 	_layers.removeAll();
 
-	delete[] _fontFile;
-	_fontFile = nullptr;
+	SAFE_DELETE_ARRAY(_fontFile);
+
+	SAFE_DELETE(_deletableFont);
 
-	delete _deletableFont;
 	_font = nullptr;
 }
 
diff --git a/engines/wintermute/base/gfx/3deffect_params.cpp b/engines/wintermute/base/gfx/3deffect_params.cpp
index eadeb51419f..fe633886568 100644
--- a/engines/wintermute/base/gfx/3deffect_params.cpp
+++ b/engines/wintermute/base/gfx/3deffect_params.cpp
@@ -30,6 +30,7 @@
 #include "engines/wintermute/base/base_file_manager.h"
 #include "engines/wintermute/base/scriptables/script_value.h"
 #include "engines/wintermute/base/gfx/3deffect_params.h"
+#include "engines/wintermute/dcgf.h"
 
 namespace Wintermute {
 
@@ -122,8 +123,7 @@ Effect3DParams::~Effect3DParams() {
 //////////////////////////////////////////////////////////////////////////
 void Effect3DParams::clear() {
 	for (int32 i = 0; i < _params.getSize(); i++) {
-		delete _params[i];
-		_params[i] = nullptr;
+		SAFE_DELETE(_params[i]);
 	}
 
 	_params.removeAll();
diff --git a/engines/wintermute/base/gfx/3dmesh.cpp b/engines/wintermute/base/gfx/3dmesh.cpp
index 7f7dfe5a924..5b6d0595666 100644
--- a/engines/wintermute/base/gfx/3dmesh.cpp
+++ b/engines/wintermute/base/gfx/3dmesh.cpp
@@ -30,6 +30,7 @@
 #include "engines/wintermute/base/base_game.h"
 #include "engines/wintermute/base/gfx/3dloader_3ds.h"
 #include "engines/wintermute/base/gfx/3dmesh.h"
+#include "engines/wintermute/dcgf.h"
 
 namespace Wintermute {
 
@@ -53,12 +54,10 @@ Mesh3DS::~Mesh3DS() {
 
 //////////////////////////////////////////////////////////////////////////
 void Mesh3DS::cleanup() {
-	delete[] _vertices;
-	_vertices = nullptr;
+	SAFE_DELETE_ARRAY(_vertices);
 	_numVertices = 0;
 
-	delete[] _faces;
-	_faces = nullptr;
+	SAFE_DELETE_ARRAY(_faces);
 	_numFaces = 0;
 
 	_vb.free();
diff --git a/engines/wintermute/base/gfx/base_renderer.cpp b/engines/wintermute/base/gfx/base_renderer.cpp
index f6f063f9d39..8cbf52f7f2f 100644
--- a/engines/wintermute/base/gfx/base_renderer.cpp
+++ b/engines/wintermute/base/gfx/base_renderer.cpp
@@ -34,6 +34,7 @@
 #include "engines/wintermute/base/base_engine.h"
 #include "engines/wintermute/platform_osystem.h"
 #include "engines/wintermute/base/base_persistence_manager.h"
+#include "engines/wintermute/dcgf.h"
 
 #ifdef ENABLE_WME3D
 #include "engines/wintermute/base/gfx/xmodel.h"
@@ -79,7 +80,7 @@ BaseRenderer::BaseRenderer(BaseGame *inGame) : BaseClass(inGame) {
 BaseRenderer::~BaseRenderer() {
 	deleteRectList();
 	unclipCursor();
-	delete _saveLoadImage;
+	SAFE_DELETE(_saveLoadImage);
 }
 
 //////////////////////////////////////////////////////////////////////
@@ -232,25 +233,21 @@ void BaseRenderer::initSaveLoad(bool isSaving, bool quickSave) {
 	_hasDrawnSaveLoadImage = false;
 
 	if (isSaving && !quickSave) {
-		delete _saveLoadImage;
-		_saveLoadImage = nullptr;
+		SAFE_DELETE(_saveLoadImage);
 		if (_saveImageName.size()) {
 			_saveLoadImage = createSurface();
 
 			if (!_saveLoadImage || DID_FAIL(_saveLoadImage->create(_saveImageName, true, 0, 0, 0))) {
-				delete _saveLoadImage;
-				_saveLoadImage = nullptr;
+				SAFE_DELETE(_saveLoadImage);
 			}
 		}
 	} else {
-		delete _saveLoadImage;
-		_saveLoadImage = nullptr;
+		SAFE_DELETE(_saveLoadImage);
 		if (_loadImageName.size()) {
 			_saveLoadImage = createSurface();
 
 			if (!_saveLoadImage || DID_FAIL(_saveLoadImage->create(_loadImageName, true, 0, 0, 0))) {
-				delete _saveLoadImage;
-				_saveLoadImage = nullptr;
+				SAFE_DELETE(_saveLoadImage);
 			}
 		}
 		_loadInProgress = true;
@@ -262,8 +259,7 @@ void BaseRenderer::endSaveLoad() {
 	_indicatorDisplay = false;
 	_indicatorWidthDrawn = 0;
 
-	delete _saveLoadImage;
-	_saveLoadImage = nullptr;
+	SAFE_DELETE(_saveLoadImage);
 }
 
 void BaseRenderer::persistSaveLoadImages(BasePersistenceManager *persistMgr) {
diff --git a/engines/wintermute/base/gfx/skin_mesh_helper.cpp b/engines/wintermute/base/gfx/skin_mesh_helper.cpp
index 05b541ab448..e79ee0b7316 100644
--- a/engines/wintermute/base/gfx/skin_mesh_helper.cpp
+++ b/engines/wintermute/base/gfx/skin_mesh_helper.cpp
@@ -40,10 +40,8 @@ SkinMeshHelper::SkinMeshHelper(DXMesh *mesh, DXSkinInfo *skinInfo) {
 
 //////////////////////////////////////////////////////////////////////////
 SkinMeshHelper::~SkinMeshHelper() {
-	delete _mesh;
-	_mesh = nullptr;
-	delete _skinInfo;
-	_skinInfo = nullptr;
+	SAFE_DELETE(_mesh);
+	SAFE_DELETE(_skinInfo);
 }
 
 //////////////////////////////////////////////////////////////////////////
diff --git a/engines/wintermute/base/gfx/xanimation_channel.cpp b/engines/wintermute/base/gfx/xanimation_channel.cpp
index bcc73e9f6b3..2352d962e0a 100644
--- a/engines/wintermute/base/gfx/xanimation_channel.cpp
+++ b/engines/wintermute/base/gfx/xanimation_channel.cpp
@@ -44,10 +44,8 @@ AnimationChannel::AnimationChannel(BaseGame *inGame, XModel *model) : BaseClass(
 
 //////////////////////////////////////////////////////////////////////////
 AnimationChannel::~AnimationChannel() {
-	delete _anim[0];
-	_anim[0] = nullptr;
-	delete _anim[1];
-	_anim[1] = nullptr;
+	SAFE_DELETE(_anim[0]);
+	SAFE_DELETE(_anim[1]);
 
 	_model = nullptr; // ref only
 }
@@ -63,16 +61,13 @@ bool AnimationChannel::playAnim(AnimationSet *animSet, uint32 transitionTime, ui
 	}
 
 	if (transitionTime == 0) {
-		delete _anim[0];
-		_anim[0] = nullptr;
-		delete _anim[1];
-		_anim[1] = nullptr;
+		SAFE_DELETE(_anim[0]);
+		SAFE_DELETE(_anim[1]);
 
 		_anim[0] = anim;
 		_transitioning = false;
 	} else {
-		delete _anim[1];
-		_anim[1] = nullptr;
+		SAFE_DELETE(_anim[1]);
 
 		if (_anim[0]) {
 			_anim[1] = anim;
@@ -81,8 +76,7 @@ bool AnimationChannel::playAnim(AnimationSet *animSet, uint32 transitionTime, ui
 			_transitionStart = _gameRef->_currentTime;
 		} else {
 			_anim[0] = anim;
-			delete _anim[1];
-			_anim[1] = nullptr;
+			SAFE_DELETE(_anim[1]);
 			_transitioning = false;
 		}
 	}
@@ -94,13 +88,10 @@ bool AnimationChannel::playAnim(AnimationSet *animSet, uint32 transitionTime, ui
 bool AnimationChannel::stopAnim(uint32 transitionTime) {
 	if (transitionTime == 0 || !_anim[0]) {
 		_transitioning = false;
-		delete _anim[0];
-		_anim[0] = nullptr;
-		delete _anim[1];
-		_anim[1] = nullptr;
+		SAFE_DELETE(_anim[0]);
+		SAFE_DELETE(_anim[1]);
 	} else {
-		delete _anim[1];
-		_anim[1] = nullptr;
+		SAFE_DELETE(_anim[1]);
 
 		if (_anim[0]) {
 			_anim[0]->setLooping(false);
@@ -123,7 +114,7 @@ bool AnimationChannel::update(bool debug) {
 			_transitioning = false;
 
 			// shift second animation to first slot and update it
-			delete _anim[0];
+			SAFE_DELETE(_anim[0]);
 			_anim[0] = _anim[1];
 			_anim[1] = nullptr;
 
@@ -217,13 +208,11 @@ bool AnimationChannel::persist(BasePersistenceManager *persistMgr) {
 //////////////////////////////////////////////////////////////////////////
 bool AnimationChannel::unloadAnim(AnimationSet *animSet) {
 	if (_anim[0] && _anim[0]->getAnimSet() == animSet) {
-		delete _anim[0];
-		_anim[0] = nullptr;
+		SAFE_DELETE(_anim[0]);
 	}
 
 	if (_anim[1] && _anim[1]->getAnimSet() == animSet) {
-		delete _anim[1];
-		_anim[1] = nullptr;
+		SAFE_DELETE(_anim[1]);
 	}
 
 	return true;
diff --git a/engines/wintermute/base/gfx/xanimation_set.cpp b/engines/wintermute/base/gfx/xanimation_set.cpp
index 892ed30a6e0..b81e14de8e5 100644
--- a/engines/wintermute/base/gfx/xanimation_set.cpp
+++ b/engines/wintermute/base/gfx/xanimation_set.cpp
@@ -81,7 +81,7 @@ bool AnimationSet::addEvent(AnimationEvent *event) {
 		int frameTime = getFrameTime();
 		if (frameTime < 0) {
 			_gameRef->LOG(0, "Error adding animation event %s, no keyframes found", event->_eventName);
-			delete event;
+			SAFE_DELETE(event);
 			return false;
 		}
 
diff --git a/engines/wintermute/base/gfx/xfile.cpp b/engines/wintermute/base/gfx/xfile.cpp
index 81e65bc591d..fc95906fb98 100644
--- a/engines/wintermute/base/gfx/xfile.cpp
+++ b/engines/wintermute/base/gfx/xfile.cpp
@@ -45,8 +45,7 @@ XFile::~XFile() {
 
 //////////////////////////////////////////////////////////////////////////
 bool XFile::closeFile() {
-	delete _xfile;
-	_xfile = nullptr;
+	SAFE_DELETE(_xfile);
 
 	return true;
 }
diff --git a/engines/wintermute/base/gfx/xframe_node.cpp b/engines/wintermute/base/gfx/xframe_node.cpp
index 2ee45cb84c4..af5d33c5836 100644
--- a/engines/wintermute/base/gfx/xframe_node.cpp
+++ b/engines/wintermute/base/gfx/xframe_node.cpp
@@ -117,7 +117,7 @@ bool FrameNode::loadFromXData(const Common::String &filename, XModel *model, XFi
 			_meshes.add(mesh);
 			return true;
 		} else {
-			delete mesh;
+			SAFE_DELETE(mesh);
 			return false;
 		}
 	} else if (objectType == kXClassFrameTransformMatrix) { // load the transformation matrix
@@ -143,7 +143,7 @@ bool FrameNode::loadFromXData(const Common::String &filename, XModel *model, XFi
 		res = XModel::loadName(childFrame, xobj);
 		if (!res) {
 			BaseEngine::LOG(0, "Error loading frame name");
-			delete childFrame;
+			SAFE_DELETE(childFrame);
 			return res;
 		}
 
diff --git a/engines/wintermute/base/gfx/xmesh.cpp b/engines/wintermute/base/gfx/xmesh.cpp
index 1bf462f76ef..ecbeb7335db 100644
--- a/engines/wintermute/base/gfx/xmesh.cpp
+++ b/engines/wintermute/base/gfx/xmesh.cpp
@@ -38,6 +38,7 @@
 #include "engines/wintermute/base/gfx/3dutils.h"
 #include "engines/wintermute/base/base_engine.h"
 #include "engines/wintermute/utils/path_util.h"
+#include "engines/wintermute/dcgf.h"
 
 #include "math/utils.h"
 
@@ -55,17 +56,12 @@ XMesh::XMesh(Wintermute::BaseGame *inGame) : BaseNamedObject(inGame) {
 }
 
 XMesh::~XMesh() {
-	delete _skinMesh;
-	_skinMesh = nullptr;
-	delete _blendedMesh;
-	_blendedMesh = nullptr;
-	delete _staticMesh;
-	_staticMesh = nullptr;
+	SAFE_DELETE(_skinMesh);
+	SAFE_DELETE(_blendedMesh);
+	SAFE_DELETE(_staticMesh);
 
-	delete[] _boneMatrices;
-	_boneMatrices = nullptr;
-	delete[] _adjacency;
-	_adjacency = nullptr;
+	SAFE_DELETE_ARRAY(_boneMatrices);
+	SAFE_DELETE_ARRAY(_adjacency);
 
 	_materials.removeAll();
 }
@@ -104,8 +100,7 @@ bool XMesh::loadFromXData(const Common::String &filename, XFileData *xobj) {
 		_skinMesh->getOriginalMesh(&_staticMesh);
 		_staticMesh->cloneMesh(&_blendedMesh);
 
-		delete _skinMesh;
-		_skinMesh = nullptr;
+		SAFE_DELETE(_skinMesh);
 
 		if (_blendedMesh) {
 			uint32 numFaces = _blendedMesh->getNumFaces();
@@ -151,10 +146,9 @@ bool XMesh::loadFromXData(const Common::String &filename, XFileData *xobj) {
 bool XMesh::generateMesh() {
 	uint32 numFaces = _skinMesh->getNumFaces();
 
-	delete _blendedMesh;
-	_blendedMesh = nullptr;
+	SAFE_DELETE(_blendedMesh);
 
-	delete[] _adjacency;
+	SAFE_DELETE_ARRAY(_adjacency);
 	_adjacency = new uint32[numFaces * 3];
 
 	// blend the mesh
@@ -350,8 +344,7 @@ bool XMesh::removeMaterialEffect(const Common::String &matName) {
 //////////////////////////////////////////////////////////////////////////
 bool XMesh::invalidateDeviceObjects() {
 	if (_skinMesh) {
-		delete[] _blendedMesh;
-		_blendedMesh = nullptr;
+		SAFE_DELETE(_blendedMesh);
 	}
 
 	for (int32 i = 0; i < _materials.getSize(); i++) {
diff --git a/engines/wintermute/base/gfx/xmodel.cpp b/engines/wintermute/base/gfx/xmodel.cpp
index 7f59429035f..a7f3f73bd1b 100644
--- a/engines/wintermute/base/gfx/xmodel.cpp
+++ b/engines/wintermute/base/gfx/xmodel.cpp
@@ -47,6 +47,7 @@
 #include "engines/wintermute/utils/path_util.h"
 #include "engines/wintermute/utils/utils.h"
 #include "engines/wintermute/wintermute.h"
+#include "engines/wintermute/dcgf.h"
 
 namespace Wintermute {
 
@@ -83,8 +84,7 @@ XModel::~XModel() {
 void XModel::cleanup(bool complete) {
 	// empty animation channels
 	for (int i = 0; i < X_NUM_ANIMATION_CHANNELS; i++) {
-		delete _channels[i];
-		_channels[i] = nullptr;
+		SAFE_DELETE(_channels[i]);
 	}
 
 	// remove animation sets
@@ -95,20 +95,18 @@ void XModel::cleanup(bool complete) {
 
 	if (complete) {
 		for (int32 i = 0; i < _mergedModels.getSize(); ++i) {
-			delete[] _mergedModels[i];
+			SAFE_DELETE_ARRAY(_mergedModels[i]);
 		}
 		_mergedModels.removeAll();
 	}
 
 	for (int32 i = 0; i < _matSprites.getSize(); i++) {
-		delete _matSprites[i];
-		_matSprites[i] = nullptr;
+		SAFE_DELETE(_matSprites[i]);
 	}
 	_matSprites.removeAll();
 
 	// remove root frame
-	delete _rootFrame;
-	_rootFrame = nullptr;
+	SAFE_DELETE(_rootFrame);
 
 	_parentModel = nullptr;
 
@@ -238,7 +236,7 @@ bool XModel::loadAnimationSet(const Common::String &filename, XFileData *xobj) {
 	AnimationSet *animSet = new AnimationSet(_gameRef, this);
 	res = loadName(animSet, xobj);
 	if (!res) {
-		delete animSet;
+		SAFE_DELETE(animSet);
 		return res;
 	}
 
@@ -261,7 +259,7 @@ bool XModel::loadAnimationSet(const Common::String &filename, XFileData *xobj) {
 		if (res) {
 			res = xchildData.getType(objectType);
 			if (!res) {
-				delete animSet;
+				SAFE_DELETE(animSet);
 				BaseEngine::LOG(0, "Error getting object type while loading animation set");
 				return res;
 			}
@@ -269,7 +267,7 @@ bool XModel::loadAnimationSet(const Common::String &filename, XFileData *xobj) {
 			if (objectType == kXClassAnimation) {
 				res = loadAnimation(filename, &xchildData, animSet);
 				if (!res) {
-					delete animSet;
+					SAFE_DELETE(animSet);
 					return res;
 				}
 			}
@@ -306,10 +304,9 @@ bool XModel::loadAnimation(const Common::String &filename, XFileData *xobj, Anim
 		if (res) {
 			res = anim->load(&xchildData, parentAnimSet);
 			if (!res) {
-				delete anim;
-				if (newAnimSet) {
-					delete parentAnimSet;
-				}
+				SAFE_DELETE(anim);
+				if (newAnimSet)
+					SAFE_DELETE(parentAnimSet);
 				return res;
 			}
 		}
@@ -775,14 +772,14 @@ bool XModel::parseEvent(AnimationSet *anim, char *buffer) {
 	}
 
 	if (cmd != PARSERR_EOF) {
-		delete event;
+		SAFE_DELETE(event);
 		return false;
 	}
 
 	if (event->_eventName) {
 		anim->addEvent(event);
 	} else {
-		delete event;
+		SAFE_DELETE(event);
 	}
 
 	return true;
@@ -800,7 +797,7 @@ bool XModel::setMaterialSprite(const char *materialName, const char *spriteFilen
 
 	BaseSprite *sprite = new BaseSprite(_gameRef);
 	if (!sprite || !sprite->loadFile(spriteFilename)) {
-		delete sprite;
+		SAFE_DELETE(sprite);
 		return false;
 	}
 
@@ -835,7 +832,7 @@ bool XModel::setMaterialTheora(const char *materialName, const char *theoraFilen
 
 	VideoTheoraPlayer *theora = new VideoTheoraPlayer(_gameRef);
 	if (!theora || theora->initialize(theoraFilename)) {
-		delete theora;
+		SAFE_DELETE(theora);
 		return false;
 	}
 
@@ -870,7 +867,7 @@ bool XModel::setMaterialEffect(const char *materialName, const char *effectFilen
 
 	Effect3D *effect = new Effect3D(_gameRef);
 	if (!effect->createFromFile(effectFilename)) {
-		delete effect;
+		SAFE_DELETE(effect);
 		return false;
 	}
 
@@ -901,8 +898,7 @@ bool XModel::removeMaterialEffect(const char *materialName) {
 
 	for (int32 i = 0; i < _matSprites.getSize(); i++) {
 		if (scumm_stricmp(_matSprites[i]->_matName, materialName) == 0) {
-			delete _matSprites[i];
-			_matSprites[i] = nullptr;
+			SAFE_DELETE(_matSprites[i]);
 			_matSprites.removeAt(i);
 			_rootFrame->removeMaterialEffect(materialName);
 			return true;
@@ -971,8 +967,7 @@ bool XModel::initializeSimple() {
 				_matSprites[i]->_effect = effect;
 				_rootFrame->setMaterialEffect(_matSprites[i]->_matName, _matSprites[i]->_effect, _matSprites[i]->_effectParams);
 			} else {
-				delete effect;
-				effect = nullptr;
+				SAFE_DELETE(effect);
 			}
 		}
 	}
@@ -1112,7 +1107,7 @@ bool XModel::unloadAnimation(const char *animName) {
 			}
 
 			found = true;
-			delete _animationSets[i];
+			SAFE_DELETE(_animationSets[i]);
 			_animationSets.removeAt(i);
 			i++;
 		}
diff --git a/engines/wintermute/base/particles/part_emitter.cpp b/engines/wintermute/base/particles/part_emitter.cpp
index bb0d3bb31a8..a9006f3bb51 100644
--- a/engines/wintermute/base/particles/part_emitter.cpp
+++ b/engines/wintermute/base/particles/part_emitter.cpp
@@ -38,6 +38,8 @@
 #include "engines/wintermute/base/gfx/base_renderer.h"
 #include "engines/wintermute/utils/utils.h"
 #include "engines/wintermute/platform_osystem.h"
+#include "engines/wintermute/dcgf.h"
+
 #include "common/str.h"
 #include "math/utils.h"
 
@@ -111,8 +113,7 @@ PartEmitter::~PartEmitter() {
 	}
 	_sprites.removeAll();
 
-	delete[] _emitEvent;
-	_emitEvent = nullptr;
+	SAFE_DELETE_ARRAY(_emitEvent);
 }
 
 //////////////////////////////////////////////////////////////////////////
diff --git a/engines/wintermute/base/particles/part_particle.cpp b/engines/wintermute/base/particles/part_particle.cpp
index 4eac02e1532..ed304e82e7e 100644
--- a/engines/wintermute/base/particles/part_particle.cpp
+++ b/engines/wintermute/base/particles/part_particle.cpp
@@ -30,6 +30,8 @@
 #include "engines/wintermute/base/base_sprite.h"
 #include "engines/wintermute/utils/utils.h"
 #include "engines/wintermute/platform_osystem.h"
+#include "engines/wintermute/dcgf.h"
+
 #include "common/str.h"
 
 namespace Wintermute {
@@ -63,8 +65,7 @@ PartParticle::PartParticle(BaseGame *inGame) : BaseClass(inGame) {
 
 //////////////////////////////////////////////////////////////////////////
 PartParticle::~PartParticle() {
-	delete _sprite;
-	_sprite = nullptr;
+	SAFE_DELETE(_sprite);
 }
 
 //////////////////////////////////////////////////////////////////////////
@@ -74,8 +75,7 @@ bool PartParticle::setSprite(const Common::String &filename) {
 		return STATUS_OK;
 	}
 
-	delete _sprite;
-	_sprite = nullptr;
+	SAFE_DELETE(_sprite);
 
 	SystemClassRegistry::getInstance()->_disabled = true;
 	_sprite = new BaseSprite(_gameRef, (BaseObject*)_gameRef);
@@ -83,8 +83,7 @@ bool PartParticle::setSprite(const Common::String &filename) {
 		SystemClassRegistry::getInstance()->_disabled = false;
 		return STATUS_OK;
 	} else {
-		delete _sprite;
-		_sprite = nullptr;
+		SAFE_DELETE(_sprite);
 		SystemClassRegistry::getInstance()->_disabled = false;
 		return STATUS_FAILED;
 	}
diff --git a/engines/wintermute/base/scriptables/script.cpp b/engines/wintermute/base/scriptables/script.cpp
index b91bc9d01b1..3f532d4f389 100644
--- a/engines/wintermute/base/scriptables/script.cpp
+++ b/engines/wintermute/base/scriptables/script.cpp
@@ -33,6 +33,8 @@
 #include "engines/wintermute/base/scriptables/script_stack.h"
 #include "engines/wintermute/base/gfx/base_renderer.h"
 #include "engines/wintermute/ext/externals.h"
+#include "engines/wintermute/dcgf.h"
+
 #include "common/memstream.h"
 
 #ifdef ENABLE_FOXTAIL
@@ -258,8 +260,7 @@ bool ScScript::create(const char *filename, byte *buffer, uint32 size, BaseScrip
 
 	_thread = false;
 	_methodThread = false;
-	delete[] _threadEvent;
-	_threadEvent = nullptr;
+	SAFE_DELETE_ARRAY(_threadEvent);
 
 	size_t filenameSize = strlen(filename) + 1;
 	_filename = new char[filenameSize];
@@ -444,13 +445,10 @@ void ScScript::cleanup() {
 	_externals = nullptr;
 	_numExternals = 0;
 
-	delete _operand;
-	_operand = nullptr;
-	delete _reg1;
-	_reg1 = nullptr;
+	SAFE_DELETE(_operand);
+	SAFE_DELETE(_reg1);
 
-	delete[] _threadEvent;
-	_threadEvent = nullptr;
+	SAFE_DELETE_ARRAY(_threadEvent);
 
 	_state = SCRIPT_FINISHED;
 
@@ -461,8 +459,7 @@ void ScScript::cleanup() {
 
 	_parentScript = nullptr; // ref only
 
-	delete _scriptStream;
-	_scriptStream = nullptr;
+	SAFE_DELETE(_scriptStream);
 }
 
 
diff --git a/engines/wintermute/base/scriptables/script_engine.cpp b/engines/wintermute/base/scriptables/script_engine.cpp
index 0ec291036ed..82013916514 100644
--- a/engines/wintermute/base/scriptables/script_engine.cpp
+++ b/engines/wintermute/base/scriptables/script_engine.cpp
@@ -33,6 +33,7 @@
 #include "engines/wintermute/base/base_game.h"
 #include "engines/wintermute/base/base_file_manager.h"
 #include "engines/wintermute/utils/utils.h"
+#include "engines/wintermute/dcgf.h"
 
 namespace Wintermute {
 
@@ -110,8 +111,7 @@ bool ScEngine::cleanup() {
 
 	_scripts.removeAll();
 
-	delete _globals;
-	_globals = nullptr;
+	SAFE_DELETE(_globals);
 
 	emptyScriptCache();
 
@@ -481,8 +481,7 @@ int ScEngine::getNumScripts(int *running, int *waiting, int *persistent) {
 bool ScEngine::emptyScriptCache() {
 	for (int i = 0; i < MAX_CACHED_SCRIPTS; i++) {
 		if (_cachedScripts[i]) {
-			delete _cachedScripts[i];
-			_cachedScripts[i] = nullptr;
+			SAFE_DELETE(_cachedScripts[i]);
 		}
 	}
 	return STATUS_OK;
diff --git a/engines/wintermute/base/scriptables/script_ext_array.cpp b/engines/wintermute/base/scriptables/script_ext_array.cpp
index 1ab2462ce21..d760194279b 100644
--- a/engines/wintermute/base/scriptables/script_ext_array.cpp
+++ b/engines/wintermute/base/scriptables/script_ext_array.cpp
@@ -30,6 +30,7 @@
 #include "engines/wintermute/base/scriptables/script_stack.h"
 #include "engines/wintermute/system/sys_instance.h"
 #include "engines/wintermute/base/scriptables/script_ext_array.h"
+#include "engines/wintermute/dcgf.h"
 
 namespace Wintermute {
 
@@ -67,8 +68,7 @@ SXArray::SXArray(BaseGame *inGame) : BaseScriptable(inGame) {
 
 //////////////////////////////////////////////////////////////////////////
 SXArray::~SXArray() {
-	delete _values;
-	_values = nullptr;
+	SAFE_DELETE(_values);
 }
 
 
diff --git a/engines/wintermute/base/scriptables/script_ext_file.cpp b/engines/wintermute/base/scriptables/script_ext_file.cpp
index c06437a3ffb..0a9611d1fdb 100644
--- a/engines/wintermute/base/scriptables/script_ext_file.cpp
+++ b/engines/wintermute/base/scriptables/script_ext_file.cpp
@@ -35,6 +35,7 @@
 #include "engines/wintermute/base/base_file_manager.h"
 #include "engines/wintermute/platform_osystem.h"
 #include "engines/wintermute/base/scriptables/script_ext_file.h"
+#include "engines/wintermute/dcgf.h"
 
 // Note: This code is completely untested, as I have yet to find a game that uses SXFile.
 
@@ -71,8 +72,7 @@ SXFile::~SXFile() {
 
 //////////////////////////////////////////////////////////////////////////
 void SXFile::cleanup() {
-	delete[] _filename;
-	_filename = nullptr;
+	SAFE_DELETE_ARRAY(_filename);
 	close();
 }
 
@@ -85,8 +85,7 @@ void SXFile::close() {
 	}
 	if (_writeFile) {
 		_writeFile->finalize();
-		delete _writeFile;
-		_writeFile = nullptr;
+		SAFE_DELETE(_writeFile);
 	}
 	_mode = 0;
 	_textMode = false;
diff --git a/engines/wintermute/base/scriptables/script_ext_string.cpp b/engines/wintermute/base/scriptables/script_ext_string.cpp
index 4cfab371f37..32acfa274c1 100644
--- a/engines/wintermute/base/scriptables/script_ext_string.cpp
+++ b/engines/wintermute/base/scriptables/script_ext_string.cpp
@@ -32,6 +32,8 @@
 #include "engines/wintermute/base/scriptables/script_ext_string.h"
 #include "engines/wintermute/base/scriptables/script_ext_array.h"
 #include "engines/wintermute/utils/string_util.h"
+#include "engines/wintermute/dcgf.h"
+
 #include "common/str.h"
 #include "common/tokenizer.h"
 
@@ -79,7 +81,7 @@ void SXString::setStringVal(const char *val) {
 	int len = strlen(val);
 	if (len >= _capacity) {
 		_capacity = len + 1;
-		delete[] _string;
+		SAFE_DELETE_ARRAY(_string);
 		_string = new char[_capacity]();
 	}
 	Common::strcpy_s(_string, _capacity, val);
@@ -396,7 +398,7 @@ bool SXString::scSetProperty(const char *name, ScValue *value) {
 			char *newStr = new char[newCap]();
 			if (newStr) {
 				Common::strcpy_s(newStr, newCap, _string);
-				delete[] _string;
+				SAFE_DELETE_ARRAY(_string);
 				_string = newStr;
 				_capacity = newCap;
 			}
diff --git a/engines/wintermute/base/sound/base_sound_buffer.cpp b/engines/wintermute/base/sound/base_sound_buffer.cpp
index af9ece8407d..53a1839de5f 100644
--- a/engines/wintermute/base/sound/base_sound_buffer.cpp
+++ b/engines/wintermute/base/sound/base_sound_buffer.cpp
@@ -30,6 +30,8 @@
 #include "engines/wintermute/base/sound/base_sound_buffer.h"
 #include "engines/wintermute/base/base_file_manager.h"
 #include "engines/wintermute/wintermute.h"
+#include "engines/wintermute/dcgf.h"
+
 #include "audio/audiostream.h"
 #include "audio/mixer.h"
 #ifdef USE_VORBIS
@@ -76,11 +78,9 @@ BaseSoundBuffer::~BaseSoundBuffer() {
 
 	if (_handle) {
 		g_system->getMixer()->stopHandle(*_handle);
-		delete _handle;
-		_handle = nullptr;
+		SAFE_DELETE(_handle);
 	}
-	delete _stream;
-	_stream = nullptr;
+	SAFE_DELETE(_stream);
 }
 
 
@@ -138,8 +138,7 @@ bool BaseSoundBuffer::loadFromFile(const Common::String &filename, bool forceRel
 bool BaseSoundBuffer::play(bool looping, uint32 startSample) {
 	if (_handle) {
 		g_system->getMixer()->stopHandle(*_handle);
-		delete _handle;
-		_handle = nullptr;
+		SAFE_DELETE(_handle);
 	}
 	// Store the loop-value for save-games.
 	setLooping(looping);
diff --git a/engines/wintermute/dcgf.h b/engines/wintermute/dcgf.h
index b3d4d13e490..8b188f7b4c9 100644
--- a/engines/wintermute/dcgf.h
+++ b/engines/wintermute/dcgf.h
@@ -47,4 +47,16 @@
 
 #define COMPRESSED_FILE_MAGIC 0x504D435A // ZCMP
 
+#define SAFE_DELETE(obj) \
+do {                     \
+	delete (obj);        \
+	(obj) = nullptr;     \
+} while (0)
+
+#define SAFE_DELETE_ARRAY(obj) \
+do {                           \
+	delete[] (obj);            \
+	(obj) = nullptr;           \
+} while (0)
+
 #endif
diff --git a/engines/wintermute/ui/ui_button.cpp b/engines/wintermute/ui/ui_button.cpp
index 3b52e1a5f59..310fe4981cc 100644
--- a/engines/wintermute/ui/ui_button.cpp
+++ b/engines/wintermute/ui/ui_button.cpp
@@ -40,6 +40,7 @@
 #include "engines/wintermute/base/scriptables/script_value.h"
 #include "engines/wintermute/base/scriptables/script.h"
 #include "engines/wintermute/base/scriptables/script_stack.h"
+#include "engines/wintermute/dcgf.h"
 
 namespace Wintermute {
 
@@ -230,101 +231,91 @@ bool UIButton::loadBuffer(char *buffer, bool complete) {
 			break;
 
 		case TOKEN_BACK:
-			delete _back;
+			SAFE_DELETE(_back);
 			_back = new UITiledImage(_gameRef);
 			if (!_back || DID_FAIL(_back->loadFile(params))) {
-				delete _back;
-				_back = nullptr;
+				SAFE_DELETE(_back);
 				cmd = PARSERR_GENERIC;
 			}
 			break;
 
 		case TOKEN_BACK_HOVER:
-			delete _backHover;
+			SAFE_DELETE(_backHover);
 			_backHover = new UITiledImage(_gameRef);
 			if (!_backHover || DID_FAIL(_backHover->loadFile(params))) {
-				delete _backHover;
-				_backHover = nullptr;
+				SAFE_DELETE(_backHover);
 				cmd = PARSERR_GENERIC;
 			}
 			break;
 
 		case TOKEN_BACK_PRESS:
-			delete _backPress;
+			SAFE_DELETE(_backPress);
 			_backPress = new UITiledImage(_gameRef);
 			if (!_backPress || DID_FAIL(_backPress->loadFile(params))) {
-				delete _backPress;
-				_backPress = nullptr;
+				SAFE_DELETE(_backPress);
 				cmd = PARSERR_GENERIC;
 			}
 			break;
 
 		case TOKEN_BACK_DISABLE:
-			delete _backDisable;
+			SAFE_DELETE(_backDisable);
 			_backDisable = new UITiledImage(_gameRef);
 			if (!_backDisable || DID_FAIL(_backDisable->loadFile(params))) {
-				delete _backDisable;
-				_backDisable = nullptr;
+				SAFE_DELETE(_backDisable);
 				cmd = PARSERR_GENERIC;
 			}
 			break;
 
 		case TOKEN_BACK_FOCUS:
-			delete _backFocus;
+			SAFE_DELETE(_backFocus);
 			_backFocus = new UITiledImage(_gameRef);
 			if (!_backFocus || DID_FAIL(_backFocus->loadFile(params))) {
-				delete _backFocus;
-				_backFocus = nullptr;
+				SAFE_DELETE(_backFocus);
 				cmd = PARSERR_GENERIC;
 			}
 			break;
 
 		case TOKEN_IMAGE:
-			delete _image;
+			SAFE_DELETE(_image);
 			_image = new BaseSprite(_gameRef);
 			if (!_image || DID_FAIL(_image->loadFile(params))) {
-				delete _image;
-				_image = nullptr;
+				SAFE_DELETE(_image);
 				cmd = PARSERR_GENERIC;
 			}
 			break;
 
 		case TOKEN_IMAGE_HOVER:
-			delete _imageHover;
+			SAFE_DELETE(_imageHover);
 			_imageHover = new BaseSprite(_gameRef);
 			if (!_imageHover || DID_FAIL(_imageHover->loadFile(params))) {
-				delete _imageHover;
-				_imageHover = nullptr;
+				SAFE_DELETE(_imageHover);
 				cmd = PARSERR_GENERIC;
 			}
 			break;
 
 		case TOKEN_IMAGE_PRESS:
-			delete _imagePress;
+			SAFE_DELETE(_imagePress);
 			_imagePress = new BaseSprite(_gameRef);
 			if (!_imagePress || DID_FAIL(_imagePress->loadFile(params))) {
-				delete _imagePress;
-				_imagePress = nullptr;
+				SAFE_DELETE(_imagePress);
 				cmd = PARSERR_GENERIC;
 			}
 			break;
 
 		case TOKEN_IMAGE_DISABLE:
-			delete _imageDisable;
+			SAFE_DELETE(_imageDisable);
 			_imageDisable = new BaseSprite(_gameRef);
 			if (!_imageDisable || DID_FAIL(_imageDisable->loadFile(params))) {
-				delete _imageDisable;
-				_imageDisable = nullptr;
+				SAFE_DELETE(_imageDisable);
 				cmd = PARSERR_GENERIC;
 			}
 			break;
 
 		case TOKEN_IMAGE_FOCUS:
-			delete _imageFocus;
+			SAFE_DELETE(_imageFocus);
 			_imageFocus = new BaseSprite(_gameRef);
 			if (!_imageFocus || DID_FAIL(_imageFocus->loadFile(params))) {
-				delete _imageFocus;
-				_imageFocus = nullptr;
+				SAFE_DELETE(_imageFocus);
 				cmd = PARSERR_GENERIC;
 			}
 			break;
@@ -411,11 +402,10 @@ bool UIButton::loadBuffer(char *buffer, bool complete) {
 			break;
 
 		case TOKEN_CURSOR:
-			delete _cursor;
+			SAFE_DELETE(_cursor);
 			_cursor = new BaseSprite(_gameRef);
 			if (!_cursor || DID_FAIL(_cursor->loadFile(params))) {
-				delete _cursor;
-				_cursor = nullptr;
+				SAFE_DELETE(_cursor);
 				cmd = PARSERR_GENERIC;
 			}
 			break;
@@ -901,8 +891,7 @@ bool UIButton::scCallMethod(ScScript *script, ScStack *stack, ScStack *thisStack
 		_imageDisable = new BaseSprite(_gameRef);
 		const char *filename = stack->pop()->getString();
 		if (!_imageDisable || DID_FAIL(_imageDisable->loadFile(filename))) {
-			delete _imageDisable;
-			_imageDisable = nullptr;
+			SAFE_DELETE(_imageDisable);
 			stack->pushBool(false);
 		} else {
 			stack->pushBool(true);
@@ -946,12 +935,11 @@ bool UIButton::scCallMethod(ScScript *script, ScStack *stack, ScStack *thisStack
 	else if (strcmp(name, "SetHoverImage") == 0) {
 		stack->correctParams(1);
 
-		delete _imageHover;
+		SAFE_DELETE(_imageHover);
 		_imageHover = new BaseSprite(_gameRef);
 		const char *filename = stack->pop()->getString();
 		if (!_imageHover || DID_FAIL(_imageHover->loadFile(filename))) {
-			delete _imageHover;
-			_imageHover = nullptr;
+			SAFE_DELETE(_imageHover);
 			stack->pushBool(false);
 		} else {
 			stack->pushBool(true);
@@ -994,12 +982,11 @@ bool UIButton::scCallMethod(ScScript *script, ScStack *stack, ScStack *thisStack
 	else if (strcmp(name, "SetPressedImage") == 0) {
 		stack->correctParams(1);
 
-		delete _imagePress;
+		SAFE_DELETE(_imagePress);
 		_imagePress = new BaseSprite(_gameRef);
 		const char *filename = stack->pop()->getString();
 		if (!_imagePress || DID_FAIL(_imagePress->loadFile(filename))) {
-			delete _imagePress;
-			_imagePress = nullptr;
+			SAFE_DELETE(_imagePress);
 			stack->pushBool(false);
 		} else {
 			stack->pushBool(true);
@@ -1042,12 +1029,11 @@ bool UIButton::scCallMethod(ScScript *script, ScStack *stack, ScStack *thisStack
 	else if (strcmp(name, "SetFocusedImage") == 0) {
 		stack->correctParams(1);
 
-		delete _imageFocus;
+		SAFE_DELETE(_imageFocus);
 		_imageFocus = new BaseSprite(_gameRef);
 		const char *filename = stack->pop()->getString();
 		if (!_imageFocus || DID_FAIL(_imageFocus->loadFile(filename))) {
-			delete _imageFocus;
-			_imageFocus = nullptr;
+			SAFE_DELETE(_imageFocus);
 			stack->pushBool(false);
 		} else {
 			stack->pushBool(true);
diff --git a/engines/wintermute/ui/ui_edit.cpp b/engines/wintermute/ui/ui_edit.cpp
index abeb00d1f7f..be5f41791a8 100644
--- a/engines/wintermute/ui/ui_edit.cpp
+++ b/engines/wintermute/ui/ui_edit.cpp
@@ -44,6 +44,8 @@
 #include "engines/wintermute/base/scriptables/script_stack.h"
 #include "engines/wintermute/base/scriptables/script.h"
 #include "engines/wintermute/utils/utils.h"
+#include "engines/wintermute/dcgf.h"
+
 #include "common/util.h"
 #include "common/keyboard.h"
 
@@ -86,8 +88,7 @@ UIEdit::~UIEdit() {
 		}
 	}
 
-	delete[] _cursorChar;
-	_cursorChar = nullptr;
+	SAFE_DELETE_ARRAY(_cursorChar);
 }
 
 
@@ -189,21 +190,19 @@ bool UIEdit::loadBuffer(char *buffer, bool complete) {
 			break;
 
 		case TOKEN_BACK:
-			delete _back;
+			SAFE_DELETE(_back);
 			_back = new UITiledImage(_gameRef);
 			if (!_back || DID_FAIL(_back->loadFile(params))) {
-				delete _back;
-				_back = nullptr;
+				SAFE_DELETE(_back);
 				cmd = PARSERR_GENERIC;
 			}
 			break;
 
 		case TOKEN_IMAGE:
-			delete _image;
+			SAFE_DELETE(_image);
 			_image = new BaseSprite(_gameRef);
 			if (!_image || DID_FAIL(_image->loadFile(params))) {
-				delete _image;
-				_image = nullptr;
+				SAFE_DELETE(_image);
 				cmd = PARSERR_GENERIC;
 			}
 			break;
@@ -258,11 +257,10 @@ bool UIEdit::loadBuffer(char *buffer, bool complete) {
 			break;
 
 		case TOKEN_CURSOR:
-			delete _cursor;
+			SAFE_DELETE(_cursor);
 			_cursor = new BaseSprite(_gameRef);
 			if (!_cursor || DID_FAIL(_cursor->loadFile(params))) {
-				delete _cursor;
-				_cursor = nullptr;
+				SAFE_DELETE(_cursor);
 				cmd = PARSERR_GENERIC;
 			}
 			break;
@@ -558,7 +556,7 @@ void UIEdit::setCursorChar(const char *character) {
 	if (!character) {
 		return;
 	}
-	delete[] _cursorChar;
+	SAFE_DELETE_ARRAY(_cursorChar);
 	size_t cursorCharSize = strlen(character) + 1;
 	_cursorChar = new char [cursorCharSize];
 	Common::strcpy_s(_cursorChar, cursorCharSize, character);
@@ -868,7 +866,7 @@ int UIEdit::deleteChars(int start, int end) {
 		}
 		memcpy(str + MAX(0, start), _text + end, strlen(_text) - end + 1);
 
-		delete[] _text;
+		SAFE_DELETE_ARRAY(_text);
 		_text = str;
 	}
 	if (_parentNotify && _parent) {
@@ -897,7 +895,7 @@ int UIEdit::insertChars(int pos, const byte *chars, int num) {
 
 		memcpy(str + pos, chars, num);
 
-		delete[] _text;
+		SAFE_DELETE_ARRAY(_text);
 		_text = str;
 	}
 	if (_parentNotify && _parent) {
diff --git a/engines/wintermute/ui/ui_entity.cpp b/engines/wintermute/ui/ui_entity.cpp
index 829cc316ac2..86f9d2679ac 100644
--- a/engines/wintermute/ui/ui_entity.cpp
+++ b/engines/wintermute/ui/ui_entity.cpp
@@ -34,6 +34,7 @@
 #include "engines/wintermute/base/scriptables/script_value.h"
 #include "engines/wintermute/base/scriptables/script.h"
 #include "engines/wintermute/base/scriptables/script_stack.h"
+#include "engines/wintermute/dcgf.h"
 
 namespace Wintermute {
 
@@ -224,8 +225,7 @@ bool UIEntity::setEntity(const char *filename) {
 	}
 	_entity = new AdEntity(_gameRef);
 	if (!_entity || DID_FAIL(_entity->loadFile(filename))) {
-		delete _entity;
-		_entity = nullptr;
+		SAFE_DELETE(_entity);
 		return STATUS_FAILED;
 	} else {
 		_entity->_nonIntMouseEvents = true;
diff --git a/engines/wintermute/ui/ui_object.cpp b/engines/wintermute/ui/ui_object.cpp
index 58d7e55cb3e..21a52c784d9 100644
--- a/engines/wintermute/ui/ui_object.cpp
+++ b/engines/wintermute/ui/ui_object.cpp
@@ -35,6 +35,7 @@
 #include "engines/wintermute/base/scriptables/script_value.h"
 #include "engines/wintermute/base/scriptables/script_stack.h"
 #include "engines/wintermute/base/font/base_font_storage.h"
+#include "engines/wintermute/dcgf.h"
 
 namespace Wintermute {
 
@@ -182,8 +183,7 @@ bool UIObject::scCallMethod(ScScript *script, ScStack *stack, ScStack *thisStack
 
 		/* const char *filename = */ val->getString();
 
-		delete _image;
-		_image = nullptr;
+		SAFE_DELETE(_image);
 		if (val->isNULL()) {
 			stack->pushBool(true);
 			return STATUS_OK;
@@ -191,8 +191,7 @@ bool UIObject::scCallMethod(ScScript *script, ScStack *stack, ScStack *thisStack
 
 		_image = new BaseSprite(_gameRef);
 		if (!_image || DID_FAIL(_image->loadFile(val->getString()))) {
-			delete _image;
-			_image = nullptr;
+			SAFE_DELETE(_image);
 			stack->pushBool(false);
 		} else {
 			stack->pushBool(true);
diff --git a/engines/wintermute/ui/ui_text.cpp b/engines/wintermute/ui/ui_text.cpp
index 800175e9a50..8196e3bf144 100644
--- a/engines/wintermute/ui/ui_text.cpp
+++ b/engines/wintermute/ui/ui_text.cpp
@@ -39,6 +39,7 @@
 #include "engines/wintermute/base/base_sprite.h"
 #include "engines/wintermute/base/base_file_manager.h"
 #include "engines/wintermute/platform_osystem.h"
+#include "engines/wintermute/dcgf.h"
 
 namespace Wintermute {
 
@@ -198,21 +199,19 @@ bool UIText::loadBuffer(char *buffer, bool complete) {
 			break;
 
 		case TOKEN_BACK:
-			delete _back;
+			SAFE_DELETE(_back);
 			_back = new UITiledImage(_gameRef);
 			if (!_back || DID_FAIL(_back->loadFile(params))) {
-				delete _back;
-				_back = nullptr;
+				SAFE_DELETE(_back);
 				cmd = PARSERR_GENERIC;
 			}
 			break;
 
 		case TOKEN_IMAGE:
-			delete _image;
+			SAFE_DELETE(_image);
 			_image = new BaseSprite(_gameRef);
 			if (!_image || DID_FAIL(_image->loadFile(params))) {
-				delete _image;
-				_image = nullptr;
+				SAFE_DELETE(_image);
 				cmd = PARSERR_GENERIC;
 			}
 			break;
@@ -269,11 +268,10 @@ bool UIText::loadBuffer(char *buffer, bool complete) {
 			break;
 
 		case TOKEN_CURSOR:
-			delete _cursor;
+			SAFE_DELETE(_cursor);
 			_cursor = new BaseSprite(_gameRef);
 			if (!_cursor || DID_FAIL(_cursor->loadFile(params))) {
-				delete _cursor;
-				_cursor = nullptr;
+				SAFE_DELETE(_cursor);
 				cmd = PARSERR_GENERIC;
 			}
 			break;
diff --git a/engines/wintermute/ui/ui_tiled_image.cpp b/engines/wintermute/ui/ui_tiled_image.cpp
index c3abf822f24..31d2b8890e6 100644
--- a/engines/wintermute/ui/ui_tiled_image.cpp
+++ b/engines/wintermute/ui/ui_tiled_image.cpp
@@ -34,6 +34,7 @@
 #include "engines/wintermute/base/base_file_manager.h"
 #include "engines/wintermute/base/gfx/base_renderer.h"
 #include "engines/wintermute/platform_osystem.h"
+#include "engines/wintermute/dcgf.h"
 
 namespace Wintermute {
 
@@ -57,8 +58,7 @@ UITiledImage::UITiledImage(BaseGame *inGame) : BaseObject(inGame) {
 
 //////////////////////////////////////////////////////////////////////////
 UITiledImage::~UITiledImage() {
-	delete _image;
-	_image = nullptr;
+	SAFE_DELETE(_image);
 }
 
 
@@ -195,11 +195,10 @@ bool UITiledImage::loadBuffer(char *buffer, bool complete) {
 			break;
 
 		case TOKEN_IMAGE:
-			delete _image;
+			SAFE_DELETE(_image);
 			_image = new BaseSubFrame(_gameRef);
 			if (!_image || DID_FAIL(_image->setSurface(params))) {
-				delete _image;
-				_image = nullptr;
+				SAFE_DELETE(_image);
 				cmd = PARSERR_GENERIC;
 			}
 			break;
diff --git a/engines/wintermute/ui/ui_window.cpp b/engines/wintermute/ui/ui_window.cpp
index 8b24dafca0b..36d42e500c2 100644
--- a/engines/wintermute/ui/ui_window.cpp
+++ b/engines/wintermute/ui/ui_window.cpp
@@ -47,6 +47,7 @@
 #include "engines/wintermute/base/base_sprite.h"
 #include "engines/wintermute/base/base_file_manager.h"
 #include "engines/wintermute/platform_osystem.h"
+#include "engines/wintermute/dcgf.h"
 
 namespace Wintermute {
 
@@ -96,13 +97,9 @@ UIWindow::~UIWindow() {
 
 //////////////////////////////////////////////////////////////////////////
 void UIWindow::cleanup() {
-	delete _shieldWindow;
-	_shieldWindow = nullptr;
-	delete _shieldButton;
-	_shieldButton = nullptr;
-	delete _viewport;
-	_viewport = nullptr;
-
+	SAFE_DELETE(_shieldWindow);
+	SAFE_DELETE(_shieldButton);
+	SAFE_DELETE(_viewport);
 	delete _backInactive;
 	if (!_sharedFonts && _fontInactive) {
 		_gameRef->_fontStorage->removeFont(_fontInactive);
@@ -367,11 +364,10 @@ bool UIWindow::loadBuffer(char *buffer, bool complete) {
 			break;
 
 		case TOKEN_BACK:
-			delete _back;
+			SAFE_DELETE(_back);
 			_back = new UITiledImage(_gameRef);
 			if (!_back || DID_FAIL(_back->loadFile(params))) {
-				delete _back;
-				_back = nullptr;
+				SAFE_DELETE(_back);
 				cmd = PARSERR_GENERIC;
 			}
 			break;
@@ -380,28 +376,25 @@ bool UIWindow::loadBuffer(char *buffer, bool complete) {
 			delete _backInactive;
 			_backInactive = new UITiledImage(_gameRef);
 			if (!_backInactive || DID_FAIL(_backInactive->loadFile(params))) {
-				delete _backInactive;
-				_backInactive = nullptr;
+				SAFE_DELETE(_backInactive);
 				cmd = PARSERR_GENERIC;
 			}
 			break;
 
 		case TOKEN_IMAGE:
-			delete _image;
+			SAFE_DELETE(_image);
 			_image = new BaseSprite(_gameRef);
 			if (!_image || DID_FAIL(_image->loadFile(params))) {
-				delete _image;
-				_image = nullptr;
+				SAFE_DELETE(_image);
 				cmd = PARSERR_GENERIC;
 			}
 			break;
 
 		case TOKEN_IMAGE_INACTIVE:
-			delete _imageInactive;
+			SAFE_DELETE(_imageInactive);
 			_imageInactive = new BaseSprite(_gameRef);
 			if (!_imageInactive || DID_FAIL(_imageInactive->loadFile(params))) {
-				delete _imageInactive;
-				_imageInactive = nullptr;
+				SAFE_DELETE(_imageInactive);
 				cmd = PARSERR_GENERIC;
 			}
 			break;
@@ -466,11 +459,10 @@ bool UIWindow::loadBuffer(char *buffer, bool complete) {
 			break;
 
 		case TOKEN_CURSOR:
-			delete _cursor;
+			SAFE_DELETE(_cursor);
 			_cursor = new BaseSprite(_gameRef);
 			if (!_cursor || DID_FAIL(_cursor->loadFile(params))) {
-				delete _cursor;
-				_cursor = nullptr;
+				SAFE_DELETE(_cursor);
 				cmd = PARSERR_GENERIC;
 			}
 			break;
@@ -478,8 +470,7 @@ bool UIWindow::loadBuffer(char *buffer, bool complete) {
 		case TOKEN_BUTTON: {
 			UIButton *btn = new UIButton(_gameRef);
 			if (!btn || DID_FAIL(btn->loadBuffer(params, false))) {
-				delete btn;
-				btn = nullptr;
+				SAFE_DELETE(btn);
 				cmd = PARSERR_GENERIC;
 			} else {
 				btn->_parent = this;
@@ -491,8 +482,7 @@ bool UIWindow::loadBuffer(char *buffer, bool complete) {
 		case TOKEN_STATIC: {
 			UIText *text = new UIText(_gameRef);
 			if (!text || DID_FAIL(text->loadBuffer(params, false))) {
-				delete text;
-				text = nullptr;
+				SAFE_DELETE(text);
 				cmd = PARSERR_GENERIC;
 			} else {
 				text->_parent = this;
@@ -504,8 +494,7 @@ bool UIWindow::loadBuffer(char *buffer, bool complete) {
 		case TOKEN_EDIT: {
 			UIEdit *edit = new UIEdit(_gameRef);
 			if (!edit || DID_FAIL(edit->loadBuffer(params, false))) {
-				delete edit;
-				edit = nullptr;
+				SAFE_DELETE(edit);
 				cmd = PARSERR_GENERIC;
 			} else {
 				edit->_parent = this;
@@ -517,8 +506,7 @@ bool UIWindow::loadBuffer(char *buffer, bool complete) {
 		case TOKEN_WINDOW: {
 			UIWindow *win = new UIWindow(_gameRef);
 			if (!win || DID_FAIL(win->loadBuffer(params, false))) {
-				delete win;
-				win = nullptr;
+				SAFE_DELETE(win);
 				cmd = PARSERR_GENERIC;
 			} else {
 				win->_parent = this;
@@ -808,12 +796,11 @@ bool UIWindow::scCallMethod(ScScript *script, ScStack *stack, ScStack *thisStack
 	else if (strcmp(name, "SetInactiveImage") == 0) {
 		stack->correctParams(1);
 
-		delete _imageInactive;
+		SAFE_DELETE(_imageInactive);
 		_imageInactive = new BaseSprite(_gameRef);
 		const char *filename = stack->pop()->getString();
 		if (!_imageInactive || DID_FAIL(_imageInactive->loadFile(filename))) {
-			delete _imageInactive;
-			_imageInactive = nullptr;
+			SAFE_DELETE(_imageInactive);
 			stack->pushBool(false);
 		} else {
 			stack->pushBool(true);
diff --git a/engines/wintermute/video/video_player.cpp b/engines/wintermute/video/video_player.cpp
index f42c678f33f..5d076adcfb6 100644
--- a/engines/wintermute/video/video_player.cpp
+++ b/engines/wintermute/video/video_player.cpp
@@ -33,6 +33,7 @@
 #include "engines/wintermute/base/gfx/base_renderer.h"
 #include "engines/wintermute/base/gfx/base_surface.h"
 #include "engines/wintermute/platform_osystem.h"
+#include "engines/wintermute/dcgf.h"
 
 namespace Wintermute {
 
@@ -76,15 +77,12 @@ VideoPlayer::~VideoPlayer() {
 bool VideoPlayer::cleanup() {
 	_playing = false;
 
-	delete _subtitler;
-	_subtitler = nullptr;
+	SAFE_DELETE(_subtitler);
 	if (_aviDecoder) {
 		_aviDecoder->close();
 	}
-	delete _aviDecoder;
-	_aviDecoder = nullptr;
-	delete _texture;
-	_texture = nullptr;
+	SAFE_DELETE(_aviDecoder);
+	SAFE_DELETE(_texture);
 
 	return setDefaults();
 }
diff --git a/engines/wintermute/video/video_theora_player.cpp b/engines/wintermute/video/video_theora_player.cpp
index 3ab59e2bff0..217544c4f23 100644
--- a/engines/wintermute/video/video_theora_player.cpp
+++ b/engines/wintermute/video/video_theora_player.cpp
@@ -35,6 +35,8 @@
 #include "engines/wintermute/base/sound/base_sound_manager.h"
 #include "engines/wintermute/platform_osystem.h"
 #include "engines/wintermute/wintermute.h"
+#include "engines/wintermute/dcgf.h"
+
 #include "video/theora_decoder.h"
 #include "common/system.h"
 
@@ -96,12 +98,9 @@ void VideoTheoraPlayer::cleanup() {
 	if (_theoraDecoder) {
 		_theoraDecoder->close();
 	}
-	delete _subtitler;
-	_subtitler = nullptr;
-	delete _theoraDecoder;
-	_theoraDecoder = nullptr;
-	delete _texture;
-	_texture = nullptr;
+	SAFE_DELETE(_subtitler);
+	SAFE_DELETE(_theoraDecoder);
+	SAFE_DELETE(_texture);
 }
 
 //////////////////////////////////////////////////////////////////////////
@@ -149,8 +148,7 @@ bool VideoTheoraPlayer::resetStream() {
 	if (_theoraDecoder) {
 		_theoraDecoder->close();
 	}
-	delete _theoraDecoder;
-	_theoraDecoder = nullptr;
+	SAFE_DELETE(_theoraDecoder);
 
 #if defined (USE_THEORADEC)
 	// Load a file, but avoid having the File-manager handle the disposal of it.