[Scummvm-git-logs] scummvm master -> 665cd7a51b9f84001c3c2c51fc5c97989545bc5e

sev- noreply at scummvm.org
Sat Oct 19 17:48:04 UTC 2024 

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

Summary:
2c7478ad13 QDENGINE: Added triangles.dll minigame code for dogncat
38ee26aca7 QDENGINE: JANITORIAL: Indentation fixes
543fb4729c QDENGINE: Unstubbed MinigameManager::load/save_game()
eeda0dbf97 QDENGINE: JANITORIAL: Fix formatting
41bc481639 QDENGINE: runtime -> g_runtime in minigames/adv
665cd7a51b TINSEL: Fixed crash on failed engine run attempt


Commit: 2c7478ad1377b749663dccd1a257c7758ed74ec7
    https://github.com/scummvm/scummvm/commit/2c7478ad1377b749663dccd1a257c7758ed74ec7
Author: Eugene Sandulenko (sev at scummvm.org)
Date: 2024-10-19T19:45:31+02:00

Commit Message:
QDENGINE: Added triangles.dll minigame code for dogncat

Changed paths:
    engines/qdengine/minigames/adv/RunTime.cpp
    engines/qdengine/minigames/adv/m_triangles.cpp
    engines/qdengine/minigames/adv/m_triangles.h
    engines/qdengine/module.mk


diff --git a/engines/qdengine/minigames/adv/RunTime.cpp b/engines/qdengine/minigames/adv/RunTime.cpp
index 04bde746b7e..f86ec785de9 100644
--- a/engines/qdengine/minigames/adv/RunTime.cpp
+++ b/engines/qdengine/minigames/adv/RunTime.cpp
@@ -877,14 +877,14 @@ int MinigameManager::rnd(const Std::vector<float> &prob) const {
 			break;
 	}
 	assert(idx >= 0 && idx < prob.size());
-	#ifdef _DEBUG
+#ifdef _DEBUG
 	float sum = 0.f;
 
 	for (auto &pit : prob)
 		sum += pit;
 
 	assert(abs(sum - 1.f) < 0.0001f);
-	#endif
+#endif
 	return idx;
 }
 
diff --git a/engines/qdengine/minigames/adv/m_triangles.cpp b/engines/qdengine/minigames/adv/m_triangles.cpp
index 051333c551d..12be98fee82 100644
--- a/engines/qdengine/minigames/adv/m_triangles.cpp
+++ b/engines/qdengine/minigames/adv/m_triangles.cpp
@@ -19,6 +19,9 @@
  *
  */
 
+#include "common/debug.h"
+
+#include "qdengine/qdengine.h"
 #include "qdengine/minigames/adv/m_triangles.h"
 #include "qdengine/minigames/adv/RunTime.h"
 #include "qdengine/minigames/adv/EventManager.h"
