[Scummvm-git-logs] scummvm master -> 04d959c894fbf5591f704484309340b699af34d7

sev- noreply at scummvm.org
Fri Oct 18 10:10:18 UTC 2024 

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

Summary:
cf2755a9e1 QDENGINE: More work on compilation fixes for minigames/adv
04d959c894 QDENGINE: Renames in class variables in minigames/adv


Commit: cf2755a9e1493b41644ef62684b2ecb7100d24e8
    https://github.com/scummvm/scummvm/commit/cf2755a9e1493b41644ef62684b2ecb7100d24e8
Author: Eugene Sandulenko (sev at scummvm.org)
Date: 2024-10-18T11:44:27+02:00

Commit Message:
QDENGINE: More work on compilation fixes for minigames/adv

Changed paths:
    engines/qdengine/minigames/adv/EventManager.cpp
    engines/qdengine/minigames/adv/EventManager.h
    engines/qdengine/minigames/adv/FlyObject.h
    engines/qdengine/minigames/adv/ObjectContainer.cpp
    engines/qdengine/minigames/adv/RunTime.h
    engines/qdengine/minigames/adv/TextManager.cpp
    engines/qdengine/minigames/adv/TextManager.h
    engines/qdengine/minigames/adv/qdMath.h
    engines/qdengine/module.mk


diff --git a/engines/qdengine/minigames/adv/EventManager.cpp b/engines/qdengine/minigames/adv/EventManager.cpp
index 35b68e7208d..fbf9b91468e 100644
--- a/engines/qdengine/minigames/adv/EventManager.cpp
+++ b/engines/qdengine/minigames/adv/EventManager.cpp
@@ -19,6 +19,9 @@
  *
  */
 
+#include "common/debug.h"
+
+#include "qdengine/qdengine.h"
 #include "qdengine/minigames/adv/common.h"
 #include "qdengine/minigames/adv/EventManager.h"
 #include "qdengine/minigames/adv/RunTime.h"
