Initial commit

engines/alcachofa/alcachofa.cpp

@@ -0,0 +1,493 @@
+/* ScummVM - Graphic Adventure Engine
+ *
+ * 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.
+ *
+ * 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 3 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, see <http://www.gnu.org/licenses/>.
+ *
+ */
+
+#include "common/config-manager.h"
+#include "common/debug-channels.h"
+#include "common/events.h"
+#include "common/savefile.h"
+#include "common/system.h"
+#include "engines/util.h"
+#include "graphics/paletteman.h"
+#include "graphics/framelimiter.h"
+#include "graphics/thumbnail.h"
+#include "graphics/managed_surface.h"
+#include "image/png.h"
+#include "video/avi_decoder.h"
+#include "video/mpegps_decoder.h"
+
+#include "alcachofa/alcachofa.h"
+#include "alcachofa/metaengine.h"
+#include "alcachofa/console.h"
+#include "alcachofa/detection.h"
+#include "alcachofa/player.h"
+#include "alcachofa/rooms.h"
+#include "alcachofa/script.h"
+#include "alcachofa/global-ui.h"
+#include "alcachofa/menu.h"
+#include "alcachofa/debug.h"
+#include "alcachofa/game.h"
+
+using namespace Math;
+using namespace Graphics;
+
+namespace Alcachofa {
+
+constexpr uint kDefaultFramerate = 100; // the original target framerate, not critical
+
+AlcachofaEngine *g_engine;
+
+AlcachofaEngine::AlcachofaEngine(OSystem *syst, const AlcachofaGameDescription *gameDesc)
+	: Engine(syst)
+	, _gameDescription(gameDesc)
+	, _eventLoopSemaphore("engine") {
+	assert(gameDesc != nullptr);
+	g_engine = this;
+}
+
+AlcachofaEngine::~AlcachofaEngine() {
+	// do not delete, this is done by `Engine::~Engine` with `delete _debugger;`
+	_console = nullptr; //-V773
+}
+
+uint32 AlcachofaEngine::getFeatures() const {
+	return _gameDescription->desc.flags;
+}
+
+Common::String AlcachofaEngine::getGameId() const {
+	return _gameDescription->desc.gameId;
+}
+
+Common::Error AlcachofaEngine::run() {
+	g_system->showMouse(false);
+	setDebugger(_console);
+	_game.reset(Game::createForMovieAdventure());
+	_renderer.reset(IRenderer::createOpenGLRenderer(Common::Point(1024, 768)));
+	_drawQueue.reset(new DrawQueue(_renderer.get()));
+	_world.reset(new World());
+	_script.reset(new Script());
+	_player.reset(new Player());
+	_globalUI.reset(new GlobalUI());
+	_menu.reset(new Menu());
+	setMillis(0);
+	game().onLoadedGameFiles();
+
+	if (!tryLoadFromLauncher()) {
+		_script->createProcess(MainCharacterKind::None, "CREDITOS_INICIALES");
+		_scheduler.run();
+		// we run once to set the initial room, otherwise we could run into currentRoom == nullptr
+	}
+
+	Common::Event e;
+	Graphics::FrameLimiter limiter(g_system, kDefaultFramerate, false);
+	while (!shouldQuit()) {
+		_input.nextFrame();
+		while (g_system->getEventManager()->pollEvent(e)) {
+			if (_input.handleEvent(e))
+				continue;
+			if (e.type == EVENT_CUSTOM_ENGINE_ACTION_START &&
+				e.customType == (CustomEventType)EventAction::LoadFromMenu)
+				menu().triggerLoad();
+		}
+
+		_sounds.update();
+		_renderer->begin();
+		_drawQueue->clear();
+		_camera.shake() = Vector2d();
+		_player->preUpdate();
+		if (_player->currentRoom() != nullptr)
+			_player->currentRoom()->update();
+		if (_player->currentRoom() != nullptr) // update() might clear currentRoom
+			_player->currentRoom()->draw();
+		_player->postUpdate();
+		if (_debugHandler != nullptr)
+			_debugHandler->update();
+		_renderer->end();
+
+		// Delay for a bit. All events loops should have a delay
+		// to prevent the system being unduly loaded
+		if (!_renderer->hasOutput()) {
+			limiter.delayBeforeSwap();
+			g_system->updateScreen();
+		}
+		// else we just rendered to some surface and will use it in the next frame
+		// no need to update the screen or wait 
+		limiter.startFrame();
+	}
+
+	return Common::kNoError;
+}
+
+void AlcachofaEngine::playVideo(int32 videoId) {
+	if (game().isKnownBadVideo(videoId)) {
+		warning("Skipping known bad video %d", videoId);
+		return;
+	}
+
+	// Video files are either MPEG PS or AVI
+	FakeLock lock("playVideo", _eventLoopSemaphore);
+	File *file = new File();
+	if (!file->open(Path(Common::String::format("Data/DATA%02d.BIN", videoId + 1)))) {
+		delete file;
+		game().invalidVideo(videoId, "open file");
+		return;
+	}
+	char magic[4];
+	if (file->read(magic, sizeof(magic)) != sizeof(magic) || !file->seek(0)) {
+		delete file;
+		game().invalidVideo(videoId, "read magic");
+		return;
+	}
+	ScopedPtr<Video::VideoDecoder> decoder;
+	if (memcmp(magic, "RIFF", sizeof(magic)) == 0)
+		decoder.reset(new Video::AVIDecoder());
+	else
+		decoder.reset(new Video::MPEGPSDecoder());
+	if (!decoder->loadStream(file)) {
+		game().invalidVideo(videoId, "decode video");
+		return;
+	}
+	decoder->setOutputPixelFormat(g_engine->renderer().getPixelFormat());
+
+	Vector2d texMax(1.0f, 1.0f);
+	int16 texWidth = decoder->getWidth(), texHeight = decoder->getHeight();
+	ManagedSurface tmpSurface;
+	if (_renderer->requiresPoTTextures() &&
+		(!isPowerOfTwo(texWidth) || !isPowerOfTwo(texHeight))) {
+		texWidth = nextHigher2(texWidth);
+		texHeight = nextHigher2(texHeight);
+		texMax = {
+			decoder->getWidth() / (float)texWidth,
+			decoder->getHeight() / (float)texHeight,
+		};
+		tmpSurface.create(texWidth, texHeight, _renderer->getPixelFormat());
+	}
+	auto texture = _renderer->createTexture(texWidth, texHeight, false);
+
+	Common::Event e;
+	_sounds.stopAll();
+	decoder->start();
+	while (!decoder->endOfVideo() && !shouldQuit()) {
+		if (decoder->needsUpdate()) {
+			auto surface = decoder->decodeNextFrame();
+			if (surface) {
+				if (tmpSurface.empty())
+					texture->update(*surface);
+				else {
+					tmpSurface.blitFrom(*surface);
+					texture->update(tmpSurface);
+				}
+			}
+			_renderer->begin();
+			_renderer->setBlendMode(BlendMode::Alpha);
+			_renderer->setLodBias(0.0f);
+			_renderer->setTexture(texture.get());
+			_renderer->quad(
+				{},
+				{ (float)g_system->getWidth(), (float)g_system->getHeight() },
+				kWhite,
+				{},
+				{},
+				texMax);
+			_renderer->end();
+			g_system->updateScreen();
+		}
+
+		_input.nextFrame();
+		while (g_system->getEventManager()->pollEvent(e)) {
+			if (_input.handleEvent(e))
+				continue;
+		}
+		if (_input.wasAnyMouseReleased() || _input.wasMenuKeyPressed())
+			break;
+
+		g_system->delayMillis(decoder->getTimeToNextFrame());
+	}
+	decoder->stop();
+}
+
+void AlcachofaEngine::fadeExit() {
+	constexpr uint kFadeOutDuration = 1000;
+	FakeLock lock("fadeExit", _eventLoopSemaphore);
+	Event e;
+	Graphics::FrameLimiter limiter(g_system, kDefaultFramerate, false);
+	uint32 startTime = g_system->getMillis();
+
+	Room *room = g_engine->player().currentRoom();
+	_renderer->end(); // we were in a frame, let's exit
+	while (g_system->getMillis() - startTime < kFadeOutDuration && !shouldQuit()) {
+		_input.nextFrame();
+		while (g_system->getEventManager()->pollEvent(e)) {
+			if (_input.handleEvent(e))
+				continue;
+		}
+
+		_renderer->begin();
+		_drawQueue->clear();
+		float t = ((float)(g_system->getMillis() - startTime)) / kFadeOutDuration;
+		_drawQueue->add<FadeDrawRequest>(FadeType::ToBlack, t, -kForegroundOrderCount);
+		if (room != nullptr)
+			room->draw(); // this executes the drawQueue as well
+		_renderer->end();
+
+		limiter.delayBeforeSwap();
+		g_system->updateScreen();
+		limiter.startFrame();
+	}
+
+	quitGame();
+	player().changeRoom("SALIR", false); // this skips some update steps along the way
+}
+
+void AlcachofaEngine::setDebugMode(DebugMode mode, int32 param) {
+	switch (mode) {
+	case DebugMode::ClosestFloorPoint:
+		_debugHandler.reset(new ClosestFloorPointDebugHandler(param));
+		break;
+	case DebugMode::FloorIntersections:
+		_debugHandler.reset(new FloorIntersectionsDebugHandler(param));
+		break;
+	case DebugMode::TeleportCharacter:
+		_debugHandler.reset(new TeleportCharacterDebugHandler(param));
+		break;
+	case DebugMode::FloorAlpha:
+		_debugHandler.reset(FloorColorDebugHandler::create(param, false));
+		break;
+	case DebugMode::FloorColor:
+		_debugHandler.reset(FloorColorDebugHandler::create(param, true));
+		break;
+	default:
+		_debugHandler.reset(nullptr);
+		break;
+	}
+	_input.toggleDebugInput(isDebugModeActive());
+}
+
+uint32 AlcachofaEngine::getMillis() const {
+	// Time is stored in savestate at various points e.g. to persist animation progress
+	// We wrap the system-provided time to offset it to the expected game-time
+	// This would also double as playtime
+	return g_system->getMillis() - _timeNegOffset + _timePosOffset;
+}
+
+void AlcachofaEngine::setMillis(uint32 newMillis) {
+	const uint32 sysMillis = g_system->getMillis();
+	if (newMillis > sysMillis) {
+		_timeNegOffset = 0;
+		_timePosOffset = newMillis - sysMillis;
+	} else {
+		_timeNegOffset = sysMillis - newMillis;
+		_timePosOffset = 0;
+	}
+}
+
+void AlcachofaEngine::pauseEngineIntern(bool pause) {
+	// Audio::Mixer also implements recursive pausing,
+	// so ScummVM pausing and Menu pausing will not conflict
+	_sounds.pauseAll(pause);
+
+	if (pause)
+		_timeBeforePause = getMillis();
+	else
+		setMillis(_timeBeforePause);
+}
+
+bool AlcachofaEngine::canLoadGameStateCurrently(U32String *msg) {
+	if (!_eventLoopSemaphore.isReleased())
+		return false;
+	return
+		(menu().isOpen() && menu().interactionSemaphore().isReleased()) ||
+		player().isAllowedToOpenMenu();
+}
+
+Common::String AlcachofaEngine::getSaveStatePattern() {
+	return getMetaEngine()->getSavegameFilePattern(_targetName.c_str());
+}
+
+Common::Error AlcachofaEngine::syncGame(MySerializer &s) {
+	if (!s.syncVersion((Serializer::Version)kCurrentSaveVersion))
+		return { kUnknownError, "Gamestate version is higher than expected" };
+
+	Graphics::ManagedSurface *thumbnail = nullptr;
+	if (s.isSaving()) {
+		thumbnail = new Graphics::ManagedSurface();
+		getSavegameThumbnail(*thumbnail->surfacePtr());
+	}
+	bool couldSyncThumbnail = syncThumbnail(s, thumbnail);
+	if (thumbnail != nullptr)
+		delete thumbnail;
+	if (!couldSyncThumbnail)
+		return { kUnknownError, "Could not read thumbnail" };
+
+	uint32 millis = menu().isOpen()
+		? menu().millisBeforeMenu()
+		: getMillis();
+	s.syncAsUint32LE(millis);
+	if (s.isLoading())
+		setMillis(millis);
+
+	/* Some notes about the order:
+	 * 1. The scheduler should prepare due to our FakeSemaphores
+	 *    By destructing all previous processes we also release all locks and
+	 *    can assert that the semaphores are released on loading.
+	 * 2. The player should come late as it changes the room
+	 * 3. With the room current, the tasks can now better find the referenced objects
+	 * 4. Redundant: The world has to be synced before the tasks to reset the semaphores to 0
+	 */
+
+	scheduler().prepareSyncGame(s);
+	world().syncGame(s);
+	camera().syncGame(s);
+	script().syncGame(s);
+	globalUI().syncGame(s);
+	player().syncGame(s);
+	scheduler().syncGame(s);
+
+	if (s.isLoading()) {
+		menu().resetAfterLoad();
+		sounds().stopAll();
+		sounds().setMusicToRoom(player().currentRoom()->musicID());
+	}
+
+	return Common::kNoError;
+}
+
+static constexpr uint32 kNoThumbnailMagicValue = 0xBADBAD;
+
+bool AlcachofaEngine::syncThumbnail(MySerializer &s, Graphics::ManagedSurface *thumbnail) {
+	if (s.isLoading()) {
+		auto prevPosition = s.readStream().pos();
+		Image::PNGDecoder pngDecoder;
+		if (pngDecoder.loadStream(s.readStream()) && pngDecoder.getSurface() != nullptr) {
+			if (thumbnail != nullptr) {
+				thumbnail->free();
+				thumbnail->copyFrom(*pngDecoder.getSurface());
+			}
+		} else {
+			// If we do not get a thumbnail, maybe we get at least the marker that there is no thumbnail
+			s.readStream().seek(prevPosition, SEEK_SET);
+			uint32 magicValue = s.readStream().readUint32LE();
+			if (magicValue != kNoThumbnailMagicValue)
+				return false; // the savegame is not valid
+			else // this is not an error, just a pity
+				warning("No thumbnail stored in in-game savestate");
+		}
+	} else {
+		if (thumbnail == nullptr ||
+			thumbnail->getPixels() == nullptr ||
+			!Image::writePNG(s.writeStream(), *thumbnail)) {
+			// We were not able to get a thumbnail, save a value that denotes that situation
+			warning("Could not save in-game thumbnail");
+			s.writeStream().writeUint32LE(kNoThumbnailMagicValue);
+		}
+	}
+	return true;
+}
+
+void AlcachofaEngine::getSavegameThumbnail(Graphics::Surface &thumbnail) {
+	thumbnail.free();
+
+	auto *bigThumbnail = g_engine->menu().getBigThumbnail();
+	if (bigThumbnail != nullptr) {
+		// we still have a one from the in-game menu opening, reuse that
+		thumbnail.copyFrom(*bigThumbnail);
+		return;
+	}
+
+	// otherwise we have to rerender
+	thumbnail.create(kBigThumbnailWidth, kBigThumbnailHeight, g_engine->renderer().getPixelFormat());
+	if (g_engine->player().currentRoom() == nullptr)
+		return; // but without a room we would render only black anyway
+
+	g_engine->drawQueue().clear();
+	g_engine->renderer().begin();
+	g_engine->renderer().setOutput(thumbnail);
+	g_engine->player().currentRoom()->draw(); // drawQueue is drawn here as well
+	g_engine->renderer().end();
+
+	// we should be within the event loop. as such it is quite safe to mess with the drawQueue or renderer
+}
+
+bool AlcachofaEngine::tryLoadFromLauncher() {
+	int saveSlot = ConfMan.getInt("save_slot");
+	if (!ConfMan.hasKey("save_slot") || saveSlot < 0)
+		return false;
+	auto *saveFile = g_system->getSavefileManager()->openForLoading(getSaveStateName(saveSlot));
+	if (saveFile == nullptr)
+		return false;
+	bool result = loadGameStream(saveFile).getCode() == kNoError;
+	delete saveFile;
+	return result;
+}
+
+Config::Config() {
+	loadFromScummVM();
+}
+
+void Config::loadFromScummVM() {
+	_musicVolume = (uint8)CLIP(ConfMan.getInt("music_volume"), 0, 255);
+	_speechVolume = (uint8)CLIP(ConfMan.getInt("speech_volume"), 0, 255);
+	_subtitles = ConfMan.getBool("subtitles");
+	_highQuality = ConfMan.getBool("high_quality");
+	_bits32 = ConfMan.getBool("32_bits");
+}
+
+void Config::saveToScummVM() {
+	ConfMan.setBool("subtitles", _subtitles);
+	ConfMan.setBool("high_quality", _highQuality);
+	ConfMan.setBool("32_bits", _bits32);
+	ConfMan.setInt("music_volume", _musicVolume);
+	ConfMan.setInt("speech_volume", _speechVolume);
+	ConfMan.setInt("sfx_volume", _speechVolume);
+	ConfMan.flushToDisk();
+	// ^ a bit unfortunate, that means if you change in-game it overrides.
+	// if you set it in ScummVMs dialog it sticks
+}
+
+DelayTask::DelayTask(Process &process, uint32 millis)
+	: Task(process)
+	, _endTime(millis) {}
+
+DelayTask::DelayTask(Process &process, Serializer &s)
+	: Task(process) {
+	DelayTask::syncGame(s);
+}
+
+TaskReturn DelayTask::run() {
+	TASK_BEGIN;
+	_endTime += g_engine->getMillis();
+	while (g_engine->getMillis() < _endTime)
+		TASK_YIELD(1);
+	TASK_END;
+}
+
+void DelayTask::debugPrint() {
+	uint32 remaining = g_engine->getMillis() <= _endTime ? _endTime - g_engine->getMillis() : 0;
+	g_engine->getDebugger()->debugPrintf("Delay for further %ums\n", remaining);
+}
+
+void DelayTask::syncGame(Serializer &s) {
+	Task::syncGame(s);
+	s.syncAsUint32LE(_endTime);
+}
+
+DECLARE_TASK(DelayTask)
+
+} // End of namespace Alcachofa