STARK: Implement the settings menu

engines/stark/gfx/renderentry.h

@@ -75,6 +75,9 @@ class RenderEntry {
 	void setSortKey(float sortKey);
 	void setClickable(bool clickable);
 
+	/** Gets the position */
+	Common::Point getPosition() const { return _position; }
+
 	/** Gets the owner-object */
 	Resources::ItemVisual *getOwner() const { return _owner; }
 

engines/stark/module.mk

@@ -79,6 +79,7 @@ MODULE_OBJS := \
 	services/stateprovider.o \
 	services/staticprovider.o \
 	services/userinterface.o \
+	services/settings.o \
 	stark.o \
 	tools/abstractsyntaxtree.o \
 	tools/block.o \
@@ -88,6 +89,7 @@ MODULE_OBJS := \
 	ui/menu/diaryindex.o \
 	ui/menu/locationscreen.o \
 	ui/menu/mainmenu.o \
+	ui/menu/settingsmenu.o \
 	ui/window.o \
 	ui/world/actionmenu.o \
 	ui/world/button.o \

engines/stark/resources/anim.h

@@ -90,6 +90,9 @@ class Anim : public Object {
 	// Resource API
 	void readData(Formats::XRCReadStream *stream) override;
 
+	/** Get current displayed frame */
+	uint32 getCurrentFrame() { return _currentFrame; }
+
 	/** Sets the animation frame to be displayed */
 	virtual void selectFrame(uint32 frameIndex);
 

engines/stark/resources/sound.h

@@ -83,6 +83,9 @@ class Sound : public Object {
 	/** Fade the sound's current volume and pan to the specified target over duration milliseconds */
 	void changeVolumePan(int32 volume, int32 pan, int32 duration);
 
+	/** Set whether to loop or not */
+	void setLooping(bool looping) { _looping = looping; }
+
 protected:
 	void printData() override;
 

engines/stark/services/services.h

@@ -48,6 +48,7 @@ class ResourceProvider;
 class StaticProvider;
 class Scene;
 class UserInterface;
+class Settings;
 
 /**
  * Public services available as a singleton
@@ -67,6 +68,8 @@ class StarkServices : public Common::Singleton<StarkServices> {
 		gameInterface = nullptr;
 		userInterface = nullptr;
 		fontProvider = nullptr;
+		gameDescription = nullptr;
+		settings = nullptr;
 	}
 
 	ArchiveLoader *archiveLoader;
@@ -82,6 +85,7 @@ class StarkServices : public Common::Singleton<StarkServices> {
 	UserInterface *userInterface;
 	FontProvider *fontProvider;
 	const ADGameDescription *gameDescription;
+	Settings *settings;
 };
 
 /** Shortcuts for accessing the services. */
@@ -98,6 +102,7 @@ class StarkServices : public Common::Singleton<StarkServices> {
 #define StarkUserInterface      StarkServices::instance().userInterface
 #define StarkFontProvider       StarkServices::instance().fontProvider
 #define StarkGameDescription    StarkServices::instance().gameDescription
+#define StarkSettings           StarkServices::instance().settings
 
 } // End of namespace Stark
 

engines/stark/services/settings.cpp

@@ -0,0 +1,83 @@
+/* ResidualVM - A 3D game interpreter
+ *
+ * ResidualVM is the legal property of its developers, whose names
+ * are too numerous to list here. Please refer to the AUTHORS
+ * file distributed with this source distribution.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ *
+ */
+
+#include "engines/stark/services/settings.h"
+#include "engines/stark/services/services.h"
+#include "engines/stark/services/archiveloader.h"
+
+#include "common/config-manager.h"
+#include "common/debug.h"
+
+#include "audio/mixer.h"
+
+namespace Stark {
+
+Settings::Settings(Audio::Mixer *mixer) :
+		_mixer(mixer) {
+	// Initialize keys
+	_boolKey[kHighModel] = "high_model";
+	_boolKey[kSubtitle] = "subtitles";
+	_boolKey[kSpecialFX] = "specialfx";
+	_boolKey[kShadow] = "shadow";
+	_boolKey[kHighFMV] = "high_fmv";
+	_boolKey[kTimeSkip] = "enable_time_skip";
+	_intKey[kVoice] = "speech_volume";
+	_intKey[kMusic] = "music_volume";
+	_intKey[kSfx] = "sfx_volume";
+
+	// Register default settings
+	ConfMan.registerDefault(_boolKey[kHighModel], true);
+	ConfMan.registerDefault(_boolKey[kSubtitle], true);
+	ConfMan.registerDefault(_boolKey[kSpecialFX], true);
+	ConfMan.registerDefault(_boolKey[kShadow], true);
+	ConfMan.registerDefault(_boolKey[kHighFMV], true);
+	ConfMan.registerDefault(_boolKey[kTimeSkip], false);
+
+	// Use the FunCom logo video to check low-resolution fmv
+	_hasLowRes = StarkArchiveLoader->getExternalFile("1402_lo_res.bbb", "Global/");
+
+	// Apply the volume
+	setIntSetting(kVoice, getIntSetting(kVoice));
+	setIntSetting(kMusic, getIntSetting(kMusic));
+	setIntSetting(kSfx, getIntSetting(kSfx));
+}
+
+void Settings::setIntSetting(IntSettingIndex index, int value) {
+	ConfMan.setInt(_intKey[index], value);
+
+	Audio::Mixer::SoundType type;
+	switch (index) {
+		case kVoice:
+			type = Audio::Mixer::kSpeechSoundType;
+			break;
+		case kMusic:
+			type = Audio::Mixer::kMusicSoundType;
+			break;
+		case kSfx:
+			type = Audio::Mixer::kSFXSoundType;
+	}
+
+	bool flag = ConfMan.getBool("mute");
+	_mixer->setVolumeForSoundType(type, flag ? 0 : value);
+}
+
+} // End of namespace Stark

engines/stark/services/settings.h

@@ -0,0 +1,86 @@
+/* ResidualVM - A 3D game interpreter
+ *
+ * ResidualVM is the legal property of its developers, whose names
+ * are too numerous to list here. Please refer to the AUTHORS
+ * file distributed with this source distribution.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ *
+ */
+
+#ifndef STARK_SERVICES_SETTINGS_H
+#define STARK_SERVICES_SETTINGS_H
+
+#include "common/config-manager.h"
+
+namespace Audio {
+class Mixer;
+}
+
+namespace Stark {
+
+/**
+ * Settings services.
+ * 
+ * Maintains the settings of the game.
+ */
+class Settings {
+public:
+	enum BoolSettingIndex {
+		kHighModel,
+		kSubtitle,
+		kSpecialFX,
+		kShadow,
+		kHighFMV,
+		kTimeSkip
+	};
+
+	enum IntSettingIndex {
+		kVoice,
+		kMusic,
+		kSfx
+	};
+
+	explicit Settings(Audio::Mixer *mixer);
+	~Settings() {}
+
+	/** Get the settings value */
+	bool getBoolSetting(BoolSettingIndex index) { return ConfMan.getBool(_boolKey[index]); }
+	int getIntSetting(IntSettingIndex index) { return ConfMan.getInt(_intKey[index]); }
+
+	/** Flip the boolean settings */
+	void flipSetting(BoolSettingIndex index) { 
+		ConfMan.setBool(_boolKey[index], !getBoolSetting(index));
+	}
+
+	/** Set the integer settings */
+	void setIntSetting(IntSettingIndex index, int value);
+
+	/** Check whether low-resolution fmv is available */
+	bool hasLowResFMV() { return _hasLowRes; }
+
+private:
+	const static int _maxVolume = 256;
+
+	Audio::Mixer *_mixer;
+	bool _hasLowRes;
+
+	const char *_boolKey[6];
+	const char *_intKey[3];
+};
+
+} // End of namespace Stark
+
+#endif // STARK_SERVICES_SETTINGS_H

engines/stark/services/staticprovider.cpp

@@ -87,6 +87,17 @@ VisualImageXMG *StaticProvider::getUIElement(UIElement element) const {
 	return getCursorImage(element);
 }
 
+VisualImageXMG *StaticProvider::getUIElement(UIElement element, uint32 index) const {
+	Resources::Anim *anim = _stockAnims[element];
+
+	uint32 prevIndex = anim->getCurrentFrame();
+	anim->selectFrame(index);
+	VisualImageXMG *visualImage = anim->getVisual()->get<VisualImageXMG>();
+	anim->selectFrame(prevIndex);
+
+	return visualImage;
+}
+
 VisualImageXMG *StaticProvider::getUIImage(UIImage image) const {
 	Resources::Image *anim = _stockImages[image];
 	return anim->getVisual()->get<VisualImageXMG>();

engines/stark/services/staticprovider.h

@@ -58,6 +58,8 @@ class StaticProvider {
 		kTextScrollUpArrow = 6,
 		kTextScrollDownArrow = 7,
 		kQuit = 8,
+		kCheckMark = 13,
+		kVolume = 14,
 		kDiaryNormal = 15,
 		kInventory = 16,
 		kTextBackgroundActive = 20,
@@ -91,6 +93,7 @@ class StaticProvider {
 
 	/** Get an image for a static UI element */
 	VisualImageXMG *getUIElement(UIElement element) const;
+	VisualImageXMG *getUIElement(UIElement element, uint32 index) const;
 
 	/** Get an image for a static UI element */
 	VisualImageXMG *getUIImage(UIImage image) const;

engines/stark/services/userinterface.cpp

@@ -37,6 +37,7 @@
 #include "engines/stark/ui/cursor.h"
 #include "engines/stark/ui/menu/diaryindex.h"
 #include "engines/stark/ui/menu/mainmenu.h"
+#include "engines/stark/ui/menu/settingsmenu.h"
 #include "engines/stark/ui/world/inventorywindow.h"
 #include "engines/stark/ui/world/fmvscreen.h"
 #include "engines/stark/ui/world/gamescreen.h"
@@ -49,6 +50,7 @@ UserInterface::UserInterface(Gfx::Driver *gfx) :
 		_cursor(nullptr),
 		_diaryIndexScreen(nullptr),
 		_mainMenuScreen(nullptr),
+		_settingsMenuScreen(nullptr),
 		_exitGame(false),
 		_fmvScreen(nullptr),
 		_gameScreen(nullptr),
@@ -67,6 +69,7 @@ UserInterface::~UserInterface() {
 	delete _diaryIndexScreen;
 	delete _cursor;
 	delete _mainMenuScreen;
+	delete _settingsMenuScreen;
 }
 
 void UserInterface::init() {
@@ -75,6 +78,7 @@ void UserInterface::init() {
 	_mainMenuScreen = new MainMenuScreen(_gfx, _cursor);
 	_gameScreen = new GameScreen(_gfx, _cursor);
 	_diaryIndexScreen = new DiaryIndexScreen(_gfx, _cursor);
+	_settingsMenuScreen = new SettingsMenuScreen(_gfx, _cursor);
 	_fmvScreen = new FMVScreen(_gfx, _cursor);
 
 	_prevScreenNameStack.push(Screen::kScreenMainMenu);
@@ -95,6 +99,11 @@ void UserInterface::handleMouseMove(const Common::Point &pos) {
 	_cursor->setMousePosition(pos);
 }
 
+void UserInterface::handleMouseUp() {
+	// Only the settings menu needs to handle this event
+	_settingsMenuScreen->handleMouseUp();
+}
+
 void UserInterface::handleClick() {
 	_currentScreen->handleClick();
 }
@@ -143,13 +152,7 @@ void UserInterface::changeScreen(Screen::Name screenName) {
 		return;
 	}
 
-	if (screenName == Screen::kScreenMainMenu) {
-		// MainMenuScreen will not request to go back
-		_prevScreenNameStack.clear();
-	} else {
-		_prevScreenNameStack.push(_currentScreen->getName());
-	}
-
+	_prevScreenNameStack.push(_currentScreen->getName());
 	_currentScreen->close();
 	_currentScreen = getScreenByName(screenName);
 	_currentScreen->open();
@@ -159,12 +162,21 @@ void UserInterface::backPrevScreen() {
 	// No need to check the stack since at least there will be a MainMenuScreen in it
 	// and MainMenuScreen will not request to go back
 	changeScreen(_prevScreenNameStack.pop());
+
+	// No need to push for going back
+	_prevScreenNameStack.pop();
 }
 
 void UserInterface::quitToMainMenu() {
 	changeScreen(Screen::kScreenGame);
 	StarkResourceProvider->shutdown();
 	changeScreen(Screen::kScreenMainMenu);
+	_prevScreenNameStack.clear();
+}
+
+void UserInterface::restoreScreenHistory() {
+	_prevScreenNameStack.clear();
+	_prevScreenNameStack.push(Screen::kScreenMainMenu);
 }
 
 Screen *UserInterface::getScreenByName(Screen::Name screenName) const {
@@ -177,6 +189,8 @@ Screen *UserInterface::getScreenByName(Screen::Name screenName) const {
 			return _gameScreen;
 		case Screen::kScreenMainMenu:
 			return _mainMenuScreen;
+		case Screen::kScreenSettingsMenu:
+			return _settingsMenuScreen;
 		default:
 			error("Unhandled screen name '%d'", screenName);
 	}