@@ -46,9 +49,8 @@ MinigameTriangle::Node::Node(int number, int rot) {
 }
 
 void MinigameTriangle::Node::release() {
-	QDObjects::iterator it;
-	FOR_EACH(face_, it)
-	runtime->release(*it);
+	for (auto &it : face_)
+		runtime->release(it);
 }
 
 bool MinigameTriangle::Node::hit(const mgVect2f& pos) const {
@@ -91,7 +93,7 @@ MinigameTriangle::MinigameTriangle() {
 		fieldSize_ = fieldLines_ * fieldWidth_;
 		break;
 	case HEXAGON:
-		xassert(fieldLines_ % 2 == 0);
+		assert(fieldLines_ % 2 == 0);
 		if (fieldLines_ % 2 != 0)
 			return;
 		fieldSize_ = 3 * sqr(fieldLines_) / 2;
@@ -111,32 +113,34 @@ MinigameTriangle::MinigameTriangle() {
 		nodes_.push_back(Node(num, 0));
 		Node& node = nodes_.back();
 		for (int angle = 1; angle <= 3; ++angle) {
-			sprintf(name, "%s%02d_%1d", faceNameBegin, num + 1, angle);
+			snprintf(name, 63, "%s%02d_%1d", faceNameBegin, num + 1, angle);
 			QDObject obj = runtime->getObject(name);
 			node.face_.push_back(obj);
 			positions_.push_back(obj->R());
 		}
 	}
 
+	warning("STUB: MinigameTriangle::MinigameTriangle(): processGameData");
+#if 0
 	XBuffer gameData;
 
-	Coords::iterator it;
-	FOR_EACH(positions_, it)
-	gameData.write(*it);
+	for (auto &it : positions_)
+		gameData.write(it);
 
 	if (!runtime->processGameData(gameData))
 		return;
 
-	FOR_EACH(positions_, it)
-	gameData.read(*it);
+	for (auto &it : positions_)
+		gameData.read(it);
+#endif
 
 	for (int num = 1; num <= 2; ++num) {
 		for (int angle = 1; angle <= 3; ++angle) {
-			sprintf(name, "%s%1d_%1d", backNameBegin, num, angle);
+			snprintf(name, 63, "%s%1d_%1d", backNameBegin, num, angle);
 			if (!backSides_[(num - 1) * 3 + angle - 1].load(name))
 				return;
 		}
-		sprintf(name, "%s%1d", selectNameBegin, num);
+		snprintf(name, 63, "%s%1d", selectNameBegin, num);
 		if (!selectBorders_[num - 1].load(name))
 			return;
 	}
@@ -169,9 +173,8 @@ MinigameTriangle::MinigameTriangle() {
 }
 
 MinigameTriangle::~MinigameTriangle() {
-	Nodes::iterator it;
-	FOR_EACH(nodes_, it)
-	it->release();
+	for (auto &it : nodes_)
+		it.release();
 
 	for (int idx = 0; idx < 2; ++idx)
 		selectBorders_[idx].release();
@@ -185,20 +188,19 @@ void MinigameTriangle::Node::debugInfo() const {
 }
 
 const char *MinigameTriangle::Node::getFaceStateName(int angle, bool selected, bool animated, bool instantaneous) {
-	xassert(!selected || !animated); // анимированные выделенными быть не могут
+	assert(!selected || !animated); // анимированные выделенными быть не могут
 
-	static char *angleNames[3] = {"0", "120", "240"};
-	xassert(angle >= 0 && angle < sizeof(angleNames) / sizeof(angleNames[0]));
+	static const char *angleNames[3] = {"0", "120", "240"};
+	assert(angle >= 0 && angle < sizeof(angleNames) / sizeof(angleNames[0]));
 
-	static XBuffer out;
-	out.init();
+	Common::String out;
 
-	out < (animated ? "02_" : "01_") < angleNames[angle] < (selected || instantaneous ? "_sel" : "") < '\0';
+	out = Common::String::format("%s%s%s", (animated ? "02_" : "01_"), angleNames[angle], (selected || instantaneous ? "_sel" : ""));
 	return out.c_str();
 }
 
 const char *MinigameTriangle::Node::getBackStateName(bool selected, bool animated, bool instantaneous) {
-	xassert(!selected || !animated); // анимированные выделенными быть не могут
+	assert(!selected || !animated); // анимированные выделенными быть не могут
 
 	if (animated)
 		return selected || instantaneous ? "02_sel" : "02";
@@ -219,9 +221,8 @@ void MinigameTriangle::releaseNodeBack(Node& node) {
 }
 
 void MinigameTriangle::updateNode(Node& node, int position, int flip, bool quick) {
-	QDObjects::iterator fit;
-	FOR_EACH(node.face_, fit)
-	runtime->hide(*fit);
+	for (auto &fit : node.face_)
+		runtime->hide(fit);
 
 	node.flip = flip;
 
@@ -243,14 +244,14 @@ void MinigameTriangle::updateNode(Node& node, int position, int flip, bool quick
 
 void MinigameTriangle::highlight(int idx, bool hl) {
 	if (idx >= 0) {
-		xassert(idx < (int)nodes_.size());
+		assert(idx < (int)nodes_.size());
 		nodes_[idx].highlight_ = hl;
 		updateNode(nodes_[idx], idx);
 	}
 }
 
 void MinigameTriangle::beginSwapNodes(int pos1, int pos2) {
-	xassert(compatible(pos1, pos2));
+	assert(compatible(pos1, pos2));
 
 	if (pos1 > pos2)
 		SWAP(pos1, pos2);
@@ -284,25 +285,25 @@ void MinigameTriangle::endSwapNodes(int pos1, int pos2) {
 
 	bool counted = false;
 	if (node1.number_ == pos1) { // поставили на свое место
-		xassert(!node1.isBack_);
+		assert(!node1.isBack_);
 		counted = true;
 		runtime->event(EVENT_PUT_RIGHT, node1.obj()->screen_R());
 	}
 
 	if (node2.number_ == pos1) { // сняли со своего места
-		xassert(node2.isBack_);
+		assert(node2.isBack_);
 		counted = true;
 		runtime->event(EVENT_GET_RIGHT, node1.obj()->screen_R());
 	}
 
 	if (node2.number_ == pos2) { // поставили на свое место
-		xassert(!node2.isBack_);
+		assert(!node2.isBack_);
 		counted = true;
 		runtime->event(EVENT_PUT_RIGHT, node2.obj()->screen_R());
 	}
 
 	if (node1.number_ == pos2) { // сняли со своего места
-		xassert(node1.isBack_);
+		assert(node1.isBack_);
 		counted = true;
 		runtime->event(EVENT_GET_RIGHT, node2.obj()->screen_R());
 	}
@@ -316,11 +317,12 @@ void MinigameTriangle::endSwapNodes(int pos1, int pos2) {
 
 	bool isWin = true;
 	int position = 0;
-	Nodes::const_iterator it;
-	FOR_EACH(nodes_, it)
-	if (it->number_ != position++) {
-		isWin = false;
-		break;
+
+	for (auto &it : nodes_) {
+		if (it.number_ != position++) {
+			isWin = false;
+			break;
+		}
 	}
 
 	if (isWin) {
@@ -351,11 +353,11 @@ bool MinigameTriangle::animate(float dt) {
 		releaseNodeBack(node1);
 		releaseNodeBack(node2);
 
-		QDObjects::iterator it;
-		FOR_EACH(node1.face_, it)
-		(*it).setState(Node::getFaceStateName(0, false, false, false));
-		FOR_EACH(node2.face_, it)
-		(*it).setState(Node::getFaceStateName(0, false, false, false));
+		for (auto &it : node1.face_)
+			it.setState(Node::getFaceStateName(0, false, false, false));
+
+		for (auto &it : node2.face_)
+			it.setState(Node::getFaceStateName(0, false, false, false));
 
 		updateNode(node1, animatedNodes_[1], destination(animatedNodes_[0], animatedNodes_[1]), true);
 		updateNode(node2, animatedNodes_[0], destination(animatedNodes_[1], animatedNodes_[0]), true);
@@ -404,6 +406,9 @@ bool MinigameTriangle::animate(float dt) {
 		animatedNodes_[1] = -1;
 
 		return true;
+
+	default:
+		break;
 	}
 
 	return false;
@@ -519,9 +524,11 @@ int MinigameTriangle::rowBegin(int row) const {
 		return sqr(row);
 	case RECTANGLE:
 		return row * fieldWidth_;
+	default:
+		break;
 	}
 	//case HEXAGON:
-	xassert(row >= 0 && row < fieldLines_);
+	assert(row >= 0 && row < fieldLines_);
 	if (row >= fieldLines_ / 2) {
 		row -= fieldLines_ / 2;
 		return fieldSize_ / 2 + (2 * fieldLines_ - row) * row;
@@ -539,6 +546,8 @@ int MinigameTriangle::rowByNum(int num) const {
 		return floor(sqrt((float)num));
 	case RECTANGLE:
 		return num / fieldWidth_;
+	default:
+		break;
 	}
 	//case HEXAGON:
 	int row = num < fieldSize_ / 2 ? 0 : fieldLines_ / 2;
@@ -553,6 +562,8 @@ int MinigameTriangle::orientation(int num) const {
 		return (rowByNum(num) + num) % 2;
 	case RECTANGLE:
 		return num % 2;
+	default:
+		break;
 	}
 	//case HEXAGON:
 	return (num + rowByNum(num) + (num >= fieldSize_ / 2 ? 1 : 0)) % 2;
@@ -590,7 +601,7 @@ int MinigameTriangle::getRotate(int num1, int num2) const {
 		{{2, 1, 0}, {1, 0, 2}},
 		{{1, 0, 2}, {2, 1, 0}}
 	};
-	xassert(compatible(num1, num2));
+	assert(compatible(num1, num2));
 	return solves[rowByNum(num1) != rowByNum(num2) ? 0 : (num2 < num1 ? 1 : 2)]
 	       [orientation(num1)][nodes_[num1].rotation_];
 }
@@ -603,7 +614,7 @@ int MinigameTriangle::destination(int num1, int num2) const {
 }
 
 mgVect3f MinigameTriangle::slotCoord(int pos, int angle) const {
-	xassert(pos * 3 + angle < positions_.size());
+	assert(pos * 3 + angle < positions_.size());
 	return positions_[pos * 3 + angle];
 }
 
diff --git a/engines/qdengine/minigames/adv/m_triangles.h b/engines/qdengine/minigames/adv/m_triangles.h
index 2323b714a54..a462dffa241 100644
--- a/engines/qdengine/minigames/adv/m_triangles.h
+++ b/engines/qdengine/minigames/adv/m_triangles.h
@@ -68,7 +68,7 @@ class MinigameTriangle : public MinigameInterface {
 		static const char *getBackStateName(bool selected, bool animated, bool instantaneous);
 		static const char *getBorderStateName(bool selected);
 	};
-	typedef vector<Node> Nodes;
+	typedef Std::vector<Node> Nodes;
 
 public:
 	MinigameTriangle();
diff --git a/engines/qdengine/module.mk b/engines/qdengine/module.mk
index 285f9bb5e14..189e19ef08e 100644
--- a/engines/qdengine/module.mk
+++ b/engines/qdengine/module.mk
@@ -13,6 +13,7 @@ MODULE_OBJS = \
 	minigames/adv/Range.o \
 	minigames/adv/RunTime.o \
 	minigames/adv/TextManager.o \
+	minigames/adv/m_triangles.o \
 	parser/qdscr_parser.o \
 	parser/xml_parser.o \
 	parser/xml_tag_buffer.o \


Commit: 38ee26aca716a3441f845ca8ff3dba4d028d3707
    https://github.com/scummvm/scummvm/commit/38ee26aca716a3441f845ca8ff3dba4d028d3707
Author: Eugene Sandulenko (sev at scummvm.org)
Date: 2024-10-19T19:45:31+02:00

Commit Message:
QDENGINE: JANITORIAL: Indentation fixes

Changed paths:
    engines/qdengine/minigames/adv/ObjectContainer.h
    engines/qdengine/minigames/adv/Rect.h
    engines/qdengine/minigames/adv/RunTime.cpp
    engines/qdengine/minigames/adv/RunTime.h
    engines/qdengine/minigames/adv/TextManager.cpp


diff --git a/engines/qdengine/minigames/adv/ObjectContainer.h b/engines/qdengine/minigames/adv/ObjectContainer.h
index db4b5c2e7ae..e7e8b59f204 100644
--- a/engines/qdengine/minigames/adv/ObjectContainer.h
+++ b/engines/qdengine/minigames/adv/ObjectContainer.h
@@ -28,9 +28,9 @@ class ObjectContainer {
 	QDObjects _objects;
 	int _current;
 	mgVect3f _coord;
-	#ifdef _DEBUG
+#ifdef _DEBUG
 	Common::String _name;
-	#endif
+#endif
 	const char *name() const;
 	void pushObject(QDObject& obj);
 
diff --git a/engines/qdengine/minigames/adv/Rect.h b/engines/qdengine/minigames/adv/Rect.h
index 4e745001ebe..77bd1ab473e 100644
--- a/engines/qdengine/minigames/adv/Rect.h
+++ b/engines/qdengine/minigames/adv/Rect.h
@@ -171,7 +171,7 @@ struct Rect {
 	/// Проверяет не находится ли точка \a _point внутри прямоугольника
 	inline bool point_inside(const VectType& point) const {
 		if (point.x >= left() && point.y >= top() &&
-		                                      point.x <= right() && point.y <= bottom())
+		                                    point.x <= right() && point.y <= bottom())
 			return true;
 		else
 			return false;
@@ -179,7 +179,7 @@ struct Rect {
 	/// Проверяет не находится ли прямоугольник \a _rect внутри прямоугольника
 	inline bool rect_inside(const RectType& rect) const {
 		if (rect.left() >= left() && rect.top() >= top() &&
-		                    rect.bottom() <= bottom() && rect.right() <= right())
+		                   rect.bottom() <= bottom() && rect.right() <= right())
 			return true;
 		else
 			return false;
diff --git a/engines/qdengine/minigames/adv/RunTime.cpp b/engines/qdengine/minigames/adv/RunTime.cpp
index f86ec785de9..dc3a7f9a107 100644
--- a/engines/qdengine/minigames/adv/RunTime.cpp
+++ b/engines/qdengine/minigames/adv/RunTime.cpp
@@ -248,10 +248,10 @@ bool MinigameManager::createGame() {
 }
 
 #define SAFE_RELEASE(name)                      \
-	if(name){                                   \
-		scene_->release_object_interface(name); \
-		name = 0;                               \
-	}
+    if(name){                                   \
+        scene_->release_object_interface(name); \
+        name = 0;                               \
+    }
 
 bool MinigameManager::finit() {
 	debugC(2, kDebugMinigames, "MinigameManager::finit(): finit game");
@@ -486,7 +486,7 @@ void MinigameManager::saveState(bool force) {
 			file < GameInfo::version();
 			file < (engine_ ? engine_->rnd(999999) : seed_);
 
-			for (auto &it: gameInfos_) {
+			for (auto &it : gameInfos_) {
 				if (!it._value.empty()) {
 					debugC(2, kDebugMinigames, "MinigameManager::save_state(): write game info: (%d,%d), index: %d, game data: %d", it._key.gameLevel_, it._key.gameNum_, it._value.game_.sequenceIndex_, it._value.empty_ ? 0 : 1);
 					file.write(it._key);
@@ -542,10 +542,10 @@ bool MinigameManager::quant(float dt) {
 		if (game_help_)
 			game_help_.setState(game_help_enabled_ ? game_help_state_name_.c_str() : "off");
 
-		#ifdef _DEBUG
+#ifdef _DEBUG
 		if (keyPressed(VK_MULTIPLY, true))
 			game_->setState(MinigameInterface::GAME_WIN);
-		#endif
+#endif
 
 		switch (game_->state()) {
 		case MinigameInterface::GAME_LOST:
diff --git a/engines/qdengine/minigames/adv/RunTime.h b/engines/qdengine/minigames/adv/RunTime.h
index 44ccff4515d..52050a7db2b 100644
--- a/engines/qdengine/minigames/adv/RunTime.h
+++ b/engines/qdengine/minigames/adv/RunTime.h
@@ -244,11 +244,15 @@ private:
 	};
 
 	struct GameInfoIndex_Hash {
-        uint operator()(const GameInfoIndex& x) const { return (x.gameNum_ << 16) + x.gameLevel_; }
+		uint operator()(const GameInfoIndex& x) const {
+			return (x.gameNum_ << 16) + x.gameLevel_;
+		}
 	};
 
 	struct GameInfoIndex_EqualTo {
-        uint operator()(const GameInfoIndex& x, const GameInfoIndex& y) const { return x.gameNum_ == y.gameNum_ && x.gameLevel_ == y.gameLevel_; }
+		uint operator()(const GameInfoIndex& x, const GameInfoIndex& y) const {
+			return x.gameNum_ == y.gameNum_ && x.gameLevel_ == y.gameLevel_;
+		}
 	};
 
 	// информация о пройденных играх
diff --git a/engines/qdengine/minigames/adv/TextManager.cpp b/engines/qdengine/minigames/adv/TextManager.cpp
index c16ea622d10..307eb7f3f45 100644
--- a/engines/qdengine/minigames/adv/TextManager.cpp
+++ b/engines/qdengine/minigames/adv/TextManager.cpp
@@ -105,7 +105,7 @@ bool TextManager::getStaticPreset(StaticTextPreset& preset, const char* name) co
 		int read = sscanf(descr, "%d %d |%63s", &align, &preset.font, str);
 
 		if (read != 3)
-				warning("TextManager::getStaticPreset(): Incorrect text format description in %s", transCyrillic(name));
+			warning("TextManager::getStaticPreset(): Incorrect text format description in %s", transCyrillic(name));
 
 		if (read != 3)
 			return false;
@@ -113,7 +113,7 @@ bool TextManager::getStaticPreset(StaticTextPreset& preset, const char* name) co
 		char *pos_obj = strchr(str, '|');
 
 		if (!pos_obj)
-				warning("TextManager::getStaticPreset(): Incorrect text format description (2) in %s", transCyrillic(name));
+			warning("TextManager::getStaticPreset(): Incorrect text format description (2) in %s", transCyrillic(name));
 
 		if (!pos_obj)
 			return false;


Commit: 543fb4729ce5ecd4851484598c33621051c57237
    https://github.com/scummvm/scummvm/commit/543fb4729ce5ecd4851484598c33621051c57237
Author: Eugene Sandulenko (sev at scummvm.org)
Date: 2024-10-19T19:45:31+02:00

Commit Message:
QDENGINE: Unstubbed MinigameManager::load/save_game()

Changed paths:
    engines/qdengine/minigames/adv/RunTime.cpp
    engines/qdengine/minigames/adv/RunTime.h


diff --git a/engines/qdengine/minigames/adv/RunTime.cpp b/engines/qdengine/minigames/adv/RunTime.cpp
index dc3a7f9a107..1fdc9a83b7e 100644
--- a/engines/qdengine/minigames/adv/RunTime.cpp
+++ b/engines/qdengine/minigames/adv/RunTime.cpp
@@ -20,6 +20,7 @@
  */
 
 #include "common/debug.h"
+#include "common/memstream.h"
 
 #include "qdengine/qdengine.h"
 #include "qdengine/minigames/adv/common.h"
@@ -362,13 +363,10 @@ int MinigameManager::save_game(const qdEngineInterface* engine, const qdMinigame
 	if (currentGameInfo_ && !currentGameInfo_->empty()) {
 		debugC(2, kDebugMinigames, "MinigameManager::save_game(): save game (%d, %d)", currentGameIndex_.gameLevel_, currentGameIndex_.gameNum_);
 
-		warning("STUB: MinigameManager::save_game()");
-#if 0
-		XBuffer out((void*)buffer, buffer_size);
-		out.write(GameInfo::version());
-		out.write(currentGameInfo_->game_);
-		return out.tell();
-#endif
+		Common::MemoryWriteStream out((byte *)buffer, buffer_size);
+		out.writeUint32LE(GameInfo::version());
+		currentGameInfo_->game_.write(out);
+		return out.pos();
 	}
 	return 0;
 
@@ -384,21 +382,18 @@ int MinigameManager::load_game(const qdEngineInterface* engine, const qdMinigame
 	TEMP_SCENE_ENTER();
 	loadState();
 
-	warning("STUB: MinigameManager::load_game()");
-
-#if 0
 	if (currentGameInfo_) {
 		if (buffer_size > 0) {
 			debugC(2, kDebugMinigames, "MinigameManager::load_game(): load game (%d, %d)", currentGameIndex_.gameLevel_, currentGameIndex_.gameNum_);
-			XBuffer in((void*)buffer, buffer_size);
+			Common::MemoryReadStream in((const byte *)buffer, buffer_size);
 			int version;
-			in.read(version);
+			version = in.readUint32LE();
 			if (version == GameInfo::version()) {
-				in.read(currentGameInfo_->game_);
+				currentGameInfo_->game_.read(in);
 
 				if (currentGameInfo_->empty_)
 					warning("MinigameManager::load_game(): Attempt to load minigame without a scene");
-				if (in.tell() != buffer_size) {
+				if (in.pos() != buffer_size) {
 					currentGameInfo_->game_ = MinigameData();
 					warning("MinigameManager::load_game(): Data size mismatch");
 					return 0;
@@ -413,7 +408,7 @@ int MinigameManager::load_game(const qdEngineInterface* engine, const qdMinigame
 		}
 		saveState();
 	}
-#endif
+
 	return buffer_size;
 
 }
@@ -928,6 +923,22 @@ MinigameData::MinigameData() {
 	bestScore_ = 0;
 }
 
+void MinigameData::write(Common::SeekableWriteStream &out) {
+	out.writeSint32LE(sequenceIndex_);
+	out.writeSint32LE(lastScore_);
+	out.writeSint32LE(lastTime_);
+	out.writeSint32LE(bestTime_);
+	out.writeSint32LE(bestScore_);
+}
+
+void MinigameData::read(Common::SeekableReadStream &out) {
+	sequenceIndex_ = out.readSint32LE();
+	lastScore_ =     out.readSint32LE();
+	lastTime_ =      out.readSint32LE();
+	bestTime_ =      out.readSint32LE();
+	bestScore_ =     out.readSint32LE();
+}
+
 GameInfo::GameInfo() {
 	empty_ = true;
 	dataSize_ = 0;
diff --git a/engines/qdengine/minigames/adv/RunTime.h b/engines/qdengine/minigames/adv/RunTime.h
index 52050a7db2b..647556aed6e 100644
--- a/engines/qdengine/minigames/adv/RunTime.h
+++ b/engines/qdengine/minigames/adv/RunTime.h
@@ -26,6 +26,7 @@
 
 namespace Common {
 class MemoryWriteStream;
+class SeekableWriteStream;
 }
 
 namespace QDEngine {
@@ -54,6 +55,9 @@ struct MinigameData {
 	int lastTime_;
 	int bestTime_;
 	int bestScore_;
+
+	void write(Common::SeekableWriteStream &out);
+	void read(Common::SeekableReadStream &out);
 };
 
 struct GameInfo {


Commit: eeda0dbf978c054586e27909a0ee3f24c1e0cb7c
    https://github.com/scummvm/scummvm/commit/eeda0dbf978c054586e27909a0ee3f24c1e0cb7c
Author: Eugene Sandulenko (sev at scummvm.org)
Date: 2024-10-19T19:45:31+02:00

Commit Message:
QDENGINE: JANITORIAL: Fix formatting

Changed paths:
    engines/qdengine/minigames/adv/RunTime.cpp
    engines/qdengine/minigames/adv/RunTime.h


diff --git a/engines/qdengine/minigames/adv/RunTime.cpp b/engines/qdengine/minigames/adv/RunTime.cpp
index 1fdc9a83b7e..1441455b0c6 100644
--- a/engines/qdengine/minigames/adv/RunTime.cpp
+++ b/engines/qdengine/minigames/adv/RunTime.cpp
@@ -108,7 +108,7 @@ MinigameManager::~MinigameManager() {
 	}
 }
 
-bool MinigameManager::init(const qdEngineInterface* engine_interface) {
+bool MinigameManager::init(const qdEngineInterface *engine_interface) {
 	debugC(1, kDebugMinigames, "MinigameManager::init(): init game");
 
 	if (runtime != this)
@@ -313,7 +313,7 @@ bool MinigameManager::finit() {
 #undef SAFE_RELEASE
 
 
-bool MinigameManager::new_game(const qdEngineInterface* engine_interface) {
+bool MinigameManager::new_game(const qdEngineInterface *engine_interface) {
 	if (!loadState(false)) {
 		debugC(2, kDebugMinigames, "MinigameManager::new_game(): new game skiped");
 		return false;
@@ -334,7 +334,7 @@ class TempValue {
 	qdMinigameSceneInterface *pre_scene_;
 	MinigameManager *pre_runtime_;
 public:
-	TempValue(MinigameManager* new_runtime, const qdEngineInterface* new_engine, qdMinigameSceneInterface* new_scene) {
+	TempValue(MinigameManager *new_runtime, const qdEngineInterface *new_engine, qdMinigameSceneInterface *new_scene) {
 		assert(new_runtime);
 		pre_runtime_ = runtime;
 		runtime = new_runtime;
@@ -356,7 +356,7 @@ public:
 
 #define TEMP_SCENE_ENTER() TempValue tempSceneObject(this, engine, const_cast<qdMinigameSceneInterface*>(scene))
 
-int MinigameManager::save_game(const qdEngineInterface* engine, const qdMinigameSceneInterface* scene, char* buffer, int buffer_size) {
+int MinigameManager::save_game(const qdEngineInterface *engine, const qdMinigameSceneInterface *scene, char *buffer, int buffer_size) {
 	debugC(2, kDebugMinigames, "MinigameManager::save_game(): save game");
 	TEMP_SCENE_ENTER();
 	loadState();
@@ -372,7 +372,7 @@ int MinigameManager::save_game(const qdEngineInterface* engine, const qdMinigame
 
 }
 
-int MinigameManager::load_game(const qdEngineInterface* engine, const qdMinigameSceneInterface* scene, const char* buffer, int buffer_size) {
+int MinigameManager::load_game(const qdEngineInterface *engine, const qdMinigameSceneInterface *scene, const char *buffer, int buffer_size) {
 	assert(!game_);
 	if (game_) {
 		debugC(2, kDebugMinigames, "MinigameManager::load_game(): load game skiped");
@@ -468,7 +468,7 @@ bool MinigameManager::loadState(bool current) {
 	return true;
 }
 
-extern bool createDirForFile(const char* partialPath);
+extern bool createDirForFile(const char *partialPath);
 void MinigameManager::saveState(bool force) {
 	debugC(2, kDebugMinigames, "MinigameManager::save_state(): save state");
 
@@ -632,7 +632,7 @@ bool MinigameManager::testAllGamesWin() {
 				--xbuf;
 				int game;
 				xbuf >= game;
-				const MinigameData* data = getScore(level, game);
+				const MinigameData *data = getScore(level, game);
 				if (!data || data->sequenceIndex_ == -1)
 					return false;
 			}
@@ -696,7 +696,7 @@ void MinigameManager::gameLose() {
 	state_flag_->set_state("lose");
 }
 
-const char *MinigameManager::parameter(const char* name, bool required) const {
+const char *MinigameManager::parameter(const char *name, bool required) const {
 	if (!scene_)
 		error("MinigameManager::parameter(): Scene is undefined");
 
@@ -765,12 +765,12 @@ mgVect2f MinigameManager::world2game(const mgVect3f& pos) const {
 	return mgVect2f(scr.x, scr.y);
 }
 
-mgVect3f MinigameManager::world2game(qdMinigameObjectInterface* obj) const {
+mgVect3f MinigameManager::world2game(qdMinigameObjectInterface *obj) const {
 	mgVect2i scr = obj->screen_R();
 	return mgVect3f(scr.x, scr.y, round(getDepth(obj)));
 }
 
-mgVect2f MinigameManager::getSize(qdMinigameObjectInterface* obj) const {
+mgVect2f MinigameManager::getSize(qdMinigameObjectInterface *obj) const {
 	if (obj) {
 		mgVect2i size = obj->screen_size();
 		return mgVect2f(size.x, size.y);
@@ -778,12 +778,12 @@ mgVect2f MinigameManager::getSize(qdMinigameObjectInterface* obj) const {
 	return mgVect2f();
 }
 
-void MinigameManager::setDepth(qdMinigameObjectInterface* obj, int depth) const {
+void MinigameManager::setDepth(qdMinigameObjectInterface *obj, int depth) const {
 	mgVect2i scr = obj->screen_R();
 	obj->set_R(scene_->screen2world_coords(scr, depth));
 }
 
-float MinigameManager::getDepth(qdMinigameObjectInterface* obj) const {
+float MinigameManager::getDepth(qdMinigameObjectInterface *obj) const {
 	return scene_->screen_depth(obj->R());
 }
 
@@ -797,7 +797,7 @@ QDObject MinigameManager::getObject(const char *name) const {
 
 	if (!name || !*name)
 		return QDObject::ZERO;
-	qdMinigameObjectInterface* obj = scene_->object_interface(name);
+	qdMinigameObjectInterface *obj = scene_->object_interface(name);
 	if (!obj)
 		warning("MinigameManager::getObject(): Object '%s' not found", transCyrillic(name));
 
@@ -806,8 +806,8 @@ QDObject MinigameManager::getObject(const char *name) const {
 	return QDObject::ZERO;
 }
 
-bool MinigameManager::testObject(const char* name) const {
-	if (qdMinigameObjectInterface * obj = scene_->object_interface(name)) {
+bool MinigameManager::testObject(const char *name) const {
+	if (qdMinigameObjectInterface *obj = scene_->object_interface(name)) {
 		scene_->release_object_interface(obj);
 		return true;
 	}
@@ -821,8 +821,8 @@ void MinigameManager::release(QDObject& obj) {
 	}
 }
 
-QDCounter MinigameManager::getCounter(const char* name) {
-	qdMinigameCounterInterface* counter = engine_->counter_interface(name);
+QDCounter MinigameManager::getCounter(const char *name) {
+	qdMinigameCounterInterface *counter = engine_->counter_interface(name);
 
 	if (!counter)
 		warning("MinigameManager::getCounter(): Counter '%s' not found", transCyrillic(name));
@@ -838,18 +838,18 @@ void MinigameManager::release(QDCounter& counter) {
 	counter = 0;
 }
 
-void MinigameManager::setText(const char* name, const char* text) const {
+void MinigameManager::setText(const char *name, const char *text) const {
 	engine_->set_interface_text(0, name, text);
 }
 
-void MinigameManager::setText(const char* name, int toText, const char* format) const {
+void MinigameManager::setText(const char *name, int toText, const char *format) const {
 	char text[16];
 	text[15] = 0;
 	snprintf(text, 15, format, toText);
 	setText(name, text);
 }
 
-void MinigameManager::hide(qdMinigameObjectInterface* obj) const {
+void MinigameManager::hide(qdMinigameObjectInterface *obj) const {
 	obj->set_R(scene_->screen2world_coords(mgVect2i(-10000, -10000), getDepth(obj)));
 }
 
@@ -889,7 +889,7 @@ int MinigameManager::rnd(const Std::vector<float> &prob) const {
 
 // если данные еще ни разу не сохранялись - запоминаем
 // если уже есть запомненные, то заменяем на них
-bool MinigameManager::processGameData(Common::MemoryWriteStream& data) {
+bool MinigameManager::processGameData(Common::MemoryWriteStream &data) {
 	warning("STUB: MinigameManager::processGameData()");
 #if 0
 	if (currentGameInfo_) {
@@ -955,7 +955,7 @@ void GameInfo::free() {
 	dataSize_ = 0;
 }
 
-void GameInfo::write(void* data, unsigned int size) {
+void GameInfo::write(void *data, uint size) {
 	if (dataSize_ != size) {
 		free();
 		if (size > 0) {
@@ -987,7 +987,7 @@ XStream &operator> (XStream& in, GameInfo& info) {
 	if (!info.empty_) {
 		in.read(info.timeManagerData_);
 		in.read(info.effectManagerData_);
-		unsigned int size;
+		uint size;
 		in > size;
 		XBuffer buf(size);
 		in.read(buf.buffer(), size);
@@ -1013,7 +1013,7 @@ TimeManager::TimeManager(HoldData<TimeManagerData> &data_) {
 		if (const char *data = runtime->parameter("time_bar"))
 			timeBar_ = runtime->getObject(data);
 
-		if (const char * data = runtime->parameter("time_cost"))
+		if (const char *data = runtime->parameter("time_cost"))
 			sscanf(data, "%f", &timeCost_);
 	}
 
diff --git a/engines/qdengine/minigames/adv/RunTime.h b/engines/qdengine/minigames/adv/RunTime.h
index 647556aed6e..08b58ce421a 100644
--- a/engines/qdengine/minigames/adv/RunTime.h
+++ b/engines/qdengine/minigames/adv/RunTime.h
@@ -62,7 +62,7 @@ struct MinigameData {
 
 struct GameInfo {
 	GameInfo();
-	void write(void* data, unsigned int size);
+	void write(void *data, uint size);
 	void free();
 	static int version() {
 		return 9;
@@ -75,7 +75,7 @@ struct GameInfo {
 	bool empty_;
 	TimeManagerData timeManagerData_;
 	EffectManagerData effectManagerData_;
-	unsigned int dataSize_;
+	uint dataSize_;
 	void *gameData_;
 };
 


Commit: 41bc48163906a1f7860f731279a0e3e78b983522
    https://github.com/scummvm/scummvm/commit/41bc48163906a1f7860f731279a0e3e78b983522
Author: Eugene Sandulenko (sev at scummvm.org)
Date: 2024-10-19T19:45:31+02:00

Commit Message:
QDENGINE: runtime -> g_runtime in minigames/adv

Changed paths:
    engines/qdengine/minigames/adv/EffectManager.cpp
    engines/qdengine/minigames/adv/EventManager.cpp
    engines/qdengine/minigames/adv/ExportInterface.cpp
    engines/qdengine/minigames/adv/FlyObject.cpp
    engines/qdengine/minigames/adv/ObjectContainer.cpp
    engines/qdengine/minigames/adv/RunTime.cpp
    engines/qdengine/minigames/adv/TextManager.cpp
    engines/qdengine/minigames/adv/common.cpp
    engines/qdengine/minigames/adv/common.h
    engines/qdengine/minigames/adv/m_karaoke.cpp
    engines/qdengine/minigames/adv/m_puzzle.cpp
    engines/qdengine/minigames/adv/m_swap.cpp
    engines/qdengine/minigames/adv/m_triangles.cpp


diff --git a/engines/qdengine/minigames/adv/EffectManager.cpp b/engines/qdengine/minigames/adv/EffectManager.cpp
index 4e2dcd2dfe5..968d96414c9 100644
--- a/engines/qdengine/minigames/adv/EffectManager.cpp
+++ b/engines/qdengine/minigames/adv/EffectManager.cpp
@@ -26,12 +26,12 @@
 namespace QDEngine {
 
 EffectManager::EffectManager(HoldData<EffectManagerData> &data) {
-	const char *effectName = runtime->parameter("effect_name", "effect");
-	if (runtime->testObject(effectName)) {
-		_effect = runtime->getObject(effectName);
+	const char *effectName = g_runtime->parameter("effect_name", "effect");
+	if (g_runtime->testObject(effectName)) {
+		_effect = g_runtime->getObject(effectName);
 		_data.crd = _effect->R();
 		_effect->set_screen_scale(mgVect2f(0.01f, 0.01f), mgVect2f(10000.f, 10000.f));
-		runtime->hide(_effect);
+		g_runtime->hide(_effect);
 	}
 
 	data.process(_data);
@@ -45,7 +45,7 @@ EffectManager::EffectManager(HoldData<EffectManagerData> &data) {
 }
 
 EffectManager::~EffectManager() {
-	runtime->release(_effect);
+	g_runtime->release(_effect);
 
 }
 
@@ -53,13 +53,13 @@ void EffectManager::quant(float dt) {
 	if (_current == EFFECT_COUNT)
 		return;
 
-	if (runtime->getTime() > _effectTimer) {
+	if (g_runtime->getTime() > _effectTimer) {
 		stop(_current);
 		return;
 	}
 
-	if (runtime->getTime() > _phaseTimer) {
-		_phaseTimer = runtime->getTime() + _phaseTime;
+	if (g_runtime->getTime() > _phaseTimer) {
+		_phaseTimer = g_runtime->getTime() + _phaseTime;
 		mgVect2f scale = _effect->screen_scale();
 		mgVect2f speed = scale;
 		scale *= _phaseSpeed;
@@ -73,9 +73,9 @@ void EffectManager::quant(float dt) {
 void EffectManager::start(EffectType id) {
 	if (_current != EFFECT_COUNT || !_effect)
 		return;
-	_effectTimer = runtime->getTime() + _effectTime;
+	_effectTimer = g_runtime->getTime() + _effectTime;
 	_current = id;
-	_phaseTimer = runtime->getTime();
+	_phaseTimer = g_runtime->getTime();
 	_effect->set_screen_scale(mgVect2f(0.02f, 0.02f), mgVect2f(10000.f, 10000.f));
 	_effect->set_R(_data.crd);
 
@@ -84,7 +84,7 @@ void EffectManager::start(EffectType id) {
 void EffectManager::stop(EffectType id) {
 	if (_current == EFFECT_COUNT)
 		return;
-	runtime->hide(_effect);
+	g_runtime->hide(_effect);
 	_effect->set_screen_scale(mgVect2f(0.01f, 0.01f), mgVect2f(10000.f, 10000.f));
 	_current = EFFECT_COUNT;
 }
diff --git a/engines/qdengine/minigames/adv/EventManager.cpp b/engines/qdengine/minigames/adv/EventManager.cpp
index 64fdf6c1164..b7decb7069d 100644
--- a/engines/qdengine/minigames/adv/EventManager.cpp
+++ b/engines/qdengine/minigames/adv/EventManager.cpp
@@ -43,8 +43,8 @@ EventManager::EventManager() {
 
 	for (int idx = 0;; ++idx) {
 		snprintf(str_cache, 127, "register_trigger_%d", idx);
-		if (const char *descr = runtime->parameter(str_cache, false))
-			_triggerEvents.push_back(runtime->getObject(descr));
+		if (const char *descr = g_runtime->parameter(str_cache, false))
+			_triggerEvents.push_back(g_runtime->getObject(descr));
 		else
 			break;
 	}
@@ -53,7 +53,7 @@ EventManager::EventManager() {
 	_eventPresets.resize(SYSTEM_EVENTS_SIZE);
 	for (int idx = 0; idx < SYSTEM_EVENTS_SIZE; ++idx) {
 		snprintf(str_cache, 127, "system_event_%d", idx);
-		if (const char * descr = runtime->parameter(str_cache, false)) {
+		if (const char * descr = g_runtime->parameter(str_cache, false)) {
 			EventPreset preset;
 			int read = sscanf(descr, "%d %d", &preset.score, &preset.triggerEventID);
 
@@ -72,7 +72,7 @@ EventManager::EventManager() {
 
 	for (int idx = 0;; ++idx) {
 		snprintf(str_cache, 127, "register_event_%d", idx);
-		if (const char * descr = runtime->parameter(str_cache, false)) {
+		if (const char * descr = g_runtime->parameter(str_cache, false)) {
 			EventPreset preset;
 			int read = sscanf(descr, "%d %d %d %d", &preset.score, &preset.fontID, &preset.escapeID, &preset.triggerEventID);
 
@@ -91,7 +91,7 @@ EventManager::EventManager() {
 	}
 	debugC(2, kDebugMinigames, "EventManager(): registered %d events", _eventPresets.size());
 
-	if (const char * data = runtime->parameter("allow_negative", false)) {
+	if (const char * data = g_runtime->parameter("allow_negative", false)) {
 		int tmp;
 		sscanf(data, "%d", &tmp);
 		_enableNegative = tmp;
@@ -105,7 +105,7 @@ void EventManager::sysEvent(int eventID) {
 
 	assert(eventID < SYSTEM_EVENTS_SIZE);
 
-	mgVect2i pos = runtime->screenSize() / 2;
+	mgVect2i pos = g_runtime->screenSize() / 2;
 	event(eventID - SYSTEM_EVENTS_SIZE, mgVect2f(pos.x, pos.y), 1);
 }
 
@@ -128,7 +128,7 @@ void EventManager::event(int eventID, const mgVect2f& pos, int factor) {
 		int diff = addScore(pr.score);
 
 		if (pr.fontID >= 0 && pr.escapeID >= 0 && diff != 0)
-			runtime->textManager().showNumber(diff, pos, pr.fontID, pr.escapeID);
+			g_runtime->textManager().showNumber(diff, pos, pr.fontID, pr.escapeID);
 	}
 }
 
@@ -142,7 +142,7 @@ int EventManager::addScore(int sc) {
 	diff = _score - diff;
 
 	if (diff)
-		runtime->textManager().updateScore(_score);
+		g_runtime->textManager().updateScore(_score);
 
 	return diff;
 }
diff --git a/engines/qdengine/minigames/adv/ExportInterface.cpp b/engines/qdengine/minigames/adv/ExportInterface.cpp
index b5d29fef219..ab462757ab9 100644
--- a/engines/qdengine/minigames/adv/ExportInterface.cpp
+++ b/engines/qdengine/minigames/adv/ExportInterface.cpp
@@ -28,20 +28,20 @@
 namespace QDEngine {
 
 qdMiniGameInterface *open_game_interface(const char* name) {
-	debugC(3, kDebugMinigames, "open_game_interface: %s, runtime%s", name, runtime ? "!=0" : "==0");
+	debugC(3, kDebugMinigames, "open_game_interface: %s, runtime%s", name, g_runtime ? "!=0" : "==0");
 
-	if (!runtime)
-		return runtime = new MinigameManager;
+	if (!g_runtime)
+		return g_runtime = new MinigameManager;
 
 	return new MinigameManager;
 }
 
 bool close_game_interface(qdMiniGameInterface* game) {
-	debugC(3, kDebugMinigames, "close_game_interface, runtime%s%s", runtime == game ? "==game" : "!=game", runtime ? "!=0" : "==0");
+	debugC(3, kDebugMinigames, "close_game_interface, runtime%s%s", g_runtime == game ? "==game" : "!=game", g_runtime ? "!=0" : "==0");
 
 	delete game;
-	if (game == runtime)
-		runtime = 0;
+	if (game == g_runtime)
+		g_runtime = 0;
 
 	return true;
 }
diff --git a/engines/qdengine/minigames/adv/FlyObject.cpp b/engines/qdengine/minigames/adv/FlyObject.cpp
index e34f5974e7b..0acdb10a3c4 100644
--- a/engines/qdengine/minigames/adv/FlyObject.cpp
+++ b/engines/qdengine/minigames/adv/FlyObject.cpp
@@ -49,7 +49,7 @@ bool FlyObjectBase::quant(float dt) {
 
 bool FlyQDObject::quant(float dt, QDObject& obj) {
 	bool ret = FlyObjectBase::quant(dt);
-	obj->set_R(runtime->game2world(current, depth));
+	obj->set_R(g_runtime->game2world(current, depth));
 	return ret;
 }
 
diff --git a/engines/qdengine/minigames/adv/ObjectContainer.cpp b/engines/qdengine/minigames/adv/ObjectContainer.cpp
index 0fda76c9260..9a3f05ca9a1 100644
--- a/engines/qdengine/minigames/adv/ObjectContainer.cpp
+++ b/engines/qdengine/minigames/adv/ObjectContainer.cpp
@@ -33,7 +33,7 @@ ObjectContainer::ObjectContainer() {
 
 void ObjectContainer::release() {
 	for (auto &it : _objects)
-		runtime->release(it);
+		g_runtime->release(it);
 
 	_objects.clear();
 	_current = 0;
@@ -53,7 +53,7 @@ const char *ObjectContainer::name() const {
 }
 
 bool ObjectContainer::load(const char* base_name, bool hide) {
-	if (!runtime->testObject(base_name)) {
+	if (!g_runtime->testObject(base_name)) {
 		warning("ObjectContainer::load(): Object '%s' not found", transCyrillic(base_name));
 		return false;
 	}
@@ -62,21 +62,21 @@ bool ObjectContainer::load(const char* base_name, bool hide) {
 	_name = base_name;
 #endif
 
-	QDObject obj = runtime->getObject(base_name);
-	_coord = runtime->world2game(obj);
+	QDObject obj = g_runtime->getObject(base_name);
+	_coord = g_runtime->world2game(obj);
 	pushObject(obj);
 	if (hide)
-		runtime->hide(obj);
+		g_runtime->hide(obj);
 
 	char name[128];
 	name[127] = 0;
 	for (int dubl = 0; ; ++dubl) {
 		snprintf(name, 127, "%s%04d", base_name, dubl);
-		if (runtime->testObject(name)) {
-			obj = runtime->getObject(name);
+		if (g_runtime->testObject(name)) {
+			obj = g_runtime->getObject(name);
 			pushObject(obj);
 			if (hide)
-				runtime->hide(obj);
+				g_runtime->hide(obj);
 		} else
 			break;
 	}
@@ -86,7 +86,7 @@ bool ObjectContainer::load(const char* base_name, bool hide) {
 
 void ObjectContainer::hideAll() {
 	for (auto &it : _objects)
-		runtime->hide(it);
+		g_runtime->hide(it);
 }
 
 QDObject ObjectContainer::getObject() {
@@ -103,7 +103,7 @@ void ObjectContainer::releaseObject(QDObject& obj) {
 		if ((int)Common::distance(_objects.begin(), it) >= _current)
 			error("ObjectContainer::releaseObject(): Object released more than once in to the pool: %s", transCyrillic(name()));
 
-		runtime->hide(obj);
+		g_runtime->hide(obj);
 		if (_current > 0)
 			SWAP(*it, _objects[--_current]);
 		obj = 0;
diff --git a/engines/qdengine/minigames/adv/RunTime.cpp b/engines/qdengine/minigames/adv/RunTime.cpp
index 1441455b0c6..436a024525d 100644
--- a/engines/qdengine/minigames/adv/RunTime.cpp
+++ b/engines/qdengine/minigames/adv/RunTime.cpp
@@ -340,15 +340,15 @@ public:
 		runtime = new_runtime;
 
 		assert(new_engine && new_scene);
-		pre_engine_ = runtime->engine_;
-		pre_scene_ = runtime->scene_;
+		pre_engine_ = g_runtime->engine_;
+		pre_scene_ = g_runtime->scene_;
 
-		runtime->engine_ = new_engine;
-		runtime->scene_ = new_scene;
+		g_runtime->engine_ = new_engine;
+		g_runtime->scene_ = new_scene;
 	}
 	~TempValue() {
-		runtime->engine_ = pre_engine_;
-		runtime->scene_ = pre_scene_;
+		g_runtime->engine_ = pre_engine_;
+		g_runtime->scene_ = pre_scene_;
 
 		runtime = pre_runtime_;
 	}
@@ -862,7 +862,7 @@ int MinigameManager::rnd(int min, int max) const {
 }
 
 int MinigameManager::rnd(const Std::vector<float> &prob) const {
-	float rnd = runtime->rnd(0.f, .9999f);
+	float rnd = g_runtime->rnd(0.f, .9999f);
 	float accum = 0.f;
 	int idx = 0;
 	int size = prob.size();
@@ -1001,7 +1001,7 @@ XStream &operator> (XStream& in, GameInfo& info) {
 
 
 TimeManager::TimeManager(HoldData<TimeManagerData> &data_) {
-	if (const char *data = runtime->parameter("game_time", false)) {
+	if (const char *data = g_runtime->parameter("game_time", false)) {
 		if (sscanf(data, "%f", &gameTime_) != 1)
 			gameTime_ = -1.f;
 	} else
@@ -1010,23 +1010,23 @@ TimeManager::TimeManager(HoldData<TimeManagerData> &data_) {
 	timeCost_ = 0.f;
 
 	if (gameTime_ > 0) {
-		if (const char *data = runtime->parameter("time_bar"))
-			timeBar_ = runtime->getObject(data);
+		if (const char *data = g_runtime->parameter("time_bar"))
+			timeBar_ = g_runtime->getObject(data);
 
-		if (const char *data = runtime->parameter("time_cost"))
+		if (const char *data = g_runtime->parameter("time_cost"))
 			sscanf(data, "%f", &timeCost_);
 	}
 
 	if (timeBar_) {
 		TimeManagerData myData;
-		myData.crd = runtime->world2game(timeBar_);
+		myData.crd = g_runtime->world2game(timeBar_);
 
 		data_.process(myData);
 
 		startPos_ = myData.crd;
-		size_ = runtime->getSize(timeBar_);
+		size_ = g_runtime->getSize(timeBar_);
 
-		if (const char *data = runtime->parameter("time_bar_direction")) {
+		if (const char *data = g_runtime->parameter("time_bar_direction")) {
 			int dir;
 			if (sscanf(data, "%d", &dir) == 1) {
 				assert(dir >= 0 && dir <= 3);
@@ -1038,7 +1038,7 @@ TimeManager::TimeManager(HoldData<TimeManagerData> &data_) {
 	} else
 		size_ = mgVect2f(-1.f, -1.f);
 
-	assert(runtime->getTime() == 0.f);
+	assert(g_runtime->getTime() == 0.f);
 
 	lastEventTime_ = 0;
 
@@ -1046,13 +1046,13 @@ TimeManager::TimeManager(HoldData<TimeManagerData> &data_) {
 
 TimeManager::~TimeManager() {
 	if (timeBar_)
-		runtime->release(timeBar_);
+		g_runtime->release(timeBar_);
 
 }
 
 bool TimeManager::timeIsOut() const {
 	if (gameTime_ > 0.f)
-		return runtime->getTime() > gameTime_;
+		return g_runtime->getTime() > gameTime_;
 	return false;
 
 }
@@ -1060,33 +1060,33 @@ bool TimeManager::timeIsOut() const {
 float TimeManager::leftTime() const {
 	if (gameTime_ <= 0.f)
 		return 0;
-	return runtime->getTime() > gameTime_ ? 0 : gameTime_ - runtime->getTime();
+	return g_runtime->getTime() > gameTime_ ? 0 : gameTime_ - g_runtime->getTime();
 
 }
 
 void TimeManager::quant(float dt) {
-	int seconds = round(runtime->getTime());
+	int seconds = round(g_runtime->getTime());
 	if (seconds != lastEventTime_) {
 		lastEventTime_ = seconds;
-		runtime->textManager().updateTime(seconds);
+		g_runtime->textManager().updateTime(seconds);
 		int amountSeconds = round(leftTime());
 		if (gameTime_ < 0.f || amountSeconds > 10)
 			if (seconds % 60 == 0)
-				runtime->signal(EVENT_TIME_60_SECOND_TICK);
+				g_runtime->signal(EVENT_TIME_60_SECOND_TICK);
 			else if (seconds % 10 == 0)
-				runtime->signal(EVENT_TIME_10_SECOND_TICK);
+				g_runtime->signal(EVENT_TIME_10_SECOND_TICK);
 			else
-				runtime->signal(EVENT_TIME_1_SECOND_TICK);
+				g_runtime->signal(EVENT_TIME_1_SECOND_TICK);
 		else if (amountSeconds == 10)
-			runtime->signal(EVENT_TIME_10_SECOND_LEFT);
+			g_runtime->signal(EVENT_TIME_10_SECOND_LEFT);
 		else
-			runtime->signal(EVENT_TIME_LESS_10_SECOND_LEFT_SECOND_TICK);
+			g_runtime->signal(EVENT_TIME_LESS_10_SECOND_LEFT_SECOND_TICK);
 	}
 
 	if (gameTime_ <= 0.f || !timeBar_)
 		return;
 
-	float phase = clamp(runtime->getTime() / gameTime_, 0.f, 1.f);
+	float phase = clamp(g_runtime->getTime() / gameTime_, 0.f, 1.f);
 	mgVect3f pos;
 	switch (direction_) {
 	case UP:
@@ -1105,7 +1105,7 @@ void TimeManager::quant(float dt) {
 
 	pos += startPos_;
 
-	timeBar_->set_R(runtime->game2world(pos));
+	timeBar_->set_R(g_runtime->game2world(pos));
 }
 
 } // namespace QDEngine
diff --git a/engines/qdengine/minigames/adv/TextManager.cpp b/engines/qdengine/minigames/adv/TextManager.cpp
index 307eb7f3f45..0b0006c6aa6 100644
--- a/engines/qdengine/minigames/adv/TextManager.cpp
+++ b/engines/qdengine/minigames/adv/TextManager.cpp
@@ -34,7 +34,7 @@ TextManager::TextManager() {
 
 	for (int idx = 0;; ++idx) {
 		snprintf(str_cache, 127, "register_font_%d", idx);
-		if (const char * descr = runtime->parameter(str_cache, false)) {
+		if (const char * descr = g_runtime->parameter(str_cache, false)) {
 			sscanf(descr, "%255s", str_cache);
 			Font digit;
 			if (!digit.pool.load(str_cache))
@@ -43,14 +43,14 @@ TextManager::TextManager() {
 			debugCN(2, kDebugMinigames, "TextManager(): %d character set \"%s\" loaded, ", idx, str_cache);
 
 			snprintf(str_cache, 127, "font_size_%d", idx);
-			if ((descr = runtime->parameter(str_cache, false))) {
+			if ((descr = g_runtime->parameter(str_cache, false))) {
 				int read = sscanf(descr, "%f %f", &digit.size.x, &digit.size.y);
 				if (read != 2)
 					warning("TextManager(): incorrect font size definition in [%s]", str_cache);
 			} else {
 				QDObject obj = digit.pool.getObject();
 				obj.setState("0");
-				digit.size = runtime->getSize(obj);
+				digit.size = g_runtime->getSize(obj);
 				digit.pool.releaseObject(obj);
 			}
 			debugC(2, kDebugMinigames, "set size to (%5.1f, %5.1f)\n", digit.size.x, digit.size.y);
@@ -61,7 +61,7 @@ TextManager::TextManager() {
 
 	for (int idx = 0;; ++idx) {
 		snprintf(str_cache, 127, "register_particle_escape_%d", idx);
-		if (const char * descr = runtime->parameter(str_cache, false)) {
+		if (const char * descr = g_runtime->parameter(str_cache, false)) {
 			Escape escape;
 			int read = sscanf(descr, "%d (%f><%f, %f><%f) (%f><%f, %f><%f) %f '%15s",
 			                  &escape.depth,
@@ -98,7 +98,7 @@ TextManager::TextManager() {
 }
 
 bool TextManager::getStaticPreset(StaticTextPreset& preset, const char* name) const {
-	if (const char * descr = runtime->parameter(name, false)) {
+	if (const char * descr = g_runtime->parameter(name, false)) {
 		int align = 0;
 		char str[64];
 		str[63] = 0;
@@ -134,9 +134,9 @@ bool TextManager::getStaticPreset(StaticTextPreset& preset, const char* name) co
 			break;
 		}
 
-		if (QDObject obj = runtime->getObject(pos_obj)) {
-			preset.pos = runtime->world2game(obj);
-			runtime->release(obj);
+		if (QDObject obj = g_runtime->getObject(pos_obj)) {
+			preset.pos = g_runtime->world2game(obj);
+			g_runtime->release(obj);
 		} else
 			return false;
 	} else
@@ -192,10 +192,10 @@ void TextManager::showText(const char* txt, const mgVect2f& pos, int fontID, int
 	msg._depth = es.depth;
 	msg._pos = pos;
 
-	msg._vel.x = runtime->rnd(es.vel_min.x, es.vel_max.x);
-	msg._vel.y = runtime->rnd(es.vel_min.y, es.vel_max.y);
-	msg._accel.x = runtime->rnd(es.accel_min.x, es.accel_max.x);
-	msg._accel.y = runtime->rnd(es.accel_min.y, es.accel_max.y);
+	msg._vel.x = g_runtime->rnd(es.vel_min.x, es.vel_max.x);
+	msg._vel.y = g_runtime->rnd(es.vel_min.y, es.vel_max.y);
+	msg._accel.x = g_runtime->rnd(es.accel_min.x, es.accel_max.x);
+	msg._accel.y = g_runtime->rnd(es.accel_min.y, es.accel_max.y);
 
 	_flowMsgs.push_back(msg);
 }
@@ -292,15 +292,15 @@ void TextManager::StaticMessage::update() {
 	default:
 		break;
 	}
-	if (y < -_font->size.y || y > runtime->screenSize().y + _font->size.y
-	        || x < -2 * width || x > runtime->screenSize().x + 2 * width) {
+	if (y < -_font->size.y || y > g_runtime->screenSize().y + _font->size.y
+	        || x < -2 * width || x > g_runtime->screenSize().x + 2 * width) {
 		release();
 		return;
 	}
 
 	for (auto &it : _objects) {
 		if (it)
-			it->set_R(runtime->game2world(mgVect2f(x, y), _depth));
+			it->set_R(g_runtime->game2world(mgVect2f(x, y), _depth));
 		x += _font->size.x;
 	}
 }
@@ -342,7 +342,7 @@ void TextManager::quant(float dt) {
 	}
 
 	if (_show_scores.textID >= 0) {
-		if (_scoreUpdateTimer >= 0.f && _scoreUpdateTimer <= runtime->getTime()) {
+		if (_scoreUpdateTimer >= 0.f && _scoreUpdateTimer <= g_runtime->getTime()) {
 			int sgn = _targetScore - _currentScore < 0 ? -1 : 1;
 			int mod = abs(_currentScore - _targetScore);
 			_currentScore += sgn * (mod / 10 + 1);
@@ -352,7 +352,7 @@ void TextManager::quant(float dt) {
 			snprintf(buf, 15, _show_scores.format, _currentScore);
 			updateStaticText(_show_scores.textID, buf);
 
-			_scoreUpdateTimer = _currentScore != _targetScore ? runtime->getTime() + _scoreUpdateTime : -1.f;
+			_scoreUpdateTimer = _currentScore != _targetScore ? g_runtime->getTime() + _scoreUpdateTime : -1.f;
 		}
 	}
 }
@@ -360,7 +360,7 @@ void TextManager::quant(float dt) {
 void TextManager::updateScore(int score) {
 	_targetScore = score;
 	if (_scoreUpdateTimer < 0.f)
-		_scoreUpdateTimer = runtime->getTime();
+		_scoreUpdateTimer = g_runtime->getTime();
 }
 
 void TextManager::updateTime(int seconds) {
diff --git a/engines/qdengine/minigames/adv/common.cpp b/engines/qdengine/minigames/adv/common.cpp
index 22acb55fa2f..8635ce9afdf 100644
--- a/engines/qdengine/minigames/adv/common.cpp
+++ b/engines/qdengine/minigames/adv/common.cpp
@@ -39,7 +39,7 @@ bool QDObject::hit(const mgVect2f& point) const {
 }
 
 float QDObject::depth() const {
-	return runtime->getDepth(_obj);
+	return g_runtime->getDepth(_obj);
 }
 
 void QDObject::setState(const char* name) {
@@ -64,7 +64,7 @@ bool getParameter(const char* name, T& out, bool obligatory) {
 
 template<>
 float getParameter(const char* name, const float &defValue) {
-	if (const char *data = runtime->parameter(name, false)) {
+	if (const char *data = g_runtime->parameter(name, false)) {
 		float retValue = defValue;
 		if (sscanf(data, "%f", &retValue) == 1)
 			return retValue;
@@ -76,7 +76,7 @@ float getParameter(const char* name, const float &defValue) {
 
 template<>
 bool getParameter(const char* name, float &out, bool obligatory) {
-	if (const char * data = runtime->parameter(name, obligatory)) {
+	if (const char * data = g_runtime->parameter(name, obligatory)) {
 		float retValue = out;
 		if (sscanf(data, "%f", &retValue) == 1) {
 			out = retValue;
@@ -90,7 +90,7 @@ bool getParameter(const char* name, float &out, bool obligatory) {
 
 template<>
 mgVect2f getParameter(const char* name, const mgVect2f& defValue) {
-	if (const char * data = runtime->parameter(name, false)) {
+	if (const char * data = g_runtime->parameter(name, false)) {
 		mgVect2f retValue = defValue;
 		if (sscanf(data, "%f %f", &retValue.x, &retValue.y) == 2)
 			return retValue;
@@ -102,7 +102,7 @@ mgVect2f getParameter(const char* name, const mgVect2f& defValue) {
 
 template<>
 bool getParameter(const char* name, mgVect2f& out, bool obligatory) {
-	if (const char * data = runtime->parameter(name, obligatory)) {
+	if (const char * data = g_runtime->parameter(name, obligatory)) {
 		mgVect2f retValue = out;
 		if (sscanf(data, "%f %f", &retValue.x, &retValue.y) == 2) {
 			out = retValue;
diff --git a/engines/qdengine/minigames/adv/common.h b/engines/qdengine/minigames/adv/common.h
index 238cd8fa0c9..6a8c8f11d3c 100644
--- a/engines/qdengine/minigames/adv/common.h
+++ b/engines/qdengine/minigames/adv/common.h
@@ -75,7 +75,7 @@ typedef Std::vector<int> Indexes;
 typedef Std::vector<mgVect3f> Coords;
 
 class MinigameManager;
-extern MinigameManager *runtime;
+extern MinigameManager *g_runtime;
 
 template<class T>
 T getParameter(const char* name, const T& defValue);
diff --git a/engines/qdengine/minigames/adv/m_karaoke.cpp b/engines/qdengine/minigames/adv/m_karaoke.cpp
index 24d39056eb9..c4ce3449b11 100644
--- a/engines/qdengine/minigames/adv/m_karaoke.cpp
+++ b/engines/qdengine/minigames/adv/m_karaoke.cpp
@@ -37,11 +37,11 @@ Karaoke::Node::Node() {
 
 
 Karaoke::Karaoke() {
-	controlName_ = runtime->parameter("control_name", true);
+	controlName_ = g_runtime->parameter("control_name", true);
 	if (!controlName_ || !*controlName_)
 		return;
 
-	colorReaded_ = runtime->parameter("color_first", true);
+	colorReaded_ = g_runtime->parameter("color_first", true);
 	if (!colorReaded_ || !*colorReaded_)
 		return;
 
@@ -119,7 +119,7 @@ Karaoke::Karaoke() {
 		}
 	};
 
-	const char *fileName = runtime->parameter("text_file", true);
+	const char *fileName = g_runtime->parameter("text_file", true);
 	if (!fileName)
 		return;
 
@@ -188,10 +188,10 @@ void Karaoke::quant(float dt) {
 		++idx;
 	}
 
-	if (runtime->mouseRightPressed())
+	if (g_runtime->mouseRightPressed())
 		debugC(2, kDebugMinigames, "%s", outText.c_str());
 
-	runtime->setText(controlName_, outText.c_str());
+	g_runtime->setText(controlName_, outText.c_str());
 }
 
 } // namespace QDEngine
diff --git a/engines/qdengine/minigames/adv/m_puzzle.cpp b/engines/qdengine/minigames/adv/m_puzzle.cpp
index 2cd15352126..4db0531f423 100644
--- a/engines/qdengine/minigames/adv/m_puzzle.cpp
+++ b/engines/qdengine/minigames/adv/m_puzzle.cpp
@@ -74,7 +74,7 @@ Puzzle::Puzzle() {
 	angles_ = getParameter("angles", 4);
 	xassert(angles_ > 0 &&  angles_ < 10);
 
-	if (!(stackBottom_ = runtime->getObject(runtime->parameter("inventory_bottom"))))
+	if (!(stackBottom_ = g_runtime->getObject(g_runtime->parameter("inventory_bottom"))))
 		return;
 	if (!getParameter("inventory_size", stackSize_, true))
 		return;
@@ -85,13 +85,13 @@ Puzzle::Puzzle() {
 			return;
 	} else
 		rotateTimePeriod_ = 86400; // сутки
-	nextRotateTime_ = runtime->getTime() + rotateTimePeriod_;
+	nextRotateTime_ = g_runtime->getTime() + rotateTimePeriod_;
 
 	flySpeed_ = getParameter("inventory_drop_speed", 240.f);
 	xassert(flySpeed_ > 0.f);
 	returnSpeed_ = getParameter("inventory_return_speed", -1.f);
 
-	const char *name_begin = runtime->parameter("obj_name_begin", "obj_");
+	const char *name_begin = g_runtime->parameter("obj_name_begin", "obj_");
 
 	char buf[128];
 	buf[127] = 0;
@@ -101,14 +101,14 @@ Puzzle::Puzzle() {
 		_snprintf(buf, 127, "%s%02d", name_begin, idx + 1);
 
 		Node node;
-		node.obj = runtime->getObject(buf);
+		node.obj = g_runtime->getObject(buf);
 
-		if (runtime->debugMode()) {
+		if (g_runtime->debugMode()) {
 			node.pos = nodes_.size();
 			node.angle = 0;
 			field_[node.pos] = node.pos;
 		} else
-			node.angle = runtime->rnd(0, angles_ - 1);
+			node.angle = g_runtime->rnd(0, angles_ - 1);
 		node.obj.setState(getStateName(node.angle, false, true));
 
 		gameData.write(node.obj->R());
@@ -116,7 +116,7 @@ Puzzle::Puzzle() {
 		nodes_.push_back(node);
 	}
 
-	if (!runtime->processGameData(gameData))
+	if (!g_runtime->processGameData(gameData))
 		return;
 
 	for (int idx = 0; idx < gameSize_; ++idx) {
@@ -126,10 +126,10 @@ Puzzle::Puzzle() {
 		positions_.push_back(crd);
 	}
 
-	if (runtime->debugMode())
+	if (g_runtime->debugMode())
 		nodes_[0].angle = angles_ - 1;
 
-	size_ = runtime->getSize(nodes_[0].obj);
+	size_ = g_runtime->getSize(nodes_[0].obj);
 	debugC(2, kDebugMinigames, "size = (%6.2f,%6.2f)", size_.x, size_.y);
 
 	depth_ = nodes_[0].obj.depth();
@@ -142,8 +142,8 @@ Puzzle::Puzzle() {
 	pickedItem_ = -1;
 	mouseObjPose_ = stidx(stackSize_ + 1);
 
-	inField_ = runtime->debugMode() ? nodes_.size() : 0;
-	nextObjTime_ = runtime->getTime();
+	inField_ = g_runtime->debugMode() ? nodes_.size() : 0;
+	nextObjTime_ = g_runtime->getTime();
 
 	setState(MinigameInterface::RUNNING);
 }
@@ -151,9 +151,9 @@ Puzzle::Puzzle() {
 Puzzle::~Puzzle() {
 	Nodes::iterator it;
 	FOR_EACH(nodes_, it)
-	runtime->release(it->obj);
+	g_runtime->release(it->obj);
 
-	runtime->release(stackBottom_);
+	g_runtime->release(stackBottom_);
 }
 
 void Puzzle::rotate(int item) {
@@ -208,15 +208,15 @@ void Puzzle::put(int where, int what, float flowSpeed) {
 			flyObj->data = what;
 
 			mgVect3f from = isOnMouse(node) ? node.obj->R() : start < -1 ? stackPosition(stidx(start)) : position(start);
-			flyObj->current = runtime->world2game(from);
+			flyObj->current = g_runtime->world2game(from);
 			node.obj->set_R(from);
 
 			flyObj->speed = flowSpeed;
 		}
 
 		mgVect3f to = where < -1 ? stackPosition(stidx(where)) : position(where);
-		flyObj->target = runtime->world2game(to);
-		flyObj->depth = runtime->getDepth(to);
+		flyObj->target = g_runtime->world2game(to);
+		flyObj->depth = g_runtime->getDepth(to);
 	}
 
 	if (where >= 0)
@@ -232,27 +232,27 @@ void Puzzle::putOnStack(int what, float speed) {
 
 void Puzzle::returnToStack() {
 	xassert(pickedItem_ != -1);
-	runtime->event(EVENT_RETURN, runtime->mousePosition());
+	g_runtime->event(EVENT_RETURN, g_runtime->mousePosition());
 	if (prevPlace_ >= 0)
 		put(prevPlace_, pickedItem_);
 	else
 		putOnStack(pickedItem_, returnSpeed_);
 	prevPlace_ = -1;
 	pickedItem_ = -1;
-	runtime->event(EVENT_CLICK, runtime->mousePosition());
+	g_runtime->event(EVENT_CLICK, g_runtime->mousePosition());
 }
 
 void Puzzle::quant(float dt) {
 	if (pickedItem_ == -1)
-		runtime->setGameHelpVariant(0);
+		g_runtime->setGameHelpVariant(0);
 	else
-		runtime->setGameHelpVariant(1);
+		g_runtime->setGameHelpVariant(1);
 
-	if (runtime->getTime() > nextRotateTime_) {
-		runtime->event(EVENT_FIELD_ROTATE, mgVect2f(400, 300));
-		nextRotateTime_ = runtime->getTime() + rotateTimePeriod_;
+	if (g_runtime->getTime() > nextRotateTime_) {
+		g_runtime->event(EVENT_FIELD_ROTATE, mgVect2f(400, 300));
+		nextRotateTime_ = g_runtime->getTime() + rotateTimePeriod_;
 		globalAngle_ = (globalAngle_ + 1) % angles_;
-		runtime->setCompleteHelpVariant(globalAngle_);
+		g_runtime->setCompleteHelpVariant(globalAngle_);
 	}
 
 	FlyQDObjects::iterator fit = flyObjs_.begin();
@@ -262,10 +262,10 @@ void Puzzle::quant(float dt) {
 		else
 			fit = flyObjs_.erase(fit);
 
-	if (inField_ < nodes_.size() && runtime->getTime() > nextObjTime_ &&
+	if (inField_ < nodes_.size() && g_runtime->getTime() > nextObjTime_ &&
 	(stack_.size() < stackSize_ - 1 || stack_.size() < stackSize_ && pickedItem_ == -1)) { // нужно добавить в инвентори фишку
 		// ищем случайный не выставленный фрагмент
-		int freeIdx = round(runtime->rnd(0.f, nodes_.size() - 1));
+		int freeIdx = round(g_runtime->rnd(0.f, nodes_.size() - 1));
 		Nodes::iterator it = nodes_.begin();
 		for (;;) {
 			if (++it == nodes_.end())
@@ -277,7 +277,7 @@ void Puzzle::quant(float dt) {
 		int idx = distance(nodes_.begin(), it);
 
 		++inField_;
-		nextObjTime_ = runtime->getTime() + stackPlaceSize_.y / flySpeed_;
+		nextObjTime_ = g_runtime->getTime() + stackPlaceSize_.y / flySpeed_;
 
 		it->pos = stidx(stackSize_);
 		it->obj.setState(getStateName(it->angle, false, true));
@@ -285,7 +285,7 @@ void Puzzle::quant(float dt) {
 		putOnStack(idx, flySpeed_);
 	}
 
-	mgVect2f mouse = runtime->mousePosition();
+	mgVect2f mouse = g_runtime->mousePosition();
 
 	int hovPlace = -1;  // Номер места которое сейчас под мышкой
 	for (int idx = 0; idx < stack_.size(); ++idx)
@@ -296,7 +296,7 @@ void Puzzle::quant(float dt) {
 	if (hovPlace == -1) {
 		float radius = 0.5f * size_.x;
 		for (int idx = 0; idx < gameSize_; ++idx)
-			if (dist(runtime->world2game(position(idx)), mouse) < radius) {
+			if (dist(g_runtime->world2game(position(idx)), mouse) < radius) {
 				hovPlace = idx;
 				break;
 			}
@@ -309,23 +309,23 @@ void Puzzle::quant(float dt) {
 			hovPlace = stidx(stackSize_);
 	}
 
-	if (runtime->mouseLeftPressed()) {
+	if (g_runtime->mouseLeftPressed()) {
 		if (hovPlace >= 0) { // клик по полю
 			Indexes::value_type& hovItem = field_[hovPlace];
 			if (hovItem == -1) // клик по пустой ячейке
 				if (pickedItem_ == -1) // на мыши ничего нет
-					runtime->event(EVENT_CLICK, mouse);
+					g_runtime->event(EVENT_CLICK, mouse);
 				else { // кладем фрагмент с мыши
 					put(hovPlace, pickedItem_);
 					if (testPlace(pickedItem_)) // положили на свое свое место
-						runtime->event(EVENT_PUT_RIGHT, mouse);
+						g_runtime->event(EVENT_PUT_RIGHT, mouse);
 					else // просто положили
-						runtime->event(EVENT_PUT, mouse);
+						g_runtime->event(EVENT_PUT, mouse);
 					pickedItem_ = -1;
 					prevPlace_ = -1;
 				} else { // клик по непустой ячейке
 				if (testPlace(hovPlace)) // клик по правильно уложенной фишке
-					runtime->event(EVENT_CLICK_RIGHT, mouse);
+					g_runtime->event(EVENT_CLICK_RIGHT, mouse);
 				else if (pickedItem_ != -1) { // поменять с тем что на мыше
 					bool swap = true;
 					if (prevPlace_ >= 0)
@@ -333,20 +333,20 @@ void Puzzle::quant(float dt) {
 					else
 						putOnStack(hovItem, returnSpeed_);
 					if (testPlace(hovItem)) { // оказалась при обмене на своем месте
-						runtime->event(EVENT_PUT_RIGHT, runtime->world2game(position(prevPlace_)));
+						g_runtime->event(EVENT_PUT_RIGHT, g_runtime->world2game(position(prevPlace_)));
 						swap = false;
 					}
 					put(hovPlace, pickedItem_);
 					if (testPlace(pickedItem_)) { // положили на свое свое место
-						runtime->event(EVENT_PUT_RIGHT, mouse);
+						g_runtime->event(EVENT_PUT_RIGHT, mouse);
 						swap = false;
 					}
 					if (swap) // просто обменяли
-						runtime->event(EVENT_SWAP, mouse);
+						g_runtime->event(EVENT_SWAP, mouse);
 					pickedItem_ = -1;
 					prevPlace_ = -1;
 				} else { // взять фрагмент на мышь
-					runtime->event(EVENT_GET, mouse);
+					g_runtime->event(EVENT_GET, mouse);
 					prevPlace_ = hovPlace;
 					pickedItem_ = hovItem;
 					nodes_[pickedItem_].pos = mouseObjPose_;
@@ -357,7 +357,7 @@ void Puzzle::quant(float dt) {
 			int hovStack = stidx(hovPlace);
 			if (pickedItem_ == -1) // на мыши ничего нет
 				if (hovStack < stack_.size()) { // взять фрагмент из стека на мышь
-					runtime->event(EVENT_GET, mouse);
+					g_runtime->event(EVENT_GET, mouse);
 					Indexes::iterator it = stack_.begin() + hovStack;
 					xassert(*it >= 0);
 					prevPlace_ = -1;
@@ -367,36 +367,36 @@ void Puzzle::quant(float dt) {
 					for (int idx = hovStack; idx < stack_.size(); ++idx)
 						put(stidx(idx), stack_[idx], flySpeed_);
 				} else // пустой клик в области стека
-					runtime->event(EVENT_CLICK, mouse);
+					g_runtime->event(EVENT_CLICK, mouse);
 			else // вернуть фишку на место
 				returnToStack();
 		} else // пустой клик мимо игрового поля
-			runtime->event(EVENT_CLICK, mouse);
-	} else if (runtime->mouseRightPressed()) {
+			g_runtime->event(EVENT_CLICK, mouse);
+	} else if (g_runtime->mouseRightPressed()) {
 		if (pickedItem_ == -1) {
 			if (hovPlace >= 0) { // клик по полю
 				if (testPlace(hovPlace)) // клик по правильно уложенной фишке
-					runtime->event(EVENT_CLICK_RIGHT, mouse);
+					g_runtime->event(EVENT_CLICK_RIGHT, mouse);
 				else {
 					Indexes::value_type& hovItem = field_[hovPlace];
 					if (hovItem >= 0) {
 						rotate(hovItem);
 						if (testPlace(hovItem)) // повернули на правильный угол
-							runtime->event(EVENT_PUT_RIGHT, mouse);
+							g_runtime->event(EVENT_PUT_RIGHT, mouse);
 						else // просто положили
-							runtime->event(EVENT_ROTATE_IN_FIELD, mouse);
+							g_runtime->event(EVENT_ROTATE_IN_FIELD, mouse);
 					} else // попытка прокрутить пустое место
-						runtime->event(EVENT_CLICK, mouse);
+						g_runtime->event(EVENT_CLICK, mouse);
 				}
 			} else  if (hovPlace < -1) { // клик по стеку
 				int hovStack = stidx(hovPlace);
 				if (hovStack < stack_.size()) { // покрутить внутри стека
-					runtime->event(EVENT_ROTATE_IN_STACK, mouse);
+					g_runtime->event(EVENT_ROTATE_IN_STACK, mouse);
 					rotate(stack_[hovStack]);
 				} else // попытка прокрутить пустое место
-					runtime->event(EVENT_CLICK, mouse);
+					g_runtime->event(EVENT_CLICK, mouse);
 			} else // пустой клик мимо игрового поля
-				runtime->event(EVENT_CLICK, mouse);
+				g_runtime->event(EVENT_CLICK, mouse);
 		} else // вернуть фишку на место
 			returnToStack();
 	}
@@ -414,7 +414,7 @@ void Puzzle::quant(float dt) {
 				}
 			} else if (idx == pickedItem_) {
 				node.obj.setState(getStateName(node.angle, hovPlace >= 0 && !testPlace(hovPlace), false));
-				node.obj->set_R(runtime->game2world(mouse, stackBottom_.depth() - 200));
+				node.obj->set_R(g_runtime->game2world(mouse, stackBottom_.depth() - 200));
 			} else {
 				node.obj.setState(getStateName(node.angle, node.pos == hovPlace && pickedItem_ == -1, true));
 				if (!isFlying(idx))
@@ -422,7 +422,7 @@ void Puzzle::quant(float dt) {
 			}
 			iWin = iWin && testPlace(idx);
 		} else {
-			runtime->hide(node.obj);
+			g_runtime->hide(node.obj);
 			iWin = false;
 		}
 	}
@@ -452,9 +452,9 @@ const mgVect3f &Puzzle::position(int num) const {
 }
 
 mgVect3f Puzzle::stackPosition(int num) const {
-	mgVect3f bottom = runtime->world2game(stackBottom_);
+	mgVect3f bottom = g_runtime->world2game(stackBottom_);
 	bottom.y -= stackPlaceSize_.y * num;
-	return runtime->game2world(bottom);
+	return g_runtime->game2world(bottom);
 }
 
 } // namespace QDEngine
diff --git a/engines/qdengine/minigames/adv/m_swap.cpp b/engines/qdengine/minigames/adv/m_swap.cpp
index 4602351267c..91117a1737f 100644
--- a/engines/qdengine/minigames/adv/m_swap.cpp
+++ b/engines/qdengine/minigames/adv/m_swap.cpp
@@ -64,9 +64,9 @@ Swap::Swap() {
 
 	if ((rotateTimePeriod_ = getParameter("rotate_period", 86400.f)) < 10.f)
 		return;
-	nextRotateTime_ = runtime->getTime() + rotateTimePeriod_;
+	nextRotateTime_ = g_runtime->getTime() + rotateTimePeriod_;
 
-	const char *name_begin = runtime->parameter("obj_name_begin", "obj_");
+	const char *name_begin = g_runtime->parameter("obj_name_begin", "obj_");
 
 	char buf[128];
 	buf[127] = 0;
@@ -77,7 +77,7 @@ Swap::Swap() {
 		_snprintf(buf, 127, "%s%02d", name_begin, idx + 1);
 
 		Node node(idx);
-		node.obj = runtime->getObject(buf);
+		node.obj = g_runtime->getObject(buf);
 		node.angle = 0;
 		node.obj.setState(getStateName(node.angle, false));
 		nodes_.push_back(node);
@@ -85,28 +85,28 @@ Swap::Swap() {
 		gameData.write(node.obj->R());
 	}
 
-	if (!runtime->processGameData(gameData))
+	if (!g_runtime->processGameData(gameData))
 		return;
 
 	positions_.resize(gameSize_);
 	for (int idx = 0; idx < gameSize_; ++idx)
 		gameData.read(positions_[idx]);
 
-	size_ = getParameter("element_size", runtime->getSize(nodes_[0].obj));
+	size_ = getParameter("element_size", g_runtime->getSize(nodes_[0].obj));
 	xassert(size_.x > 0.f && size_.y > 0.f && size_.x < 500.f && size_.y < 500.f);
 	debugC(2, kDebugMinigames, "element_size = (%6.2f,%6.2f)", size_.x, size_.y);
 
 	pickedItem_ = -1;
 	last1_ = last2_ = -1;
 
-	if (runtime->debugMode()) {
+	if (g_runtime->debugMode()) {
 		last1_ = 0;
 		last2_ = 1;
 		rotate(last1_, last2_, false);
 	} else
 		for (int cnt = 0; cnt < 50; ++cnt) {
-			rotate(runtime->rnd(0, gameSize_ - 1), runtime->rnd(0, gameSize_ - 1), true, true);
-			swap(runtime->rnd(0, gameSize_ - 1), runtime->rnd(0, gameSize_ - 1), true);
+			rotate(g_runtime->rnd(0, gameSize_ - 1), g_runtime->rnd(0, gameSize_ - 1), true, true);
+			swap(g_runtime->rnd(0, gameSize_ - 1), g_runtime->rnd(0, gameSize_ - 1), true);
 		}
 
 
@@ -117,30 +117,30 @@ Swap::Swap() {
 Swap::~Swap() {
 	Nodes::iterator it;
 	FOR_EACH(nodes_, it)
-	runtime->release(it->obj);
+	g_runtime->release(it->obj);
 
 }
 
 void Swap::quant(float dt) {
 	if (pickedItem_ >= 0)
-		runtime->setGameHelpVariant(1);
+		g_runtime->setGameHelpVariant(1);
 	else if (last1_ >= 0)
-		runtime->setGameHelpVariant(2);
+		g_runtime->setGameHelpVariant(2);
 	else
-		runtime->setGameHelpVariant(0);
+		g_runtime->setGameHelpVariant(0);
 
-	if (runtime->getTime() > nextRotateTime_) {
-		int item1 = runtime->rnd(0, gameSize_ - 1);
-		int item2 = runtime->rnd(0, gameSize_ - 1);
+	if (g_runtime->getTime() > nextRotateTime_) {
+		int item1 = g_runtime->rnd(0, gameSize_ - 1);
+		int item2 = g_runtime->rnd(0, gameSize_ - 1);
 		if (item1 != last1_ && item1 != last2_ && item1 != pickedItem_ && item2 != last1_ && item2 != last2_ && item2 != pickedItem_) {
-			nextRotateTime_ = runtime->getTime() + rotateTimePeriod_;
+			nextRotateTime_ = g_runtime->getTime() + rotateTimePeriod_;
 			rotate(item1, item2, false, true);
-			runtime->event(EVENT_AUTO_ROTATE, mgVect2f(400, 300));
+			g_runtime->event(EVENT_AUTO_ROTATE, mgVect2f(400, 300));
 			return;
 		}
 	}
 
-	mgVect2f mouse = runtime->mousePosition();
+	mgVect2f mouse = g_runtime->mousePosition();
 
 	int hovPlace = -1;  // Номер места которое сейчас под мышкой
 	if (pickedItem_ == -1) {
@@ -154,21 +154,21 @@ void Swap::quant(float dt) {
 	if (hovPlace == -1)
 		for (int idx = 0; idx < gameSize_; ++idx) {
 			Rectf rect(size_ * 0.9f);
-			rect.center(runtime->world2game(position(idx)));
+			rect.center(g_runtime->world2game(position(idx)));
 			if (rect.point_inside(mouse)) {
 				hovPlace = idx;
 				break;
 			}
 		}
 
-	if (runtime->mouseLeftPressed()) {
+	if (g_runtime->mouseLeftPressed()) {
 		if (hovPlace >= 0) { // клик по полю
 			if (pickedItem_ == -1) { // мышь пустая, берем
 				deactivate();
-				runtime->event(EVENT_GET, mouse);
+				g_runtime->event(EVENT_GET, mouse);
 				pickedItem_ = hovPlace;
 			} else if (pickedItem_ == hovPlace) { // вернуть на место
-				runtime->event(EVENT_RETURN, mouse);
+				g_runtime->event(EVENT_RETURN, mouse);
 				put(pickedItem_, false);
 				pickedItem_ = -1;
 			} else { // поменять местами
@@ -179,19 +179,19 @@ void Swap::quant(float dt) {
 			}
 		} else { // пустой клик мимо игрового поля
 			deactivate();
-			runtime->event(EVENT_CLICK, mouse);
+			g_runtime->event(EVENT_CLICK, mouse);
 		}
-	} else if (runtime->mouseRightPressed()) {
+	} else if (g_runtime->mouseRightPressed()) {
 		if (pickedItem_ >= 0) // если на мыши фрагмент ничего не делаем
-			runtime->event(EVENT_CLICK, mouse);
+			g_runtime->event(EVENT_CLICK, mouse);
 		else if (hovPlace == last1_ || hovPlace == last2_) // клик по выделенным
 			rotate(last1_, last2_, false);
 		else // пустой клик мимо активного места
-			runtime->event(EVENT_CLICK, mouse);
+			g_runtime->event(EVENT_CLICK, mouse);
 	}
 
 	if (pickedItem_ >= 0)
-		nodes_[pickedItem_].obj->set_R(runtime->game2world(mouse, -5000));
+		nodes_[pickedItem_].obj->set_R(g_runtime->game2world(mouse, -5000));
 
 	int idx = 0;
 	for (; idx < gameSize_; ++idx)
@@ -238,11 +238,11 @@ void Swap::swap(int item1, int item2, bool silent) {
 	bool res = false;
 	if (!silent) {
 		if (testPlace(item1)) { // сняли со своего места
-			runtime->event(EVENT_GET_RIGHT, runtime->world2game(position(item1)));
+			g_runtime->event(EVENT_GET_RIGHT, g_runtime->world2game(position(item1)));
 			res = true;
 		}
 		if (testPlace(item2)) { // сняли со своего места
-			runtime->event(EVENT_GET_RIGHT, runtime->world2game(position(item2)));
+			g_runtime->event(EVENT_GET_RIGHT, g_runtime->world2game(position(item2)));
 			res = true;
 		}
 	}
@@ -253,15 +253,15 @@ void Swap::swap(int item1, int item2, bool silent) {
 
 	if (!silent) {
 		if (testPlace(item1)) { // оказалась при обмене на своем месте
-			runtime->event(EVENT_PUT_RIGHT, runtime->world2game(position(item1)));
+			g_runtime->event(EVENT_PUT_RIGHT, g_runtime->world2game(position(item1)));
 			res = true;
 		}
 		if (testPlace(item2)) { // положили на свое свое место
-			runtime->event(EVENT_PUT_RIGHT, runtime->world2game(position(item2)));
+			g_runtime->event(EVENT_PUT_RIGHT, g_runtime->world2game(position(item2)));
 			res = true;
 		}
 		if (!res) // просто обменяли
-			runtime->event(EVENT_SWAP, runtime->mousePosition());
+			g_runtime->event(EVENT_SWAP, g_runtime->mousePosition());
 	}
 }
 
@@ -271,9 +271,9 @@ void Swap::rotate(int item1, int item2, bool silent, bool avto) {
 
 	if (!silent) {
 		if (testPlace(item1)) // сняли со своего места
-			runtime->event(EVENT_GET_RIGHT, runtime->world2game(position(item1)));
+			g_runtime->event(EVENT_GET_RIGHT, g_runtime->world2game(position(item1)));
 		if (testPlace(item2)) // сняли со своего места
-			runtime->event(EVENT_GET_RIGHT, runtime->world2game(position(item2)));
+			g_runtime->event(EVENT_GET_RIGHT, g_runtime->world2game(position(item2)));
 	}
 
 	nodes_[item1].angle = (nodes_[item1].angle + 1) % angles_;
@@ -283,10 +283,10 @@ void Swap::rotate(int item1, int item2, bool silent, bool avto) {
 
 	if (!silent) {
 		if (testPlace(item1)) // оказалась при обмене на своем месте
-			runtime->event(EVENT_PUT_RIGHT, runtime->world2game(position(item1)));
+			g_runtime->event(EVENT_PUT_RIGHT, g_runtime->world2game(position(item1)));
 		if (testPlace(item2)) // положили на свое свое место
-			runtime->event(EVENT_PUT_RIGHT, runtime->world2game(position(item2)));
-		runtime->event(EVENT_ROTATE, runtime->mousePosition());
+			g_runtime->event(EVENT_PUT_RIGHT, g_runtime->world2game(position(item2)));
+		g_runtime->event(EVENT_ROTATE, g_runtime->mousePosition());
 	}
 }
 
diff --git a/engines/qdengine/minigames/adv/m_triangles.cpp b/engines/qdengine/minigames/adv/m_triangles.cpp
index 12be98fee82..99ec8b58f37 100644
--- a/engines/qdengine/minigames/adv/m_triangles.cpp
+++ b/engines/qdengine/minigames/adv/m_triangles.cpp
@@ -50,7 +50,7 @@ MinigameTriangle::Node::Node(int number, int rot) {
 
 void MinigameTriangle::Node::release() {
 	for (auto &it : face_)
-		runtime->release(it);
+		g_runtime->release(it);
 }
 
 bool MinigameTriangle::Node::hit(const mgVect2f& pos) const {
@@ -103,9 +103,9 @@ MinigameTriangle::MinigameTriangle() {
 	if (!getParameter("animation_time", animationTime_, true))
 		return;
 
-	const char *faceNameBegin = runtime->parameter("object_name_begin", "obj_");
-	const char *backNameBegin = runtime->parameter("backg_name_begin", "element_back_");
-	const char *selectNameBegin = runtime->parameter("select_name_begin", "element_select_");
+	const char *faceNameBegin = g_runtime->parameter("object_name_begin", "obj_");
+	const char *backNameBegin = g_runtime->parameter("backg_name_begin", "element_back_");
+	const char *selectNameBegin = g_runtime->parameter("select_name_begin", "element_select_");
 
 	char name[64];
 	name[63] = 0;
@@ -114,7 +114,7 @@ MinigameTriangle::MinigameTriangle() {
 		Node& node = nodes_.back();
 		for (int angle = 1; angle <= 3; ++angle) {
 			snprintf(name, 63, "%s%02d_%1d", faceNameBegin, num + 1, angle);
-			QDObject obj = runtime->getObject(name);
+			QDObject obj = g_runtime->getObject(name);
 			node.face_.push_back(obj);
 			positions_.push_back(obj->R());
 		}
@@ -127,7 +127,7 @@ MinigameTriangle::MinigameTriangle() {
 	for (auto &it : positions_)
 		gameData.write(it);
 
-	if (!runtime->processGameData(gameData))
+	if (!g_runtime->processGameData(gameData))
 		return;
 
 	for (auto &it : positions_)
@@ -154,11 +154,11 @@ MinigameTriangle::MinigameTriangle() {
 	animatedNodes_[0] = animatedNodes_[1] = -1;
 	animationTimer_ = 0.f;
 
-	if (!runtime->debugMode())
+	if (!g_runtime->debugMode())
 		for (int i = 0; i < 150; ++i) {
-			int pos1 = runtime->rnd(0, nodes_.size() - 1);
+			int pos1 = g_runtime->rnd(0, nodes_.size() - 1);
 			for (int j = 0; j < 20; ++j) {
-				int pos2 = runtime->rnd(pos1 - 10, pos1 + 10);
+				int pos2 = g_runtime->rnd(pos1 - 10, pos1 + 10);
 				if (compatible(pos1, pos2)) {
 					swapNodes(pos1, pos2, true);
 					break;
@@ -222,7 +222,7 @@ void MinigameTriangle::releaseNodeBack(Node& node) {
 
 void MinigameTriangle::updateNode(Node& node, int position, int flip, bool quick) {
 	for (auto &fit : node.face_)
-		runtime->hide(fit);
+		g_runtime->hide(fit);
 
 	node.flip = flip;
 
@@ -287,32 +287,32 @@ void MinigameTriangle::endSwapNodes(int pos1, int pos2) {
 	if (node1.number_ == pos1) { // поставили на свое место
 		assert(!node1.isBack_);
 		counted = true;
-		runtime->event(EVENT_PUT_RIGHT, node1.obj()->screen_R());
+		g_runtime->event(EVENT_PUT_RIGHT, node1.obj()->screen_R());
 	}
 
 	if (node2.number_ == pos1) { // сняли со своего места
 		assert(node2.isBack_);
 		counted = true;
-		runtime->event(EVENT_GET_RIGHT, node1.obj()->screen_R());
+		g_runtime->event(EVENT_GET_RIGHT, node1.obj()->screen_R());
 	}
 
 	if (node2.number_ == pos2) { // поставили на свое место
 		assert(!node2.isBack_);
 		counted = true;
-		runtime->event(EVENT_PUT_RIGHT, node2.obj()->screen_R());
+		g_runtime->event(EVENT_PUT_RIGHT, node2.obj()->screen_R());
 	}
 
 	if (node1.number_ == pos2) { // сняли со своего места
 		assert(node1.isBack_);
 		counted = true;
-		runtime->event(EVENT_GET_RIGHT, node2.obj()->screen_R());
+		g_runtime->event(EVENT_GET_RIGHT, node2.obj()->screen_R());
 	}
 
 	if (!counted) { // просто сделали ход
 		mgVect2i pos = node1.obj()->screen_R();
 		pos += node2.obj()->screen_R();
 		pos /= 2;
-		runtime->event(EVENT_TURN, pos);
+		g_runtime->event(EVENT_TURN, pos);
 	}
 
 	bool isWin = true;
@@ -438,16 +438,16 @@ void MinigameTriangle::swapNodes(int pos1, int pos2, bool silentQuick) {
 
 void MinigameTriangle::quant(float dt) {
 	if (selected_ >= 0)
-		runtime->setGameHelpVariant(0);
+		g_runtime->setGameHelpVariant(0);
 	else
-		runtime->setGameHelpVariant(1);
+		g_runtime->setGameHelpVariant(1);
 
 	if (animate(dt))
 		return;
 
 	int mousePos = -1;
 	for (int idx = 0; idx < fieldSize_; ++idx)
-		if (nodes_[idx].hit(runtime->mousePosition())) {
+		if (nodes_[idx].hit(g_runtime->mousePosition())) {
 			mousePos = idx;
 			break;
 		}
@@ -455,7 +455,7 @@ void MinigameTriangle::quant(float dt) {
 	int startAnimation = -1;
 	int lastSelected = selected_;
 
-	if (runtime->mouseLeftPressed()) {
+	if (g_runtime->mouseLeftPressed()) {
 		if (mousePos < 0)                       // кликнули мимо - снимаем выделение
 			selected_ = -1;
 		else if (selected_ < 0)                 // ничего выделено небыло, просто выделяем
@@ -478,7 +478,7 @@ void MinigameTriangle::quant(float dt) {
 				node.border_.setState(Node::getBorderStateName(idx == selected_));
 				node.border_->set_R(slotCoord(idx));
 				node.border_->update_screen_R();
-				runtime->setDepth(node.border_, selectDepth_);
+				g_runtime->setDepth(node.border_, selectDepth_);
 			} else if (node.border_) {
 				selectBorders_[0].releaseObject(node.border_);
 				selectBorders_[1].releaseObject(node.border_);
@@ -508,7 +508,7 @@ void MinigameTriangle::quant(float dt) {
 		swapNodes(startAnimation, mousePos, false);
 	}
 
-	if (runtime->mouseRightPressed() && mousePos >= 0) {
+	if (g_runtime->mouseRightPressed() && mousePos >= 0) {
 		debugC(2, kDebugMinigames, "----- DUBUG INFO FOR %d POSITION --------------------", mousePos);
 		debugC(2, kDebugMinigames, "row = %d, begin = %d, orientation = %d", rowByNum(mousePos), rowBegin(rowByNum(mousePos)), orientation(mousePos));
 		nodes_[mousePos].debugInfo();


Commit: 665cd7a51b9f84001c3c2c51fc5c97989545bc5e
    https://github.com/scummvm/scummvm/commit/665cd7a51b9f84001c3c2c51fc5c97989545bc5e
Author: Eugene Sandulenko (sev at scummvm.org)
Date: 2024-10-19T19:45:31+02:00

Commit Message:
TINSEL: Fixed crash on failed engine run attempt

Changed paths:
    engines/tinsel/tinsel.cpp


diff --git a/engines/tinsel/tinsel.cpp b/engines/tinsel/tinsel.cpp
index ced7f454eb9..12c87b25553 100644
--- a/engines/tinsel/tinsel.cpp
+++ b/engines/tinsel/tinsel.cpp
@@ -1135,7 +1135,8 @@ Common::Error TinselEngine::run() {
 	_vm->_config->writeToDisk();
 
 	EndScene();
-	_bg->ResetBackground();
+	if (_bg)
+		_bg->ResetBackground();
 
 	return Common::kNoError;
 }

More information about the Scummvm-git-logs mailing list