[Scummvm-git-logs] scummvm master -> 34ff7c572d334d9e4cff4d6c259bb4c49b377a54

sev- noreply at scummvm.org
Wed Jun 11 22:43:10 UTC 2025 

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

Summary:
f1b04ef1a7 QDENGINE: Class variable renames
983f3c73ae QDENGINE: Init class variables. CID 1611412
bc02d51c54 QDENGINE: Initialize class variables. CID 1566534
a62e56fe21 QDENGINE: Initialize class vairables. CID 1566538
f8e782423a QDENGINE: Initialize class variables. CID 1566533
8649e9e6b1 QDENGINE: Initialize class variable. CID 1611405
89e71ebec4 ENGINES: Prevent resource leak in ExtendedSavegameHeader. CID 1591629
38389b986d QDENGINE: Fix potential division by zero. CID 1591720
9b151b58b2 QDENGINE: Check that file is truly open before reading. CID 1611381
34ff7c572d QDENGINE: Fix potential NULL dereference. CID 1611402


Commit: f1b04ef1a7f6bc2065e2bee1304dc96d6fafcfe9
    https://github.com/scummvm/scummvm/commit/f1b04ef1a7f6bc2065e2bee1304dc96d6fafcfe9
Author: Eugene Sandulenko (sev at scummvm.org)
Date: 2025-06-12T00:19:16+02:00

Commit Message:
QDENGINE: Class variable renames

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


