diff options
Diffstat (limited to 'engines/bladerunner/ui')
38 files changed, 5968 insertions, 0 deletions
diff --git a/engines/bladerunner/ui/elevator.cpp b/engines/bladerunner/ui/elevator.cpp new file mode 100644 index 0000000000..f0c8d7d921 --- /dev/null +++ b/engines/bladerunner/ui/elevator.cpp @@ -0,0 +1,325 @@ +/* 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 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 "bladerunner/ui/elevator.h" + +#include "bladerunner/actor.h" +#include "bladerunner/bladerunner.h" +#include "bladerunner/audio_player.h" +#include "bladerunner/game_info.h" +#include "bladerunner/mouse.h" +#include "bladerunner/shape.h" +#include "bladerunner/script/script.h" +#include "bladerunner/ui/ui_image_picker.h" +#include "bladerunner/vqa_player.h" + +#include "common/rect.h" +#include "common/str.h" +#include "common/system.h" + +namespace BladeRunner { + +Elevator::Elevator(BladeRunnerEngine *vm) { + _vm = vm; + reset(); + _imagePicker = new UIImagePicker(vm, 8); +} + +Elevator::~Elevator() { + delete _imagePicker; + reset(); +} + +int Elevator::activate(int elevatorId) { + const char *vqaName; + + if (elevatorId == 1) { + _buttonClicked = 3; + vqaName = "MA06ELEV.VQA"; + } else if (elevatorId == 2) { + _buttonClicked = 1; + vqaName = "PS02ELEV.VQA"; + } else { + error("Invalid elevator id"); + } + + if (!_vm->openArchive("MODE.MIX")) { + return 0; + } + + _vqaPlayer = new VQAPlayer(_vm, &_vm->_surfaceBack); + if (!_vqaPlayer->open(vqaName)) { + return 0; + } + + _vqaPlayer->setLoop(1, -1, kLoopSetModeJustStart, nullptr, nullptr); + _vm->_mouse->setCursor(0); + + for (int i = 0; i != 16; ++i) { + _shapes.push_back(new Shape(_vm)); + _shapes[i]->readFromContainer("ELEVATOR.SHP", i); + } + + _imagePicker->resetImages(); + + if (elevatorId == 1) { + _imagePicker->defineImage( + 0, + Common::Rect(220, 298, 308, 392), + nullptr, + _shapes[11], + _shapes[14], + nullptr); + _imagePicker->defineImage( + 1, + Common::Rect(259, 259, 302, 292), + nullptr, + _shapes[10], + _shapes[13], + nullptr); + _imagePicker->defineImage( + 2, + Common::Rect(227, 398, 301, 434), + nullptr, + _shapes[12], + _shapes[15], + nullptr); + } else { + _imagePicker->defineImage( + 4, + Common::Rect(395, 131, 448, 164), + nullptr, + _shapes[0], + _shapes[5], + nullptr + ); + _imagePicker->defineImage( + 3, + Common::Rect(395, 165, 448, 198), + nullptr, + _shapes[1], + _shapes[6], + nullptr + ); + _imagePicker->defineImage( + 5, + Common::Rect(395, 199, 448, 232), + nullptr, + _shapes[2], + _shapes[7], + nullptr + ); + _imagePicker->defineImage( + 6, + Common::Rect(395, 233, 448, 264), + nullptr, + _shapes[3], + _shapes[8], + nullptr + ); + _imagePicker->defineImage( + 7, + Common::Rect(395, 265, 448, 295), + nullptr, + _shapes[4], + _shapes[9], + nullptr + ); + } + + _imagePicker->activate( + mouseInCallback, + mouseOutCallback, + mouseDownCallback, + mouseUpCallback, + this + ); + + open(); + + // TODO: time->lock(); + + _buttonClicked = -1; + do { + _vm->gameTick(); + } while (_buttonClicked == -1); + + _imagePicker->deactivate(); + + _vqaPlayer->close(); + delete _vqaPlayer; + + for (int i = 0; i != (int)_shapes.size(); ++i) { + delete _shapes[i]; + } + _shapes.clear(); + + _vm->closeArchive("MODE.MIX"); + + _isOpen = false; + + // TODO: time->unlock(); + + return _buttonClicked; +} + +void Elevator::open() { + resetDescription(); + _isOpen = true; +} + +bool Elevator::isOpen() const { + return _isOpen; +} + +int Elevator::handleMouseUp(int x, int y) { + _imagePicker->handleMouseAction(x, y, false, true, false); + return false; +} + +int Elevator::handleMouseDown(int x, int y) { + _imagePicker->handleMouseAction(x, y, true, false, false); + return false; +} + +void Elevator::tick() { + if (!_vm->_gameIsRunning) { + return; + } + + int frame = _vqaPlayer->update(); + assert(frame >= -1); + + // vqaPlayer renders to _surfaceBack + blit(_vm->_surfaceBack, _vm->_surfaceFront); + + Common::Point p = _vm->getMousePos(); + + // TODO(madmoose): BLADE.EXE has hasHoveredImage before handleMouseAction? + _imagePicker->handleMouseAction(p.x, p.y, false, false, false); + if (_imagePicker->hasHoveredImage()) { + _vm->_mouse->setCursor(1); + } else { + _vm->_mouse->setCursor(0); + } + + _imagePicker->draw(_vm->_surfaceFront); + _vm->_mouse->draw(_vm->_surfaceFront, p.x, p.y); + + _vm->blitToScreen(_vm->_surfaceFront); + tickDescription(); + _vm->_system->delayMillis(10); +} + +void Elevator::buttonClick(int buttonId) { + _buttonClicked = buttonId; +} + +void Elevator::reset() { + _isOpen = false; + _vqaPlayer = nullptr; + _imagePicker = nullptr; + _actorId = -1; + _sentenceId = -1; + _timeSpeakDescription = 0; +} + +void Elevator::buttonFocus(int buttonId) { + switch (buttonId) { + case 7: + setupDescription(kActorAnsweringMachine, 140); + break; + case 6: + setupDescription(kActorAnsweringMachine, 130); + break; + case 5: + setupDescription(kActorAnsweringMachine, 120); + break; + case 4: + setupDescription(kActorAnsweringMachine, 100); + break; + case 3: + setupDescription(kActorAnsweringMachine, 110); + break; + case 2: + setupDescription(kActorAnsweringMachine, 130); + break; + case 1: + setupDescription(kActorAnsweringMachine, 100); + break; + case 0: + setupDescription(kActorAnsweringMachine, 150); + break; + default: + resetDescription(); + break; + } +} + +void Elevator::setupDescription(int actorId, int sentenceId) { + _actorId = actorId; + _sentenceId = sentenceId; + + // TODO: Use proper timer + _timeSpeakDescription = _vm->getTotalPlayTime() + 600; +} + +void Elevator::resetDescription() { + _actorId = -1; + _sentenceId = -1; + _timeSpeakDescription = 0; +} + +void Elevator::tickDescription() { + int now = _vm->getTotalPlayTime(); + if (_actorId <= 0 || now < _timeSpeakDescription) { + return; + } + + _vm->_actors[_actorId]->speechPlay(_sentenceId, false); + _actorId = -1; + _sentenceId = -1; +} + +void Elevator::resume() { + // TODO +} + +void Elevator::mouseInCallback(int buttonId, void *self) { + ((Elevator *)self)->buttonFocus(buttonId); +} + +void Elevator::mouseOutCallback(int, void *self) { + ((Elevator *)self)->buttonFocus(-1); +} + +void Elevator::mouseDownCallback(int, void *self) { + Elevator *elevator = ((Elevator *)self); + const char *name = elevator->_vm->_gameInfo->getSfxTrack(515); + elevator->_vm->_audioPlayer->playAud(name, 100, 0, 0, 50, 0); +} + +void Elevator::mouseUpCallback(int buttonId, void *self) { + ((Elevator *)self)->buttonClick(buttonId); +} + +} // End of namespace BladeRunner diff --git a/engines/bladerunner/ui/elevator.h b/engines/bladerunner/ui/elevator.h new file mode 100644 index 0000000000..f2e1443929 --- /dev/null +++ b/engines/bladerunner/ui/elevator.h @@ -0,0 +1,73 @@ +/* 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 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 BLADERUNNER_ELEVATOR_H +#define BLADERUNNER_ELEVATOR_H + +#include "common/array.h" + +namespace BladeRunner { + +class BladeRunnerEngine; +class Shape; +class VQAPlayer; +class UIImagePicker; + +class Elevator { + BladeRunnerEngine *_vm; + bool _isOpen; + VQAPlayer *_vqaPlayer; + int _buttonClicked; + Common::Array<Shape *> _shapes; + UIImagePicker *_imagePicker; + int _actorId; + int _sentenceId; + int _timeSpeakDescription; + +public: + Elevator(BladeRunnerEngine *vm); + ~Elevator(); + + int activate(int elevatorId); + void open(); + bool isOpen() const; + int handleMouseUp(int x, int y); + int handleMouseDown(int x, int y); + void tick(); + void buttonClick(int buttonId); + void reset(); + void buttonFocus(int buttonId); + void setupDescription(int actorId, int sentenceId); + void resetDescription(); + void tickDescription(); + void resume(); + +private: + static void mouseInCallback(int, void *); + static void mouseOutCallback(int, void *); + static void mouseDownCallback(int, void *); + static void mouseUpCallback(int, void *); +}; + +} // End of namespace BladeRunner + +#endif diff --git a/engines/bladerunner/ui/kia.cpp b/engines/bladerunner/ui/kia.cpp new file mode 100644 index 0000000000..09c5918872 --- /dev/null +++ b/engines/bladerunner/ui/kia.cpp @@ -0,0 +1,1229 @@ +/* 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 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 "bladerunner/ui/kia.h" + +#include "bladerunner/actor.h" +#include "bladerunner/audio_player.h" +#include "bladerunner/bladerunner.h" +#include "bladerunner/combat.h" +#include "bladerunner/font.h" +#include "bladerunner/game_constants.h" +#include "bladerunner/game_flags.h" +#include "bladerunner/game_info.h" +#include "bladerunner/mouse.h" +#include "bladerunner/scene.h" +#include "bladerunner/shape.h" +#include "bladerunner/script/kia.h" +#include "bladerunner/settings.h" +#include "bladerunner/slice_renderer.h" +#include "bladerunner/text_resource.h" +#include "bladerunner/ui/kia_log.h" +#include "bladerunner/ui/kia_section_base.h" +#include "bladerunner/ui/kia_section_clues.h" +#include "bladerunner/ui/kia_section_crimes.h" +#include "bladerunner/ui/kia_section_diagnostic.h" +#include "bladerunner/ui/kia_section_help.h" +#include "bladerunner/ui/kia_section_load.h" +#include "bladerunner/ui/kia_section_settings.h" +#include "bladerunner/ui/kia_section_pogo.h" +#include "bladerunner/ui/kia_section_save.h" +#include "bladerunner/ui/kia_section_suspects.h" +#include "bladerunner/ui/kia_shapes.h" +#include "bladerunner/ui/ui_image_picker.h" +#include "bladerunner/vqa_player.h" + +#include "common/str.h" +#include "common/keyboard.h" + +namespace BladeRunner { + +const char *KIA::kPogo = "POGO"; + +enum KIASections { + kKIASectionNone = 0, + kKIASectionCrimes = 1, + kKIASectionSuspects = 2, + kKIASectionClues = 3, + kKIASectionSettings = 4, + kKIASectionHelp = 5, + kKIASectionSave = 6, + kKIASectionLoad = 7, + kKIASectionQuit = 8, + kKIASectionDiagnostic = 9, + kKIASectionPogo = 10 +}; + +KIA::KIA(BladeRunnerEngine *vm) { + _vm = vm; + + _script = new KIAScript(_vm); + _log = new KIALog(_vm); + _shapes = new KIAShapes(_vm); + + _forceOpen = 0; + _currentSectionId = kKIASectionNone; + _lastSectionIdKIA = kKIASectionCrimes; + _lastSectionIdOptions = kKIASectionSettings; + _playerVqaTimeLast = _vm->getTotalPlayTime(); + _playerVqaFrame = 0; + _playerVisualizerState = 0; + _playerPhotographId = -1; + _playerPhotograph = nullptr; + _playerSliceModelId = -1; + _playerSliceModelAngle = 0.0f; + // _playerImage = nullptr; + _timeLast = _vm->getTotalPlayTime(); + _playerActorDialogueQueueCapacity = 31; + _playerActorDialogueQueuePosition = 0; + _playerActorDialogueQueueSize = 0; + _playerActorDialogueQueue = new ActorDialogueQueueEntry[_playerActorDialogueQueueCapacity]; + _playerActorDialogueState = 0; + _currentSection = nullptr; + _mainVqaPlayer = nullptr; + _playerVqaPlayer = nullptr; + // _thumbnail = nullptr; + + _pogoPos = 0; + + _buttons = new UIImagePicker(_vm, 22); + + _crimesSection = new KIASectionCrimes(_vm); // PlayerActor->_clues + _suspectsSection = new KIASectionSuspects(_vm); // PlayerActor->_clues + _cluesSection = new KIASectionClues(_vm, _vm->_playerActor->_clues); + _settingsSection = new KIASectionSettings(_vm); + _helpSection = new KIASectionHelp(_vm); + _saveSection = new KIASectionSave(_vm); + _loadSection = new KIASectionLoad(_vm); + _diagnosticSection = new KIASectionDiagnostic(_vm); + _pogoSection = new KIASectionPogo(_vm); +} + +KIA::~KIA() { + delete _playerPhotograph; + // delete _playerImage; + // delete _thumbnail; + delete _settingsSection; + delete _buttons; + delete _shapes; + delete _log; + delete _script; +} + +void KIA::openLastOpened() { + open(_lastSectionIdKIA); +} + +void KIA::openOptions() { + open(kKIASectionSettings); +} + +void KIA::tick() { + if (!_currentSectionId) { + return; + } + + int timeNow = _vm->getTotalPlayTime(); + int timeDiff = timeNow - _timeLast; + + if (_playerActorDialogueQueueSize == _playerActorDialogueQueuePosition) { + _playerActorDialogueState = 0; + } else if (_playerActorDialogueState == 0) { + if (_playerSliceModelId == -1 && _playerPhotographId == -1) { //&& !this->_playerImage + _vm->_audioPlayer->playAud(_vm->_gameInfo->getSfxTrack(495), 70, 0, 0, 50, 0); + } + _playerActorDialogueState = 1; + } else if (_playerActorDialogueState == 200) { + if (!_vm->_actors[_playerActorDialogueQueue[_playerActorDialogueQueuePosition].actorId]->isSpeeching()) { + if (_playerActorDialogueQueueSize != _playerActorDialogueQueuePosition) { + _playerActorDialogueQueuePosition = (_playerActorDialogueQueuePosition + 1) % _playerActorDialogueQueueCapacity; + } + if (_playerActorDialogueQueueSize != _playerActorDialogueQueuePosition) { + _vm->_actors[_playerActorDialogueQueue[_playerActorDialogueQueuePosition].actorId]->speechPlay(_playerActorDialogueQueue[_playerActorDialogueQueuePosition].sentenceId, true); + } + } + } else { + _playerActorDialogueState += timeDiff; + + if (_playerActorDialogueState >= 200) { + _playerActorDialogueState = 200; + _vm->_actors[_playerActorDialogueQueue[_playerActorDialogueQueuePosition].actorId]->speechPlay(_playerActorDialogueQueue[_playerActorDialogueQueuePosition].sentenceId, true); + } + } + + int timeDiffDiv48 = (timeNow - _playerVqaTimeLast) / 48; + if (timeDiffDiv48 > 0) { + _playerVqaTimeLast = timeNow; + if (_playerActorDialogueQueueSize == _playerActorDialogueQueuePosition || _playerSliceModelId != -1 || _playerPhotographId != -1) { // || this->_viewerImage + if (_playerVisualizerState > 0) { + _playerVisualizerState = MAX(_playerVisualizerState - timeDiffDiv48, 0); + } + } else { + if (_playerVisualizerState < 2) { + _playerVisualizerState = MIN(_playerVisualizerState + timeDiffDiv48, 2); + + } + } + + if ( _playerSliceModelId != -1 || _playerPhotographId != -1 ) { // || _playerImage + if (_playerVqaFrame < 8) { + int newVqaFrame = MIN(timeDiffDiv48 + _playerVqaFrame, 8); + if (_playerVqaFrame <= 0 && newVqaFrame > 0) { + _vm->_audioPlayer->playAud(_vm->_gameInfo->getSfxTrack(497), 100, 70, 70, 50, 0); + } + _playerVqaFrame = newVqaFrame; + } + } else { + if (_playerVqaFrame > 0) { + int newVqaFrame = MAX(_playerVqaFrame - timeDiffDiv48, 0); + if (_playerVqaFrame >= 8 && newVqaFrame < 8) + { + _vm->_audioPlayer->playAud(_vm->_gameInfo->getSfxTrack(496), 100, 70, 70, 50, 0); + } + _playerVqaFrame = newVqaFrame; + } + } + } + + _mainVqaPlayer->update(false); + blit(_vm->_surfaceBack, _vm->_surfaceFront); + + Common::Point mouse = _vm->getMousePos(); + + if (!_transitionId) { + _buttons->handleMouseAction(mouse.x, mouse.y, false, false, false); + if (_buttons->hasHoveredImage()) { + _vm->_mouse->setCursor(1); + } else { + _vm->_mouse->setCursor(0); + } + if (_currentSection) { + _currentSection->handleMouseMove(mouse.x, mouse.y); + } + } + + if (_vm->_gameFlags->query(kFlagKIAPrivacyAddon)) { + _shapes->get(40)->draw(_vm->_surfaceFront, 0, 0); + _shapes->get(41)->draw(_vm->_surfaceFront, 211, 447); + } + if (_currentSectionId != kKIASectionQuit && _transitionId != 14) { + if (_vm->_settings->getDifficulty() > 0) { + _vm->_mainFont->drawColor(Common::String::format("%04d", _vm->_gameVars[2]), _vm->_surfaceFront, 580, 341, 0x2991); + } else { + _shapes->get(39)->draw(_vm->_surfaceFront, 583, 342); + } + } + _playerVqaPlayer->seekToFrame(_playerVqaFrame); + _playerVqaPlayer->update(true); //_vm->_surfaceFront, 3 + + _playerSliceModelAngle += (float)(timeDiff) * 1.0f/400.0f; + while (_playerSliceModelAngle >= 2 * M_PI) { + _playerSliceModelAngle -= (float)(2 * M_PI); + } + + if (_playerVqaFrame == 8) { + if (_playerSliceModelId != -1) { + _vm->_sliceRenderer->drawOnScreen(_playerSliceModelId, 0, 585, 80, _playerSliceModelAngle, 100.0, _vm->_surfaceFront); + } else if (_playerPhotographId != -1) { + int width = _playerPhotograph->getWidth(); + int height = _playerPhotograph->getHeight(); + _playerPhotograph->draw(_vm->_surfaceFront, 590 - width / 2, 80 - height / 2); + } + // else if (_playerImage) { + // ... + // } + } + + if (_playerVisualizerState == 1) { + _shapes->get(51)->draw(_vm->_surfaceFront, 576, 174); + } else if (_playerVisualizerState == 2) { + _shapes->get(50)->draw(_vm->_surfaceFront, 576, 174); + _shapes->get(_vm->_rnd.getRandomNumberRng(90, 105))->draw(_vm->_surfaceFront, 576, 174); + } + if (!_transitionId) { + _buttons->draw(_vm->_surfaceFront); + if (_currentSection) { + _currentSection->draw(_vm->_surfaceFront); + } + } + if (_vm->_settings->getAmmoAmount(0) > 0) { + if (_vm->_settings->getAmmoType() == 0) { + _shapes->get(42)->draw(_vm->_surfaceFront, 147, 405); + } else { + _shapes->get(45)->draw(_vm->_surfaceFront, 140, 446); + } + } + if (_vm->_settings->getAmmoAmount(1) > 0) { + if (_vm->_settings->getAmmoType() == 1) { + _shapes->get(43)->draw(_vm->_surfaceFront, 167, 394); + } else { + _shapes->get(46)->draw(_vm->_surfaceFront, 160, 446); + } + } + if (_vm->_settings->getAmmoAmount(2) > 0) { + if (_vm->_settings->getAmmoType() == 2) { + _shapes->get(44)->draw(_vm->_surfaceFront, 189, 385); + } else { + _shapes->get(47)->draw(_vm->_surfaceFront, 182, 446); + } + } + _vm->_mainFont->drawColor("1.00", _vm->_surfaceFront, 438, 471, 0x1CE7); + if (!_transitionId) { + _buttons->drawTooltip(_vm->_surfaceFront, mouse.x, mouse.y); + } + _vm->_mouse->draw(_vm->_surfaceFront, mouse.x, mouse.y); + _vm->blitToScreen(_vm->_surfaceFront); + + _timeLast = timeNow; +} + +void KIA::handleMouseDown(int mouseX, int mouseY, bool mainButton) { + if (!_currentSectionId) { + return; + } + if (mainButton) { + _buttons->handleMouseAction(mouseX, mouseY, true, false, false); + } + if (_currentSection) { + _currentSection->handleMouseDown(mainButton); + } +} + +void KIA::handleMouseUp(int mouseX, int mouseY, bool mainButton) { + if (!_currentSectionId) { + return; + } + if (mainButton) { + _buttons->handleMouseAction(mouseX, mouseY, false, true, false); + } + if (_currentSection) { + _currentSection->handleMouseUp(mainButton); + } + if (_currentSection && _currentSection->_field0) { + if (_currentSectionId == kKIASectionCrimes) { + open(kKIASectionSuspects); + // kiaSuspects::sub_45290C(_suspectsMenu, _crimesMenu->selectedSuspectId); + _log->next(); + _log->clearFuture(); + } else if (_currentSectionId == kKIASectionSuspects) { + open(kKIASectionCrimes); + // kiaCrimes::updateCrime(_crimesMenu, *&_suspectsMenu->data[8052]); + _log->next(); + _log->clearFuture(); + } else { + open(kKIASectionNone); + } + } +} + +void KIA::handleKeyUp(const Common::KeyState &kbd) { + if (!_currentSectionId) { + return; + } + + if (toupper(kbd.ascii) != kPogo[_pogoPos]) { + _pogoPos = 0; + } + if (_currentSectionId != kKIASectionSave) { + if (toupper(kbd.ascii) == kPogo[_pogoPos]) { + ++_pogoPos; + if (!kPogo[_pogoPos]) { + open(kKIASectionPogo); + _pogoPos = 0; + } + } + } + if (kbd.keycode == Common::KEYCODE_ESCAPE) { + if (!_forceOpen) { + open(kKIASectionNone); + } + } else { + if (_currentSection) { + _currentSection->handleKeyUp(kbd); + } + } + if (_currentSection && _currentSection->_field0) { + open(kKIASectionNone); + } +} + +void KIA::handleKeyDown(const Common::KeyState &kbd) { + if (!_currentSectionId) { + return; + } + switch (kbd.keycode) { + case Common::KEYCODE_F1: + open(kKIASectionHelp); + break; + case Common::KEYCODE_F2: + if (!_forceOpen) { + open(kKIASectionSave); + } + break; + case Common::KEYCODE_F3: + open(kKIASectionLoad); + break; + case Common::KEYCODE_F10: + open(kKIASectionQuit); + break; + case Common::KEYCODE_F4: + if (_currentSectionId != kKIASectionCrimes) { + if (!_forceOpen) { + open(kKIASectionCrimes); + _log->next(); + _log->clearFuture(); + } + } + break; + case Common::KEYCODE_F5: + if (_currentSectionId != kKIASectionSuspects) { + if (_forceOpen) { + open(kKIASectionSuspects); + _log->next(); + _log->clearFuture(); + } + } + break; + case Common::KEYCODE_F6: + if (_currentSectionId != kKIASectionClues) { + if (!_forceOpen) { + open(kKIASectionClues); + _log->next(); + _log->clearFuture(); + } + } + break; + default: + if (_currentSection) { + _currentSection->handleKeyDown(kbd); + } + break; + } + if (_currentSection && _currentSection->_field0) { + open(kKIASectionNone); + } +} + +void KIA::playerReset() { + if (_playerActorDialogueQueueSize != _playerActorDialogueQueuePosition) { + if (_playerActorDialogueQueueSize != _playerActorDialogueQueuePosition) { + int actorId = _playerActorDialogueQueue[_playerActorDialogueQueuePosition].actorId; + if (_vm->_actors[actorId]->isSpeeching()) { + _vm->_actors[actorId]->speechStop(); + } + } + } + _playerActorDialogueQueueSize = _playerActorDialogueQueuePosition; + _playerSliceModelId = -1; + if (_playerPhotographId != -1) { + delete _playerPhotograph; + _playerPhotograph = nullptr; + } + _playerPhotographId = -1; + // delete _playerImage; + // _playerImage = nullptr; + _playerActorDialogueState = 0; +} + +void KIA::playActorDialogue(int actorId, int sentenceId) { + int newQueueSize = (_playerActorDialogueQueueSize + 1) % _playerActorDialogueQueueCapacity; + if (newQueueSize != _playerActorDialogueQueuePosition) { + _playerActorDialogueQueue[_playerActorDialogueQueueSize].actorId = actorId; + _playerActorDialogueQueue[_playerActorDialogueQueueSize].sentenceId = sentenceId; + _playerActorDialogueQueueSize = newQueueSize; + } +} + +void KIA::playSliceModel(int sliceModelId) { + if (_playerVqaFrame == 8) { + _vm->_audioPlayer->playAud(_vm->_gameInfo->getSfxTrack(502), 70, 0, 0, 50, 0); + } + _playerSliceModelId = sliceModelId; +} + +void KIA::playPhotograph(int photographId) { + if (_playerPhotographId != -1) { + delete _playerPhotograph; + _playerPhotograph = nullptr; + } + if (_playerVqaFrame == 8) { + _vm->_audioPlayer->playAud(_vm->_gameInfo->getSfxTrack(502), 70, 0, 0, 50, 0); + } + _playerPhotographId = photographId; + _playerPhotograph = new Shape(_vm); + _playerPhotograph->readFromContainer("photos.shp", photographId); +} + +void KIA::mouseDownCallback(int buttonId, void *callbackData) { + KIA *self = (KIA *)callbackData; + switch (buttonId) { + case 0: + case 6: + self->_vm->_audioPlayer->playAud(self->_vm->_gameInfo->getSfxTrack(503), 100, -65, -65, 50, 0); + break; + case 1: + case 2: + case 3: + case 4: + case 5: + case 7: + case 8: + case 9: + case 10: + case 11: + case 12: + case 13: + case 14: + self->_vm->_audioPlayer->playAud(self->_vm->_gameInfo->getSfxTrack(505), 70, 0, 0, 50, 0); + if (buttonId == 12){ + self->_vm->_audioPlayer->playAud(self->_vm->_gameInfo->getSfxTrack(596), 70, 0, 0, 50, 0); + } + break; + case 15: + self->_vm->_audioPlayer->playAud(self->_vm->_gameInfo->getSfxTrack(503), 70, 0, 0, 50, 0); + break; + } +} + +void KIA::mouseUpCallback(int buttonId, void *callbackData) { + KIA *self = (KIA *)callbackData; + switch (buttonId) { + case 0: + case 6: + self->_vm->_audioPlayer->playAud(self->_vm->_gameInfo->getSfxTrack(504), 100, -65, -65, 50, 0); + break; + case 1: + case 2: + case 3: + case 4: + case 5: + case 7: + case 8: + case 9: + case 10: + case 11: + case 12: + case 13: + case 14: + self->_vm->_audioPlayer->playAud(self->_vm->_gameInfo->getSfxTrack(506), 70, 0, 0, 50, 0); + break; + case 15: + self->_vm->_audioPlayer->playAud(self->_vm->_gameInfo->getSfxTrack(504), 100, 0, 0, 50, 0); + break; + default: + break; + } + self->buttonClicked(buttonId); +} + +void KIA::loopEnded(void *callbackData, int frame, int loopId) { + KIA *self = (KIA *)callbackData; + self->_mainVqaPlayer->setLoop(self->getVqaLoopMain(self->_currentSectionId) + 1, -1, kLoopSetModeJustStart, nullptr, nullptr); + self->_transitionId = 0; +} + +void KIA::open(int sectionId) { + if (_currentSectionId == sectionId) { + return; + } + + if (!sectionId) { + unload(); + return; + } + + if (!_currentSectionId) { + init(); + } + + switch (_currentSectionId) { + case kKIASectionCrimes: + _crimesSection->saveToLog(); + break; + case kKIASectionSuspects: + _suspectsSection->saveToLog(); + break; + case kKIASectionClues: + _cluesSection->saveToLog(); + break; + } + + if (sectionId != kKIASectionCrimes && sectionId != kKIASectionSuspects && sectionId != kKIASectionClues) { + playerReset(); + } + + _transitionId = getTransitionId(_currentSectionId, sectionId); + const char *name = getSectionVqaName(sectionId); + if (getSectionVqaName(_currentSectionId) != name) { + if (_mainVqaPlayer) { + _mainVqaPlayer->close(); + delete _mainVqaPlayer; + _mainVqaPlayer = nullptr; + } + + _mainVqaPlayer = new VQAPlayer(_vm, &_vm->_surfaceBack); + _mainVqaPlayer->open(name); + } + + if (_transitionId) { + playTransitionSound(_transitionId); + _mainVqaPlayer->setLoop(getVqaLoopTransition(_transitionId), -1, kLoopSetModeImmediate, nullptr, nullptr); + _mainVqaPlayer->setLoop(getVqaLoopMain(sectionId), -1, kLoopSetModeEnqueue, loopEnded, this); + } else { + int loopId = getVqaLoopMain(sectionId); + _mainVqaPlayer->setLoop(loopId, -1, kLoopSetModeImmediate, nullptr, nullptr); + _mainVqaPlayer->setLoop(loopId + 1, -1, kLoopSetModeJustStart, nullptr, nullptr); + } + + _buttons->resetImages(); + createButtons(sectionId); + switchSection(sectionId); + _currentSectionId = sectionId; + + if (sectionId == kKIASectionCrimes || sectionId == kKIASectionSuspects || sectionId == kKIASectionClues) { + _lastSectionIdKIA = _currentSectionId; + } + + if (sectionId == kKIASectionSettings || sectionId == kKIASectionHelp || sectionId == kKIASectionSave || sectionId == kKIASectionLoad) { + _lastSectionIdOptions = _currentSectionId; + } +} + +void KIA::init() { + if (!_vm->openArchive("MODE.MIX")) { + return; + } + + playerReset(); + _playerVqaFrame = 0; + _playerVqaTimeLast = _vm->getTotalPlayTime(); + _timeLast = _vm->getTotalPlayTime(); + + if (_vm->_gameFlags->query(kFlagKIAPrivacyAddon) && !_vm->_gameFlags->query(kFlagKIAPrivacyAddonIntro)) { + _vm->_gameFlags->set(kFlagKIAPrivacyAddonIntro); + playPrivateAddon(); + } + + _shapes->load(); + _buttons->activate(nullptr, nullptr, mouseDownCallback, mouseUpCallback, this); + _vm->_mouse->setCursor(0); + if (_playerVqaPlayer == nullptr) { + + _playerVqaPlayer = new VQAPlayer(_vm, &_vm->_surfaceFront); + _playerVqaPlayer->open("kiaover.vqa"); + _playerVqaPlayer->setLoop(0, -1, kLoopSetModeJustStart, nullptr, nullptr); + } + _vm->_audioPlayer->playAud(_vm->_gameInfo->getSfxTrack(501), 70, 0, 0, 50, 0); + + // TODO: time->lock(); +} + +void KIA::unload() { + if (!_currentSectionId) { + return; + } + + _forceOpen = false; + + if (_currentSection) { + _currentSection->close(); + _currentSection = nullptr; + } + + _buttons->resetImages(); + _buttons->deactivate(); + + _shapes->unload(); + + if (_mainVqaPlayer) { + _mainVqaPlayer->close(); + delete _mainVqaPlayer; + _mainVqaPlayer = nullptr; + } + + if (_playerVqaPlayer) { + _playerVqaPlayer->close(); + delete _playerVqaPlayer; + _playerVqaPlayer = nullptr; + } + + _vm->closeArchive("MODE.MIX"); + + _currentSectionId = 0; + + // TODO: Unfreeze game time + + //if (!_vm->_settings->isLoadingGame(&Settings) && GameRunning) + // if (_vm->_gameIsRunning) { + // _vm->_scene->resume(false); + // } +} + +void KIA::createButtons(int sectionId) { + Common::Rect kiaButton6( 66, 00, 122, 44); + Common::Rect kiaButton7( 191, 29, 233, 70); + Common::Rect kiaButton8( 234, 29, 278, 70); + Common::Rect kiaButton9( 278, 29, 321, 70); + Common::Rect kiaButton10(322, 29, 365, 70); + Common::Rect kiaButton11(366, 29, 410, 70); + Common::Rect kiaButton12(420, 286, 472, 328); + Common::Rect kiaButton13(334, 286, 386, 328); + Common::Rect kiaButton14(411, 29, 453, 70); + Common::Rect kiaButton15(264, 9, 304, 26); + Common::Rect kiaButton16(140, 406, 160, 479); + Common::Rect kiaButton17(161, 406, 180, 479); + Common::Rect kiaButton18(181, 406, 202, 479); + Common::Rect kiaButton19(575, 307, 606, 350); + Common::Rect kiaButton21(211, 443, 291, 479); + + const Shape *shapeUp = nullptr; + const Shape *shapeHovered = nullptr; + const Shape *shapeDown = nullptr; + + switch (sectionId) { + case kKIASectionCrimes: + case kKIASectionSuspects: + case kKIASectionClues: + _buttons->defineImage(0, kiaButton6, nullptr, nullptr, _shapes->get(1), _vm->_textKIA->getText(23)); + + if (sectionId == kKIASectionCrimes) { + shapeUp = _shapes->get(2); + shapeHovered = _shapes->get(2); + shapeDown = _shapes->get(10); + } else { + shapeUp = nullptr; + shapeHovered = nullptr; + shapeDown = _shapes->get(18); + } + _buttons->defineImage(1, kiaButton7, shapeUp, shapeHovered, shapeDown, _vm->_textKIA->getText(24)); + + if (sectionId == kKIASectionSuspects) { + shapeUp = _shapes->get(3); + shapeHovered = _shapes->get(3); + shapeDown = _shapes->get(11); + } else { + shapeUp = nullptr; + shapeHovered = nullptr; + shapeDown = _shapes->get(19); + } + _buttons->defineImage(2, kiaButton8, shapeUp, shapeHovered, shapeDown, _vm->_textKIA->getText(25)); + + if (sectionId == kKIASectionClues) { + shapeUp = _shapes->get(4); + shapeHovered = _shapes->get(4); + shapeDown = _shapes->get(12); + } else { + shapeUp = nullptr; + shapeHovered = nullptr; + shapeDown = _shapes->get(20); + } + _buttons->defineImage(3, kiaButton9, shapeUp, shapeHovered, shapeDown, _vm->_textKIA->getText(26)); + + _buttons->defineImage(4, kiaButton10, nullptr, nullptr, _shapes->get(21), _vm->_textKIA->getText(27)); + + _buttons->defineImage(5, kiaButton11, nullptr, nullptr, _shapes->get(22), _vm->_textKIA->getText(28)); + + _buttons->defineImage(14, kiaButton14, nullptr, nullptr, _shapes->get(23), _vm->_textKIA->getText(29)); + + break; + case kKIASectionSettings: + case kKIASectionHelp: + case kKIASectionSave: + case kKIASectionLoad: + case kKIASectionDiagnostic: + case kKIASectionPogo: + _buttons->defineImage(6, kiaButton6, nullptr, nullptr, _shapes->get(0), _vm->_textKIA->getText(37)); + + if (sectionId == kKIASectionSettings) { + shapeUp = _shapes->get(5); + shapeHovered = _shapes->get(5); + shapeDown = _shapes->get(13); + } else { + shapeUp = nullptr; + shapeHovered = nullptr; + shapeDown = _shapes->get(24); + } + _buttons->defineImage(7, kiaButton7, shapeUp, shapeHovered, shapeDown, _vm->_textKIA->getText(38)); + + if (sectionId == kKIASectionHelp) { + shapeUp = _shapes->get(6); + shapeHovered = _shapes->get(6); + shapeDown = _shapes->get(14); + } else { + shapeUp = nullptr; + shapeHovered = nullptr; + shapeDown = _shapes->get(25); + } + _buttons->defineImage(8, kiaButton8, shapeUp, shapeHovered, shapeDown, _vm->_textKIA->getText(41)); + + if (sectionId == kKIASectionSave) { + shapeUp = _shapes->get(7); + shapeHovered = _shapes->get(7); + shapeDown = _shapes->get(15); + } else { + shapeUp = nullptr; + shapeHovered = nullptr; + shapeDown = _shapes->get(26); + } + _buttons->defineImage(9, kiaButton9, shapeUp, shapeHovered, shapeDown, _vm->_textKIA->getText(39)); + + if (sectionId == kKIASectionLoad) { + shapeUp = _shapes->get(8); + shapeHovered = _shapes->get(8); + shapeDown = _shapes->get(16); + } else { + shapeUp = nullptr; + shapeHovered = nullptr; + shapeDown = _shapes->get(27); + } + _buttons->defineImage(10, kiaButton10, shapeUp, shapeHovered, shapeDown, _vm->_textKIA->getText(40)); + + _buttons->defineImage(11, kiaButton11, nullptr, nullptr, _shapes->get(28), _vm->_textKIA->getText(42)); + + _buttons->defineImage(14, kiaButton14, nullptr, nullptr, _shapes->get(29), _vm->_textKIA->getText(29)); + + break; + case 8: + _buttons->defineImage(12, kiaButton12, _shapes->get(124), _shapes->get(124), _shapes->get(48), _vm->_textKIA->getText(42)); + + _buttons->defineImage(13, kiaButton13, _shapes->get(125), _shapes->get(125), _shapes->get(49), _vm->_textKIA->getText(29)); + break; + } + + if (sectionId != kKIASectionQuit) { + _buttons->defineImage(15, kiaButton15, nullptr, nullptr, _shapes->get(38), _vm->_textKIA->getText(43)); + + _buttons->defineImage(19, kiaButton19, nullptr, nullptr, nullptr, _vm->_textKIA->getText(44)); + + if (_vm->_settings->getAmmoAmount(0) > 0) { + _buttons->defineImage(16, kiaButton16, nullptr, nullptr, nullptr, _vm->_textKIA->getText(50)); + } + Common::String tooltip; + if (_vm->_settings->getAmmoAmount(1) > 0) { + if (_vm->_settings->getDifficulty() > 0) { + tooltip = Common::String::format("%d", _vm->_settings->getAmmoAmount(1)); + } else { + tooltip = _vm->_textKIA->getText(50); + } + _buttons->defineImage(17, kiaButton17, nullptr, nullptr, nullptr, tooltip.c_str()); + } + if (_vm->_settings->getAmmoAmount(2) > 0) { + if (_vm->_settings->getDifficulty() > 0) { + tooltip = Common::String::format("%d", _vm->_settings->getAmmoAmount(2)); + } else { + tooltip = _vm->_textKIA->getText(50); + } + _buttons->defineImage(18, kiaButton18, nullptr, nullptr, nullptr, tooltip.c_str()); + } + if (_vm->_gameFlags->query(kFlagKIAPrivacyAddon)) { + _buttons->defineImage(21, kiaButton21, nullptr, nullptr, nullptr, nullptr); + } + } +} + +void KIA::buttonClicked(int buttonId) { + int soundId = 0; + + if (!_currentSectionId) { + return; + } + switch (buttonId) { + case 0: + open(kKIASectionSettings); + break; + case 1: + if (_currentSectionId != kKIASectionCrimes) { + open(kKIASectionCrimes); + _log->next(); + _log->clearFuture(); + } + break; + case 2: + if (_currentSectionId != kKIASectionSuspects) { + open(kKIASectionSuspects); + _log->next(); + _log->clearFuture(); + } + break; + case 3: + if (_currentSectionId != kKIASectionClues) { + open(kKIASectionClues); + _log->next(); + _log->clearFuture(); + } + break; + case 4: + if (_log->hasPrev()) { + int kiaLogPrevType = _log->getPrevType(); + switch (kiaLogPrevType) { + case 2: + open(kKIASectionCrimes); + _log->prev(); + _crimesSection->loadFromLog(); + break; + case 1: + open(kKIASectionSuspects); + _log->prev(); + _suspectsSection->loadFromLog(); + break; + case 0: + open(kKIASectionClues); + _log->prev(); + _cluesSection->loadFromLog(); + break; + } + } + break; + case 5: + if (_log->hasNext()) { + int kiaLogNextType = _log->getNextType(); + switch (kiaLogNextType) { + case 2: + open(kKIASectionCrimes); + _log->next(); + _crimesSection->loadFromLog(); + break; + case 1: + open(kKIASectionSuspects); + _log->next(); + _suspectsSection->loadFromLog(); + break; + case 0: + open(kKIASectionClues); + _log->next(); + _cluesSection->loadFromLog(); + break; + } + } + break; + case 6: + if (!_forceOpen) { + open(_lastSectionIdKIA); + } + break; + case 7: + open(kKIASectionSettings); + break; + case 8: + open(kKIASectionHelp); + break; + case 9: + if (!_forceOpen) { + open(kKIASectionSave); + } + break; + case 10: + open(kKIASectionLoad); + break; + case 11: + open(kKIASectionQuit); + break; + case 12: + _vm->_gameIsRunning = false; + open(kKIASectionNone); + break; + case 13: + open(_lastSectionIdOptions); + break; + case 14: + if (!_forceOpen) { + open(kKIASectionNone); + } + break; + case 15: + open(kKIASectionDiagnostic); + break; + case 16: + _vm->_settings->setAmmoType(0); + if (_vm->_rnd.getRandomNumber(1)) { + soundId = _vm->_combat->getHitSound(); + } else { + soundId = _vm->_combat->getMissSound(); + } + _vm->_audioPlayer->playAud(_vm->_gameInfo->getSfxTrack(soundId), 70, 0, 0, 50, 0); + break; + case 17: + _vm->_settings->setAmmoType(1); + if (_vm->_rnd.getRandomNumber(1)) { + soundId = _vm->_combat->getHitSound(); + } else { + soundId = _vm->_combat->getMissSound(); + } + _vm->_audioPlayer->playAud(_vm->_gameInfo->getSfxTrack(soundId), 70, 0, 0, 50, 0); + break; + case 18: + _vm->_settings->setAmmoType(2); + if (_vm->_rnd.getRandomNumber(1)) { + soundId = _vm->_combat->getHitSound(); + } else { + soundId = _vm->_combat->getMissSound(); + } + _vm->_audioPlayer->playAud(_vm->_gameInfo->getSfxTrack(soundId), 70, 0, 0, 50, 0); + break; + case 19: + return; + case 20: + playerReset(); + break; + case 21: + playPrivateAddon(); + break; + } +} + +void KIA::switchSection(int sectionId) { + if (_currentSection) { + _currentSection->close(); + } + switch (sectionId) { + case kKIASectionCrimes: + _currentSection = _crimesSection; + break; + case kKIASectionSuspects: + _currentSection = _suspectsSection; + break; + case kKIASectionClues: + _currentSection = _cluesSection; + break; + case kKIASectionSettings: + _currentSection = _settingsSection; + break; + case kKIASectionHelp: + _currentSection = _helpSection; + break; + case kKIASectionSave: + _currentSection = _saveSection; + break; + case kKIASectionLoad: + _currentSection = _loadSection; + break; + case kKIASectionQuit: + _currentSection = nullptr; + break; + case kKIASectionDiagnostic: + _currentSection = _diagnosticSection; + break; + case kKIASectionPogo: + _currentSection = _pogoSection; + break; + default: + _currentSection = nullptr; + break; + } + if (_currentSection) { + _currentSection->open(); + } +} + +const char *KIA::getSectionVqaName(int sectionId) { + switch (sectionId) { + case kKIASectionCrimes: + return "kia_crim.vqa"; + case kKIASectionSuspects: + return "kia_susp.vqa"; + case kKIASectionClues: + return "kia_clue.vqa"; + case kKIASectionSettings: + case kKIASectionHelp: + case kKIASectionSave: + case kKIASectionLoad: + case kKIASectionQuit: + case kKIASectionDiagnostic: + case kKIASectionPogo: + return "kia_ingm.vqa"; + default: + return nullptr; + } +} + +int KIA::getVqaLoopMain(int sectionId) { + switch (sectionId) { + case kKIASectionCrimes: + case kKIASectionSuspects: + case kKIASectionClues: + return 3; + case kKIASectionSettings: + case kKIASectionHelp: + case kKIASectionSave: + case kKIASectionLoad: + case kKIASectionDiagnostic: + case kKIASectionPogo: + return 4; + case kKIASectionQuit: + return 7; + default: + return 0; + } +} + +int KIA::getVqaLoopTransition(int transitionId) { + switch (transitionId) { + case 0: + case 2: + case 7: + case 8: + return 0; + case 1: + case 4: + case 5: + case 9: + return 1; + case 3: + case 10: + case 11: + case 12: + return 2; + case 6: + return 3; + case 13: + return 6; + default: + return 0; + } +} + +int KIA::getTransitionId(int oldSectionId, int newSectionId) { + switch (oldSectionId) { + case kKIASectionNone: + return 0; + case kKIASectionCrimes: + switch (newSectionId) { + case kKIASectionCrimes: + return 0; + case kKIASectionSuspects: + return 1; + case kKIASectionClues: + return 2; + case kKIASectionSettings: + case kKIASectionHelp: + case kKIASectionSave: + case kKIASectionLoad: + case kKIASectionDiagnostic: + case kKIASectionPogo: + return 3; + case kKIASectionQuit: + return 13; + } + return 0; + case kKIASectionSuspects: + switch (newSectionId) { + case kKIASectionCrimes: + return 4; + case kKIASectionSuspects: + return 0; + case kKIASectionClues: + return 5; + case kKIASectionSettings: + case kKIASectionHelp: + case kKIASectionSave: + case kKIASectionLoad: + case kKIASectionDiagnostic: + case kKIASectionPogo: + return 6; + case kKIASectionQuit: + return 13; + } + return 0; + case kKIASectionClues: + switch (newSectionId) { + case kKIASectionCrimes: + return 7; + case kKIASectionSuspects: + return 8; + case kKIASectionClues: + return 0; + case kKIASectionSettings: + case kKIASectionHelp: + case kKIASectionSave: + case kKIASectionLoad: + case kKIASectionDiagnostic: + case kKIASectionPogo: + return 9; + case kKIASectionQuit: + return 13; + } + return 0; + case kKIASectionSettings: + case kKIASectionHelp: + case kKIASectionSave: + case kKIASectionLoad: + case kKIASectionDiagnostic: + case kKIASectionPogo: + switch (newSectionId) { + case kKIASectionCrimes: + return 10; + case kKIASectionSuspects: + return 11; + case kKIASectionClues: + return 12; + case kKIASectionSettings: + case kKIASectionHelp: + case kKIASectionSave: + case kKIASectionLoad: + case kKIASectionDiagnostic: + case kKIASectionPogo: + return 0; + case kKIASectionQuit: + return 13; + } + return 0; + case kKIASectionQuit: + if (newSectionId != kKIASectionQuit) { + return 14; + } + } + return 0; +} + +void KIA::playTransitionSound(int transitionId) { + switch (transitionId) { + case 1: + case 2: + case 3: + case 4: + case 5: + case 6: + case 7: + case 8: + case 9: + case 10: + case 11: + case 12: + _vm->_audioPlayer->playAud(_vm->_gameInfo->getSfxTrack(498), 100, 0, 0, 50, 0); + break; + case 13: + _vm->_audioPlayer->playAud(_vm->_gameInfo->getSfxTrack(499), 100, 0, 0, 50, 0); + break; + case 14: + _vm->_audioPlayer->playAud(_vm->_gameInfo->getSfxTrack(500), 100, 0, 0, 50, 0); + break; + } +} + +void KIA::playPrivateAddon() { + playerReset(); + playSliceModel(524); + playActorDialogue(14, 2060); + playActorDialogue(14, 2070); +} + +} // End of namespace BladeRunner diff --git a/engines/bladerunner/ui/kia.h b/engines/bladerunner/ui/kia.h new file mode 100644 index 0000000000..c979f9ff8b --- /dev/null +++ b/engines/bladerunner/ui/kia.h @@ -0,0 +1,155 @@ +/* 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 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 BLADERUNNER_KIA_H +#define BLADERUNNER_KIA_H + +#include "common/str.h" + + +namespace Common { +struct KeyState; +} + +namespace Graphics { +struct Surface; +} + +namespace BladeRunner { + +class BladeRunnerEngine; +class KIALog; +class KIAScript; +class KIASectionBase; +class KIASectionClues; +class KIASectionDiagnostic; +class KIASectionCrimes; +class KIASectionHelp; +class KIASectionLoad; +class KIASectionSettings; +class KIASectionPogo; +class KIASectionSave; +class KIASectionSuspects; +class KIAShapes; +class Shape; +class UIImagePicker; +class VQAPlayer; + +class KIA { + static const char *kPogo; + + struct ActorDialogueQueueEntry { + int actorId; + int sentenceId; + }; + + BladeRunnerEngine *_vm; + + int _forceOpen; + int _transitionId; + + int _lastSectionIdKIA; + int _lastSectionIdOptions; + + int _playerVqaTimeLast; + VQAPlayer *_playerVqaPlayer; + int _playerVqaFrame; + int _playerVisualizerState; + int _playerPhotographId; + Shape *_playerPhotograph; + int _playerSliceModelId; + float _playerSliceModelAngle; + int _timeLast; + + ActorDialogueQueueEntry *_playerActorDialogueQueue; + int _playerActorDialogueQueueCapacity; + int _playerActorDialogueQueuePosition; + int _playerActorDialogueQueueSize; + int _playerActorDialogueState; + + KIASectionBase *_currentSection; + KIASectionClues *_cluesSection; + KIASectionCrimes *_crimesSection; + KIASectionDiagnostic *_diagnosticSection; + KIASectionHelp *_helpSection; + KIASectionLoad *_loadSection; + KIASectionSettings *_settingsSection; + KIASectionPogo *_pogoSection; + KIASectionSave *_saveSection; + KIASectionSuspects *_suspectsSection; + + UIImagePicker *_buttons; + + VQAPlayer *_mainVqaPlayer; + + int _pogoPos; + +public: + int _currentSectionId; + KIALog *_log; + KIAScript *_script; + KIAShapes *_shapes; + +public: + KIA(BladeRunnerEngine *vm); + ~KIA(); + + void openLastOpened(); + void openOptions(); + + void tick(); + + void handleMouseDown(int mouseX, int mouseY, bool mainButton); + void handleMouseUp(int mouseX, int mouseY, bool mainButton); + void handleKeyUp(const Common::KeyState &kbd); + void handleKeyDown(const Common::KeyState &kbd); + + void playerReset(); + void playActorDialogue(int actorId, int sentenceId); + void playSliceModel(int sliceModelId); + void playPhotograph(int photographId); + +private: + static void mouseDownCallback(int buttonId, void *callbackData); + static void mouseUpCallback(int buttonId, void *callbackData); + static void loopEnded(void *callbackData, int frame, int loopId); + + void open(int sectionId); + void init(); + void unload(); + void switchSection(int sectionId); + + void createButtons(int sectionId); + void buttonClicked(int buttonId); + + const char *getSectionVqaName(int sectionId); + int getVqaLoopMain(int sectionId); + int getVqaLoopTransition(int transitionId); + + int getTransitionId(int oldSectionId, int newSectionId); + void playTransitionSound(int transitionId); + + void playPrivateAddon(); +}; + +} // End of namespace BladeRunner +#endif diff --git a/engines/bladerunner/ui/kia_log.cpp b/engines/bladerunner/ui/kia_log.cpp new file mode 100644 index 0000000000..51b922a8f7 --- /dev/null +++ b/engines/bladerunner/ui/kia_log.cpp @@ -0,0 +1,128 @@ +/* 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 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 "bladerunner/ui/kia_log.h" + +#include "bladerunner/bladerunner.h" + +namespace BladeRunner { + +KIALog::KIALog(BladeRunnerEngine *vm) { + _vm = vm; + + _firstIndex = 0; + _lastIndex = 0; + _currentIndex = 0; + for (int i = 0; i < kSize; ++i) { + _entries[i].dataSize = 0; + _entries[i].data = nullptr; + } +} + +KIALog::~KIALog() { + clear(); +} + +void KIALog::add(int type, int dataSize, const void *data) { + if (_currentIndex == _lastIndex) { + _lastIndex = (_lastIndex + 1) % kSize; + } + + if (_entries[_currentIndex].data) { + delete[] _entries[_currentIndex].data; + } + + _entries[_currentIndex].type = type; + _entries[_currentIndex].dataSize = dataSize; + + if (dataSize > 0) { + char *dataCopy = new char[dataSize]; + memcpy(dataCopy, data, dataSize); + _entries[_currentIndex].data = dataCopy; + } else { + _entries[_currentIndex].data = nullptr; + } +} + +void KIALog::clear() { + _firstIndex = 0; + _lastIndex = 0; + _currentIndex = 0; + for (int i = 0; i < kSize; ++i) { + if (_entries[i].data) { + delete[] _entries[i].data; + } + _entries[i].dataSize = 0; + _entries[i].data = nullptr; + } +} + +void KIALog::prev() { + if (_currentIndex != _firstIndex) { + _currentIndex = (_currentIndex - 1) % kSize; + } +} + +void KIALog::next() { + if (_currentIndex != _lastIndex) { + _currentIndex = (_currentIndex + 1) % kSize; + } +} + +void KIALog::clearFuture() { + _lastIndex = _currentIndex; + int currentIndex = _currentIndex; + while (currentIndex != _firstIndex) { + if (_entries[currentIndex].data) { + delete[] _entries[currentIndex].data; + _entries[currentIndex].data = 0; + _entries[currentIndex].dataSize = 0; + } + currentIndex = (currentIndex + 1) % kSize; + } +} + +bool KIALog::hasPrev() const { + return _currentIndex != _firstIndex; +} + +bool KIALog::hasNext() const { + if (_currentIndex == _lastIndex) { + return false; + } + + return (((_currentIndex + 1) % kSize) != _lastIndex); +} + +int KIALog::getPrevType() const { + return _entries[(_currentIndex - 1) % kSize].type; +} + +int KIALog::getNextType() const { + return _entries[(_currentIndex + 1) % kSize].type; +} + +const void *KIALog::getCurrentData() const { + return _entries[_currentIndex].data; +} + +} // End of namespace BladeRunner diff --git a/engines/bladerunner/ui/kia_log.h b/engines/bladerunner/ui/kia_log.h new file mode 100644 index 0000000000..4a89492817 --- /dev/null +++ b/engines/bladerunner/ui/kia_log.h @@ -0,0 +1,65 @@ +/* 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 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 BLADERUNNER_KIA_LOG_H +#define BLADERUNNER_KIA_LOG_H + +namespace BladeRunner { + +class BladeRunnerEngine; + +class KIALog { + static const int kSize = 16; + + struct Entry { + int type; + int dataSize; + const char *data; + }; + + BladeRunnerEngine *_vm; + + Entry _entries[kSize]; + int _firstIndex; + int _lastIndex; + int _currentIndex; + +public: + KIALog(BladeRunnerEngine *vm); + ~KIALog(); + + void add(int type, int dataSize, const void *data); + void clear(); + + void prev(); + void next(); + void clearFuture(); + bool hasPrev() const; + bool hasNext() const; + int getPrevType() const; + int getNextType() const; + const void *getCurrentData() const; +}; + +} // End of namespace BladeRunner + +#endif diff --git a/engines/bladerunner/ui/kia_section_base.cpp b/engines/bladerunner/ui/kia_section_base.cpp new file mode 100644 index 0000000000..96571e5a48 --- /dev/null +++ b/engines/bladerunner/ui/kia_section_base.cpp @@ -0,0 +1,35 @@ +/* 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 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 "bladerunner/ui/kia_section_base.h" + +namespace BladeRunner { + +KIASectionBase::KIASectionBase(BladeRunnerEngine *vm) { + _vm = vm; + _field0 = false; +} + +KIASectionBase::~KIASectionBase() { +} + +} // End of namespace BladeRunner diff --git a/engines/bladerunner/ui/kia_section_base.h b/engines/bladerunner/ui/kia_section_base.h new file mode 100644 index 0000000000..176e30d4b7 --- /dev/null +++ b/engines/bladerunner/ui/kia_section_base.h @@ -0,0 +1,67 @@ +/* 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 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 BLADERUNNER_KIA_SECTION_BASE_H +#define BLADERUNNER_KIA_SECTION_BASE_H + + +namespace Common { +struct KeyState; +} + +namespace Graphics { +struct Surface; +} + +namespace BladeRunner { + +class BladeRunnerEngine; + +class KIASectionBase { +protected: + BladeRunnerEngine *_vm; + +public: + bool _field0; + + KIASectionBase(BladeRunnerEngine *vm); + virtual ~KIASectionBase(); + + virtual void open() {} + virtual void close() {} + + virtual void draw(Graphics::Surface &surface) {} + + virtual void handleKeyUp(const Common::KeyState &kbd) {} + virtual void handleKeyDown(const Common::KeyState &kbd) {} + virtual void handleMouseMove(int mouseX, int mouseY) {} + virtual void handleMouseDown(bool mainButton) {} + virtual void handleMouseUp(bool mainButton) {} + +protected: + virtual void onButtonPressed(int buttonId) {} + +}; + +} // End of namespace BladeRunner + +#endif diff --git a/engines/bladerunner/ui/kia_section_clues.cpp b/engines/bladerunner/ui/kia_section_clues.cpp new file mode 100644 index 0000000000..1e80b57ed7 --- /dev/null +++ b/engines/bladerunner/ui/kia_section_clues.cpp @@ -0,0 +1,422 @@ +/* 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 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 "bladerunner/ui/kia_section_clues.h" + +#include "bladerunner/actor_clues.h" +#include "bladerunner/audio_player.h" +#include "bladerunner/bladerunner.h" +#include "bladerunner/crimes_database.h" +#include "bladerunner/game_constants.h" +#include "bladerunner/game_flags.h" +#include "bladerunner/game_info.h" +#include "bladerunner/font.h" +#include "bladerunner/script/kia.h" +#include "bladerunner/text_resource.h" +#include "bladerunner/ui/kia.h" +#include "bladerunner/ui/kia_log.h" +#include "bladerunner/ui/kia_shapes.h" +#include "bladerunner/ui/ui_container.h" +#include "bladerunner/ui/ui_image_picker.h" +#include "bladerunner/ui/ui_scroll_box.h" + +#include "common/rect.h" + +namespace BladeRunner { + +KIASectionClues::KIASectionClues(BladeRunnerEngine *vm, ActorClues *clues) : KIASectionBase(vm) { + _uiContainer = new UIContainer(_vm); + + _isVisible = false; + + _debugIntangible = false; + _debugNop = 0; + + _clues = clues; + + _mouseX = 0; + _mouseY = 0; + + _buttons = new UIImagePicker(_vm, 2); + + _cluesScrollBox = new UIScrollBox(_vm, scrollBoxCallback, this, _vm->_gameInfo->getClueCount(), 1, false, Common::Rect(312, 172, 500, 376), Common::Rect(506, 160, 506, 394)); + _uiContainer->add(_cluesScrollBox); + + _filterScrollBox = new UIScrollBox(_vm, scrollBoxCallback, this, 128, 1, false, Common::Rect(142, 162, 291, 376), Common::Rect(120, 160, 120, 370)); + _uiContainer->add(_filterScrollBox); + + _assetTypeFilterCount = 4 + 1; // we have 4 asset types + _crimeFilterCount = _vm->_gameInfo->getCrimeCount() + 1; + _filterCount = _assetTypeFilterCount + _crimeFilterCount; + _filters.resize(_filterCount); + for (int i = 0; i < _filterCount; ++i) { + _filters[i] = true; + } +} + +KIASectionClues::~KIASectionClues() { + _uiContainer->clear(); + delete _filterScrollBox; + delete _cluesScrollBox; + delete _uiContainer; +} + +void KIASectionClues::open() { + _isVisible = true; + + _buttons->resetImages(); + _buttons->defineImage(0, Common::Rect(142, 380, 191, 395), _vm->_kia->_shapes->get(79), _vm->_kia->_shapes->get(80), _vm->_kia->_shapes->get(81), _vm->_textKIA->getText(30)); + _buttons->defineImage(1, Common::Rect(193, 380, 242, 395), _vm->_kia->_shapes->get(76), _vm->_kia->_shapes->get(77), _vm->_kia->_shapes->get(78), _vm->_textKIA->getText(31)); + + _buttons->activate(nullptr, nullptr, nullptr, mouseUpCallback, this); + _cluesScrollBox->show(); + _filterScrollBox->show(); + + populateFilters(); + populateClues(); +} + +void KIASectionClues::close() { + if (_isVisible) { + _isVisible = false; + + _buttons->deactivate(); + _cluesScrollBox->hide(); + _filterScrollBox->hide(); + } +} + +void KIASectionClues::draw(Graphics::Surface &surface) { + _uiContainer->draw(surface); + + _vm->_mainFont->drawColor(_vm->_textKIA->getText(0), surface, 300, 162, 0x77DF); + _vm->_mainFont->drawColor(_vm->_textKIA->getText(2), surface, 440, 426, 0x2991); + _vm->_mainFont->drawColor(_vm->_textKIA->getText(1), surface, 440, 442, 0x2991); + _vm->_mainFont->drawColor(_vm->_textKIA->getText(4), surface, 440, 458, 0x2991); + + int clueId = _cluesScrollBox->getSelectedLineData(); + if (clueId != -1) { + Common::String text; + + int actorId = _clues->getFromActorId(clueId); + if (actorId != -1) { + text = _vm->_textActorNames->getText(actorId); + } else { + text.clear(); + } + _vm->_mainFont->drawColor(text, surface, 490, 426, 0x46BF); + + int crimeId = _vm->_crimesDatabase->getCrime(clueId); + if (crimeId != -1) { + text = _vm->_textCrimes->getText(crimeId); + } else { + text.clear(); + } + _vm->_mainFont->drawColor(text, surface, 490, 442, 0x46BF); + + int assetType = _vm->_crimesDatabase->getAssetType(clueId); + if (assetType != -1) { + text = _vm->_textClueTypes->getText(assetType); + } else { + text.clear(); + } + _vm->_mainFont->drawColor(text, surface, 490, 458, 0x46BF); + } + + _buttons->draw(surface); + _buttons->drawTooltip(surface, _mouseX, _mouseY); + + if (_debugNop) { + _vm->_mainFont->drawColor(Common::String::format("Debug display: %s", _vm->_textActorNames->getText(_debugNop)), surface, 120, 132, 0x7FE0); + } + if (_debugIntangible) { + _vm->_mainFont->drawColor("Debug Mode: Showing intangible clues.", surface, 220, 105, 0x7FE0); + } +} + +void KIASectionClues::handleMouseMove(int mouseX, int mouseY) { + _mouseX = mouseX; + _mouseY = mouseY; + _buttons->handleMouseAction(mouseX, mouseY, false, false, false); + _uiContainer->handleMouseMove(mouseX, mouseY); +} + +void KIASectionClues::handleMouseDown(bool mainButton) { + _uiContainer->handleMouseDown(!mainButton); + if (mainButton) { + _buttons->handleMouseAction(_mouseX, _mouseY, true, false, false); + } +} + +void KIASectionClues::handleMouseUp(bool mainButton) { + _uiContainer->handleMouseUp(!mainButton); + if (mainButton) { + _buttons->handleMouseAction(_mouseX, _mouseY, false, true, false); + } +} + +void KIASectionClues::saveToLog() { + _vm->_kia->_log->add(0, sizeof(bool) * _filterCount, _filters.data()); +} + +void KIASectionClues::loadFromLog() { + memcpy(_filters.data(), _vm->_kia->_log->getCurrentData(), sizeof(bool) * _filterCount); + populateFilters(); + populateClues(); +} + +void KIASectionClues::scrollBoxCallback(void *callbackData, void *source, int lineData, int mouseButton) { + KIASectionClues *self = (KIASectionClues *)callbackData; + + if (source == self->_filterScrollBox && lineData >= 0) { + self->_filters[lineData] = !self->_filters[lineData]; + self->_filterScrollBox->toggleCheckBox(lineData); + self->populateClues(); + } else if (source == self->_cluesScrollBox && lineData >= 0) { + if (mouseButton) { + if (self->_vm->_gameFlags->query(kFlagKIAPrivacyAddon)) { + self->_vm->_audioPlayer->playAud(self->_vm->_gameInfo->getSfxTrack(511), 70, 0, 0, 50, 0); + + if (self->_clues->isPrivate(lineData)) { + self->_clues->setPrivate(lineData, false); + self->_cluesScrollBox->resetFlags(lineData, 0x08); + } else { + self->_clues->setPrivate(lineData, true); + self->_cluesScrollBox->setFlags(lineData, 0x08); + } + } + } else { + self->_clues->setViewed(lineData, true); + self->_cluesScrollBox->resetHighlight(lineData); + self->_vm->_kia->_script->playClueAssetScript(0, lineData); + } + } +} + +void KIASectionClues::mouseUpCallback(int buttonId, void *callbackData) { + KIASectionClues *self = (KIASectionClues *)callbackData; + + if (buttonId <= 1) { + self->_vm->_audioPlayer->playAud(self->_vm->_gameInfo->getSfxTrack(510), 100, 0, 0, 50, 0); + } + + self->onButtonPressed(buttonId); +} + +void KIASectionClues::onButtonPressed(int buttonId) { + if (buttonId == 1) { + disableAllFilters(); + } + if (buttonId == 0) { + enableAllFilters(); + } +} + +void KIASectionClues::enableAllFilters() { + for (int i = 0; i < _filterCount; ++i) { + if (_filterScrollBox->hasLine(i)) { + _filters[i] = true; + } + } + _filterScrollBox->checkAll(); + populateClues(); +} + +void KIASectionClues::disableAllFilters() { + for (int i = 0; i < _filterCount; ++i) { + if (_filterScrollBox->hasLine(i)) { + _filters[i] = false; + } + } + _filterScrollBox->uncheckAll(); + populateClues(); +} + +void KIASectionClues::populateFilters() { + _filterScrollBox->clearLines(); + + Common::Array<bool> availableFilters(_filterCount); + for (int i = 0; i < _filterCount; ++i) { + availableFilters[i] = false; + } + + Common::String assetTypeNames[] = { + _vm->_textKIA->getText(6), + _vm->_textKIA->getText(7), + _vm->_textKIA->getText(8), + _vm->_textKIA->getText(9) + }; + + for (int i = 0; i < kClueCount; ++i) { + if (_clues->isAcquired(i)) { + int assetType = _vm->_crimesDatabase->getAssetType(i); + int crimeId = _vm->_crimesDatabase->getCrime(i); + if (_debugIntangible || assetType != -1) { + availableFilters[getLineIdForAssetType(assetType)] = true; + availableFilters[getLineIdForCrimeId(crimeId)] = true; + } + } + } + + int assetTypeFiltersAvailable = 0; + for (int i = 0; i < _assetTypeFilterCount; ++i) { + if (availableFilters[i]) { + ++assetTypeFiltersAvailable; + } + } + + int crimeFiltersAvailable = 0; + for (int i = _assetTypeFilterCount; i < _filterCount; ++i) { + if (availableFilters[i]) { + ++crimeFiltersAvailable; + } + } + + if (assetTypeFiltersAvailable > 1) { + _filterScrollBox->addLine(_vm->_textKIA->getText(11), -1, 0x04); + + for (int i = 0; i < _assetTypeFilterCount; ++i) { + if (availableFilters[i]) { + int flags = 0x01; + if (_filters[i]) { + flags |= 0x02; + } + + Common::String text; + int typeTextId = getClueFilterTypeTextId(i); + if (typeTextId == -1) { + text = _vm->_textKIA->getText(10); + } else { + text = assetTypeNames[typeTextId]; + } + + _filterScrollBox->addLine(text, i, flags); + } + } + } + + if (crimeFiltersAvailable > 1) { + if (assetTypeFiltersAvailable > 1) { + _filterScrollBox->addLine(" ", -1, 0); + } + + _filterScrollBox->addLine(_vm->_textKIA->getText(12), -1, 0x04); + + struct Line { + Common::String crimeName; + int lineData; + int flags; + }; + + Common::Array<Line> crimeLines; + crimeLines.reserve(crimeFiltersAvailable); + + for (int i = _assetTypeFilterCount; i < _filterCount; ++i) { + if (availableFilters[i]) { + Line line; + + line.lineData = i; + + line.flags = 0x01; + if (_filters[i]) { + line.flags |= 0x02; + } + + int crimeId = getClueFilterCrimeId(i); + if (crimeId == -1) { + line.crimeName = _vm->_textKIA->getText(5); + } else { + line.crimeName = _vm->_textCrimes->getText(crimeId); + } + + crimeLines.push_back(line); + } + } + + for (int i = 0; i < crimeFiltersAvailable - 1; ++i) { + for (int j = i + 1; j < crimeFiltersAvailable; ++j) { + if (crimeLines[i].lineData != _assetTypeFilterCount) { + if (crimeLines[i].crimeName.compareToIgnoreCase(crimeLines[j].crimeName) <= 0) { + continue; + } + } + SWAP(crimeLines[i], crimeLines[j]); + } + } + + for (uint i = 0; i < crimeLines.size(); ++i) { + _filterScrollBox->addLine(crimeLines[i].crimeName, crimeLines[i].lineData, crimeLines[i].flags); + } + } +} + +void KIASectionClues::populateClues() { + _cluesScrollBox->clearLines(); + for (int i = 0; i < kClueCount; ++i) { + if (_clues->isAcquired(i)) { + int assetType = _vm->_crimesDatabase->getAssetType(i); + int crimeId = _vm->_crimesDatabase->getCrime(i); + if (assetType != -1 || _debugIntangible) { + if(_filters[getLineIdForAssetType(assetType)] && _filters[getLineIdForCrimeId(crimeId)]) { + int flags = 0x30; + if (_clues->isPrivate(i)) { + flags = 0x08; + } else if (_clues->isViewed(i)) { + flags = 0x10; + } + _cluesScrollBox->addLine(_vm->_crimesDatabase->getClueText(i), i, flags); + } + } + } + } + _cluesScrollBox->sortLines(); +} + +int KIASectionClues::getClueFilterTypeTextId(int i) { + if (i) { + return i - 1; + } + return -1; +} + +int KIASectionClues::getClueFilterCrimeId(int filterId) { + if (filterId == _assetTypeFilterCount) { + return -1; + } + return filterId - (_assetTypeFilterCount + 1); +} + +int KIASectionClues::getLineIdForAssetType(int assetType) { + if (assetType == -1) { + return 0; + } + return assetType + 1; +} + +int KIASectionClues::getLineIdForCrimeId(int crimeId) { + if (crimeId == -1) { + return _assetTypeFilterCount; + } + return _assetTypeFilterCount + crimeId + 1; +} + +} // End of namespace BladeRunner diff --git a/engines/bladerunner/ui/kia_section_clues.h b/engines/bladerunner/ui/kia_section_clues.h new file mode 100644 index 0000000000..28d9077e6c --- /dev/null +++ b/engines/bladerunner/ui/kia_section_clues.h @@ -0,0 +1,95 @@ +/* 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 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 BLADERUNNER_KIA_SECTION_CLUES_H +#define BLADERUNNER_KIA_SECTION_CLUES_H + +#include "bladerunner/ui/kia_section_base.h" + +#include "common/array.h" +#include "common/str.h" + +namespace BladeRunner { + +class ActorClues; +class UIContainer; +class UIImagePicker; +class UIScrollBox; + +class KIASectionClues : public KIASectionBase { + static const int kClueCount = 288; + + UIContainer *_uiContainer; + UIImagePicker *_buttons; + UIScrollBox *_cluesScrollBox; + UIScrollBox *_filterScrollBox; + + bool _isVisible; + bool _debugIntangible; + int _debugNop; + ActorClues *_clues; + + int _assetTypeFilterCount; + int _crimeFilterCount; + int _filterCount; + Common::Array<bool> _filters; + + int _mouseX; + int _mouseY; + +public: + KIASectionClues(BladeRunnerEngine *vm, ActorClues *clues); + ~KIASectionClues(); + + void open(); + void close(); + + void draw(Graphics::Surface &surface); + + void handleMouseMove(int mouseX, int mouseY); + void handleMouseDown(bool mainButton); + void handleMouseUp(bool mainButton); + + void saveToLog(); + void loadFromLog(); + +private: + static void scrollBoxCallback(void *callbackData, void *source, int lineData, int mouseButton); + static void mouseUpCallback(int buttonId, void *callbackData); + + void onButtonPressed(int buttonId); + + void enableAllFilters(); + void disableAllFilters(); + + void populateFilters(); + void populateClues(); + + int getClueFilterTypeTextId(int); + int getClueFilterCrimeId(int); + int getLineIdForAssetType(int assetType); + int getLineIdForCrimeId(int crimeId); +}; + +} // End of namespace BladeRunner + +#endif diff --git a/engines/bladerunner/ui/kia_section_crimes.cpp b/engines/bladerunner/ui/kia_section_crimes.cpp new file mode 100644 index 0000000000..4cfaaedbad --- /dev/null +++ b/engines/bladerunner/ui/kia_section_crimes.cpp @@ -0,0 +1,37 @@ +/* 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 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 "bladerunner/ui/kia_section_crimes.h" + +#include "bladerunner/bladerunner.h" + +namespace BladeRunner { + +KIASectionCrimes::KIASectionCrimes(BladeRunnerEngine *vm) + : KIASectionBase(vm) + , _shape(vm) { +} + +KIASectionCrimes::~KIASectionCrimes() { +} + +} // End of namespace BladeRunner diff --git a/engines/bladerunner/ui/kia_section_crimes.h b/engines/bladerunner/ui/kia_section_crimes.h new file mode 100644 index 0000000000..befe5e528c --- /dev/null +++ b/engines/bladerunner/ui/kia_section_crimes.h @@ -0,0 +1,82 @@ +/* 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 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 BLADERUNNER_KIA_SECTION_CRIME_H +#define BLADERUNNER_KIA_SECTION_CRIME_H + +#include "bladerunner/shape.h" +#include "bladerunner/ui/kia_section_base.h" + +namespace BladeRunner { + +class ActorClues; +class BladeRunnerEngine; +class UIContainer; +class UIImagePicker; +class UIScrollBox; + +class KIASectionCrimes : public KIASectionBase { + struct Clue + { + int clueId; + int actorId; + }; + +protected: + + UIContainer *_uiContainer; + // void (__cdecl **scrollboxCallback)(int, UIScrollBoxStruc *, int, int); + int _isOpen; + int *_list; + UIImagePicker *_uiImagePicker; + + UIScrollBox *_cluesScrollbox; + ActorClues *_clues; + int _clueInfoCount; + Clue _clueInfo[1000]; + int _selectedCrimeId; + int _crimesFoundCount; + int *_crimeIsKnown; + int _selectedSuspectId; + int _suspectsFoundCount; + int *_suspectIsKnown; + int *_suspectHasIdentity; + int _mouseX; + int _mouseY; + int _suspectPhotoShapeId; + int _field_15; + Shape _shape; + +public: + KIASectionCrimes(BladeRunnerEngine *vm); + ~KIASectionCrimes(); + + void saveToLog() {} + void loadFromLog() {} + +protected: + +}; + +} // End of namespace BladeRunner + +#endif diff --git a/engines/bladerunner/ui/kia_section_diagnostic.h b/engines/bladerunner/ui/kia_section_diagnostic.h new file mode 100644 index 0000000000..9a5b74b8af --- /dev/null +++ b/engines/bladerunner/ui/kia_section_diagnostic.h @@ -0,0 +1,39 @@ +/* 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 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 BLADERUNNER_KIA_SECTION_DIAGNOSTIC_H +#define BLADERUNNER_KIA_SECTION_DIAGNOSTIC_H + +#include "bladerunner/ui/kia_section_base.h" + +namespace BladeRunner { + +class KIASectionDiagnostic : public KIASectionBase { + +public: + KIASectionDiagnostic(BladeRunnerEngine *vm) : KIASectionBase(vm){} + +}; + +} // End of namespace BladeRunner + +#endif diff --git a/engines/bladerunner/ui/kia_section_help.cpp b/engines/bladerunner/ui/kia_section_help.cpp new file mode 100644 index 0000000000..5065382c41 --- /dev/null +++ b/engines/bladerunner/ui/kia_section_help.cpp @@ -0,0 +1,90 @@ +/* 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 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 "bladerunner/ui/kia_section_help.h" + +#include "bladerunner/bladerunner.h" +#include "bladerunner/text_resource.h" +#include "bladerunner/ui/kia.h" +#include "bladerunner/ui/kia_shapes.h" +#include "bladerunner/ui/ui_container.h" +#include "bladerunner/ui/ui_scroll_box.h" + +namespace BladeRunner { + +KIASectionHelp::KIASectionHelp(BladeRunnerEngine *vm) : KIASectionBase(vm) { + _uiContainer = new UIContainer(_vm); + _scrollBox = new UIScrollBox(_vm, nullptr, this, 1024, 0, false, Common::Rect(135, 145, 461, 385), Common::Rect(506, 160, 506, 350)); + + _uiContainer->add(_scrollBox); +} + +KIASectionHelp::~KIASectionHelp() { + _uiContainer->clear(); + delete _scrollBox; + delete _uiContainer; +} + +void KIASectionHelp::open() { + TextResource textResource(_vm); + textResource.open("HELP"); + + _scrollBox->clearLines(); + + for (int i = 0; i < textResource.getCount(); ++i) { + Common::String textLine = textResource.getText(i); + int flags = 0x04; + if (textLine.firstChar() == ' ') { + flags = 0x00; + } + _scrollBox->addLine(textLine, -1, flags); + } + + _scrollBox->show(); +} + +void KIASectionHelp::close() { + _scrollBox->hide(); +} + +void KIASectionHelp::draw(Graphics::Surface &surface){ + _vm->_kia->_shapes->get(69)->draw(surface, 501, 123); + _uiContainer->draw(surface); +} + +void KIASectionHelp::handleKeyUp(const Common::KeyState &kbd) { + _uiContainer->handleKeyUp(kbd); +} + +void KIASectionHelp::handleMouseMove(int mouseX, int mouseY) { + _uiContainer->handleMouseMove(mouseX, mouseY); +} + +void KIASectionHelp::handleMouseDown(bool mainButton) { + _uiContainer->handleMouseDown(!mainButton); +} + +void KIASectionHelp::handleMouseUp(bool mainButton) { + _uiContainer->handleMouseUp(!mainButton); +} + +} // End of namespace BladeRunner diff --git a/engines/bladerunner/ui/kia_section_help.h b/engines/bladerunner/ui/kia_section_help.h new file mode 100644 index 0000000000..0bda5d8851 --- /dev/null +++ b/engines/bladerunner/ui/kia_section_help.h @@ -0,0 +1,54 @@ +/* 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 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 BLADERUNNER_KIA_SECTION_HELP_H +#define BLADERUNNER_KIA_SECTION_HELP_H + +#include "bladerunner/ui/kia_section_base.h" + +namespace BladeRunner { + +class BladeRunnerEngine; +class UIContainer; +class UIScrollBox; + +class KIASectionHelp : public KIASectionBase { + UIContainer *_uiContainer; + UIScrollBox *_scrollBox; + +public: + KIASectionHelp(BladeRunnerEngine *vm); + ~KIASectionHelp(); + + void open(); + void close(); + + void draw(Graphics::Surface &surface); + + void handleKeyUp(const Common::KeyState &kbd); + void handleMouseMove(int mouseX, int mouseY); + void handleMouseDown(bool mainButton); + void handleMouseUp(bool mainButton); +}; + +} // End of namespace BladeRunner +#endif diff --git a/engines/bladerunner/ui/kia_section_load.h b/engines/bladerunner/ui/kia_section_load.h new file mode 100644 index 0000000000..4cff04d2c4 --- /dev/null +++ b/engines/bladerunner/ui/kia_section_load.h @@ -0,0 +1,39 @@ +/* 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 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 BLADERUNNER_KIA_SECTION_LOAD_H +#define BLADERUNNER_KIA_SECTION_LOAD_H + +#include "bladerunner/ui/kia_section_base.h" + +namespace BladeRunner { + +class KIASectionLoad : public KIASectionBase { + +public: + KIASectionLoad(BladeRunnerEngine *vm): KIASectionBase(vm){} + +}; + +} // End of namespace BladeRunner + +#endif diff --git a/engines/bladerunner/ui/kia_section_pogo.h b/engines/bladerunner/ui/kia_section_pogo.h new file mode 100644 index 0000000000..d2a2edd859 --- /dev/null +++ b/engines/bladerunner/ui/kia_section_pogo.h @@ -0,0 +1,39 @@ +/* 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 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 BLADERUNNER_KIA_SECTION_POGO_H +#define BLADERUNNER_KIA_SECTION_POGO_H + +#include "bladerunner/ui/kia_section_base.h" + +namespace BladeRunner { + +class KIASectionPogo : public KIASectionBase { + +public: + KIASectionPogo(BladeRunnerEngine *vm): KIASectionBase(vm){} + +}; + +} // End of namespace BladeRunner + +#endif diff --git a/engines/bladerunner/ui/kia_section_save.h b/engines/bladerunner/ui/kia_section_save.h new file mode 100644 index 0000000000..5e2f5f26ac --- /dev/null +++ b/engines/bladerunner/ui/kia_section_save.h @@ -0,0 +1,39 @@ +/* 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 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 BLADERUNNER_KIA_SECTION_SAVE_H +#define BLADERUNNER_KIA_SECTION_SAVE_H + +#include "bladerunner/ui/kia_section_base.h" + +namespace BladeRunner { + +class KIASectionSave : public KIASectionBase { + +public: + KIASectionSave(BladeRunnerEngine *vm): KIASectionBase(vm){} + +}; + +} // End of namespace BladeRunner + +#endif diff --git a/engines/bladerunner/ui/kia_section_settings.cpp b/engines/bladerunner/ui/kia_section_settings.cpp new file mode 100644 index 0000000000..7f2db4ae12 --- /dev/null +++ b/engines/bladerunner/ui/kia_section_settings.cpp @@ -0,0 +1,301 @@ +/* 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 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 "bladerunner/ui/kia_section_settings.h" + +#include "bladerunner/audio_player.h" +#include "bladerunner/audio_speech.h" +#include "bladerunner/ambient_sounds.h" +#include "bladerunner/bladerunner.h" +#include "bladerunner/font.h" +#include "bladerunner/game_constants.h" +#include "bladerunner/game_flags.h" +#include "bladerunner/game_info.h" +#include "bladerunner/music.h" +#include "bladerunner/settings.h" +#include "bladerunner/text_resource.h" +#include "bladerunner/ui/kia.h" +#include "bladerunner/ui/kia_shapes.h" +#include "bladerunner/ui/ui_check_box.h" +#include "bladerunner/ui/ui_container.h" +#include "bladerunner/ui/ui_image_picker.h" +#include "bladerunner/ui/ui_slider.h" + +#include "common/keyboard.h" + +namespace BladeRunner { + +const char *KIASectionSettings::kLeary = "LEARY"; + +KIASectionSettings::KIASectionSettings(BladeRunnerEngine *vm) + : KIASectionBase(vm) { + + _uiContainer = new UIContainer(_vm); + _musicVolume = new UISlider(_vm, sliderCallback, this, Common::Rect(180, 160, 460, 170), 101, 0); + _soundEffectVolume = new UISlider(_vm, sliderCallback, this, Common::Rect( 180, 185, 460, 195), 101, 0); + _ambientSoundVolume = new UISlider(_vm, sliderCallback, this, Common::Rect(180, 210, 460, 220), 101, 0); + _speechVolume = new UISlider(_vm, sliderCallback, this, Common::Rect(180, 235, 460, 245), 101, 0); + _gammaCorrection = new UISlider(_vm, sliderCallback, this, Common::Rect(180, 260, 460, 270), 101, 0); + _directorsCut = new UICheckBox(_vm, checkBoxCallback, this, Common::Rect(180, 364, 460, 374), 0, false); + _playerAgendaSelector = new UIImagePicker(_vm, 5); + + _uiContainer->add(_musicVolume); + _uiContainer->add(_soundEffectVolume); + _uiContainer->add(_ambientSoundVolume); + _uiContainer->add(_speechVolume); + _uiContainer->add(_gammaCorrection); + _uiContainer->add(_directorsCut); + + _learyPos = 0; +} + +KIASectionSettings::~KIASectionSettings() { + delete _uiContainer; + delete _musicVolume; + delete _soundEffectVolume; + delete _ambientSoundVolume; + delete _speechVolume; + delete _gammaCorrection; + delete _directorsCut; + delete _playerAgendaSelector; +} + +void KIASectionSettings::open() { + _playerAgendaSelector->resetImages(); + + _playerAgendaSelector->defineImage(0, Common::Rect(180, 290, 227, 353), nullptr, nullptr, nullptr, _vm->_textOptions->getText(30)); + _playerAgendaSelector->defineImage(1, Common::Rect(238, 290, 285, 353), nullptr, nullptr, nullptr, _vm->_textOptions->getText(31)); + _playerAgendaSelector->defineImage(2, Common::Rect(296, 290, 343, 353), nullptr, nullptr, nullptr, _vm->_textOptions->getText(32)); + _playerAgendaSelector->defineImage(3, Common::Rect(354, 290, 401, 353), nullptr, nullptr, nullptr, _vm->_textOptions->getText(33)); + _playerAgendaSelector->defineImage(4, Common::Rect(412, 290, 459, 353), nullptr, nullptr, nullptr, _vm->_textOptions->getText(34)); + initConversationChoices(); + _playerAgendaSelector->activate(mouseInCallback, nullptr, nullptr, mouseUpCallback, this); + + _directorsCut->enable(); +} + +void KIASectionSettings::close() { + _playerAgendaSelector->deactivate(); +} + +void KIASectionSettings::draw(Graphics::Surface &surface) { + _musicVolume->setValue(_vm->_music->getVolume()); + _soundEffectVolume->setValue(_vm->_audioPlayer->getVolume()); + _ambientSoundVolume->setValue(_vm->_ambientSounds->getVolume()); + _speechVolume->setValue(_vm->_audioSpeech->getVolume()); + _gammaCorrection->setValue(100.0f); + _directorsCut->setChecked(_vm->_gameFlags->query(kFlagDirectorsCut)); + + const char *textConversationChoices = _vm->_textOptions->getText(0); + const char *textMusic = _vm->_textOptions->getText(2); + const char *textSoundEffects = _vm->_textOptions->getText(3); + const char *textAmbientSound = _vm->_textOptions->getText(4); + const char *textSpeech = _vm->_textOptions->getText(5); + const char *textGammaCorrection = _vm->_textOptions->getText(7); + const char *textSoft = _vm->_textOptions->getText(10); + const char *textLoud = _vm->_textOptions->getText(11); + const char *textDark = _vm->_textOptions->getText(14); + const char *textLight = _vm->_textOptions->getText(15); + const char *textDesignersCut = _vm->_textOptions->getText(18); + + int posConversationChoices = 320 - _vm->_mainFont->getTextWidth(textConversationChoices) / 2; + int posMusic = 320 - _vm->_mainFont->getTextWidth(textMusic) / 2; + int posSoundEffects = 320 - _vm->_mainFont->getTextWidth(textSoundEffects) / 2; + int posAmbientSound = 320 - _vm->_mainFont->getTextWidth(textAmbientSound) / 2; + int posSpeech = 320 - _vm->_mainFont->getTextWidth(textSpeech) / 2; + int posGammaCorrection = 320 - _vm->_mainFont->getTextWidth(textGammaCorrection) / 2; + int posSoft = 178 - _vm->_mainFont->getTextWidth(textSoft); + int posDark = 178 - _vm->_mainFont->getTextWidth(textDark); + + _uiContainer->draw(surface); + _playerAgendaSelector->draw(surface); + + _vm->_mainFont->drawColor(textConversationChoices, surface, posConversationChoices, 280, 0x7751); + + _vm->_mainFont->drawColor(textMusic, surface, posMusic, 150, 0x7751); + _vm->_mainFont->drawColor(textSoft, surface, posSoft, 161, 0x6EEE); + _vm->_mainFont->drawColor(textLoud, surface, 462, 161, 0x6EEE); + + _vm->_mainFont->drawColor(textSoundEffects, surface, posSoundEffects, 175, 0x7751); + _vm->_mainFont->drawColor(textSoft, surface, posSoft, 186, 0x6EEE); + _vm->_mainFont->drawColor(textLoud, surface, 462, 186, 0x6EEE); + + _vm->_mainFont->drawColor(textAmbientSound, surface, posAmbientSound, 200, 0x7751); + _vm->_mainFont->drawColor(textSoft, surface, posSoft, 211, 0x6EEE); + _vm->_mainFont->drawColor(textLoud, surface, 462, 211, 0x6EEE); + + _vm->_mainFont->drawColor(textSpeech, surface, posSpeech, 225, 0x7751); + _vm->_mainFont->drawColor(textSoft, surface, posSoft, 236, 0x6EEE); + _vm->_mainFont->drawColor(textLoud, surface, 462, 236, 0x6EEE); + + _vm->_mainFont->drawColor(textGammaCorrection, surface, posGammaCorrection, 250, 0x7751); + _vm->_mainFont->drawColor(textDark, surface, posDark, 261, 0x6EEE); + _vm->_mainFont->drawColor(textLight, surface, 462, 261, 0x6EEE); + + _vm->_mainFont->drawColor(textDesignersCut, surface, 192, 365, 0x7751); + + _playerAgendaSelector->drawTooltip(surface, _mouseX, _mouseY); +} + +void KIASectionSettings::handleKeyUp(const Common::KeyState &kbd) { + if (toupper(kbd.ascii) != kLeary[_learyPos]) { + _learyPos = 0; + } + + if (toupper(kbd.ascii) == kLeary[_learyPos]) { + ++_learyPos; + if (!kLeary[_learyPos]) { + _vm->_settings->setLearyMode(!_vm->_settings->getLearyMode()); + _learyPos = 0; + initConversationChoices(); + } + } +} + +void KIASectionSettings::handleMouseMove(int mouseX, int mouseY) { + _uiContainer->handleMouseMove(mouseX, mouseY); + _mouseX = mouseX; + _mouseY = mouseY; + _playerAgendaSelector->handleMouseAction(mouseX, mouseY, false, false, false); +} + +void KIASectionSettings::handleMouseDown(bool mainButton) { + if (mainButton) { + _uiContainer->handleMouseDown(false); + _playerAgendaSelector->handleMouseAction(_mouseX, _mouseY, true, false, false); + } +} + +void KIASectionSettings::handleMouseUp(bool mainButton) { + if (mainButton) { + _uiContainer->handleMouseUp(false); + _playerAgendaSelector->handleMouseAction(_mouseX, _mouseY, false, true, false); + } +} + +void KIASectionSettings::sliderCallback(void *callbackData, void *source) { + KIASectionSettings *self = (KIASectionSettings *)callbackData; + + if (source == self->_musicVolume) { + self->_vm->_music->setVolume(self->_musicVolume->_value); + self->_vm->_music->playSample(); + } else if (source == self->_soundEffectVolume) { + self->_vm->_audioPlayer->setVolume(self->_soundEffectVolume->_value); + self->_vm->_audioPlayer->playSample(); + } else if (source == self->_ambientSoundVolume) { + self->_vm->_ambientSounds->setVolume(self->_ambientSoundVolume->_value); + self->_vm->_ambientSounds->playSample(); + } else if (source == self->_speechVolume) { + self->_vm->_audioSpeech->setVolume(self->_speechVolume->_value); + self->_vm->_audioSpeech->playSample(); + } else if (source == self->_gammaCorrection) { + // TODO: gamma, should we support it? + // gamma = self->_gammaCorrection._value / 100.0f; + // settings::setGamma(&Settings, gamma); + // colorFormat = DirectDrawSurfaces_get_colorFormat(); + // Palette_fill(colorFormat); + // Palette_copy(Palette); + // kia::resume(KIA); + } +} + +void KIASectionSettings::checkBoxCallback(void *callbackData, void *source) { + KIASectionSettings *self = (KIASectionSettings *)callbackData; + if (source == self->_directorsCut) { + if (self->_directorsCut->_isChecked) { + self->_vm->_gameFlags->set(kFlagDirectorsCut); + } else { + self->_vm->_gameFlags->reset(kFlagDirectorsCut); + } + } +} + +void KIASectionSettings::mouseInCallback(int buttonId, void *callbackData) { + KIASectionSettings *self = (KIASectionSettings *)callbackData; + self->_vm->_audioPlayer->playAud(self->_vm->_gameInfo->getSfxTrack(508), 100, 0, 0, 50, 0); +} + +void KIASectionSettings::mouseUpCallback(int buttonId, void *callbackData) { + KIASectionSettings *self = (KIASectionSettings *)callbackData; + self->onButtonPressed(buttonId); +} + +void KIASectionSettings::onButtonPressed(int buttonId) { + switch (buttonId) { + case 0: + _vm->_audioPlayer->playAud(_vm->_gameInfo->getSfxTrack(513), 90, -30, -30, 50, 0); + _vm->_settings->setPlayerAgenda(0); + initConversationChoices(); + break; + case 1: + _vm->_audioPlayer->playAud(_vm->_gameInfo->getSfxTrack(513), 90, -15, -15, 50, 0); + _vm->_settings->setPlayerAgenda(1); + initConversationChoices(); + break; + case 2: + _vm->_audioPlayer->playAud(_vm->_gameInfo->getSfxTrack(513), 90, 0, 0, 50, 0); + _vm->_settings->setPlayerAgenda(2); + initConversationChoices(); + break; + case 3: + _vm->_audioPlayer->playAud(_vm->_gameInfo->getSfxTrack(513), 90, 15, 15, 50, 0); + _vm->_settings->setPlayerAgenda(3); + initConversationChoices(); + break; + case 4: + _vm->_audioPlayer->playAud(_vm->_gameInfo->getSfxTrack(513), 90, 30, 30, 50, 0); + _vm->_settings->setPlayerAgenda(4); + initConversationChoices(); + break; + default: + return; + } +} + +void KIASectionSettings::initConversationChoices() { + for (int i = 0; i < 5; ++i) { + const Shape *shape = nullptr; + if (_vm->_settings->getPlayerAgenda() == i) { + if (i == 4) { + shape = _vm->_kia->_shapes->get(122); + } else if (_vm->_settings->getLearyMode()) { + shape = _vm->_kia->_shapes->get(106 + i); + } else { + shape = _vm->_kia->_shapes->get(114 + i); + } + } else { + if (i == 4) { + shape = _vm->_kia->_shapes->get(123); + } else if (_vm->_settings->getLearyMode()) { + shape = _vm->_kia->_shapes->get(110 + i); + } else { + shape = _vm->_kia->_shapes->get(118 + i); + } + } + + _playerAgendaSelector->setImageShapeUp(i, shape); + _playerAgendaSelector->setImageShapeHovered(i, shape); + _playerAgendaSelector->setImageShapeDown(i, shape); + } +} + +} // End of namespace BladeRunner diff --git a/engines/bladerunner/ui/kia_section_settings.h b/engines/bladerunner/ui/kia_section_settings.h new file mode 100644 index 0000000000..49356266b7 --- /dev/null +++ b/engines/bladerunner/ui/kia_section_settings.h @@ -0,0 +1,80 @@ +/* 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 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 BLADERUNNER_KIA_SECTION_SETTINGS_H +#define BLADERUNNER_KIA_SECTION_SETTINGS_H + +#include "bladerunner/ui/kia_section_base.h" + +namespace BladeRunner { + +class BladeRunnerEngine; +class UIContainer; +class UICheckBox; +class UIImagePicker; +class UISlider; + +class KIASectionSettings : public KIASectionBase { + static const char *kLeary; + + UIContainer *_uiContainer; + UISlider *_musicVolume; + UISlider *_soundEffectVolume; + UISlider *_ambientSoundVolume; + UISlider *_speechVolume; + UISlider *_gammaCorrection; + UICheckBox *_directorsCut; + UIImagePicker *_playerAgendaSelector; + + int _mouseX; + int _mouseY; + + int _learyPos; + +public: + KIASectionSettings(BladeRunnerEngine *vm); + ~KIASectionSettings(); + + void open(); + void close(); + + void draw(Graphics::Surface &surface); + + void handleKeyUp(const Common::KeyState &kbd); + void handleMouseMove(int mouseX, int mouseY); + void handleMouseDown(bool mainButton); + void handleMouseUp(bool mainButton); + +private: + static void sliderCallback(void *callbackData, void *source); + static void checkBoxCallback(void *callbackData, void *source); + static void mouseInCallback(int buttonId, void *callbackData); + static void mouseUpCallback(int buttonId, void *callbackData); + + void onButtonPressed(int buttonId); + + void initConversationChoices(); +}; + +} // End of namespace BladeRunner + +#endif diff --git a/engines/bladerunner/ui/kia_section_suspects.h b/engines/bladerunner/ui/kia_section_suspects.h new file mode 100644 index 0000000000..94cf1bfc06 --- /dev/null +++ b/engines/bladerunner/ui/kia_section_suspects.h @@ -0,0 +1,41 @@ +/* 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 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 BLADERUNNER_KIA_SECTION_SUSPECTS_H +#define BLADERUNNER_KIA_SECTION_SUSPECTS_H + +#include "bladerunner/ui/kia_section_base.h" + +namespace BladeRunner { + +class KIASectionSuspects : public KIASectionBase { + +public: + KIASectionSuspects(BladeRunnerEngine *vm): KIASectionBase(vm) {} + + void saveToLog() {} + void loadFromLog() {} +}; + +} // End of namespace BladeRunner + +#endif diff --git a/engines/bladerunner/ui/kia_shapes.cpp b/engines/bladerunner/ui/kia_shapes.cpp new file mode 100644 index 0000000000..6835216e26 --- /dev/null +++ b/engines/bladerunner/ui/kia_shapes.cpp @@ -0,0 +1,69 @@ +/* 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 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 "bladerunner/ui/kia_shapes.h" + +#include "bladerunner/bladerunner.h" + +namespace BladeRunner { + +KIAShapes::KIAShapes(BladeRunnerEngine *vm) { + _vm = vm; + _isLoaded = false; +} + +KIAShapes::~KIAShapes() { + unload(); +} + +void KIAShapes::load() { + if (_isLoaded) { + return; + } + + for (uint i = 0; i < kShapeCount; ++i) { + Shape *shape = new Shape(_vm); + shape->readFromContainer("kiaopt.shp", i); + _shapes[i] = shape; + } + + _isLoaded = true; +} + +void KIAShapes::unload() { + if (!_isLoaded) { + return; + } + + for (uint i = 0; i < kShapeCount; ++i) { + delete _shapes[i]; + _shapes[i] = nullptr; + } + + _isLoaded = false; +} + +const Shape *KIAShapes::get(int shapeId) const { + return _shapes[shapeId]; +} + +} // End of namespace BladeRunner diff --git a/engines/bladerunner/ui/kia_shapes.h b/engines/bladerunner/ui/kia_shapes.h new file mode 100644 index 0000000000..e075547542 --- /dev/null +++ b/engines/bladerunner/ui/kia_shapes.h @@ -0,0 +1,54 @@ +/* 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 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 BLADERUNNER_UI_SHAPES_H +#define BLADERUNNER_UI_SHAPES_H + +#include "bladerunner/shape.h" + +#include "common/array.h" + +namespace BladeRunner { + +class BladeRunnerEngine; + +class KIAShapes +{ +private: + static const int kShapeCount = 132; + + BladeRunnerEngine *_vm; + const Shape *_shapes[kShapeCount]; + bool _isLoaded; + +public: + KIAShapes(BladeRunnerEngine *vm); + ~KIAShapes(); + + void load(); + void unload(); + const Shape *get(int shapeId) const; +}; + +} // End of namespace BladeRunner + +#endif diff --git a/engines/bladerunner/ui/spinner.cpp b/engines/bladerunner/ui/spinner.cpp new file mode 100644 index 0000000000..9018de15e6 --- /dev/null +++ b/engines/bladerunner/ui/spinner.cpp @@ -0,0 +1,303 @@ +/* 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 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 "bladerunner/ui/spinner.h" + +#include "bladerunner/bladerunner.h" +#include "bladerunner/mouse.h" +#include "bladerunner/scene.h" +#include "bladerunner/shape.h" +#include "bladerunner/text_resource.h" +#include "bladerunner/vqa_player.h" +#include "bladerunner/ui/ui_image_picker.h" + +#include "common/rect.h" +#include "common/system.h" + +namespace BladeRunner { + +Spinner::Spinner(BladeRunnerEngine *vm) { + _vm = vm; + reset(); + _imagePicker = new UIImagePicker(vm, kSpinnerDestinations); + _vqaPlayer = nullptr; +} + +Spinner::~Spinner() { + delete _imagePicker; + + reset(); + + if (_vqaPlayer != nullptr) { + _vqaPlayer->close(); + delete _vqaPlayer; + } +} + +void Spinner::setSelectableDestinationFlag(int destination, bool selectable) { + _isDestinationSelectable[destination] = selectable; +} + +bool Spinner::querySelectableDestinationFlag(int destination) const { + return _isDestinationSelectable[destination]; +} + +const Spinner::Destination Spinner::kSpinnerDestinationsNear[] = { + { 0, Common::Rect(210, 263, 263, 332) }, + { 1, Common::Rect(307, 330, 361, 381) }, + { 2, Common::Rect(338, 137, 362, 169) }, + { 3, Common::Rect(248, 135, 289, 168) }, + { 4, Common::Rect(352, 222, 379, 238) }, + { -1, Common::Rect(-1,-1,-1,-1) } +}; + +const Spinner::Destination Spinner::kSpinnerDestinationsMedium[] = { + { 0, Common::Rect(252, 242, 279, 283) }, + { 1, Common::Rect(301, 273, 328, 304) }, + { 2, Common::Rect(319, 182, 336, 200) }, + { 3, Common::Rect(269, 181, 293, 200) }, + { 4, Common::Rect(325, 227, 345, 240) }, + { 5, Common::Rect(259, 74, 380, 119) }, + { 6, Common::Rect(203, 124, 224, 136) }, + { 7, Common::Rect(200, 147, 222, 170) }, + { -1, Common::Rect(-1,-1,-1,-1) } +}; + +const Spinner::Destination Spinner::kSpinnerDestinationsFar[] = { + { 0, Common::Rect(220, 227, 246, 262) }, + { 1, Common::Rect(260, 252, 286, 279) }, + { 2, Common::Rect(286, 178, 302, 196) }, + { 3, Common::Rect(244, 178, 263, 195) }, + { 4, Common::Rect(288, 216, 306, 228) }, + { 5, Common::Rect(249, 77, 353, 124) }, + { 6, Common::Rect(190, 127, 208, 138) }, + { 7, Common::Rect(185, 149, 206, 170) }, + { 8, Common::Rect(398, 249, 419, 268) }, + { 9, Common::Rect(390, 218, 419, 236) }, + { -1, Common::Rect(-1, -1, -1, -1) } +}; + +int Spinner::chooseDestination(int loopId, bool immediately) { + _selectedDestination = 0; + if (!_vm->openArchive("MODE.MIX")) { + return 0; + } + + if (loopId < 0) { + _isOpen = true; + } else { + _vm->playerLosesControl(); + _vm->_scene->loopStartSpecial(kSceneLoopModeSpinner, loopId, immediately); + while (!_isOpen) { + _vm->gameTick(); + } + _vm->playerGainsControl(); + } + + _vqaPlayer = new VQAPlayer(_vm, &_vm->_surfaceBack); + if (!_vqaPlayer->open("SPINNER.VQA")) { + return 0; + } + + _vm->_mouse->setCursor(0); + + // Determine which map we need to show to include the active destinations + uint8 mapmask = 0; + uint8 mapmaskv[kSpinnerDestinations] = { 1, 1, 1, 1, 1, 3, 3, 3, 7, 7 }; + for (int i = 0; i != kSpinnerDestinations; ++i) { + if (_isDestinationSelectable[i]) { + mapmask |= mapmaskv[i]; + } + } + + _destinations = nullptr; + int firstShapeId = 0; + int shapeCount = 0; + int spinnerLoopId = 4; + + mapmask = 1; + + if (mapmask & 4) { + _destinations = kSpinnerDestinationsFar; + firstShapeId = 26; + shapeCount = 20; + spinnerLoopId = 4; + } else if (mapmask & 2) { + _destinations = kSpinnerDestinationsMedium; + firstShapeId = 10; + shapeCount = 16; + spinnerLoopId = 2; + } else if (mapmask & 1) { + _destinations = kSpinnerDestinationsNear; + firstShapeId = 0; + shapeCount = 10; + spinnerLoopId = 0; + } else { + return -1; + } + + _vqaPlayer->setLoop(spinnerLoopId, -1, kLoopSetModeImmediate, nullptr, nullptr); + _vqaPlayer->setLoop(spinnerLoopId + 1, -1, kLoopSetModeJustStart, nullptr, nullptr); + + for (int j = 0; j != shapeCount; ++j) { + _shapes.push_back(new Shape(_vm)); + _shapes[j]->readFromContainer("SPINNER.SHP", firstShapeId + j); + } + + _imagePicker->resetImages(); + + for (const Destination *dest = _destinations; dest->id != -1; ++dest) { + if (!_isDestinationSelectable[dest->id]) { + continue; + } + + const char *tooltip = _vm->_textSpinnerDestinations->getText(dest->id); + + _imagePicker->defineImage( + dest->id, + dest->rect, + _shapes[dest->id], + _shapes[dest->id + _shapes.size() / 2], + _shapes[dest->id + _shapes.size() / 2], + tooltip + ); + } + + _imagePicker->activate( + nullptr, + nullptr, + nullptr, + mouseUpCallback, + this + ); + + // TODO: Freeze game time + _selectedDestination = -1; + do { + _vm->gameTick(); + } while (_selectedDestination == -1); + + _imagePicker->deactivate(); + + for (int i = 0; i != (int)_shapes.size(); ++i) { + delete _shapes[i]; + } + _shapes.clear(); + + if (_vqaPlayer != nullptr) { + _vqaPlayer->close(); + delete _vqaPlayer; + _vqaPlayer = nullptr; + } + + _vm->closeArchive("MODE.MIX"); + + _isOpen = false; + + // TODO: Unfreeze game time + // TODO: _vm->_scene->resume(); + + return _selectedDestination; +} + +void Spinner::mouseUpCallback(int image, void *self) { + if (image >= 0 && image < 10) { + ((Spinner *)self)->setSelectedDestination(image); + } +} + +void Spinner::open() { + _isOpen = true; +} + +bool Spinner::isOpen() const { + return _isOpen; +} + +int Spinner::handleMouseUp(int x, int y) { + _imagePicker->handleMouseAction(x, y, false, true, false); + return false; +} + +int Spinner::handleMouseDown(int x, int y) { + _imagePicker->handleMouseAction(x, y, true, false, false); + return false; +} + +void Spinner::tick() { + if (!_vm->_gameIsRunning) { + return; + } + + int frame = _vqaPlayer->update(); + assert(frame >= -1); + + // vqaPlayer renders to _surfaceBack + blit(_vm->_surfaceBack, _vm->_surfaceFront); + + Common::Point p = _vm->getMousePos(); + _imagePicker->handleMouseAction(p.x, p.y, false, false, false); + if (_imagePicker->hasHoveredImage()) { + _vm->_mouse->setCursor(1); + } else { + _vm->_mouse->setCursor(0); + } + _imagePicker->draw(_vm->_surfaceFront); + _vm->_mouse->draw(_vm->_surfaceFront, p.x, p.y); + _imagePicker->drawTooltip(_vm->_surfaceFront, p.x, p.y); + + _vm->blitToScreen(_vm->_surfaceFront); + _vm->_system->delayMillis(10); +} + +void Spinner::setSelectedDestination(int destination) { + _selectedDestination = destination; +} + +void Spinner::reset() { + for (int i = 0; i != kSpinnerDestinations; ++i) { + _isDestinationSelectable[i] = false; + } + + _isOpen = false; + _destinations = nullptr; + _selectedDestination = -1; + _imagePicker = nullptr; + + for (int i = 0; i != (int)_shapes.size(); ++i) { + delete _shapes[i]; + } + _shapes.clear(); +} + +void Spinner::resume() { + if(_vqaPlayer == nullptr) { + return; + } + + //_vqa->clear(); + _vqaPlayer->setLoop(0, -1, kLoopSetModeImmediate, nullptr, nullptr); + tick(); + _vqaPlayer->setLoop(1, -1, kLoopSetModeJustStart, nullptr, nullptr); +} + +} // End of namespace BladeRunner diff --git a/engines/bladerunner/ui/spinner.h b/engines/bladerunner/ui/spinner.h new file mode 100644 index 0000000000..ec0f8dbe33 --- /dev/null +++ b/engines/bladerunner/ui/spinner.h @@ -0,0 +1,84 @@ +/* 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 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 BLADERUNNER_SPINNER_H +#define BLADERUNNER_SPINNER_H + +#include "common/array.h" +#include "common/rect.h" + +namespace BladeRunner { + +class BladeRunnerEngine; +class Shape; +class VQAPlayer; +class UIImagePicker; + + +class Spinner { + static const int kSpinnerDestinations = 10; + + struct Destination { + int id; + Common::Rect rect; + }; + + static const Destination kSpinnerDestinationsNear[]; + static const Destination kSpinnerDestinationsMedium[]; + static const Destination kSpinnerDestinationsFar[]; + + BladeRunnerEngine *_vm; + bool _isDestinationSelectable[kSpinnerDestinations]; + bool _isOpen; + VQAPlayer *_vqaPlayer; + const Destination *_destinations; + int _selectedDestination; + Common::Array<Shape *> _shapes; + UIImagePicker *_imagePicker; + +public: + Spinner(BladeRunnerEngine *vm); + ~Spinner(); + + void setSelectableDestinationFlag(int destination, bool selectable); + bool querySelectableDestinationFlag(int destination) const; + + int chooseDestination(int vqaLoopId, bool immediately); + + void open(); + bool isOpen() const; + + int handleMouseUp(int x, int y); + int handleMouseDown(int x, int y); + + void tick(); + void setSelectedDestination(int destination); + void reset(); + void resume(); + +private: + static void mouseUpCallback(int, void *); +}; + +} // End of namespace BladeRunner + +#endif diff --git a/engines/bladerunner/ui/ui_check_box.cpp b/engines/bladerunner/ui/ui_check_box.cpp new file mode 100644 index 0000000000..39e120e883 --- /dev/null +++ b/engines/bladerunner/ui/ui_check_box.cpp @@ -0,0 +1,140 @@ +/* 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 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 "bladerunner/ui/ui_check_box.h" + +#include "bladerunner/audio_player.h" +#include "bladerunner/bladerunner.h" +#include "bladerunner/game_info.h" +#include "bladerunner/ui/kia.h" +#include "bladerunner/ui/kia_shapes.h" + +namespace BladeRunner { + +UICheckBox::UICheckBox(BladeRunnerEngine *vm, UIComponentCallback *valueChangedCallback, void *callbackData, Common::Rect rect, int style, bool isChecked) + : UIComponent(vm) { + + _valueChangedCallback = valueChangedCallback; + _callbackData = callbackData; + + _isEnabled = true; + _hasFocus = false; + _isPressed = false; + _style = style; + + if (isChecked) { + _frame = 5; + } else { + _frame = 0; + } + + _timeLast = _vm->getTotalPlayTime(); + _rect = rect; + _isChecked = isChecked; +} + + +void UICheckBox::draw(Graphics::Surface &surface) { + int shapeId; + if (_rect.right > _rect.left && _rect.bottom > _rect.top) { + uint timeNow = _vm->getTotalPlayTime(); + if (timeNow - _timeLast > 67) { + int frameDelta = (timeNow - _timeLast) / 67u; + _timeLast = timeNow; + + if (_isChecked) { + _frame = MIN(_frame + frameDelta, 5); + } else { + _frame = MAX(_frame - frameDelta, 0); + } + } + + if (_style) { + if (_frame || (_hasFocus && !_isPressed && _isEnabled)) { + if (_frame != 5 || (_hasFocus && !_isPressed && _isEnabled)) { + shapeId = _frame + 54; + } else { + shapeId = 53; + } + } else { + shapeId = 52; + } + } else { + if (_frame || (_hasFocus && !_isPressed && _isEnabled)) { + if (_frame != 5 || (_hasFocus && !_isPressed && _isEnabled)) { + shapeId = _frame + 62; + } else { + shapeId = 61; + } + } else { + shapeId = 60; + } + } + + _vm->_kia->_shapes->get(shapeId)->draw(surface, _rect.left, _rect.top + 1); + } +} + +void UICheckBox::enable() { + _isEnabled = true; + _isPressed = false; + _hasFocus = false; +} + +void UICheckBox::disable() { + _isEnabled = false; +} + +void UICheckBox::setChecked(bool isChecked) { + _isChecked = isChecked; +} + +void UICheckBox::handleMouseMove(int mouseX, int mouseY) { + if (_rect.contains(mouseX, mouseY)) { + if (!_hasFocus && _isEnabled && !_isPressed ) { + _vm->_audioPlayer->playAud(_vm->_gameInfo->getSfxTrack(508), 100, 0, 0, 50, 0); + } + _hasFocus = true; + } else { + _hasFocus = false; + } +} + +void UICheckBox::handleMouseDown(bool alternateButton) { + if (!alternateButton) { + if (_isEnabled && _hasFocus) { + _isChecked = !_isChecked; + if (_valueChangedCallback) { + _valueChangedCallback(_callbackData, this); + } + _vm->_audioPlayer->playAud(_vm->_gameInfo->getSfxTrack(509), 100, 0, 0, 50, 0); + } else { + _isPressed = true; + } + } +} + +void UICheckBox::handleMouseUp(bool alternateButton) { + _isPressed = false; +} + +} // End of namespace BladeRunner diff --git a/engines/bladerunner/ui/ui_check_box.h b/engines/bladerunner/ui/ui_check_box.h new file mode 100644 index 0000000000..cfd584b09e --- /dev/null +++ b/engines/bladerunner/ui/ui_check_box.h @@ -0,0 +1,64 @@ +/* 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 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 BLADERUNNER_UI_CHECKBOX_H +#define BLADERUNNER_UI_CHECKBOX_H + +#include "bladerunner/ui/ui_component.h" + +#include "common/rect.h" + +namespace BladeRunner { + +class UICheckBox : public UIComponent +{ +private: + UIComponentCallback *_valueChangedCallback; + void *_callbackData; + + int _style; + int _isEnabled; + Common::Rect _rect; + int _frame; + int _isPressed; + uint _timeLast; + int _hasFocus; + +public: + bool _isChecked; + + UICheckBox(BladeRunnerEngine *vm, UIComponentCallback *valueChangedCallback, void *callbackData, Common::Rect rect, int style, bool isChecked); + + void draw(Graphics::Surface &surface); + + void enable(); + void disable(); + void setChecked(bool isChecked); + + void handleMouseMove(int mouseX, int mouseY); + void handleMouseDown(bool alternateButton); + void handleMouseUp(bool alternateButton); +}; + +} // End of namespace BladeRunner + +#endif diff --git a/engines/bladerunner/ui/ui_component.h b/engines/bladerunner/ui/ui_component.h new file mode 100644 index 0000000000..9c290d9dcb --- /dev/null +++ b/engines/bladerunner/ui/ui_component.h @@ -0,0 +1,62 @@ +/* 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 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 BLADERUNNER_UI_COMPONENT_H +#define BLADERUNNER_UI_COMPONENT_H + +namespace Common{ +struct KeyState; +} + +namespace Graphics { +struct Surface; +} + +namespace BladeRunner { + +class BladeRunnerEngine; + +typedef void UIComponentCallback(void *callbackData, void *source); + +class UIComponent +{ +protected: + BladeRunnerEngine *_vm; + +public: + UIComponent(BladeRunnerEngine *vm) { + _vm = vm; + } + + virtual ~UIComponent() {} + + virtual void draw(Graphics::Surface &surface) {} + + virtual void handleMouseMove(int mouseX, int mouseY) {} + virtual void handleMouseDown(bool alternateButton) {} + virtual void handleMouseUp(bool alternateButton) {} + virtual void handleKeyUp(const Common::KeyState &kbd) {} +}; + +} // End of namespace BladeRunner + +#endif diff --git a/engines/bladerunner/ui/ui_container.cpp b/engines/bladerunner/ui/ui_container.cpp new file mode 100644 index 0000000000..78097a9d3d --- /dev/null +++ b/engines/bladerunner/ui/ui_container.cpp @@ -0,0 +1,67 @@ +/* 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 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 "bladerunner/ui/ui_container.h" + +#include "common/keyboard.h" + +namespace BladeRunner { + +void UIContainer::draw(Graphics::Surface &surface) { +for (Common::Array<UIComponent*>::iterator component = _components.begin(); component != _components.end(); component++) { + (*component)->draw(surface); + } +} + +void UIContainer::handleMouseMove(int mouseX, int mouseY) { + for (Common::Array<UIComponent*>::iterator component = _components.begin(); component != _components.end(); component++) { + (*component)->handleMouseMove(mouseX, mouseY); + } +} + +void UIContainer::handleMouseDown(bool alternateButton) { +for (Common::Array<UIComponent*>::iterator component = _components.begin(); component != _components.end(); component++) { + (*component)->handleMouseDown(alternateButton); + } +} + +void UIContainer::handleMouseUp(bool alternateButton) { +for (Common::Array<UIComponent*>::iterator component = _components.begin(); component != _components.end(); component++) { + (*component)->handleMouseUp(alternateButton); + } +} + +void UIContainer::handleKeyUp(const Common::KeyState &kbd) { +for (Common::Array<UIComponent*>::iterator component = _components.begin(); component != _components.end(); component++) { + (*component)->handleKeyUp(kbd); + } +} + +void UIContainer::add(UIComponent *component) { + _components.push_back(component); +} + +void UIContainer::clear() { + _components.clear(); +} + +} // End of namespace BladeRunner diff --git a/engines/bladerunner/ui/ui_container.h b/engines/bladerunner/ui/ui_container.h new file mode 100644 index 0000000000..9d5bded960 --- /dev/null +++ b/engines/bladerunner/ui/ui_container.h @@ -0,0 +1,56 @@ +/* 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 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 BLADERUNNER_UI_CONTAINER_H +#define BLADERUNNER_UI_CONTAINER_H + +#include "bladerunner/ui/ui_component.h" + +#include "common/array.h" + +namespace BladeRunner { + +class UIComponent; + +class UIContainer : public UIComponent +{ +private: + Common::Array<UIComponent*> _components; + +public: + UIContainer(BladeRunnerEngine *vm) : UIComponent(vm) {} + + void draw(Graphics::Surface &surface); + + void handleMouseMove(int mouseX, int mouseY); + void handleMouseDown(bool alternateButton); + void handleMouseUp(bool alternateButton); + void handleKeyUp(const Common::KeyState &kbd); + + void add(UIComponent *component); + void clear(); +}; + + +} // End of namespace BladeRunner + +#endif diff --git a/engines/bladerunner/ui/ui_image_picker.cpp b/engines/bladerunner/ui/ui_image_picker.cpp new file mode 100644 index 0000000000..997ff7bc5e --- /dev/null +++ b/engines/bladerunner/ui/ui_image_picker.cpp @@ -0,0 +1,331 @@ +/* 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 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 "bladerunner/ui/ui_image_picker.h" + +#include "bladerunner/bladerunner.h" +#include "bladerunner/font.h" +#include "bladerunner/mouse.h" +#include "bladerunner/shape.h" + +#include "common/rect.h" +#include "common/str.h" +#include "graphics/surface.h" + +namespace BladeRunner { + +UIImagePicker::UIImagePicker(BladeRunnerEngine *vm, int imageCount) { + _vm = vm; + reset(); + _images.resize(imageCount); + _imageCount = imageCount; + resetImages(); +} + +UIImagePicker::~UIImagePicker() { + _images.clear(); + reset(); +} + +void UIImagePicker::resetImages() { + for (int i = 0; i != _imageCount; i++) { + resetImage(i); + } +} + +bool UIImagePicker::defineImage(int i, Common::Rect rect, const Shape *shapeUp, const Shape *shapeHovered, const Shape *shapeDown, const char *tooltip) { + if (i < 0 || i >= _imageCount || _images[i].active) { + return false; + } + + Image &img = _images[i]; + + img.rect = rect; + // for rect to be inclusive + img.rect.right += 1; + img.rect.bottom += 1; + img.shapeUp = shapeUp; + img.shapeHovered = shapeHovered; + img.shapeDown = shapeDown; + img.active = true; + + if (tooltip != nullptr) { + img.tooltip = tooltip; + } else { + img.tooltip.clear(); + } + + return true; +} + +bool UIImagePicker::setImageTop(int i, int top) { + if (i < 0 || i >= _imageCount || !_images[i].active) { + return false; + } + + Image &img = _images[i]; + + img.rect.moveTo(img.rect.left, top); + + return true; +} + +bool UIImagePicker::setImageLeft(int i, int left) { + if (i < 0 || i >= _imageCount || !_images[i].active) { + return false; + } + + Image &img = _images[i]; + + img.rect.moveTo(left, img.rect.top); + + return true; +} + +bool UIImagePicker::setImageShapeUp(int i, const Shape *shapeUp) { + if (i < 0 || i >= _imageCount || !_images[i].active) { + return false; + } + + _images[i].shapeUp = shapeUp; + + return true; +} + +bool UIImagePicker::setImageShapeHovered(int i, const Shape *shapeHovered) { + if (i < 0 || i >= _imageCount || !_images[i].active) { + return false; + } + + _images[i].shapeHovered = shapeHovered; + + return true; +} + +bool UIImagePicker::setImageShapeDown(int i, const Shape *shapeDown) { + if (i < 0 || i >= _imageCount || !_images[i].active) { + return false; + } + + _images[i].shapeDown = shapeDown; + + return true; +} + +bool UIImagePicker::setImageTooltip(int i, const char *tooltip) { + if (i < 0 || i >= _imageCount || !_images[i].active) { + return false; + } + + _images[i].tooltip = tooltip; + + return true; +} + +bool UIImagePicker::resetActiveImage(int i) { + if (i < 0 || i >= _imageCount || !_images[i].active) { + return false; + } + + resetImage(i); + return true; +} + +void UIImagePicker::activate(UIImagePickerCallback *mouseInCallback, + UIImagePickerCallback *mouseOutCallback, + UIImagePickerCallback *mouseDownCallback, + UIImagePickerCallback *mouseUpCallback, + void *callbackData) +{ + _isButtonDown = false; + _mouseInCallback = mouseInCallback; + _mouseOutCallback = mouseOutCallback; + _mouseDownCallback = mouseDownCallback; + _mouseUpCallback = mouseUpCallback; + _callbackData = callbackData; + _hoverStartTimestamp = 0; + _isVisible = true; + _hoveredImageIndex = -1; + _pressedImageIndex = -1; +} + +void UIImagePicker::deactivate() { + _isButtonDown = false; + _mouseInCallback = nullptr; + _mouseOutCallback = nullptr; + _mouseDownCallback = nullptr; + _mouseUpCallback = nullptr; + _callbackData = nullptr; + _hoverStartTimestamp = 0; + _isVisible = false; + _hoveredImageIndex = -1; + _pressedImageIndex = -1; +} + +void UIImagePicker::draw(Graphics::Surface &surface) { + if (!_isVisible) { + return; + } + + for (int i = 0; i != _imageCount; ++i) { + Image &img = _images[i]; + if (!img.active) { + continue; + } + + // TODO: Check interaction with Mouse::isDisabled + if (i == _hoveredImageIndex && i == _pressedImageIndex && _isButtonDown) { + if (img.shapeDown) { + img.shapeDown->draw(surface, img.rect.left, img.rect.top); + } + } else if (i == _hoveredImageIndex && !_isButtonDown) { + if (img.shapeHovered) { + img.shapeHovered->draw(surface, img.rect.left, img.rect.top); + } + } else { + if (img.shapeUp) { + img.shapeUp->draw(surface, img.rect.left, img.rect.top); + } + } +#if BLADERUNNER_DEBUG_RENDERING + surface.frameRect(img.rect, 0x7fff); +#endif + } +} + +void UIImagePicker::drawTooltip(Graphics::Surface &surface, int x, int y) { + if (!_isVisible) { + return; + } + + if (_hoveredImageIndex == -1 || _vm->_mouse->isDisabled() || !_images[_hoveredImageIndex].active || _vm->getTotalPlayTime() < _hoverStartTimestamp + 1000) { + return; + } + + Common::String &tooltip = _images[_hoveredImageIndex].tooltip; + int width = _vm->_mainFont->getTextWidth(tooltip) + 1; + int height = _vm->_mainFont->getTextHeight(tooltip) + 1; + + Common::Rect rect; + rect.left = x - ((width / 2) + 1); + if (rect.left < 0) { + rect.left = 0; + } + + rect.top = y - 10; + if (rect.top < 0) { + rect.top = 0; + } + + rect.right = width + rect.left + 3; + if (rect.right >= 640) { + rect.right = 639; + rect.left = 636 - width; + } + + rect.bottom = height + rect.top + 1; + if (rect.bottom >= 480) { + rect.bottom = 479; + rect.top = 478 - height; + } + + surface.fillRect(rect, 0); + surface.frameRect(rect, 0x7FFF); + _vm->_mainFont->drawColor(tooltip, surface, rect.left + 2, rect.top, 0x7FFF); +} + +void UIImagePicker::handleMouseAction(int x, int y, bool down, bool up, bool ignore) { + if (!_isVisible || ignore) { + return; + } + + int hoveredImageIndex = -1; + for (int i = 0; i != _imageCount; ++i) { + if (_images[i].rect.contains(x, y)) { + hoveredImageIndex = i; + break; + } + } + + // If mouse moved to a new image + if (hoveredImageIndex != _hoveredImageIndex) { + if (!_isButtonDown) { + if (hoveredImageIndex == -1) { + if (_mouseOutCallback) { + _mouseOutCallback(hoveredImageIndex, _callbackData); + } + } else { + if (_mouseInCallback) { + _mouseInCallback(hoveredImageIndex, _callbackData); + } + } + } + _hoverStartTimestamp = _vm->getTotalPlayTime(); + _hoveredImageIndex = hoveredImageIndex; + } + + // If mouse button changed to pressed + if (down && !_isButtonDown) { + _isButtonDown = true; + _pressedImageIndex = _hoveredImageIndex; + if (_hoveredImageIndex != 1) { + if (_mouseDownCallback) { + _mouseDownCallback(_hoveredImageIndex, _callbackData); + } + } + } + + // If mouse button changed to released + if (up) { + if (_isButtonDown) { + if (_hoveredImageIndex == _pressedImageIndex && _pressedImageIndex != -1) { + if (_mouseUpCallback) + _mouseUpCallback(_hoveredImageIndex, _callbackData); + } + } + _isButtonDown = false; + _pressedImageIndex = -1; + } +} + +void UIImagePicker::resetImage(int i) { + assert(i >= 0 && i < _imageCount); + Image &img = _images[i]; + + img.active = false; + img.rect.left = -1; + img.rect.top = -1; + img.rect.right = -1; + img.rect.bottom = -1; + img.shapeUp = nullptr; + img.shapeHovered = nullptr; + img.shapeDown = nullptr; + img.tooltip.clear(); +} + +bool UIImagePicker::hasHoveredImage() { + return _hoveredImageIndex >= 0; +} + +void UIImagePicker::reset() {} + +} // End of namespace BladeRunner diff --git a/engines/bladerunner/ui/ui_image_picker.h b/engines/bladerunner/ui/ui_image_picker.h new file mode 100644 index 0000000000..00f2f3dfd9 --- /dev/null +++ b/engines/bladerunner/ui/ui_image_picker.h @@ -0,0 +1,104 @@ +/* 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 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 BLADERUNNER_UI_IMAGE_PICKER_H +#define BLADERUNNER_UI_IMAGE_PICKER_H + +#include "common/array.h" +#include "common/rect.h" +#include "common/str.h" + +namespace Graphics { +struct Surface; +} + +namespace BladeRunner { + +class BladeRunnerEngine; +class Shape; + +typedef void UIImagePickerCallback(int, void *); + +class UIImagePicker { + struct Image { + int active; + Common::Rect rect; + const Shape *shapeUp; + const Shape *shapeHovered; + const Shape *shapeDown; + Common::String tooltip; + }; + + BladeRunnerEngine *_vm; + + int _isVisible; + int _imageCount; + int _hoveredImageIndex; + int _pressedImageIndex; + uint32 _hoverStartTimestamp; + int _isButtonDown; + Common::Array<Image> _images; + + UIImagePickerCallback *_mouseInCallback; + UIImagePickerCallback *_mouseOutCallback; + UIImagePickerCallback *_mouseDownCallback; + UIImagePickerCallback *_mouseUpCallback; + void *_callbackData; + +public: + UIImagePicker(BladeRunnerEngine *vm, int imageCount); + ~UIImagePicker(); + + void resetImages(); + bool defineImage(int i, Common::Rect rect, const Shape *shapeUp, const Shape *shapeHovered, const Shape *shapeDown, const char *tooltip); + + bool setImageTop(int i, int top); + bool setImageLeft(int i, int left); + bool setImageShapeUp(int i, const Shape *shapeUp); + bool setImageShapeHovered(int i, const Shape *shapeHovered); + bool setImageShapeDown(int i, const Shape *shapeDown); + bool setImageTooltip(int i, const char *tooltip); + + bool resetActiveImage(int i); + + void activate(UIImagePickerCallback *mouseInCallback, + UIImagePickerCallback *mouseOutCallback, + UIImagePickerCallback *mouseDownCallback, + UIImagePickerCallback *mouseUpCallback, + void *callbackData); + + void deactivate(); + + void draw(Graphics::Surface &surface); + void drawTooltip(Graphics::Surface &surface, int x, int y); + + void handleMouseAction(int x, int y, bool down, bool up, bool ignore = false); + + void resetImage(int i); + bool hasHoveredImage(); + + void reset(); +}; + +} // End of namespace BladeRunner + +#endif diff --git a/engines/bladerunner/ui/ui_input_box.cpp b/engines/bladerunner/ui/ui_input_box.cpp new file mode 100644 index 0000000000..409563f73e --- /dev/null +++ b/engines/bladerunner/ui/ui_input_box.cpp @@ -0,0 +1,115 @@ +/* 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 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 "bladerunner/ui/ui_input_box.h" + +#include "bladerunner/bladerunner.h" +#include "bladerunner/font.h" + +#include "common/keyboard.h" + +#include "graphics/surface.h" + +namespace BladeRunner { + +UIInputBox::UIInputBox(BladeRunnerEngine *vm, UIComponentCallback *valueChangedCallback, void *callbackData, Common::Rect rect, int maxLength, const Common::String &text) + : UIComponent(vm) { + _valueChangedCallback = valueChangedCallback; + _callbackData = callbackData; + + _isVisible = true; + _rect = rect; + + _maxLength = maxLength; + _length = 0; + setText(text); + + _cursorIsVisible = false; + _timeLast = _vm->getTotalPlayTime(); +} + +void UIInputBox::draw(Graphics::Surface &surface) { + if (!_isVisible) { + return; + } + + int rectHalfWidth = (_rect.right + _rect.left) / 2; + int textHalfWidth = _vm->_mainFont->getTextWidth(_text) / 2; + + _vm->_mainFont->drawColor(_text, surface, rectHalfWidth - textHalfWidth, _rect.top, 0x4DC7); // 10011 01110 00111 + + if (_cursorIsVisible) { + surface.vLine(textHalfWidth + rectHalfWidth + 2, _rect.top, _rect.bottom - 1, 0x7FDD); // 11111 11110 11101 + } + + if (_vm->getTotalPlayTime() - _timeLast > 500) { + _timeLast = _vm->getTotalPlayTime(); + _cursorIsVisible = !_cursorIsVisible; + } +} + +void UIInputBox::setText(const Common::String &text) { + _text = text; +} + +const Common::String &UIInputBox::getText() { + return _text; +} + +void UIInputBox::show() { + _isVisible = true; +} + +void UIInputBox::hide() { + _isVisible = false; +} + +void UIInputBox::handleKeyUp(const Common::KeyState &kbd) { + if (_isVisible) { + if (charIsValid(kbd)) { + _text += kbd.ascii; + } else if (kbd.keycode == Common::KEYCODE_BACKSPACE) { + _text.deleteLastChar(); + } else if (kbd.keycode == Common::KEYCODE_RETURN && !_text.empty()) { + if (_valueChangedCallback) { + _valueChangedCallback(_callbackData, this); + } + } + } +} + +bool UIInputBox::charIsValid(const Common::KeyState &kbd) +{ + return kbd.ascii >= ' ' + && kbd.ascii != '<' + && kbd.ascii != '>' + && kbd.ascii != ':' + && kbd.ascii != '"' + && kbd.ascii != '/' + && kbd.ascii != '\\' + && kbd.ascii != '|' + && kbd.ascii != '?' + && kbd.ascii != '*' + && (kbd.ascii <= '¿' || kbd.ascii == '¡' || kbd.ascii == 'ß'); +} + +} // End of namespace BladeRunner diff --git a/engines/bladerunner/ui/ui_input_box.h b/engines/bladerunner/ui/ui_input_box.h new file mode 100644 index 0000000000..473fe175df --- /dev/null +++ b/engines/bladerunner/ui/ui_input_box.h @@ -0,0 +1,69 @@ +/* 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 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 BLADERUNNER_ui_inputbox_H +#define BLADERUNNER_ui_inputbox_H + +#include "bladerunner/ui/ui_component.h" + +#include "common/rect.h" +#include "common/str.h" + +namespace BladeRunner { + +class UIInputBox : public UIComponent +{ +private: + UIComponentCallback *_valueChangedCallback; + void *_callbackData; + + bool _isVisible; + Common::Rect _rect; + + int _maxLength; + int _length; + Common::String _text; + + bool _cursorIsVisible; + + int _timeLast; + +public: + UIInputBox(BladeRunnerEngine *vm, UIComponentCallback *valueChangedCallback, void *callbackData, Common::Rect rect, int maxLength, const Common::String &text); + + void draw(Graphics::Surface &surface); + + void setText(const Common::String &text); + const Common::String &getText(); + + void show(); + void hide(); + + void handleKeyUp(const Common::KeyState &kbd); + +private: + bool charIsValid(const Common::KeyState &kbd); +}; + +} // End of namespace BladeRunner + +#endif diff --git a/engines/bladerunner/ui/ui_scroll_box.cpp b/engines/bladerunner/ui/ui_scroll_box.cpp new file mode 100644 index 0000000000..a0d53a444d --- /dev/null +++ b/engines/bladerunner/ui/ui_scroll_box.cpp @@ -0,0 +1,662 @@ +/* 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 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 "bladerunner/ui/ui_scroll_box.h" + +#include "bladerunner/audio_player.h" +#include "bladerunner/bladerunner.h" +#include "bladerunner/font.h" +#include "bladerunner/game_info.h" +#include "bladerunner/shape.h" +#include "bladerunner/ui/kia.h" +#include "bladerunner/ui/kia_shapes.h" + +namespace BladeRunner { + +const int UIScrollBox::k3DFrameColors[] = { 0x1083, 0x14A5, 0x14A6, 0x2508, 0x5230, 0x5230, 0x0000, 0x0000 }; +const int UIScrollBox::kTextBackgroundColors[] = { 0x14EA, 0x190C, 0x1D2E, 0x2570, 0x4F1F, 0x0000 }; +const int UIScrollBox::kTextColors1[] = { 0x25B3, 0x31F7, 0x3A5B, 0x46BF, 0x4F1F }; +const int UIScrollBox::kTextColors2[] = { 0x677F, 0x6F9F, 0x73BF, 0x77DF, 0x7FFF }; +const int UIScrollBox::kTextColors3[] = { 0x7BB8, 0x7BBA, 0x7BDB, 0x7FDD, 0x7FFF }; +const int UIScrollBox::kTextColors4[] = { 0x4DC7, 0x5E4B, 0x6EEE, 0x7751, 0x7F92 }; + +UIScrollBox::UIScrollBox(BladeRunnerEngine *vm, UIScrollBoxCallback *lineSelectedCallback, void *callbackData, int maxLineCount, int style, bool center, Common::Rect rect, Common::Rect scrollBarRect) : UIComponent(vm) { + _selectedLineState = 0; + _scrollUpButtonState = 0; + _scrollDownButtonState = 0; + _scrollAreaUpState = 0; + _scrollAreaDownState = 0; + _scrollBarState = 0; + + _scrollUpButtonHover = false; + _scrollDownButtonHover = false; + _scrollAreaUpHover = false; + _scrollAreaDownHover = false; + _scrollBarHover = false; + + _hoveredLine = -1; + _selectedLineIndex = -1; + + _lineSelectedCallback = lineSelectedCallback; + _callbackData = callbackData; + + _isVisible = false; + _style = style; + _center = center; + _timeLastScroll = _vm->getTotalPlayTime(); + _timeLastCheckbox = _vm->getTotalPlayTime(); + _timeLastHighlight = _vm->getTotalPlayTime(); + + _highlightFrame = 0; + + _rect = rect; + _scrollBarRect = scrollBarRect; + + _lineCount = 0; + _maxLineCount = maxLineCount; + + _firstLineVisible = 0; + + _maxLinesVisible = _rect.height() / kLineHeight; + _rect.bottom = _rect.top + kLineHeight * _maxLinesVisible - 1; + + _lines.resize(_maxLineCount); + for (int i = 0; i < _maxLineCount; ++i) { + _lines[i] = new Line(); + _lines[i]->lineData = -1; + _lines[i]->flags = 0x00; + _lines[i]->checkboxFrame = 5; + } +} + +UIScrollBox::~UIScrollBox() { + for (int i = 0; i < _maxLineCount; ++i) { + delete _lines[i]; + } +} + +void UIScrollBox::show() { + _selectedLineState = 0; + _scrollUpButtonState = 0; + _scrollDownButtonState = 0; + _scrollAreaUpState = 0; + _scrollAreaDownState = 0; + _scrollBarState = 0; + + _hoveredLine = -1; + _selectedLineIndex = -1; + + _scrollUpButtonHover = false; + _scrollDownButtonHover = false; + _scrollAreaUpHover = false; + _scrollAreaDownHover = false; + _scrollBarHover = false; + + _timeLastScroll = _vm->getTotalPlayTime(); + _timeLastCheckbox = _vm->getTotalPlayTime(); + _timeLastHighlight = _vm->getTotalPlayTime(); + + _highlightFrame = 0; + _isVisible = true; +} + +void UIScrollBox::hide() { + _isVisible = false; +} + +void UIScrollBox::clearLines(){ + _lineCount = 0; + _firstLineVisible = 0; + +} + +void UIScrollBox::addLine(const Common::String &text, int lineData, int flags) { + _lines[_lineCount]->text = text; + _lines[_lineCount]->lineData = lineData; + _lines[_lineCount]->flags = flags; + + ++_lineCount; +} + +void UIScrollBox::addLine(const char *text, int lineData, int flags) { + _lines[_lineCount]->text = text; + _lines[_lineCount]->lineData = lineData; + _lines[_lineCount]->flags = flags; + + ++_lineCount; +} + +void UIScrollBox::sortLines() { + qsort(_lines.data(), _lineCount, sizeof(Line *), &sortFunction); +} + +void UIScrollBox::handleMouseMove(int mouseX, int mouseY) { + if (!_isVisible) { + return; + } + + if (_rect.contains(mouseX, mouseY)) { + int newHoveredLine = (mouseY - _rect.top) / 10 + _firstLineVisible; + if (newHoveredLine >= _lineCount) { + newHoveredLine = -1; + } + + if (newHoveredLine != _hoveredLine && newHoveredLine >= 0 && newHoveredLine < _lineCount) { + if (_lines[newHoveredLine]->lineData >= 0 && _selectedLineState == 0) { + int soundId = 507; + if (_lines[newHoveredLine]->flags & 0x01 ) { + soundId = 508; + } + _vm->_audioPlayer->playAud(_vm->_gameInfo->getSfxTrack(soundId), 100, 0, 0, 50, 0); + } + } + _hoveredLine = newHoveredLine; + } else { + _hoveredLine = -1; + } + + _scrollUpButtonHover = + (mouseX >= _scrollBarRect.left) + && (mouseX < _scrollBarRect.left + 15) + && (mouseY >= _scrollBarRect.top) + && (mouseY < _scrollBarRect.top + 8); + + _scrollDownButtonHover = + (mouseX >= _scrollBarRect.left) + && (mouseX < _scrollBarRect.left + 15) + && (mouseY > _scrollBarRect.bottom - 8) + && (mouseY <= _scrollBarRect.bottom); + + int scrollAreaHeight = _scrollBarRect.bottom - _scrollBarRect.top - 15; + + int scrollBarHeight = scrollAreaHeight; + if (_lineCount > _maxLinesVisible) { + scrollBarHeight = _maxLinesVisible * scrollAreaHeight / _lineCount; + } + if (scrollBarHeight < 16) { + scrollBarHeight = 16; + } + + int scrollAreaEmptySize = scrollAreaHeight - scrollBarHeight; + + int scrollBarY = 0; + if (_lineCount > _maxLinesVisible) { + scrollBarY = scrollAreaEmptySize * _firstLineVisible / (_lineCount - _maxLinesVisible); + } + + if (_scrollBarState == 2) { + int v12 = scrollBarHeight / 2 + 8; + if (mouseY - _scrollBarRect.top > v12 && _lineCount > _maxLinesVisible && scrollAreaEmptySize > 0) { + _firstLineVisible = (_lineCount - _maxLinesVisible) * (mouseY - _scrollBarRect.top - v12) / scrollAreaEmptySize; + if (_firstLineVisible > _lineCount - _maxLinesVisible) { + _firstLineVisible = _lineCount - _maxLinesVisible; + } + } else { + _firstLineVisible = 0; + } + + if (_lineCount <= _maxLinesVisible) { + scrollBarY = 0; + } else { + scrollBarY = scrollAreaEmptySize * _firstLineVisible/ (_lineCount - _maxLinesVisible); + } + } + scrollBarY = scrollBarY + _scrollBarRect.top + 8; + + _scrollBarHover = + (mouseX >= _scrollBarRect.left) + && (mouseX < _scrollBarRect.left + 15) + && (mouseY >= scrollBarY) + && (mouseY < scrollBarY + scrollBarHeight); + + _scrollAreaUpHover = + (mouseX >= _scrollBarRect.left) + && (mouseX < _scrollBarRect.left + 15) + && (mouseY >= _scrollBarRect.top + 8) + && (mouseY < scrollBarY); + + _scrollAreaDownHover = + (mouseX >= _scrollBarRect.left) + && (mouseX < _scrollBarRect.left + 15) + && (mouseY >= scrollBarY + scrollBarHeight) + && (mouseY < _scrollBarRect.bottom - 8); +} + +void UIScrollBox::handleMouseDown(bool alternateButton) { + if (!_isVisible) { + return; + } + + _mouseButton = alternateButton; + if (_hoveredLine == -1) { + _selectedLineState = 1; + } else if (_selectedLineIndex == -1) { + _selectedLineIndex = _hoveredLine; + _selectedLineState = 2; + if (_hoveredLine < _lineCount) { + if (_lineSelectedCallback) { + _lineSelectedCallback(_callbackData, this, _lines[_selectedLineIndex]->lineData, _mouseButton); + } + + if (_lines[_selectedLineIndex]->flags & 0x01) { + _vm->_audioPlayer->playAud(_vm->_gameInfo->getSfxTrack(509), 100, 0, 0, 50, 0); + } + } + } + if (!alternateButton) { + if (_scrollUpButtonHover) { + _scrollUpButtonState = 2; + _timeLastScroll = _vm->getTotalPlayTime() - 160; + } else { + _scrollUpButtonState = 1; + } + if (_scrollDownButtonHover) { + _scrollDownButtonState = 2; + } else { + _scrollDownButtonState = 1; + } + if (_scrollBarHover) { + _scrollBarState = 2; + } else { + _scrollBarState = 1; + } + if (_scrollAreaUpHover) { + _scrollAreaUpState = 2; + _timeLastScroll = _vm->getTotalPlayTime() - 160; + } else { + _scrollAreaUpState = 1; + } + if (_scrollAreaDownHover) { + _scrollAreaDownState = 2; + _timeLastScroll = _vm->getTotalPlayTime() - 160; + } else { + _scrollAreaDownState = 1; + } + } +} + +void UIScrollBox::handleMouseUp(bool alternateButton) { + if (_isVisible) { + if ( alternateButton == _mouseButton) { + _selectedLineState = 0; + _selectedLineIndex = -1; + } + + if (!alternateButton) { + _scrollUpButtonState = 0; + _scrollDownButtonState = 0; + _scrollAreaUpState = 0; + _scrollAreaDownState = 0; + _scrollBarState = 0; + } + } +} + +int UIScrollBox::getSelectedLineData() { + if (_hoveredLine >= 0 && _selectedLineState != 1 && _hoveredLine < _lineCount) { + return _lines[_hoveredLine]->lineData; + } + return -1; +} + +void UIScrollBox::draw(Graphics::Surface &surface) { + int timeNow = _vm->getTotalPlayTime(); + + // update scrolling + if (_scrollUpButtonState == 2 && _scrollUpButtonHover) { + if ((timeNow - _timeLastScroll) > 160) { + scrollUp(); + _timeLastScroll = timeNow; + } + } else if (_scrollDownButtonState == 2 && _scrollDownButtonHover) { + if ((timeNow - _timeLastScroll) > 160) { + scrollDown(); + _timeLastScroll = timeNow; + } + } else if (_scrollAreaUpState == 2 && _scrollAreaUpHover) { + if ((timeNow - _timeLastScroll) > 160) { + _firstLineVisible -= _maxLinesVisible - 1; + _firstLineVisible = CLIP(_firstLineVisible, 0, _lineCount - _maxLinesVisible); + _timeLastScroll = timeNow; + } + } else if (_scrollAreaDownState == 2 && _scrollAreaDownHover) { + if ((timeNow - _timeLastScroll) > 160) { + _firstLineVisible += _maxLinesVisible - 1; + _firstLineVisible = CLIP(_firstLineVisible, 0, _lineCount - _maxLinesVisible); + _timeLastScroll = timeNow; + } + } + + // update checkboxes + int timeDiffCheckBox = timeNow - _timeLastCheckbox; + if (timeDiffCheckBox > 67) { + _timeLastCheckbox = timeNow; + for (int i = 0; i < _lineCount; ++i) { + if (_lines[i]->flags & 0x01) { // has checkbox + if (_lines[i]->flags & 0x02) { // checkbox checked + if (_lines[i]->checkboxFrame < 5) { + _lines[i]->checkboxFrame += timeDiffCheckBox / 67; + } + if (_lines[i]->checkboxFrame > 5) { + _lines[i]->checkboxFrame = 5; + } + } else { // checkbox not checked + if (_lines[i]->checkboxFrame > 0) { + _lines[i]->checkboxFrame -= timeDiffCheckBox / 67; + } + if (_lines[i]->checkboxFrame < 0) { + _lines[i]->checkboxFrame = 0; + } + } + } + } + } + + + // update highlight + if ((timeNow - _timeLastHighlight) > 67) { + _timeLastHighlight = timeNow; + _highlightFrame = (_highlightFrame + 1) % 8; + } + + // draw text lines + int linesVisible = 0; + int lastLineVisible = 0; + + if (_maxLinesVisible < _lineCount - _firstLineVisible) { + linesVisible = _maxLinesVisible; + lastLineVisible = _firstLineVisible + _maxLinesVisible; + } else { + linesVisible = _lineCount - _firstLineVisible; + lastLineVisible = _lineCount; + } + + if (_firstLineVisible < lastLineVisible) { + int y = _rect.top; + int y1 = _rect.top + 8; + int y2 = _rect.top + 2; + int i = _firstLineVisible; + do { + int startingColorIndex = 3; + if (i - _firstLineVisible < 3) { + startingColorIndex = i - _firstLineVisible; + } + + int endingColorIndex = 3; + if (i - _firstLineVisible >= linesVisible - 3) { + endingColorIndex = linesVisible - (i - _firstLineVisible + 1); + } + + int colorIndex = endingColorIndex; + if (startingColorIndex < endingColorIndex) { + colorIndex = startingColorIndex; + } + + bool v35 = false; + int color = 0; + + if ((((_selectedLineState == 0 && i == _hoveredLine) || (_selectedLineState == 2 && i == _selectedLineIndex && _selectedLineIndex == _hoveredLine)) && _lines[i]->lineData != -1) || _lines[i]->flags & 0x04) { + v35 = true; + if (_style) { + color = kTextColors2[colorIndex]; + } else { + color = kTextColors3[colorIndex]; + } + } + else { + if (_style) { + color = kTextColors1[colorIndex]; + } else { + color = kTextColors4[colorIndex]; + } + } + + int x = _rect.left; + + if (_lines[i]->flags & 0x01) { // has checkbox + int checkboxShapeId = 0; + if (_style == 0) { + if (_lines[i]->checkboxFrame || v35) { + if (_lines[i]->checkboxFrame != 5 || v35) { + checkboxShapeId = _lines[i]->checkboxFrame + 62; + } else { + checkboxShapeId = 61; + } + } else { + checkboxShapeId = 60; + } + } else if (_lines[i]->checkboxFrame || v35) { + if (_lines[i]->checkboxFrame != 5 || v35) { + checkboxShapeId = _lines[i]->checkboxFrame + 54; + } else { + checkboxShapeId = 53; + } + } else { + checkboxShapeId = 52; + } + _vm->_kia->_shapes->get(checkboxShapeId)->draw(surface, x - 1, y); + x += 11; + } + + if (_lines[i]->flags & 0x10) { // highlighted line + if (_lines[i]->flags & 0x20) { + int highlightShapeId = _highlightFrame; + if (highlightShapeId > 4) { + highlightShapeId = 8 - highlightShapeId; + } + _vm->_kia->_shapes->get(highlightShapeId + 85)->draw(surface, x, y2); + } + x += 6; + } + + if (_lines[i]->flags & 0x08) { // has background rectangle + int colorBackground = 0; + if (_style) { + colorBackground = kTextBackgroundColors[colorIndex]; + } else { + colorBackground = 0x28E4; + } + surface.fillRect(Common::Rect(x, y, _rect.right + 1, y1 + 1), colorBackground); + } + + if (_center) { + x = (_rect.width() - _vm->_mainFont->getTextWidth(_lines[i]->text)) / 2; + } + + _vm->_mainFont->drawColor(_lines[i]->text, surface, x, y, color); + + y1 += kLineHeight; + y2 += kLineHeight; + y += kLineHeight; + ++i; + } + while (i < lastLineVisible); + } + + // draw scroll up button + int scrollUpButtonShapeId = 0; + if (_scrollUpButtonState) { + if (_scrollUpButtonState == 2) { + if (_scrollUpButtonHover) { + scrollUpButtonShapeId = 72; + } else { + scrollUpButtonShapeId = 71; + } + } else { + scrollUpButtonShapeId = 70; + } + } else if (_scrollUpButtonHover) { + scrollUpButtonShapeId = 71; + } else { + scrollUpButtonShapeId = 70; + } + _vm->_kia->_shapes->get(scrollUpButtonShapeId)->draw(surface, _scrollBarRect.left, _scrollBarRect.top); + + // draw scroll down button + int scrollDownButtonShapeId = 0; + if (_scrollDownButtonState) { + if (_scrollDownButtonState == 2) { + if (_scrollDownButtonHover) { + scrollDownButtonShapeId = 75; + } else { + scrollDownButtonShapeId = 74; + } + } else { + scrollDownButtonShapeId = 73; + } + } else if (_scrollDownButtonHover) { + scrollDownButtonShapeId = 74; + } else { + scrollDownButtonShapeId = 73; + } + _vm->_kia->_shapes->get(scrollDownButtonShapeId)->draw(surface, _scrollBarRect.left, _scrollBarRect.bottom - 7); + + int scrollAreaSize = _scrollBarRect.bottom - (_scrollBarRect.top + 15); + int scrollBarHeight = 0; + if (_lineCount <= _maxLinesVisible) { + scrollBarHeight = _scrollBarRect.bottom - (_scrollBarRect.top + 15); + } else { + scrollBarHeight = _maxLinesVisible * scrollAreaSize / _lineCount; + } + scrollBarHeight = MAX(scrollBarHeight, 16); + + int v56 = 0; + if (_lineCount <= _maxLinesVisible) { + v56 = 0; + } else { + v56 = _firstLineVisible * (scrollAreaSize - scrollBarHeight) / (_lineCount - _maxLinesVisible); + } + + int v58 = v56 + _scrollBarRect.top + 8; + + if (_scrollBarState == 2) { + draw3DFrame(surface, Common::Rect(_scrollBarRect.left, v58, _scrollBarRect.left + 15, v58 + scrollBarHeight), 1, 1); + } else if (!_scrollBarState && _scrollBarHover) { + draw3DFrame(surface, Common::Rect(_scrollBarRect.left, v56 + _scrollBarRect.top + 8, _scrollBarRect.left + 15, v58 + scrollBarHeight), 0, 1); + } else { + draw3DFrame(surface, Common::Rect(_scrollBarRect.left, v58, _scrollBarRect.left + 15, v58 + scrollBarHeight), 0, 0); + } +} + +void UIScrollBox::checkAll() { + for (int i = 0; i < _lineCount; ++i) { + if (_lines[i]->flags & 0x01) { + _lines[i]->flags |= 0x02; + } + } +} + +void UIScrollBox::uncheckAll() { + for (int i = 0; i < _lineCount; ++i) { + if (_lines[i]->flags & 0x01) { + _lines[i]->flags &= ~0x02; + } + } +} + +void UIScrollBox::toggleCheckBox(int lineData) { + int i = findLine(lineData); + if (i != -1) { + if (_lines[i]->flags & 0x02) { + _lines[i]->flags &= ~0x02; + } else { + _lines[i]->flags |= 0x02; + } + } +} + +bool UIScrollBox::hasLine(int lineData) { + return findLine(lineData) != -1; +} + +void UIScrollBox::resetHighlight(int lineData) { + int i = findLine(lineData); + if (i != -1) { + _lines[i]->flags &= ~0x20; + } +} + +void UIScrollBox::setFlags(int lineData, int flags) { + int i = findLine(lineData); + if (i != -1) { + _lines[i]->flags |= flags; + } +} + +void UIScrollBox::resetFlags(int lineData, int flags) { + int i = findLine(lineData); + if (i != -1) { + _lines[i]->flags &= ~flags; + } +} + +int UIScrollBox::sortFunction(const void *item1, const void *item2) { + Line *line1 = *(Line * const *)item1; + Line *line2 = *(Line * const *)item2; + return line1->text.compareToIgnoreCase(line2->text); +} + +void UIScrollBox::draw3DFrame(Graphics::Surface &surface, Common::Rect rect, bool pressed, int style) { + int color1, color2; + + if (pressed) { + color1 = k3DFrameColors[style + 6]; + color2 = k3DFrameColors[style + 4]; + } else { + color1 = k3DFrameColors[style + 4]; + color2 = k3DFrameColors[style + 6]; + } + + int fillColor = k3DFrameColors[style + 2]; + + surface.fillRect(Common::Rect(rect.left + 1, rect.top + 1, rect.right - 1, rect.bottom - 1), fillColor); + + surface.hLine(rect.left + 1, rect.top, rect.right - 2, color1); + surface.hLine(rect.left + 1, rect.bottom - 1, rect.right - 2, color2); + surface.vLine(rect.left, rect.top, rect.bottom - 2, color1); + surface.vLine(rect.right - 1, rect.top + 1, rect.bottom - 1, color2); + surface.hLine(rect.right - 1, rect.top, rect.right - 1, k3DFrameColors[style]); + surface.hLine(rect.left, rect.bottom - 1, rect.left, k3DFrameColors[style]); +} + +void UIScrollBox::scrollUp() { + if (_firstLineVisible > 0) { + --_firstLineVisible; + } +} + +void UIScrollBox::scrollDown() { + if (_lineCount - _firstLineVisible > _maxLinesVisible) { + ++_firstLineVisible; + } +} + +int UIScrollBox::findLine(int lineData) { + for (int i = 0; i < _lineCount; ++i) { + if (_lines[i]->lineData == lineData) { + return i; + } + } + return -1; +} + +} // End of namespace BladeRunner diff --git a/engines/bladerunner/ui/ui_scroll_box.h b/engines/bladerunner/ui/ui_scroll_box.h new file mode 100644 index 0000000000..1f416baffc --- /dev/null +++ b/engines/bladerunner/ui/ui_scroll_box.h @@ -0,0 +1,137 @@ +/* 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 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 BLADERUNNER_UI_SCROLLBOX_H +#define BLADERUNNER_UI_SCROLLBOX_H + +#include "bladerunner/ui/ui_component.h" + +#include "common/array.h" +#include "common/rect.h" +#include "common/str.h" + +namespace BladeRunner { + +typedef void UIScrollBoxCallback(void *callbackData, void *source, int lineData, int mouseButton); + +class UIScrollBox : public UIComponent +{ +private: + static const int kLineHeight = 10; + static const int k3DFrameColors[]; + static const int kTextBackgroundColors[]; + static const int kTextColors1[]; + static const int kTextColors2[]; + static const int kTextColors3[]; + static const int kTextColors4[]; + + struct Line { + Common::String text; + int lineData; + int flags; + int checkboxFrame; + }; + + int _selectedLineState; + int _scrollUpButtonState; + int _scrollDownButtonState; + int _scrollAreaUpState; + int _scrollAreaDownState; + int _scrollBarState; + + int _hoveredLine; + int _selectedLineIndex; + + bool _scrollUpButtonHover; + bool _scrollDownButtonHover; + bool _scrollAreaUpHover; + bool _scrollAreaDownHover; + bool _scrollBarHover; + + bool _mouseButton; + + UIScrollBoxCallback *_lineSelectedCallback; + void *_callbackData; + + bool _isVisible; + int _style; + bool _center; + + int _timeLastScroll; + int _timeLastCheckbox; + int _timeLastHighlight; + + int _highlightFrame; + + Common::Rect _rect; + Common::Rect _scrollBarRect; + + int _lineCount; + int _maxLineCount; + Common::Array<Line *> _lines; + int _maxLinesVisible; + int _firstLineVisible; + +public: + UIScrollBox(BladeRunnerEngine *vm, UIScrollBoxCallback *lineSelectedCallback, void *callbackData, int maxLineCount, int style, bool center, Common::Rect rect,Common::Rect scrollBarRect); + ~UIScrollBox(); + + void draw(Graphics::Surface &surface); + + void handleMouseMove(int mouseX, int mouseY); + void handleMouseDown(bool alternateButton); + void handleMouseUp(bool alternateButton); + + void show(); + void hide(); + + void clearLines(); + void addLine(const Common::String &text, int lineData, int flags); + void addLine(const char *text, int lineData, int flags); + void sortLines(); + + int getSelectedLineData(); + + void checkAll(); + void uncheckAll(); + void toggleCheckBox(int lineData); + + bool hasLine(int lineData); + + void resetHighlight(int lineData); + void setFlags(int lineData, int flags); + void resetFlags(int lineData, int flags); + +private: + static int sortFunction(const void *line1, const void *line2); + + void draw3DFrame(Graphics::Surface &surface, Common::Rect rect, bool pressed, int style); + + void scrollUp(); + void scrollDown(); + + int findLine(int lineData); +}; + +} // End of namespace BladeRunner + +#endif diff --git a/engines/bladerunner/ui/ui_slider.cpp b/engines/bladerunner/ui/ui_slider.cpp new file mode 100644 index 0000000000..d25b7fac2c --- /dev/null +++ b/engines/bladerunner/ui/ui_slider.cpp @@ -0,0 +1,153 @@ +/* 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 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 "bladerunner/ui/ui_slider.h" + +#include "bladerunner/audio_player.h" +#include "bladerunner/bladerunner.h" +#include "bladerunner/game_info.h" + +namespace BladeRunner { + +const uint16 UISlider::kColors[] = { 0x0000, 0x0821, 0x1061, 0x1C82, 0x24C2, 0x2CE3, 0x3524, 0x4145, 0x4586, 0x4DC7, 0x5609, 0x5E4B, 0x668C, 0x6EEE, 0x7730, 0x7B92 }; + +UISlider::UISlider(BladeRunnerEngine *vm, UIComponentCallback *valueChangedCallback, void *callbackData, Common::Rect rect, int maxValue, int value) + : UIComponent(vm) { + + _valueChangedCallback = valueChangedCallback; + _callbackData = callbackData; + + _maxValue = MAX(0, maxValue); + _value = CLIP(value, 0, _maxValue - 1); + + _rect = rect; + _isEnabled = true; + _currentFrameColor = 0; + _hasFocus = false; + _pressedStatus = 0; +} + +void UISlider::draw(Graphics::Surface &surface) { + if (_rect.isEmpty()) { + return; + } + + int frameColor; + if (_pressedStatus == 1) { + frameColor = 10; + } else if (_hasFocus && _pressedStatus != 2 && _isEnabled) { + frameColor = 5; + } else { + frameColor = 0; + } + + if (_currentFrameColor < frameColor) { + ++_currentFrameColor; + } + + if (_currentFrameColor > frameColor) { + --_currentFrameColor; + } + + surface.frameRect(_rect, kColors[_currentFrameColor]); + + int sliderX = 0; + if (_maxValue <= 1) { + sliderX = _rect.left; + } else { + sliderX = _rect.left + ((_value * _rect.width()) / (_maxValue - 1)); + } + + if (_pressedStatus == 1) { + int sliderValue = ((_maxValue - 1) * (_mouseX - _rect.left)) / _rect.width(); + sliderX = _rect.left + ((sliderValue * _rect.width()) / (_maxValue - 1)); + sliderX = CLIP(sliderX, (int)_rect.left, (int)_rect.right); + } + + if (_rect.left + 1 < _rect.right - 1) { + int striding = _rect.left + sliderX; + for (int x = _rect.left + 1; x < _rect.right - 1; x++) { + int colorIndex = 15 - (abs(sliderX - x) >> 2); + + if (!_isEnabled) { + colorIndex /= 2; + } + + if (colorIndex < 3) { + colorIndex = 3; + } + + uint16 color = kColors[colorIndex]; + if ((striding + x) & 1 || x == sliderX) { + color = 0; + } + + surface.vLine(x, _rect.top + 1, _rect.bottom - 2, color); + } + } +} + +void UISlider::handleMouseMove(int mouseX, int mouseY) { + _mouseX = mouseX; + if (_rect.contains(mouseX, mouseY)) { + if (!_hasFocus && _isEnabled && _pressedStatus == 0) { + _vm->_audioPlayer->playAud(_vm->_gameInfo->getSfxTrack(508), 100, 0, 0, 50, 0); + } + _hasFocus = true; + } else { + _hasFocus = false; + } +} + +void UISlider::handleMouseDown(bool alternateButton) { + if (_isEnabled && !alternateButton) { + if (_hasFocus) { + _pressedStatus = 1; + } else { + _pressedStatus = 2; + } + } +} + +void UISlider::handleMouseUp(bool alternateButton) { + if (!alternateButton) { + if (_pressedStatus == 1) { + if (_rect.width() == 0) { + _value = 0; + } else { + _value = ((_maxValue - 1) * (_mouseX - _rect.left)) / _rect.width(); + } + _value = CLIP(_value, 0, _maxValue - 1); + + if (_valueChangedCallback) { + _valueChangedCallback(_callbackData, this); + } + } + _pressedStatus = 0; + } +} + +void UISlider::setValue(int value) { + _value = CLIP(value, 0, _maxValue - 1); +} + +} // End of namespace BladeRunner diff --git a/engines/bladerunner/ui/ui_slider.h b/engines/bladerunner/ui/ui_slider.h new file mode 100644 index 0000000000..7cbd5bfda7 --- /dev/null +++ b/engines/bladerunner/ui/ui_slider.h @@ -0,0 +1,63 @@ +/* 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 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 BLADERUNNER_UI_SLIDER_H +#define BLADERUNNER_UI_SLIDER_H + +#include "bladerunner/ui/ui_component.h" + +#include "common/rect.h" + +namespace BladeRunner { + +class UISlider : public UIComponent +{ +private: + static const uint16 kColors[]; + + UIComponentCallback *_valueChangedCallback; + void *_callbackData; + bool _isEnabled; + int _maxValue; + Common::Rect _rect; + int _currentFrameColor; + bool _hasFocus; + int _pressedStatus; + int _mouseX; + +public: + int _value; + + UISlider(BladeRunnerEngine *vm, UIComponentCallback *valueChangedCallback, void *callbackData, Common::Rect rect, int maxValue, int value); + + void draw(Graphics::Surface &surface); + + void handleMouseMove(int mouseX, int mouseY); + void handleMouseDown(bool alternateButton); + void handleMouseUp(bool alternateButton); + + void setValue(int value); +}; + +} // End of namespace BladeRunner + +#endif |