[Scummvm-git-logs] scummvm master -> 13cd003eae5401997c67dcbb4ede8c7cb80a45ec

sev- noreply at scummvm.org
Tue Nov 26 16:02:15 UTC 2024 

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

Summary:
eb06a0a729 QDENGINE: Got rid of g_runtime in FlyObject in adv minigames
c3c2588997 QDENGINE: Got rid of g_runtime in m_triangle minigame
f00126f3e8 QDENGINE: Got rid of g_runtime in m_swap minigame
13cd003eae QDENGINE: Plugged in m_swap minigame


Commit: eb06a0a729b1b76aac79ac1db283e413504c88f8
    https://github.com/scummvm/scummvm/commit/eb06a0a729b1b76aac79ac1db283e413504c88f8
Author: Eugene Sandulenko (sev at scummvm.org)
Date: 2024-11-26T16:45:43+01:00

Commit Message:
QDENGINE: Got rid of g_runtime in FlyObject in adv minigames

Changed paths:
    engines/qdengine/minigames/adv/FlyObject.cpp
    engines/qdengine/minigames/adv/FlyObject.h
    engines/qdengine/minigames/adv/m_puzzle.cpp


diff --git a/engines/qdengine/minigames/adv/FlyObject.cpp b/engines/qdengine/minigames/adv/FlyObject.cpp
index 0acdb10a3c4..4c49d9abc9b 100644
--- a/engines/qdengine/minigames/adv/FlyObject.cpp
+++ b/engines/qdengine/minigames/adv/FlyObject.cpp
@@ -47,9 +47,9 @@ bool FlyObjectBase::quant(float dt) {
 }
 
 