diff --git a/engines/qdengine/minigames/adv/m_karaoke.cpp b/engines/qdengine/minigames/adv/m_karaoke.cpp
index b084bba49aa..95cfa7113e5 100644
--- a/engines/qdengine/minigames/adv/m_karaoke.cpp
+++ b/engines/qdengine/minigames/adv/m_karaoke.cpp
@@ -44,12 +44,12 @@ Karaoke::Node::Node() {
 Karaoke::Karaoke(MinigameManager *runtime) {
 	_runtime = runtime;
 
-	controlName_ = _runtime->parameter("control_name", true);
-	if (!controlName_ || !*controlName_)
+	_controlName = _runtime->parameter("control_name", true);
+	if (!_controlName || !*_controlName)
 		return;
 
-	colorReaded_ = _runtime->parameter("color_first", true);
-	if (!colorReaded_ || !*colorReaded_)
+	_colorReaded = _runtime->parameter("color_first", true);
+	if (!_colorReaded || !*_colorReaded)
 		return;
 
 	struct Parse {
@@ -143,50 +143,50 @@ Karaoke::Karaoke(MinigameManager *runtime) {
 		return;
 	}
 
-	Parse(file, nodes_);
-	debugC(2, kDebugMinigames, "read %d tags", nodes_.size());
+	Parse(file, _nodes);
+	debugC(2, kDebugMinigames, "read %d tags", _nodes.size());
 
-	startScreenTag_ = 0;
-	currentTag_ = 0;
+	_startScreenTag = 0;
+	_currentTag = 0;
 
-	startTime_ = 0.001f * g_system->getMillis();
-	startTagTime_ = 0.f;
+	_startTime = 0.001f * g_system->getMillis();
+	_startTagTime = 0.f;
 
 	setState(MinigameInterface::RUNNING);
 
 }
 
 void Karaoke::quant(float dt) {
-	float curTime = 0.001f * g_system->getMillis() - startTime_;
+	float curTime = 0.001f * g_system->getMillis() - _startTime;
 	if (curTime < 0.f)
 		curTime = 0.f;
 
-	Node& node = nodes_[currentTag_];
+	Node& node = _nodes[_currentTag];
 	if (node.type == CLEAR) {
-		++currentTag_;
-		if ((uint)currentTag_ == nodes_.size())
+		++_currentTag;
+		if ((uint)_currentTag == _nodes.size())
 			setState(MinigameInterface::GAME_WIN);
-		startScreenTag_ = currentTag_;
+		_startScreenTag = _currentTag;
 		return;
 	}
 
 	Common::String outText;
-	outText += colorReaded_;
-	int idx = startScreenTag_;
-	while (idx < currentTag_) {
-		assert((uint)idx < nodes_.size());
-		assert(nodes_[idx].type == STRING);
-		outText += nodes_[idx].text.c_str();
+	outText += _colorReaded;
+	int idx = _startScreenTag;
+	while (idx < _currentTag) {
+		assert((uint)idx < _nodes.size());
+		assert(_nodes[idx].type == STRING);
+		outText += _nodes[idx].text.c_str();
 		++idx;
 	}
 
-	float phase = (curTime - startTagTime_) / node.time;
+	float phase = (curTime - _startTagTime) / node.time;
 	assert(phase >= 0.f);
 	if (phase >= 1.f) {
 		outText += node.text + "&>";
-		++currentTag_;
-		startTagTime_ += node.time;
-		if ((uint)currentTag_ == nodes_.size())
+		++_currentTag;
+		_startTagTime += node.time;
+		if ((uint)_currentTag == _nodes.size())
 			setState(MinigameInterface::GAME_WIN);
 	} else {
 		int part = phase * node.text.size();
@@ -195,17 +195,17 @@ void Karaoke::quant(float dt) {
 	}
 
 	++idx;
-	while ((uint)idx < nodes_.size()) {
-		if (nodes_[idx].type == CLEAR)
+	while ((uint)idx < _nodes.size()) {
+		if (_nodes[idx].type == CLEAR)
 			break;
-		outText += nodes_[idx].text.c_str();
+		outText += _nodes[idx].text.c_str();
 		++idx;
 	}
 
 	if (_runtime->mouseRightPressed())
 		debugC(2, kDebugMinigames, "%s", outText.c_str());
 
-	_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 a98b11e8c3e..e552e2dda5e 100644
--- a/engines/qdengine/minigames/adv/m_karaoke.h
+++ b/engines/qdengine/minigames/adv/m_karaoke.h
@@ -40,8 +40,8 @@ public:
 	};
 
 private:
-	const char *controlName_;
-	const char *colorReaded_;
+	const char *_controlName;
+	const char *_colorReaded;
 
 	struct Node {
 		Node();
@@ -51,12 +51,12 @@ private:
 	};
 
 	typedef Std::vector<Node> Nodes;
-	Nodes nodes_;
+	Nodes _nodes;
 
-	float startTime_;
-	int startScreenTag_;
-	int currentTag_;
-	float startTagTime_;
+	float _startTime;
+	int _startScreenTag;
+	int _currentTag;
+	float _startTagTime;
 
 	MinigameManager *_runtime;
 };
diff --git a/engines/qdengine/minigames/adv/m_puzzle.cpp b/engines/qdengine/minigames/adv/m_puzzle.cpp
index d3957461da6..832116a8e78 100644
--- a/engines/qdengine/minigames/adv/m_puzzle.cpp
+++ b/engines/qdengine/minigames/adv/m_puzzle.cpp
@@ -58,44 +58,44 @@ const char *Puzzle::getStateName(int angle, bool selected, bool small) const {
 	static char buf[32];
 	buf[31] = 0;
 
-	assert(angle >= 0 && angle < angles_);
-	angle = (angle + globalAngle_) % angles_;
+	assert(angle >= 0 && angle < _angles);
+	angle = (angle + _globalAngle) % _angles;
 
-	snprintf(buf, 31, "%s%02d%s", !singleSize_ && small ? small_pref : "", angle + 1, selected ? selected_suf : "");
+	snprintf(buf, 31, "%s%02d%s", !_singleSize && small ? small_pref : "", angle + 1, selected ? selected_suf : "");
 	return buf;
 }
 
 Puzzle::Puzzle(MinigameManager *runtime) {
 	_runtime = runtime;
 
-	if (!_runtime->getParameter("game_size", gameSize_, true))
+	if (!_runtime->getParameter("game_size", _gameSize, true))
 		return;
-	assert(gameSize_ > 0 && gameSize_ < 100);
+	assert(_gameSize > 0 && _gameSize < 100);
 
-	field_.resize(gameSize_, -1);
-	globalAngle_ = 0;
+	_field.resize(_gameSize, -1);
+	_globalAngle = 0;
 
-	singleSize_ = _runtime->getParameter("small_objects", false);
+	_singleSize = _runtime->getParameter("small_objects", false);
 
-	angles_ = _runtime->getParameter("angles", 4);
-	assert(angles_ > 0 &&  angles_ < 10);
+	_angles = _runtime->getParameter("angles", 4);
+	assert(_angles > 0 &&  _angles < 10);
 
-	if (!(stackBottom_ = _runtime->getObject(_runtime->parameter("inventory_bottom"))))
+	if (!(_stackBottom = _runtime->getObject(_runtime->parameter("inventory_bottom"))))
 		return;
-	if (!_runtime->getParameter("inventory_size", stackSize_, true))
+	if (!_runtime->getParameter("inventory_size", _stackSize, true))
 		return;
 
-	if (_runtime->getParameter("rotate_period", rotateTimePeriod_, false)) {
-		assert(sqr(sqrt((float)gameSize_)) == gameSize_);
-		if (sqr(sqrt((float)gameSize_)) != gameSize_)
+	if (_runtime->getParameter("rotate_period", _rotateTimePeriod, false)) {
+		assert(sqr(sqrt((float)_gameSize)) == _gameSize);
+		if (sqr(sqrt((float)_gameSize)) != _gameSize)
 			return;
 	} else
-		rotateTimePeriod_ = 86400; // сутки
-	nextRotateTime_ = _runtime->getTime() + rotateTimePeriod_;
+		_rotateTimePeriod = 86400; // сутки
+	_nextRotateTime = _runtime->getTime() + _rotateTimePeriod;
 
-	flySpeed_ = _runtime->getParameter("inventory_drop_speed", 240.f);
-	assert(flySpeed_ > 0.f);
-	returnSpeed_ = _runtime->getParameter("inventory_return_speed", -1.f);
+	_flySpeed = _runtime->getParameter("inventory_drop_speed", 240.f);
+	assert(_flySpeed > 0.f);
+	_returnSpeed = _runtime->getParameter("inventory_return_speed", -1.f);
 
 	const char *name_begin = _runtime->parameter("obj_name_begin", "obj_");
 
@@ -103,23 +103,23 @@ Puzzle::Puzzle(MinigameManager *runtime) {
 	buf[127] = 0;
 
 	Common::MemoryReadWriteStream gameData(DisposeAfterUse::YES);
-	for (int idx = 0; idx < gameSize_; ++idx) {
+	for (int idx = 0; idx < _gameSize; ++idx) {
 		snprintf(buf, 127, "%s%02d", name_begin, idx + 1);
 
 		Node node;
 		node.obj = _runtime->getObject(buf);
 
 		if (_runtime->debugMode()) {
-			node.pos = nodes_.size();
+			node.pos = _nodes.size();
 			node.angle = 0;
-			field_[node.pos] = node.pos;
+			_field[node.pos] = node.pos;
 		} else
-			node.angle = _runtime->rnd(0, angles_ - 1);
+			node.angle = _runtime->rnd(0, _angles - 1);
 		node.obj.setState(getStateName(node.angle, false, true));
 
 		node.obj->R().write(gameData);
 
-		nodes_.push_back(node);
+		_nodes.push_back(node);
 	}
 
 	if (!_runtime->processGameData(gameData))
@@ -128,53 +128,53 @@ Puzzle::Puzzle(MinigameManager *runtime) {
 	GameInfo *gameInfo = _runtime->getCurrentGameInfo();
 	if (gameInfo) {
 		Common::MemoryReadStream data((byte *)gameInfo->_gameData, gameInfo->_dataSize);
-		for (int idx = 0; idx < gameSize_; ++idx) {
+		for (int idx = 0; idx < _gameSize; ++idx) {
 			mgVect3f crd;
 			crd.read(data);
-			nodes_[idx].obj->set_R(crd);
-			positions_.push_back(crd);
+			_nodes[idx].obj->set_R(crd);
+			_positions.push_back(crd);
 		}
 	} else {
-		for (int idx = 0; idx < gameSize_; ++idx) {
+		for (int idx = 0; idx < _gameSize; ++idx) {
 			mgVect3f crd;
 			crd.read(gameData);
-			nodes_[idx].obj->set_R(crd);
-			positions_.push_back(crd);
+			_nodes[idx].obj->set_R(crd);
+			_positions.push_back(crd);
 		}
 	}
 
 	if (_runtime->debugMode())
-		nodes_[0].angle = angles_ - 1;
+		_nodes[0].angle = _angles - 1;
 
-	size_ = _runtime->getSize(nodes_[0].obj);
-	debugC(2, kDebugMinigames, "size = (%6.2f,%6.2f)", size_.x, size_.y);
+	_size = _runtime->getSize(_nodes[0].obj);
+	debugC(2, kDebugMinigames, "size = (%6.2f,%6.2f)", _size.x, _size.y);
 
-	depth_ = nodes_[0].obj.depth(runtime);
+	depth_ = _nodes[0].obj.depth(runtime);
 
-	stackPlaceSize_ = _runtime->getParameter("inventory_place_size", size_ * 1.2f);
-	assert(stackPlaceSize_.x > 0.f && stackPlaceSize_.x < 500.f && stackPlaceSize_.y > 0.f && stackPlaceSize_.y < 500.f);
-	debugC(2, kDebugMinigames, "stackPlaceSize = (%5.1f, %5.1f)", stackPlaceSize_.x, stackPlaceSize_.y);
+	_stackPlaceSize = _runtime->getParameter("inventory_place_size", _size * 1.2f);
+	assert(_stackPlaceSize.x > 0.f && _stackPlaceSize.x < 500.f && _stackPlaceSize.y > 0.f && _stackPlaceSize.y < 500.f);
+	debugC(2, kDebugMinigames, "stackPlaceSize = (%5.1f, %5.1f)", _stackPlaceSize.x, _stackPlaceSize.y);
 
-	prevPlace_ = -1;
-	pickedItem_ = -1;
-	mouseObjPose_ = stidx(stackSize_ + 1);
+	_prevPlace = -1;
+	_pickedItem = -1;
+	_mouseObjPose = stidx(_stackSize + 1);
 
-	inField_ = _runtime->debugMode() ? nodes_.size() : 0;
-	nextObjTime_ = _runtime->getTime();
+	_inField = _runtime->debugMode() ? _nodes.size() : 0;
+	_nextObjTime = _runtime->getTime();
 
 	setState(MinigameInterface::RUNNING);
 }
 
 Puzzle::~Puzzle() {
-	for (auto &it : nodes_)
+	for (auto &it : _nodes)
 		_runtime->release(it.obj);
 
-	_runtime->release(stackBottom_);
+	_runtime->release(_stackBottom);
 }
 
 void Puzzle::rotate(int item) {
-	assert(item >= 0 && item < (int)nodes_.size());
-	nodes_[item].angle = (nodes_[item].angle + 1) % angles_;
+	assert(item >= 0 && item < (int)_nodes.size());
+	_nodes[item].angle = (_nodes[item].angle + 1) % _angles;
 }
 
 int Puzzle::stidx(int idx) const {
@@ -182,44 +182,44 @@ int Puzzle::stidx(int idx) const {
 }
 
 bool Puzzle::testPlace(int item) const {
-	assert(item >= 0 && item < (int)nodes_.size());
-	return nodes_[item].pos == item && nodes_[item].angle == 0;
+	assert(item >= 0 && item < (int)_nodes.size());
+	return _nodes[item].pos == item && _nodes[item].angle == 0;
 }
 
 bool Puzzle::isFlying(int idx) const {
-	for (auto &it : flyObjs_)
+	for (auto &it : _flyObjs)
 		if (it.data == idx)
 			return true;
 	return false;
 }
 
 bool Puzzle::isOnMouse(const Node& node) const {
-	if (node.pos == mouseObjPose_) {
+	if (node.pos == _mouseObjPose) {
 		return true;
 	}
 	return false;
 }
 
 void Puzzle::put(int where, int what, float flowSpeed) {
-	assert(where < (int)field_.size());
-	assert(what >= 0 && what < (int)nodes_.size());
+	assert(where < (int)_field.size());
+	assert(what >= 0 && what < (int)_nodes.size());
 
-	Node& node = nodes_[what];
+	Node& node = _nodes[what];
 	int start = node.pos;
 
 	if (flowSpeed > 0.f || isFlying(what)) {
 		FlyQDObject* flyObj = 0;
 
 		FlyQDObjects::iterator fit;
-		for (fit = flyObjs_.begin(); fit != flyObjs_.end(); fit++) {
+		for (fit = _flyObjs.begin(); fit != _flyObjs.end(); fit++) {
 			if (fit->data == what)
 				break;
 		}
-		if (fit != flyObjs_.end()) // Этот фрагмент уже летит, просто поменять точку назначения
+		if (fit != _flyObjs.end()) // Этот фрагмент уже летит, просто поменять точку назначения
 			flyObj = fit;
 		else { // Добавляем новый летящий фрагмент
-			flyObjs_.push_back(FlyQDObject());
-			flyObj = &flyObjs_.back();
+			_flyObjs.push_back(FlyQDObject());
+			flyObj = &_flyObjs.back();
 
 			flyObj->data = what;
 
@@ -236,152 +236,152 @@ void Puzzle::put(int where, int what, float flowSpeed) {
 	}
 
 	if (where >= 0)
-		field_[where] = what;
+		_field[where] = what;
 
 	node.pos = where;
 }
 
 void Puzzle::putOnStack(int what, float speed) {
-	put(stidx((int)stack_.size()), what, speed);
-	stack_.push_back(what);
+	put(stidx((int)_stack.size()), what, speed);
+	_stack.push_back(what);
 }
 
 void Puzzle::returnToStack() {
-	assert(pickedItem_ != -1);
+	assert(_pickedItem != -1);
 	_runtime->event(EVENT_RETURN, _runtime->mousePosition());
-	if (prevPlace_ >= 0)
-		put(prevPlace_, pickedItem_);
+	if (_prevPlace >= 0)
+		put(_prevPlace, _pickedItem);
 	else
-		putOnStack(pickedItem_, returnSpeed_);
-	prevPlace_ = -1;
-	pickedItem_ = -1;
+		putOnStack(_pickedItem, _returnSpeed);
+	_prevPlace = -1;
+	_pickedItem = -1;
 	_runtime->event(EVENT_CLICK, _runtime->mousePosition());
 }
 
 void Puzzle::quant(float dt) {
-	if (pickedItem_ == -1)
+	if (_pickedItem == -1)
 		_runtime->setGameHelpVariant(0);
 	else
 		_runtime->setGameHelpVariant(1);
 
-	if (_runtime->getTime() > nextRotateTime_) {
+	if (_runtime->getTime() > _nextRotateTime) {
 		_runtime->event(EVENT_FIELD_ROTATE, mgVect2f(400, 300));
-		nextRotateTime_ = _runtime->getTime() + rotateTimePeriod_;
-		globalAngle_ = (globalAngle_ + 1) % angles_;
-		_runtime->setCompleteHelpVariant(globalAngle_);
+		_nextRotateTime = _runtime->getTime() + _rotateTimePeriod;
+		_globalAngle = (_globalAngle + 1) % _angles;
+		_runtime->setCompleteHelpVariant(_globalAngle);
 	}
 
-	FlyQDObjects::iterator fit = flyObjs_.begin();
-	while (fit != flyObjs_.end())
-		if (!isOnMouse(nodes_[fit->data]) && fit->quant(dt, nodes_[fit->data].obj, _runtime))
+	FlyQDObjects::iterator fit = _flyObjs.begin();
+	while (fit != _flyObjs.end())
+		if (!isOnMouse(_nodes[fit->data]) && fit->quant(dt, _nodes[fit->data].obj, _runtime))
 			++fit;
 		else
-			fit = flyObjs_.erase(fit);
+			fit = _flyObjs.erase(fit);
 
-	if (inField_ < (int)nodes_.size() && _runtime->getTime() > nextObjTime_ &&
-			((int)stack_.size() < stackSize_ - 1 || ((int)stack_.size() < stackSize_ && pickedItem_ == -1))) { // нужно добавить в инвентори фишку
+	if (_inField < (int)_nodes.size() && _runtime->getTime() > _nextObjTime &&
+			((int)_stack.size() < _stackSize - 1 || ((int)_stack.size() < _stackSize && _pickedItem == -1))) { // нужно добавить в инвентори фишку
 		// ищем случайный не выставленный фрагмент
-		int freeIdx = round(_runtime->rnd(0.f, nodes_.size() - 1));
-		Nodes::iterator it = nodes_.begin();
+		int freeIdx = round(_runtime->rnd(0.f, _nodes.size() - 1));
+		Nodes::iterator it = _nodes.begin();
 		for (;;) {
-			if (++it == nodes_.end())
-				it = nodes_.begin();
+			if (++it == _nodes.end())
+				it = _nodes.begin();
 			if (it->isFree())
 				if (!freeIdx--)
 					break;
 		}
-		int idx = Common::distance(nodes_.begin(), it);
+		int idx = Common::distance(_nodes.begin(), it);
 
-		++inField_;
-		nextObjTime_ = _runtime->getTime() + stackPlaceSize_.y / flySpeed_;
+		++_inField;
+		_nextObjTime = _runtime->getTime() + _stackPlaceSize.y / _flySpeed;
 
-		it->pos = stidx(stackSize_);
+		it->pos = stidx(_stackSize);
 		it->obj.setState(getStateName(it->angle, false, true));
 
-		putOnStack(idx, flySpeed_);
+		putOnStack(idx, _flySpeed);
 	}
 
 	mgVect2f mouse = _runtime->mousePosition();
 
 	int hovPlace = -1;  // Номер места которое сейчас под мышкой
-	for (int idx = 0; idx < (int)stack_.size(); ++idx)
-		if (nodes_[stack_[idx]].obj.hit(mouse)) {
+	for (int idx = 0; idx < (int)_stack.size(); ++idx)
+		if (_nodes[_stack[idx]].obj.hit(mouse)) {
 			hovPlace = stidx(idx);
 			break;
 		}
 	if (hovPlace == -1) {
-		float radius = 0.5f * size_.x;
-		for (int idx = 0; idx < gameSize_; ++idx)
+		float radius = 0.5f * _size.x;
+		for (int idx = 0; idx < _gameSize; ++idx)
 			if (dist(_runtime->world2game(position(idx)), mouse) < radius) {
 				hovPlace = idx;
 				break;
 			}
 	}
 	if (hovPlace == -1) {
-		mgVect2i st = stackBottom_->screen_R();
-		st.y -= stackPlaceSize_.y * stackSize_ - 0.5f * stackPlaceSize_.x;
-		Rectf stackPos(st.x - 0.5f * stackPlaceSize_.x, st.y, stackPlaceSize_.x, stackPlaceSize_.y * stackSize_);
+		mgVect2i st = _stackBottom->screen_R();
+		st.y -= _stackPlaceSize.y * _stackSize - 0.5f * _stackPlaceSize.x;
+		Rectf stackPos(st.x - 0.5f * _stackPlaceSize.x, st.y, _stackPlaceSize.x, _stackPlaceSize.y * _stackSize);
 		if (stackPos.point_inside(mouse))
-			hovPlace = stidx(stackSize_);
+			hovPlace = stidx(_stackSize);
 	}
 
 	if (_runtime->mouseLeftPressed()) {
 		if (hovPlace >= 0) { // клик по полю
-			Indexes::value_type& hovItem = field_[hovPlace];
+			Indexes::value_type& hovItem = _field[hovPlace];
 			if (hovItem == -1) // клик по пустой ячейке
-				if (pickedItem_ == -1) // на мыши ничего нет
+				if (_pickedItem == -1) // на мыши ничего нет
 					_runtime->event(EVENT_CLICK, mouse);
 				else { // кладем фрагмент с мыши
-					put(hovPlace, pickedItem_);
-					if (testPlace(pickedItem_)) // положили на свое свое место
+					put(hovPlace, _pickedItem);
+					if (testPlace(_pickedItem)) // положили на свое свое место
 						_runtime->event(EVENT_PUT_RIGHT, mouse);
 					else // просто положили
 						_runtime->event(EVENT_PUT, mouse);
-					pickedItem_ = -1;
-					prevPlace_ = -1;
+					_pickedItem = -1;
+					_prevPlace = -1;
 				} else { // клик по непустой ячейке
 				if (testPlace(hovPlace)) // клик по правильно уложенной фишке
 					_runtime->event(EVENT_CLICK_RIGHT, mouse);
-				else if (pickedItem_ != -1) { // поменять с тем что на мыше
+				else if (_pickedItem != -1) { // поменять с тем что на мыше
 					bool swap = true;
-					if (prevPlace_ >= 0)
-						put(prevPlace_, hovItem);
+					if (_prevPlace >= 0)
+						put(_prevPlace, hovItem);
 					else
-						putOnStack(hovItem, returnSpeed_);
+						putOnStack(hovItem, _returnSpeed);
 					if (testPlace(hovItem)) { // оказалась при обмене на своем месте
-						_runtime->event(EVENT_PUT_RIGHT, _runtime->world2game(position(prevPlace_)));
+						_runtime->event(EVENT_PUT_RIGHT, _runtime->world2game(position(_prevPlace)));
 						swap = false;
 					}
-					put(hovPlace, pickedItem_);
-					if (testPlace(pickedItem_)) { // положили на свое свое место
+					put(hovPlace, _pickedItem);
+					if (testPlace(_pickedItem)) { // положили на свое свое место
 						_runtime->event(EVENT_PUT_RIGHT, mouse);
 						swap = false;
 					}
 					if (swap) // просто обменяли
 						_runtime->event(EVENT_SWAP, mouse);
-					pickedItem_ = -1;
-					prevPlace_ = -1;
+					_pickedItem = -1;
+					_prevPlace = -1;
 				} else { // взять фрагмент на мышь
 					_runtime->event(EVENT_GET, mouse);
-					prevPlace_ = hovPlace;
-					pickedItem_ = hovItem;
-					nodes_[pickedItem_].pos = mouseObjPose_;
+					_prevPlace = hovPlace;
+					_pickedItem = hovItem;
+					_nodes[_pickedItem].pos = _mouseObjPose;
 					hovItem = -1;
 				}
 			}
 		} else if (hovPlace < -1) { // клик по стеку
 			int hovStack = stidx(hovPlace);
-			if (pickedItem_ == -1) // на мыши ничего нет
-				if (hovStack < (int)stack_.size()) { // взять фрагмент из стека на мышь
+			if (_pickedItem == -1) // на мыши ничего нет
+				if (hovStack < (int)_stack.size()) { // взять фрагмент из стека на мышь
 					_runtime->event(EVENT_GET, mouse);
-					Indexes::iterator it = stack_.begin() + hovStack;
+					Indexes::iterator it = _stack.begin() + hovStack;
 					assert(*it >= 0);
-					prevPlace_ = -1;
-					pickedItem_ = *it;
-					nodes_[pickedItem_].pos = mouseObjPose_;
-					stack_.erase(it);
-					for (int idx = hovStack; idx < (int)stack_.size(); ++idx)
-						put(stidx(idx), stack_[idx], flySpeed_);
+					_prevPlace = -1;
+					_pickedItem = *it;
+					_nodes[_pickedItem].pos = _mouseObjPose;
+					_stack.erase(it);
+					for (int idx = hovStack; idx < (int)_stack.size(); ++idx)
+						put(stidx(idx), _stack[idx], _flySpeed);
 				} else // пустой клик в области стека
 					_runtime->event(EVENT_CLICK, mouse);
 			else // вернуть фишку на место
@@ -389,12 +389,12 @@ void Puzzle::quant(float dt) {
 		} else // пустой клик мимо игрового поля
 			_runtime->event(EVENT_CLICK, mouse);
 	} else if (_runtime->mouseRightPressed()) {
-		if (pickedItem_ == -1) {
+		if (_pickedItem == -1) {
 			if (hovPlace >= 0) { // клик по полю
 				if (testPlace(hovPlace)) // клик по правильно уложенной фишке
 					_runtime->event(EVENT_CLICK_RIGHT, mouse);
 				else {
-					Indexes::value_type& hovItem = field_[hovPlace];
+					Indexes::value_type& hovItem = _field[hovPlace];
 					if (hovItem >= 0) {
 						rotate(hovItem);
 						if (testPlace(hovItem)) // повернули на правильный угол
@@ -406,9 +406,9 @@ void Puzzle::quant(float dt) {
 				}
 			} else  if (hovPlace < -1) { // клик по стеку
 				int hovStack = stidx(hovPlace);
-				if (hovStack < (int)stack_.size()) { // покрутить внутри стека
+				if (hovStack < (int)_stack.size()) { // покрутить внутри стека
 					_runtime->event(EVENT_ROTATE_IN_STACK, mouse);
-					rotate(stack_[hovStack]);
+					rotate(_stack[hovStack]);
 				} else // попытка прокрутить пустое место
 					_runtime->event(EVENT_CLICK, mouse);
 			} else // пустой клик мимо игрового поля
@@ -418,8 +418,8 @@ void Puzzle::quant(float dt) {
 	}
 
 	bool iWin = true;
-	for (int idx = 0; idx < (int)nodes_.size(); ++idx) {
-		Node& node = nodes_[idx];
+	for (int idx = 0; idx < (int)_nodes.size(); ++idx) {
+		Node& node = _nodes[idx];
 		if (node.pos != -1) {
 			if (node.pos >= 0) {
 				if (isFlying(idx))
@@ -428,11 +428,11 @@ void Puzzle::quant(float dt) {
 					node.obj.setState(getStateName(node.angle, node.pos == hovPlace && !testPlace(idx), false));
 					node.obj->set_R(position(node.pos));
 				}
-			} else if (idx == pickedItem_) {
+			} else if (idx == _pickedItem) {
 				node.obj.setState(getStateName(node.angle, hovPlace >= 0 && !testPlace(hovPlace), false));
-				node.obj->set_R(_runtime->game2world(mouse, stackBottom_.depth(_runtime) - 200));
+				node.obj->set_R(_runtime->game2world(mouse, _stackBottom.depth(_runtime) - 200));
 			} else {
-				node.obj.setState(getStateName(node.angle, node.pos == hovPlace && pickedItem_ == -1, true));
+				node.obj.setState(getStateName(node.angle, node.pos == hovPlace && _pickedItem == -1, true));
 				if (!isFlying(idx))
 					node.obj->set_R(stackPosition(stidx(node.pos)));
 			}
@@ -449,27 +449,27 @@ void Puzzle::quant(float dt) {
 }
 
 const mgVect3f &Puzzle::position(int num) const {
-	assert(num >= 0 && num < (int)positions_.size());
+	assert(num >= 0 && num < (int)_positions.size());
 	// Если глобальный поворот ненулевой, пересчитываем индекс
-	if (globalAngle_ > 0) {
-		int size = sqrt((float)gameSize_);
+	if (_globalAngle > 0) {
+		int size = sqrt((float)_gameSize);
 		int y = num / size;
 		int x = num - y * size;
 		--size;
-		for (int angle = 0; angle < globalAngle_; ++angle) {
+		for (int angle = 0; angle < _globalAngle; ++angle) {
 			int tmp = x;
 			x = size - y;
 			y = tmp;
 		}
 		num = y * (size + 1) + x;
 	}
-	assert(num >= 0 && num < (int)positions_.size());
-	return positions_[num];
+	assert(num >= 0 && num < (int)_positions.size());
+	return _positions[num];
 }
 
 mgVect3f Puzzle::stackPosition(int num) const {
-	mgVect3f bottom = _runtime->world2game(stackBottom_);
-	bottom.y -= stackPlaceSize_.y * num;
+	mgVect3f bottom = _runtime->world2game(_stackBottom);
+	bottom.y -= _stackPlaceSize.y * num;
 	return _runtime->game2world(bottom);
 }
 
diff --git a/engines/qdengine/minigames/adv/m_puzzle.h b/engines/qdengine/minigames/adv/m_puzzle.h
index 19c71d528cb..235bc581b3f 100644
--- a/engines/qdengine/minigames/adv/m_puzzle.h
+++ b/engines/qdengine/minigames/adv/m_puzzle.h
@@ -54,42 +54,42 @@ public:
 	void quant(float dt);
 
 private:
-	int gameSize_;
-	int angles_;
+	int _gameSize;
+	int _angles;
 
-	int globalAngle_;
-	float rotateTimePeriod_;
-	float nextRotateTime_;
+	int _globalAngle;
+	float _rotateTimePeriod;
+	float _nextRotateTime;
 
-	bool singleSize_;
-	mgVect2f size_;
+	bool _singleSize;
+	mgVect2f _size;
 	float depth_;
 
-	Nodes nodes_;
+	Nodes _nodes;
 	/// Номер места с которого взяли фрагмент
-	int prevPlace_;
+	int _prevPlace;
 	/// Индекс фрагмента на мыши
-	int pickedItem_;
+	int _pickedItem;
 
-	int inField_;
+	int _inField;
 
-	float nextObjTime_;
-	int mouseObjPose_;
+	float _nextObjTime;
+	int _mouseObjPose;
 
-	QDObject stackBottom_;
-	int stackSize_;
-	mgVect2f stackPlaceSize_;
+	QDObject _stackBottom;
+	int _stackSize;
+	mgVect2f _stackPlaceSize;
 
-	Indexes stack_;
-	Indexes field_;
+	Indexes _stack;
+	Indexes _field;
 
-	FlyQDObjects flyObjs_;
+	FlyQDObjects _flyObjs;
 	/// скорость падения новых в стек
-	float flySpeed_;
+	float _flySpeed;
 	/// скорость возврата в стек
-	float returnSpeed_;
+	float _returnSpeed;
 
-	Coords positions_;
+	Coords _positions;
 
 	const char *getStateName(int angle, bool selected, bool small) const;
 	/// повернуть фишку


Commit: 983f3c73ae88060be65e8cc3f2223c420a1f10ba
    https://github.com/scummvm/scummvm/commit/983f3c73ae88060be65e8cc3f2223c420a1f10ba
Author: Eugene Sandulenko (sev at scummvm.org)
Date: 2025-06-12T00:20:44+02:00

Commit Message:
QDENGINE: Init class variables. CID 1611412

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


diff --git a/engines/qdengine/minigames/adv/m_karaoke.h b/engines/qdengine/minigames/adv/m_karaoke.h
index e552e2dda5e..49eb6c09540 100644
--- a/engines/qdengine/minigames/adv/m_karaoke.h
+++ b/engines/qdengine/minigames/adv/m_karaoke.h
@@ -40,8 +40,8 @@ public:
 	};
 
 private:
-	const char *_controlName;
-	const char *_colorReaded;
+	const char *_controlName = nullptr;
+	const char *_colorReaded = nullptr;
 
 	struct Node {
 		Node();
@@ -53,10 +53,10 @@ private:
 	typedef Std::vector<Node> Nodes;
 	Nodes _nodes;
 
-	float _startTime;
-	int _startScreenTag;
-	int _currentTag;
-	float _startTagTime;
+	float _startTime = 0.f;
+	int _startScreenTag = 0;
+	int _currentTag = 0;
+	float _startTagTime = 0.f;
 
 	MinigameManager *_runtime;
 };


Commit: bc02d51c5443d2790d6b2ecb4b86b1d675f88539
    https://github.com/scummvm/scummvm/commit/bc02d51c5443d2790d6b2ecb4b86b1d675f88539
Author: Eugene Sandulenko (sev at scummvm.org)
Date: 2025-06-12T00:23:43+02:00

Commit Message:
QDENGINE: Initialize class variables. CID 1566534

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 832116a8e78..34ab3fb4923 100644
--- a/engines/qdengine/minigames/adv/m_puzzle.cpp
+++ b/engines/qdengine/minigames/adv/m_puzzle.cpp
@@ -149,7 +149,7 @@ Puzzle::Puzzle(MinigameManager *runtime) {
 	_size = _runtime->getSize(_nodes[0].obj);
 	debugC(2, kDebugMinigames, "size = (%6.2f,%6.2f)", _size.x, _size.y);
 
-	depth_ = _nodes[0].obj.depth(runtime);
+	_depth = _nodes[0].obj.depth(runtime);
 
 	_stackPlaceSize = _runtime->getParameter("inventory_place_size", _size * 1.2f);
 	assert(_stackPlaceSize.x > 0.f && _stackPlaceSize.x < 500.f && _stackPlaceSize.y > 0.f && _stackPlaceSize.y < 500.f);
diff --git a/engines/qdengine/minigames/adv/m_puzzle.h b/engines/qdengine/minigames/adv/m_puzzle.h
index 235bc581b3f..82065b4fcc0 100644
--- a/engines/qdengine/minigames/adv/m_puzzle.h
+++ b/engines/qdengine/minigames/adv/m_puzzle.h
@@ -54,30 +54,30 @@ public:
 	void quant(float dt);
 
 private:
-	int _gameSize;
-	int _angles;
+	int _gameSize = 0;
+	int _angles = 0;
 
-	int _globalAngle;
-	float _rotateTimePeriod;
-	float _nextRotateTime;
+	int _globalAngle = 0;
+	float _rotateTimePeriod = 0.f;
+	float _nextRotateTime = 0.f;
 
-	bool _singleSize;
+	bool _singleSize = false;
 	mgVect2f _size;
-	float depth_;
+	float _depth = 0.f;
 
 	Nodes _nodes;
 	/// Номер места с которого взяли фрагмент
-	int _prevPlace;
+	int _prevPlace = -1;
 	/// Индекс фрагмента на мыши
-	int _pickedItem;
+	int _pickedItem = -1;
 
-	int _inField;
+	int _inField = 0; // количество фрагментов на поле
 
-	float _nextObjTime;
-	int _mouseObjPose;
+	float _nextObjTime = 0.f;
+	int _mouseObjPose = -1; // индекс положения фрагмента на мыши в стеке
 
 	QDObject _stackBottom;
-	int _stackSize;
+	int _stackSize = 0;
 	mgVect2f _stackPlaceSize;
 
 	Indexes _stack;
@@ -85,9 +85,9 @@ private:
 
 	FlyQDObjects _flyObjs;
 	/// скорость падения новых в стек
-	float _flySpeed;
+	float _flySpeed = 0.f;
 	/// скорость возврата в стек
-	float _returnSpeed;
+	float _returnSpeed = -1.f;
 
 	Coords _positions;
 


Commit: a62e56fe21db15f01c32be49147bd2892982be5f
    https://github.com/scummvm/scummvm/commit/a62e56fe21db15f01c32be49147bd2892982be5f
Author: Eugene Sandulenko (sev at scummvm.org)
Date: 2025-06-12T00:25:17+02:00

Commit Message:
QDENGINE: Initialize class vairables. CID 1566538

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


diff --git a/engines/qdengine/minigames/adv/m_scores.h b/engines/qdengine/minigames/adv/m_scores.h
index e0eaf09dffb..fbb24d4eab2 100644
--- a/engines/qdengine/minigames/adv/m_scores.h
+++ b/engines/qdengine/minigames/adv/m_scores.h
@@ -58,13 +58,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 = nullptr;
+	const char *_bestScore = nullptr;
+	const char *_bestTime = nullptr;
+	const char *_lastScore = nullptr;
+	const char *_lastTime = nullptr;
 
-	const char *_timeFormat;
+	const char *_timeFormat = nullptr;
 
 	QDObject _prev;
 	QDObject _next;
@@ -73,8 +73,8 @@ private:
 
 	QDObjects _games;
 
-	int _preLevel;
-	int _level;
+	int _preLevel = -1;
+	int _level = -1;
 
 	Coords _positions;
 


Commit: f8e782423a5ce2df5398c43f72b1cf4117a5b864
    https://github.com/scummvm/scummvm/commit/f8e782423a5ce2df5398c43f72b1cf4117a5b864
Author: Eugene Sandulenko (sev at scummvm.org)
Date: 2025-06-12T00:26:32+02:00

Commit Message:
QDENGINE: Initialize class variables. CID 1566533

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


diff --git a/engines/qdengine/minigames/adv/m_swap.h b/engines/qdengine/minigames/adv/m_swap.h
index ee02bcb34f9..0bed1023201 100644
--- a/engines/qdengine/minigames/adv/m_swap.h
+++ b/engines/qdengine/minigames/adv/m_swap.h
@@ -35,11 +35,11 @@ public:
 
 	void quant(float dt);
 private:
-	int _gameSize;
-	int _angles;
+	int _gameSize = 0;
+	int _angles = 0;
 
-	float _rotateTimePeriod;
-	float _nextRotateTime;
+	float _rotateTimePeriod = 0.5f; // время поворота фишки
+	float _nextRotateTime = 0.f; // время следующего поворота
 
 	mgVect2f _size;
 
@@ -53,9 +53,9 @@ private:
 	Nodes _nodes;
 
 	// Индекс фрагмента на мыши
-	int _pickedItem;
+	int _pickedItem = -1;
 	// активные фрагменты после обмена
-	int _last1, _last2;
+	int _last1 = 0, _last2 = 0;
 
 	Coords _positions;
 


Commit: 8649e9e6b151e408719b860dd22f9573eee3bb25
    https://github.com/scummvm/scummvm/commit/8649e9e6b151e408719b860dd22f9573eee3bb25
Author: Eugene Sandulenko (sev at scummvm.org)
Date: 2025-06-12T00:28:46+02:00

Commit Message:
QDENGINE: Initialize class variable. CID 1611405

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


diff --git a/engines/qdengine/minigames/adv/m_triangles.h b/engines/qdengine/minigames/adv/m_triangles.h
index ba1b5e0d668..a08eb49070d 100644
--- a/engines/qdengine/minigames/adv/m_triangles.h
+++ b/engines/qdengine/minigames/adv/m_triangles.h
@@ -91,7 +91,7 @@ private:
 	int _selected = 0;
 	int _hovered = 0;
 
-	bool _quickReselect;
+	bool _quickReselect = false;
 
 	AnimationState _animationState = NO_ANIMATION;
 	int _animatedNodes[2] =  { 0 };


Commit: 89e71ebec479a8b8291af9cd86ee11827d5670de
    https://github.com/scummvm/scummvm/commit/89e71ebec479a8b8291af9cd86ee11827d5670de
Author: Eugene Sandulenko (sev at scummvm.org)
Date: 2025-06-12T00:34:39+02:00

Commit Message:
ENGINES: Prevent resource leak in ExtendedSavegameHeader. CID 1591629

Changed paths:
    engines/metaengine.cpp
    engines/metaengine.h


diff --git a/engines/metaengine.cpp b/engines/metaengine.cpp
index ec96298415b..8be8ef2bb8b 100644
--- a/engines/metaengine.cpp
+++ b/engines/metaengine.cpp
@@ -208,6 +208,14 @@ bool MetaEngine::hasFeature(MetaEngineFeature f) const {
 //// Extended Saves
 /////////////////////////////////////////
 
+ExtendedSavegameHeader::~ExtendedSavegameHeader() {
+	if (thumbnail)
+		thumbnail->free();
+
+	delete thumbnail;
+}
+
+
 void MetaEngine::appendExtendedSave(Common::OutSaveFile *saveFile, uint32 playtime,
 		Common::String desc, bool isAutosave) {
 	appendExtendedSaveToStream(saveFile, playtime, desc, isAutosave);
diff --git a/engines/metaengine.h b/engines/metaengine.h
index 116cd4c5491..ee145eecca1 100644
--- a/engines/metaengine.h
+++ b/engines/metaengine.h
@@ -111,6 +111,8 @@ struct ExtendedSavegameHeader {
 		thumbnail = nullptr;
 		isAutosave = false;
 	}
+
+	~ExtendedSavegameHeader();
 };
 
 /**


Commit: 38389b986dc5fb55d6f7dd72047e6533e20b199a
    https://github.com/scummvm/scummvm/commit/38389b986dc5fb55d6f7dd72047e6533e20b199a
Author: Eugene Sandulenko (sev at scummvm.org)
Date: 2025-06-12T00:38:58+02:00

Commit Message:
QDENGINE: Fix potential division by zero. CID 1591720

Changed paths:
    engines/qdengine/qdcore/qd_game_object_moving.cpp


diff --git a/engines/qdengine/qdcore/qd_game_object_moving.cpp b/engines/qdengine/qdcore/qd_game_object_moving.cpp
index f559f12e9bf..15d0a36fac9 100644
--- a/engines/qdengine/qdcore/qd_game_object_moving.cpp
+++ b/engines/qdengine/qdcore/qd_game_object_moving.cpp
@@ -1667,10 +1667,19 @@ float qdGameObjectMoving::calc_scale(const Vect3f &r) const {
 	if (!check_flag(QD_OBJ_NO_SCALE_FLAG)) {
 		float scale;
 
-		if (!check_flag(QD_OBJ_INVERSE_PERSPECTIVE_FLAG))
+		if (!check_flag(QD_OBJ_INVERSE_PERSPECTIVE_FLAG)) {
 			scale = qdCamera::current_camera()->get_scale(r) * _scale;
-		else
-			scale = _scale / qdCamera::current_camera()->get_scale(r);
+		} else {
+			float scale1 = qdCamera::current_camera()->get_scale(r);
+
+			if (scale1) {
+				// Если инверсная перспектива, то масштабируем по инверсной формуле
+				scale = 1.0f / scale1;
+			} else {
+				// Если нулевой масштаб, то не масштабируем
+				scale = 1.0f;
+			}
+		}
 
 		return scale;
 	}


Commit: 9b151b58b25457e9b0271821df830d1556fe7d82
    https://github.com/scummvm/scummvm/commit/9b151b58b25457e9b0271821df830d1556fe7d82
Author: Eugene Sandulenko (sev at scummvm.org)
Date: 2025-06-12T00:41:01+02:00

Commit Message:
QDENGINE: Check that file is truly open before reading. CID 1611381

Changed paths:
    engines/qdengine/qdcore/qd_setup.cpp


diff --git a/engines/qdengine/qdcore/qd_setup.cpp b/engines/qdengine/qdcore/qd_setup.cpp
index ee906d9f5f7..567f5bae136 100644
--- a/engines/qdengine/qdcore/qd_setup.cpp
+++ b/engines/qdengine/qdcore/qd_setup.cpp
@@ -30,7 +30,12 @@ bool enumerateIniSections(Common::INIFile& ini, const Common::Path &fname, Commo
 
 	Common::Path iniFilePath(fname);
 	ini.allowNonEnglishCharacters();
-	ini.loadFromFile(iniFilePath);
+
+	if (!ini.loadFromFile(iniFilePath)) {
+		warning("Failed to load INI file: %s", iniFilePath.toString().c_str());
+		return false;
+	}
+
 	sectionList = ini.getSections();
 	int size = sectionList.size();
 


Commit: 34ff7c572d334d9e4cff4d6c259bb4c49b377a54
    https://github.com/scummvm/scummvm/commit/34ff7c572d334d9e4cff4d6c259bb4c49b377a54
Author: Eugene Sandulenko (sev at scummvm.org)
Date: 2025-06-12T00:42:46+02:00

Commit Message:
QDENGINE: Fix potential NULL dereference. CID 1611402

Changed paths:
    engines/qdengine/qdcore/qd_game_scene.cpp


diff --git a/engines/qdengine/qdcore/qd_game_scene.cpp b/engines/qdengine/qdcore/qd_game_scene.cpp
index ba4be37df1f..09183ac4ebe 100644
--- a/engines/qdengine/qdcore/qd_game_scene.cpp
+++ b/engines/qdengine/qdcore/qd_game_scene.cpp
@@ -897,7 +897,8 @@ void qdGameScene::set_active_personage(qdGameObjectMoving *p) {
 	_camera.set_default_object(p);
 
 	if (g_engine->_gameVersion <= 20040601) {
-		_selected_object->set_last_move_order(_selected_object->R());
+		if (_selected_object)
+			_selected_object->set_last_move_order(_selected_object->R());
 	}
 
 	if (p && p->has_camera_mode()) {

More information about the Scummvm-git-logs mailing list