@@ -39,23 +42,28 @@ EventManager::EventManager() {
 	char str_cache[256];
 
 	for (int idx = 0;; ++idx) {
-		_snprintf(str_cache, 127, "register_trigger_%d", idx);
-		if (const char * descr = runtime->parameter(str_cache, false))
+		snprintf(str_cache, 127, "register_trigger_%d", idx);
+		if (const char *descr = runtime->parameter(str_cache, false))
 			triggerEvents_.push_back(runtime->getObject(descr));
 		else
 			break;
 	}
-	dprintf("registered %d trigger objects\n", triggerEvents_.size());
+	debugC(2, kDebugMinigames, "EventManager(): registered %d trigger objects", triggerEvents_.size());
 
 	eventPresets_.resize(SYSTEM_EVENTS_SIZE);
 	for (int idx = 0; idx < SYSTEM_EVENTS_SIZE; ++idx) {
-		_snprintf(str_cache, 127, "system_event_%d", idx);
+		snprintf(str_cache, 127, "system_event_%d", idx);
 		if (const char * descr = runtime->parameter(str_cache, false)) {
 			EventPreset preset;
 			int read = sscanf(descr, "%d %d", &preset.score, &preset.triggerEventID);
-			xxassert(read == 2, (XBuffer() < "Неверная строка для описания" < str_cache).c_str());
+
+			if (read != 2)
+				error("EventManager(): Incorrect description string: %s", str_cache);
+
 			if (read == 2) {
-				xxassert(preset.triggerEventID < (int)triggerEvents_.size(), (XBuffer() < "Ссылка на незарегистрированный триггер в " < str_cache).c_str());
+				if (preset.triggerEventID >= (int)triggerEvents_.size())
+					error("EventManager(): Reference to an unregistered trigger in %s", str_cache);
+
 				if (preset.triggerEventID < (int)triggerEvents_.size())
 					eventPresets_[idx] = preset;
 			}
@@ -63,12 +71,17 @@ EventManager::EventManager() {
 	}
 
 	for (int idx = 0;; ++idx) {
-		_snprintf(str_cache, 127, "register_event_%d", idx);
+		snprintf(str_cache, 127, "register_event_%d", idx);
 		if (const char * descr = runtime->parameter(str_cache, false)) {
 			EventPreset preset;
 			int read = sscanf(descr, "%d %d %d %d", &preset.score, &preset.fontID, &preset.escapeID, &preset.triggerEventID);
-			xxassert(read == 4, (XBuffer() < "Неверная строка для описания события " < idx).c_str());
-			xxassert(preset.triggerEventID < (int)triggerEvents_.size(), (XBuffer() < "Ссылка на незарегистрированный триггер в " < str_cache).c_str());
+
+			if (read != 4)
+				error("EventManager(): Incorrect event description string: %d", idx);
+
+			if (preset.triggerEventID >= (int)triggerEvents_.size())
+				error("EventManager(): Reference to an unregistered trigger in %s", str_cache);
+
 			if (read == 4 && preset.triggerEventID < (int)triggerEvents_.size())
 				eventPresets_.push_back(preset);
 			else
@@ -76,7 +89,7 @@ EventManager::EventManager() {
 		} else
 			break;
 	}
-	dprintf("registered %d events\n", eventPresets_.size());
+	debugC(2, kDebugMinigames, "EventManager(): registered %d events", eventPresets_.size());
 
 	if (const char * data = runtime->parameter("allow_negative", false)) {
 		int tmp;
@@ -87,17 +100,17 @@ EventManager::EventManager() {
 }
 
 void EventManager::sysEvent(int eventID) {
-	xassert(eventID >= 0);
-	//dprintf("System event: %d\n", eventID);
+	assert(eventID >= 0);
+	debugC(6, kDebugMinigames, "EventManager() System event: %d", eventID);
 
-	xassert(eventID < SYSTEM_EVENTS_SIZE);
+	assert(eventID < SYSTEM_EVENTS_SIZE);
 
 	mgVect2i pos = runtime->screenSize() / 2;
 	event(eventID - SYSTEM_EVENTS_SIZE, mgVect2f(pos.x, pos.y), 1);
 }
 
 void EventManager::event(int eventID, const mgVect2f& pos, int factor) {
-	//dprintf("Event: %d, pos=(%5.1f, %5.1f), fartor=%d\n", eventID, pos.x, pos.y, factor);
+	debugC(6, kDebugMinigames, "EventManager() Event: %d, pos=(%5.1f, %5.1f), fartor=%d", eventID, pos.x, pos.y, factor);
 
 	eventID += SYSTEM_EVENTS_SIZE;
 
@@ -107,7 +120,7 @@ void EventManager::event(int eventID, const mgVect2f& pos, int factor) {
 	const EventPreset& pr = eventPresets_[eventID];
 
 	if (pr.triggerEventID >= 0) {
-		xassert(pr.triggerEventID < triggerEvents_.size());
+		assert(pr.triggerEventID < triggerEvents_.size());
 		triggerEvents_[pr.triggerEventID]->set_state("on");
 	}
 
diff --git a/engines/qdengine/minigames/adv/EventManager.h b/engines/qdengine/minigames/adv/EventManager.h
index 490a80a8d9a..e4c91ef3755 100644
--- a/engines/qdengine/minigames/adv/EventManager.h
+++ b/engines/qdengine/minigames/adv/EventManager.h
@@ -47,7 +47,7 @@ private:
 		int escapeID;
 		int triggerEventID;
 	};
-	typedef vector<EventPreset> EventPresets;
+	typedef Std::vector<EventPreset> EventPresets;
 	EventPresets eventPresets_;
 
 	QDObjects triggerEvents_;
diff --git a/engines/qdengine/minigames/adv/FlyObject.h b/engines/qdengine/minigames/adv/FlyObject.h
index f2ab50e0dfb..75a0e0f9242 100644
--- a/engines/qdengine/minigames/adv/FlyObject.h
+++ b/engines/qdengine/minigames/adv/FlyObject.h
@@ -47,7 +47,7 @@ struct FlyQDObject : public FlyObjectBase {
 	int data;
 };
 
-typedef vector<FlyQDObject> FlyQDObjects;
+typedef Std::vector<FlyQDObject> FlyQDObjects;
 
 } // namespace QDEngine
 
diff --git a/engines/qdengine/minigames/adv/ObjectContainer.cpp b/engines/qdengine/minigames/adv/ObjectContainer.cpp
index 1ca2e90eecb..7a4948cf154 100644
--- a/engines/qdengine/minigames/adv/ObjectContainer.cpp
+++ b/engines/qdengine/minigames/adv/ObjectContainer.cpp
@@ -19,6 +19,7 @@
  *
  */
 
+#include "qdengine/qdengine.h"
 #include "qdengine/minigames/adv/common.h"
 #include "qdengine/minigames/adv/ObjectContainer.h"
 #include "qdengine/minigames/adv/RunTime.h"
@@ -31,16 +32,15 @@ ObjectContainer::ObjectContainer() {
 }
 
 void ObjectContainer::release() {
-	QDObjects::iterator it;
-	FOR_EACH(objects_, it)
-	runtime->release(*it);
+	for (auto &it : objects_)
+		runtime->release(it);
 
 	objects_.clear();
 	current_ = 0;
 }
 
 void ObjectContainer::pushObject(QDObject& obj) {
-	xassert(find(objects_.begin(), objects_.end(), obj) == objects_.end());
+	assert(Common::find(objects_.begin(), objects_.end(), obj) == objects_.end());
 	objects_.push_back(obj);
 }
 
@@ -55,7 +55,7 @@ const char *ObjectContainer::name() const {
 
 bool ObjectContainer::load(const char* base_name, bool hide) {
 	if (!runtime->testObject(base_name)) {
-		xxassert(false, (XBuffer() < "Не найден объект: \"" < base_name < "\"").c_str());
+		warning("ObjectContainer::load(): Object '%s' not found", transCyrillic(base_name));
 		return false;
 	}
 
@@ -72,7 +72,7 @@ bool ObjectContainer::load(const char* base_name, bool hide) {
 	char name[128];
 	name[127] = 0;
 	for (int dubl = 0; ; ++dubl) {
-		_snprintf(name, 127, "%s%04d", base_name, dubl);
+		snprintf(name, 127, "%s%04d", base_name, dubl);
 		if (runtime->testObject(name)) {
 			obj = runtime->getObject(name);
 			pushObject(obj);
@@ -86,27 +86,24 @@ bool ObjectContainer::load(const char* base_name, bool hide) {
 }
 
 void ObjectContainer::hideAll() {
-	QDObjects::iterator it;
-	FOR_EACH(objects_, it)
-	runtime->hide(*it);
+	for (auto &it : objects_)
+		runtime->hide(it);
 }
 
 QDObject ObjectContainer::getObject() {
 	if (current_ < objects_.size())
 		return objects_[current_++];
-	xxassert(0, (XBuffer() < "кончились объекты \"" < name() < "\" в пуле").c_str());
-//#ifdef _DEBUG
-//	return QDObject::ZERO;
-//#else
-	return objects_[0]; // плохо, но альтернатива это вообще упасть
-//#endif
+
+	return objects_[0]; // bad, but better than crashing
 
 }
 
 void ObjectContainer::releaseObject(QDObject& obj) {
-	QDObjects::iterator it = find(objects_.begin(), objects_.end(), obj);
+	QDObjects::iterator it = Common::find(objects_.begin(), objects_.end(), obj);
 	if (it != objects_.end()) {
-		xxassert((int)distance(objects_.begin(), it) < current_, (XBuffer() < "объект в пул \"" < name() < "\" возвращен несколько раз").c_str());
+		if ((int)Common::distance(objects_.begin(), it) >= current_)
+			error("ObjectContainer::releaseObject(): Object released more than once in to the pool: %s", transCyrillic(name()));
+
 		runtime->hide(obj);
 		if (current_ > 0)
 			swap(*it, objects_[--current_]);
diff --git a/engines/qdengine/minigames/adv/RunTime.h b/engines/qdengine/minigames/adv/RunTime.h
index 37f73f05a3f..ce60fd6da60 100644
--- a/engines/qdengine/minigames/adv/RunTime.h
+++ b/engines/qdengine/minigames/adv/RunTime.h
@@ -24,6 +24,10 @@
 
 #include "common/hashmap.h"
 
+namespace Common {
+class MemoryWriteStream;
+}
+
 namespace QDEngine {
 
 class qdEngineInterface;
@@ -92,7 +96,7 @@ public:
 	// finish MiniGame virtual interface
 
 	// при необходимости заменяет на неизмененные предыдущим прохождением данные
-	bool processGameData(XBuffer& data);
+	bool processGameData(Common::MemoryWriteStream& data);
 
 	mgVect2f mousePosition() const {
 		return mousePos_;
@@ -242,8 +246,17 @@ private:
 			return gameLevel_ == rs.gameLevel_ ? gameNum_ < rs.gameNum_ : gameLevel_ < rs.gameLevel_;
 		}
 	};
+
+	struct GameInfoIndex_Hash {
+        uint operator()(const GameInfoIndex& x) const { return (x.gameNum_ << 16) + x.gameLevel_; }
+	};
+
+	struct GameInfoIndex_EqualTo {
+        uint operator()(const GameInfoIndex& x, const GameInfoIndex& y) const { return x.gameNum_ == y.gameNum_ && x.gameLevel_ == y.gameLevel_; }
+	};
+
 	// информация о пройденных играх
-	typedef Common::HashMap<GameInfoIndex, GameInfo> GameInfoMap;
+	typedef Common::HashMap<GameInfoIndex, GameInfo, GameInfoIndex_Hash, GameInfoIndex_EqualTo> GameInfoMap;
 	GameInfoMap gameInfos_;
 	// Информация о текущей игре, при выходе запишется
 	GameInfoIndex currentGameIndex_;
diff --git a/engines/qdengine/minigames/adv/TextManager.cpp b/engines/qdengine/minigames/adv/TextManager.cpp
index 75ff9f9ebe1..72042eedf2f 100644
--- a/engines/qdengine/minigames/adv/TextManager.cpp
+++ b/engines/qdengine/minigames/adv/TextManager.cpp
@@ -19,6 +19,9 @@
  *
  */
 
+#include "common/debug.h"
+
+#include "qdengine/qdengine.h"
 #include "qdengine/minigames/adv/common.h"
 #include "qdengine/minigames/adv/TextManager.h"
 #include "qdengine/minigames/adv/RunTime.h"
@@ -30,32 +33,34 @@ TextManager::TextManager() {
 	char str_cache[256];
 
 	for (int idx = 0;; ++idx) {
-		_snprintf(str_cache, 127, "register_font_%d", idx);
+		snprintf(str_cache, 127, "register_font_%d", idx);
 		if (const char * descr = runtime->parameter(str_cache, false)) {
 			sscanf(descr, "%255s", str_cache);
 			Font digit;
 			if (!digit.pool.load(str_cache))
 				break;
-			dprintf("%d character set \"%s\" loaded, ", idx, str_cache);
-			_snprintf(str_cache, 127, "font_size_%d", idx);
-			if (descr = runtime->parameter(str_cache, false)) {
+
+			debugCN(2, kDebugMinigames, "TextManager(): %d character set \"%s\" loaded, ", idx, str_cache);
+
+			snprintf(str_cache, 127, "font_size_%d", idx);
+			if ((descr = runtime->parameter(str_cache, false))) {
 				int read = sscanf(descr, "%f %f", &digit.size.x, &digit.size.y);
-				xxassert(read == 2, (XBuffer() < "Неверная строка с размерами шрифта в [" < str_cache < "]").c_str());
-				dprintf("re");
+				if (read != 2)
+					warning("TextManager(): incorrect font size definition in [%s]", str_cache);
 			} else {
-				QDObject& obj = digit.pool.getObject();
-				obj->set_state("0");
+				QDObject obj = digit.pool.getObject();
+				obj.setState("0");
 				digit.size = runtime->getSize(obj);
 				digit.pool.releaseObject(obj);
 			}
-			dprintf("set size to (%5.1f, %5.1f)\n", digit.size.x, digit.size.y);
+			debugC(2, kDebugMinigames, "set size to (%5.1f, %5.1f)\n", digit.size.x, digit.size.y);
 			fonts_.push_back(digit);
 		} else
 			break;
 	}
 
 	for (int idx = 0;; ++idx) {
-		_snprintf(str_cache, 127, "register_particle_escape_%d", idx);
+		snprintf(str_cache, 127, "register_particle_escape_%d", idx);
 		if (const char * descr = runtime->parameter(str_cache, false)) {
 			Escape escape;
 			int read = sscanf(descr, "%d (%f><%f, %f><%f) (%f><%f, %f><%f) %f '%15s",
@@ -63,14 +68,17 @@ TextManager::TextManager() {
 			                  &escape.vel_min.x, &escape.vel_max.x, &escape.vel_min.y, &escape.vel_max.y,
 			                  &escape.accel_min.x, &escape.accel_max.x, &escape.accel_min.y, &escape.accel_max.y,
 			                  &escape.aliveTime, escape.format);
-			xxassert(read == 11, (XBuffer() < "Неверная строка для описания полета в [" < str_cache < "]").c_str());
+
+			if (read != 11)
+				warning("TextManager(): incorrect particle definition in [%s]", str_cache);
+
 			if (read != 11)
 				break;
 			escapes_.push_back(escape);
 		} else
 			break;
 	}
-	dprintf("registered %d particle escapes\n", escapes_.size());
+	debugCN(2, kDebugMinigames, "TextManager(): registered %d particle escapes", escapes_.size());
 
 	if (getStaticPreset(show_scores_, "show_scores"))
 		show_scores_.textID = createStaticText(show_scores_.pos, show_scores_.font, show_scores_.align);
@@ -95,12 +103,18 @@ bool TextManager::getStaticPreset(StaticTextPreset& preset, const char* name) co
 		char str[64];
 		str[63] = 0;
 		int read = sscanf(descr, "%d %d |%63s", &align, &preset.font, str);
-		xxassert(read == 3, (XBuffer() < "Неверная строка для описания формата текста в [" < name < "]").c_str());
+
+		if (read != 3)
+				warning("TextManager::getStaticPreset(): Incorrect text format description in %s", transCyrillic(name));
+
 		if (read != 3)
 			return false;
 
 		char *pos_obj = strchr(str, '|');
-		xxassert(pos_obj, (XBuffer() < "Неверная строка для описания формата текста в [" < name < "]").c_str());
+
+		if (!pos_obj)
+				warning("TextManager::getStaticPreset(): Incorrect text format description (2) in %s", transCyrillic(name));
+
 		if (!pos_obj)
 			return false;
 		*pos_obj = 0;
@@ -132,21 +146,18 @@ bool TextManager::getStaticPreset(StaticTextPreset& preset, const char* name) co
 }
 
 TextManager::~TextManager() {
-	Messages::iterator mit;
-	FOR_EACH(flowMsgs_, mit)
-	mit->release();
+	for (auto &mit : flowMsgs_)
+		mit.release();
 
-	StaticMessages::iterator sit;
-	FOR_EACH(staticMsgs_, sit)
-	sit->release();
+	for (auto &sit : staticMsgs_)
+		sit.release();
 
-	Fonts::iterator dit;
-	FOR_EACH(fonts_, dit)
-	dit->pool.release();
+	for (auto &dit : fonts_)
+		dit.pool.release();
 }
 
 int TextManager::createStaticText(const mgVect3f& pos, int fontID, TextAlign align) {
-	xassert(fontID >= 0 && fontID < fonts_.size());
+	assert(fontID >= 0 && fontID < fonts_.size());
 
 	StaticMessage msg(&fonts_[fontID]);
 
@@ -159,14 +170,14 @@ int TextManager::createStaticText(const mgVect3f& pos, int fontID, TextAlign ali
 }
 
 void TextManager::updateStaticText(int textID, const char* txt) {
-	xassert(textID >= 0 && textID < staticMsgs_.size());
+	assert(textID >= 0 && textID < staticMsgs_.size());
 
 	staticMsgs_[textID].setText(txt);
 }
 
 void TextManager::showText(const char* txt, const mgVect2f& pos, int fontID, int escapeID) {
-	xassert(fontID >= 0 && fontID < fonts_.size());
-	xassert(escapeID >= 0 && escapeID < escapes_.size());
+	assert(fontID >= 0 && fontID < fonts_.size());
+	assert(escapeID >= 0 && escapeID < escapes_.size());
 
 	Escape& es = escapes_[escapeID];
 
@@ -190,12 +201,12 @@ void TextManager::showText(const char* txt, const mgVect2f& pos, int fontID, int
 }
 
 void TextManager::showNumber(int num, const mgVect2f& pos, int fontID, int escapeID) {
-	xassert(fontID >= 0 && fontID < fonts_.size());
-	xassert(escapeID >= 0 && escapeID < escapes_.size());
+	assert(fontID >= 0 && fontID < fonts_.size());
+	assert(escapeID >= 0 && escapeID < escapes_.size());
 
 	char buf[16];
 	buf[15] = 0;
-	_snprintf(buf, 15, escapes_[escapeID].format, num);
+	snprintf(buf, 15, escapes_[escapeID].format, num);
 
 	showText(buf, pos, fontID, escapeID);
 }
@@ -212,21 +223,21 @@ TextManager::StaticTextPreset::StaticTextPreset() {
 	format[15] = 0;
 }
 
-TextManager::StaticMessage::StaticMessage(Font* font, TextAlign align_) {
+TextManager::StaticMessage::StaticMessage(Font* font, TextAlign align) {
 	font_ = font;
-	align_ = align_;
+	align_ = align;
 	depth_ = 0.f;
 }
 
 void TextManager::StaticMessage::release() {
-	QDObjects::iterator it;
-	FOR_EACH(objects_, it)
-	font_->pool.releaseObject(*it);
+	for (auto &it : objects_)
+		font_->pool.releaseObject(it);
+
 	objects_.clear();
 }
 
 void TextManager::StaticMessage::setText(const char* str) {
-	xassert(font_);
+	assert(font_);
 
 	if (!str) {
 		release();
@@ -278,6 +289,8 @@ void TextManager::StaticMessage::update() {
 	case ALIGN_CENTER:
 		x -= width / 2.f;
 		break;
+	default:
+		break;
 	}
 	if (y < -font_->size.y || y > runtime->screenSize().y + font_->size.y
 	        || x < -2 * width || x > runtime->screenSize().x + 2 * width) {
@@ -285,10 +298,9 @@ void TextManager::StaticMessage::update() {
 		return;
 	}
 
-	QDObjects::iterator it;
-	FOR_EACH(objects_, it) {
-		if (*it)
-			(*it)->set_R(runtime->game2world(mgVect2f(x, y), depth_));
+	for (auto &it : objects_) {
+		if (it)
+			it->set_R(runtime->game2world(mgVect2f(x, y), depth_));
 		x += font_->size.x;
 	}
 }
@@ -331,13 +343,13 @@ void TextManager::quant(float dt) {
 
 	if (show_scores_.textID >= 0) {
 		if (scoreUpdateTimer_ >= 0.f && scoreUpdateTimer_ <= runtime->getTime()) {
-			int sgn = SIGN(targetScore_ - currentScore_);
+			int sgn = targetScore_ - currentScore_ < 0 ? -1 : 1;
 			int mod = abs(currentScore_ - targetScore_);
 			currentScore_ += sgn * (mod / 10 + 1);
 
 			char buf[16];
 			buf[15] = 0;
-			_snprintf(buf, 15, show_scores_.format, currentScore_);
+			snprintf(buf, 15, show_scores_.format, currentScore_);
 			updateStaticText(show_scores_.textID, buf);
 
 			scoreUpdateTimer_ = currentScore_ != targetScore_ ? runtime->getTime() + scoreUpdateTime_ : -1.f;
@@ -359,7 +371,7 @@ void TextManager::updateTime(int seconds) {
 		seconds -= 3600 * h;
 		int minutes = seconds / 60;
 		seconds -= 60 * minutes;
-		_snprintf(buf, 15, show_time_.format, h, minutes, seconds);
+		snprintf(buf, 15, show_time_.format, h, minutes, seconds);
 		updateStaticText(show_time_.textID, buf);
 	}
 }
diff --git a/engines/qdengine/minigames/adv/TextManager.h b/engines/qdengine/minigames/adv/TextManager.h
index e7b37bd3a64..56a48009e6d 100644
--- a/engines/qdengine/minigames/adv/TextManager.h
+++ b/engines/qdengine/minigames/adv/TextManager.h
@@ -52,7 +52,7 @@ private:
 		mgVect2f size;
 		ObjectContainer pool;
 	};
-	typedef vector<Font> Fonts;
+	typedef Std::vector<Font> Fonts;
 
 	struct Escape {
 		Escape();
@@ -64,7 +64,7 @@ private:
 		mgVect2f accel_max;
 		char format[16];
 	};
-	typedef vector<Escape> Escapes;
+	typedef Std::vector<Escape> Escapes;
 
 	struct StaticTextPreset {
 		StaticTextPreset();
@@ -101,7 +101,7 @@ private:
 
 		QDObjects objects_;
 	};
-	typedef vector<StaticMessage> StaticMessages;
+	typedef Std::vector<StaticMessage> StaticMessages;
 
 	struct Message : public StaticMessage {
 		Message(Font* font = 0);
@@ -114,7 +114,7 @@ private:
 		mgVect2f accel_;
 
 	};
-	typedef vector<Message> Messages;
+	typedef Std::vector<Message> Messages;
 
 	Fonts fonts_;
 	Escapes escapes_;
diff --git a/engines/qdengine/minigames/adv/qdMath.h b/engines/qdengine/minigames/adv/qdMath.h
index 1ea73bfe6ef..a9744ed5749 100644
--- a/engines/qdengine/minigames/adv/qdMath.h
+++ b/engines/qdengine/minigames/adv/qdMath.h
@@ -22,10 +22,9 @@
 #ifndef QDENGINE_MINIGAMES_ADV_QDMATH_H
 #define QDENGINE_MINIGAMES_ADV_QDMATH_H
 
-namespace QDEngine {
+#include "qdengine/xmath.h"
 
-const float FLT_EPS = 1.192092896e-07f;
-const float FLT_INF = 1.e+30f;
+namespace QDEngine {
 
 #define SQRT2 1.41421356f
 #define SQRT3 1.73205081f
diff --git a/engines/qdengine/module.mk b/engines/qdengine/module.mk
index c1696fc67e0..735fe580422 100644
--- a/engines/qdengine/module.mk
+++ b/engines/qdengine/module.mk
@@ -4,7 +4,14 @@ MODULE_OBJS = \
 	qdengine.o \
 	console.o \
 	metaengine.o \
+	minigames/adv/common.o \
+	minigames/adv/EffectManager.o \
+	minigames/adv/EventManager.o \
+	minigames/adv/ExportInterface.o \
+	minigames/adv/FlyObject.o \
+	minigames/adv/ObjectContainer.o \
 	minigames/adv/Range.o \
+	minigames/adv/TextManager.o \
 	parser/qdscr_parser.o \
 	parser/xml_parser.o \
 	parser/xml_tag_buffer.o \


Commit: 04d959c894fbf5591f704484309340b699af34d7
    https://github.com/scummvm/scummvm/commit/04d959c894fbf5591f704484309340b699af34d7
Author: Eugene Sandulenko (sev at scummvm.org)
Date: 2024-10-18T12:09:54+02:00

Commit Message:
QDENGINE: Renames in class variables in minigames/adv

Changed paths:
    engines/qdengine/minigames/adv/EffectManager.cpp
    engines/qdengine/minigames/adv/EffectManager.h
    engines/qdengine/minigames/adv/EventManager.cpp
    engines/qdengine/minigames/adv/EventManager.h
    engines/qdengine/minigames/adv/HoldData.h
    engines/qdengine/minigames/adv/ObjectContainer.cpp
    engines/qdengine/minigames/adv/ObjectContainer.h
    engines/qdengine/minigames/adv/Range.cpp
    engines/qdengine/minigames/adv/Range.h
    engines/qdengine/minigames/adv/common.cpp
    engines/qdengine/minigames/adv/common.h


diff --git a/engines/qdengine/minigames/adv/EffectManager.cpp b/engines/qdengine/minigames/adv/EffectManager.cpp
index fa6f79851ac..4e2dcd2dfe5 100644
--- a/engines/qdengine/minigames/adv/EffectManager.cpp
+++ b/engines/qdengine/minigames/adv/EffectManager.cpp
@@ -28,65 +28,65 @@ namespace QDEngine {
 EffectManager::EffectManager(HoldData<EffectManagerData> &data) {
 	const char *effectName = runtime->parameter("effect_name", "effect");
 	if (runtime->testObject(effectName)) {
-		effect_ = runtime->getObject(effectName);
-		data_.crd = effect_->R();
-		effect_->set_screen_scale(mgVect2f(0.01f, 0.01f), mgVect2f(10000.f, 10000.f));
-		runtime->hide(effect_);
+		_effect = runtime->getObject(effectName);
+		_data.crd = _effect->R();
+		_effect->set_screen_scale(mgVect2f(0.01f, 0.01f), mgVect2f(10000.f, 10000.f));
+		runtime->hide(_effect);
 	}
 
-	data.process(data_);
+	data.process(_data);
 
-	effectTime_ = clamp(getParameter("effect_time", 3.f), 0.5f, 10.f);
-	phaseTime_ = clamp(getParameter("effect_phase_time", effectTime_ / 20.f), 0.03f, 1.f);
-	phaseSpeed_ = clamp(getParameter("effect_phase_speed", 1.5f), 1.05f, 10.f);
+	_effectTime = clamp(getParameter("effect_time", 3.f), 0.5f, 10.f);
+	_phaseTime = clamp(getParameter("effect_phase_time", _effectTime / 20.f), 0.03f, 1.f);
+	_phaseSpeed = clamp(getParameter("effect_phase_speed", 1.5f), 1.05f, 10.f);
 
-	current_ = EFFECT_COUNT;
+	_current = EFFECT_COUNT;
 
 }
 
 EffectManager::~EffectManager() {
-	runtime->release(effect_);
+	runtime->release(_effect);
 
 }
 
 void EffectManager::quant(float dt) {
-	if (current_ == EFFECT_COUNT)
+	if (_current == EFFECT_COUNT)
 		return;
 
-	if (runtime->getTime() > effectTimer_) {
-		stop(current_);
+	if (runtime->getTime() > _effectTimer) {
+		stop(_current);
 		return;
 	}
 
-	if (runtime->getTime() > phaseTimer_) {
-		phaseTimer_ = runtime->getTime() + phaseTime_;
-		mgVect2f scale = effect_->screen_scale();
+	if (runtime->getTime() > _phaseTimer) {
+		_phaseTimer = runtime->getTime() + _phaseTime;
+		mgVect2f scale = _effect->screen_scale();
 		mgVect2f speed = scale;
-		scale *= phaseSpeed_;
+		scale *= _phaseSpeed;
 		speed = scale - speed;
-		speed /= phaseTime_;
-		effect_->set_screen_scale(scale, speed);
+		speed /= _phaseTime;
+		_effect->set_screen_scale(scale, speed);
 	}
 
 }
 
 void EffectManager::start(EffectType id) {
-	if (current_ != EFFECT_COUNT || !effect_)
+	if (_current != EFFECT_COUNT || !_effect)
 		return;
-	effectTimer_ = runtime->getTime() + effectTime_;
-	current_ = id;
-	phaseTimer_ = runtime->getTime();
-	effect_->set_screen_scale(mgVect2f(0.02f, 0.02f), mgVect2f(10000.f, 10000.f));
-	effect_->set_R(data_.crd);
+	_effectTimer = runtime->getTime() + _effectTime;
+	_current = id;
+	_phaseTimer = runtime->getTime();
+	_effect->set_screen_scale(mgVect2f(0.02f, 0.02f), mgVect2f(10000.f, 10000.f));
+	_effect->set_R(_data.crd);
 
 }
 
 void EffectManager::stop(EffectType id) {
-	if (current_ == EFFECT_COUNT)
+	if (_current == EFFECT_COUNT)
 		return;
-	runtime->hide(effect_);
-	effect_->set_screen_scale(mgVect2f(0.01f, 0.01f), mgVect2f(10000.f, 10000.f));
-	current_ = EFFECT_COUNT;
+	runtime->hide(_effect);
+	_effect->set_screen_scale(mgVect2f(0.01f, 0.01f), mgVect2f(10000.f, 10000.f));
+	_current = EFFECT_COUNT;
 }
 
 } // namespace QDEngine
diff --git a/engines/qdengine/minigames/adv/EffectManager.h b/engines/qdengine/minigames/adv/EffectManager.h
index c1a8bec78a3..9d4d47d9376 100644
--- a/engines/qdengine/minigames/adv/EffectManager.h
+++ b/engines/qdengine/minigames/adv/EffectManager.h
@@ -43,15 +43,15 @@ public:
 	void stop(EffectType id);
 
 private:
-	EffectType current_;
-	EffectManagerData data_;
-	float phaseTime_;
-	float effectTime_;
-	float phaseSpeed_;
-
-	float effectTimer_;
-	float phaseTimer_;
-	QDObject effect_;
+	EffectType _current;
+	EffectManagerData _data;
+	float _phaseTime;
+	float _effectTime;
+	float _phaseSpeed;
+
+	float _effectTimer;
+	float _phaseTimer;
+	QDObject _effect;
 
 };
 
diff --git a/engines/qdengine/minigames/adv/EventManager.cpp b/engines/qdengine/minigames/adv/EventManager.cpp
index fbf9b91468e..64fdf6c1164 100644
--- a/engines/qdengine/minigames/adv/EventManager.cpp
+++ b/engines/qdengine/minigames/adv/EventManager.cpp
@@ -37,20 +37,20 @@ EventManager::EventPreset::EventPreset() {
 }
 
 EventManager::EventManager() {
-	score_ = 0;
+	_score = 0;
 
 	char str_cache[256];
 
 	for (int idx = 0;; ++idx) {
 		snprintf(str_cache, 127, "register_trigger_%d", idx);
 		if (const char *descr = runtime->parameter(str_cache, false))
-			triggerEvents_.push_back(runtime->getObject(descr));
+			_triggerEvents.push_back(runtime->getObject(descr));
 		else
 			break;
 	}
-	debugC(2, kDebugMinigames, "EventManager(): registered %d trigger objects", triggerEvents_.size());
+	debugC(2, kDebugMinigames, "EventManager(): registered %d trigger objects", _triggerEvents.size());
 
-	eventPresets_.resize(SYSTEM_EVENTS_SIZE);
+	_eventPresets.resize(SYSTEM_EVENTS_SIZE);
 	for (int idx = 0; idx < SYSTEM_EVENTS_SIZE; ++idx) {
 		snprintf(str_cache, 127, "system_event_%d", idx);
 		if (const char * descr = runtime->parameter(str_cache, false)) {
@@ -61,11 +61,11 @@ EventManager::EventManager() {
 				error("EventManager(): Incorrect description string: %s", str_cache);
 
 			if (read == 2) {
-				if (preset.triggerEventID >= (int)triggerEvents_.size())
+				if (preset.triggerEventID >= (int)_triggerEvents.size())
 					error("EventManager(): Reference to an unregistered trigger in %s", str_cache);
 
-				if (preset.triggerEventID < (int)triggerEvents_.size())
-					eventPresets_[idx] = preset;
+				if (preset.triggerEventID < (int)_triggerEvents.size())
+					_eventPresets[idx] = preset;
 			}
 		}
 	}
@@ -79,24 +79,24 @@ EventManager::EventManager() {
 			if (read != 4)
 				error("EventManager(): Incorrect event description string: %d", idx);
 
-			if (preset.triggerEventID >= (int)triggerEvents_.size())
+			if (preset.triggerEventID >= (int)_triggerEvents.size())
 				error("EventManager(): Reference to an unregistered trigger in %s", str_cache);
 
-			if (read == 4 && preset.triggerEventID < (int)triggerEvents_.size())
-				eventPresets_.push_back(preset);
+			if (read == 4 && preset.triggerEventID < (int)_triggerEvents.size())
+				_eventPresets.push_back(preset);
 			else
-				eventPresets_.push_back(EventPreset());
+				_eventPresets.push_back(EventPreset());
 		} else
 			break;
 	}
-	debugC(2, kDebugMinigames, "EventManager(): registered %d events", eventPresets_.size());
+	debugC(2, kDebugMinigames, "EventManager(): registered %d events", _eventPresets.size());
 
 	if (const char * data = runtime->parameter("allow_negative", false)) {
 		int tmp;
 		sscanf(data, "%d", &tmp);
-		enableNegative_ = tmp;
+		_enableNegative = tmp;
 	} else
-		enableNegative_ = false;
+		_enableNegative = false;
 }
 
 void EventManager::sysEvent(int eventID) {
@@ -114,14 +114,14 @@ void EventManager::event(int eventID, const mgVect2f& pos, int factor) {
 
 	eventID += SYSTEM_EVENTS_SIZE;
 
-	if (eventID >= eventPresets_.size())
+	if (eventID >= _eventPresets.size())
 		return;
 
-	const EventPreset& pr = eventPresets_[eventID];
+	const EventPreset& pr = _eventPresets[eventID];
 
 	if (pr.triggerEventID >= 0) {
-		assert(pr.triggerEventID < triggerEvents_.size());
-		triggerEvents_[pr.triggerEventID]->set_state("on");
+		assert(pr.triggerEventID < _triggerEvents.size());
+		_triggerEvents[pr.triggerEventID]->set_state("on");
 	}
 
 	if (pr.score) {
@@ -133,16 +133,16 @@ void EventManager::event(int eventID, const mgVect2f& pos, int factor) {
 }
 
 int EventManager::addScore(int sc) {
-	int diff = score_;
+	int diff = _score;
 
-	score_ += sc;
-	if (score_ < 0 && !enableNegative_)
-		score_ = 0;
+	_score += sc;
+	if (_score < 0 && !_enableNegative)
+		_score = 0;
 
-	diff = score_ - diff;
+	diff = _score - diff;
 
 	if (diff)
-		runtime->textManager().updateScore(score_);
+		runtime->textManager().updateScore(_score);
 
 	return diff;
 }
diff --git a/engines/qdengine/minigames/adv/EventManager.h b/engines/qdengine/minigames/adv/EventManager.h
index e4c91ef3755..094c339c4f8 100644
--- a/engines/qdengine/minigames/adv/EventManager.h
+++ b/engines/qdengine/minigames/adv/EventManager.h
@@ -32,13 +32,13 @@ public:
 	void event(int eventID, const mgVect2f& pos, int factor);
 
 	int score() const {
-		return score_;
+		return _score;
 	}
 	int addScore(int sc);
 
 private:
-	int score_;
-	bool enableNegative_;
+	int _score;
+	bool _enableNegative;
 
 	struct EventPreset {
 		EventPreset();
@@ -48,9 +48,9 @@ private:
 		int triggerEventID;
 	};
 	typedef Std::vector<EventPreset> EventPresets;
-	EventPresets eventPresets_;
+	EventPresets _eventPresets;
 
-	QDObjects triggerEvents_;
+	QDObjects _triggerEvents;
 };
 
 } // namespace QDEngine
diff --git a/engines/qdengine/minigames/adv/HoldData.h b/engines/qdengine/minigames/adv/HoldData.h
index f2bf6d8d70f..5a720b0863a 100644
--- a/engines/qdengine/minigames/adv/HoldData.h
+++ b/engines/qdengine/minigames/adv/HoldData.h
@@ -26,27 +26,27 @@ namespace QDEngine {
 
 template <class T>
 class HoldData {
-	T emptyData_;
-	T &data_;
-	bool empty_;
+	T _emptyData;
+	T &_data;
+	bool _empty;
 public:
-	HoldData() : data_(emptyData_), empty_(true) {}
+	HoldData() : _data(_emptyData), _empty(true) {}
 	HoldData(T* data, bool empty)
-		: data_(data ? * data : emptyData_) {
-		empty_ = data ? empty : true;
+		: _data(data ? * data : _emptyData) {
+		_empty = data ? empty : true;
 	}
 
 	void process(T& current) {
-		if (empty_) {
-			data_ = current;
-			empty_ = false;
+		if (_empty) {
+			_data = current;
+			_empty = false;
 		} else
-			current = data_;
+			current = _data;
 	}
 
 	const T &get() const {
-		assert(!empty_);
-		return data_;
+		assert(!_empty);
+		return _data;
 	}
 };
 
diff --git a/engines/qdengine/minigames/adv/ObjectContainer.cpp b/engines/qdengine/minigames/adv/ObjectContainer.cpp
index 7a4948cf154..af3bbc8e268 100644
--- a/engines/qdengine/minigames/adv/ObjectContainer.cpp
+++ b/engines/qdengine/minigames/adv/ObjectContainer.cpp
@@ -27,30 +27,29 @@
 namespace QDEngine {
 
 ObjectContainer::ObjectContainer() {
-	current_ = 0;
+	_current = 0;
 
 }
 
 void ObjectContainer::release() {
-	for (auto &it : objects_)
+	for (auto &it : _objects)
 		runtime->release(it);
 
-	objects_.clear();
-	current_ = 0;
+	_objects.clear();
+	_current = 0;
 }
 
 void ObjectContainer::pushObject(QDObject& obj) {
-	assert(Common::find(objects_.begin(), objects_.end(), obj) == objects_.end());
-	objects_.push_back(obj);
+	assert(Common::find(_objects.begin(), _objects.end(), obj) == _objects.end());
+	_objects.push_back(obj);
 }
 
 const char *ObjectContainer::name() const {
-	#ifdef _DEBUG
-	return name_.c_str();
-	#else
+#ifdef _DEBUG
+	return _name.c_str();
+#else
 	return "";
-	#endif
-
+#endif
 }
 
 bool ObjectContainer::load(const char* base_name, bool hide) {
@@ -59,12 +58,12 @@ bool ObjectContainer::load(const char* base_name, bool hide) {
 		return false;
 	}
 
-	#ifdef _DEBUG
-	name_ = base_name;
-	#endif
+#ifdef _DEBUG
+	_name = base_name;
+#endif
 
 	QDObject obj = runtime->getObject(base_name);
-	coord_ = runtime->world2game(obj);
+	_coord = runtime->world2game(obj);
 	pushObject(obj);
 	if (hide)
 		runtime->hide(obj);
@@ -86,27 +85,27 @@ bool ObjectContainer::load(const char* base_name, bool hide) {
 }
 
 void ObjectContainer::hideAll() {
-	for (auto &it : objects_)
+	for (auto &it : _objects)
 		runtime->hide(it);
 }
 
 QDObject ObjectContainer::getObject() {
-	if (current_ < objects_.size())
-		return objects_[current_++];
+	if (_current < _objects.size())
+		return _objects[_current++];
 
-	return objects_[0]; // bad, but better than crashing
+	return _objects[0]; // bad, but better than crashing
 
 }
 
 void ObjectContainer::releaseObject(QDObject& obj) {
-	QDObjects::iterator it = Common::find(objects_.begin(), objects_.end(), obj);
-	if (it != objects_.end()) {
-		if ((int)Common::distance(objects_.begin(), it) >= current_)
+	QDObjects::iterator it = Common::find(_objects.begin(), _objects.end(), obj);
+	if (it != _objects.end()) {
+		if ((int)Common::distance(_objects.begin(), it) >= _current)
 			error("ObjectContainer::releaseObject(): Object released more than once in to the pool: %s", transCyrillic(name()));
 
 		runtime->hide(obj);
-		if (current_ > 0)
-			swap(*it, objects_[--current_]);
+		if (_current > 0)
+			swap(*it, _objects[--_current]);
 		obj = 0;
 	}
 }
diff --git a/engines/qdengine/minigames/adv/ObjectContainer.h b/engines/qdengine/minigames/adv/ObjectContainer.h
index 92194e6ad52..4a3afeed4ca 100644
--- a/engines/qdengine/minigames/adv/ObjectContainer.h
+++ b/engines/qdengine/minigames/adv/ObjectContainer.h
@@ -1,6 +1,6 @@
 /* ScummVM - Graphic Adventure Engine
  *
- * ScummVM is the legal property of its developers, whose names
+ * ScummVM is the legal property of its developers, whose _names
  * are too numerous to list here. Please refer to the COPYRIGHT
  * file distributed with this source distribution.
  *
@@ -25,11 +25,11 @@
 namespace QDEngine {
 
 class ObjectContainer {
-	QDObjects objects_;
-	int current_;
-	mgVect3f coord_;
+	QDObjects _objects;
+	int _current;
+	mgVect3f _coord;
 	#ifdef _DEBUG
-	string name_;
+	string _name;
 	#endif
 	const char *name() const;
 	void pushObject(QDObject& obj);
@@ -38,11 +38,11 @@ public:
 	ObjectContainer();
 	void release();
 
-	bool load(const char* name, bool hide = true);
+	bool load(const char* _name, bool hide = true);
 	void hideAll();
 
 	const mgVect3f &coord() const {
-		return coord_;
+		return _coord;
 	}
 
 	QDObject getObject();
diff --git a/engines/qdengine/minigames/adv/Range.cpp b/engines/qdengine/minigames/adv/Range.cpp
index 744c082b623..976d116c657 100644
--- a/engines/qdengine/minigames/adv/Range.cpp
+++ b/engines/qdengine/minigames/adv/Range.cpp
@@ -23,35 +23,35 @@
 
 namespace QDEngine {
 
-void Rangef::set(float _min, float _max) {
-	min_ = _min;
-	max_ = _max;
+void Rangef::set(float min, float max) {
+	_min = min;
+	_max = max;
 }
 
-Rangef Rangef::intersection(const Rangef& _range) {
+Rangef Rangef::intersection(const Rangef& range) {
 	float begin;
 	float end;
-	if (maximum() < _range.minimum() || minimum() > _range.maximum())
+	if (maximum() < range.minimum() || minimum() > range.maximum())
 		return Rangef(0.f, 0.f);
 
-	if (include(_range.minimum()))
-		begin = _range.minimum();
+	if (include(range.minimum()))
+		begin = range.minimum();
 	else
 		begin = minimum();
 
-	if (include(_range.maximum()))
-		end = _range.maximum();
+	if (include(range.maximum()))
+		end = range.maximum();
 	else
 		end = maximum();
 	return Rangef(begin, end);
 }
 
 
-float Rangef::clip(float &_value) const {
-	if (include(_value))
-		return _value;
+float Rangef::clip(float &value) const {
+	if (include(value))
+		return value;
 	else {
-		if (_value < minimum())
+		if (value < minimum())
 			return minimum();
 		else
 			return maximum();
@@ -60,146 +60,39 @@ float Rangef::clip(float &_value) const {
 
 // --------------------- Rangei
 
-void Rangei::set(int _min, int _max) {
-	min_ = _min;
-	max_ = _max;
+void Rangei::set(int min, int max) {
+	_min = min;
+	_max = max;
 }
 
-Rangei Rangei::intersection(const Rangei& _range) {
+Rangei Rangei::intersection(const Rangei& range) {
 	int begin;
 	int end;
-	if (maximum() < _range.minimum() || minimum() > _range.maximum())
+	if (maximum() < range.minimum() || minimum() > range.maximum())
 		return Rangei(0, 0);
 
-	if (include(_range.minimum()))
-		begin = _range.minimum();
+	if (include(range.minimum()))
+		begin = range.minimum();
 	else
 		begin = minimum();
 
-	if (include(_range.maximum()))
-		end = _range.maximum();
+	if (include(range.maximum()))
+		end = range.maximum();
 	else
 		end = maximum();
 	return Rangei(begin, end);
 }
 
 
-int Rangei::clip(int &_value) {
-	if (include(_value))
-		return _value;
+int Rangei::clip(int &value) {
+	if (include(value))
+		return value;
 	else {
-		if (_value < minimum())
+		if (value < minimum())
 			return minimum();
 		else
 			return maximum();
 	}
 }
 
-/*
-/// Абстракция закрытого интервала (отрезка).
-template<typename ScalarType = float>
-class Range
-{
-public:
-    typedef Range<ScalarType> RangeType;
-
-    Range (ScalarType _min = ScalarType(0), ScalarType _max = ScalarType(0)) :
-    min_ (_min),
-        max_ (_max)
-    {}
-
-    inline ScalarType minimum () const
-    {
-        return min_;
-    }
-    inline void minimum (ScalarType _min)
-    {
-        min_ = _min;
-    }
-    inline ScalarType maximum () const
-    {
-        return max_;
-    }
-    inline void maximum (ScalarType _max)
-    {
-        max_ = _max;
-    }
-    inline void set (ScalarType _min, ScalarType _max)
-    {
-        min_ = _min;
-        max_ = _max;
-    }
-
-    inline ScalarType length () const
-    {
-        return (maximum () - minimum ());
-    }
-
-    inline ScalarType center() const
-    {
-        return (maximum() + minimum()) / 2;
-    }
-
-    /// Корректен ли интервал (нет - в случае когда minimum > maximum);
-    inline bool is_valid () const
-    {
-        return (minimum () <= maximum ());
-    }
-
-    /// Включает ли отрезок (закрытый интервал) точку \c _value.
-    inline bool include (ScalarType _value) const
-    {
-        return (minimum () <= _value) && (maximum () >= _value);
-    }
-    /// Включает ли интервал в себя \c _range.
-    inline bool include (const RangeType& _range) const
-    {
-        return (minimum () <= _range.minimum ()) && (maximum () >= _range.maximum ());
-    }
-
-    /// Возвращает пересечение интервала *this и \c _range.
-    inline RangeType intersection (const RangeType& _range)
-    {
-        ScalarType begin;
-        ScalarType end;
-        if (maximum () < _range.minimum () || minimum () > _range.maximum ())
-            return RangeType (0, 0);
-
-        if (include (_range.minimum ()))
-            begin = _range.minimum ();
-        else
-            begin = minimum ();
-
-        if (include (_range.maximum ()))
-            end = _range.maximum ();
-        else
-            end = maximum ();
-        return RangeType (begin, end);
-    }
-
-    /// Возвращает \c _value в пределах интервала [minimum, maximum].
-    inline ScalarType clip (ScalarType& _value)
-    {
-        if (include (_value))
-            return _value;
-        else
-        {
-            if (_value < minimum ())
-                return minimum ();
-            else
-                return maximum ();
-        }
-    }
-
-        void serialize(Archive& ar){
-            ar.serialize(min_, "min_", "Минимум");
-            ar.serialize(max_, "max_", "Максимум");
-        }
-
-private:
-    ScalarType min_;
-    ScalarType max_;
-};
-*/
-
 } // namespace QDEngine
diff --git a/engines/qdengine/minigames/adv/Range.h b/engines/qdengine/minigames/adv/Range.h
index 19843890ceb..4a9cb867041 100644
--- a/engines/qdengine/minigames/adv/Range.h
+++ b/engines/qdengine/minigames/adv/Range.h
@@ -26,114 +26,114 @@ namespace QDEngine {
 
 class Rangef {
 public:
-	Rangef(float _min = 0.f, float _max = 0.f)
-		: min_(_min)
-		, max_(_max)
+	Rangef(float min = 0.f, float max = 0.f)
+		: _min(min)
+		, _max(max)
 	{}
 
 	float minimum() const {
-		return min_;
+		return _min;
 	}
-	void setMinimum(float _min) {
-		min_ = _min;
+	void setMinimum(float min) {
+		_min = min;
 	}
 
 	float maximum() const {
-		return max_;
+		return _max;
 	}
-	void setMaximum(float _max) {
-		max_ = _max;
+	void setMaximum(float max) {
+		_max = max;
 	}
 
-	void set(float _min, float _max);
+	void set(float min, float max);
 
 	float length() const {
-		return max_ - min_;
+		return _max - _min;
 	}
 	float center() const {
-		return (max_ + min_) / 2.f;
+		return (_max + _min) / 2.f;
 	}
 
 	/// Корректен ли интервал (нет - в случае когда minimum > maximum);
 	bool is_valid() const {
-		return min_ <= max_;
+		return _min <= _max;
 	}
 
 	/// Включает ли отрезок (закрытый интервал) точку \c _value.
-	bool include(float _value) const {
-		return (min_ <= _value) && (max_ >= _value);
+	bool include(float value) const {
+		return (_min <= value) && (_max >= value);
 	}
 	/// Включает ли интервал в себя \c _range.
-	bool include(const Rangef& _range) const {
-		return min_ <= _range.min_ && max_ >= _range.max_;
+	bool include(const Rangef& range) const {
+		return _min <= range._min && _max >= range._max;
 	}
 
 	/// Возвращает пересечение интервала *this и \c _range.
-	Rangef intersection(const Rangef& _range);
+	Rangef intersection(const Rangef& range);
 
 	/// Возвращает \c _value в пределах интервала [minimum, maximum].
-	float clip(float &_value) const;
+	float clip(float &value) const;
 
 private:
-	float min_;
-	float max_;
+	float _min;
+	float _max;
 };
 
 // --------------------- Rangei
 
 class Rangei {
 public:
-	Rangei(int _min = 0.f, int _max = 0.f)
-		: min_(_min)
-		, max_(_max)
+	Rangei(int min = 0.f, int max = 0.f)
+		: _min(min)
+		, _max(max)
 	{}
 
 	int minimum() const {
-		return min_;
+		return _min;
 	}
-	void setMinimum(int _min) {
-		min_ = _min;
+	void setMinimum(int min) {
+		_min = min;
 	}
 
 	int maximum() const {
-		return max_;
+		return _max;
 	}
-	void setMaximum(int _max) {
-		max_ = _max;
+	void setMaximum(int max) {
+		_max = max;
 	}
 
-	void set(int _min, int _max);
+	void set(int min, int max);
 
 	int length() const {
-		return max_ - min_;
+		return _max - _min;
 	}
 	int center() const {
-		return (max_ + min_) / 2;
+		return (_max + _min) / 2;
 	}
 
 	/// Корректен ли интервал (нет - в случае когда minimum > maximum);
 	bool is_valid() const {
-		return min_ <= max_;
+		return _min <= _max;
 	}
 
 	/// Включает ли отрезок (закрытый интервал) точку \c _value.
-	bool include(int _value) const {
-		return (min_ <= _value) && (max_ >= _value);
+	bool include(int value) const {
+		return (_min <= value) && (_max >= value);
 	}
 	/// Включает ли интервал в себя \c _range.
-	bool include(const Rangei& _range) const {
-		return min_ <= _range.min_ && max_ >= _range.max_;
+	bool include(const Rangei& range) const {
+		return _min <= range._min && _max >= range._max;
 	}
 
 	/// Возвращает пересечение интервала *this и \c _range.
-	Rangei intersection(const Rangei& _range);
+	Rangei intersection(const Rangei& range);
 
 	/// Возвращает \c _value в пределах интервала [minimum, maximum].
-	int clip(int &_value);
+	int clip(int &value);
 
 private:
-	int min_;
-	int max_;
+	int _min;
+	int _max;
 };
 
 } // namespace QDEngine
diff --git a/engines/qdengine/minigames/adv/common.cpp b/engines/qdengine/minigames/adv/common.cpp
index 11f8c8e700d..22acb55fa2f 100644
--- a/engines/qdengine/minigames/adv/common.cpp
+++ b/engines/qdengine/minigames/adv/common.cpp
@@ -27,24 +27,24 @@ namespace QDEngine {
 QDObject QDObject::ZERO(0, "ZERO OBJECT");
 
 const char *QDObject::getName() const {
-	#ifdef _DEBUG
+#ifdef _DEBUG
 	return name_.c_str();
-	#else
+#else
 	return "";
-	#endif
+#endif
 }
 
 bool QDObject::hit(const mgVect2f& point) const {
-	return obj_->hit_test(mgVect2i(round(point.x), round(point.y)));
+	return _obj->hit_test(mgVect2i(round(point.x), round(point.y)));
 }
 
 float QDObject::depth() const {
-	return runtime->getDepth(obj_);
+	return runtime->getDepth(_obj);
 }
 
 void QDObject::setState(const char* name) {
-	if (!obj_->is_state_active(name))
-		obj_->set_state(name);
+	if (!_obj->is_state_active(name))
+		_obj->set_state(name);
 }
 
 template<class T>
diff --git a/engines/qdengine/minigames/adv/common.h b/engines/qdengine/minigames/adv/common.h
index 3916eb373f9..d857ed0cb88 100644
--- a/engines/qdengine/minigames/adv/common.h
+++ b/engines/qdengine/minigames/adv/common.h
@@ -34,19 +34,19 @@ typedef mgVect3<int> mgVect3i;
 using namespace std;
 
 class QDObject {
-	qdMinigameObjectInterface *obj_;
+	qdMinigameObjectInterface *_obj;
 
-	#ifdef _DEBUG
+#ifdef _DEBUG
 	string name_;
-	#endif
+#endif
 
 public:
 	static QDObject ZERO;
 
-	QDObject(qdMinigameObjectInterface* obj = 0, const char* name = "") : obj_(obj) {
-		#ifdef _DEBUG
+	QDObject(qdMinigameObjectInterface* obj = 0, const char* name = "") : _obj(obj) {
+#ifdef _DEBUG
 		name_ = name;
-		#endif
+#endif
 	}
 
 	const char *getName() const; // DEBUG ONLY
@@ -56,17 +56,17 @@ public:
 	void setState(const char* name);
 
 	bool operator==(const QDObject& obj) const {
-		return obj_ == obj.obj_;
+		return _obj == obj._obj;
 	}
 	bool operator==(const qdMinigameObjectInterface* obj) const {
-		return obj_ == obj;
+		return _obj == obj;
 	}
 
 	operator qdMinigameObjectInterface* () const {
-		return obj_;
+		return _obj;
 	}
 	qdMinigameObjectInterface* operator->() const {
-		return obj_;
+		return _obj;
 	}
 };

More information about the Scummvm-git-logs mailing list