-bool FlyQDObject::quant(float dt, QDObject& obj) {
+bool FlyQDObject::quant(float dt, QDObject& obj, MinigameManager *runtime) {
 	bool ret = FlyObjectBase::quant(dt);
-	obj->set_R(g_runtime->game2world(current, depth));
+	obj->set_R(runtime->game2world(current, depth));
 	return ret;
 }
 
diff --git a/engines/qdengine/minigames/adv/FlyObject.h b/engines/qdengine/minigames/adv/FlyObject.h
index 75a0e0f9242..53457981537 100644
--- a/engines/qdengine/minigames/adv/FlyObject.h
+++ b/engines/qdengine/minigames/adv/FlyObject.h
@@ -41,7 +41,7 @@ struct FlyQDObject : public FlyObjectBase {
 		return data == dat;
 	}
 
-	bool quant(float dt, QDObject& obj);
+	bool quant(float dt, QDObject& obj, MinigameManager *runtime);
 
 	float depth;
 	int data;
diff --git a/engines/qdengine/minigames/adv/m_puzzle.cpp b/engines/qdengine/minigames/adv/m_puzzle.cpp
index 4125abc7641..241c042e099 100644
--- a/engines/qdengine/minigames/adv/m_puzzle.cpp
+++ b/engines/qdengine/minigames/adv/m_puzzle.cpp
@@ -261,7 +261,7 @@ void Puzzle::quant(float dt) {
 
 	FlyQDObjects::iterator fit = flyObjs_.begin();
 	while (fit != flyObjs_.end())
-		if (!isOnMouse(nodes_[fit->data]) && fit->quant(dt, nodes_[fit->data].obj))
+		if (!isOnMouse(nodes_[fit->data]) && fit->quant(dt, nodes_[fit->data].obj, g_runtime))
 			++fit;
 		else
 			fit = flyObjs_.erase(fit);


Commit: c3c2588997425d53654b76f4969d5d7fb8e96ea8
    https://github.com/scummvm/scummvm/commit/c3c2588997425d53654b76f4969d5d7fb8e96ea8
Author: Eugene Sandulenko (sev at scummvm.org)
Date: 2024-11-26T16:50:50+01:00

Commit Message:
QDENGINE: Got rid of g_runtime in m_triangle minigame

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


diff --git a/engines/qdengine/minigames/adv/m_triangles.cpp b/engines/qdengine/minigames/adv/m_triangles.cpp
index eeb1ee79784..7fd99deca1b 100644
--- a/engines/qdengine/minigames/adv/m_triangles.cpp
+++ b/engines/qdengine/minigames/adv/m_triangles.cpp
@@ -31,7 +31,7 @@
 namespace QDEngine {
 
 MinigameInterface *createMinigameTriangleGame() {
-	return new MinigameTriangle;
+	return new MinigameTriangle(g_runtime);
 }
 
 enum {
@@ -49,16 +49,18 @@ MinigameTriangle::Node::Node(int number, int rot) {
 	_flip = 0;
 }
 
-void MinigameTriangle::Node::release() {
+void MinigameTriangle::Node::release(MinigameManager *runtime) {
 	for (auto &it : _face)
-		g_runtime->release(it);
+		runtime->release(it);
 }
 
 bool MinigameTriangle::Node::hit(const mgVect2f &pos) const {
 	return obj().hit(pos);
 }
 
-MinigameTriangle::MinigameTriangle() {
+MinigameTriangle::MinigameTriangle(MinigameManager *runtime) {
+	_runtime = runtime;
+
 	int type = 0;
 	if (!getParameter("game_type", type, true))
 		return;
@@ -106,9 +108,9 @@ MinigameTriangle::MinigameTriangle() {
 	if (!getParameter("animation_time", _animationTime, true))
 		return;
 
-	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_");
+	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_");
 
 	char name[64];
 	name[63] = 0;
@@ -117,7 +119,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 = g_runtime->getObject(name);
+			QDObject obj = _runtime->getObject(name);
 			node._face.push_back(obj);
 			_positions.push_back(obj->R());
 		}
@@ -128,7 +130,7 @@ MinigameTriangle::MinigameTriangle() {
 	for (auto &it : _positions)
 		it.write(gameData);
 
-	if (!g_runtime->processGameData(gameData))
+	if (!_runtime->processGameData(gameData))
 		return;
 
 	for (auto &it : _positions)
@@ -137,11 +139,11 @@ MinigameTriangle::MinigameTriangle() {
 	for (int num = 1; num <= 2; ++num) {
 		for (int angle = 1; angle <= 3; ++angle) {
 			snprintf(name, 63, "%s%1d_%1d", backNameBegin, num, angle);
-			if (!_backSides[(num - 1) * 3 + angle - 1].load(name, g_runtime))
+			if (!_backSides[(num - 1) * 3 + angle - 1].load(name, _runtime))
 				return;
 		}
 		snprintf(name, 63, "%s%1d", selectNameBegin, num);
-		if (!_selectBorders[num - 1].load(name, g_runtime))
+		if (!_selectBorders[num - 1].load(name, _runtime))
 			return;
 	}
 
@@ -154,11 +156,11 @@ MinigameTriangle::MinigameTriangle() {
 	animatedNodes_[0] = animatedNodes_[1] = -1;
 	_animationTimer = 0.f;
 
-	if (!g_runtime->debugMode())
+	if (!_runtime->debugMode())
 		for (int i = 0; i < 150; ++i) {
-			int pos1 = g_runtime->rnd(0, _nodes.size() - 1);
+			int pos1 = _runtime->rnd(0, _nodes.size() - 1);
 			for (int j = 0; j < 20; ++j) {
-				int pos2 = g_runtime->rnd(pos1 - 10, pos1 + 10);
+				int pos2 = _runtime->rnd(pos1 - 10, pos1 + 10);
 				if (compatible(pos1, pos2)) {
 					swapNodes(pos1, pos2, true);
 					break;
@@ -174,13 +176,13 @@ MinigameTriangle::MinigameTriangle() {
 
 MinigameTriangle::~MinigameTriangle() {
 	for (auto &it : _nodes)
-		it.release();
+		it.release(_runtime);
 
 	for (int idx = 0; idx < 2; ++idx)
-		_selectBorders[idx].release(g_runtime);
+		_selectBorders[idx].release(_runtime);
 
 	for (int idx = 0; idx < 6; ++idx)
-		_backSides[idx].release(g_runtime);
+		_backSides[idx].release(_runtime);
 }
 
 void MinigameTriangle::Node::debugInfo() const {
@@ -216,13 +218,13 @@ void MinigameTriangle::releaseNodeBack(Node &node) {
 	if (node._back) {
 		node._back.setState(Node::getBackStateName(false, false, false));
 		for (int type = 0; type < 6; ++type)
-			_backSides[type].releaseObject(node._back, g_runtime);
+			_backSides[type].releaseObject(node._back, _runtime);
 	}
 }
 
 void MinigameTriangle::updateNode(Node &node, int position, int flip, bool quick) {
 	for (auto &fit : node._face)
-		g_runtime->hide(fit);
+		_runtime->hide(fit);
 
 	node._flip = flip;
 
@@ -287,32 +289,32 @@ void MinigameTriangle::endSwapNodes(int pos1, int pos2) {
 	if (node1._number == pos1) { // поставили на свое место
 		assert(!node1._isBack);
 		counted = true;
-		g_runtime->event(EVENT_PUT_RIGHT, node1.obj()->screen_R());
+		_runtime->event(EVENT_PUT_RIGHT, node1.obj()->screen_R());
 	}
 
 	if (node2._number == pos1) { // сняли со своего места
 		assert(node2._isBack);
 		counted = true;
-		g_runtime->event(EVENT_GET_RIGHT, node1.obj()->screen_R());
+		_runtime->event(EVENT_GET_RIGHT, node1.obj()->screen_R());
 	}
 
 	if (node2._number == pos2) { // поставили на свое место
 		assert(!node2._isBack);
 		counted = true;
-		g_runtime->event(EVENT_PUT_RIGHT, node2.obj()->screen_R());
+		_runtime->event(EVENT_PUT_RIGHT, node2.obj()->screen_R());
 	}
 
 	if (node1._number == pos2) { // сняли со своего места
 		assert(node1._isBack);
 		counted = true;
-		g_runtime->event(EVENT_GET_RIGHT, node2.obj()->screen_R());
+		_runtime->event(EVENT_GET_RIGHT, node2.obj()->screen_R());
 	}
 
 	if (!counted) { // просто сделали ход
 		mgVect2i pos = node1.obj()->screen_R();
 		pos += node2.obj()->screen_R();
 		pos /= 2;
-		g_runtime->event(EVENT_TURN, pos);
+		_runtime->event(EVENT_TURN, pos);
 	}
 
 	bool isWin = true;
@@ -438,16 +440,16 @@ void MinigameTriangle::swapNodes(int pos1, int pos2, bool silentQuick) {
 
 void MinigameTriangle::quant(float dt) {
 	if (_selected >= 0)
-		g_runtime->setGameHelpVariant(0);
+		_runtime->setGameHelpVariant(0);
 	else
-		g_runtime->setGameHelpVariant(1);
+		_runtime->setGameHelpVariant(1);
 
 	if (animate(dt))
 		return;
 
 	int mousePos = -1;
 	for (int idx = 0; idx < fieldSize_; ++idx)
-		if (_nodes[idx].hit(g_runtime->mousePosition())) {
+		if (_nodes[idx].hit(_runtime->mousePosition())) {
 			mousePos = idx;
 			break;
 		}
@@ -455,7 +457,7 @@ void MinigameTriangle::quant(float dt) {
 	int startAnimation = -1;
 	int lastSelected = _selected;
 
-	if (g_runtime->mouseLeftPressed()) {
+	if (_runtime->mouseLeftPressed()) {
 		if (mousePos < 0)                       // кликнули мимо - снимаем выделение
 			_selected = -1;
 		else if (_selected < 0)                 // ничего выделено небыло, просто выделяем
@@ -478,10 +480,10 @@ void MinigameTriangle::quant(float dt) {
 				node._border.setState(Node::getBorderStateName(idx == _selected));
 				node._border->set_R(slotCoord(idx));
 				node._border->update_screen_R();
-				g_runtime->setDepth(node._border, _selectDepth);
+				_runtime->setDepth(node._border, _selectDepth);
 			} else if (node._border) {
-				_selectBorders[0].releaseObject(node._border, g_runtime);
-				_selectBorders[1].releaseObject(node._border, g_runtime);
+				_selectBorders[0].releaseObject(node._border, _runtime);
+				_selectBorders[1].releaseObject(node._border, _runtime);
 			}
 		}
 	}
@@ -508,7 +510,7 @@ void MinigameTriangle::quant(float dt) {
 		swapNodes(startAnimation, mousePos, false);
 	}
 
-	if (g_runtime->mouseRightPressed() && mousePos >= 0) {
+	if (_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();
diff --git a/engines/qdengine/minigames/adv/m_triangles.h b/engines/qdengine/minigames/adv/m_triangles.h
index 84072adabe6..3a1396da318 100644
--- a/engines/qdengine/minigames/adv/m_triangles.h
+++ b/engines/qdengine/minigames/adv/m_triangles.h
@@ -47,7 +47,7 @@ class MinigameTriangle : public MinigameInterface {
 	struct Node {
 		Node(int number = -1, int rot = -1);
 
-		void release();
+		void release(MinigameManager *runtime);
 		void debugInfo() const;
 
 		const QDObject &obj() const {
@@ -73,7 +73,7 @@ class MinigameTriangle : public MinigameInterface {
 	typedef Std::vector<Node> Nodes;
 
 public:
-	MinigameTriangle();
+	MinigameTriangle(MinigameManager *runtime);
 	~MinigameTriangle();
 	void quant(float dt);
 
@@ -126,6 +126,8 @@ private:
 	int destination(int num1, int num2) const;
 	/// по номеру слота и углу переворота (с учетом типа игры) возвращает экранные координаты
 	mgVect3f slotCoord(int pos, int angle = 0) const;
+
+	MinigameManager *_runtime;
 };
 
 } // namespace QDEngine


Commit: f00126f3e81946a7b69a4d30f8096631905a4175
    https://github.com/scummvm/scummvm/commit/f00126f3e81946a7b69a4d30f8096631905a4175
Author: Eugene Sandulenko (sev at scummvm.org)
Date: 2024-11-26T16:53:17+01:00

Commit Message:
QDENGINE: Got rid of g_runtime in m_swap minigame

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


diff --git a/engines/qdengine/minigames/adv/m_swap.cpp b/engines/qdengine/minigames/adv/m_swap.cpp
index 91117a1737f..2348ddbace2 100644
--- a/engines/qdengine/minigames/adv/m_swap.cpp
+++ b/engines/qdengine/minigames/adv/m_swap.cpp
@@ -29,7 +29,7 @@ namespace QDEngine {
 typedef Rect<float, mgVect2f> Rectf;
 
 MinigameInterface *createGame() {
-	return new Swap;
+	return new Swap(_runtime);
 }
 
 enum {
@@ -55,7 +55,9 @@ const char *Swap::getStateName(int angle, bool selected) const {
 	return buf;
 }
 
-Swap::Swap() {
+Swap::Swap(MinigameManager *runtime) {
+	_runtime = runtime;
+
 	if (!getParameter("game_size", gameSize_, true) || gameSize_ < 2)
 		return;
 
@@ -64,9 +66,9 @@ Swap::Swap() {
 
 	if ((rotateTimePeriod_ = getParameter("rotate_period", 86400.f)) < 10.f)
 		return;
-	nextRotateTime_ = g_runtime->getTime() + rotateTimePeriod_;
+	nextRotateTime_ = _runtime->getTime() + rotateTimePeriod_;
 
-	const char *name_begin = g_runtime->parameter("obj_name_begin", "obj_");
+	const char *name_begin = _runtime->parameter("obj_name_begin", "obj_");
 
 	char buf[128];
 	buf[127] = 0;
@@ -77,7 +79,7 @@ Swap::Swap() {
 		_snprintf(buf, 127, "%s%02d", name_begin, idx + 1);
 
 		Node node(idx);
-		node.obj = g_runtime->getObject(buf);
+		node.obj = _runtime->getObject(buf);
 		node.angle = 0;
 		node.obj.setState(getStateName(node.angle, false));
 		nodes_.push_back(node);
@@ -85,28 +87,28 @@ Swap::Swap() {
 		gameData.write(node.obj->R());
 	}
 
-	if (!g_runtime->processGameData(gameData))
+	if (!_runtime->processGameData(gameData))
 		return;
 
 	positions_.resize(gameSize_);
 	for (int idx = 0; idx < gameSize_; ++idx)
 		gameData.read(positions_[idx]);
 
-	size_ = getParameter("element_size", g_runtime->getSize(nodes_[0].obj));
+	size_ = getParameter("element_size", _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 (g_runtime->debugMode()) {
+	if (_runtime->debugMode()) {
 		last1_ = 0;
 		last2_ = 1;
 		rotate(last1_, last2_, false);
 	} else
 		for (int cnt = 0; cnt < 50; ++cnt) {
-			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);
+			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);
 		}
 
 
@@ -117,30 +119,30 @@ Swap::Swap() {
 Swap::~Swap() {
 	Nodes::iterator it;
 	FOR_EACH(nodes_, it)
-	g_runtime->release(it->obj);
+	_runtime->release(it->obj);
 
 }
 
 void Swap::quant(float dt) {
 	if (pickedItem_ >= 0)
-		g_runtime->setGameHelpVariant(1);
+		_runtime->setGameHelpVariant(1);
 	else if (last1_ >= 0)
-		g_runtime->setGameHelpVariant(2);
+		_runtime->setGameHelpVariant(2);
 	else
-		g_runtime->setGameHelpVariant(0);
+		_runtime->setGameHelpVariant(0);
 
-	if (g_runtime->getTime() > nextRotateTime_) {
-		int item1 = g_runtime->rnd(0, gameSize_ - 1);
-		int item2 = g_runtime->rnd(0, gameSize_ - 1);
+	if (_runtime->getTime() > nextRotateTime_) {
+		int item1 = _runtime->rnd(0, gameSize_ - 1);
+		int item2 = _runtime->rnd(0, gameSize_ - 1);
 		if (item1 != last1_ && item1 != last2_ && item1 != pickedItem_ && item2 != last1_ && item2 != last2_ && item2 != pickedItem_) {
-			nextRotateTime_ = g_runtime->getTime() + rotateTimePeriod_;
+			nextRotateTime_ = _runtime->getTime() + rotateTimePeriod_;
 			rotate(item1, item2, false, true);
-			g_runtime->event(EVENT_AUTO_ROTATE, mgVect2f(400, 300));
+			_runtime->event(EVENT_AUTO_ROTATE, mgVect2f(400, 300));
 			return;
 		}
 	}
 
-	mgVect2f mouse = g_runtime->mousePosition();
+	mgVect2f mouse = _runtime->mousePosition();
 
 	int hovPlace = -1;  // Номер места которое сейчас под мышкой
 	if (pickedItem_ == -1) {
@@ -154,21 +156,21 @@ void Swap::quant(float dt) {
 	if (hovPlace == -1)
 		for (int idx = 0; idx < gameSize_; ++idx) {
 			Rectf rect(size_ * 0.9f);
-			rect.center(g_runtime->world2game(position(idx)));
+			rect.center(_runtime->world2game(position(idx)));
 			if (rect.point_inside(mouse)) {
 				hovPlace = idx;
 				break;
 			}
 		}
 
-	if (g_runtime->mouseLeftPressed()) {
+	if (_runtime->mouseLeftPressed()) {
 		if (hovPlace >= 0) { // клик по полю
 			if (pickedItem_ == -1) { // мышь пустая, берем
 				deactivate();
-				g_runtime->event(EVENT_GET, mouse);
+				_runtime->event(EVENT_GET, mouse);
 				pickedItem_ = hovPlace;
 			} else if (pickedItem_ == hovPlace) { // вернуть на место
-				g_runtime->event(EVENT_RETURN, mouse);
+				_runtime->event(EVENT_RETURN, mouse);
 				put(pickedItem_, false);
 				pickedItem_ = -1;
 			} else { // поменять местами
@@ -179,19 +181,19 @@ void Swap::quant(float dt) {
 			}
 		} else { // пустой клик мимо игрового поля
 			deactivate();
-			g_runtime->event(EVENT_CLICK, mouse);
+			_runtime->event(EVENT_CLICK, mouse);
 		}
-	} else if (g_runtime->mouseRightPressed()) {
+	} else if (_runtime->mouseRightPressed()) {
 		if (pickedItem_ >= 0) // если на мыши фрагмент ничего не делаем
-			g_runtime->event(EVENT_CLICK, mouse);
+			_runtime->event(EVENT_CLICK, mouse);
 		else if (hovPlace == last1_ || hovPlace == last2_) // клик по выделенным
 			rotate(last1_, last2_, false);
 		else // пустой клик мимо активного места
-			g_runtime->event(EVENT_CLICK, mouse);
+			_runtime->event(EVENT_CLICK, mouse);
 	}
 
 	if (pickedItem_ >= 0)
-		nodes_[pickedItem_].obj->set_R(g_runtime->game2world(mouse, -5000));
+		nodes_[pickedItem_].obj->set_R(_runtime->game2world(mouse, -5000));
 
 	int idx = 0;
 	for (; idx < gameSize_; ++idx)
@@ -238,11 +240,11 @@ void Swap::swap(int item1, int item2, bool silent) {
 	bool res = false;
 	if (!silent) {
 		if (testPlace(item1)) { // сняли со своего места
-			g_runtime->event(EVENT_GET_RIGHT, g_runtime->world2game(position(item1)));
+			_runtime->event(EVENT_GET_RIGHT, _runtime->world2game(position(item1)));
 			res = true;
 		}
 		if (testPlace(item2)) { // сняли со своего места
-			g_runtime->event(EVENT_GET_RIGHT, g_runtime->world2game(position(item2)));
+			_runtime->event(EVENT_GET_RIGHT, _runtime->world2game(position(item2)));
 			res = true;
 		}
 	}
@@ -253,15 +255,15 @@ void Swap::swap(int item1, int item2, bool silent) {
 
 	if (!silent) {
 		if (testPlace(item1)) { // оказалась при обмене на своем месте
-			g_runtime->event(EVENT_PUT_RIGHT, g_runtime->world2game(position(item1)));
+			_runtime->event(EVENT_PUT_RIGHT, _runtime->world2game(position(item1)));
 			res = true;
 		}
 		if (testPlace(item2)) { // положили на свое свое место
-			g_runtime->event(EVENT_PUT_RIGHT, g_runtime->world2game(position(item2)));
+			_runtime->event(EVENT_PUT_RIGHT, _runtime->world2game(position(item2)));
 			res = true;
 		}
 		if (!res) // просто обменяли
-			g_runtime->event(EVENT_SWAP, g_runtime->mousePosition());
+			_runtime->event(EVENT_SWAP, _runtime->mousePosition());
 	}
 }
 
@@ -271,9 +273,9 @@ void Swap::rotate(int item1, int item2, bool silent, bool avto) {
 
 	if (!silent) {
 		if (testPlace(item1)) // сняли со своего места
-			g_runtime->event(EVENT_GET_RIGHT, g_runtime->world2game(position(item1)));
+			_runtime->event(EVENT_GET_RIGHT, _runtime->world2game(position(item1)));
 		if (testPlace(item2)) // сняли со своего места
-			g_runtime->event(EVENT_GET_RIGHT, g_runtime->world2game(position(item2)));
+			_runtime->event(EVENT_GET_RIGHT, _runtime->world2game(position(item2)));
 	}
 
 	nodes_[item1].angle = (nodes_[item1].angle + 1) % angles_;
@@ -283,10 +285,10 @@ void Swap::rotate(int item1, int item2, bool silent, bool avto) {
 
 	if (!silent) {
 		if (testPlace(item1)) // оказалась при обмене на своем месте
-			g_runtime->event(EVENT_PUT_RIGHT, g_runtime->world2game(position(item1)));
+			_runtime->event(EVENT_PUT_RIGHT, _runtime->world2game(position(item1)));
 		if (testPlace(item2)) // положили на свое свое место
-			g_runtime->event(EVENT_PUT_RIGHT, g_runtime->world2game(position(item2)));
-		g_runtime->event(EVENT_ROTATE, g_runtime->mousePosition());
+			_runtime->event(EVENT_PUT_RIGHT, _runtime->world2game(position(item2)));
+		_runtime->event(EVENT_ROTATE, _runtime->mousePosition());
 	}
 }
 
diff --git a/engines/qdengine/minigames/adv/m_swap.h b/engines/qdengine/minigames/adv/m_swap.h
index 7c8642ed473..998ee9d671c 100644
--- a/engines/qdengine/minigames/adv/m_swap.h
+++ b/engines/qdengine/minigames/adv/m_swap.h
@@ -28,7 +28,7 @@ namespace QDEngine {
 
 class Swap : public MinigameInterface {
 public:
-	Swap();
+	Swap(MinigameManager *runtime);
 	~Swap();
 
 	void quant(float dt);
@@ -71,6 +71,7 @@ private:
 	// мировые координаты слота на поле
 	const mgVect3f &position(int num) const;
 
+	MinigameManager *_runtime;
 };
 
 } // namespace QDEngine


Commit: 13cd003eae5401997c67dcbb4ede8c7cb80a45ec
    https://github.com/scummvm/scummvm/commit/13cd003eae5401997c67dcbb4ede8c7cb80a45ec
Author: Eugene Sandulenko (sev at scummvm.org)
Date: 2024-11-26T17:01:43+01:00

Commit Message:
QDENGINE: Plugged in m_swap minigame

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


diff --git a/engines/qdengine/minigames/adv/m_swap.cpp b/engines/qdengine/minigames/adv/m_swap.cpp
index 2348ddbace2..f776724b413 100644
--- a/engines/qdengine/minigames/adv/m_swap.cpp
+++ b/engines/qdengine/minigames/adv/m_swap.cpp
@@ -19,6 +19,9 @@
  *
  */
 
+#include "common/debug.h"
+
+#include "qdengine/qdengine.h"
 #include "qdengine/minigames/adv/common.h"
 #include "qdengine/minigames/adv/m_swap.h"
 #include "qdengine/minigames/adv/RunTime.h"
@@ -29,7 +32,7 @@ namespace QDEngine {
 typedef Rect<float, mgVect2f> Rectf;
 
 MinigameInterface *createGame() {
-	return new Swap(_runtime);
+	return new Swap(g_runtime);
 }
 
 enum {
@@ -49,9 +52,9 @@ const char *Swap::getStateName(int angle, bool selected) const {
 	static char buf[32];
 	buf[31] = 0;
 
-	xassert(angle >= 0 && angle < angles_);
+	assert(angle >= 0 && angle < angles_);
 
-	_snprintf(buf, 31, "%02d%s", angle + 1, selected ? selected_suf : "");
+	snprintf(buf, 31, "%02d%s", angle + 1, selected ? selected_suf : "");
 	return buf;
 }
 
@@ -70,16 +73,15 @@ Swap::Swap(MinigameManager *runtime) {
 
 	const char *name_begin = _runtime->parameter("obj_name_begin", "obj_");
 
-	char buf[128];
-	buf[127] = 0;
-
+	warning("STUB: Swap::Swap()");
+#if 0
 	XBuffer gameData;
 
 	for (int idx = 0; idx < gameSize_; ++idx) {
-		_snprintf(buf, 127, "%s%02d", name_begin, idx + 1);
+		Common::String buf = Common::String::format("%s%02d", name_begin, idx + 1);
 
 		Node node(idx);
-		node.obj = _runtime->getObject(buf);
+		node.obj = _runtime->getObject(buf.c_str());
 		node.angle = 0;
 		node.obj.setState(getStateName(node.angle, false));
 		nodes_.push_back(node);
@@ -93,9 +95,10 @@ Swap::Swap(MinigameManager *runtime) {
 	positions_.resize(gameSize_);
 	for (int idx = 0; idx < gameSize_; ++idx)
 		gameData.read(positions_[idx]);
+#endif
 
 	size_ = getParameter("element_size", _runtime->getSize(nodes_[0].obj));
-	xassert(size_.x > 0.f && size_.y > 0.f && size_.x < 500.f && size_.y < 500.f);
+	assert(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;
@@ -117,9 +120,8 @@ Swap::Swap(MinigameManager *runtime) {
 }
 
 Swap::~Swap() {
-	Nodes::iterator it;
-	FOR_EACH(nodes_, it)
-	_runtime->release(it->obj);
+	for (auto &it : nodes_)
+		_runtime->release(it.obj);
 
 }
 
@@ -146,12 +148,11 @@ void Swap::quant(float dt) {
 
 	int hovPlace = -1;  // Номер места которое сейчас под мышкой
 	if (pickedItem_ == -1) {
-		Nodes::iterator it;
-		FOR_EACH(nodes_, it)
-		if (it->obj.hit(mouse)) {
-			hovPlace = distance(nodes_.begin(), it);
-			break;
-		}
+		for (auto &it : nodes_)
+			if (it.obj.hit(mouse)) {
+				hovPlace = Common::distance(nodes_.begin(), &it);
+				break;
+			}
 	}
 	if (hovPlace == -1)
 		for (int idx = 0; idx < gameSize_; ++idx) {
@@ -207,12 +208,12 @@ void Swap::quant(float dt) {
 }
 
 const mgVect3f &Swap::position(int num) const {
-	xassert(num >= 0 && num < positions_.size());
+	assert(num >= 0 && num < positions_.size());
 	return positions_[num];
 }
 
 void Swap::put(int item, bool hl) {
-	xassert(item >= 0 && item < nodes_.size());
+	assert(item >= 0 && item < nodes_.size());
 	nodes_[item].obj->set_R(position(item));
 	nodes_[item].obj.setState(getStateName(nodes_[item].angle, hl));
 
@@ -220,7 +221,7 @@ void Swap::put(int item, bool hl) {
 
 void Swap::deactivate() {
 	if (last1_ >= 0) {
-		xassert(last2_ >= 0);
+		assert(last2_ >= 0);
 		put(last1_, false);
 		put(last2_, false);
 	}
@@ -229,13 +230,13 @@ void Swap::deactivate() {
 }
 
 bool Swap::testPlace(int item) const {
-	xassert(item >= 0 && item < nodes_.size());
+	assert(item >= 0 && item < nodes_.size());
 	return nodes_[item].home == item && nodes_[item].angle == 0;
 }
 
 void Swap::swap(int item1, int item2, bool silent) {
-	xassert(item1 >= 0 && item1 < nodes_.size());
-	xassert(item2 >= 0 && item2 < nodes_.size());
+	assert(item1 >= 0 && item1 < nodes_.size());
+	assert(item2 >= 0 && item2 < nodes_.size());
 
 	bool res = false;
 	if (!silent) {
@@ -268,8 +269,8 @@ void Swap::swap(int item1, int item2, bool silent) {
 }
 
 void Swap::rotate(int item1, int item2, bool silent, bool avto) {
-	xassert(item1 >= 0 && item1 < nodes_.size());
-	xassert(item2 >= 0 && item2 < nodes_.size());
+	assert(item1 >= 0 && item1 < nodes_.size());
+	assert(item2 >= 0 && item2 < nodes_.size());
 
 	if (!silent) {
 		if (testPlace(item1)) // сняли со своего места
diff --git a/engines/qdengine/minigames/adv/m_swap.h b/engines/qdengine/minigames/adv/m_swap.h
index 998ee9d671c..591dc3222dd 100644
--- a/engines/qdengine/minigames/adv/m_swap.h
+++ b/engines/qdengine/minigames/adv/m_swap.h
@@ -47,7 +47,7 @@ private:
 		int angle;
 		int home;
 	};
-	typedef vector<Node> Nodes;
+	typedef Std::vector<Node> Nodes;
 	Nodes nodes_;
 
 	// Индекс фрагмента на мыши
diff --git a/engines/qdengine/module.mk b/engines/qdengine/module.mk
index 7f746ed4b50..d405565e453 100644
--- a/engines/qdengine/module.mk
+++ b/engines/qdengine/module.mk
@@ -15,6 +15,7 @@ MODULE_OBJS = \
 	minigames/adv/TextManager.o \
 	minigames/adv/m_puzzle.o \
 	minigames/adv/m_scores.o \
+	minigames/adv/m_swap.o \
 	minigames/adv/m_triangles.o \
 	parser/qdscr_parser.o \
 	parser/xml_parser.o \

More information about the Scummvm-git-logs mailing list