[Scummvm-git-logs] scummvm master -> a22ce387e82d8715df87506023bc099ffd178c1b

sev- noreply at scummvm.org
Fri Nov 29 17:04:57 UTC 2024 

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

Summary:
30d08ab7cc QDENGINE: Class variable renames in adv minigames
322f9e34ba QDENGINE: Remove more g_runtime usage in adv minigames
8a9c76e9c0 QDENGINE: Remove g_runtime usage in m_scores minigame
3a9f2d5016 QDENGINE: Remove g_runtime usage in m_puzzle minigame
d6265e63bd QDENGINE: Removed g_engine usage in m_karaoke minigame
5bdd694b89 QDENGINE: More renames in adv minigames
a22ce387e8 QDENGINE: Renames in m_scores minigame


Commit: 30d08ab7ccf178bc15252486f40e53c40477f8ff
    https://github.com/scummvm/scummvm/commit/30d08ab7ccf178bc15252486f40e53c40477f8ff
Author: Eugene Sandulenko (sev at scummvm.org)
Date: 2024-11-29T18:04:35+01:00

Commit Message:
QDENGINE: Class variable renames in adv minigames

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


diff --git a/engines/qdengine/minigames/adv/MinigameInterface.h b/engines/qdengine/minigames/adv/MinigameInterface.h
index f3608f74e09..00f33535929 100644
--- a/engines/qdengine/minigames/adv/MinigameInterface.h
+++ b/engines/qdengine/minigames/adv/MinigameInterface.h
@@ -33,20 +33,20 @@ public:
 		GAME_LOST
 	};
 
-	MinigameInterface() : state_(NOT_INITED) {}
+	MinigameInterface() : _state(NOT_INITED) {}
 	virtual ~MinigameInterface() {}
 
 	virtual void quant(float dt) = 0;
 
 	void setState(StateType state) {
-		state_ = state;
+		_state = state;
 	}
 	StateType state() const {
-		return state_;
+		return _state;
 	}
 
 private:
-	StateType state_;
+	StateType _state;
 };
 
 } // namespace QDEngine
