aboutsummaryrefslogtreecommitdiff
path: root/engines/avalanche/timer.cpp
diff options
context:
space:
mode:
Diffstat (limited to 'engines/avalanche/timer.cpp')
-rw-r--r--engines/avalanche/timer.cpp684
1 files changed, 684 insertions, 0 deletions
diff --git a/engines/avalanche/timer.cpp b/engines/avalanche/timer.cpp
new file mode 100644
index 0000000000..2656aeaa84
--- /dev/null
+++ b/engines/avalanche/timer.cpp
@@ -0,0 +1,684 @@
+/* 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.
+ *
+ */
+
+/*
+ * This code is based on the original source code of Lord Avalot d'Argent version 1.3.
+ * Copyright (c) 1994-1995 Mike, Mark and Thomas Thurman.
+ */
+
+/* Original name: TIMEOUT The scheduling unit. */
+
+#include "avalanche/avalanche.h"
+
+#include "avalanche/timer.h"
+#include "avalanche/visa2.h"
+#include "avalanche/lucerna2.h"
+#include "avalanche/animation.h"
+#include "avalanche/scrolls2.h"
+#include "avalanche/acci2.h"
+#include "avalanche/sequence2.h"
+#include "avalanche/enid2.h"
+#include "avalanche/pingo2.h"
+
+#include "common/textconsole.h"
+
+namespace Avalanche {
+
+Timer::Timer(AvalancheEngine *vm) {
+ _vm = vm;
+
+ for (byte i = 0; i < 7; i++) {
+ _times[i]._timeLeft = 0;
+ _times[i]._action = 0;
+ _times[i]._reason = 0;
+ }
+ _timerLost = false;
+}
+
+/**
+ * Add a nex timer
+ * @remarks Originally called 'set_up_timer'
+ */
+void Timer::addTimer(int32 duration, byte action, byte reason) {
+ if ((_vm->_gyro->isLoaded == false) || (_timerLost == true)) {
+ byte i = 0;
+ while ((i < 7) && (_times[i]._timeLeft != 0))
+ i++;
+
+ if (i == 7)
+ return; // Oh dear... No timer left
+
+ // Everything's OK here!
+ _times[i]._timeLeft = duration;
+ _times[i]._action = action;
+ _times[i]._reason = reason;
+ } else {
+ _vm->_gyro->isLoaded = false;
+ return;
+ }
+}
+
+/**
+ * Update the timers
+ * @remarks Originally called 'one_tick'
+ */
+void Timer::updateTimer() {
+ if (_vm->_gyro->_dropdownActive)
+ return;
+
+ for (byte i = 0; i < 7; i++) {
+ if (_times[i]._timeLeft <= 0)
+ continue;
+
+ _times[i]._timeLeft--;
+
+ if (_times[i]._timeLeft == 0) {
+ switch (_times[i]._action) {
+ case kProcOpenDrawbridge :
+ openDrawbridge();
+ break;
+ case kProcAvariciusTalks :
+ avariciusTalks();
+ break;
+ case kProcUrinate :
+ urinate();
+ break;
+ case kProcToilet :
+ toilet();
+ break;
+ case kProcBang:
+ bang();
+ break;
+ case kProcBang2:
+ bang2();
+ break;
+ case kProcStairs:
+ stairs();
+ break;
+ case kProcCardiffSurvey:
+ cardiffSurvey();
+ break;
+ case kProcCardiffReturn:
+ cardiffReturn();
+ break;
+ case kProcCwytalotInHerts:
+ cwytalotInHerts();
+ break;
+ case kProcGetTiedUp:
+ getTiedUp();
+ break;
+ case kProcGetTiedUp2:
+ getTiedUp2();
+ break;
+ case kProcHangAround:
+ hangAround();
+ break;
+ case kProcHangAround2:
+ hangAround2();
+ break;
+ case kProcAfterTheShootemup:
+ afterTheShootemup();
+ break;
+ case kProcJacquesWakesUp:
+ jacquesWakesUp();
+ break;
+ case kProcNaughtyDuke:
+ naughtyDuke();
+ break;
+ case kProcNaughtyDuke2:
+ naughtyDuke2();
+ break;
+ case kProcNaughtyDuke3:
+ naughtyDuke3();
+ break;
+ case kProcJump:
+ jump();
+ break;
+ case kProcSequence:
+ _vm->_sequence->callSequencer();
+ break;
+ case kProcCrapulusSpludOut:
+ crapulusSaysSpludOut();
+ break;
+ case kProcDawnDelay:
+ _vm->_lucerna->dawn();
+ break;
+ case kProcBuyDrinks:
+ buyDrinks();
+ break;
+ case kProcBuyWine:
+ buyWine();
+ break;
+ case kProcCallsGuards:
+ callsGuards();
+ break;
+ case kProcGreetsMonk:
+ greetsMonk();
+ break;
+ case kProcFallDownOubliette:
+ fallDownOubliette();
+ break;
+ case kProcMeetAvaroid:
+ meetAvaroid();
+ break;
+ case kProcRiseUpOubliette:
+ riseUpOubliette();
+ break;
+ case kProcRobinHoodAndGeida:
+ robinHoodAndGeida();
+ break;
+ case kProcRobinHoodAndGeidaTalk:
+ robinHoodAndGeidaTalk();
+ break;
+ case kProcAvalotReturns:
+ avalotReturns();
+ break;
+ case kProcAvvySitDown:
+ avvySitDown();
+ break;
+ case kProcGhostRoomPhew:
+ ghostRoomPhew();
+ break;
+ case kProcArkataShouts:
+ arkataShouts();
+ break;
+ case kProcWinning:
+ winning();
+ break;
+ case kProcAvalotFalls:
+ avalotFalls();
+ break;
+ case kProcSpludwickGoesToCauldron:
+ spludwickGoesToCauldron();
+ break;
+ case kProcSpludwickLeavesCauldron:
+ spludwickLeavesCauldron();
+ break;
+ case kProcGiveLuteToGeida:
+ giveLuteToGeida();
+ break;
+ }
+ }
+ }
+ _vm->_gyro->_roomTime++; // Cycles since you've been in this room.
+ _vm->_gyro->_dna._totalTime++; // Total amount of time for this game.
+}
+
+void Timer::loseTimer(byte which) {
+ for (byte i = 0; i < 7; i++) {
+ if (_times[i]._reason == which)
+ _times[i]._timeLeft = 0; // Cancel this one!
+ }
+
+ _timerLost = true;
+}
+
+void Timer::openDrawbridge() {
+ _vm->_gyro->_dna._drawbridgeOpen++;
+ _vm->_celer->drawBackgroundSprite(-1, -1, _vm->_gyro->_dna._drawbridgeOpen - 1);
+
+ if (_vm->_gyro->_dna._drawbridgeOpen == 4)
+ _vm->_gyro->_magics[1]._operation = _vm->_gyro->kMagicNothing; // You may enter the drawbridge.
+ else
+ addTimer(7, kProcOpenDrawbridge, kReasonDrawbridgeFalls);
+}
+
+void Timer::avariciusTalks() {
+ _vm->_visa->displayScrollChain('q', _vm->_gyro->_dna._avariciusTalk);
+ _vm->_gyro->_dna._avariciusTalk++;
+
+ if (_vm->_gyro->_dna._avariciusTalk < 17)
+ addTimer(177, kProcAvariciusTalks, kReasonAvariciusTalks);
+ else
+ _vm->_lucerna->incScore(3);
+}
+
+void Timer::urinate() {
+ _vm->_animation->tr[0].turn(Animation::kDirUp);
+ _vm->_animation->stopWalking();
+ _vm->_lucerna->drawDirection();
+ addTimer(14, kProcToilet, kReasonGoToToilet);
+}
+
+void Timer::toilet() {
+ _vm->_scrolls->displayText("That's better!");
+}
+
+void Timer::bang() {
+ _vm->_scrolls->displayText(Common::String(_vm->_scrolls->kControlItalic) + "< BANG! >");
+ addTimer(30, kProcBang2, kReasonExplosion);
+}
+
+void Timer::bang2() {
+ _vm->_scrolls->displayText("Hmm... sounds like Spludwick's up to something...");
+}
+
+void Timer::stairs() {
+ _vm->_gyro->blip();
+ _vm->_animation->tr[0].walkto(4);
+ _vm->_celer->drawBackgroundSprite(-1, -1, 2);
+ _vm->_gyro->_dna._brummieStairs = 2;
+ _vm->_gyro->_magics[10]._operation = _vm->_gyro->kMagicSpecial;
+ _vm->_gyro->_magics[10]._data = 2; // Reached the bottom of the stairs.
+ _vm->_gyro->_magics[3]._operation = _vm->_gyro->kMagicNothing; // Stop them hitting the sides (or the game will hang.)
+}
+
+void Timer::cardiffSurvey() {
+ if (_vm->_gyro->_dna._cardiffQuestionNum == 0) {
+ _vm->_gyro->_dna._cardiffQuestionNum++;
+ _vm->_visa->displayScrollChain('q', 27);
+ }
+
+ _vm->_visa->displayScrollChain('z', _vm->_gyro->_dna._cardiffQuestionNum);
+ _vm->_gyro->_interrogation = _vm->_gyro->_dna._cardiffQuestionNum;
+ addTimer(182, kProcCardiffSurvey, kReasonCardiffsurvey);
+}
+
+void Timer::cardiffReturn() {
+ _vm->_visa->displayScrollChain('q', 28);
+ cardiffSurvey(); // Add end of question.
+}
+
+void Timer::cwytalotInHerts() {
+ _vm->_visa->displayScrollChain('q', 29);
+}
+
+void Timer::getTiedUp() {
+ _vm->_visa->displayScrollChain('q', 34); // ...Trouble!
+ _vm->_gyro->_dna._userMovesAvvy = false;
+ _vm->_gyro->_dna._beenTiedUp = true;
+ _vm->_animation->stopWalking();
+ _vm->_animation->tr[1].stopWalk();
+ _vm->_animation->tr[1].stophoming();
+ _vm->_animation->tr[1]._callEachStepFl = true;
+ _vm->_animation->tr[1]._eachStepProc = _vm->_animation->kProcGrabAvvy;
+ addTimer(70, kProcGetTiedUp2, kReasonGettingTiedUp);
+}
+
+void Timer::getTiedUp2() {
+ _vm->_animation->tr[0].walkto(4);
+ _vm->_animation->tr[1].walkto(5);
+ _vm->_gyro->_magics[3]._operation = _vm->_gyro->kMagicNothing; // No effect when you touch the boundaries.
+ _vm->_gyro->_dna._friarWillTieYouUp = true;
+}
+
+void Timer::hangAround() {
+ _vm->_animation->tr[1]._doCheck = false;
+ _vm->_animation->tr[0].init(7, true, _vm->_animation); // Robin Hood
+ _vm->_gyro->_whereIs[_vm->_gyro->kPeopleRobinHood - 150] = r__robins;
+ _vm->_animation->apped(1, 2);
+ _vm->_visa->displayScrollChain('q', 39);
+ _vm->_animation->tr[0].walkto(7);
+ addTimer(55, kProcHangAround2, kReasonHangingAround);
+}
+
+void Timer::hangAround2() {
+ _vm->_visa->displayScrollChain('q', 40);
+ _vm->_animation->tr[1]._vanishIfStill = false;
+ _vm->_animation->tr[1].walkto(4);
+ _vm->_gyro->_whereIs[_vm->_gyro->kPeopleFriarTuck - 150] = r__robins;
+ _vm->_visa->displayScrollChain('q', 41);
+ _vm->_animation->tr[0].done();
+ _vm->_animation->tr[1].done(); // Get rid of Robin Hood and Friar Tuck.
+
+ addTimer(1, kProcAfterTheShootemup, kReasonHangingAround);
+ // Immediately call the following proc (when you have a chance).
+
+ _vm->_gyro->_dna._tiedUp = false;
+
+ _vm->_enid->backToBootstrap(1); // Call the shoot-'em-up.
+}
+
+void Timer::afterTheShootemup() {
+
+ _vm->_animation->fliproom(_vm->_gyro->_dna._room, 0);
+ // Only placed this here to replace the minigame. TODO: Remove it when the shoot em' up is implemented!
+
+ _vm->_animation->tr[0].init(0, true, _vm->_animation); // Avalot.
+ _vm->_animation->apped(1, 2);
+ _vm->_gyro->_dna._userMovesAvvy = true;
+ _vm->_gyro->_dna._objects[_vm->_gyro->kObjectCrossbow - 1] = true;
+ _vm->_lucerna->refreshObjectList();
+
+ // Same as the added line above: TODO: Remove it later!!!
+ _vm->_scrolls->displayText(Common::String("P.S.: There should have been the mini-game called \"shoot em' up\", but I haven't implemented it yet: you get the crossbow automatically.")
+ + _vm->_scrolls->kControlNewLine + _vm->_scrolls->kControlNewLine + "Peter (uruk)");
+
+#if 0
+ byte shootscore, gain;
+
+ shootscore = mem[storage_seg * storage_ofs];
+ gain = (shootscore + 5) / 10; // Rounding up.
+
+ display(string("\6Your score was ") + strf(shootscore) + '.' + "\r\rYou gain (" +
+ strf(shootscore) + " 0xF6 10) = " + strf(gain) + " points.");
+
+ if (gain > 20) {
+ display("But we won't let you have more than 20 points!");
+ points(20);
+ } else
+ points(gain);
+#endif
+
+ warning("STUB: Timer::after_the_shootemup()");
+
+ _vm->_visa->displayScrollChain('q', 70);
+}
+
+void Timer::jacquesWakesUp() {
+ _vm->_gyro->_dna._jacquesState++;
+
+ switch (_vm->_gyro->_dna._jacquesState) { // Additional pictures.
+ case 1 :
+ _vm->_celer->drawBackgroundSprite(-1, -1, 1); // Eyes open.
+ _vm->_visa->displayScrollChain('Q', 45);
+ break;
+ case 2 : // Going through the door.
+ _vm->_celer->drawBackgroundSprite(-1, -1, 2); // Not on the floor.
+ _vm->_celer->drawBackgroundSprite(-1, -1, 3); // But going through the door.
+ _vm->_gyro->_magics[5]._operation = _vm->_gyro->kMagicNothing; // You can't wake him up now.
+ break;
+ case 3 : // Gone through the door.
+ _vm->_celer->drawBackgroundSprite(-1, -1, 2); // Not on the floor, either.
+ _vm->_celer->drawBackgroundSprite(-1, -1, 4); // He's gone... so the door's open.
+ _vm->_gyro->_whereIs[_vm->_gyro->kPeopleJacques - 150] = 0; // Gone!
+ break;
+ }
+
+ if (_vm->_gyro->_dna._jacquesState == 5) {
+ _vm->_gyro->_dna._bellsAreRinging = true;
+ _vm->_gyro->_dna._aylesIsAwake = true;
+ _vm->_lucerna->incScore(2);
+ }
+
+ switch (_vm->_gyro->_dna._jacquesState) {
+ case 1:
+ case 2:
+ case 3:
+ addTimer(12, kProcJacquesWakesUp, kReasonJacquesWakingUp);
+ break;
+ case 4:
+ addTimer(24, kProcJacquesWakesUp, kReasonJacquesWakingUp);
+ break;
+ }
+}
+
+void Timer::naughtyDuke() { // This is when the Duke comes in and takes your money.
+ _vm->_animation->tr[1].init(9, false, _vm->_animation); // Here comes the Duke.
+ _vm->_animation->apped(2, 1); // He starts at the door...
+ _vm->_animation->tr[1].walkto(3); // He walks over to you.
+
+ // Let's get the door opening.
+ _vm->_celer->drawBackgroundSprite(-1, -1, 1);
+ _vm->_sequence->firstShow(2);
+ _vm->_sequence->startToClose();
+
+ addTimer(50, kProcNaughtyDuke2, kReasonNaughtyDuke);
+}
+
+void Timer::naughtyDuke2() {
+ _vm->_visa->displayScrollChain('q', 48); // "Ha ha, it worked again!"
+ _vm->_animation->tr[1].walkto(1); // Walk to the door.
+ _vm->_animation->tr[1]._vanishIfStill = true; // Then go away!
+ addTimer(32, kProcNaughtyDuke3, kReasonNaughtyDuke);
+}
+
+void Timer::naughtyDuke3() {
+ _vm->_celer->drawBackgroundSprite(-1, -1, 1);
+ _vm->_sequence->firstShow(2);
+ _vm->_sequence->startToClose();
+}
+
+void Timer::jump() {
+ _vm->_gyro->_dna._jumpStatus++;
+
+ switch (_vm->_gyro->_dna._jumpStatus) {
+ case 1:
+ case 2:
+ case 3:
+ case 5:
+ case 7:
+ case 9:
+ _vm->_animation->tr[0]._y--;
+ break;
+ case 12:
+ case 13:
+ case 14:
+ case 16:
+ case 18:
+ case 19:
+ _vm->_animation->tr[0]._y++;
+ break;
+ }
+
+ if (_vm->_gyro->_dna._jumpStatus == 20) { // End of jump.
+ _vm->_gyro->_dna._userMovesAvvy = true;
+ _vm->_gyro->_dna._jumpStatus = 0;
+ } else { // Still jumping.
+ addTimer(1, kProcJump, kReasonJumping);
+ }
+
+ if ((_vm->_gyro->_dna._jumpStatus == 10) // You're at the highest point of your jump.
+ && (_vm->_gyro->_dna._room == r__insidecardiffcastle)
+ && (_vm->_gyro->_dna._arrowInTheDoor == true)
+ && (_vm->_animation->infield(3))) { // Beside the wall
+ // Grab the arrow!
+ if (_vm->_gyro->_dna._carryNum >= kCarryLimit)
+ _vm->_scrolls->displayText("You fail to grab it, because your hands are full.");
+ else {
+ _vm->_celer->drawBackgroundSprite(-1, -1, 2);
+ _vm->_gyro->_dna._arrowInTheDoor = false; // You've got it.
+ _vm->_gyro->_dna._objects[_vm->_gyro->kObjectBolt - 1] = true;
+ _vm->_lucerna->refreshObjectList();
+ _vm->_visa->displayScrollChain('q', 50);
+ _vm->_lucerna->incScore(3);
+ }
+ }
+}
+
+void Timer::crapulusSaysSpludOut() {
+ _vm->_visa->displayScrollChain('q', 56);
+ _vm->_gyro->_dna._crapulusWillTell = false;
+}
+
+void Timer::buyDrinks() {
+ _vm->_celer->drawBackgroundSprite(-1, -1, 11); // Malagauche gets up again.
+ _vm->_gyro->_dna._malagauche = 0;
+
+ _vm->_visa->displayScrollChain('D', _vm->_gyro->_dna._drinking); // Display message about it.
+ _vm->_pingo->wobble(); // Do the special effects.
+ _vm->_visa->displayScrollChain('D', 1); // That'll be thruppence.
+ if (_vm->_gyro->decreaseMoney(3)) // Pay 3d.
+ _vm->_visa->displayScrollChain('D', 3); // Tell 'em you paid up.
+ _vm->_acci->drink();
+}
+
+void Timer::buyWine() {
+ _vm->_celer->drawBackgroundSprite(-1, -1, 11); // Malagauche gets up again.
+ _vm->_gyro->_dna._malagauche = 0;
+
+ _vm->_visa->displayScrollChain('D', 50); // You buy the wine.
+ _vm->_visa->displayScrollChain('D', 1); // It'll be thruppence.
+ if (_vm->_gyro->decreaseMoney(3)) {
+ _vm->_visa->displayScrollChain('D', 4); // You paid up.
+ _vm->_gyro->_dna._objects[_vm->_gyro->kObjectWine - 1] = true;
+ _vm->_lucerna->refreshObjectList();
+ _vm->_gyro->_dna._wineState = 1; // OK Wine.
+ }
+}
+
+void Timer::callsGuards() {
+ _vm->_visa->displayScrollChain('Q', 58); // "GUARDS!!!"
+ _vm->_lucerna->gameOver();
+}
+
+void Timer::greetsMonk() {
+ _vm->_visa->displayScrollChain('Q', 59);
+ _vm->_gyro->_dna._enteredLustiesRoomAsMonk = true;
+}
+
+void Timer::fallDownOubliette() {
+ _vm->_gyro->_magics[8]._operation = _vm->_gyro->kMagicNothing;
+ _vm->_animation->tr[0]._moveY++; // Increments dx/dy!
+ _vm->_animation->tr[0]._y += _vm->_animation->tr[0]._moveY; // Dowwwn we go...
+ addTimer(3, kProcFallDownOubliette, kReasonFallingDownOubliette);
+}
+
+void Timer::meetAvaroid() {
+ if (_vm->_gyro->_dna._metAvaroid) {
+ _vm->_scrolls->displayText(Common::String("You can't expect to be ") + _vm->_scrolls->kControlItalic + "that"
+ + _vm->_scrolls->kControlRoman + " lucky twice in a row!");
+ _vm->_lucerna->gameOver();
+ } else {
+ _vm->_visa->displayScrollChain('Q', 60);
+ _vm->_gyro->_dna._metAvaroid = true;
+ addTimer(1, kProcRiseUpOubliette, kReasonRisingUpOubliette);
+
+ _vm->_animation->tr[0]._facingDir = Animation::kDirLeft;
+ _vm->_animation->tr[0]._x = 151;
+ _vm->_animation->tr[0]._moveX = -3;
+ _vm->_animation->tr[0]._moveY = -5;
+
+ _vm->_gyro->setBackgroundColor(2);
+ }
+}
+
+void Timer::riseUpOubliette() {
+ _vm->_animation->tr[0]._visible = true;
+ _vm->_animation->tr[0]._moveY++; // Decrements dx/dy!
+ _vm->_animation->tr[0]._y -= _vm->_animation->tr[0]._moveY; // Uuuupppp we go...
+ if (_vm->_animation->tr[0]._moveY > 0)
+ addTimer(3, kProcRiseUpOubliette, kReasonRisingUpOubliette);
+ else
+ _vm->_gyro->_dna._userMovesAvvy = true;
+}
+
+void Timer::robinHoodAndGeida() {
+ _vm->_animation->tr[0].init(7, true, _vm->_animation);
+ _vm->_animation->apped(1, 7);
+ _vm->_animation->tr[0].walkto(6);
+ _vm->_animation->tr[1].stopWalk();
+ _vm->_animation->tr[1]._facingDir = Animation::kDirLeft;
+ addTimer(20, kProcRobinHoodAndGeidaTalk, kReasonRobinHoodAndGeida);
+ _vm->_gyro->_dna._geidaFollows = false;
+}
+
+void Timer::robinHoodAndGeidaTalk() {
+ _vm->_visa->displayScrollChain('q', 66);
+ _vm->_animation->tr[0].walkto(2);
+ _vm->_animation->tr[1].walkto(2);
+ _vm->_animation->tr[0]._vanishIfStill = true;
+ _vm->_animation->tr[1]._vanishIfStill = true;
+ addTimer(162, kProcAvalotReturns, kReasonRobinHoodAndGeida);
+}
+
+void Timer::avalotReturns() {
+ _vm->_animation->tr[0].done();
+ _vm->_animation->tr[1].done();
+ _vm->_animation->tr[0].init(0, true, _vm->_animation);
+ _vm->_animation->apped(1, 1);
+ _vm->_visa->displayScrollChain('q', 67);
+ _vm->_gyro->_dna._userMovesAvvy = true;
+}
+
+/**
+ * This is used when you sit down in the pub in Notts. It loops around
+ * so that it will happen when Avvy stops walking.
+ * @remarks Originally called 'avvy_sit_down'
+ */
+void Timer::avvySitDown() {
+ if (_vm->_animation->tr[0]._homing) // Still walking.
+ addTimer(1, kProcAvvySitDown, kReasonSittingDown);
+ else {
+ _vm->_celer->drawBackgroundSprite(-1, -1, 3);
+ _vm->_gyro->_dna._sittingInPub = true;
+ _vm->_gyro->_dna._userMovesAvvy = false;
+ _vm->_animation->tr[0]._visible = false;
+ }
+}
+
+void Timer::ghostRoomPhew() {
+ _vm->_scrolls->displayText(Common::String(_vm->_scrolls->kControlItalic) + "PHEW!" + _vm->_scrolls->kControlRoman
+ + " You're glad to get out of " + _vm->_scrolls->kControlItalic + "there!");
+}
+
+void Timer::arkataShouts() {
+ if (_vm->_gyro->_dna._teetotal)
+ return;
+
+ _vm->_visa->displayScrollChain('q', 76);
+ addTimer(160, kProcArkataShouts, kReasonArkataShouts);
+}
+
+void Timer::winning() {
+ _vm->_visa->displayScrollChain('q', 79);
+ _vm->_pingo->winningPic();
+
+ warning("STUB: Timer::winning()");
+#if 0
+ do {
+ _vm->_lucerna->checkclick();
+ } while (!(_vm->_gyro->mrelease == 0));
+#endif
+ // TODO: To be implemented with Pingo::winningPic().
+
+ _vm->_lucerna->callVerb(_vm->_acci->kVerbCodeScore);
+ _vm->_scrolls->displayText(" T H E E N D ");
+ _vm->_gyro->_letMeOut = true;
+}
+
+void Timer::avalotFalls() {
+ if (_vm->_animation->tr[0]._stepNum < 5) {
+ _vm->_animation->tr[0]._stepNum++;
+ addTimer(3, kProcAvalotFalls, kReasonFallingOver);
+ } else {
+ Common::String toDisplay;
+ for (byte i = 0; i < 6; i++)
+ toDisplay += _vm->_scrolls->kControlNewLine;
+ for (byte i = 0; i < 6; i++)
+ toDisplay += _vm->_scrolls->kControlInsertSpaces;
+ toDisplay = toDisplay + _vm->_scrolls->kControlRegister + 'Z' + _vm->_scrolls->kControlIcon;
+ _vm->_scrolls->displayText(toDisplay);
+ }
+}
+
+void Timer::spludwickGoesToCauldron() {
+ if (_vm->_animation->tr[1]._homing)
+ addTimer(1, kProcSpludwickGoesToCauldron, kReasonSpludWalk);
+ else
+ addTimer(17, kProcSpludwickLeavesCauldron, kReasonSpludWalk);
+}
+
+void Timer::spludwickLeavesCauldron() {
+ _vm->_animation->tr[1]._callEachStepFl = true; // So that normal procs will continue.
+}
+
+void Timer::giveLuteToGeida() { // Moved here from Acci.
+ _vm->_visa->displayScrollChain('Q', 86);
+ _vm->_lucerna->incScore(4);
+ _vm->_gyro->_dna._lustieIsAsleep = true;
+ _vm->_sequence->firstShow(5);
+ _vm->_sequence->thenShow(6); // He falls asleep...
+ _vm->_sequence->startToClose(); // Not really closing, but we're using the same procedure.
+}
+
+} // End of namespace Avalanche.
generated by cgit v1.2.3 (git 2.25.1) at 2024-11-20 10:55:18 +0000