diff --git a/engines/qdengine/minigames/adv/m_swap.cpp b/engines/qdengine/minigames/adv/m_swap.cpp
index c4b10b50d33..99926092388 100644
--- a/engines/qdengine/minigames/adv/m_swap.cpp
+++ b/engines/qdengine/minigames/adv/m_swap.cpp
@@ -52,7 +52,7 @@ const char *Swap::getStateName(int angle, bool selected) const {
 	static char buf[32];
 	buf[31] = 0;
 
-	assert(angle >= 0 && angle < angles_);
+	assert(angle >= 0 && angle < _angles);
 
 	snprintf(buf, 31, "%02d%s", angle + 1, selected ? selected_suf : "");
 	return buf;
@@ -61,15 +61,15 @@ const char *Swap::getStateName(int angle, bool selected) const {
 Swap::Swap(MinigameManager *runtime) {
 	_runtime = runtime;
 
-	if (!getParameter("game_size", gameSize_, true) || gameSize_ < 2)
+	if (!getParameter("game_size", _gameSize, true) || _gameSize < 2)
 		return;
 
-	if ((angles_ = getParameter("angles", 4)) < 1)
+	if ((_angles = getParameter("angles", 4)) < 1)
 		return;
 
-	if ((rotateTimePeriod_ = getParameter("rotate_period", 86400.f)) < 10.f)
+	if ((_rotateTimePeriod = getParameter("rotate_period", 86400.f)) < 10.f)
 		return;
-	nextRotateTime_ = _runtime->getTime() + rotateTimePeriod_;
+	_nextRotateTime = _runtime->getTime() + _rotateTimePeriod;
 
 	/*const char *name_begin = */_runtime->parameter("obj_name_begin", "obj_");
 
@@ -77,14 +77,14 @@ Swap::Swap(MinigameManager *runtime) {
 #if 0
 	XBuffer gameData;
 
-	for (int idx = 0; idx < gameSize_; ++idx) {
+	for (int idx = 0; idx < _gameSize; ++idx) {
 		Common::String buf = Common::String::format("%s%02d", name_begin, idx + 1);
 
 		Node node(idx);
 		node.obj = _runtime->getObject(buf.c_str());
 		node.angle = 0;
 		node.obj.setState(getStateName(node.angle, false));
-		nodes_.push_back(node);
+		_nodes.push_back(node);
 
 		gameData.write(node.obj->R());
 	}
@@ -92,26 +92,26 @@ Swap::Swap(MinigameManager *runtime) {
 	if (!_runtime->processGameData(gameData))
 		return;
 
-	positions_.resize(gameSize_);
-	for (int idx = 0; idx < gameSize_; ++idx)
-		gameData.read(positions_[idx]);
+	_positions.resize(_gameSize);
+	for (int idx = 0; idx < _gameSize; ++idx)
+		gameData.read(_positions[idx]);
 #endif
 
-	size_ = getParameter("element_size", _runtime->getSize(nodes_[0].obj));
-	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);
+	_size = getParameter("element_size", _runtime->getSize(_nodes[0].obj));
+	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;
-	last1_ = last2_ = -1;
+	_pickedItem = -1;
+	_last1 = _last2 = -1;
 
 	if (_runtime->debugMode()) {
-		last1_ = 0;
-		last2_ = 1;
-		rotate(last1_, last2_, false);
+		_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(_runtime->rnd(0, _gameSize - 1), _runtime->rnd(0, _gameSize - 1), true, true);
+			swap(_runtime->rnd(0, _gameSize - 1), _runtime->rnd(0, _gameSize - 1), true);
 		}
 
 
@@ -120,24 +120,24 @@ Swap::Swap(MinigameManager *runtime) {
 }
 
 Swap::~Swap() {
-	for (auto &it : nodes_)
+	for (auto &it : _nodes)
 		_runtime->release(it.obj);
 
 }
 
 void Swap::quant(float dt) {
-	if (pickedItem_ >= 0)
+	if (_pickedItem >= 0)
 		_runtime->setGameHelpVariant(1);
-	else if (last1_ >= 0)
+	else if (_last1 >= 0)
 		_runtime->setGameHelpVariant(2);
 	else
 		_runtime->setGameHelpVariant(0);
 
-	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_ = _runtime->getTime() + rotateTimePeriod_;
+	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 = _runtime->getTime() + _rotateTimePeriod;
 			rotate(item1, item2, false, true);
 			_runtime->event(EVENT_AUTO_ROTATE, mgVect2f(400, 300));
 			return;
@@ -147,16 +147,16 @@ void Swap::quant(float dt) {
 	mgVect2f mouse = _runtime->mousePosition();
 
 	int hovPlace = -1;  // Номер места которое сейчас под мышкой
-	if (pickedItem_ == -1) {
-		for (auto &it : nodes_)
+	if (_pickedItem == -1) {
+		for (auto &it : _nodes)
 			if (it.obj.hit(mouse)) {
-				hovPlace = Common::distance(nodes_.begin(), &it);
+				hovPlace = Common::distance(_nodes.begin(), &it);
 				break;
 			}
 	}
 	if (hovPlace == -1)
-		for (int idx = 0; idx < gameSize_; ++idx) {
-			Rectf rect(size_ * 0.9f);
+		for (int idx = 0; idx < _gameSize; ++idx) {
+			Rectf rect(_size * 0.9f);
 			rect.center(_runtime->world2game(position(idx)));
 			if (rect.point_inside(mouse)) {
 				hovPlace = idx;
@@ -166,77 +166,77 @@ void Swap::quant(float dt) {
 
 	if (_runtime->mouseLeftPressed()) {
 		if (hovPlace >= 0) { // клик по полю
-			if (pickedItem_ == -1) { // мышь пустая, берем
+			if (_pickedItem == -1) { // мышь пустая, берем
 				deactivate();
 				_runtime->event(EVENT_GET, mouse);
-				pickedItem_ = hovPlace;
-			} else if (pickedItem_ == hovPlace) { // вернуть на место
+				_pickedItem = hovPlace;
+			} else if (_pickedItem == hovPlace) { // вернуть на место
 				_runtime->event(EVENT_RETURN, mouse);
-				put(pickedItem_, false);
-				pickedItem_ = -1;
+				put(_pickedItem, false);
+				_pickedItem = -1;
 			} else { // поменять местами
-				last1_ = pickedItem_;
-				last2_ = hovPlace;
-				swap(last1_, last2_, false);
-				pickedItem_ = -1;
+				_last1 = _pickedItem;
+				_last2 = hovPlace;
+				swap(_last1, _last2, false);
+				_pickedItem = -1;
 			}
 		} else { // пустой клик мимо игрового поля
 			deactivate();
 			_runtime->event(EVENT_CLICK, mouse);
 		}
 	} else if (_runtime->mouseRightPressed()) {
-		if (pickedItem_ >= 0) // если на мыши фрагмент ничего не делаем
+		if (_pickedItem >= 0) // если на мыши фрагмент ничего не делаем
 			_runtime->event(EVENT_CLICK, mouse);
-		else if (hovPlace == last1_ || hovPlace == last2_) // клик по выделенным
-			rotate(last1_, last2_, false);
+		else if (hovPlace == _last1 || hovPlace == _last2) // клик по выделенным
+			rotate(_last1, _last2, false);
 		else // пустой клик мимо активного места
 			_runtime->event(EVENT_CLICK, mouse);
 	}
 
-	if (pickedItem_ >= 0)
-		nodes_[pickedItem_].obj->set_R(_runtime->game2world(mouse, -5000));
+	if (_pickedItem >= 0)
+		_nodes[_pickedItem].obj->set_R(_runtime->game2world(mouse, -5000));
 
 	int idx = 0;
-	for (; idx < gameSize_; ++idx)
+	for (; idx < _gameSize; ++idx)
 		if (!testPlace(idx))
 			break;
 
-	if (idx == (int)nodes_.size()) {
+	if (idx == (int)_nodes.size()) {
 		deactivate();
 		setState(MinigameInterface::GAME_WIN);
 	}
 }
 
 const mgVect3f &Swap::position(int num) const {
-	assert(num >= 0 && num < (int)positions_.size());
-	return positions_[num];
+	assert(num >= 0 && num < (int)_positions.size());
+	return _positions[num];
 }
 
 void Swap::put(int item, bool hl) {
-	assert(item >= 0 && item < (int)nodes_.size());
-	nodes_[item].obj->set_R(position(item));
-	nodes_[item].obj.setState(getStateName(nodes_[item].angle, hl));
+	assert(item >= 0 && item < (int)_nodes.size());
+	_nodes[item].obj->set_R(position(item));
+	_nodes[item].obj.setState(getStateName(_nodes[item].angle, hl));
 
 }
 
 void Swap::deactivate() {
-	if (last1_ >= 0) {
-		assert(last2_ >= 0);
-		put(last1_, false);
-		put(last2_, false);
+	if (_last1 >= 0) {
+		assert(_last2 >= 0);
+		put(_last1, false);
+		put(_last2, false);
 	}
-	last1_ = -1;
-	last2_ = -1;
+	_last1 = -1;
+	_last2 = -1;
 }
 
 bool Swap::testPlace(int item) const {
-	assert(item >= 0 && item < (int)nodes_.size());
-	return nodes_[item].home == item && nodes_[item].angle == 0;
+	assert(item >= 0 && item < (int)_nodes.size());
+	return _nodes[item].home == item && _nodes[item].angle == 0;
 }
 
 void Swap::swap(int item1, int item2, bool silent) {
-	assert(item1 >= 0 && item1 < (int)nodes_.size());
-	assert(item2 >= 0 && item2 < (int)nodes_.size());
+	assert(item1 >= 0 && item1 < (int)_nodes.size());
+	assert(item2 >= 0 && item2 < (int)_nodes.size());
 
 	bool res = false;
 	if (!silent) {
@@ -250,7 +250,7 @@ void Swap::swap(int item1, int item2, bool silent) {
 		}
 	}
 
-	SWAP(nodes_[item1], nodes_[item2]);
+	SWAP(_nodes[item1], _nodes[item2]);
 	put(item1, !silent);
 	put(item2, !silent);
 
@@ -269,8 +269,8 @@ void Swap::swap(int item1, int item2, bool silent) {
 }
 
 void Swap::rotate(int item1, int item2, bool silent, bool avto) {
-	assert(item1 >= 0 && item1 < (int)nodes_.size());
-	assert(item2 >= 0 && item2 < (int)nodes_.size());
+	assert(item1 >= 0 && item1 < (int)_nodes.size());
+	assert(item2 >= 0 && item2 < (int)_nodes.size());
 
 	if (!silent) {
 		if (testPlace(item1)) // сняли со своего места
@@ -279,8 +279,8 @@ void Swap::rotate(int item1, int item2, bool silent, bool avto) {
 			_runtime->event(EVENT_GET_RIGHT, _runtime->world2game(position(item2)));
 	}
 
-	nodes_[item1].angle = (nodes_[item1].angle + 1) % angles_;
-	nodes_[item2].angle = (nodes_[item2].angle + 1) % angles_;
+	_nodes[item1].angle = (_nodes[item1].angle + 1) % _angles;
+	_nodes[item2].angle = (_nodes[item2].angle + 1) % _angles;
 	put(item1, !avto);
 	put(item2, !avto);
 
diff --git a/engines/qdengine/minigames/adv/m_swap.h b/engines/qdengine/minigames/adv/m_swap.h
index 591dc3222dd..79ad429c7cc 100644
--- a/engines/qdengine/minigames/adv/m_swap.h
+++ b/engines/qdengine/minigames/adv/m_swap.h
@@ -33,13 +33,13 @@ public:
 
 	void quant(float dt);
 private:
-	int gameSize_;
-	int angles_;
+	int _gameSize;
+	int _angles;
 
-	float rotateTimePeriod_;
-	float nextRotateTime_;
+	float _rotateTimePeriod;
+	float _nextRotateTime;
 
-	mgVect2f size_;
+	mgVect2f _size;
 
 	struct Node {
 		Node(int idx = -1) : home(idx), angle(0) {}
@@ -48,14 +48,14 @@ private:
 		int home;
 	};
 	typedef Std::vector<Node> Nodes;
-	Nodes nodes_;
+	Nodes _nodes;
 
 	// Индекс фрагмента на мыши
-	int pickedItem_;
+	int _pickedItem;
 	// активные фрагменты после обмена
-	int last1_, last2_;
+	int _last1, _last2;
 
-	Coords positions_;
+	Coords _positions;
 
 	const char *getStateName(int angle, bool selected) const;
 	// поменять местами, если было снятие или укладка на/с правильного места, то true
diff --git a/engines/qdengine/minigames/adv/m_triangles.cpp b/engines/qdengine/minigames/adv/m_triangles.cpp
index 260a5dad0ec..f842c2d1b01 100644
--- a/engines/qdengine/minigames/adv/m_triangles.cpp
+++ b/engines/qdengine/minigames/adv/m_triangles.cpp
@@ -153,7 +153,7 @@ MinigameTriangle::MinigameTriangle(MinigameManager *runtime) {
 	_hovered = -1;
 
 	_animationState = NO_ANIMATION;
-	animatedNodes_[0] = animatedNodes_[1] = -1;
+	_animatedNodes[0] = _animatedNodes[1] = -1;
 	_animationTimer = 0.f;
 
 	if (!_runtime->debugMode())
@@ -261,8 +261,8 @@ void MinigameTriangle::beginSwapNodes(int pos1, int pos2) {
 	_animationState = FIRST_PHASE;
 	_animationTimer = _animationTime;
 
-	animatedNodes_[0] = pos1;
-	animatedNodes_[1] = pos2;
+	_animatedNodes[0] = pos1;
+	_animatedNodes[1] = pos2;
 
 	Node &node1 = _nodes[pos1];
 	Node &node2 = _nodes[pos2];
@@ -341,13 +341,13 @@ bool MinigameTriangle::animate(float dt) {
 	if (_animationTimer > 0)
 		return true;
 
-	Node &node1 = _nodes[animatedNodes_[0]];
-	Node &node2 = _nodes[animatedNodes_[1]];
+	Node &node1 = _nodes[_animatedNodes[0]];
+	Node &node2 = _nodes[_animatedNodes[1]];
 
 	switch (_animationState) {
 	case FIRST_PHASE: {
-		node1._rotation = getRotate(animatedNodes_[0], animatedNodes_[1]);
-		node2._rotation = getRotate(animatedNodes_[1], animatedNodes_[0]);
+		node1._rotation = getRotate(_animatedNodes[0], _animatedNodes[1]);
+		node2._rotation = getRotate(_animatedNodes[1], _animatedNodes[0]);
 
 		node1._isBack = !node1._isBack;
 		node2._isBack = !node2._isBack;
@@ -361,13 +361,13 @@ bool MinigameTriangle::animate(float dt) {
 		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);
+		updateNode(node1, _animatedNodes[1], destination(_animatedNodes[0], _animatedNodes[1]), true);
+		updateNode(node2, _animatedNodes[0], destination(_animatedNodes[1], _animatedNodes[0]), true);
 
 		_animationTimer = 0.f;
 		_animationState = SECOND_PHASE;
 
-		debugC(5, kDebugMinigames, ">>>>>>>>>>>>>>>>>>>>>>>>>>> change %d <> %d, 2nd phase 1 <<<<<<<<<<<<<<<<<<<<<<<<<<<<", animatedNodes_[0], animatedNodes_[1]);
+		debugC(5, kDebugMinigames, ">>>>>>>>>>>>>>>>>>>>>>>>>>> change %d <> %d, 2nd phase 1 <<<<<<<<<<<<<<<<<<<<<<<<<<<<", _animatedNodes[0], _animatedNodes[1]);
 		node1.debugInfo();
 		node2.debugInfo();
 
@@ -377,15 +377,15 @@ bool MinigameTriangle::animate(float dt) {
 		node1._animated = false;
 		node2._animated = false;
 
-		updateNode(node1, animatedNodes_[1], destination(animatedNodes_[0], animatedNodes_[1]));
-		updateNode(node2, animatedNodes_[0], destination(animatedNodes_[1], animatedNodes_[0]));
+		updateNode(node1, _animatedNodes[1], destination(_animatedNodes[0], _animatedNodes[1]));
+		updateNode(node2, _animatedNodes[0], destination(_animatedNodes[1], _animatedNodes[0]));
 
 		SWAP(node1, node2);
 
 		_animationTimer = _animationTime;
 		_animationState = FIRD_PHASE;
 
-		debugC(5, kDebugMinigames, ">>>>>>>>>>>>>>>>>>>>>>>>>>> change %d <> %d, 2nd phase 2 <<<<<<<<<<<<<<<<<<<<<<<<<<<<", animatedNodes_[0], animatedNodes_[1]);
+		debugC(5, kDebugMinigames, ">>>>>>>>>>>>>>>>>>>>>>>>>>> change %d <> %d, 2nd phase 2 <<<<<<<<<<<<<<<<<<<<<<<<<<<<", _animatedNodes[0], _animatedNodes[1]);
 		node2.debugInfo();
 		node1.debugInfo();
 
@@ -398,14 +398,14 @@ bool MinigameTriangle::animate(float dt) {
 		releaseNodeBack(node1);
 		releaseNodeBack(node2);
 
-		updateNode(node1, animatedNodes_[0]);
-		updateNode(node2, animatedNodes_[1]);
+		updateNode(node1, _animatedNodes[0]);
+		updateNode(node2, _animatedNodes[1]);
 
-		endSwapNodes(animatedNodes_[0], animatedNodes_[1]);
-		debugC(5, kDebugMinigames, "^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ change %d <> %d, finished ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^", animatedNodes_[0], animatedNodes_[1]);
+		endSwapNodes(_animatedNodes[0], _animatedNodes[1]);
+		debugC(5, kDebugMinigames, "^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ change %d <> %d, finished ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^", _animatedNodes[0], _animatedNodes[1]);
 
-		animatedNodes_[0] = -1;
-		animatedNodes_[1] = -1;
+		_animatedNodes[0] = -1;
+		_animatedNodes[1] = -1;
 
 		return true;
 
diff --git a/engines/qdengine/minigames/adv/m_triangles.h b/engines/qdengine/minigames/adv/m_triangles.h
index 149ca0ab10e..491e66da720 100644
--- a/engines/qdengine/minigames/adv/m_triangles.h
+++ b/engines/qdengine/minigames/adv/m_triangles.h
@@ -92,7 +92,7 @@ private:
 	int _hovered = 0;
 
 	AnimationState _animationState = NO_ANIMATION;
-	int animatedNodes_[2] =  { 0 };
+	int _animatedNodes[2] =  { 0 };
 	float _animationTime = 0.0;
 	float _animationTimer = 0.0;
 


Commit: 322f9e34bae7ba635a27c00559cce93d35409ac7
    https://github.com/scummvm/scummvm/commit/322f9e34bae7ba635a27c00559cce93d35409ac7
Author: Eugene Sandulenko (sev at scummvm.org)
Date: 2024-11-29T18:04:35+01:00

Commit Message:
QDENGINE: Remove more g_runtime usage in adv minigames

Changed paths:
    engines/qdengine/minigames/adv/RunTime.cpp
    engines/qdengine/minigames/adv/RunTime.h
    engines/qdengine/minigames/adv/m_karaoke.cpp
    engines/qdengine/minigames/adv/m_puzzle.cpp
    engines/qdengine/minigames/adv/m_scores.cpp
    engines/qdengine/minigames/adv/m_swap.cpp
    engines/qdengine/minigames/adv/m_triangles.cpp
    engines/qdengine/minigames/adv/m_triangles.h


diff --git a/engines/qdengine/minigames/adv/RunTime.cpp b/engines/qdengine/minigames/adv/RunTime.cpp
index 22d0a8c0347..5162c14d05a 100644
--- a/engines/qdengine/minigames/adv/RunTime.cpp
+++ b/engines/qdengine/minigames/adv/RunTime.cpp
@@ -232,7 +232,7 @@ bool MinigameManager::createGame() {
 	}
 
 	// Here we instantiate the specific game
-	_game = _callback();
+	_game = _callback(this);
 
 	if (_currentGameInfo)
 		_currentGameInfo->_empty = false;
diff --git a/engines/qdengine/minigames/adv/RunTime.h b/engines/qdengine/minigames/adv/RunTime.h
index 6f6581bb6f2..e6b74bfb949 100644
--- a/engines/qdengine/minigames/adv/RunTime.h
+++ b/engines/qdengine/minigames/adv/RunTime.h
@@ -85,7 +85,7 @@ struct GameInfo {
 	void *_gameData;
 };
 
-typedef MinigameInterface *(*MinigameConsCallback)();
+typedef MinigameInterface *(*MinigameConsCallback)(MinigameManager *runtime);
 
 qdMiniGameInterface *create_adv_minigame(const char *name, MinigameConsCallback callback);
 
diff --git a/engines/qdengine/minigames/adv/m_karaoke.cpp b/engines/qdengine/minigames/adv/m_karaoke.cpp
index c4ce3449b11..8477964791d 100644
--- a/engines/qdengine/minigames/adv/m_karaoke.cpp
+++ b/engines/qdengine/minigames/adv/m_karaoke.cpp
@@ -25,7 +25,7 @@
 
 namespace QDEngine {
 
-MinigameInterface *createGame() {
+MinigameInterface *createMinigameKaraoke(MinigameManager *runtime) {
 	return new Karaoke;
 }
 
diff --git a/engines/qdengine/minigames/adv/m_puzzle.cpp b/engines/qdengine/minigames/adv/m_puzzle.cpp
index 9ba33619a37..dbd351a1138 100644
--- a/engines/qdengine/minigames/adv/m_puzzle.cpp
+++ b/engines/qdengine/minigames/adv/m_puzzle.cpp
@@ -33,7 +33,7 @@ namespace QDEngine {
 
 typedef Rect<float, mgVect2f> Rectf;
 
-MinigameInterface *createMinigamePuzzle() {
+MinigameInterface *createMinigamePuzzle(MinigameManager *runtime) {
 	return new Puzzle;
 }
 
diff --git a/engines/qdengine/minigames/adv/m_scores.cpp b/engines/qdengine/minigames/adv/m_scores.cpp
index 588292f9f01..c3a049fe8b9 100644
--- a/engines/qdengine/minigames/adv/m_scores.cpp
+++ b/engines/qdengine/minigames/adv/m_scores.cpp
@@ -27,7 +27,7 @@
 
 namespace QDEngine {
 
-MinigameInterface *createMinigameScores() {
+MinigameInterface *createMinigameScores(MinigameManager *runtime) {
 	return new Scores;
 }
 
diff --git a/engines/qdengine/minigames/adv/m_swap.cpp b/engines/qdengine/minigames/adv/m_swap.cpp
index 99926092388..6a2e366b73f 100644
--- a/engines/qdengine/minigames/adv/m_swap.cpp
+++ b/engines/qdengine/minigames/adv/m_swap.cpp
@@ -31,8 +31,8 @@ namespace QDEngine {
 
 typedef Rect<float, mgVect2f> Rectf;
 
-MinigameInterface *createMinigameSwap() {
-	return new Swap(g_runtime);
+MinigameInterface *createMinigameSwap(MinigameManager *runtime) {
+	return new Swap(runtime);
 }
 
 enum {
diff --git a/engines/qdengine/minigames/adv/m_triangles.cpp b/engines/qdengine/minigames/adv/m_triangles.cpp
index f842c2d1b01..2874c56f1e2 100644
--- a/engines/qdengine/minigames/adv/m_triangles.cpp
+++ b/engines/qdengine/minigames/adv/m_triangles.cpp
@@ -30,8 +30,8 @@
 
 namespace QDEngine {
 
-MinigameInterface *createMinigameTriangle() {
-	return new MinigameTriangle(g_runtime);
+MinigameInterface *createMinigameTriangle(MinigameManager *runtime) {
+	return new MinigameTriangle(runtime);
 }
 
 enum {
diff --git a/engines/qdengine/minigames/adv/m_triangles.h b/engines/qdengine/minigames/adv/m_triangles.h
index 491e66da720..9ef0fa758a1 100644
--- a/engines/qdengine/minigames/adv/m_triangles.h
+++ b/engines/qdengine/minigames/adv/m_triangles.h
@@ -28,7 +28,7 @@
 
 namespace QDEngine {
 
-MinigameInterface *createMinigameTriangle();
+MinigameInterface *createMinigameTriangle(MinigameManager *runtime);
 
 class MinigameTriangle : public MinigameInterface {
 	enum GameType {


Commit: 8a9c76e9c0cc3accd784537e356977f171426f52
    https://github.com/scummvm/scummvm/commit/8a9c76e9c0cc3accd784537e356977f171426f52
Author: Eugene Sandulenko (sev at scummvm.org)
Date: 2024-11-29T18:04:35+01:00

Commit Message:
QDENGINE: Remove g_runtime usage in m_scores minigame

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


diff --git a/engines/qdengine/minigames/adv/m_scores.cpp b/engines/qdengine/minigames/adv/m_scores.cpp
index c3a049fe8b9..783c1e8edeb 100644
--- a/engines/qdengine/minigames/adv/m_scores.cpp
+++ b/engines/qdengine/minigames/adv/m_scores.cpp
@@ -28,19 +28,21 @@
 namespace QDEngine {
 
 MinigameInterface *createMinigameScores(MinigameManager *runtime) {
-	return new Scores;
+	return new Scores(runtime);
 }
 
-Scores::Scores() {
-	const char *fileName = g_runtime->parameter("minigame_list");
+Scores::Scores(MinigameManager *runtime) {
+	_runtime = runtime;
+
+	const char *fileName = _runtime->parameter("minigame_list");
 	if (!fileName || !*fileName)
 		return;
 
-	if (!scumm_stricmp(fileName, g_runtime->gameListFileName())) {
-		error("[minigame_list] must refer to \"%s\"", transCyrillic(g_runtime->gameListFileName()));
+	if (!scumm_stricmp(fileName, _runtime->gameListFileName())) {
+		error("[minigame_list] must refer to \"%s\"", transCyrillic(_runtime->gameListFileName()));
 	}
 
-	const char *gameButtonName = g_runtime->parameter("game_miniature_button");
+	const char *gameButtonName = _runtime->parameter("game_miniature_button");
 	if (!gameButtonName || !*gameButtonName)
 		return;
 
@@ -51,10 +53,10 @@ Scores::Scores() {
 	name[127] = 0;
 	for (int num = 1; ; ++num) {
 		snprintf(name, 127, "%s%02d", gameButtonName, num);
-		if (g_runtime->testObject(name)) {
-			QDObject obj = g_runtime->getObject(name);
+		if (_runtime->testObject(name)) {
+			QDObject obj = _runtime->getObject(name);
 			gameData.write(obj->R());
-			games_.push_back(g_runtime->getObject(name));
+			games_.push_back(_runtime->getObject(name));
 		} else
 			break;
 	}
@@ -63,7 +65,7 @@ Scores::Scores() {
 		error("Game images not found '%s'", transCyrillic(gameButtonName));
 	}
 
-	if (!g_runtime->processGameData(gameData))
+	if (!_runtime->processGameData(gameData))
 		return;
 
 	positions_.resize(games_.size());
@@ -96,7 +98,7 @@ Scores::Scores() {
 				xbuf >= game;
 				lvl.games.push_back(game);
 				debugCN(2, kDebugMinigames, "%d, ", game);
-				if (const MinigameData * data = g_runtime->getScore(level, game))
+				if (const MinigameData * data = _runtime->getScore(level, game))
 					lvl.data.push_back(GameData(game, *data));
 			}
 		}
@@ -115,23 +117,23 @@ Scores::Scores() {
 	level_ = 0;
 	preLevel_ = -1;
 
-	if (!(bestScore_ = g_runtime->parameter("best_score")))
+	if (!(bestScore_ = _runtime->parameter("best_score")))
 		return;
-	if (!(bestTime_ = g_runtime->parameter("best_time")))
+	if (!(bestTime_ = _runtime->parameter("best_time")))
 		return;
-	if (!(lastScore_ = g_runtime->parameter("last_score")))
+	if (!(lastScore_ = _runtime->parameter("last_score")))
 		return;
-	if (!(lastTime_ = g_runtime->parameter("last_time")))
+	if (!(lastTime_ = _runtime->parameter("last_time")))
 		return;
-	if (!(currentLevel_ = g_runtime->parameter("current_level")))
+	if (!(currentLevel_ = _runtime->parameter("current_level")))
 		return;
 
-	if (!(prev_ = g_runtime->getObject(g_runtime->parameter("prev_button"))))
+	if (!(prev_ = _runtime->getObject(_runtime->parameter("prev_button"))))
 		return;
-	if (!(next_ = g_runtime->getObject(g_runtime->parameter("next_button"))))
+	if (!(next_ = _runtime->getObject(_runtime->parameter("next_button"))))
 		return;
 
-	outMaxLevel_ = g_runtime->getObject(g_runtime->parameter("for_game_level"));
+	outMaxLevel_ = _runtime->getObject(_runtime->parameter("for_game_level"));
 	if (outMaxLevel_) {
 		uint level = 0;
 		for (; level < levels_.size(); ++level)
@@ -148,11 +150,11 @@ Scores::Scores() {
 }
 
 Scores::~Scores() {
-	g_runtime->release(prev_);
-	g_runtime->release(next_);
+	_runtime->release(prev_);
+	_runtime->release(next_);
 
 	for (auto &it : games_)
-		g_runtime->release(it);
+		_runtime->release(it);
 
 }
 
@@ -164,10 +166,10 @@ void Scores::quant(float dt) {
 		preLevel_ = level_;
 
 
-		g_runtime->setText(currentLevel_, lvl.level);
+		_runtime->setText(currentLevel_, lvl.level);
 
 		for (int idx = 0; idx < (int)games_.size(); ++idx)
-			g_runtime->hide(games_[idx]);
+			_runtime->hide(games_[idx]);
 
 		for (int idx = 0; idx < (int)games_.size(); ++idx) {
 			if (idx < (int)lvl.data.size()) {
@@ -181,23 +183,23 @@ void Scores::quant(float dt) {
 				assert(gameNum < (int)games_.size());
 				games_[gameNum].setState(Common::String::format("%d", level_).c_str());
 				games_[gameNum]->set_R(positions_[idx]);
-				g_runtime->setText(getName(bestScore_, idx), data.info._bestScore);
-				g_runtime->setText(getName(bestTime_, idx), data.info._bestTime);
-				g_runtime->setText(getName(lastScore_, idx), data.info._lastScore);
-				g_runtime->setText(getName(lastTime_, idx), data.info._lastTime);
+				_runtime->setText(getName(bestScore_, idx), data.info._bestScore);
+				_runtime->setText(getName(bestTime_, idx), data.info._bestTime);
+				_runtime->setText(getName(lastScore_, idx), data.info._lastScore);
+				_runtime->setText(getName(lastTime_, idx), data.info._lastTime);
 			} else {
-				g_runtime->setText(getName(bestScore_, idx), "");
-				g_runtime->setText(getName(bestTime_, idx), "");
-				g_runtime->setText(getName(lastScore_, idx), "");
-				g_runtime->setText(getName(lastTime_, idx), "");
+				_runtime->setText(getName(bestScore_, idx), "");
+				_runtime->setText(getName(bestTime_, idx), "");
+				_runtime->setText(getName(lastScore_, idx), "");
+				_runtime->setText(getName(lastTime_, idx), "");
 			}
 		}
 	}
 
-	if (g_runtime->mouseLeftPressed()) {
-		if (level_ < (int)levels_.size() - 1 && lvl.data.size() == lvl.games.size() && next_.hit(g_runtime->mousePosition()))
+	if (_runtime->mouseLeftPressed()) {
+		if (level_ < (int)levels_.size() - 1 && lvl.data.size() == lvl.games.size() && next_.hit(_runtime->mousePosition()))
 			++level_;
-		else if (level_ > 0 && prev_.hit(g_runtime->mousePosition()))
+		else if (level_ > 0 && prev_.hit(_runtime->mousePosition()))
 			--level_;
 	}
 }
diff --git a/engines/qdengine/minigames/adv/m_scores.h b/engines/qdengine/minigames/adv/m_scores.h
index bbf06422f3d..2b4a51fa020 100644
--- a/engines/qdengine/minigames/adv/m_scores.h
+++ b/engines/qdengine/minigames/adv/m_scores.h
@@ -29,7 +29,7 @@ namespace QDEngine {
 
 class Scores : public MinigameInterface {
 public:
-	Scores();
+	Scores(MinigameManager *runtime);
 	~Scores();
 
 	void quant(float dt);
@@ -74,6 +74,8 @@ private:
 	Coords positions_;
 
 	const char *getName(const char* begin, int idx) const;
+
+	MinigameManager *_runtime;
 };
 
 } // namespace QDEngine


Commit: 3a9f2d5016152e31ed10a3a9fb8746cc3d1ee680
    https://github.com/scummvm/scummvm/commit/3a9f2d5016152e31ed10a3a9fb8746cc3d1ee680
Author: Eugene Sandulenko (sev at scummvm.org)
Date: 2024-11-29T18:04:35+01:00

Commit Message:
QDENGINE: Remove g_runtime usage in m_puzzle minigame

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


diff --git a/engines/qdengine/minigames/adv/m_puzzle.cpp b/engines/qdengine/minigames/adv/m_puzzle.cpp
index dbd351a1138..c9ecef03d2c 100644
--- a/engines/qdengine/minigames/adv/m_puzzle.cpp
+++ b/engines/qdengine/minigames/adv/m_puzzle.cpp
@@ -34,7 +34,7 @@ namespace QDEngine {
 typedef Rect<float, mgVect2f> Rectf;
 
 MinigameInterface *createMinigamePuzzle(MinigameManager *runtime) {
-	return new Puzzle;
+	return new Puzzle(runtime);
 }
 
 enum {
@@ -64,7 +64,9 @@ const char *Puzzle::getStateName(int angle, bool selected, bool small) const {
 	return buf;
 }
 
-Puzzle::Puzzle() {
+Puzzle::Puzzle(MinigameManager *runtime) {
+	_runtime = runtime;
+
 	if (!getParameter("game_size", gameSize_, true))
 		return;
 	assert(gameSize_ > 0 && gameSize_ < 100);
@@ -77,7 +79,7 @@ Puzzle::Puzzle() {
 	angles_ = getParameter("angles", 4);
 	assert(angles_ > 0 &&  angles_ < 10);
 
-	if (!(stackBottom_ = g_runtime->getObject(g_runtime->parameter("inventory_bottom"))))
+	if (!(stackBottom_ = _runtime->getObject(_runtime->parameter("inventory_bottom"))))
 		return;
 	if (!getParameter("inventory_size", stackSize_, true))
 		return;
@@ -88,7 +90,7 @@ Puzzle::Puzzle() {
 			return;
 	} else
 		rotateTimePeriod_ = 86400; // сутки
-	nextRotateTime_ = g_runtime->getTime() + rotateTimePeriod_;
+	nextRotateTime_ = _runtime->getTime() + rotateTimePeriod_;
 
 	flySpeed_ = getParameter("inventory_drop_speed", 240.f);
 	assert(flySpeed_ > 0.f);
@@ -97,7 +99,7 @@ Puzzle::Puzzle() {
 	warning("STUB: Puzzle::Puzzle()");
 
 #if 0
-	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;
@@ -107,14 +109,14 @@ Puzzle::Puzzle() {
 		snprintf(buf, 127, "%s%02d", name_begin, idx + 1);
 
 		Node node;
-		node.obj = g_runtime->getObject(buf);
+		node.obj = _runtime->getObject(buf);
 
-		if (g_runtime->debugMode()) {
+		if (_runtime->debugMode()) {
 			node.pos = nodes_.size();
 			node.angle = 0;
 			field_[node.pos] = node.pos;
 		} else
-			node.angle = g_runtime->rnd(0, angles_ - 1);
+			node.angle = _runtime->rnd(0, angles_ - 1);
 		node.obj.setState(getStateName(node.angle, false, true));
 
 		gameData.write(node.obj->R());
@@ -122,7 +124,7 @@ Puzzle::Puzzle() {
 		nodes_.push_back(node);
 	}
 
-	if (!g_runtime->processGameData(gameData))
+	if (!_runtime->processGameData(gameData))
 		return;
 
 	for (int idx = 0; idx < gameSize_; ++idx) {
@@ -132,10 +134,10 @@ Puzzle::Puzzle() {
 		positions_.push_back(crd);
 	}
 #endif
-	if (g_runtime->debugMode())
+	if (_runtime->debugMode())
 		nodes_[0].angle = angles_ - 1;
 
-	size_ = g_runtime->getSize(nodes_[0].obj);
+	size_ = _runtime->getSize(nodes_[0].obj);
 	debugC(2, kDebugMinigames, "size = (%6.2f,%6.2f)", size_.x, size_.y);
 
 	depth_ = nodes_[0].obj.depth();
@@ -148,17 +150,17 @@ Puzzle::Puzzle() {
 	pickedItem_ = -1;
 	mouseObjPose_ = stidx(stackSize_ + 1);
 
-	inField_ = g_runtime->debugMode() ? nodes_.size() : 0;
-	nextObjTime_ = g_runtime->getTime();
+	inField_ = _runtime->debugMode() ? nodes_.size() : 0;
+	nextObjTime_ = _runtime->getTime();
 
 	setState(MinigameInterface::RUNNING);
 }
 
 Puzzle::~Puzzle() {
 	for (auto &it : nodes_)
-		g_runtime->release(it.obj);
+		_runtime->release(it.obj);
 
-	g_runtime->release(stackBottom_);
+	_runtime->release(stackBottom_);
 }
 
 void Puzzle::rotate(int item) {
@@ -211,7 +213,7 @@ 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 = g_runtime->world2game(from);
+				flyObj->current = _runtime->world2game(from);
 				node.obj->set_R(from);
 
 				flyObj->speed = flowSpeed;
@@ -219,8 +221,8 @@ void Puzzle::put(int where, int what, float flowSpeed) {
 		}
 
 		mgVect3f to = where < -1 ? stackPosition(stidx(where)) : position(where);
-		flyObj->target = g_runtime->world2game(to);
-		flyObj->depth = g_runtime->getDepth(to);
+		flyObj->target = _runtime->world2game(to);
+		flyObj->depth = _runtime->getDepth(to);
 	}
 
 	if (where >= 0)
@@ -236,40 +238,40 @@ void Puzzle::putOnStack(int what, float speed) {
 
 void Puzzle::returnToStack() {
 	assert(pickedItem_ != -1);
-	g_runtime->event(EVENT_RETURN, g_runtime->mousePosition());
+	_runtime->event(EVENT_RETURN, _runtime->mousePosition());
 	if (prevPlace_ >= 0)
 		put(prevPlace_, pickedItem_);
 	else
 		putOnStack(pickedItem_, returnSpeed_);
 	prevPlace_ = -1;
 	pickedItem_ = -1;
-	g_runtime->event(EVENT_CLICK, g_runtime->mousePosition());
+	_runtime->event(EVENT_CLICK, _runtime->mousePosition());
 }
 
 void Puzzle::quant(float dt) {
 	if (pickedItem_ == -1)
-		g_runtime->setGameHelpVariant(0);
+		_runtime->setGameHelpVariant(0);
 	else
-		g_runtime->setGameHelpVariant(1);
+		_runtime->setGameHelpVariant(1);
 
-	if (g_runtime->getTime() > nextRotateTime_) {
-		g_runtime->event(EVENT_FIELD_ROTATE, mgVect2f(400, 300));
-		nextRotateTime_ = g_runtime->getTime() + rotateTimePeriod_;
+	if (_runtime->getTime() > nextRotateTime_) {
+		_runtime->event(EVENT_FIELD_ROTATE, mgVect2f(400, 300));
+		nextRotateTime_ = _runtime->getTime() + rotateTimePeriod_;
 		globalAngle_ = (globalAngle_ + 1) % angles_;
-		g_runtime->setCompleteHelpVariant(globalAngle_);
+		_runtime->setCompleteHelpVariant(globalAngle_);
 	}
 
 	FlyQDObjects::iterator fit = flyObjs_.begin();
 	while (fit != flyObjs_.end())
-		if (!isOnMouse(nodes_[fit->data]) && fit->quant(dt, nodes_[fit->data].obj, g_runtime))
+		if (!isOnMouse(nodes_[fit->data]) && fit->quant(dt, nodes_[fit->data].obj, _runtime))
 			++fit;
 		else
 			fit = flyObjs_.erase(fit);
 
-	if (inField_ < (int)nodes_.size() && g_runtime->getTime() > nextObjTime_ &&
+	if (inField_ < (int)nodes_.size() && _runtime->getTime() > nextObjTime_ &&
 			((int)stack_.size() < stackSize_ - 1 || ((int)stack_.size() < stackSize_ && pickedItem_ == -1))) { // нужно добавить в инвентори фишку
 		// ищем случайный не выставленный фрагмент
-		int freeIdx = round(g_runtime->rnd(0.f, nodes_.size() - 1));
+		int freeIdx = round(_runtime->rnd(0.f, nodes_.size() - 1));
 		Nodes::iterator it = nodes_.begin();
 		for (;;) {
 			if (++it == nodes_.end())
@@ -281,7 +283,7 @@ void Puzzle::quant(float dt) {
 		int idx = Common::distance(nodes_.begin(), it);
 
 		++inField_;
-		nextObjTime_ = g_runtime->getTime() + stackPlaceSize_.y / flySpeed_;
+		nextObjTime_ = _runtime->getTime() + stackPlaceSize_.y / flySpeed_;
 
 		it->pos = stidx(stackSize_);
 		it->obj.setState(getStateName(it->angle, false, true));
@@ -289,7 +291,7 @@ void Puzzle::quant(float dt) {
 		putOnStack(idx, flySpeed_);
 	}
 
-	mgVect2f mouse = g_runtime->mousePosition();
+	mgVect2f mouse = _runtime->mousePosition();
 
 	int hovPlace = -1;  // Номер места которое сейчас под мышкой
 	for (int idx = 0; idx < (int)stack_.size(); ++idx)
@@ -300,7 +302,7 @@ void Puzzle::quant(float dt) {
 	if (hovPlace == -1) {
 		float radius = 0.5f * size_.x;
 		for (int idx = 0; idx < gameSize_; ++idx)
-			if (dist(g_runtime->world2game(position(idx)), mouse) < radius) {
+			if (dist(_runtime->world2game(position(idx)), mouse) < radius) {
 				hovPlace = idx;
 				break;
 			}
@@ -313,23 +315,23 @@ void Puzzle::quant(float dt) {
 			hovPlace = stidx(stackSize_);
 	}
 
-	if (g_runtime->mouseLeftPressed()) {
+	if (_runtime->mouseLeftPressed()) {
 		if (hovPlace >= 0) { // клик по полю
 			Indexes::value_type& hovItem = field_[hovPlace];
 			if (hovItem == -1) // клик по пустой ячейке
 				if (pickedItem_ == -1) // на мыши ничего нет
-					g_runtime->event(EVENT_CLICK, mouse);
+					_runtime->event(EVENT_CLICK, mouse);
 				else { // кладем фрагмент с мыши
 					put(hovPlace, pickedItem_);
 					if (testPlace(pickedItem_)) // положили на свое свое место
-						g_runtime->event(EVENT_PUT_RIGHT, mouse);
+						_runtime->event(EVENT_PUT_RIGHT, mouse);
 					else // просто положили
-						g_runtime->event(EVENT_PUT, mouse);
+						_runtime->event(EVENT_PUT, mouse);
 					pickedItem_ = -1;
 					prevPlace_ = -1;
 				} else { // клик по непустой ячейке
 				if (testPlace(hovPlace)) // клик по правильно уложенной фишке
-					g_runtime->event(EVENT_CLICK_RIGHT, mouse);
+					_runtime->event(EVENT_CLICK_RIGHT, mouse);
 				else if (pickedItem_ != -1) { // поменять с тем что на мыше
 					bool swap = true;
 					if (prevPlace_ >= 0)
@@ -337,20 +339,20 @@ void Puzzle::quant(float dt) {
 					else
 						putOnStack(hovItem, returnSpeed_);
 					if (testPlace(hovItem)) { // оказалась при обмене на своем месте
-						g_runtime->event(EVENT_PUT_RIGHT, g_runtime->world2game(position(prevPlace_)));
+						_runtime->event(EVENT_PUT_RIGHT, _runtime->world2game(position(prevPlace_)));
 						swap = false;
 					}
 					put(hovPlace, pickedItem_);
 					if (testPlace(pickedItem_)) { // положили на свое свое место
-						g_runtime->event(EVENT_PUT_RIGHT, mouse);
+						_runtime->event(EVENT_PUT_RIGHT, mouse);
 						swap = false;
 					}
 					if (swap) // просто обменяли
-						g_runtime->event(EVENT_SWAP, mouse);
+						_runtime->event(EVENT_SWAP, mouse);
 					pickedItem_ = -1;
 					prevPlace_ = -1;
 				} else { // взять фрагмент на мышь
-					g_runtime->event(EVENT_GET, mouse);
+					_runtime->event(EVENT_GET, mouse);
 					prevPlace_ = hovPlace;
 					pickedItem_ = hovItem;
 					nodes_[pickedItem_].pos = mouseObjPose_;
@@ -361,7 +363,7 @@ void Puzzle::quant(float dt) {
 			int hovStack = stidx(hovPlace);
 			if (pickedItem_ == -1) // на мыши ничего нет
 				if (hovStack < (int)stack_.size()) { // взять фрагмент из стека на мышь
-					g_runtime->event(EVENT_GET, mouse);
+					_runtime->event(EVENT_GET, mouse);
 					Indexes::iterator it = stack_.begin() + hovStack;
 					assert(*it >= 0);
 					prevPlace_ = -1;
@@ -371,36 +373,36 @@ void Puzzle::quant(float dt) {
 					for (int idx = hovStack; idx < (int)stack_.size(); ++idx)
 						put(stidx(idx), stack_[idx], flySpeed_);
 				} else // пустой клик в области стека
-					g_runtime->event(EVENT_CLICK, mouse);
+					_runtime->event(EVENT_CLICK, mouse);
 			else // вернуть фишку на место
 				returnToStack();
 		} else // пустой клик мимо игрового поля
-			g_runtime->event(EVENT_CLICK, mouse);
-	} else if (g_runtime->mouseRightPressed()) {
+			_runtime->event(EVENT_CLICK, mouse);
+	} else if (_runtime->mouseRightPressed()) {
 		if (pickedItem_ == -1) {
 			if (hovPlace >= 0) { // клик по полю
 				if (testPlace(hovPlace)) // клик по правильно уложенной фишке
-					g_runtime->event(EVENT_CLICK_RIGHT, mouse);
+					_runtime->event(EVENT_CLICK_RIGHT, mouse);
 				else {
 					Indexes::value_type& hovItem = field_[hovPlace];
 					if (hovItem >= 0) {
 						rotate(hovItem);
 						if (testPlace(hovItem)) // повернули на правильный угол
-							g_runtime->event(EVENT_PUT_RIGHT, mouse);
+							_runtime->event(EVENT_PUT_RIGHT, mouse);
 						else // просто положили
-							g_runtime->event(EVENT_ROTATE_IN_FIELD, mouse);
+							_runtime->event(EVENT_ROTATE_IN_FIELD, mouse);
 					} else // попытка прокрутить пустое место
-						g_runtime->event(EVENT_CLICK, mouse);
+						_runtime->event(EVENT_CLICK, mouse);
 				}
 			} else  if (hovPlace < -1) { // клик по стеку
 				int hovStack = stidx(hovPlace);
 				if (hovStack < (int)stack_.size()) { // покрутить внутри стека
-					g_runtime->event(EVENT_ROTATE_IN_STACK, mouse);
+					_runtime->event(EVENT_ROTATE_IN_STACK, mouse);
 					rotate(stack_[hovStack]);
 				} else // попытка прокрутить пустое место
-					g_runtime->event(EVENT_CLICK, mouse);
+					_runtime->event(EVENT_CLICK, mouse);
 			} else // пустой клик мимо игрового поля
-				g_runtime->event(EVENT_CLICK, mouse);
+				_runtime->event(EVENT_CLICK, mouse);
 		} else // вернуть фишку на место
 			returnToStack();
 	}
@@ -418,7 +420,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(g_runtime->game2world(mouse, stackBottom_.depth() - 200));
+				node.obj->set_R(_runtime->game2world(mouse, stackBottom_.depth() - 200));
 			} else {
 				node.obj.setState(getStateName(node.angle, node.pos == hovPlace && pickedItem_ == -1, true));
 				if (!isFlying(idx))
@@ -426,7 +428,7 @@ void Puzzle::quant(float dt) {
 			}
 			iWin = iWin && testPlace(idx);
 		} else {
-			g_runtime->hide(node.obj);
+			_runtime->hide(node.obj);
 			iWin = false;
 		}
 	}
@@ -456,9 +458,9 @@ const mgVect3f &Puzzle::position(int num) const {
 }
 
 mgVect3f Puzzle::stackPosition(int num) const {
-	mgVect3f bottom = g_runtime->world2game(stackBottom_);
+	mgVect3f bottom = _runtime->world2game(stackBottom_);
 	bottom.y -= stackPlaceSize_.y * num;
-	return g_runtime->game2world(bottom);
+	return _runtime->game2world(bottom);
 }
 
 } // namespace QDEngine
diff --git a/engines/qdengine/minigames/adv/m_puzzle.h b/engines/qdengine/minigames/adv/m_puzzle.h
index 585444b5534..03ecd988d19 100644
--- a/engines/qdengine/minigames/adv/m_puzzle.h
+++ b/engines/qdengine/minigames/adv/m_puzzle.h
@@ -46,7 +46,7 @@ class Puzzle : public MinigameInterface {
 	typedef Std::vector<Node> Nodes;
 
 public:
-	Puzzle();
+	Puzzle(MinigameManager *runtime);
 	~Puzzle();
 
 	void quant(float dt);
@@ -110,6 +110,8 @@ private:
 	const mgVect3f &position(int num) const;
 	/// положение N-ой фишки в инвентори
 	mgVect3f stackPosition(int N) const;
+
+	MinigameManager *_runtime;
 };
 
 } // namespace QDEngine


Commit: d6265e63bdc1688018705f6b0b9faaabc201a871
    https://github.com/scummvm/scummvm/commit/d6265e63bdc1688018705f6b0b9faaabc201a871
Author: Eugene Sandulenko (sev at scummvm.org)
Date: 2024-11-29T18:04:35+01:00

Commit Message:
QDENGINE: Removed g_engine usage in m_karaoke minigame

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


diff --git a/engines/qdengine/minigames/adv/m_karaoke.cpp b/engines/qdengine/minigames/adv/m_karaoke.cpp
index 8477964791d..cb690ef7e91 100644
--- a/engines/qdengine/minigames/adv/m_karaoke.cpp
+++ b/engines/qdengine/minigames/adv/m_karaoke.cpp
@@ -26,7 +26,7 @@
 namespace QDEngine {
 
 MinigameInterface *createMinigameKaraoke(MinigameManager *runtime) {
-	return new Karaoke;
+	return new Karaoke(runtime);
 }
 
 Karaoke::Node::Node() {
@@ -36,12 +36,14 @@ Karaoke::Node::Node() {
 }
 
 
-Karaoke::Karaoke() {
-	controlName_ = g_runtime->parameter("control_name", true);
+Karaoke::Karaoke(MinigameManager *runtime) {
+	_runtime = runtime;
+
+	controlName_ = _runtime->parameter("control_name", true);
 	if (!controlName_ || !*controlName_)
 		return;
 
-	colorReaded_ = g_runtime->parameter("color_first", true);
+	colorReaded_ = _runtime->parameter("color_first", true);
 	if (!colorReaded_ || !*colorReaded_)
 		return;
 
@@ -119,7 +121,7 @@ Karaoke::Karaoke() {
 		}
 	};
 
-	const char *fileName = g_runtime->parameter("text_file", true);
+	const char *fileName = _runtime->parameter("text_file", true);
 	if (!fileName)
 		return;
 
@@ -188,10 +190,10 @@ void Karaoke::quant(float dt) {
 		++idx;
 	}
 
-	if (g_runtime->mouseRightPressed())
+	if (_runtime->mouseRightPressed())
 		debugC(2, kDebugMinigames, "%s", outText.c_str());
 
-	g_runtime->setText(controlName_, outText.c_str());
+	_runtime->setText(controlName_, outText.c_str());
 }
 
 } // namespace QDEngine
diff --git a/engines/qdengine/minigames/adv/m_karaoke.h b/engines/qdengine/minigames/adv/m_karaoke.h
index 6580074241a..27e19a95e3b 100644
--- a/engines/qdengine/minigames/adv/m_karaoke.h
+++ b/engines/qdengine/minigames/adv/m_karaoke.h
@@ -28,7 +28,7 @@ namespace QDEngine {
 
 class Karaoke : public MinigameInterface {
 public:
-	Karaoke();
+	Karaoke(MinigameManager *runtime);
 	void quant(float dt);
 
 	enum TagType {
@@ -55,6 +55,7 @@ private:
 	int currentTag_;
 	float startTagTime_;
 
+	MinigameManager *_runtime;
 };
 
 } // namespace QDEngine


Commit: 5bdd694b89aff2de0b8f0ef29b5473f5a5604c82
    https://github.com/scummvm/scummvm/commit/5bdd694b89aff2de0b8f0ef29b5473f5a5604c82
Author: Eugene Sandulenko (sev at scummvm.org)
Date: 2024-11-29T18:04:35+01:00

Commit Message:
QDENGINE: More renames in adv minigames

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


diff --git a/engines/qdengine/minigames/adv/RunTime.cpp b/engines/qdengine/minigames/adv/RunTime.cpp
index 5162c14d05a..4874aca0a20 100644
--- a/engines/qdengine/minigames/adv/RunTime.cpp
+++ b/engines/qdengine/minigames/adv/RunTime.cpp
@@ -331,35 +331,35 @@ bool MinigameManager::new_game(const qdEngineInterface *engine_interface) {
 }
 
 class TempValue {
-	const qdEngineInterface *pre_engine_;
-	qdMinigameSceneInterface *pre__scene;
-	MinigameManager *pre_runtime_;
+	const qdEngineInterface *_pre_engine;
+	qdMinigameSceneInterface *_pre_scene;
+	MinigameManager *_pre_runtime;
 public:
 	TempValue(MinigameManager *new_runtime, const qdEngineInterface *new_engine, qdMinigameSceneInterface *new_scene) {
 		assert(new_runtime);
-		pre_runtime_ = g_runtime;
+		_pre_runtime = g_runtime;
 		g_runtime = new_runtime;
 
 		assert(new_engine && new_scene);
-		pre_engine_ = g_runtime->_engine;
-		pre__scene = g_runtime->_scene;
+		_pre_engine = g_runtime->_engine;
+		_pre_scene = g_runtime->_scene;
 
 		g_runtime->_engine = new_engine;
 		g_runtime->_scene = new_scene;
 	}
 	~TempValue() {
-		g_runtime->_engine = pre_engine_;
-		g_runtime->_scene = pre__scene;
+		g_runtime->_engine = _pre_engine;
+		g_runtime->_scene = _pre_scene;
 
-		g_runtime = pre_runtime_;
+		g_runtime = _pre_runtime;
 	}
 };
 
-#define TEMP__sceneENTER() TempValue tempSceneObject(this, engine, const_cast<qdMinigameSceneInterface*>(scene))
+#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) {
 	debugC(2, kDebugMinigames, "MinigameManager::save_game(): save game");
-	TEMP__sceneENTER();
+	TEMP_scene_ENTER();
 	loadState();
 	if (_currentGameInfo && !_currentGameInfo->empty()) {
 		debugC(2, kDebugMinigames, "MinigameManager::save_game(): save game (%d, %d)", _currentGameIndex._gameLevel, _currentGameIndex._gameNum);
@@ -380,7 +380,7 @@ int MinigameManager::load_game(const qdEngineInterface *engine, const qdMinigame
 		return buffer_size;
 	}
 	debugC(2, kDebugMinigames, "MinigameManager::load_game(): load game");
-	TEMP__sceneENTER();
+	TEMP_scene_ENTER();
 	loadState();
 
 	if (_currentGameInfo) {


Commit: a22ce387e82d8715df87506023bc099ffd178c1b
    https://github.com/scummvm/scummvm/commit/a22ce387e82d8715df87506023bc099ffd178c1b
Author: Eugene Sandulenko (sev at scummvm.org)
Date: 2024-11-29T18:04:35+01:00

Commit Message:
QDENGINE: Renames in m_scores minigame

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


diff --git a/engines/qdengine/minigames/adv/m_scores.cpp b/engines/qdengine/minigames/adv/m_scores.cpp
index 783c1e8edeb..b0cefad5861 100644
--- a/engines/qdengine/minigames/adv/m_scores.cpp
+++ b/engines/qdengine/minigames/adv/m_scores.cpp
@@ -117,18 +117,18 @@ Scores::Scores(MinigameManager *runtime) {
 	level_ = 0;
 	preLevel_ = -1;
 
-	if (!(bestScore_ = _runtime->parameter("best_score")))
+	if (!(_bestScore = _runtime->parameter("best_score")))
 		return;
-	if (!(bestTime_ = _runtime->parameter("best_time")))
+	if (!(_bestTime = _runtime->parameter("best_time")))
 		return;
-	if (!(lastScore_ = _runtime->parameter("last_score")))
+	if (!(_lastScore = _runtime->parameter("last_score")))
 		return;
-	if (!(lastTime_ = _runtime->parameter("last_time")))
+	if (!(_lastTime = _runtime->parameter("last_time")))
 		return;
-	if (!(currentLevel_ = _runtime->parameter("current_level")))
+	if (!(_currentLevel = _runtime->parameter("current_level")))
 		return;
 
-	if (!(prev_ = _runtime->getObject(_runtime->parameter("prev_button"))))
+	if (!(_prev = _runtime->getObject(_runtime->parameter("_prevbutton"))))
 		return;
 	if (!(next_ = _runtime->getObject(_runtime->parameter("next_button"))))
 		return;
@@ -150,7 +150,7 @@ Scores::Scores(MinigameManager *runtime) {
 }
 
 Scores::~Scores() {
-	_runtime->release(prev_);
+	_runtime->release(_prev);
 	_runtime->release(next_);
 
 	for (auto &it : games_)
@@ -166,7 +166,7 @@ void Scores::quant(float dt) {
 		preLevel_ = level_;
 
 
-		_runtime->setText(currentLevel_, lvl.level);
+		_runtime->setText(_currentLevel, lvl.level);
 
 		for (int idx = 0; idx < (int)games_.size(); ++idx)
 			_runtime->hide(games_[idx]);
@@ -183,15 +183,15 @@ void Scores::quant(float dt) {
 				assert(gameNum < (int)games_.size());
 				games_[gameNum].setState(Common::String::format("%d", level_).c_str());
 				games_[gameNum]->set_R(positions_[idx]);
-				_runtime->setText(getName(bestScore_, idx), data.info._bestScore);
-				_runtime->setText(getName(bestTime_, idx), data.info._bestTime);
-				_runtime->setText(getName(lastScore_, idx), data.info._lastScore);
-				_runtime->setText(getName(lastTime_, idx), data.info._lastTime);
+				_runtime->setText(getName(_bestScore, idx), data.info._bestScore);
+				_runtime->setText(getName(_bestTime, idx), data.info._bestTime);
+				_runtime->setText(getName(_lastScore, idx), data.info._lastScore);
+				_runtime->setText(getName(_lastTime, idx), data.info._lastTime);
 			} else {
-				_runtime->setText(getName(bestScore_, idx), "");
-				_runtime->setText(getName(bestTime_, idx), "");
-				_runtime->setText(getName(lastScore_, idx), "");
-				_runtime->setText(getName(lastTime_, idx), "");
+				_runtime->setText(getName(_bestScore, idx), "");
+				_runtime->setText(getName(_bestTime, idx), "");
+				_runtime->setText(getName(_lastScore, idx), "");
+				_runtime->setText(getName(_lastTime, idx), "");
 			}
 		}
 	}
@@ -199,7 +199,7 @@ void Scores::quant(float dt) {
 	if (_runtime->mouseLeftPressed()) {
 		if (level_ < (int)levels_.size() - 1 && lvl.data.size() == lvl.games.size() && next_.hit(_runtime->mousePosition()))
 			++level_;
-		else if (level_ > 0 && prev_.hit(_runtime->mousePosition()))
+		else if (level_ > 0 && _prev.hit(_runtime->mousePosition()))
 			--level_;
 	}
 }
diff --git a/engines/qdengine/minigames/adv/m_scores.h b/engines/qdengine/minigames/adv/m_scores.h
index 2b4a51fa020..dcc7e79dc33 100644
--- a/engines/qdengine/minigames/adv/m_scores.h
+++ b/engines/qdengine/minigames/adv/m_scores.h
@@ -56,13 +56,13 @@ private:
 	typedef Std::vector<Level> Levels;
 	Levels levels_;
 
-	const char *currentLevel_;
-	const char *bestScore_;
-	const char *bestTime_;
-	const char *lastScore_;
-	const char *lastTime_;
+	const char *_currentLevel;
+	const char *_bestScore;
+	const char *_bestTime;
+	const char *_lastScore;
+	const char *_lastTime;
 
-	QDObject prev_;
+	QDObject _prev;
 	QDObject next_;
 	QDObject outMaxLevel_;

More information about the Scummvm-git-logs mailing list