madcow/scummvm-cursorfix
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases 1 Wiki Activity

Initial commit

Browse Source
This commit is contained in:
Leon Krieg
2026-02-02 04:50:13 +01:00
commit 5b11698731
22592 changed files with 7677434 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

311
engines/lastexpress/characters/demo/demo_abbot.cpp Normal file
View File

@@ -0,0 +1,311 @@
/* ScummVM - Graphic Adventure Engine
*
* ScummVM is the legal property of its developers, whose names
* are too numerous to list here. Please refer to the COPYRIGHT
* file distributed with this source distribution.
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <http://www.gnu.org/licenses/>.
*
*/
#include "lastexpress/lastexpress.h"
namespace LastExpress {
void LogicManager::CONS_DemoAbbot(int chapter) {
switch (chapter) {
case 0:
_engine->getMessageManager()->setMessageHandle(
kCharacterAbbot,
_functionsDemoAbbot[getCharacter(kCharacterAbbot).callbacks[getCharacter(kCharacterAbbot).currentCall]]
);
break;
case 1:
CONS_DemoAbbot_Birth(0, 0, 0, 0);
break;
case 2:
CONS_DemoAbbot_StartPart2(0, 0, 0, 0);
break;
case 3:
CONS_DemoAbbot_StartPart3(0, 0, 0, 0);
break;
case 4:
CONS_DemoAbbot_StartPart4(0, 0, 0, 0);
break;
case 5:
CONS_DemoAbbot_StartPart5(0, 0, 0, 0);
break;
default:
break;
}
}
void LogicManager::DemoAbbotCall(CALL_PARAMS) {
getCharacter(kCharacterAbbot).currentCall++;
(this->*functionPointer)(param1, param2, param3, param4);
}
void LogicManager::CONS_DemoAbbot_DoWait(CONS_PARAMS) {
CharacterCallParams *params = &getCharacter(kCharacterAbbot).callParams[getCharacter(kCharacterAbbot).currentCall];
_engine->getMessageManager()->setMessageHandle(kCharacterAbbot, &LogicManager::HAND_DemoAbbot_DoWait);
getCharacter(kCharacterAbbot).callbacks[getCharacter(kCharacterAbbot).currentCall] = 1;
params->clear();
params->parameters[0] = param1.intParam;
fedEx(kCharacterAbbot, kCharacterAbbot, 12, 0);
}
void LogicManager::HAND_DemoAbbot_DoWait(HAND_PARAMS) {
switch (msg->action) {
case 0:
if (getCharacterCurrentParams(kCharacterAbbot)[1]) {
if (getCharacterCurrentParams(kCharacterAbbot)[1] >= _gameTime)
return;
getCharacterCurrentParams(kCharacterAbbot)[1] = 0x7FFFFFFF;
} else {
getCharacterCurrentParams(kCharacterAbbot)[1] = _gameTime + getCharacterCurrentParams(kCharacterAbbot)[0];
if (_gameTime + getCharacterCurrentParams(kCharacterAbbot)[0] == 0)
return;
if (_gameTime <= getCharacterCurrentParams(kCharacterAbbot)[1])
return;
getCharacterCurrentParams(kCharacterAbbot)[1] = 0x7FFFFFFF;
}
getCharacter(kCharacterAbbot).currentCall--;
_engine->getMessageManager()->setMessageHandle(kCharacterAbbot, _functionsDemoAbbot[getCharacter(kCharacterAbbot).callbacks[getCharacter(kCharacterAbbot).currentCall]]);
fedEx(kCharacterAbbot, kCharacterAbbot, 18, 0);
break;
default:
break;
}
}
void LogicManager::CONS_DemoAbbot_DoJoinedSeqOtis(CONS_PARAMS) {
CharacterCallParams *params = &getCharacter(kCharacterAbbot).callParams[getCharacter(kCharacterAbbot).currentCall];
_engine->getMessageManager()->setMessageHandle(kCharacterAbbot, &LogicManager::HAND_DemoAbbot_DoJoinedSeqOtis);
getCharacter(kCharacterAbbot).callbacks[getCharacter(kCharacterAbbot).currentCall] = 2;
params->clear();
strncpy((char *)&params->parameters[0], param1.stringParam, 12);
params->parameters[3] = param2.intParam;
params->parameters[4] = param3.intParam;
strncpy((char *)&params->parameters[5], param4.stringParam, 12);
fedEx(kCharacterAbbot, kCharacterAbbot, 12, 0);
}
void LogicManager::HAND_DemoAbbot_DoJoinedSeqOtis(HAND_PARAMS) {
switch (msg->action) {
case 3:
if (!getCharacterCurrentParams(kCharacterAbbot)[8])
fedEx(kCharacterAbbot, getCharacterCurrentParams(kCharacterAbbot)[3], getCharacterCurrentParams(kCharacterAbbot)[4], getCharacterCurrentParams(kCharacterAbbot)[5]);
getCharacter(kCharacterAbbot).currentCall--;
_engine->getMessageManager()->setMessageHandle(kCharacterAbbot, _functionsDemoAbbot[getCharacter(kCharacterAbbot).callbacks[getCharacter(kCharacterAbbot).currentCall]]);
fedEx(kCharacterAbbot, kCharacterAbbot, 18, 0);
break;
case 10:
if (!getCharacterCurrentParams(kCharacterAbbot)[8]) {
fedEx(kCharacterAbbot, getCharacterCurrentParams(kCharacterAbbot)[3], getCharacterCurrentParams(kCharacterAbbot)[4], getCharacterCurrentParams(kCharacterAbbot)[5]);
getCharacterCurrentParams(kCharacterAbbot)[8] = 1;
}
break;
case 12:
startSeqOtis(kCharacterAbbot, (char *)&getCharacterCurrentParams(kCharacterAbbot));
break;
default:
break;
}
}
void LogicManager::CONS_DemoAbbot_WaitRCClear(CONS_PARAMS) {
CharacterCallParams *params = &getCharacter(kCharacterAbbot).callParams[getCharacter(kCharacterAbbot).currentCall];
_engine->getMessageManager()->setMessageHandle(kCharacterAbbot, &LogicManager::HAND_DemoAbbot_WaitRCClear);
getCharacter(kCharacterAbbot).callbacks[getCharacter(kCharacterAbbot).currentCall] = 3;
params->clear();
fedEx(kCharacterAbbot, kCharacterAbbot, 12, 0);
}
void LogicManager::HAND_DemoAbbot_WaitRCClear(HAND_PARAMS) {
switch (msg->action) {
case 0:
case 12:
if (rcClear()) {
getCharacter(kCharacterAbbot).currentCall--;
_engine->getMessageManager()->setMessageHandle(kCharacterAbbot, _functionsDemoAbbot[getCharacter(kCharacterAbbot).callbacks[getCharacter(kCharacterAbbot).currentCall]]);
fedEx(kCharacterAbbot, kCharacterAbbot, 18, 0);
}
break;
default:
break;
}
}
void LogicManager::CONS_DemoAbbot_Birth(CONS_PARAMS) {
CharacterCallParams *params = &getCharacter(kCharacterAbbot).callParams[getCharacter(kCharacterAbbot).currentCall];
_engine->getMessageManager()->setMessageHandle(kCharacterAbbot, &LogicManager::HAND_DemoAbbot_Birth);
getCharacter(kCharacterAbbot).callbacks[getCharacter(kCharacterAbbot).currentCall] = 4;
params->clear();
fedEx(kCharacterAbbot, kCharacterAbbot, 12, 0);
}
void LogicManager::HAND_DemoAbbot_Birth(HAND_PARAMS) {
switch (msg->action) {
case 0:
if (getCharacterCurrentParams(kCharacterAbbot)[0] == 0x7FFFFFFF || _gameTime <= 2248200)
return;
if (_gameTime <= 2259000) {
if (!inSalon(kCharacterCath) || !getCharacterCurrentParams(kCharacterAbbot)[0]) {
getCharacterCurrentParams(kCharacterAbbot)[0] = _gameTime + 225;
if (_gameTime == -225) {
send(kCharacterAbbot, kCharacterAugust, 136196244, 0);
getCharacter(kCharacterAbbot).callbacks[getCharacter(kCharacterAbbot).currentCall + 8] = 1;
AbbotCall(&LogicManager::CONS_DemoAbbot_DoWait, 0, 0, 0, 0);
return;
}
}
if (getCharacterCurrentParams(kCharacterAbbot)[0] >= _gameTime)
return;
}
getCharacterCurrentParams(kCharacterAbbot)[0] = 0x7FFFFFFF;
send(kCharacterAbbot, kCharacterAugust, 136196244, 0);
getCharacter(kCharacterAbbot).callbacks[getCharacter(kCharacterAbbot).currentCall + 8] = 1;
AbbotCall(&LogicManager::CONS_DemoAbbot_DoWait, 0, 0, 0, 0);
break;
case 12:
getCharacter(kCharacterAbbot).characterPosition.car = kCarRestaurant;
getCharacter(kCharacterAbbot).characterPosition.position = 3450;
getCharacter(kCharacterAbbot).characterPosition.location = 1;
startCycOtis(kCharacterAbbot, "115B");
break;
case 18:
switch (getCharacter(kCharacterAbbot).callbacks[getCharacter(kCharacterAbbot).currentCall + 8]) {
case 1:
getCharacter(kCharacterAbbot).callbacks[getCharacter(kCharacterAbbot).currentCall + 8] = 2;
AbbotCall(&LogicManager::CONS_DemoAbbot_WaitRCClear, 0, 0, 0, 0);
break;
case 2:
getCharacter(kCharacterAbbot).characterPosition.location = 0;
playDialog(kCharacterAbbot, "Abb3demo", -1, 45);
blockView(kCharacterAbbot, kCarRestaurant, 50);
getCharacter(kCharacterAbbot).callbacks[getCharacter(kCharacterAbbot).currentCall + 8] = 3;
AbbotCall(&LogicManager::CONS_DemoAbbot_DoJoinedSeqOtis, "121A", 2, 122358304, "BOGUS");
break;
case 3:
releaseView(kCharacterAbbot, kCarRestaurant, 50);
getCharacter(kCharacterAbbot).characterPosition.location = 1;
startCycOtis(kCharacterAbbot, "121B");
break;
default:
break;
}
break;
default:
break;
}
}
void LogicManager::CONS_DemoAbbot_StartPart2(CONS_PARAMS) {
CharacterCallParams *params = &getCharacter(kCharacterAbbot).callParams[getCharacter(kCharacterAbbot).currentCall];
_engine->getMessageManager()->setMessageHandle(kCharacterAbbot, &LogicManager::HAND_DemoAbbot_StartPart2);
getCharacter(kCharacterAbbot).callbacks[getCharacter(kCharacterAbbot).currentCall] = 5;
params->clear();
fedEx(kCharacterAbbot, kCharacterAbbot, 12, 0);
}
void LogicManager::HAND_DemoAbbot_StartPart2(HAND_PARAMS) {
// No-op
}
void LogicManager::CONS_DemoAbbot_StartPart3(CONS_PARAMS) {
CharacterCallParams *params = &getCharacter(kCharacterAbbot).callParams[getCharacter(kCharacterAbbot).currentCall];
_engine->getMessageManager()->setMessageHandle(kCharacterAbbot, &LogicManager::HAND_DemoAbbot_StartPart3);
getCharacter(kCharacterAbbot).callbacks[getCharacter(kCharacterAbbot).currentCall] = 6;
params->clear();
fedEx(kCharacterAbbot, kCharacterAbbot, 12, 0);
}
void LogicManager::HAND_DemoAbbot_StartPart3(HAND_PARAMS) {
// No-op
}
void LogicManager::CONS_DemoAbbot_StartPart4(CONS_PARAMS) {
CharacterCallParams *params = &getCharacter(kCharacterAbbot).callParams[getCharacter(kCharacterAbbot).currentCall];
_engine->getMessageManager()->setMessageHandle(kCharacterAbbot, &LogicManager::HAND_DemoAbbot_StartPart4);
getCharacter(kCharacterAbbot).callbacks[getCharacter(kCharacterAbbot).currentCall] = 7;
params->clear();
fedEx(kCharacterAbbot, kCharacterAbbot, 12, 0);
}
void LogicManager::HAND_DemoAbbot_StartPart4(HAND_PARAMS) {
// No-op
}
void LogicManager::CONS_DemoAbbot_StartPart5(CONS_PARAMS) {
CharacterCallParams *params = &getCharacter(kCharacterAbbot).callParams[getCharacter(kCharacterAbbot).currentCall];
_engine->getMessageManager()->setMessageHandle(kCharacterAbbot, &LogicManager::HAND_DemoAbbot_StartPart5);
getCharacter(kCharacterAbbot).callbacks[getCharacter(kCharacterAbbot).currentCall] = 8;
params->clear();
fedEx(kCharacterAbbot, kCharacterAbbot, 12, 0);
}
void LogicManager::HAND_DemoAbbot_StartPart5(HAND_PARAMS) {
// No-op
}
void (LogicManager::*LogicManager::_functionsDemoAbbot[])(HAND_PARAMS) = {
nullptr,
&LogicManager::HAND_DemoAbbot_DoWait,
&LogicManager::HAND_DemoAbbot_DoJoinedSeqOtis,
&LogicManager::HAND_DemoAbbot_WaitRCClear,
&LogicManager::HAND_DemoAbbot_Birth,
&LogicManager::HAND_DemoAbbot_StartPart2,
&LogicManager::HAND_DemoAbbot_StartPart3,
&LogicManager::HAND_DemoAbbot_StartPart4,
&LogicManager::HAND_DemoAbbot_StartPart5
};
} // End of namespace LastExpress

521
engines/lastexpress/characters/demo/demo_anna.cpp Normal file
View File

@@ -0,0 +1,521 @@
/* ScummVM - Graphic Adventure Engine
*
* ScummVM is the legal property of its developers, whose names
* are too numerous to list here. Please refer to the COPYRIGHT
* file distributed with this source distribution.
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY {} without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <http://www.gnu.org/licenses/>.
*
*/
#include "lastexpress/lastexpress.h"
namespace LastExpress {
void LogicManager::CONS_DemoAnna(int chapter) {
switch (chapter) {
case 0:
_engine->getMessageManager()->setMessageHandle(
kCharacterAnna,
_functionsDemoAnna[getCharacter(kCharacterAnna).callbacks[getCharacter(kCharacterAnna).currentCall]]);
break;
case 1:
CONS_DemoAnna_Birth(0, 0, 0, 0);
break;
case 2:
CONS_DemoAnna_StartPart2(0, 0, 0, 0);
break;
case 3:
CONS_DemoAnna_StartPart3(0, 0, 0, 0);
break;
case 4:
CONS_DemoAnna_StartPart4(0, 0, 0, 0);
break;
case 5:
CONS_DemoAnna_StartPart5(0, 0, 0, 0);
break;
default:
break;
}
}
void LogicManager::DemoAnnaCall(CALL_PARAMS) {
getCharacter(kCharacterAnna).currentCall++;
(this->*functionPointer)(param1, param2, param3, param4);
}
void LogicManager::CONS_DemoAnna_DoSeqOtis(CONS_PARAMS) {
CharacterCallParams *params = &getCharacter(kCharacterAnna).callParams[getCharacter(kCharacterAnna).currentCall];
_engine->getMessageManager()->setMessageHandle(kCharacterAnna, &LogicManager::HAND_DemoAnna_DoSeqOtis);
getCharacter(kCharacterAnna).callbacks[getCharacter(kCharacterAnna).currentCall] = 1;
params->clear();
strncpy((char *)&params->parameters[0], param1.stringParam, 12);
fedEx(kCharacterAnna, kCharacterAnna, 12, 0);
}
void LogicManager::HAND_DemoAnna_DoSeqOtis(HAND_PARAMS) {
switch (msg->action) {
case 3:
getCharacter(kCharacterAnna).currentCall--;
_engine->getMessageManager()->setMessageHandle(kCharacterAnna, _functionsDemoAnna[getCharacter(kCharacterAnna).callbacks[getCharacter(kCharacterAnna).currentCall]]);
fedEx(kCharacterAnna, kCharacterAnna, 18, 0);
break;
case 12:
startSeqOtis(kCharacterAnna, (char *)&getCharacterCurrentParams(kCharacterAnna)[0]);
break;
default:
break;
}
}
void LogicManager::CONS_DemoAnna_FinishSeqOtis(CONS_PARAMS) {
CharacterCallParams *params = &getCharacter(kCharacterAnna).callParams[getCharacter(kCharacterAnna).currentCall];
_engine->getMessageManager()->setMessageHandle(kCharacterAnna, &LogicManager::HAND_DemoAnna_FinishSeqOtis);
getCharacter(kCharacterAnna).callbacks[getCharacter(kCharacterAnna).currentCall] = 2;
params->clear();
fedEx(kCharacterAnna, kCharacterAnna, 12, 0);
}
void LogicManager::HAND_DemoAnna_FinishSeqOtis(HAND_PARAMS) {
if (msg->action == 3) {
getCharacter(kCharacterAnna).currentCall--;
_engine->getMessageManager()->setMessageHandle(kCharacterAnna, _functionsDemoAnna[getCharacter(kCharacterAnna).callbacks[getCharacter(kCharacterAnna).currentCall]]);
fedEx(kCharacterAnna, kCharacterAnna, 18, 0);
}
}
void LogicManager::CONS_DemoAnna_DoCorrOtis(CONS_PARAMS) {
CharacterCallParams *params = &getCharacter(kCharacterAnna).callParams[getCharacter(kCharacterAnna).currentCall];
_engine->getMessageManager()->setMessageHandle(kCharacterAnna, &LogicManager::HAND_DemoAnna_DoCorrOtis);
getCharacter(kCharacterAnna).callbacks[getCharacter(kCharacterAnna).currentCall] = 3;
params->clear();
strncpy((char *)&params->parameters[0], param1.stringParam, 12);
params->parameters[3] = param2.intParam;
fedEx(kCharacterAnna, kCharacterAnna, 12, 0);
}
void LogicManager::HAND_DemoAnna_DoCorrOtis(HAND_PARAMS) {
switch (msg->action) {
case 3:
releaseAtDoor(kCharacterAnna, getCharacterCurrentParams(kCharacterAnna)[3]);
getCharacter(kCharacterAnna).currentCall--;
_engine->getMessageManager()->setMessageHandle(kCharacterAnna, _functionsDemoAnna[getCharacter(kCharacterAnna).callbacks[getCharacter(kCharacterAnna).currentCall]]);
fedEx(kCharacterAnna, kCharacterAnna, 18, 0);
break;
case 12:
startSeqOtis(kCharacterAnna, (char *)&getCharacterCurrentParams(kCharacterAnna)[0]);
blockAtDoor(kCharacterAnna, getCharacterCurrentParams(kCharacterAnna)[3]);
break;
default:
break;
}
}
void LogicManager::CONS_DemoAnna_WaitRCClear(CONS_PARAMS) {
CharacterCallParams *params = &getCharacter(kCharacterAnna).callParams[getCharacter(kCharacterAnna).currentCall];
_engine->getMessageManager()->setMessageHandle(kCharacterAnna, &LogicManager::HAND_DemoAnna_WaitRCClear);
getCharacter(kCharacterAnna).callbacks[getCharacter(kCharacterAnna).currentCall] = 4;
params->clear();
fedEx(kCharacterAnna, kCharacterAnna, 12, 0);
}
void LogicManager::HAND_DemoAnna_WaitRCClear(HAND_PARAMS) {
switch (msg->action) {
case 0:
case 12:
if (rcClear()) {
getCharacter(kCharacterAnna).currentCall--;
_engine->getMessageManager()->setMessageHandle(kCharacterAnna, _functionsDemoAnna[getCharacter(kCharacterAnna).callbacks[getCharacter(kCharacterAnna).currentCall]]);
fedEx(kCharacterAnna, kCharacterAnna, 18, 0);
}
break;
default:
break;
}
}
void LogicManager::CONS_DemoAnna_SaveGame(CONS_PARAMS) {
CharacterCallParams *params = &getCharacter(kCharacterAnna).callParams[getCharacter(kCharacterAnna).currentCall];
_engine->getMessageManager()->setMessageHandle(kCharacterAnna, &LogicManager::HAND_DemoAnna_SaveGame);
getCharacter(kCharacterAnna).callbacks[getCharacter(kCharacterAnna).currentCall] = 5;
params->clear();
params->parameters[0] = param1.intParam;
params->parameters[1] = param2.intParam;
fedEx(kCharacterAnna, kCharacterAnna, 12, 0);
}
void LogicManager::HAND_DemoAnna_SaveGame(HAND_PARAMS) {
switch (msg->action) {
case 0:
getCharacter(kCharacterAnna).currentCall--;
_engine->getMessageManager()->setMessageHandle(kCharacterAnna, _functionsDemoAnna[getCharacter(kCharacterAnna).callbacks[getCharacter(kCharacterAnna).currentCall]]);
fedEx(kCharacterAnna, kCharacterAnna, 18, 0);
break;
case 12:
save(
kCharacterAnna,
getCharacterCurrentParams(kCharacterAnna)[0],
getCharacterCurrentParams(kCharacterAnna)[1]
);
getCharacter(kCharacterAnna).currentCall--;
_engine->getMessageManager()->setMessageHandle(kCharacterAnna, _functionsDemoAnna[getCharacter(kCharacterAnna).callbacks[getCharacter(kCharacterAnna).currentCall]]);
fedEx(kCharacterAnna, kCharacterAnna, 18, 0);
break;
default:
break;
}
}
void LogicManager::CONS_DemoAnna_DoWalk(CONS_PARAMS) {
CharacterCallParams *params = &getCharacter(kCharacterAnna).callParams[getCharacter(kCharacterAnna).currentCall];
_engine->getMessageManager()->setMessageHandle(kCharacterAnna, &LogicManager::HAND_DemoAnna_DoWalk);
getCharacter(kCharacterAnna).callbacks[getCharacter(kCharacterAnna).currentCall] = 6;
params->clear();
params->parameters[0] = param1.intParam;
params->parameters[1] = param2.intParam;
fedEx(kCharacterAnna, kCharacterAnna, 12, 0);
}
void LogicManager::HAND_DemoAnna_DoWalk(HAND_PARAMS) {
switch (msg->action) {
case 0:
case 12:
if (walk(kCharacterAnna, getCharacterCurrentParams(kCharacterAnna)[0], getCharacterCurrentParams(kCharacterAnna)[1])) {
getCharacter(kCharacterAnna).currentCall--;
_engine->getMessageManager()->setMessageHandle(kCharacterAnna, _functionsDemoAnna[getCharacter(kCharacterAnna).callbacks[getCharacter(kCharacterAnna).currentCall]]);
fedEx(kCharacterAnna, kCharacterAnna, 18, 0);
}
break;
case 5:
playDialog(kCharacterCath, "CAT1001", -1, 0);
break;
case 6:
playChrExcuseMe(kCharacterAnna, kCharacterCath, 0);
break;
default:
break;
}
}
void LogicManager::CONS_DemoAnna_Birth(CONS_PARAMS) {
CharacterCallParams *params = &getCharacter(kCharacterAnna).callParams[getCharacter(kCharacterAnna).currentCall];
_engine->getMessageManager()->setMessageHandle(kCharacterAnna, &LogicManager::HAND_DemoAnna_Birth);
getCharacter(kCharacterAnna).callbacks[getCharacter(kCharacterAnna).currentCall] = 7;
params->clear();
fedEx(kCharacterAnna, kCharacterAnna, 12, 0);
}
void LogicManager::HAND_DemoAnna_Birth(HAND_PARAMS) {
switch (msg->action) {
case 0:
if (_gameTime > 2254500 && !getCharacterCurrentParams(kCharacterAnna)[0]) {
getCharacterCurrentParams(kCharacterAnna)[0] = 1;
getCharacter(kCharacterAnna).callbacks[getCharacter(kCharacterAnna).currentCall + 8] = 1;
DemoAnnaCall(&LogicManager::CONS_DemoAnna_GoBagg, 0, 0, 0, 0);
}
break;
case 12:
getCharacter(kCharacterAnna).characterPosition.car = kCarRedSleeping;
getCharacter(kCharacterAnna).characterPosition.position = 4070;
getCharacter(kCharacterAnna).characterPosition.location = 1;
getCharacter(kCharacterAnna).clothes = 2;
break;
default:
break;
}
}
void LogicManager::CONS_DemoAnna_GoBagg(CONS_PARAMS) {
CharacterCallParams *params = &getCharacter(kCharacterAnna).callParams[getCharacter(kCharacterAnna).currentCall];
_engine->getMessageManager()->setMessageHandle(kCharacterAnna, &LogicManager::HAND_DemoAnna_GoBagg);
getCharacter(kCharacterAnna).callbacks[getCharacter(kCharacterAnna).currentCall] = 8;
params->clear();
fedEx(kCharacterAnna, kCharacterAnna, 12, 0);
}
void LogicManager::HAND_DemoAnna_GoBagg(HAND_PARAMS) {
switch (msg->action) {
case 12:
setDoor(53, kCharacterCath, 1, 10, 9);
getCharacter(kCharacterAnna).characterPosition.location = 0;
getCharacter(kCharacterAnna).callbacks[getCharacter(kCharacterAnna).currentCall + 8] = 1;
DemoAnnaCall(&LogicManager::CONS_DemoAnna_DoCorrOtis, "625Bf", 37, 0, 0);
break;
case 18:
switch (getCharacter(kCharacterAnna).callbacks[getCharacter(kCharacterAnna).currentCall + 8]) {
case 1:
setDoor(37, kCharacterCath, 1, 10, 9);
getCharacter(kCharacterAnna).callbacks[getCharacter(kCharacterAnna).currentCall + 8] = 2;
DemoAnnaCall(&LogicManager::CONS_DemoAnna_DoWalk, 5, 850, 0, 0);
break;
case 2:
getCharacter(kCharacterAnna).callbacks[getCharacter(kCharacterAnna).currentCall + 8] = 3;
DemoAnnaCall(&LogicManager::CONS_DemoAnna_WaitRCClear, 0, 0, 0, 0);
break;
case 3:
getCharacter(kCharacterAnna).characterPosition.position = 1540;
getCharacter(kCharacterAnna).characterPosition.location = 0;
getCharacter(kCharacterAnna).callbacks[getCharacter(kCharacterAnna).currentCall + 8] = 4;
DemoAnnaCall(&LogicManager::CONS_DemoAnna_DoSeqOtis, "802US", 0, 0, 0);
break;
case 4:
startSeqOtis(kCharacterAnna, "802UD");
if (inSalon(kCharacterCath))
advanceFrame(kCharacterAnna);
getCharacter(kCharacterAnna).callbacks[getCharacter(kCharacterAnna).currentCall + 8] = 5;
DemoAnnaCall(&LogicManager::CONS_DemoAnna_FinishSeqOtis, 0, 0, 0, 0);
break;
case 5:
_globals[kGlobalUnknownDebugFlag] = 1;
endGraphics(kCharacterAnna);
CONS_DemoAnna_InBagg(0, 0, 0, 0);
break;
default:
break;
}
break;
default:
break;
}
}
void LogicManager::CONS_DemoAnna_InBagg(CONS_PARAMS) {
CharacterCallParams *params = &getCharacter(kCharacterAnna).callParams[getCharacter(kCharacterAnna).currentCall];
_engine->getMessageManager()->setMessageHandle(kCharacterAnna, &LogicManager::HAND_DemoAnna_InBagg);
getCharacter(kCharacterAnna).callbacks[getCharacter(kCharacterAnna).currentCall] = 9;
params->clear();
fedEx(kCharacterAnna, kCharacterAnna, 12, 0);
}
void LogicManager::HAND_DemoAnna_InBagg(HAND_PARAMS) {
switch (msg->action) {
case 0:
if (getCharacterCurrentParams(kCharacterAnna)[0] && _gameTime > 2265300 && !getCharacterCurrentParams(kCharacterAnna)[1]) {
getCharacterCurrentParams(kCharacterAnna)[1] = 1;
if (checkLoc(kCharacterCath, 6)) {
CONS_DemoAnna_BaggageFight(0, 0, 0, 0);
} else {
send(kCharacterAnna, kCharacterVesna, 189299008, 0);
CONS_DemoAnna_DeadBagg(0, 0, 0, 0);
}
}
break;
case 12:
getCharacter(kCharacterAnna).characterPosition.car = kCarBaggage;
_globals[kGlobalAnnaIsInBaggageCar] = 1;
break;
case 235856512:
getCharacterCurrentParams(kCharacterAnna)[0] = 1;
break;
default:
break;
}
}
void LogicManager::CONS_DemoAnna_DeadBagg(CONS_PARAMS) {
CharacterCallParams *params = &getCharacter(kCharacterAnna).callParams[getCharacter(kCharacterAnna).currentCall];
_engine->getMessageManager()->setMessageHandle(kCharacterAnna, &LogicManager::HAND_DemoAnna_DeadBagg);
getCharacter(kCharacterAnna).callbacks[getCharacter(kCharacterAnna).currentCall] = 10;
params->clear();
fedEx(kCharacterAnna, kCharacterAnna, 12, 0);
}
void LogicManager::HAND_DemoAnna_DeadBagg(HAND_PARAMS) {
switch (msg->action) {
case 18:
if (getCharacter(kCharacterAnna).callbacks[getCharacter(kCharacterAnna).currentCall + 8] == 1) {
playNIS(kEventAnnaKilled);
endGame(1, 2259000, 58, true);
}
break;
case 272177921:
if (dialogRunning("MUS021"))
fadeDialog("MUS021");
getCharacter(kCharacterAnna).callbacks[getCharacter(kCharacterAnna).currentCall + 8] = 1;
DemoAnnaCall(&LogicManager::CONS_DemoAnna_SaveGame, 2, kEventAnnaKilled, 0, 0);
break;
default:
break;
}
}
void LogicManager::CONS_DemoAnna_BaggageFight(CONS_PARAMS) {
CharacterCallParams *params = &getCharacter(kCharacterAnna).callParams[getCharacter(kCharacterAnna).currentCall];
_engine->getMessageManager()->setMessageHandle(kCharacterAnna, &LogicManager::HAND_DemoAnna_BaggageFight);
getCharacter(kCharacterAnna).callbacks[getCharacter(kCharacterAnna).currentCall] = 11;
params->clear();
fedEx(kCharacterAnna, kCharacterAnna, 12, 0);
}
void LogicManager::HAND_DemoAnna_BaggageFight(HAND_PARAMS) {
switch (msg->action) {
case 12:
endGraphics(kCharacterAnna);
if (dialogRunning("MUS021"))
fadeDialog("MUS021");
getCharacter(kCharacterAnna).callbacks[getCharacter(kCharacterAnna).currentCall + 8] = 1;
DemoAnnaCall(&LogicManager::CONS_DemoAnna_SaveGame, 2, kEventAnnaBaggageArgument, 0, 0);
break;
case 18:
switch (getCharacter(kCharacterAnna).callbacks[getCharacter(kCharacterAnna).currentCall + 8]) {
case 1:
playNIS(kEventAnnaBaggageArgument);
getCharacter(kCharacterAnna).callbacks[getCharacter(kCharacterAnna).currentCall + 8] = 2;
DemoAnnaCall(&LogicManager::CONS_DemoAnna_SaveGame, 1, 0, 0, 0);
break;
case 2:
getCharacterCurrentParams(kCharacterAnna)[0] = playFight(2002);
if (getCharacterCurrentParams(kCharacterAnna)[0]) {
endGame(0, 0, 0, getCharacterCurrentParams(kCharacterAnna)[0] == 1);
} else {
_gameTime = 2268000;
getCharacter(kCharacterAnna).callbacks[getCharacter(kCharacterAnna).currentCall + 8] = 3;
DemoAnnaCall(&LogicManager::CONS_DemoAnna_SaveGame, 2, kEventAnnaBaggagePart2, 0, 0);
}
break;
case 3:
playNIS(kEventAnnaBaggagePart2);
_globals[kGlobalAnnaIsInBaggageCar] = 0;
forceJump(kCharacterVesna, &LogicManager::CONS_DemoVesna_InComp);
winGame();
break;
default:
break;
}
break;
default:
break;
}
}
void LogicManager::CONS_DemoAnna_StartPart2(CONS_PARAMS) {
CharacterCallParams *params = &getCharacter(kCharacterAnna).callParams[getCharacter(kCharacterAnna).currentCall];
_engine->getMessageManager()->setMessageHandle(kCharacterAnna, &LogicManager::HAND_DemoAnna_StartPart2);
getCharacter(kCharacterAnna).callbacks[getCharacter(kCharacterAnna).currentCall] = 12;
params->clear();
fedEx(kCharacterAnna, kCharacterAnna, 12, 0);
}
void LogicManager::HAND_DemoAnna_StartPart2(HAND_PARAMS) {
// No-op
}
void LogicManager::CONS_DemoAnna_StartPart3(CONS_PARAMS) {
CharacterCallParams *params = &getCharacter(kCharacterAnna).callParams[getCharacter(kCharacterAnna).currentCall];
_engine->getMessageManager()->setMessageHandle(kCharacterAnna, &LogicManager::HAND_DemoAnna_StartPart3);
getCharacter(kCharacterAnna).callbacks[getCharacter(kCharacterAnna).currentCall] = 13;
params->clear();
fedEx(kCharacterAnna, kCharacterAnna, 12, 0);
}
void LogicManager::HAND_DemoAnna_StartPart3(HAND_PARAMS) {
// No-op
}
void LogicManager::CONS_DemoAnna_StartPart4(CONS_PARAMS) {
CharacterCallParams *params = &getCharacter(kCharacterAnna).callParams[getCharacter(kCharacterAnna).currentCall];
_engine->getMessageManager()->setMessageHandle(kCharacterAnna, &LogicManager::HAND_DemoAnna_StartPart4);
getCharacter(kCharacterAnna).callbacks[getCharacter(kCharacterAnna).currentCall] = 14;
params->clear();
fedEx(kCharacterAnna, kCharacterAnna, 12, 0);
}
void LogicManager::HAND_DemoAnna_StartPart4(HAND_PARAMS) {
// No-op
}
void LogicManager::CONS_DemoAnna_StartPart5(CONS_PARAMS) {
CharacterCallParams *params = &getCharacter(kCharacterAnna).callParams[getCharacter(kCharacterAnna).currentCall];
_engine->getMessageManager()->setMessageHandle(kCharacterAnna, &LogicManager::HAND_DemoAnna_StartPart5);
getCharacter(kCharacterAnna).callbacks[getCharacter(kCharacterAnna).currentCall] = 15;
params->clear();
fedEx(kCharacterAnna, kCharacterAnna, 12, 0);
}
void LogicManager::HAND_DemoAnna_StartPart5(HAND_PARAMS) {
// No-op
}
void (LogicManager::*LogicManager::_functionsDemoAnna[])(HAND_PARAMS) = {
nullptr,
&LogicManager::HAND_DemoAnna_DoSeqOtis,
&LogicManager::HAND_DemoAnna_FinishSeqOtis,
&LogicManager::HAND_DemoAnna_DoCorrOtis,
&LogicManager::HAND_DemoAnna_WaitRCClear,
&LogicManager::HAND_DemoAnna_SaveGame,
&LogicManager::HAND_DemoAnna_DoWalk,
&LogicManager::HAND_DemoAnna_Birth,
&LogicManager::HAND_DemoAnna_GoBagg,
&LogicManager::HAND_DemoAnna_InBagg,
&LogicManager::HAND_DemoAnna_DeadBagg,
&LogicManager::HAND_DemoAnna_BaggageFight,
&LogicManager::HAND_DemoAnna_StartPart2,
&LogicManager::HAND_DemoAnna_StartPart3,
&LogicManager::HAND_DemoAnna_StartPart4,
&LogicManager::HAND_DemoAnna_StartPart5
};
} // End of namespace LastExpress

230
engines/lastexpress/characters/demo/demo_august.cpp Normal file
View File

@@ -0,0 +1,230 @@
/* ScummVM - Graphic Adventure Engine
*
* ScummVM is the legal property of its developers, whose names
* are too numerous to list here. Please refer to the COPYRIGHT
* file distributed with this source distribution.
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <http://www.gnu.org/licenses/>.
*
*/
#include "lastexpress/lastexpress.h"
namespace LastExpress {
void LogicManager::CONS_DemoAugust(int chapter) {
switch (chapter) {
case 0:
_engine->getMessageManager()->setMessageHandle(
kCharacterAugust,
_functionsDemoAugust[getCharacter(kCharacterAugust).callbacks[getCharacter(kCharacterAugust).currentCall]]
);
break;
case 1:
CONS_DemoAugust_Birth(0, 0, 0, 0);
break;
case 2:
CONS_DemoAugust_StartPart2(0, 0, 0, 0);
break;
case 3:
CONS_DemoAugust_StartPart3(0, 0, 0, 0);
break;
case 4:
CONS_DemoAugust_StartPart4(0, 0, 0, 0);
break;
case 5:
CONS_DemoAugust_StartPart5(0, 0, 0, 0);
break;
default:
break;
}
}
void LogicManager::DemoAugustCall(CALL_PARAMS) {
getCharacter(kCharacterAugust).currentCall++;
(this->*functionPointer)(param1, param2, param3, param4);
}
void LogicManager::CONS_DemoAugust_SaveGame(CONS_PARAMS) {
CharacterCallParams *params = &getCharacter(kCharacterAugust).callParams[getCharacter(kCharacterAugust).currentCall];
_engine->getMessageManager()->setMessageHandle(kCharacterAugust, &LogicManager::HAND_DemoAugust_SaveGame);
getCharacter(kCharacterAugust).callbacks[getCharacter(kCharacterAugust).currentCall] = 1;
params->clear();
params->parameters[0] = param1.intParam;
params->parameters[1] = param2.intParam;
fedEx(kCharacterAugust, kCharacterAugust, 12, 0);
}
void LogicManager::HAND_DemoAugust_SaveGame(HAND_PARAMS) {
switch (msg->action) {
case 0:
getCharacter(kCharacterAugust).currentCall--;
_engine->getMessageManager()->setMessageHandle(kCharacterAugust, _functionsDemoAugust[getCharacter(kCharacterAugust).callbacks[getCharacter(kCharacterAugust).currentCall]]);
fedEx(kCharacterAugust, kCharacterAugust, 18, 0);
break;
case 12:
save(
kCharacterAugust,
getCharacterCurrentParams(kCharacterAugust)[0],
getCharacterCurrentParams(kCharacterAugust)[1]
);
getCharacter(kCharacterAugust).currentCall--;
_engine->getMessageManager()->setMessageHandle(kCharacterAugust, _functionsDemoAugust[getCharacter(kCharacterAugust).callbacks[getCharacter(kCharacterAugust).currentCall]]);
fedEx(kCharacterAugust, kCharacterAugust, 18, 0);
break;
default:
break;
}
}
void LogicManager::CONS_DemoAugust_Birth(CONS_PARAMS) {
CharacterCallParams *params = &getCharacter(kCharacterAugust).callParams[getCharacter(kCharacterAugust).currentCall];
_engine->getMessageManager()->setMessageHandle(kCharacterAugust, &LogicManager::HAND_DemoAugust_Birth);
getCharacter(kCharacterAugust).callbacks[getCharacter(kCharacterAugust).currentCall] = 2;
params->clear();
fedEx(kCharacterAugust, kCharacterAugust, 12, 0);
}
void LogicManager::HAND_DemoAugust_Birth(HAND_PARAMS) {
switch (msg->action) {
case 0:
if (getCharacterCurrentParams(kCharacterAugust)[2] && !getCharacterCurrentParams(kCharacterAugust)[0]) {
getCharacter(kCharacterAugust).inventoryItem = 0x80;
} else {
getCharacter(kCharacterAugust).inventoryItem = 0;
}
break;
case 1:
getCharacter(kCharacterAugust).inventoryItem = 0;
getCharacter(kCharacterAugust).callbacks[getCharacter(kCharacterAugust).currentCall + 8] = 1;
DemoAugustCall(&LogicManager::CONS_DemoAugust_SaveGame, 2, kEventAugustTalkCigar, 0, 0);
break;
case 3:
releaseView(kCharacterAugust, kCarRestaurant, 50);
startCycOtis(kCharacterAugust, "105B3");
break;
case 12:
getCharacter(kCharacterAugust).characterPosition.car = kCarRestaurant;
getCharacter(kCharacterAugust).characterPosition.position = 3450;
getCharacter(kCharacterAugust).characterPosition.location = 1;
send(kCharacterAugust, kCharacterAbbot, 123712592, 0);
startCycOtis(kCharacterAugust, "105B3");
getCharacterCurrentParams(kCharacterAugust)[2] = 1;
break;
case 17:
if (checkCathDir(kCarRestaurant, 60) && !getCharacterCurrentParams(kCharacterAugust)[1] && !getCharacterCurrentParams(kCharacterAugust)[0]) {
blockView(kCharacterAugust, kCarRestaurant, 50);
startSeqOtis(kCharacterAugust, "105C3");
}
break;
case 18:
if (getCharacter(kCharacterAugust).callbacks[getCharacter(kCharacterAugust).currentCall + 8] == 1) {
playNIS(kEventAugustTalkCigar);
startCycOtis(kCharacterAugust, "105B3");
cleanNIS();
getCharacterCurrentParams(kCharacterAugust)[2] = 0;
}
break;
case 122358304:
startCycOtis(kCharacterAugust, "BLANK");
getCharacterCurrentParams(kCharacterAugust)[0] = 1;
getCharacterCurrentParams(kCharacterAugust)[1] = 1;
break;
case 136196244:
getCharacterCurrentParams(kCharacterAugust)[0] = 1;
getCharacter(kCharacterAugust).inventoryItem = 0;
break;
default:
break;
}
}
void LogicManager::CONS_DemoAugust_StartPart2(CONS_PARAMS) {
CharacterCallParams *params = &getCharacter(kCharacterAugust).callParams[getCharacter(kCharacterAugust).currentCall];
_engine->getMessageManager()->setMessageHandle(kCharacterAugust, &LogicManager::HAND_DemoAugust_StartPart2);
getCharacter(kCharacterAugust).callbacks[getCharacter(kCharacterAugust).currentCall] = 3;
params->clear();
fedEx(kCharacterAugust, kCharacterAugust, 12, 0);
}
void LogicManager::HAND_DemoAugust_StartPart2(HAND_PARAMS) {
// No-op
}
void LogicManager::CONS_DemoAugust_StartPart3(CONS_PARAMS) {
CharacterCallParams *params = &getCharacter(kCharacterAugust).callParams[getCharacter(kCharacterAugust).currentCall];
_engine->getMessageManager()->setMessageHandle(kCharacterAugust, &LogicManager::HAND_DemoAugust_StartPart3);
getCharacter(kCharacterAugust).callbacks[getCharacter(kCharacterAugust).currentCall] = 4;
params->clear();
fedEx(kCharacterAugust, kCharacterAugust, 12, 0);
}
void LogicManager::HAND_DemoAugust_StartPart3(HAND_PARAMS) {
// No-op
}
void LogicManager::CONS_DemoAugust_StartPart4(CONS_PARAMS) {
CharacterCallParams *params = &getCharacter(kCharacterAugust).callParams[getCharacter(kCharacterAugust).currentCall];
_engine->getMessageManager()->setMessageHandle(kCharacterAugust, &LogicManager::HAND_DemoAugust_StartPart4);
getCharacter(kCharacterAugust).callbacks[getCharacter(kCharacterAugust).currentCall] = 5;
params->clear();
fedEx(kCharacterAugust, kCharacterAugust, 12, 0);
}
void LogicManager::HAND_DemoAugust_StartPart4(HAND_PARAMS) {
// No-op
}
void LogicManager::CONS_DemoAugust_StartPart5(CONS_PARAMS) {
CharacterCallParams *params = &getCharacter(kCharacterAugust).callParams[getCharacter(kCharacterAugust).currentCall];
_engine->getMessageManager()->setMessageHandle(kCharacterAugust, &LogicManager::HAND_DemoAugust_StartPart5);
getCharacter(kCharacterAugust).callbacks[getCharacter(kCharacterAugust).currentCall] = 35;
params->clear();
fedEx(kCharacterAugust, kCharacterAugust, 12, 0);
}
void LogicManager::HAND_DemoAugust_StartPart5(HAND_PARAMS) {
// No-op
}
void (LogicManager::*LogicManager::_functionsDemoAugust[])(HAND_PARAMS) = {
nullptr,
&LogicManager::HAND_DemoAugust_SaveGame,
&LogicManager::HAND_DemoAugust_Birth,
&LogicManager::HAND_DemoAugust_StartPart2,
&LogicManager::HAND_DemoAugust_StartPart3,
&LogicManager::HAND_DemoAugust_StartPart4,
&LogicManager::HAND_DemoAugust_StartPart5
};
} // End of namespace LastExpress

261
engines/lastexpress/characters/demo/demo_cond2.cpp Normal file
View File

@@ -0,0 +1,261 @@
/* ScummVM - Graphic Adventure Engine
*
* ScummVM is the legal property of its developers, whose names
* are too numerous to list here. Please refer to the COPYRIGHT
* file distributed with this source distribution.
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <http://www.gnu.org/licenses/>.
*
*/
#include "lastexpress/lastexpress.h"
namespace LastExpress {
void LogicManager::CONS_DemoCond2(int chapter) {
switch (chapter) {
case 0:
_engine->getMessageManager()->setMessageHandle(
kCharacterCond2,
_functionsDemoCond2[getCharacter(kCharacterCond2).callbacks[getCharacter(kCharacterCond2).currentCall]]
);
break;
case 1:
CONS_DemoCond2_Birth(0, 0, 0, 0);
break;
case 2:
CONS_DemoCond2_StartPart2(0, 0, 0, 0);
break;
case 3:
CONS_DemoCond2_StartPart3(0, 0, 0, 0);
break;
case 4:
CONS_DemoCond2_StartPart4(0, 0, 0, 0);
break;
case 5:
CONS_DemoCond2_StartPart5(0, 0, 0, 0);
break;
default:
break;
}
}
void LogicManager::DemoCond2Call(CALL_PARAMS) {
getCharacter(kCharacterCond2).currentCall++;
(this->*functionPointer)(param1, param2, param3, param4);
}
void LogicManager::CONS_DemoCond2_DoSeqOtis(CONS_PARAMS) {
CharacterCallParams *params = &getCharacter(kCharacterCond2).callParams[getCharacter(kCharacterCond2).currentCall];
_engine->getMessageManager()->setMessageHandle(kCharacterCond2, &LogicManager::HAND_DemoCond2_DoSeqOtis);
getCharacter(kCharacterCond2).callbacks[getCharacter(kCharacterCond2).currentCall] = 1;
params->clear();
strncpy((char *)&params->parameters[0], param1.stringParam, 12);
fedEx(kCharacterCond2, kCharacterCond2, 12, 0);
}
void LogicManager::HAND_DemoCond2_DoSeqOtis(HAND_PARAMS) {
switch (msg->action) {
case 3:
getCharacter(kCharacterCond2).currentCall--;
_engine->getMessageManager()->setMessageHandle(kCharacterCond2, _functionsDemoCond2[getCharacter(kCharacterCond2).callbacks[getCharacter(kCharacterCond2).currentCall]]);
fedEx(kCharacterCond2, kCharacterCond2, 18, 0);
break;
case 12:
startSeqOtis(kCharacterCond2, (char *)&getCharacterCurrentParams(kCharacterCond2)[0]);
break;
default:
break;
}
}
void LogicManager::CONS_DemoCond2_FinishSeqOtis(CONS_PARAMS) {
CharacterCallParams *params = &getCharacter(kCharacterCond2).callParams[getCharacter(kCharacterCond2).currentCall];
_engine->getMessageManager()->setMessageHandle(kCharacterCond2, &LogicManager::HAND_DemoCond2_FinishSeqOtis);
getCharacter(kCharacterCond2).callbacks[getCharacter(kCharacterCond2).currentCall] = 2;
params->clear();
fedEx(kCharacterCond2, kCharacterCond2, 12, 0);
}
void LogicManager::HAND_DemoCond2_FinishSeqOtis(HAND_PARAMS) {
if (msg->action == 3) {
getCharacter(kCharacterCond2).currentCall--;
_engine->getMessageManager()->setMessageHandle(kCharacterCond2, _functionsDemoCond2[getCharacter(kCharacterCond2).callbacks[getCharacter(kCharacterCond2).currentCall]]);
fedEx(kCharacterCond2, kCharacterCond2, 18, 0);
}
}
void LogicManager::CONS_DemoCond2_SitDown(CONS_PARAMS) {
CharacterCallParams *params = &getCharacter(kCharacterCond2).callParams[getCharacter(kCharacterCond2).currentCall];
_engine->getMessageManager()->setMessageHandle(kCharacterCond2, &LogicManager::HAND_DemoCond2_SitDown);
getCharacter(kCharacterCond2).callbacks[getCharacter(kCharacterCond2).currentCall] = 3;
params->clear();
params->parameters[0] = param1.intParam;
fedEx(kCharacterCond2, kCharacterCond2, 12, 0);
}
void LogicManager::HAND_DemoCond2_SitDown(HAND_PARAMS) {
switch (msg->action) {
case 12:
if (getCharacterCurrentParams(kCharacterCond2)[0]) {
startSeqOtis(kCharacterCond2, "697H");
} else {
startSeqOtis(kCharacterCond2, "627A");
}
getCharacter(kCharacterCond2).callbacks[getCharacter(kCharacterCond2).currentCall + 8] = 1;
DemoCond2Call(&LogicManager::CONS_DemoCond2_FinishSeqOtis, 0, 0, 0, 0);
break;
case 18:
switch (getCharacter(kCharacterCond2).callbacks[getCharacter(kCharacterCond2).currentCall + 8]) {
case 1:
startCycOtis(kCharacterCond2, "627B");
getCharacter(kCharacterCond2).currentCall--;
_engine->getMessageManager()->setMessageHandle(kCharacterCond2, _functionsDemoCond2[getCharacter(kCharacterCond2).callbacks[getCharacter(kCharacterCond2).currentCall]]);
fedEx(kCharacterCond2, kCharacterCond2, 18, 0);
break;
default:
break;
}
break;
default:
break;
}
}
void LogicManager::CONS_DemoCond2_Birth(CONS_PARAMS) {
CharacterCallParams *params = &getCharacter(kCharacterCond2).callParams[getCharacter(kCharacterCond2).currentCall];
_engine->getMessageManager()->setMessageHandle(kCharacterCond2, &LogicManager::HAND_DemoCond2_Birth);
getCharacter(kCharacterCond2).callbacks[getCharacter(kCharacterCond2).currentCall] = 4;
params->clear();
fedEx(kCharacterCond2, kCharacterCond2, 12, 0);
}
void LogicManager::HAND_DemoCond2_Birth(HAND_PARAMS) {
switch (msg->action) {
case 12:
getCharacter(kCharacterCond2).characterPosition.car = kCarRedSleeping;
getCharacter(kCharacterCond2).characterPosition.position = 1500;
getCharacter(kCharacterCond2).characterPosition.location = 0;
getCharacter(kCharacterCond2).callbacks[getCharacter(kCharacterCond2).currentCall + 8] = 1;
DemoCond2Call(&LogicManager::CONS_DemoCond2_SitDown, 0, 0, 0, 0);
break;
case 18:
if (getCharacter(kCharacterCond2).callbacks[getCharacter(kCharacterCond2).currentCall + 8] == 2) {
getCharacter(kCharacterCond2).callbacks[getCharacter(kCharacterCond2).currentCall + 8] = 3;
DemoCond2Call(&LogicManager::CONS_DemoCond2_SitDown, 0, 0, 0, 0);
}
break;
case 168253822:
if (whoOnScreen(kCharacterCond2) && !getCharacterCurrentParams(kCharacterCond2)[0]) {
getCharacterCurrentParams(kCharacterCond2)[0] = 1;
playDialog(kCharacterCond2, "JAC1120", -1, 0);
getCharacter(kCharacterCond2).callbacks[getCharacter(kCharacterCond2).currentCall + 8] = 2;
DemoCond2Call(&LogicManager::CONS_DemoCond2_DoSeqOtis, "697D", 0, 0, 0);
}
break;
case 225932896:
send(kCharacterCond2, kCharacterFrancois, 205346192, 0);
break;
default:
break;
}
}
void LogicManager::CONS_DemoCond2_StartPart2(CONS_PARAMS) {
CharacterCallParams *params = &getCharacter(kCharacterCond2).callParams[getCharacter(kCharacterCond2).currentCall];
_engine->getMessageManager()->setMessageHandle(kCharacterCond2, &LogicManager::HAND_DemoCond2_StartPart2);
getCharacter(kCharacterCond2).callbacks[getCharacter(kCharacterCond2).currentCall] = 5;
params->clear();
fedEx(kCharacterCond2, kCharacterCond2, 12, 0);
}
void LogicManager::HAND_DemoCond2_StartPart2(HAND_PARAMS) {
// No-op
}
void LogicManager::CONS_DemoCond2_StartPart3(CONS_PARAMS) {
CharacterCallParams *params = &getCharacter(kCharacterCond2).callParams[getCharacter(kCharacterCond2).currentCall];
_engine->getMessageManager()->setMessageHandle(kCharacterCond2, &LogicManager::HAND_DemoCond2_StartPart3);
getCharacter(kCharacterCond2).callbacks[getCharacter(kCharacterCond2).currentCall] = 6;
params->clear();
fedEx(kCharacterCond2, kCharacterCond2, 12, 0);
}
void LogicManager::HAND_DemoCond2_StartPart3(HAND_PARAMS) {
// No-op
}
void LogicManager::CONS_DemoCond2_StartPart4(CONS_PARAMS) {
CharacterCallParams *params = &getCharacter(kCharacterCond2).callParams[getCharacter(kCharacterCond2).currentCall];
_engine->getMessageManager()->setMessageHandle(kCharacterCond2, &LogicManager::HAND_DemoCond2_StartPart4);
getCharacter(kCharacterCond2).callbacks[getCharacter(kCharacterCond2).currentCall] = 7;
params->clear();
fedEx(kCharacterCond2, kCharacterCond2, 12, 0);
}
void LogicManager::HAND_DemoCond2_StartPart4(HAND_PARAMS) {
// No-op
}
void LogicManager::CONS_DemoCond2_StartPart5(CONS_PARAMS) {
CharacterCallParams *params = &getCharacter(kCharacterCond2).callParams[getCharacter(kCharacterCond2).currentCall];
_engine->getMessageManager()->setMessageHandle(kCharacterCond2, &LogicManager::HAND_DemoCond2_StartPart5);
getCharacter(kCharacterCond2).callbacks[getCharacter(kCharacterCond2).currentCall] = 8;
params->clear();
fedEx(kCharacterCond2, kCharacterCond2, 12, 0);
}
void LogicManager::HAND_DemoCond2_StartPart5(HAND_PARAMS) {
// No-op
}
void (LogicManager::*LogicManager::_functionsDemoCond2[])(HAND_PARAMS) = {
nullptr,
&LogicManager::HAND_DemoCond2_DoSeqOtis,
&LogicManager::HAND_DemoCond2_FinishSeqOtis,
&LogicManager::HAND_DemoCond2_SitDown,
&LogicManager::HAND_DemoCond2_Birth,
&LogicManager::HAND_DemoCond2_StartPart2,
&LogicManager::HAND_DemoCond2_StartPart3,
&LogicManager::HAND_DemoCond2_StartPart4,
&LogicManager::HAND_DemoCond2_StartPart5
};
} // End of namespace LastExpress

358
engines/lastexpress/characters/demo/demo_francois.cpp Normal file
View File

@@ -0,0 +1,358 @@
/* ScummVM - Graphic Adventure Engine
*
* ScummVM is the legal property of its developers, whose names
* are too numerous to list here. Please refer to the COPYRIGHT
* file distributed with this source distribution.
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <http://www.gnu.org/licenses/>.
*
*/
#include "lastexpress/lastexpress.h"
namespace LastExpress {
void LogicManager::CONS_DemoFrancois(int chapter) {
switch (chapter) {
case 0:
_engine->getMessageManager()->setMessageHandle(
kCharacterFrancois,
_functionsDemoFrancois[getCharacter(kCharacterFrancois).callbacks[getCharacter(kCharacterFrancois).currentCall]]
);
break;
case 1:
CONS_DemoFrancois_Birth(0, 0, 0, 0);
break;
case 2:
CONS_DemoFrancois_StartPart2(0, 0, 0, 0);
break;
case 3:
CONS_DemoFrancois_StartPart3(0, 0, 0, 0);
break;
case 4:
CONS_DemoFrancois_StartPart4(0, 0, 0, 0);
break;
case 5:
CONS_DemoFrancois_StartPart5(0, 0, 0, 0);
break;
default:
break;
}
}
void LogicManager::DemoFrancoisCall(CALL_PARAMS) {
getCharacter(kCharacterFrancois).currentCall++;
(this->*functionPointer)(param1, param2, param3, param4);
}
void LogicManager::CONS_DemoFrancois_DoSeqOtis(CONS_PARAMS) {
CharacterCallParams *params = &getCharacter(kCharacterFrancois).callParams[getCharacter(kCharacterFrancois).currentCall];
_engine->getMessageManager()->setMessageHandle(kCharacterFrancois, &LogicManager::HAND_DemoFrancois_DoSeqOtis);
getCharacter(kCharacterFrancois).callbacks[getCharacter(kCharacterFrancois).currentCall] = 1;
params->clear();
strncpy((char *)&params->parameters[0], param1.stringParam, 12);
fedEx(kCharacterFrancois, kCharacterFrancois, 12, 0);
}
void LogicManager::HAND_DemoFrancois_DoSeqOtis(HAND_PARAMS) {
if (msg->action == 3) {
getCharacter(kCharacterFrancois).currentCall--;
_engine->getMessageManager()->setMessageHandle(kCharacterFrancois, _functionsDemoFrancois[getCharacter(kCharacterFrancois).callbacks[getCharacter(kCharacterFrancois).currentCall]]);
fedEx(kCharacterFrancois, kCharacterFrancois, 18, 0);
} else if (msg->action == 12) {
startSeqOtis(kCharacterFrancois, (char *)&getCharacterCurrentParams(kCharacterFrancois)[0]);
}
}
void LogicManager::CONS_DemoFrancois_SaveGame(CONS_PARAMS) {
CharacterCallParams *params = &getCharacter(kCharacterFrancois).callParams[getCharacter(kCharacterFrancois).currentCall];
_engine->getMessageManager()->setMessageHandle(kCharacterFrancois, &LogicManager::HAND_DemoFrancois_SaveGame);
getCharacter(kCharacterFrancois).callbacks[getCharacter(kCharacterFrancois).currentCall] = 2;
params->clear();
params->parameters[0] = param1.intParam;
params->parameters[1] = param2.intParam;
fedEx(kCharacterFrancois, kCharacterFrancois, 12, 0);
}
void LogicManager::HAND_DemoFrancois_SaveGame(HAND_PARAMS) {
switch (msg->action) {
case 0:
getCharacter(kCharacterFrancois).currentCall--;
_engine->getMessageManager()->setMessageHandle(kCharacterFrancois, _functionsDemoFrancois[getCharacter(kCharacterFrancois).callbacks[getCharacter(kCharacterFrancois).currentCall]]);
fedEx(kCharacterFrancois, kCharacterFrancois, 18, 0);
break;
case 12:
save(
kCharacterFrancois,
getCharacterCurrentParams(kCharacterFrancois)[0],
getCharacterCurrentParams(kCharacterFrancois)[1]
);
getCharacter(kCharacterFrancois).currentCall--;
_engine->getMessageManager()->setMessageHandle(kCharacterFrancois, _functionsDemoFrancois[getCharacter(kCharacterFrancois).callbacks[getCharacter(kCharacterFrancois).currentCall]]);
fedEx(kCharacterFrancois, kCharacterFrancois, 18, 0);
break;
default:
break;
}
}
void LogicManager::CONS_DemoFrancois_Birth(CONS_PARAMS) {
CharacterCallParams *params = &getCharacter(kCharacterFrancois).callParams[getCharacter(kCharacterFrancois).currentCall];
_engine->getMessageManager()->setMessageHandle(kCharacterFrancois, &LogicManager::HAND_DemoFrancois_Birth);
getCharacter(kCharacterFrancois).callbacks[getCharacter(kCharacterFrancois).currentCall] = 3;
params->clear();
fedEx(kCharacterFrancois, kCharacterFrancois, 12, 0);
}
void LogicManager::HAND_DemoFrancois_Birth(HAND_PARAMS) {
switch (msg->action) {
case 0:
if (whoRunningDialog(kCharacterFrancois)) {
if (whoOnScreen(kCharacterFrancois) && whoFacingCath(kCharacterFrancois)) {
if (nearChar(kCharacterFrancois, kCharacterCath, 2500) && !_doneNIS[kEventFrancoisWhistleD])
getCharacter(kCharacterFrancois).inventoryItem = 0x80;
} else {
getCharacter(kCharacterFrancois).inventoryItem = 0;
}
if (getCharacterCurrentParams(kCharacterFrancois)[4]) {
getCharacterCurrentParams(kCharacterFrancois)[4]--;
} else if (walk(kCharacterFrancois, *getCharacterCurrentParams(kCharacterFrancois), getCharacterCurrentParams(kCharacterFrancois)[1])) {
if (getCharacterCurrentParams(kCharacterFrancois)[1] == 540) {
getCharacterCurrentParams(kCharacterFrancois)[0] = 4;
getCharacterCurrentParams(kCharacterFrancois)[1] = 9460;
getCharacterCurrentParams(kCharacterFrancois)[4] = 120;
} else {
getCharacterCurrentParams(kCharacterFrancois)[0] = 3;
getCharacterCurrentParams(kCharacterFrancois)[1] = 540;
getCharacterCurrentParams(kCharacterFrancois)[4] = 15;
getCharacterCurrentParams(kCharacterFrancois)[3] = 0;
send(kCharacterFrancois, kCharacterCond2, 225932896, 0);
}
}
if (nearX(kCharacterFrancois, 2000, 500) &&
getCharacter(kCharacterFrancois).direction == 2 &&
checkLoc(kCharacterFrancois, 4) && getCharacterCurrentParams(kCharacterFrancois)[3]) {
getCharacter(kCharacterFrancois).callbacks[getCharacter(kCharacterFrancois).currentCall + 8] = 1;
DemoFrancoisCall(&LogicManager::CONS_DemoFrancois_DoSeqOtis, "605A", 0, 0, 0);
}
return;
}
if (getCharacterCurrentParams(kCharacterFrancois)[5] || (getCharacterCurrentParams(kCharacterFrancois)[5] = getCharacterCurrentParams(kCharacterFrancois)[2] + _realTime,
getCharacterCurrentParams(kCharacterFrancois)[5] != 0)) {
if (_realTime <= getCharacterCurrentParams(kCharacterFrancois)[5]) {
if (whoOnScreen(kCharacterFrancois) && whoFacingCath(kCharacterFrancois)) {
if (nearChar(kCharacterFrancois, kCharacterCath, 2500) && !_doneNIS[kEventFrancoisWhistleD])
getCharacter(kCharacterFrancois).inventoryItem = 0x80;
} else {
getCharacter(kCharacterFrancois).inventoryItem = 0;
}
if (getCharacterCurrentParams(kCharacterFrancois)[4]) {
getCharacterCurrentParams(kCharacterFrancois)[4]--;
} else if (walk(kCharacterFrancois, *getCharacterCurrentParams(kCharacterFrancois), getCharacterCurrentParams(kCharacterFrancois)[1])) {
if (getCharacterCurrentParams(kCharacterFrancois)[1] == 540) {
getCharacterCurrentParams(kCharacterFrancois)[0] = 4;
getCharacterCurrentParams(kCharacterFrancois)[1] = 9460;
getCharacterCurrentParams(kCharacterFrancois)[4] = 120;
} else {
getCharacterCurrentParams(kCharacterFrancois)[0] = 3;
getCharacterCurrentParams(kCharacterFrancois)[1] = 540;
getCharacterCurrentParams(kCharacterFrancois)[4] = 15;
getCharacterCurrentParams(kCharacterFrancois)[3] = 0;
send(kCharacterFrancois, kCharacterCond2, 225932896, 0);
}
}
if (nearX(kCharacterFrancois, 2000, 500) &&
getCharacter(kCharacterFrancois).direction == 2 &&
checkLoc(kCharacterFrancois, 4) && getCharacterCurrentParams(kCharacterFrancois)[3]) {
getCharacter(kCharacterFrancois).callbacks[getCharacter(kCharacterFrancois).currentCall + 8] = 1;
DemoFrancoisCall(&LogicManager::CONS_DemoFrancois_DoSeqOtis, "605A", 0, 0, 0);
}
return;
}
getCharacterCurrentParams(kCharacterFrancois)[5] = 0x7FFFFFFF;
}
if (rnd(2) == 0) {
playDialog(kCharacterFrancois, "Fra1002G", -1, 0);
} else {
playDialog(kCharacterFrancois, "Fra1002A", -1, 0);
}
getCharacterCurrentParams(kCharacterFrancois)[5] = 0;
getCharacterCurrentParams(kCharacterFrancois)[2] = 15 * rnd(7);
if (whoOnScreen(kCharacterFrancois) && whoFacingCath(kCharacterFrancois)) {
if (nearChar(kCharacterFrancois, kCharacterCath, 2500) && !_doneNIS[kEventFrancoisWhistleD])
getCharacter(kCharacterFrancois).inventoryItem = 0x80;
} else {
getCharacter(kCharacterFrancois).inventoryItem = 0;
}
if (getCharacterCurrentParams(kCharacterFrancois)[4]) {
getCharacterCurrentParams(kCharacterFrancois)[4]--;
} else if (walk(kCharacterFrancois, *getCharacterCurrentParams(kCharacterFrancois), getCharacterCurrentParams(kCharacterFrancois)[1])) {
if (getCharacterCurrentParams(kCharacterFrancois)[1] == 540) {
getCharacterCurrentParams(kCharacterFrancois)[0] = 4;
getCharacterCurrentParams(kCharacterFrancois)[1] = 9460;
getCharacterCurrentParams(kCharacterFrancois)[4] = 120;
} else {
getCharacterCurrentParams(kCharacterFrancois)[0] = 3;
getCharacterCurrentParams(kCharacterFrancois)[1] = 540;
getCharacterCurrentParams(kCharacterFrancois)[4] = 15;
getCharacterCurrentParams(kCharacterFrancois)[3] = 0;
send(kCharacterFrancois, kCharacterCond2, 225932896, 0);
}
}
if (nearX(kCharacterFrancois, 2000, 500) &&
getCharacter(kCharacterFrancois).direction == 2 &&
checkLoc(kCharacterFrancois, 4) && getCharacterCurrentParams(kCharacterFrancois)[3]) {
getCharacter(kCharacterFrancois).callbacks[getCharacter(kCharacterFrancois).currentCall + 8] = 1;
DemoFrancoisCall(&LogicManager::CONS_DemoFrancois_DoSeqOtis, "605A", 0, 0, 0);
}
break;
case 1:
getCharacter(kCharacterFrancois).inventoryItem = 0;
if (whoRunningDialog(kCharacterFrancois))
fadeDialog(kCharacterFrancois);
getCharacter(kCharacterFrancois).callbacks[getCharacter(kCharacterFrancois).currentCall + 8] = 2;
DemoFrancoisCall(&LogicManager::CONS_DemoFrancois_SaveGame, 2, kEventFrancoisWhistle, 0, 0);
break;
case 12:
getCharacter(kCharacterFrancois).characterPosition.car = kCarRedSleeping;
getCharacter(kCharacterFrancois).characterPosition.position = 2088;
getCharacter(kCharacterFrancois).characterPosition.location = 0;
getCharacter(kCharacterFrancois).clothes = 1;
getCharacter(kCharacterFrancois).walkStepSize = 100;
getCharacter(kCharacterFrancois).inventoryItem = 0;
getCharacterCurrentParams(kCharacterFrancois)[0] = kCarRedSleeping;
getCharacterCurrentParams(kCharacterFrancois)[1] = 9460;
walk(kCharacterFrancois, kCarRedSleeping, 9460);
getCharacterCurrentParams(kCharacterFrancois)[2] = 15 * rnd(7);
break;
case 18:
if (getCharacter(kCharacterFrancois).callbacks[getCharacter(kCharacterFrancois).currentCall + 8] == 1) {
send(kCharacterFrancois, kCharacterCond2, 168253822, 0);
getCharacterCurrentParams(kCharacterFrancois)[0] = kCarRedSleeping;
getCharacterCurrentParams(kCharacterFrancois)[1] = 9460;
getCharacter(kCharacterFrancois).characterPosition.position = 2088;
walk(kCharacterFrancois, getCharacterCurrentParams(kCharacterFrancois)[0], getCharacterCurrentParams(kCharacterFrancois)[1]);
} else if (getCharacter(kCharacterFrancois).callbacks[getCharacter(kCharacterFrancois).currentCall + 8] == 2) {
playNIS(kEventFrancoisWhistleD);
if (getCharacter(kCharacterFrancois).direction == 1) {
bumpCathFx(kCarRedSleeping, getCharacter(kCharacterFrancois).characterPosition.position - 750);
} else {
bumpCathRx(kCarRedSleeping, getCharacter(kCharacterFrancois).characterPosition.position + 750);
}
}
break;
case 205346192:
getCharacterCurrentParams(kCharacterFrancois)[3] = 1;
break;
default:
break;
}
}
void LogicManager::CONS_DemoFrancois_StartPart2(CONS_PARAMS) {
CharacterCallParams *params = &getCharacter(kCharacterFrancois).callParams[getCharacter(kCharacterFrancois).currentCall];
_engine->getMessageManager()->setMessageHandle(kCharacterFrancois, &LogicManager::HAND_DemoFrancois_StartPart2);
getCharacter(kCharacterFrancois).callbacks[getCharacter(kCharacterFrancois).currentCall] = 4;
params->clear();
fedEx(kCharacterFrancois, kCharacterFrancois, 12, 0);
}
void LogicManager::HAND_DemoFrancois_StartPart2(HAND_PARAMS) {
// No-op
}
void LogicManager::CONS_DemoFrancois_StartPart3(CONS_PARAMS) {
CharacterCallParams *params = &getCharacter(kCharacterFrancois).callParams[getCharacter(kCharacterFrancois).currentCall];
_engine->getMessageManager()->setMessageHandle(kCharacterFrancois, &LogicManager::HAND_DemoFrancois_StartPart3);
getCharacter(kCharacterFrancois).callbacks[getCharacter(kCharacterFrancois).currentCall] = 5;
params->clear();
fedEx(kCharacterFrancois, kCharacterFrancois, 12, 0);
}
void LogicManager::HAND_DemoFrancois_StartPart3(HAND_PARAMS) {
// No-op
}
void LogicManager::CONS_DemoFrancois_StartPart4(CONS_PARAMS) {
CharacterCallParams *params = &getCharacter(kCharacterFrancois).callParams[getCharacter(kCharacterFrancois).currentCall];
_engine->getMessageManager()->setMessageHandle(kCharacterFrancois, &LogicManager::HAND_DemoFrancois_StartPart4);
getCharacter(kCharacterFrancois).callbacks[getCharacter(kCharacterFrancois).currentCall] = 6;
params->clear();
fedEx(kCharacterFrancois, kCharacterFrancois, 12, 0);
}
void LogicManager::HAND_DemoFrancois_StartPart4(HAND_PARAMS) {
// No-op
}
void LogicManager::CONS_DemoFrancois_StartPart5(CONS_PARAMS) {
CharacterCallParams *params = &getCharacter(kCharacterFrancois).callParams[getCharacter(kCharacterFrancois).currentCall];
_engine->getMessageManager()->setMessageHandle(kCharacterFrancois, &LogicManager::HAND_DemoFrancois_StartPart5);
getCharacter(kCharacterFrancois).callbacks[getCharacter(kCharacterFrancois).currentCall] = 7;
params->clear();
fedEx(kCharacterFrancois, kCharacterFrancois, 12, 0);
}
void LogicManager::HAND_DemoFrancois_StartPart5(HAND_PARAMS) {
// No-op
}
void (LogicManager::*LogicManager::_functionsDemoFrancois[])(HAND_PARAMS) = {
nullptr,
&LogicManager::HAND_DemoFrancois_DoSeqOtis,
&LogicManager::HAND_DemoFrancois_SaveGame,
&LogicManager::HAND_DemoFrancois_Birth,
&LogicManager::HAND_DemoFrancois_StartPart2,
&LogicManager::HAND_DemoFrancois_StartPart3,
&LogicManager::HAND_DemoFrancois_StartPart4,
&LogicManager::HAND_DemoFrancois_StartPart5
};
} // End of namespace LastExpress

278
engines/lastexpress/characters/demo/demo_ivo.cpp Normal file
View File

@@ -0,0 +1,278 @@
/* ScummVM - Graphic Adventure Engine
*
* ScummVM is the legal property of its developers, whose names
* are too numerous to list here. Please refer to the COPYRIGHT
* file distributed with this source distribution.
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <http://www.gnu.org/licenses/>.
*
*/
#include "lastexpress/lastexpress.h"
namespace LastExpress {
void LogicManager::CONS_DemoIvo(int chapter) {
switch (chapter) {
case 0:
_engine->getMessageManager()->setMessageHandle(
kCharacterIvo,
_functionsDemoIvo[getCharacter(kCharacterIvo).callbacks[getCharacter(kCharacterIvo).currentCall]]
);
break;
case 1:
CONS_DemoIvo_Birth(0, 0, 0, 0);
break;
case 2:
CONS_DemoIvo_StartPart2(0, 0, 0, 0);
break;
case 3:
CONS_DemoIvo_StartPart3(0, 0, 0, 0);
break;
case 4:
CONS_DemoIvo_StartPart4(0, 0, 0, 0);
break;
case 5:
CONS_DemoIvo_StartPart5(0, 0, 0, 0);
break;
default:
break;
}
}
void LogicManager::DemoIvoCall(CALL_PARAMS) {
getCharacter(kCharacterIvo).currentCall++;
(this->*functionPointer)(param1, param2, param3, param4);
}
void LogicManager::CONS_DemoIvo_WaitRCClear(CONS_PARAMS) {
CharacterCallParams *params = &getCharacter(kCharacterIvo).callParams[getCharacter(kCharacterIvo).currentCall];
_engine->getMessageManager()->setMessageHandle(kCharacterIvo, &LogicManager::HAND_DemoIvo_WaitRCClear);
getCharacter(kCharacterIvo).callbacks[getCharacter(kCharacterIvo).currentCall] = 1;
params->clear();
fedEx(kCharacterIvo, kCharacterIvo, 12, 0);
}
void LogicManager::HAND_DemoIvo_WaitRCClear(HAND_PARAMS) {
switch (msg->action) {
case 0:
case 12:
if (rcClear()) {
getCharacter(kCharacterIvo).currentCall--;
_engine->getMessageManager()->setMessageHandle(kCharacterIvo, _functionsDemoIvo[getCharacter(kCharacterIvo).callbacks[getCharacter(kCharacterIvo).currentCall]]);
fedEx(kCharacterIvo, kCharacterIvo, 18, 0);
}
break;
default:
break;
}
}
void LogicManager::CONS_DemoIvo_DoSeqOtis(CONS_PARAMS) {
CharacterCallParams *params = &getCharacter(kCharacterIvo).callParams[getCharacter(kCharacterIvo).currentCall];
_engine->getMessageManager()->setMessageHandle(kCharacterIvo, &LogicManager::HAND_DemoIvo_DoSeqOtis);
getCharacter(kCharacterIvo).callbacks[getCharacter(kCharacterIvo).currentCall] = 2;
params->clear();
strncpy((char *)&params->parameters[0], param1.stringParam, 12);
fedEx(kCharacterIvo, kCharacterIvo, 12, 0);
}
void LogicManager::HAND_DemoIvo_DoSeqOtis(HAND_PARAMS) {
switch (msg->action) {
case 3:
getCharacter(kCharacterIvo).currentCall--;
_engine->getMessageManager()->setMessageHandle(kCharacterIvo, _functionsDemoIvo[getCharacter(kCharacterIvo).callbacks[getCharacter(kCharacterIvo).currentCall]]);
fedEx(kCharacterIvo, kCharacterIvo, 18, 0);
break;
case 12:
startSeqOtis(kCharacterIvo, (char *)&getCharacterCurrentParams(kCharacterIvo)[0]);
break;
default:
break;
}
}
void LogicManager::CONS_DemoIvo_FinishSeqOtis(CONS_PARAMS) {
CharacterCallParams *params = &getCharacter(kCharacterIvo).callParams[getCharacter(kCharacterIvo).currentCall];
_engine->getMessageManager()->setMessageHandle(kCharacterIvo, &LogicManager::HAND_DemoIvo_FinishSeqOtis);
getCharacter(kCharacterIvo).callbacks[getCharacter(kCharacterIvo).currentCall] = 3;
params->clear();
fedEx(kCharacterIvo, kCharacterIvo, 12, 0);
}
void LogicManager::HAND_DemoIvo_FinishSeqOtis(HAND_PARAMS) {
switch (msg->action) {
case 3:
getCharacter(kCharacterIvo).currentCall--;
_engine->getMessageManager()->setMessageHandle(kCharacterIvo, _functionsDemoIvo[getCharacter(kCharacterIvo).callbacks[getCharacter(kCharacterIvo).currentCall]]);
fedEx(kCharacterIvo, kCharacterIvo, 18, 0);
break;
default:
break;
}
}
void LogicManager::CONS_DemoIvo_DoSplitOtis023A(CONS_PARAMS) {
CharacterCallParams *params = &getCharacter(kCharacterIvo).callParams[getCharacter(kCharacterIvo).currentCall];
_engine->getMessageManager()->setMessageHandle(kCharacterIvo, &LogicManager::HAND_DemoIvo_DoSplitOtis023A);
getCharacter(kCharacterIvo).callbacks[getCharacter(kCharacterIvo).currentCall] = 4;
params->clear();
fedEx(kCharacterIvo, kCharacterIvo, 12, 0);
}
void LogicManager::HAND_DemoIvo_DoSplitOtis023A(HAND_PARAMS) {
switch (msg->action) {
case 3:
endGraphics(kCharacterTableD);
send(kCharacterIvo, kCharacterTableC, 136455232, 0);
getCharacter(kCharacterIvo).currentCall--;
_engine->getMessageManager()->setMessageHandle(kCharacterIvo, _functionsDemoIvo[getCharacter(kCharacterIvo).callbacks[getCharacter(kCharacterIvo).currentCall]]);
fedEx(kCharacterIvo, kCharacterIvo, 18, 0);
break;
case 12:
startSeqOtis(kCharacterIvo, "023A1");
startSeqOtis(kCharacterTableD, "023A2");
startSeqOtis(kCharacterTableC, "023A3");
break;
default:
break;
}
}
void LogicManager::CONS_DemoIvo_Birth(CONS_PARAMS) {
CharacterCallParams *params = &getCharacter(kCharacterIvo).callParams[getCharacter(kCharacterIvo).currentCall];
_engine->getMessageManager()->setMessageHandle(kCharacterIvo, &LogicManager::HAND_DemoIvo_Birth);
getCharacter(kCharacterIvo).callbacks[getCharacter(kCharacterIvo).currentCall] = 5;
params->clear();
fedEx(kCharacterIvo, kCharacterIvo, 12, 0);
}
void LogicManager::HAND_DemoIvo_Birth(HAND_PARAMS) {
switch (msg->action) {
case 12:
getCharacter(kCharacterIvo).characterPosition.position = 1539;
getCharacter(kCharacterIvo).characterPosition.location = 0;
getCharacter(kCharacterIvo).characterPosition.car = kCarRestaurant;
getCharacter(kCharacterIvo).callbacks[getCharacter(kCharacterIvo).currentCall + 8] = 1;
DemoIvoCall(&LogicManager::CONS_DemoIvo_WaitRCClear, 0, 0, 0, 0);
break;
case 18:
switch (getCharacter(kCharacterIvo).callbacks[getCharacter(kCharacterIvo).currentCall + 8]) {
case 1:
getCharacter(kCharacterIvo).callbacks[getCharacter(kCharacterIvo).currentCall + 8] = 2;
DemoIvoCall(&LogicManager::CONS_DemoIvo_DoSeqOtis, "809US", 0, 0, 0);
break;
case 2:
getCharacter(kCharacterIvo).callbacks[getCharacter(kCharacterIvo).currentCall + 8] = 3;
DemoIvoCall(&LogicManager::CONS_DemoIvo_DoSplitOtis023A, 0, 0, 0, 0);
break;
case 3:
getCharacter(kCharacterIvo).characterPosition.location = 1;
startCycOtis(kCharacterIvo, "023B");
break;
default:
break;
}
break;
default:
break;
}
}
void LogicManager::CONS_DemoIvo_StartPart2(CONS_PARAMS) {
CharacterCallParams *params = &getCharacter(kCharacterIvo).callParams[getCharacter(kCharacterIvo).currentCall];
_engine->getMessageManager()->setMessageHandle(kCharacterIvo, &LogicManager::HAND_DemoIvo_StartPart2);
getCharacter(kCharacterIvo).callbacks[getCharacter(kCharacterIvo).currentCall] = 6;
params->clear();
fedEx(kCharacterIvo, kCharacterIvo, 12, 0);
}
void LogicManager::HAND_DemoIvo_StartPart2(HAND_PARAMS) {
// No-op
}
void LogicManager::CONS_DemoIvo_StartPart3(CONS_PARAMS) {
CharacterCallParams *params = &getCharacter(kCharacterIvo).callParams[getCharacter(kCharacterIvo).currentCall];
_engine->getMessageManager()->setMessageHandle(kCharacterIvo, &LogicManager::HAND_DemoIvo_StartPart3);
getCharacter(kCharacterIvo).callbacks[getCharacter(kCharacterIvo).currentCall] = 7;
params->clear();
fedEx(kCharacterIvo, kCharacterIvo, 12, 0);
}
void LogicManager::HAND_DemoIvo_StartPart3(HAND_PARAMS) {
// No-op
}
void LogicManager::CONS_DemoIvo_StartPart4(CONS_PARAMS) {
CharacterCallParams *params = &getCharacter(kCharacterIvo).callParams[getCharacter(kCharacterIvo).currentCall];
_engine->getMessageManager()->setMessageHandle(kCharacterIvo, &LogicManager::HAND_DemoIvo_StartPart4);
getCharacter(kCharacterIvo).callbacks[getCharacter(kCharacterIvo).currentCall] = 8;
params->clear();
fedEx(kCharacterIvo, kCharacterIvo, 12, 0);
}
void LogicManager::HAND_DemoIvo_StartPart4(HAND_PARAMS) {
// No-op
}
void LogicManager::CONS_DemoIvo_StartPart5(CONS_PARAMS) {
CharacterCallParams *params = &getCharacter(kCharacterIvo).callParams[getCharacter(kCharacterIvo).currentCall];
_engine->getMessageManager()->setMessageHandle(kCharacterIvo, &LogicManager::HAND_DemoIvo_StartPart5);
getCharacter(kCharacterIvo).callbacks[getCharacter(kCharacterIvo).currentCall] = 9;
params->clear();
fedEx(kCharacterIvo, kCharacterIvo, 12, 0);
}
void LogicManager::HAND_DemoIvo_StartPart5(HAND_PARAMS) {
// No-op
}
void (LogicManager::*LogicManager::_functionsDemoIvo[])(HAND_PARAMS) = {
nullptr,
&LogicManager::HAND_DemoIvo_WaitRCClear,
&LogicManager::HAND_DemoIvo_DoSeqOtis,
&LogicManager::HAND_DemoIvo_FinishSeqOtis,
&LogicManager::HAND_DemoIvo_DoSplitOtis023A,
&LogicManager::HAND_DemoIvo_Birth,
&LogicManager::HAND_DemoIvo_StartPart2,
&LogicManager::HAND_DemoIvo_StartPart3,
&LogicManager::HAND_DemoIvo_StartPart4,
&LogicManager::HAND_DemoIvo_StartPart5
};
} // End of namespace LastExpress

252
engines/lastexpress/characters/demo/demo_madame.cpp Normal file
View File

@@ -0,0 +1,252 @@
/* ScummVM - Graphic Adventure Engine
*
* ScummVM is the legal property of its developers, whose names
* are too numerous to list here. Please refer to the COPYRIGHT
* file distributed with this source distribution.
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <http://www.gnu.org/licenses/>.
*
*/
#include "lastexpress/lastexpress.h"
namespace LastExpress {
void LogicManager::CONS_DemoMadame(int chapter) {
switch (chapter) {
case 0:
_engine->getMessageManager()->setMessageHandle(
kCharacterMadame,
_functionsDemoMadame[getCharacter(kCharacterMadame).callbacks[getCharacter(kCharacterMadame).currentCall]]
);
break;
case 1:
CONS_DemoMadame_Birth(0, 0, 0, 0);
break;
case 2:
CONS_DemoMadame_StartPart2(0, 0, 0, 0);
break;
case 3:
CONS_DemoMadame_StartPart3(0, 0, 0, 0);
break;
case 4:
CONS_DemoMadame_StartPart4(0, 0, 0, 0);
break;
case 5:
CONS_DemoMadame_StartPart5(0, 0, 0, 0);
break;
default:
break;
}
}
void LogicManager::DemoMadameCall(CALL_PARAMS) {
getCharacter(kCharacterMadame).currentCall++;
(this->*functionPointer)(param1, param2, param3, param4);
}
void LogicManager::CONS_DemoMadame_DoDialog(CONS_PARAMS) {
CharacterCallParams *params = &getCharacter(kCharacterMadame).callParams[getCharacter(kCharacterMadame).currentCall];
_engine->getMessageManager()->setMessageHandle(kCharacterMadame, &LogicManager::HAND_DemoMadame_DoDialog);
getCharacter(kCharacterMadame).callbacks[getCharacter(kCharacterMadame).currentCall] = 1;
params->clear();
strncpy((char *)&params->parameters[0], param1.stringParam, 12);
fedEx(kCharacterMadame, kCharacterMadame, 12, 0);
}
void LogicManager::HAND_DemoMadame_DoDialog(HAND_PARAMS) {
switch (msg->action) {
case 2:
getCharacter(kCharacterMadame).currentCall--;
_engine->getMessageManager()->setMessageHandle(kCharacterMadame, _functionsDemoMadame[getCharacter(kCharacterMadame).callbacks[getCharacter(kCharacterMadame).currentCall]]);
fedEx(kCharacterMadame, kCharacterMadame, 18, 0);
break;
case 12:
playDialog(kCharacterMadame, (char *)&getCharacterCurrentParams(kCharacterMadame)[0], -1, 0);
break;
default:
break;
}
}
void LogicManager::CONS_DemoMadame_Birth(CONS_PARAMS) {
CharacterCallParams *params = &getCharacter(kCharacterMadame).callParams[getCharacter(kCharacterMadame).currentCall];
_engine->getMessageManager()->setMessageHandle(kCharacterMadame, &LogicManager::HAND_DemoMadame_Birth);
getCharacter(kCharacterMadame).callbacks[getCharacter(kCharacterMadame).currentCall] = 2;
params->clear();
fedEx(kCharacterMadame, kCharacterMadame, 12, 0);
}
void LogicManager::HAND_DemoMadame_Birth(HAND_PARAMS) {
switch (msg->action) {
case 0:
if (getCharacterCurrentParams(kCharacterMadame)[2]) {
if (getCharacterCurrentParams(kCharacterMadame)[3] ||
(getCharacterCurrentParams(kCharacterMadame)[3] = _realTime + 75,
_realTime != -75)) {
if (_realTime <= getCharacterCurrentParams(kCharacterMadame)[3])
return;
getCharacterCurrentParams(kCharacterMadame)[3] = 0x7FFFFFFF;
}
getCharacterCurrentParams(kCharacterMadame)[2] = 0;
getCharacterCurrentParams(kCharacterMadame)[1] = 1;
setDoor(33, kCharacterMadame, 1, 0, 0);
getCharacterCurrentParams(kCharacterMadame)[3] = 0;
} else {
getCharacterCurrentParams(kCharacterMadame)[3] = 0;
}
break;
case 8:
case 9:
if (getCharacterCurrentParams(kCharacterMadame)[2]) {
setDoor(33, kCharacterMadame, 1, 0, 0);
getCharacter(kCharacterMadame).callbacks[getCharacter(kCharacterMadame).currentCall + 8] = 5;
DemoMadameCall(&LogicManager::CONS_DemoMadame_DoDialog, getCathSorryDialog(), 0, 0, 0);
} else {
getCharacterCurrentParams(kCharacterMadame)[0]++;
setDoor(33, kCharacterMadame, 1, 0, 0);
if (msg->action == 9) {
getCharacter(kCharacterMadame).callbacks[getCharacter(kCharacterMadame).currentCall + 8] = 1;
DemoMadameCall(&LogicManager::CONS_DemoMadame_DoDialog, "LIB013", 0, 0, 0);
} else {
getCharacter(kCharacterMadame).callbacks[getCharacter(kCharacterMadame).currentCall + 8] = 2;
DemoMadameCall(&LogicManager::CONS_DemoMadame_DoDialog, "LIB012", 0, 0, 0);
}
}
break;
case 12:
getCharacter(kCharacterMadame).characterPosition.car = 4;
getCharacter(kCharacterMadame).characterPosition.location = 1;
getCharacter(kCharacterMadame).characterPosition.position = 7500;
setDoor(33, kCharacterMadame, 1, 10, 9);
break;
case 17:
if (getCharacterCurrentParams(kCharacterMadame)[1] || getCharacterCurrentParams(kCharacterMadame)[2]) {
setDoor(33, kCharacterMadame, 1, 10, 9);
getCharacterCurrentParams(kCharacterMadame)[1] = 0;
getCharacterCurrentParams(kCharacterMadame)[2] = 0;
getCharacterCurrentParams(kCharacterMadame)[0] = 0;
}
break;
case 18:
switch (getCharacter(kCharacterMadame).callbacks[getCharacter(kCharacterMadame).currentCall + 8]) {
case 1:
case 2:
if (getCharacterCurrentParams(kCharacterMadame)[0] <= 1) {
getCharacter(kCharacterMadame).callbacks[getCharacter(kCharacterMadame).currentCall + 8] = 4;
DemoMadameCall(&LogicManager::CONS_DemoMadame_DoDialog, "MME1038", 0, 0, 0);
} else {
getCharacter(kCharacterMadame).callbacks[getCharacter(kCharacterMadame).currentCall + 8] = 3;
DemoMadameCall(&LogicManager::CONS_DemoMadame_DoDialog, "MME1038C", 0, 0, 0);
}
break;
case 3:
case 4:
setDoor(33, kCharacterMadame, 1, 14, 0);
getCharacterCurrentParams(kCharacterMadame)[2] = 1;
break;
case 5:
getCharacterCurrentParams(kCharacterMadame)[2] = 0;
getCharacterCurrentParams(kCharacterMadame)[1] = 1;
break;
default:
break;
}
break;
default:
break;
}
}
void LogicManager::CONS_DemoMadame_StartPart2(CONS_PARAMS) {
CharacterCallParams *params = &getCharacter(kCharacterMadame).callParams[getCharacter(kCharacterMadame).currentCall];
_engine->getMessageManager()->setMessageHandle(kCharacterMadame, &LogicManager::HAND_DemoMadame_StartPart2);
getCharacter(kCharacterMadame).callbacks[getCharacter(kCharacterMadame).currentCall] = 3;
params->clear();
fedEx(kCharacterMadame, kCharacterMadame, 12, 0);
}
void LogicManager::HAND_DemoMadame_StartPart2(HAND_PARAMS) {
// No-op
}
void LogicManager::CONS_DemoMadame_StartPart3(CONS_PARAMS) {
CharacterCallParams *params = &getCharacter(kCharacterMadame).callParams[getCharacter(kCharacterMadame).currentCall];
_engine->getMessageManager()->setMessageHandle(kCharacterMadame, &LogicManager::HAND_DemoMadame_StartPart3);
getCharacter(kCharacterMadame).callbacks[getCharacter(kCharacterMadame).currentCall] = 4;
params->clear();
fedEx(kCharacterMadame, kCharacterMadame, 12, 0);
}
void LogicManager::HAND_DemoMadame_StartPart3(HAND_PARAMS) {
// No-op
}
void LogicManager::CONS_DemoMadame_StartPart4(CONS_PARAMS) {
CharacterCallParams *params = &getCharacter(kCharacterMadame).callParams[getCharacter(kCharacterMadame).currentCall];
_engine->getMessageManager()->setMessageHandle(kCharacterMadame, &LogicManager::HAND_DemoMadame_StartPart4);
getCharacter(kCharacterMadame).callbacks[getCharacter(kCharacterMadame).currentCall] = 5;
params->clear();
fedEx(kCharacterMadame, kCharacterMadame, 12, 0);
}
void LogicManager::HAND_DemoMadame_StartPart4(HAND_PARAMS) {
// No-op
}
void LogicManager::CONS_DemoMadame_StartPart5(CONS_PARAMS) {
CharacterCallParams *params = &getCharacter(kCharacterMadame).callParams[getCharacter(kCharacterMadame).currentCall];
_engine->getMessageManager()->setMessageHandle(kCharacterMadame, &LogicManager::HAND_DemoMadame_StartPart5);
getCharacter(kCharacterMadame).callbacks[getCharacter(kCharacterMadame).currentCall] = 6;
params->clear();
fedEx(kCharacterMadame, kCharacterMadame, 12, 0);
}
void LogicManager::HAND_DemoMadame_StartPart5(HAND_PARAMS) {
// No-op
}
void (LogicManager::*LogicManager::_functionsDemoMadame[])(HAND_PARAMS) = {
nullptr,
&LogicManager::HAND_DemoMadame_DoDialog,
&LogicManager::HAND_DemoMadame_Birth,
&LogicManager::HAND_DemoMadame_StartPart2,
&LogicManager::HAND_DemoMadame_StartPart3,
&LogicManager::HAND_DemoMadame_StartPart4,
&LogicManager::HAND_DemoMadame_StartPart5
};
} // End of namespace LastExpress

319
engines/lastexpress/characters/demo/demo_master.cpp Normal file
View File

@@ -0,0 +1,319 @@
/* ScummVM - Graphic Adventure Engine
*
* ScummVM is the legal property of its developers, whose names
* are too numerous to list here. Please refer to the COPYRIGHT
* file distributed with this source distribution.
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <http://www.gnu.org/licenses/>.
*
*/
#include "lastexpress/lastexpress.h"
namespace LastExpress {
void LogicManager::CONS_DemoMaster(int chapter) {
switch (chapter) {
case 0:
_engine->getMessageManager()->setMessageHandle(
kCharacterMaster,
_functionsDemoMaster[getCharacter(kCharacterMaster).callbacks[getCharacter(kCharacterMaster).currentCall]]
);
break;
case 1:
CONS_DemoMaster_Birth(0, 0, 0, 0);
break;
case 2:
CONS_DemoMaster_StartPart2(0, 0, 0, 0);
break;
case 3:
CONS_DemoMaster_StartPart3(0, 0, 0, 0);
break;
case 4:
CONS_DemoMaster_StartPart4(0, 0, 0, 0);
break;
case 5:
CONS_DemoMaster_StartPart5(0, 0, 0, 0);
break;
default:
break;
}
}
void LogicManager::DemoMasterCall(CALL_PARAMS) {
getCharacter(kCharacterMaster).currentCall++;
(this->*functionPointer)(param1, param2, param3, param4);
}
void LogicManager::CONS_DemoMaster_SaveGame(CONS_PARAMS) {
CharacterCallParams *params = &getCharacter(kCharacterMaster).callParams[getCharacter(kCharacterMaster).currentCall];
_engine->getMessageManager()->setMessageHandle(kCharacterMaster, &LogicManager::HAND_DemoMaster_SaveGame);
getCharacter(kCharacterMaster).callbacks[getCharacter(kCharacterMaster).currentCall] = 1;
params->clear();
params->parameters[0] = param1.intParam;
params->parameters[1] = param2.intParam;
fedEx(kCharacterMaster, kCharacterMaster, 12, 0);
}
void LogicManager::HAND_DemoMaster_SaveGame(HAND_PARAMS) {
switch (msg->action) {
case 0:
getCharacter(kCharacterMaster).currentCall--;
_engine->getMessageManager()->setMessageHandle(
kCharacterMaster,
_functionsDemoMaster[getCharacter(kCharacterMaster).callbacks[getCharacter(kCharacterMaster).currentCall]]
);
fedEx(kCharacterMaster, kCharacterMaster, 18, 0);
break;
case 12:
save(
kCharacterMaster,
getCharacterCurrentParams(kCharacterMaster)[0],
getCharacterCurrentParams(kCharacterMaster)[1]
);
getCharacter(kCharacterMaster).currentCall--;
_engine->getMessageManager()->setMessageHandle(
kCharacterMaster,
_functionsDemoMaster[getCharacter(kCharacterMaster).callbacks[getCharacter(kCharacterMaster).currentCall]]
);
fedEx(kCharacterMaster, kCharacterMaster, 18, 0);
break;
default:
break;
}
}
void LogicManager::CONS_DemoMaster_Birth(CONS_PARAMS) {
CharacterCallParams *params = &getCharacter(kCharacterMaster).callParams[getCharacter(kCharacterMaster).currentCall];
_engine->getMessageManager()->setMessageHandle(kCharacterMaster, &LogicManager::HAND_DemoMaster_Birth);
getCharacter(kCharacterMaster).callbacks[getCharacter(kCharacterMaster).currentCall] = 2;
params->clear();
fedEx(kCharacterMaster, kCharacterMaster, 12, 0);
}
void LogicManager::HAND_DemoMaster_Birth(HAND_PARAMS) {
switch (msg->action) {
case 0:
{
bool playSndFx = false;
bool doBumpCath = false;
if (_globals[kGlobalTrainIsRunning]) {
if (!getCharacterCurrentParams(kCharacterMaster)[3]) {
getCharacterCurrentParams(kCharacterMaster)[3] = _realTime + getCharacterCurrentParams(kCharacterMaster)[0];
if (!getCharacterCurrentParams(kCharacterMaster)[3])
playSndFx = true;
}
if (!playSndFx && _realTime > getCharacterCurrentParams(kCharacterMaster)[3]) {
getCharacterCurrentParams(kCharacterMaster)[3] = 0x7FFFFFFF;
playSndFx = true;
}
if (playSndFx) {
if (!rnd(2)) {
playDialog(kCharacterCath, "ZFX1007B", rnd(15) + 2, 0);
} else {
playDialog(kCharacterCath, "ZFX1005", rnd(15) + 2, 0);
}
getCharacterCurrentParams(kCharacterMaster)[3] = 0;
getCharacterCurrentParams(kCharacterMaster)[0] = 900 * (rnd(5) + 5);
}
}
if (_gameTime > 2268000 && !getCharacterCurrentParams(kCharacterMaster)[4]) {
getCharacterCurrentParams(kCharacterMaster)[4] = 1;
getCharacter(kCharacterMaster).callbacks[getCharacter(kCharacterMaster).currentCall + 8] = 2;
DemoMasterCall(&LogicManager::CONS_DemoMaster_SaveGame, 2, kEventVergesAnnaDead, 0, 0);
break;
}
if (getCharacterCurrentParams(kCharacterMaster)[1]) {
if (!getCharacterCurrentParams(kCharacterMaster)[5]) {
getCharacterCurrentParams(kCharacterMaster)[5] = _gameTime + 900;
if (_gameTime == -900)
doBumpCath = true;
}
if (!doBumpCath && _gameTime > getCharacterCurrentParams(kCharacterMaster)[5]) {
getCharacterCurrentParams(kCharacterMaster)[5] = 0x7FFFFFFF;
doBumpCath = true;
}
if (doBumpCath) {
bumpCath(kCarRestaurant, 58, 255);
}
}
getCharacterCurrentParams(kCharacterMaster)[5] = 0;
if (getCharacterCurrentParams(kCharacterMaster)[1]) {
if (!cathRunningDialog("ZFX1001"))
playDialog(kCharacterCath, "ZFX1001", -1, 0);
}
break;
}
case 12:
_engine->getSoundManager()->startAmbient();
getCharacterCurrentParams(kCharacterMaster)[0] = 900 * (rnd(5) + 5);
setDoor(34, kCharacterCath, 2, 255, 255);
getCharacter(kCharacterMaster).callbacks[getCharacter(kCharacterMaster).currentCall + 8] = 1;
DemoMasterCall(&LogicManager::CONS_DemoMaster_SaveGame, 1, 0, 0, 0);
break;
case 17:
getCharacter(kCharacterMaster).characterPosition.car = getCharacter(kCharacterCath).characterPosition.car;
if (checkCathDir(kCarRestaurant, 81)) {
getCharacterCurrentParams(kCharacterMaster)[1] = 1;
if (!dialogRunning("ZFX1001"))
playDialog(kCharacterCath, "ZFX1001", -1, 0);
} else {
getCharacterCurrentParams(kCharacterMaster)[1] = 0;
if (cathRunningDialog("ZFX1001"))
endDialog("ZFX1001");
}
if (getCharacter(kCharacterCath).characterPosition.car != getCharacterCurrentParams(kCharacterMaster)[2]) {
if (getCharacter(kCharacterCath).characterPosition.car == kCarRestaurant) {
startCycOtis(kCharacterMaster, "RCWND");
} else if (getCharacter(kCharacterCath).characterPosition.car == kCarRedSleeping) {
startCycOtis(kCharacterMaster, "S1WND");
} else {
endGraphics(kCharacterMaster);
}
getCharacterCurrentParams(kCharacterMaster)[2] = getCharacter(kCharacterCath).characterPosition.car;
}
break;
case 18:
{
bool doBumpCath = false;
if (getCharacter(kCharacterMaster).callbacks[getCharacter(kCharacterMaster).currentCall + 8] == 2) {
playNIS(kEventVergesAnnaDead);
endGame(1, 2259000, 58, true);
if (getCharacterCurrentParams(kCharacterMaster)[1]) {
if (!getCharacterCurrentParams(kCharacterMaster)[5]) {
getCharacterCurrentParams(kCharacterMaster)[5] = _gameTime + 900;
if (_gameTime == -900)
doBumpCath = true;
}
if (!doBumpCath && _gameTime > getCharacterCurrentParams(kCharacterMaster)[5]) {
getCharacterCurrentParams(kCharacterMaster)[5] = 0x7FFFFFFF;
doBumpCath = true;
}
if (doBumpCath) {
bumpCath(kCarRestaurant, 58, 255);
}
}
getCharacterCurrentParams(kCharacterMaster)[5] = 0;
if (getCharacterCurrentParams(kCharacterMaster)[1]) {
if (!cathRunningDialog("ZFX1001"))
playDialog(kCharacterCath, "ZFX1001", -1, 0);
}
}
break;
}
default:
break;
}
}
void LogicManager::CONS_DemoMaster_StartPart2(CONS_PARAMS) {
CharacterCallParams *params = &getCharacter(kCharacterMaster).callParams[getCharacter(kCharacterMaster).currentCall];
_engine->getMessageManager()->setMessageHandle(kCharacterMaster, &LogicManager::HAND_DemoMaster_StartPart2);
getCharacter(kCharacterMaster).callbacks[getCharacter(kCharacterMaster).currentCall] = 3;
params->clear();
fedEx(kCharacterMaster, kCharacterMaster, 12, 0);
}
void LogicManager::HAND_DemoMaster_StartPart2(HAND_PARAMS) {
// No-op
}
void LogicManager::CONS_DemoMaster_StartPart3(CONS_PARAMS) {
CharacterCallParams *params = &getCharacter(kCharacterMaster).callParams[getCharacter(kCharacterMaster).currentCall];
_engine->getMessageManager()->setMessageHandle(kCharacterMaster, &LogicManager::HAND_DemoMaster_StartPart3);
getCharacter(kCharacterMaster).callbacks[getCharacter(kCharacterMaster).currentCall] = 4;
params->clear();
fedEx(kCharacterMaster, kCharacterMaster, 12, 0);
}
void LogicManager::HAND_DemoMaster_StartPart3(HAND_PARAMS) {
// No-op
}
void LogicManager::CONS_DemoMaster_StartPart4(CONS_PARAMS) {
CharacterCallParams *params = &getCharacter(kCharacterMaster).callParams[getCharacter(kCharacterMaster).currentCall];
_engine->getMessageManager()->setMessageHandle(kCharacterMaster, &LogicManager::HAND_DemoMaster_StartPart4);
getCharacter(kCharacterMaster).callbacks[getCharacter(kCharacterMaster).currentCall] = 5;
params->clear();
fedEx(kCharacterMaster, kCharacterMaster, 12, 0);
}
void LogicManager::HAND_DemoMaster_StartPart4(HAND_PARAMS) {
// No-op
}
void LogicManager::CONS_DemoMaster_StartPart5(CONS_PARAMS) {
CharacterCallParams *params = &getCharacter(kCharacterMaster).callParams[getCharacter(kCharacterMaster).currentCall];
_engine->getMessageManager()->setMessageHandle(kCharacterMaster, &LogicManager::HAND_DemoMaster_StartPart5);
getCharacter(kCharacterMaster).callbacks[getCharacter(kCharacterMaster).currentCall] = 6;
params->clear();
fedEx(kCharacterMaster, kCharacterMaster, 12, 0);
}
void LogicManager::HAND_DemoMaster_StartPart5(HAND_PARAMS) {
// No-op
}
void (LogicManager::*LogicManager::_functionsDemoMaster[])(HAND_PARAMS) = {
nullptr,
&LogicManager::HAND_DemoMaster_SaveGame,
&LogicManager::HAND_DemoMaster_Birth,
&LogicManager::HAND_DemoMaster_StartPart2,
&LogicManager::HAND_DemoMaster_StartPart3,
&LogicManager::HAND_DemoMaster_StartPart4,
&LogicManager::HAND_DemoMaster_StartPart5
};
} // End of namespace LastExpress

150
engines/lastexpress/characters/demo/demo_monsieur.cpp Normal file
View File

@@ -0,0 +1,150 @@
/* ScummVM - Graphic Adventure Engine
*
* ScummVM is the legal property of its developers, whose names
* are too numerous to list here. Please refer to the COPYRIGHT
* file distributed with this source distribution.
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <http://www.gnu.org/licenses/>.
*
*/
#include "lastexpress/lastexpress.h"
namespace LastExpress {
void LogicManager::CONS_DemoMonsieur(int chapter) {
switch (chapter) {
case 0:
_engine->getMessageManager()->setMessageHandle(
kCharacterMonsieur,
_functionsDemoMonsieur[getCharacter(kCharacterMonsieur).callbacks[getCharacter(kCharacterMonsieur).currentCall]]
);
break;
case 1:
CONS_DemoMonsieur_Birth(0, 0, 0, 0);
break;
case 2:
CONS_DemoMonsieur_StartPart2(0, 0, 0, 0);
break;
case 3:
CONS_DemoMonsieur_StartPart3(0, 0, 0, 0);
break;
case 4:
CONS_DemoMonsieur_StartPart4(0, 0, 0, 0);
break;
case 5:
CONS_DemoMonsieur_StartPart5(0, 0, 0, 0);
break;
default:
break;
}
}
void LogicManager::DemoMonsieurCall(CALL_PARAMS) {
getCharacter(kCharacterMonsieur).currentCall++;
(this->*functionPointer)(param1, param2, param3, param4);
}
void LogicManager::CONS_DemoMonsieur_Birth(CONS_PARAMS) {
CharacterCallParams *params = &getCharacter(kCharacterMonsieur).callParams[getCharacter(kCharacterMonsieur).currentCall];
_engine->getMessageManager()->setMessageHandle(kCharacterMonsieur, &LogicManager::HAND_DemoMonsieur_Birth);
getCharacter(kCharacterMonsieur).callbacks[getCharacter(kCharacterMonsieur).currentCall] = 1;
params->clear();
fedEx(kCharacterMonsieur, kCharacterMonsieur, 12, 0);
}
void LogicManager::HAND_DemoMonsieur_Birth(HAND_PARAMS) {
switch (msg->action) {
case 12:
getCharacter(kCharacterMonsieur).characterPosition.car = kCarRedSleeping;
getCharacter(kCharacterMonsieur).characterPosition.position = 8200;
getCharacter(kCharacterMonsieur).characterPosition.location = 1;
setDoor(32, kCharacterCath, 2, 255, 255);
startCycOtis(kCharacterMonsieur, "510");
break;
default:
break;
}
}
void LogicManager::CONS_DemoMonsieur_StartPart2(CONS_PARAMS) {
CharacterCallParams *params = &getCharacter(kCharacterMonsieur).callParams[getCharacter(kCharacterMonsieur).currentCall];
_engine->getMessageManager()->setMessageHandle(kCharacterMonsieur, &LogicManager::HAND_DemoMonsieur_StartPart2);
getCharacter(kCharacterMonsieur).callbacks[getCharacter(kCharacterMonsieur).currentCall] = 2;
params->clear();
fedEx(kCharacterMonsieur, kCharacterMonsieur, 12, 0);
}
void LogicManager::HAND_DemoMonsieur_StartPart2(HAND_PARAMS) {
// No-op
}
void LogicManager::CONS_DemoMonsieur_StartPart3(CONS_PARAMS) {
CharacterCallParams *params = &getCharacter(kCharacterMonsieur).callParams[getCharacter(kCharacterMonsieur).currentCall];
_engine->getMessageManager()->setMessageHandle(kCharacterMonsieur, &LogicManager::HAND_DemoMonsieur_StartPart3);
getCharacter(kCharacterMonsieur).callbacks[getCharacter(kCharacterMonsieur).currentCall] = 3;
params->clear();
fedEx(kCharacterMonsieur, kCharacterMonsieur, 12, 0);
}
void LogicManager::HAND_DemoMonsieur_StartPart3(HAND_PARAMS) {
// No-op
}
void LogicManager::CONS_DemoMonsieur_StartPart4(CONS_PARAMS) {
CharacterCallParams *params = &getCharacter(kCharacterMonsieur).callParams[getCharacter(kCharacterMonsieur).currentCall];
_engine->getMessageManager()->setMessageHandle(kCharacterMonsieur, &LogicManager::HAND_DemoMonsieur_StartPart4);
getCharacter(kCharacterMonsieur).callbacks[getCharacter(kCharacterMonsieur).currentCall] = 4;
params->clear();
fedEx(kCharacterMonsieur, kCharacterMonsieur, 12, 0);
}
void LogicManager::HAND_DemoMonsieur_StartPart4(HAND_PARAMS) {
// No-op
}
void LogicManager::CONS_DemoMonsieur_StartPart5(CONS_PARAMS) {
CharacterCallParams *params = &getCharacter(kCharacterMonsieur).callParams[getCharacter(kCharacterMonsieur).currentCall];
_engine->getMessageManager()->setMessageHandle(kCharacterMonsieur, &LogicManager::HAND_DemoMonsieur_StartPart5);
getCharacter(kCharacterMonsieur).callbacks[getCharacter(kCharacterMonsieur).currentCall] = 5;
params->clear();
fedEx(kCharacterMonsieur, kCharacterMonsieur, 12, 0);
}
void LogicManager::HAND_DemoMonsieur_StartPart5(HAND_PARAMS) {
// No-op
}
void (LogicManager::*LogicManager::_functionsDemoMonsieur[])(HAND_PARAMS) = {
nullptr,
&LogicManager::HAND_DemoMonsieur_Birth,
&LogicManager::HAND_DemoMonsieur_StartPart2,
&LogicManager::HAND_DemoMonsieur_StartPart3,
&LogicManager::HAND_DemoMonsieur_StartPart4,
&LogicManager::HAND_DemoMonsieur_StartPart5
};
} // End of namespace LastExpress

255
engines/lastexpress/characters/demo/demo_rebecca.cpp Normal file
View File

@@ -0,0 +1,255 @@
/* ScummVM - Graphic Adventure Engine
*
* ScummVM is the legal property of its developers, whose names
* are too numerous to list here. Please refer to the COPYRIGHT
* file distributed with this source distribution.
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <http://www.gnu.org/licenses/>.
*
*/
#include "lastexpress/lastexpress.h"
namespace LastExpress {
void LogicManager::CONS_DemoRebecca(int chapter) {
switch (chapter) {
case 0:
_engine->getMessageManager()->setMessageHandle(
kCharacterRebecca,
_functionsDemoRebecca[getCharacter(kCharacterRebecca).callbacks[getCharacter(kCharacterRebecca).currentCall]]
);
break;
case 1:
CONS_DemoRebecca_Birth(0, 0, 0, 0);
break;
case 2:
CONS_DemoRebecca_StartPart2(0, 0, 0, 0);
break;
case 3:
CONS_DemoRebecca_StartPart3(0, 0, 0, 0);
break;
case 4:
CONS_DemoRebecca_StartPart4(0, 0, 0, 0);
break;
case 5:
CONS_DemoRebecca_StartPart5(0, 0, 0, 0);
break;
default:
break;
}
}
void LogicManager::DemoRebeccaCall(CALL_PARAMS) {
getCharacter(kCharacterRebecca).currentCall++;
(this->*functionPointer)(param1, param2, param3, param4);
}
void LogicManager::CONS_DemoRebecca_DoDialog(CONS_PARAMS) {
CharacterCallParams *params = &getCharacter(kCharacterRebecca).callParams[getCharacter(kCharacterRebecca).currentCall];
_engine->getMessageManager()->setMessageHandle(kCharacterRebecca, &LogicManager::HAND_DemoRebecca_DoDialog);
getCharacter(kCharacterRebecca).callbacks[getCharacter(kCharacterRebecca).currentCall] = 1;
params->clear();
strncpy((char *)&params->parameters[0], param1.stringParam, 12);
fedEx(kCharacterRebecca, kCharacterRebecca, 12, 0);
}
void LogicManager::HAND_DemoRebecca_DoDialog(HAND_PARAMS) {
switch (msg->action) {
case 2:
getCharacter(kCharacterRebecca).currentCall--;
_engine->getMessageManager()->setMessageHandle(kCharacterRebecca, _functionsDemoRebecca[getCharacter(kCharacterRebecca).callbacks[getCharacter(kCharacterRebecca).currentCall]]);
fedEx(kCharacterRebecca, kCharacterRebecca, 18, 0);
break;
case 12:
playDialog(kCharacterRebecca, (char *)&getCharacterCurrentParams(kCharacterRebecca)[0], -1, 0);
break;
default:
break;
}
}
void LogicManager::CONS_DemoRebecca_Birth(CONS_PARAMS) {
CharacterCallParams *params = &getCharacter(kCharacterRebecca).callParams[getCharacter(kCharacterRebecca).currentCall];
_engine->getMessageManager()->setMessageHandle(kCharacterRebecca, &LogicManager::HAND_DemoRebecca_Birth);
getCharacter(kCharacterRebecca).callbacks[getCharacter(kCharacterRebecca).currentCall] = 2;
params->clear();
fedEx(kCharacterRebecca, kCharacterRebecca, 12, 0);
}
void LogicManager::HAND_DemoRebecca_Birth(HAND_PARAMS) {
switch (msg->action) {
case 0:
if (getCharacterCurrentParams(kCharacterRebecca)[0] || getCharacterCurrentParams(kCharacterRebecca)[1] >= 3 || !inDiningRoom(kCharacterCath)) {
if (_gameTime > 2254500 && !getCharacterCurrentParams(kCharacterRebecca)[3]) {
getCharacterCurrentParams(kCharacterRebecca)[3] = 1;
send(kCharacterRebecca, kCharacterWaiter1, 223712416, 0);
getCharacterCurrentParams(kCharacterRebecca)[0] = 1;
}
break;
}
if (getCharacterCurrentParams(kCharacterRebecca)[2] || (getCharacterCurrentParams(kCharacterRebecca)[2] = _gameTime + 150, _gameTime != -150)) {
if (_gameTime <= getCharacterCurrentParams(kCharacterRebecca)[2]) {
if (_gameTime > 2254500 && !getCharacterCurrentParams(kCharacterRebecca)[3]) {
getCharacterCurrentParams(kCharacterRebecca)[3] = 1;
send(kCharacterRebecca, kCharacterWaiter1, 223712416, 0);
getCharacterCurrentParams(kCharacterRebecca)[0] = 1;
}
break;
}
getCharacterCurrentParams(kCharacterRebecca)[2] = 0x7FFFFFFF;
}
if (getCharacterCurrentParams(kCharacterRebecca)[1] == 1) {
getCharacterCurrentParams(kCharacterRebecca)[1]++;
getCharacter(kCharacterRebecca).callbacks[getCharacter(kCharacterRebecca).currentCall + 8] = 1;
DemoRebeccaCall(&LogicManager::CONS_DemoRebecca_DoDialog, "REB1013", 0, 0, 0);
} else if (getCharacterCurrentParams(kCharacterRebecca)[1] == 2) {
getCharacterCurrentParams(kCharacterRebecca)[1]++;
getCharacter(kCharacterRebecca).callbacks[getCharacter(kCharacterRebecca).currentCall + 8] = 2;
DemoRebeccaCall(&LogicManager::CONS_DemoRebecca_DoDialog, "REB1199A", 0, 0, 0);
} else if (getCharacterCurrentParams(kCharacterRebecca)[1] == 3) {
getCharacterCurrentParams(kCharacterRebecca)[1]++;
getCharacter(kCharacterRebecca).callbacks[getCharacter(kCharacterRebecca).currentCall + 8] = 3;
DemoRebeccaCall(&LogicManager::CONS_DemoRebecca_DoDialog, "REB1199C", 0, 0, 0);
} else {
getCharacterCurrentParams(kCharacterRebecca)[1]++;
getCharacterCurrentParams(kCharacterRebecca)[2] = 0;
if (_gameTime > 2254500 && !getCharacterCurrentParams(kCharacterRebecca)[3]) {
getCharacterCurrentParams(kCharacterRebecca)[3] = 1;
send(kCharacterRebecca, kCharacterWaiter1, 223712416, 0);
getCharacterCurrentParams(kCharacterRebecca)[0] = 1;
}
}
break;
case 12:
getCharacter(kCharacterRebecca).characterPosition.car = kCarRestaurant;
getCharacter(kCharacterRebecca).characterPosition.location = 1;
getCharacter(kCharacterRebecca).characterPosition.position = 4690;
startCycOtis(kCharacterRebecca, "012D");
break;
case 18:
switch (getCharacter(kCharacterRebecca).callbacks[getCharacter(kCharacterRebecca).currentCall + 8]) {
case 1:
case 2:
case 3:
getCharacterCurrentParams(kCharacterRebecca)[2] = 0;
if (_gameTime > 2254500 && !getCharacterCurrentParams(kCharacterRebecca)[3]) {
getCharacterCurrentParams(kCharacterRebecca)[3] = 1;
send(kCharacterRebecca, kCharacterWaiter1, 223712416, 0);
getCharacterCurrentParams(kCharacterRebecca)[0] = 1;
}
break;
case 4:
send(kCharacterRebecca, kCharacterWaiter1, 136702400, 0);
startCycOtis(kCharacterRebecca, "012G");
getCharacterCurrentParams(kCharacterRebecca)[0] = 0;
break;
default:
break;
}
break;
case 123712592:
startCycOtis(kCharacterWaiter1, "BLANK");
startCycOtis(kCharacterRebecca, "012E");
getCharacter(kCharacterRebecca).callbacks[getCharacter(kCharacterRebecca).currentCall + 8] = 4;
DemoRebeccaCall(&LogicManager::CONS_DemoRebecca_DoDialog, "REB1200", 0, 0, 0);
break;
default:
break;
}
}
void LogicManager::CONS_DemoRebecca_StartPart2(CONS_PARAMS) {
CharacterCallParams *params = &getCharacter(kCharacterRebecca).callParams[getCharacter(kCharacterRebecca).currentCall];
_engine->getMessageManager()->setMessageHandle(kCharacterRebecca, &LogicManager::HAND_DemoRebecca_StartPart2);
getCharacter(kCharacterRebecca).callbacks[getCharacter(kCharacterRebecca).currentCall] = 3;
params->clear();
fedEx(kCharacterRebecca, kCharacterRebecca, 12, 0);
}
void LogicManager::HAND_DemoRebecca_StartPart2(HAND_PARAMS) {
// No-op
}
void LogicManager::CONS_DemoRebecca_StartPart3(CONS_PARAMS) {
CharacterCallParams *params = &getCharacter(kCharacterRebecca).callParams[getCharacter(kCharacterRebecca).currentCall];
_engine->getMessageManager()->setMessageHandle(kCharacterRebecca, &LogicManager::HAND_DemoRebecca_StartPart3);
getCharacter(kCharacterRebecca).callbacks[getCharacter(kCharacterRebecca).currentCall] = 4;
params->clear();
fedEx(kCharacterRebecca, kCharacterRebecca, 12, 0);
}
void LogicManager::HAND_DemoRebecca_StartPart3(HAND_PARAMS) {
// No-op
}
void LogicManager::CONS_DemoRebecca_StartPart4(CONS_PARAMS) {
CharacterCallParams *params = &getCharacter(kCharacterRebecca).callParams[getCharacter(kCharacterRebecca).currentCall];
_engine->getMessageManager()->setMessageHandle(kCharacterRebecca, &LogicManager::HAND_DemoRebecca_StartPart4);
getCharacter(kCharacterRebecca).callbacks[getCharacter(kCharacterRebecca).currentCall] = 5;
params->clear();
fedEx(kCharacterRebecca, kCharacterRebecca, 12, 0);
}
void LogicManager::HAND_DemoRebecca_StartPart4(HAND_PARAMS) {
// No-op
}
void LogicManager::CONS_DemoRebecca_StartPart5(CONS_PARAMS) {
CharacterCallParams *params = &getCharacter(kCharacterRebecca).callParams[getCharacter(kCharacterRebecca).currentCall];
_engine->getMessageManager()->setMessageHandle(kCharacterRebecca, &LogicManager::HAND_DemoRebecca_StartPart5);
getCharacter(kCharacterRebecca).callbacks[getCharacter(kCharacterRebecca).currentCall] = 6;
params->clear();
fedEx(kCharacterRebecca, kCharacterRebecca, 12, 0);
}
void LogicManager::HAND_DemoRebecca_StartPart5(HAND_PARAMS) {
// No-op
}
void (LogicManager::*LogicManager::_functionsDemoRebecca[])(HAND_PARAMS) = {
nullptr,
&LogicManager::HAND_DemoRebecca_DoDialog,
&LogicManager::HAND_DemoRebecca_Birth,
&LogicManager::HAND_DemoRebecca_StartPart2,
&LogicManager::HAND_DemoRebecca_StartPart3,
&LogicManager::HAND_DemoRebecca_StartPart4,
&LogicManager::HAND_DemoRebecca_StartPart5
};
} // End of namespace LastExpress

154
engines/lastexpress/characters/demo/demo_tablea.cpp Normal file
View File

@@ -0,0 +1,154 @@
/* ScummVM - Graphic Adventure Engine
*
* ScummVM is the legal property of its developers, whose names
* are too numerous to list here. Please refer to the COPYRIGHT
* file distributed with this source distribution.
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <http://www.gnu.org/licenses/>.
*
*/
#include "lastexpress/lastexpress.h"
namespace LastExpress {
void LogicManager::CONS_DemoTableA(int chapter) {
switch (chapter) {
case 0:
_engine->getMessageManager()->setMessageHandle(
kCharacterTableA,
_functionsDemoTableA[getCharacter(kCharacterTableA).callbacks[getCharacter(kCharacterTableA).currentCall]]
);
break;
case 1:
CONS_DemoTableA_Birth(0, 0, 0, 0);
break;
case 2:
CONS_DemoTableA_StartPart2(0, 0, 0, 0);
break;
case 3:
CONS_DemoTableA_StartPart3(0, 0, 0, 0);
break;
case 4:
CONS_DemoTableA_StartPart4(0, 0, 0, 0);
break;
case 5:
CONS_DemoTableA_StartPart5(0, 0, 0, 0);
break;
default:
break;
}
}
void LogicManager::CONS_DemoTableA_Birth(CONS_PARAMS) {
CharacterCallParams *params = &getCharacter(kCharacterTableA).callParams[getCharacter(kCharacterTableA).currentCall];
_engine->getMessageManager()->setMessageHandle(kCharacterTableA, &LogicManager::HAND_DemoTableA_Birth);
getCharacter(kCharacterTableA).callbacks[getCharacter(kCharacterTableA).currentCall] = 1;
params->clear();
fedEx(kCharacterTableA, kCharacterTableA, 12, 0);
}
void LogicManager::HAND_DemoTableA_Birth(HAND_PARAMS) {
switch (msg->action) {
case 12:
getCharacter(kCharacterTableA).characterPosition.position = 3970;
getCharacter(kCharacterTableA).characterPosition.location = 1;
getCharacter(kCharacterTableA).characterPosition.car = kCarRestaurant;
startCycOtis(kCharacterTableA, "001P");
break;
case 103798704:
if (msg->param.stringParam) {
startCycOtis(kCharacterTableA, msg->param.stringParam);
} else {
startCycOtis(kCharacterTableA, "001P");
}
break;
case 136455232:
startCycOtis(kCharacterTableA, "BLANK");
break;
default:
break;
}
}
void LogicManager::CONS_DemoTableA_StartPart2(CONS_PARAMS) {
CharacterCallParams *params = &getCharacter(kCharacterTableA).callParams[getCharacter(kCharacterTableA).currentCall];
_engine->getMessageManager()->setMessageHandle(kCharacterTableA, &LogicManager::HAND_DemoTableA_StartPart2);
getCharacter(kCharacterTableA).callbacks[getCharacter(kCharacterTableA).currentCall] = 2;
params->clear();
fedEx(kCharacterTableA, kCharacterTableA, 12, 0);
}
void LogicManager::HAND_DemoTableA_StartPart2(HAND_PARAMS) {
// No-op
}
void LogicManager::CONS_DemoTableA_StartPart3(CONS_PARAMS) {
CharacterCallParams *params = &getCharacter(kCharacterTableA).callParams[getCharacter(kCharacterTableA).currentCall];
_engine->getMessageManager()->setMessageHandle(kCharacterTableA, &LogicManager::HAND_DemoTableA_StartPart3);
getCharacter(kCharacterTableA).callbacks[getCharacter(kCharacterTableA).currentCall] = 3;
params->clear();
fedEx(kCharacterTableA, kCharacterTableA, 12, 0);
}
void LogicManager::HAND_DemoTableA_StartPart3(HAND_PARAMS) {
// No-op
}
void LogicManager::CONS_DemoTableA_StartPart4(CONS_PARAMS) {
CharacterCallParams *params = &getCharacter(kCharacterTableA).callParams[getCharacter(kCharacterTableA).currentCall];
_engine->getMessageManager()->setMessageHandle(kCharacterTableA, &LogicManager::HAND_DemoTableA_StartPart4);
getCharacter(kCharacterTableA).callbacks[getCharacter(kCharacterTableA).currentCall] = 4;
params->clear();
fedEx(kCharacterTableA, kCharacterTableA, 12, 0);
}
void LogicManager::HAND_DemoTableA_StartPart4(HAND_PARAMS) {
// No-op
}
void LogicManager::CONS_DemoTableA_StartPart5(CONS_PARAMS) {
CharacterCallParams *params = &getCharacter(kCharacterTableA).callParams[getCharacter(kCharacterTableA).currentCall];
_engine->getMessageManager()->setMessageHandle(kCharacterTableA, &LogicManager::HAND_DemoTableA_StartPart5);
getCharacter(kCharacterTableA).callbacks[getCharacter(kCharacterTableA).currentCall] = 5;
params->clear();
fedEx(kCharacterTableA, kCharacterTableA, 12, 0);
}
void LogicManager::HAND_DemoTableA_StartPart5(HAND_PARAMS) {
// No-op
}
void (LogicManager::*LogicManager::_functionsDemoTableA[])(HAND_PARAMS) = {
nullptr,
&LogicManager::HAND_DemoTableA_Birth,
&LogicManager::HAND_DemoTableA_StartPart2,
&LogicManager::HAND_DemoTableA_StartPart3,
&LogicManager::HAND_DemoTableA_StartPart4,
&LogicManager::HAND_DemoTableA_StartPart5,
};
} // End of namespace LastExpress

154
engines/lastexpress/characters/demo/demo_tableb.cpp Normal file
View File

@@ -0,0 +1,154 @@
/* ScummVM - Graphic Adventure Engine
*
* ScummVM is the legal property of its developers, whose names
* are too numerous to list here. Please refer to the COPYRIGHT
* file distributed with this source distribution.
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <http://www.gnu.org/licenses/>.
*
*/
#include "lastexpress/lastexpress.h"
namespace LastExpress {
void LogicManager::CONS_DemoTableB(int chapter) {
switch (chapter) {
case 0:
_engine->getMessageManager()->setMessageHandle(
kCharacterTableB,
_functionsDemoTableB[getCharacter(kCharacterTableB).callbacks[getCharacter(kCharacterTableB).currentCall]]
);
break;
case 1:
CONS_DemoTableB_Birth(0, 0, 0, 0);
break;
case 2:
CONS_DemoTableB_StartPart2(0, 0, 0, 0);
break;
case 3:
CONS_DemoTableB_StartPart3(0, 0, 0, 0);
break;
case 4:
CONS_DemoTableB_StartPart4(0, 0, 0, 0);
break;
case 5:
CONS_DemoTableB_StartPart5(0, 0, 0, 0);
break;
default:
break;
}
}
void LogicManager::CONS_DemoTableB_Birth(CONS_PARAMS) {
CharacterCallParams *params = &getCharacter(kCharacterTableB).callParams[getCharacter(kCharacterTableB).currentCall];
_engine->getMessageManager()->setMessageHandle(kCharacterTableB, &LogicManager::HAND_DemoTableB_Birth);
getCharacter(kCharacterTableB).callbacks[getCharacter(kCharacterTableB).currentCall] = 1;
params->clear();
fedEx(kCharacterTableB, kCharacterTableB, 12, 0);
}
void LogicManager::HAND_DemoTableB_Birth(HAND_PARAMS) {
switch (msg->action) {
case 12:
getCharacter(kCharacterTableB).characterPosition.position = 3970;
getCharacter(kCharacterTableB).characterPosition.location = 1;
getCharacter(kCharacterTableB).characterPosition.car = kCarRestaurant;
startCycOtis(kCharacterTableB, "005J");
break;
case 103798704:
if (msg->param.stringParam) {
startCycOtis(kCharacterTableB, msg->param.stringParam);
} else {
startCycOtis(kCharacterTableB, "005J");
}
break;
case 136455232:
startCycOtis(kCharacterTableB, "BLANK");
break;
default:
break;
}
}
void LogicManager::CONS_DemoTableB_StartPart2(CONS_PARAMS) {
CharacterCallParams *params = &getCharacter(kCharacterTableB).callParams[getCharacter(kCharacterTableB).currentCall];
_engine->getMessageManager()->setMessageHandle(kCharacterTableB, &LogicManager::HAND_DemoTableB_StartPart2);
getCharacter(kCharacterTableB).callbacks[getCharacter(kCharacterTableB).currentCall] = 2;
params->clear();
fedEx(kCharacterTableB, kCharacterTableB, 12, 0);
}
void LogicManager::HAND_DemoTableB_StartPart2(HAND_PARAMS) {
// No-op
}
void LogicManager::CONS_DemoTableB_StartPart3(CONS_PARAMS) {
CharacterCallParams *params = &getCharacter(kCharacterTableB).callParams[getCharacter(kCharacterTableB).currentCall];
_engine->getMessageManager()->setMessageHandle(kCharacterTableB, &LogicManager::HAND_DemoTableB_StartPart3);
getCharacter(kCharacterTableB).callbacks[getCharacter(kCharacterTableB).currentCall] = 3;
params->clear();
fedEx(kCharacterTableB, kCharacterTableB, 12, 0);
}
void LogicManager::HAND_DemoTableB_StartPart3(HAND_PARAMS) {
// No-op
}
void LogicManager::CONS_DemoTableB_StartPart4(CONS_PARAMS) {
CharacterCallParams *params = &getCharacter(kCharacterTableB).callParams[getCharacter(kCharacterTableB).currentCall];
_engine->getMessageManager()->setMessageHandle(kCharacterTableB, &LogicManager::HAND_DemoTableB_StartPart4);
getCharacter(kCharacterTableB).callbacks[getCharacter(kCharacterTableB).currentCall] = 4;
params->clear();
fedEx(kCharacterTableB, kCharacterTableB, 12, 0);
}
void LogicManager::HAND_DemoTableB_StartPart4(HAND_PARAMS) {
// No-op
}
void LogicManager::CONS_DemoTableB_StartPart5(CONS_PARAMS) {
CharacterCallParams *params = &getCharacter(kCharacterTableB).callParams[getCharacter(kCharacterTableB).currentCall];
_engine->getMessageManager()->setMessageHandle(kCharacterTableB, &LogicManager::HAND_DemoTableB_StartPart5);
getCharacter(kCharacterTableB).callbacks[getCharacter(kCharacterTableB).currentCall] = 5;
params->clear();
fedEx(kCharacterTableB, kCharacterTableB, 12, 0);
}
void LogicManager::HAND_DemoTableB_StartPart5(HAND_PARAMS) {
// No-op
}
void (LogicManager::*LogicManager::_functionsDemoTableB[])(HAND_PARAMS) = {
nullptr,
&LogicManager::HAND_DemoTableB_Birth,
&LogicManager::HAND_DemoTableB_StartPart2,
&LogicManager::HAND_DemoTableB_StartPart3,
&LogicManager::HAND_DemoTableB_StartPart4,
&LogicManager::HAND_DemoTableB_StartPart5,
};
} // End of namespace LastExpress

155
engines/lastexpress/characters/demo/demo_tablec.cpp Normal file
View File

@@ -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 3 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <http://www.gnu.org/licenses/>.
*
*/
#include "lastexpress/lastexpress.h"
namespace LastExpress {
void LogicManager::CONS_DemoTableC(int chapter) {
switch (chapter) {
case 0:
_engine->getMessageManager()->setMessageHandle(
kCharacterTableC,
_functionsDemoTableC[getCharacter(kCharacterTableC).callbacks[getCharacter(kCharacterTableC).currentCall]]
);
break;
case 1:
CONS_DemoTableC_Birth(0, 0, 0, 0);
break;
case 2:
CONS_DemoTableC_StartPart2(0, 0, 0, 0);
break;
case 3:
CONS_DemoTableC_StartPart3(0, 0, 0, 0);
break;
case 4:
CONS_DemoTableC_StartPart4(0, 0, 0, 0);
break;
case 5:
CONS_DemoTableC_StartPart5(0, 0, 0, 0);
break;
default:
break;
}
}
void LogicManager::CONS_DemoTableC_Birth(CONS_PARAMS) {
CharacterCallParams *params = &getCharacter(kCharacterTableC).callParams[getCharacter(kCharacterTableC).currentCall];
_engine->getMessageManager()->setMessageHandle(kCharacterTableC, &LogicManager::HAND_DemoTableC_Birth);
getCharacter(kCharacterTableC).callbacks[getCharacter(kCharacterTableC).currentCall] = 1;
params->clear();
fedEx(kCharacterTableC, kCharacterTableC, 12, 0);
}
void LogicManager::HAND_DemoTableC_Birth(HAND_PARAMS) {
switch (msg->action) {
case 12:
_engine->getSoundManager()->playSoundFile("LOOP8A.SND", kSoundTypeWalla | kSoundFlagLooped | kVolume8, kCharacterTableC, 0);
getCharacter(kCharacterTableC).characterPosition.position = 4690;
getCharacter(kCharacterTableC).characterPosition.location = 1;
getCharacter(kCharacterTableC).characterPosition.car = kCarRestaurant;
startCycOtis(kCharacterTableC, "009G");
break;
case 103798704:
if (msg->param.stringParam) {
startCycOtis(kCharacterTableC, msg->param.stringParam);
} else {
startCycOtis(kCharacterTableC, "009G");
}
break;
case 136455232:
startCycOtis(kCharacterTableC, "BLANK");
break;
default:
break;
}
}
void LogicManager::CONS_DemoTableC_StartPart2(CONS_PARAMS) {
CharacterCallParams *params = &getCharacter(kCharacterTableC).callParams[getCharacter(kCharacterTableC).currentCall];
_engine->getMessageManager()->setMessageHandle(kCharacterTableC, &LogicManager::HAND_DemoTableC_StartPart2);
getCharacter(kCharacterTableC).callbacks[getCharacter(kCharacterTableC).currentCall] = 2;
params->clear();
fedEx(kCharacterTableC, kCharacterTableC, 12, 0);
}
void LogicManager::HAND_DemoTableC_StartPart2(HAND_PARAMS) {
// No-op
}
void LogicManager::CONS_DemoTableC_StartPart3(CONS_PARAMS) {
CharacterCallParams *params = &getCharacter(kCharacterTableC).callParams[getCharacter(kCharacterTableC).currentCall];
_engine->getMessageManager()->setMessageHandle(kCharacterTableC, &LogicManager::HAND_DemoTableC_StartPart3);
getCharacter(kCharacterTableC).callbacks[getCharacter(kCharacterTableC).currentCall] = 3;
params->clear();
fedEx(kCharacterTableC, kCharacterTableC, 12, 0);
}
void LogicManager::HAND_DemoTableC_StartPart3(HAND_PARAMS) {
// No-op
}
void LogicManager::CONS_DemoTableC_StartPart4(CONS_PARAMS) {
CharacterCallParams *params = &getCharacter(kCharacterTableC).callParams[getCharacter(kCharacterTableC).currentCall];
_engine->getMessageManager()->setMessageHandle(kCharacterTableC, &LogicManager::HAND_DemoTableC_StartPart4);
getCharacter(kCharacterTableC).callbacks[getCharacter(kCharacterTableC).currentCall] = 4;
params->clear();
fedEx(kCharacterTableC, kCharacterTableC, 12, 0);
}
void LogicManager::HAND_DemoTableC_StartPart4(HAND_PARAMS) {
// No-op
}
void LogicManager::CONS_DemoTableC_StartPart5(CONS_PARAMS) {
CharacterCallParams *params = &getCharacter(kCharacterTableC).callParams[getCharacter(kCharacterTableC).currentCall];
_engine->getMessageManager()->setMessageHandle(kCharacterTableC, &LogicManager::HAND_DemoTableC_StartPart5);
getCharacter(kCharacterTableC).callbacks[getCharacter(kCharacterTableC).currentCall] = 5;
params->clear();
fedEx(kCharacterTableC, kCharacterTableC, 12, 0);
}
void LogicManager::HAND_DemoTableC_StartPart5(HAND_PARAMS) {
// No-op
}
void (LogicManager::*LogicManager::_functionsDemoTableC[])(HAND_PARAMS) = {
nullptr,
&LogicManager::HAND_DemoTableC_Birth,
&LogicManager::HAND_DemoTableC_StartPart2,
&LogicManager::HAND_DemoTableC_StartPart3,
&LogicManager::HAND_DemoTableC_StartPart4,
&LogicManager::HAND_DemoTableC_StartPart5,
};
} // End of namespace LastExpress

154
engines/lastexpress/characters/demo/demo_tabled.cpp Normal file
View File

@@ -0,0 +1,154 @@
/* ScummVM - Graphic Adventure Engine
*
* ScummVM is the legal property of its developers, whose names
* are too numerous to list here. Please refer to the COPYRIGHT
* file distributed with this source distribution.
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <http://www.gnu.org/licenses/>.
*
*/
#include "lastexpress/lastexpress.h"
namespace LastExpress {
void LogicManager::CONS_DemoTableD(int chapter) {
switch (chapter) {
case 0:
_engine->getMessageManager()->setMessageHandle(
kCharacterTableD,
_functionsDemoTableD[getCharacter(kCharacterTableD).callbacks[getCharacter(kCharacterTableD).currentCall]]
);
break;
case 1:
CONS_DemoTableD_Birth(0, 0, 0, 0);
break;
case 2:
CONS_DemoTableD_StartPart2(0, 0, 0, 0);
break;
case 3:
CONS_DemoTableD_StartPart3(0, 0, 0, 0);
break;
case 4:
CONS_DemoTableD_StartPart4(0, 0, 0, 0);
break;
case 5:
CONS_DemoTableD_StartPart5(0, 0, 0, 0);
break;
default:
break;
}
}
void LogicManager::CONS_DemoTableD_Birth(CONS_PARAMS) {
CharacterCallParams *params = &getCharacter(kCharacterTableD).callParams[getCharacter(kCharacterTableD).currentCall];
_engine->getMessageManager()->setMessageHandle(kCharacterTableD, &LogicManager::HAND_DemoTableD_Birth);
getCharacter(kCharacterTableD).callbacks[getCharacter(kCharacterTableD).currentCall] = 1;
params->clear();
fedEx(kCharacterTableD, kCharacterTableD, 12, 0);
}
void LogicManager::HAND_DemoTableD_Birth(HAND_PARAMS) {
switch (msg->action) {
case 12:
getCharacter(kCharacterTableD).characterPosition.position = 4690;
getCharacter(kCharacterTableD).characterPosition.location = 1;
getCharacter(kCharacterTableD).characterPosition.car = kCarRestaurant;
startCycOtis(kCharacterTableD, "010M");
break;
case 103798704:
if (msg->param.stringParam) {
startCycOtis(kCharacterTableD, msg->param.stringParam);
} else {
startCycOtis(kCharacterTableD, "010M");
}
break;
case 136455232:
startCycOtis(kCharacterTableD, "BLANK");
break;
default:
break;
}
}
void LogicManager::CONS_DemoTableD_StartPart2(CONS_PARAMS) {
CharacterCallParams *params = &getCharacter(kCharacterTableD).callParams[getCharacter(kCharacterTableD).currentCall];
_engine->getMessageManager()->setMessageHandle(kCharacterTableD, &LogicManager::HAND_DemoTableD_StartPart2);
getCharacter(kCharacterTableD).callbacks[getCharacter(kCharacterTableD).currentCall] = 2;
params->clear();
fedEx(kCharacterTableD, kCharacterTableD, 12, 0);
}
void LogicManager::HAND_DemoTableD_StartPart2(HAND_PARAMS) {
// No-op
}
void LogicManager::CONS_DemoTableD_StartPart3(CONS_PARAMS) {
CharacterCallParams *params = &getCharacter(kCharacterTableD).callParams[getCharacter(kCharacterTableD).currentCall];
_engine->getMessageManager()->setMessageHandle(kCharacterTableD, &LogicManager::HAND_DemoTableD_StartPart3);
getCharacter(kCharacterTableD).callbacks[getCharacter(kCharacterTableD).currentCall] = 3;
params->clear();
fedEx(kCharacterTableD, kCharacterTableD, 12, 0);
}
void LogicManager::HAND_DemoTableD_StartPart3(HAND_PARAMS) {
// No-op
}
void LogicManager::CONS_DemoTableD_StartPart4(CONS_PARAMS) {
CharacterCallParams *params = &getCharacter(kCharacterTableD).callParams[getCharacter(kCharacterTableD).currentCall];
_engine->getMessageManager()->setMessageHandle(kCharacterTableD, &LogicManager::HAND_DemoTableD_StartPart4);
getCharacter(kCharacterTableD).callbacks[getCharacter(kCharacterTableD).currentCall] = 4;
params->clear();
fedEx(kCharacterTableD, kCharacterTableD, 12, 0);
}
void LogicManager::HAND_DemoTableD_StartPart4(HAND_PARAMS) {
// No-op
}
void LogicManager::CONS_DemoTableD_StartPart5(CONS_PARAMS) {
CharacterCallParams *params = &getCharacter(kCharacterTableD).callParams[getCharacter(kCharacterTableD).currentCall];
_engine->getMessageManager()->setMessageHandle(kCharacterTableD, &LogicManager::HAND_DemoTableD_StartPart5);
getCharacter(kCharacterTableD).callbacks[getCharacter(kCharacterTableD).currentCall] = 5;
params->clear();
fedEx(kCharacterTableD, kCharacterTableD, 12, 0);
}
void LogicManager::HAND_DemoTableD_StartPart5(HAND_PARAMS) {
// No-op
}
void (LogicManager::*LogicManager::_functionsDemoTableD[])(HAND_PARAMS) = {
nullptr,
&LogicManager::HAND_DemoTableD_Birth,
&LogicManager::HAND_DemoTableD_StartPart2,
&LogicManager::HAND_DemoTableD_StartPart3,
&LogicManager::HAND_DemoTableD_StartPart4,
&LogicManager::HAND_DemoTableD_StartPart5,
};
} // End of namespace LastExpress

154
engines/lastexpress/characters/demo/demo_tablee.cpp Normal file
View File

@@ -0,0 +1,154 @@
/* ScummVM - Graphic Adventure Engine
*
* ScummVM is the legal property of its developers, whose names
* are too numerous to list here. Please refer to the COPYRIGHT
* file distributed with this source distribution.
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <http://www.gnu.org/licenses/>.
*
*/
#include "lastexpress/lastexpress.h"
namespace LastExpress {
void LogicManager::CONS_DemoTableE(int chapter) {
switch (chapter) {
case 0:
_engine->getMessageManager()->setMessageHandle(
kCharacterTableE,
_functionsDemoTableE[getCharacter(kCharacterTableE).callbacks[getCharacter(kCharacterTableE).currentCall]]
);
break;
case 1:
CONS_DemoTableE_Birth(0, 0, 0, 0);
break;
case 2:
CONS_DemoTableE_StartPart2(0, 0, 0, 0);
break;
case 3:
CONS_DemoTableE_StartPart3(0, 0, 0, 0);
break;
case 4:
CONS_DemoTableE_StartPart4(0, 0, 0, 0);
break;
case 5:
CONS_DemoTableE_StartPart5(0, 0, 0, 0);
break;
default:
break;
}
}
void LogicManager::CONS_DemoTableE_Birth(CONS_PARAMS) {
CharacterCallParams *params = &getCharacter(kCharacterTableE).callParams[getCharacter(kCharacterTableE).currentCall];
_engine->getMessageManager()->setMessageHandle(kCharacterTableE, &LogicManager::HAND_DemoTableE_Birth);
getCharacter(kCharacterTableE).callbacks[getCharacter(kCharacterTableE).currentCall] = 1;
params->clear();
fedEx(kCharacterTableE, kCharacterTableE, 12, 0);
}
void LogicManager::HAND_DemoTableE_Birth(HAND_PARAMS) {
switch (msg->action) {
case 12:
getCharacter(kCharacterTableE).characterPosition.position = 5420;
getCharacter(kCharacterTableE).characterPosition.location = 1;
getCharacter(kCharacterTableE).characterPosition.car = kCarRestaurant;
startCycOtis(kCharacterTableE, "014F");
break;
case 103798704:
if (msg->param.stringParam) {
startCycOtis(kCharacterTableE, msg->param.stringParam);
} else {
startCycOtis(kCharacterTableE, "014F");
}
break;
case 136455232:
startCycOtis(kCharacterTableE, "BLANK");
break;
default:
break;
}
}
void LogicManager::CONS_DemoTableE_StartPart2(CONS_PARAMS) {
CharacterCallParams *params = &getCharacter(kCharacterTableE).callParams[getCharacter(kCharacterTableE).currentCall];
_engine->getMessageManager()->setMessageHandle(kCharacterTableE, &LogicManager::HAND_DemoTableE_StartPart2);
getCharacter(kCharacterTableE).callbacks[getCharacter(kCharacterTableE).currentCall] = 2;
params->clear();
fedEx(kCharacterTableE, kCharacterTableE, 12, 0);
}
void LogicManager::HAND_DemoTableE_StartPart2(HAND_PARAMS) {
// No-op
}
void LogicManager::CONS_DemoTableE_StartPart3(CONS_PARAMS) {
CharacterCallParams *params = &getCharacter(kCharacterTableE).callParams[getCharacter(kCharacterTableE).currentCall];
_engine->getMessageManager()->setMessageHandle(kCharacterTableE, &LogicManager::HAND_DemoTableE_StartPart3);
getCharacter(kCharacterTableE).callbacks[getCharacter(kCharacterTableE).currentCall] = 3;
params->clear();
fedEx(kCharacterTableE, kCharacterTableE, 12, 0);
}
void LogicManager::HAND_DemoTableE_StartPart3(HAND_PARAMS) {
// No-op
}
void LogicManager::CONS_DemoTableE_StartPart4(CONS_PARAMS) {
CharacterCallParams *params = &getCharacter(kCharacterTableE).callParams[getCharacter(kCharacterTableE).currentCall];
_engine->getMessageManager()->setMessageHandle(kCharacterTableE, &LogicManager::HAND_DemoTableE_StartPart4);
getCharacter(kCharacterTableE).callbacks[getCharacter(kCharacterTableE).currentCall] = 4;
params->clear();
fedEx(kCharacterTableE, kCharacterTableE, 12, 0);
}
void LogicManager::HAND_DemoTableE_StartPart4(HAND_PARAMS) {
// No-op
}
void LogicManager::CONS_DemoTableE_StartPart5(CONS_PARAMS) {
CharacterCallParams *params = &getCharacter(kCharacterTableE).callParams[getCharacter(kCharacterTableE).currentCall];
_engine->getMessageManager()->setMessageHandle(kCharacterTableE, &LogicManager::HAND_DemoTableE_StartPart5);
getCharacter(kCharacterTableE).callbacks[getCharacter(kCharacterTableE).currentCall] = 5;
params->clear();
fedEx(kCharacterTableE, kCharacterTableE, 12, 0);
}
void LogicManager::HAND_DemoTableE_StartPart5(HAND_PARAMS) {
// No-op
}
void (LogicManager::*LogicManager::_functionsDemoTableE[])(HAND_PARAMS) = {
nullptr,
&LogicManager::HAND_DemoTableE_Birth,
&LogicManager::HAND_DemoTableE_StartPart2,
&LogicManager::HAND_DemoTableE_StartPart3,
&LogicManager::HAND_DemoTableE_StartPart4,
&LogicManager::HAND_DemoTableE_StartPart5,
};
} // End of namespace LastExpress

154
engines/lastexpress/characters/demo/demo_tablef.cpp Normal file
View File

@@ -0,0 +1,154 @@
/* ScummVM - Graphic Adventure Engine
*
* ScummVM is the legal property of its developers, whose names
* are too numerous to list here. Please refer to the COPYRIGHT
* file distributed with this source distribution.
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <http://www.gnu.org/licenses/>.
*
*/
#include "lastexpress/lastexpress.h"
namespace LastExpress {
void LogicManager::CONS_DemoTableF(int chapter) {
switch (chapter) {
case 0:
_engine->getMessageManager()->setMessageHandle(
kCharacterTableF,
_functionsDemoTableF[getCharacter(kCharacterTableF).callbacks[getCharacter(kCharacterTableF).currentCall]]
);
break;
case 1:
CONS_DemoTableF_Birth(0, 0, 0, 0);
break;
case 2:
CONS_DemoTableF_StartPart2(0, 0, 0, 0);
break;
case 3:
CONS_DemoTableF_StartPart3(0, 0, 0, 0);
break;
case 4:
CONS_DemoTableF_StartPart4(0, 0, 0, 0);
break;
case 5:
CONS_DemoTableF_StartPart5(0, 0, 0, 0);
break;
default:
break;
}
}
void LogicManager::CONS_DemoTableF_Birth(CONS_PARAMS) {
CharacterCallParams *params = &getCharacter(kCharacterTableF).callParams[getCharacter(kCharacterTableF).currentCall];
_engine->getMessageManager()->setMessageHandle(kCharacterTableF, &LogicManager::HAND_DemoTableF_Birth);
getCharacter(kCharacterTableF).callbacks[getCharacter(kCharacterTableF).currentCall] = 1;
params->clear();
fedEx(kCharacterTableF, kCharacterTableF, 12, 0);
}
void LogicManager::HAND_DemoTableF_Birth(HAND_PARAMS) {
switch (msg->action) {
case 12:
getCharacter(kCharacterTableF).characterPosition.position = 5420;
getCharacter(kCharacterTableF).characterPosition.location = 1;
getCharacter(kCharacterTableF).characterPosition.car = kCarRestaurant;
startCycOtis(kCharacterTableF, "024D");
break;
case 103798704:
if (msg->param.stringParam) {
startCycOtis(kCharacterTableF, msg->param.stringParam);
} else {
startCycOtis(kCharacterTableF, "024D");
}
break;
case 136455232:
startCycOtis(kCharacterTableF, "BLANK");
break;
default:
break;
}
}
void LogicManager::CONS_DemoTableF_StartPart2(CONS_PARAMS) {
CharacterCallParams *params = &getCharacter(kCharacterTableF).callParams[getCharacter(kCharacterTableF).currentCall];
_engine->getMessageManager()->setMessageHandle(kCharacterTableF, &LogicManager::HAND_DemoTableF_StartPart2);
getCharacter(kCharacterTableF).callbacks[getCharacter(kCharacterTableF).currentCall] = 2;
params->clear();
fedEx(kCharacterTableF, kCharacterTableF, 12, 0);
}
void LogicManager::HAND_DemoTableF_StartPart2(HAND_PARAMS) {
// No-op
}
void LogicManager::CONS_DemoTableF_StartPart3(CONS_PARAMS) {
CharacterCallParams *params = &getCharacter(kCharacterTableF).callParams[getCharacter(kCharacterTableF).currentCall];
_engine->getMessageManager()->setMessageHandle(kCharacterTableF, &LogicManager::HAND_DemoTableF_StartPart3);
getCharacter(kCharacterTableF).callbacks[getCharacter(kCharacterTableF).currentCall] = 3;
params->clear();
fedEx(kCharacterTableF, kCharacterTableF, 12, 0);
}
void LogicManager::HAND_DemoTableF_StartPart3(HAND_PARAMS) {
// No-op
}
void LogicManager::CONS_DemoTableF_StartPart4(CONS_PARAMS) {
CharacterCallParams *params = &getCharacter(kCharacterTableF).callParams[getCharacter(kCharacterTableF).currentCall];
_engine->getMessageManager()->setMessageHandle(kCharacterTableF, &LogicManager::HAND_DemoTableF_StartPart4);
getCharacter(kCharacterTableF).callbacks[getCharacter(kCharacterTableF).currentCall] = 4;
params->clear();
fedEx(kCharacterTableF, kCharacterTableF, 12, 0);
}
void LogicManager::HAND_DemoTableF_StartPart4(HAND_PARAMS) {
// No-op
}
void LogicManager::CONS_DemoTableF_StartPart5(CONS_PARAMS) {
CharacterCallParams *params = &getCharacter(kCharacterTableF).callParams[getCharacter(kCharacterTableF).currentCall];
_engine->getMessageManager()->setMessageHandle(kCharacterTableF, &LogicManager::HAND_DemoTableF_StartPart5);
getCharacter(kCharacterTableF).callbacks[getCharacter(kCharacterTableF).currentCall] = 5;
params->clear();
fedEx(kCharacterTableF, kCharacterTableF, 12, 0);
}
void LogicManager::HAND_DemoTableF_StartPart5(HAND_PARAMS) {
// No-op
}
void (LogicManager::*LogicManager::_functionsDemoTableF[])(HAND_PARAMS) = {
nullptr,
&LogicManager::HAND_DemoTableF_Birth,
&LogicManager::HAND_DemoTableF_StartPart2,
&LogicManager::HAND_DemoTableF_StartPart3,
&LogicManager::HAND_DemoTableF_StartPart4,
&LogicManager::HAND_DemoTableF_StartPart5,
};
} // End of namespace LastExpress

184
engines/lastexpress/characters/demo/demo_tatiana.cpp Normal file
View File

@@ -0,0 +1,184 @@
/* ScummVM - Graphic Adventure Engine
*
* ScummVM is the legal property of its developers, whose names
* are too numerous to list here. Please refer to the COPYRIGHT
* file distributed with this source distribution.
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <http://www.gnu.org/licenses/>.
*
*/
#include "lastexpress/lastexpress.h"
namespace LastExpress {
void LogicManager::CONS_DemoTatiana(int chapter) {
switch (chapter) {
case 0:
_engine->getMessageManager()->setMessageHandle(
kCharacterTatiana,
_functionsDemoTatiana[getCharacter(kCharacterTatiana).callbacks[getCharacter(kCharacterTatiana).currentCall]]
);
break;
case 1:
CONS_DemoTatiana_Birth(0, 0, 0, 0);
break;
case 2:
CONS_DemoTatiana_StartPart2(0, 0, 0, 0);
break;
case 3:
CONS_DemoTatiana_StartPart3(0, 0, 0, 0);
break;
case 4:
CONS_DemoTatiana_StartPart4(0, 0, 0, 0);
break;
case 5:
CONS_DemoTatiana_StartPart5(0, 0, 0, 0);
break;
default:
break;
}
}
void LogicManager::CONS_DemoTatiana_Birth(CONS_PARAMS) {
CharacterCallParams *params = &getCharacter(kCharacterTatiana).callParams[getCharacter(kCharacterTatiana).currentCall];
_engine->getMessageManager()->setMessageHandle(kCharacterTatiana, &LogicManager::HAND_DemoTatiana_Birth);
getCharacter(kCharacterTatiana).callbacks[getCharacter(kCharacterTatiana).currentCall] = 1;
params->clear();
fedEx(kCharacterTatiana, kCharacterTatiana, 12, 0);
}
void LogicManager::HAND_DemoTatiana_Birth(HAND_PARAMS) {
switch (msg->action) {
case 0:
if (!getCharacterCurrentParams(kCharacterTatiana)[1] && !getCharacterCurrentParams(kCharacterTatiana)[3]) {
getCharacterCurrentParams(kCharacterTatiana)[0] -= _timeSpeed;
if (getCharacterCurrentParams(kCharacterTatiana)[0] < _timeSpeed) {
startCycOtis(kCharacterTatiana, (char *)&getCharacterCurrentParams(kCharacterTatiana)[7]);
playDialog(kCharacterTatiana, (char *)&getCharacterCurrentParams(kCharacterTatiana)[4], -1, 0);
getCharacterCurrentParams(kCharacterTatiana)[1] = 1;
}
}
break;
case 2:
getCharacterCurrentParams(kCharacterTatiana)[1] = 0;
getCharacterCurrentParams(kCharacterTatiana)[2]++;
switch (getCharacterCurrentParams(kCharacterTatiana)[2]) {
case 1:
getCharacterCurrentParams(kCharacterTatiana)[0] = 900;
startCycOtis(kCharacterTatiana, "110A");
Common::strcpy_s((char *)&getCharacterCurrentParams(kCharacterTatiana)[4], 12, "Tat3160B");
Common::strcpy_s((char *)&getCharacterCurrentParams(kCharacterTatiana)[7], 12, "110A");
break;
case 2:
getCharacterCurrentParams(kCharacterTatiana)[0] = 2700;
startCycOtis(kCharacterTatiana, "110B");
Common::strcpy_s((char *)&getCharacterCurrentParams(kCharacterTatiana)[4], 12, "Tat3160D");
Common::strcpy_s((char *)&getCharacterCurrentParams(kCharacterTatiana)[7], 12, "110D");
break;
case 3:
getCharacterCurrentParams(kCharacterTatiana)[0] = 4500;
startCycOtis(kCharacterTatiana, "110B");
Common::strcpy_s((char *)&getCharacterCurrentParams(kCharacterTatiana)[4], 12, "Tat3160E");
Common::strcpy_s((char *)&getCharacterCurrentParams(kCharacterTatiana)[7], 12, "110D");
break;
default:
getCharacterCurrentParams(kCharacterTatiana)[3] = 1;
break;
}
break;
case 12:
getCharacter(kCharacterTatiana).characterPosition.car = kCarRestaurant;
getCharacter(kCharacterTatiana).characterPosition.location = 1;
getCharacter(kCharacterTatiana).characterPosition.position = 1750;
startCycOtis(kCharacterTatiana, "110C");
playDialog(kCharacterTatiana, "Tat3160A", -1, 0);
getCharacterCurrentParams(kCharacterTatiana)[1] = 1;
break;
default:
break;
}
}
void LogicManager::CONS_DemoTatiana_StartPart2(CONS_PARAMS) {
CharacterCallParams *params = &getCharacter(kCharacterTatiana).callParams[getCharacter(kCharacterTatiana).currentCall];
_engine->getMessageManager()->setMessageHandle(kCharacterTatiana, &LogicManager::HAND_DemoTatiana_StartPart2);
getCharacter(kCharacterTatiana).callbacks[getCharacter(kCharacterTatiana).currentCall] = 2;
params->clear();
fedEx(kCharacterTatiana, kCharacterTatiana, 12, 0);
}
void LogicManager::HAND_DemoTatiana_StartPart2(HAND_PARAMS) {
// No-op
}
void LogicManager::CONS_DemoTatiana_StartPart3(CONS_PARAMS) {
CharacterCallParams *params = &getCharacter(kCharacterTatiana).callParams[getCharacter(kCharacterTatiana).currentCall];
_engine->getMessageManager()->setMessageHandle(kCharacterTatiana, &LogicManager::HAND_DemoTatiana_StartPart3);
getCharacter(kCharacterTatiana).callbacks[getCharacter(kCharacterTatiana).currentCall] = 3;
params->clear();
fedEx(kCharacterTatiana, kCharacterTatiana, 12, 0);
}
void LogicManager::HAND_DemoTatiana_StartPart3(HAND_PARAMS) {
// No-op
}
void LogicManager::CONS_DemoTatiana_StartPart4(CONS_PARAMS) {
CharacterCallParams *params = &getCharacter(kCharacterTatiana).callParams[getCharacter(kCharacterTatiana).currentCall];
_engine->getMessageManager()->setMessageHandle(kCharacterTatiana, &LogicManager::HAND_DemoTatiana_StartPart4);
getCharacter(kCharacterTatiana).callbacks[getCharacter(kCharacterTatiana).currentCall] = 4;
params->clear();
fedEx(kCharacterTatiana, kCharacterTatiana, 12, 0);
}
void LogicManager::HAND_DemoTatiana_StartPart4(HAND_PARAMS) {
// No-op
}
void LogicManager::CONS_DemoTatiana_StartPart5(CONS_PARAMS) {
CharacterCallParams *params = &getCharacter(kCharacterTatiana).callParams[getCharacter(kCharacterTatiana).currentCall];
_engine->getMessageManager()->setMessageHandle(kCharacterTatiana, &LogicManager::HAND_DemoTatiana_StartPart5);
getCharacter(kCharacterTatiana).callbacks[getCharacter(kCharacterTatiana).currentCall] = 5;
params->clear();
fedEx(kCharacterTatiana, kCharacterTatiana, 12, 0);
}
void LogicManager::HAND_DemoTatiana_StartPart5(HAND_PARAMS) {
// No-op
}
void (LogicManager::*LogicManager::_functionsDemoTatiana[])(HAND_PARAMS) = {
nullptr,
&LogicManager::HAND_DemoTatiana_Birth,
&LogicManager::HAND_DemoTatiana_StartPart2,
&LogicManager::HAND_DemoTatiana_StartPart3,
&LogicManager::HAND_DemoTatiana_StartPart4,
&LogicManager::HAND_DemoTatiana_StartPart5
};
} // End of namespace LastExpress

419
engines/lastexpress/characters/demo/demo_vesna.cpp Normal file
View File

@@ -0,0 +1,419 @@
/* ScummVM - Graphic Adventure Engine
*
* ScummVM is the legal property of its developers, whose names
* are too numerous to list here. Please refer to the COPYRIGHT
* file distributed with this source distribution.
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <http://www.gnu.org/licenses/>.
*
*/
#include "lastexpress/lastexpress.h"
namespace LastExpress {
void LogicManager::CONS_DemoVesna(int chapter) {
switch (chapter) {
case 0:
_engine->getMessageManager()->setMessageHandle(
kCharacterVesna,
_functionsDemoVesna[getCharacter(kCharacterVesna).callbacks[getCharacter(kCharacterVesna).currentCall]]
);
break;
case 1:
CONS_DemoVesna_Birth(0, 0, 0, 0);
break;
case 2:
CONS_DemoVesna_StartPart2(0, 0, 0, 0);
break;
case 3:
CONS_DemoVesna_StartPart3(0, 0, 0, 0);
break;
case 4:
CONS_DemoVesna_StartPart4(0, 0, 0, 0);
break;
case 5:
CONS_DemoVesna_StartPart5(0, 0, 0, 0);
break;
default:
break;
}
}
void LogicManager::DemoVesnaCall(CALL_PARAMS) {
getCharacter(kCharacterVesna).currentCall++;
(this->*functionPointer)(param1, param2, param3, param4);
}
void LogicManager::CONS_DemoVesna_DoCorrOtis(CONS_PARAMS) {
CharacterCallParams *params = &getCharacter(kCharacterVesna).callParams[getCharacter(kCharacterVesna).currentCall];
_engine->getMessageManager()->setMessageHandle(kCharacterVesna, &LogicManager::HAND_DemoVesna_DoCorrOtis);
getCharacter(kCharacterVesna).callbacks[getCharacter(kCharacterVesna).currentCall] = 1;
params->clear();
strncpy((char *)&params->parameters[0], param1.stringParam, 12);
params->parameters[3] = param2.intParam;
fedEx(kCharacterVesna, kCharacterVesna, 12, 0);
}
void LogicManager::HAND_DemoVesna_DoCorrOtis(HAND_PARAMS) {
if (msg->action == 3) {
releaseAtDoor(kCharacterVesna, getCharacterCurrentParams(kCharacterVesna)[3]);
getCharacter(kCharacterVesna).currentCall--;
_engine->getMessageManager()->setMessageHandle(kCharacterVesna, _functionsDemoVesna[getCharacter(kCharacterVesna).callbacks[getCharacter(kCharacterVesna).currentCall]]);
fedEx(kCharacterVesna, kCharacterVesna, 18, 0);
} else if (msg->action == 12) {
startSeqOtis(kCharacterVesna, (char *)&getCharacterCurrentParams(kCharacterVesna)[0]);
blockAtDoor(kCharacterVesna, getCharacterCurrentParams(kCharacterVesna)[3]);
}
}
void LogicManager::CONS_DemoVesna_DoSeqOtis(CONS_PARAMS) {
CharacterCallParams *params = &getCharacter(kCharacterVesna).callParams[getCharacter(kCharacterVesna).currentCall];
_engine->getMessageManager()->setMessageHandle(kCharacterVesna, &LogicManager::HAND_DemoVesna_DoSeqOtis);
getCharacter(kCharacterVesna).callbacks[getCharacter(kCharacterVesna).currentCall] = 2;
params->clear();
strncpy((char *)&params->parameters[0], param1.stringParam, 12);
fedEx(kCharacterVesna, kCharacterVesna, 12, 0);
}
void LogicManager::HAND_DemoVesna_DoSeqOtis(HAND_PARAMS) {
if (msg->action == 3) {
getCharacter(kCharacterVesna).currentCall--;
_engine->getMessageManager()->setMessageHandle(kCharacterVesna, _functionsDemoVesna[getCharacter(kCharacterVesna).callbacks[getCharacter(kCharacterVesna).currentCall]]);
fedEx(kCharacterVesna, kCharacterVesna, 18, 0);
} else if (msg->action == 12) {
startSeqOtis(kCharacterVesna, (char *)&getCharacterCurrentParams(kCharacterVesna)[0]);
}
}
void LogicManager::CONS_DemoVesna_DoWalk(CONS_PARAMS) {
CharacterCallParams *params = &getCharacter(kCharacterVesna).callParams[getCharacter(kCharacterVesna).currentCall];
_engine->getMessageManager()->setMessageHandle(kCharacterVesna, &LogicManager::HAND_DemoVesna_DoWalk);
getCharacter(kCharacterVesna).callbacks[getCharacter(kCharacterVesna).currentCall] = 3;
params->clear();
params->parameters[0] = param1.intParam;
params->parameters[1] = param2.intParam;
fedEx(kCharacterVesna, kCharacterVesna, 12, 0);
}
void LogicManager::HAND_DemoVesna_DoWalk(HAND_PARAMS) {
switch (msg->action) {
case 0:
case 12:
if (walk(kCharacterVesna, getCharacterCurrentParams(kCharacterVesna)[0], getCharacterCurrentParams(kCharacterVesna)[1])) {
getCharacter(kCharacterVesna).currentCall--;
_engine->getMessageManager()->setMessageHandle(kCharacterVesna, _functionsDemoVesna[getCharacter(kCharacterVesna).callbacks[getCharacter(kCharacterVesna).currentCall]]);
fedEx(kCharacterVesna, kCharacterVesna, 18, 0);
}
break;
case 5:
if (rnd(2) == 0) {
playDialog(kCharacterCath, "CAT1015A", -1, 0);
} else {
playDialog(kCharacterCath, "CAT1015", -1, 0);
}
break;
case 6:
playChrExcuseMe(kCharacterVesna, kCharacterCath, 0);
break;
default:
break;
}
}
void LogicManager::CONS_DemoVesna_WaitRCClear(CONS_PARAMS) {
CharacterCallParams *params = &getCharacter(kCharacterVesna).callParams[getCharacter(kCharacterVesna).currentCall];
_engine->getMessageManager()->setMessageHandle(kCharacterVesna, &LogicManager::HAND_DemoVesna_WaitRCClear);
getCharacter(kCharacterVesna).callbacks[getCharacter(kCharacterVesna).currentCall] = 4;
params->clear();
fedEx(kCharacterVesna, kCharacterVesna, 12, 0);
}
void LogicManager::HAND_DemoVesna_WaitRCClear(HAND_PARAMS) {
switch (msg->action) {
case 0:
case 12:
if (rcClear()) {
getCharacter(kCharacterVesna).currentCall--;
_engine->getMessageManager()->setMessageHandle(kCharacterVesna, _functionsDemoVesna[getCharacter(kCharacterVesna).callbacks[getCharacter(kCharacterVesna).currentCall]]);
fedEx(kCharacterVesna, kCharacterVesna, 18, 0);
}
break;
default:
break;
}
}
void LogicManager::CONS_DemoVesna_FinishSeqOtis(CONS_PARAMS) {
CharacterCallParams *params = &getCharacter(kCharacterVesna).callParams[getCharacter(kCharacterVesna).currentCall];
_engine->getMessageManager()->setMessageHandle(kCharacterVesna, &LogicManager::HAND_DemoVesna_FinishSeqOtis);
getCharacter(kCharacterVesna).callbacks[getCharacter(kCharacterVesna).currentCall] = 5;
params->clear();
fedEx(kCharacterVesna, kCharacterVesna, 12, 0);
}
void LogicManager::HAND_DemoVesna_FinishSeqOtis(HAND_PARAMS) {
if (msg->action == 3) {
getCharacter(kCharacterVesna).currentCall--;
_engine->getMessageManager()->setMessageHandle(kCharacterVesna, _functionsDemoVesna[getCharacter(kCharacterVesna).callbacks[getCharacter(kCharacterVesna).currentCall]]);
fedEx(kCharacterVesna, kCharacterVesna, 18, 0);
}
}
void LogicManager::CONS_DemoVesna_Birth(CONS_PARAMS) {
CharacterCallParams *params = &getCharacter(kCharacterVesna).callParams[getCharacter(kCharacterVesna).currentCall];
_engine->getMessageManager()->setMessageHandle(kCharacterVesna, &LogicManager::HAND_DemoVesna_Birth);
getCharacter(kCharacterVesna).callbacks[getCharacter(kCharacterVesna).currentCall] = 6;
params->clear();
fedEx(kCharacterVesna, kCharacterVesna, 12, 0);
}
void LogicManager::HAND_DemoVesna_Birth(HAND_PARAMS) {
if (msg->action == 12)
CONS_DemoVesna_InComp(0, 0, 0, 0);
}
void LogicManager::CONS_DemoVesna_InComp(CONS_PARAMS) {
CharacterCallParams *params = &getCharacter(kCharacterVesna).callParams[getCharacter(kCharacterVesna).currentCall];
_engine->getMessageManager()->setMessageHandle(kCharacterVesna, &LogicManager::HAND_DemoVesna_InComp);
getCharacter(kCharacterVesna).callbacks[getCharacter(kCharacterVesna).currentCall] = 7;
params->clear();
fedEx(kCharacterVesna, kCharacterVesna, 12, 0);
}
void LogicManager::HAND_DemoVesna_InComp(HAND_PARAMS) {
switch (msg->action) {
case 0:
if (_globals[kGlobalAnnaIsInBaggageCar] && getCharacterCurrentParams(kCharacterVesna)[0] != 0x7FFFFFFF && _gameTime) {
if (_gameTime <= 2259000) {
if (!cathInCorridor(kCarRedSleeping) || !getCharacterCurrentParams(kCharacterVesna)[0]) {
getCharacterCurrentParams(kCharacterVesna)[0] = _gameTime;
if (!_gameTime) {
CONS_DemoVesna_KillAnna(0, 0, 0, 0);
break;
}
}
if (getCharacterCurrentParams(kCharacterVesna)[0] >= _gameTime)
break;
}
getCharacterCurrentParams(kCharacterVesna)[0] = 0x7FFFFFFF;
CONS_DemoVesna_KillAnna(0, 0, 0, 0);
}
break;
case 12:
getCharacter(kCharacterVesna).characterPosition.car = kCarRedSleeping;
getCharacter(kCharacterVesna).characterPosition.position = 3050;
getCharacter(kCharacterVesna).characterPosition.location = 1;
getCharacter(kCharacterVesna).clothes = 0;
getCharacter(kCharacterVesna).inventoryItem = 0;
endGraphics(kCharacterVesna);
break;
default:
break;
}
}
void LogicManager::CONS_DemoVesna_KillAnna(CONS_PARAMS) {
CharacterCallParams *params = &getCharacter(kCharacterVesna).callParams[getCharacter(kCharacterVesna).currentCall];
_engine->getMessageManager()->setMessageHandle(kCharacterVesna, &LogicManager::HAND_DemoVesna_KillAnna);
getCharacter(kCharacterVesna).callbacks[getCharacter(kCharacterVesna).currentCall] = 8;
params->clear();
fedEx(kCharacterVesna, kCharacterVesna, 12, 0);
}
void LogicManager::HAND_DemoVesna_KillAnna(HAND_PARAMS) {
switch (msg->action) {
case 12:
getCharacter(kCharacterVesna).callbacks[getCharacter(kCharacterVesna).currentCall + 8] = 1;
DemoVesnaCall(&LogicManager::CONS_DemoVesna_DoCorrOtis, "610Bg", 38, 0, 0);
break;
case 18:
switch (getCharacter(kCharacterVesna).callbacks[getCharacter(kCharacterVesna).currentCall + 8]) {
case 1:
getCharacter(kCharacterVesna).characterPosition.location = 0;
if (getCharacter(kCharacterVesna).characterPosition.position < 2087)
getCharacter(kCharacterVesna).characterPosition.position = 2088;
getCharacter(kCharacterVesna).callbacks[getCharacter(kCharacterVesna).currentCall + 8] = 2;
DemoVesnaCall(&LogicManager::CONS_DemoVesna_DoWalk, kCarRestaurant, 850, 0, 0);
break;
case 2:
getCharacter(kCharacterVesna).callbacks[getCharacter(kCharacterVesna).currentCall + 8] = 3;
DemoVesnaCall(&LogicManager::CONS_DemoVesna_WaitRCClear, 0, 0, 0, 0);
break;
case 3:
getCharacter(kCharacterVesna).characterPosition.position = 1540;
getCharacter(kCharacterVesna).characterPosition.location = 0;
getCharacter(kCharacterVesna).callbacks[getCharacter(kCharacterVesna).currentCall + 8] = 4;
DemoVesnaCall(&LogicManager::CONS_DemoVesna_DoSeqOtis, "808US", 0, 0, 0);
break;
case 4:
startSeqOtis(kCharacterVesna, "808UD");
if (inSalon(kCharacterCath))
advanceFrame(kCharacterVesna);
getCharacter(kCharacterVesna).callbacks[getCharacter(kCharacterVesna).currentCall + 8] = 5;
DemoVesnaCall(&LogicManager::CONS_DemoVesna_FinishSeqOtis, 0, 0, 0, 0);
break;
case 5:
endGraphics(kCharacterVesna);
getCharacter(kCharacterVesna).characterPosition.car = kCarBaggage;
send(kCharacterVesna, kCharacterAnna, 235856512, 0);
break;
case 6:
getCharacter(kCharacterVesna).characterPosition.car = kCarRestaurant;
getCharacter(kCharacterVesna).characterPosition.position = 5800;
getCharacter(kCharacterVesna).characterPosition.location = 0;
getCharacter(kCharacterVesna).callbacks[getCharacter(kCharacterVesna).currentCall + 8] = 7;
DemoVesnaCall(&LogicManager::CONS_DemoVesna_DoSeqOtis, "808DD", 0, 0, 0);
break;
case 7:
startSeqOtis(kCharacterVesna, "808DS");
if (inDiningRoom(kCharacterCath))
advanceFrame(kCharacterVesna);
getCharacter(kCharacterVesna).callbacks[getCharacter(kCharacterVesna).currentCall + 8] = 8;
DemoVesnaCall(&LogicManager::CONS_DemoVesna_FinishSeqOtis, 0, 0, 0, 0);
break;
case 8:
getCharacter(kCharacterVesna).callbacks[getCharacter(kCharacterVesna).currentCall + 8] = 9;
DemoVesnaCall(&LogicManager::CONS_DemoVesna_DoWalk, kCarRedSleeping, 3050, 0, 0);
break;
case 9:
getCharacter(kCharacterVesna).callbacks[getCharacter(kCharacterVesna).currentCall + 8] = 10;
DemoVesnaCall(&LogicManager::CONS_DemoVesna_DoCorrOtis, "610Ag", 3050, 0, 0);
break;
case 10:
getCharacter(kCharacterVesna).characterPosition.position = 3050;
getCharacter(kCharacterVesna).characterPosition.location = 1;
endGraphics(kCharacterVesna);
break;
default:
break;
}
break;
case 189299008:
getCharacter(kCharacterVesna).callbacks[getCharacter(kCharacterVesna).currentCall + 8] = 6;
DemoVesnaCall(&LogicManager::CONS_DemoVesna_WaitRCClear, 0, 0, 0, 0);
break;
default:
break;
}
}
void LogicManager::CONS_DemoVesna_StartPart2(CONS_PARAMS) {
CharacterCallParams *params = &getCharacter(kCharacterVesna).callParams[getCharacter(kCharacterVesna).currentCall];
_engine->getMessageManager()->setMessageHandle(kCharacterVesna, &LogicManager::HAND_DemoVesna_StartPart2);
getCharacter(kCharacterVesna).callbacks[getCharacter(kCharacterVesna).currentCall] = 9;
params->clear();
fedEx(kCharacterVesna, kCharacterVesna, 12, 0);
}
void LogicManager::HAND_DemoVesna_StartPart2(HAND_PARAMS) {
// No-op
}
void LogicManager::CONS_DemoVesna_StartPart3(CONS_PARAMS) {
CharacterCallParams *params = &getCharacter(kCharacterVesna).callParams[getCharacter(kCharacterVesna).currentCall];
_engine->getMessageManager()->setMessageHandle(kCharacterVesna, &LogicManager::HAND_DemoVesna_StartPart3);
getCharacter(kCharacterVesna).callbacks[getCharacter(kCharacterVesna).currentCall] = 10;
params->clear();
fedEx(kCharacterVesna, kCharacterVesna, 12, 0);
}
void LogicManager::HAND_DemoVesna_StartPart3(HAND_PARAMS) {
// No-op
}
void LogicManager::CONS_DemoVesna_StartPart4(CONS_PARAMS) {
CharacterCallParams *params = &getCharacter(kCharacterVesna).callParams[getCharacter(kCharacterVesna).currentCall];
_engine->getMessageManager()->setMessageHandle(kCharacterVesna, &LogicManager::HAND_DemoVesna_StartPart4);
getCharacter(kCharacterVesna).callbacks[getCharacter(kCharacterVesna).currentCall] = 11;
params->clear();
fedEx(kCharacterVesna, kCharacterVesna, 12, 0);
}
void LogicManager::HAND_DemoVesna_StartPart4(HAND_PARAMS) {
// No-op
}
void LogicManager::CONS_DemoVesna_StartPart5(CONS_PARAMS) {
CharacterCallParams *params = &getCharacter(kCharacterVesna).callParams[getCharacter(kCharacterVesna).currentCall];
_engine->getMessageManager()->setMessageHandle(kCharacterVesna, &LogicManager::HAND_DemoVesna_StartPart5);
getCharacter(kCharacterVesna).callbacks[getCharacter(kCharacterVesna).currentCall] = 12;
params->clear();
fedEx(kCharacterVesna, kCharacterVesna, 12, 0);
}
void LogicManager::HAND_DemoVesna_StartPart5(HAND_PARAMS) {
// No-op
}
void (LogicManager::*LogicManager::_functionsDemoVesna[])(HAND_PARAMS) = {
nullptr,
&LogicManager::HAND_DemoVesna_DoCorrOtis,
&LogicManager::HAND_DemoVesna_DoSeqOtis,
&LogicManager::HAND_DemoVesna_DoWalk,
&LogicManager::HAND_DemoVesna_WaitRCClear,
&LogicManager::HAND_DemoVesna_FinishSeqOtis,
&LogicManager::HAND_DemoVesna_Birth,
&LogicManager::HAND_DemoVesna_InComp,
&LogicManager::HAND_DemoVesna_KillAnna,
&LogicManager::HAND_DemoVesna_StartPart2,
&LogicManager::HAND_DemoVesna_StartPart3,
&LogicManager::HAND_DemoVesna_StartPart4,
&LogicManager::HAND_DemoVesna_StartPart5
};
} // End of namespace LastExpress

225
engines/lastexpress/characters/demo/demo_waiter1.cpp Normal file
View File

@@ -0,0 +1,225 @@
/* ScummVM - Graphic Adventure Engine
*
* ScummVM is the legal property of its developers, whose names
* are too numerous to list here. Please refer to the COPYRIGHT
* file distributed with this source distribution.
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <http://www.gnu.org/licenses/>.
*
*/
#include "lastexpress/lastexpress.h"
namespace LastExpress {
void LogicManager::CONS_DemoWaiter1(int chapter) {
switch (chapter) {
case 0:
_engine->getMessageManager()->setMessageHandle(
kCharacterWaiter1,
_functionsDemoWaiter1[getCharacter(kCharacterWaiter1).callbacks[getCharacter(kCharacterWaiter1).currentCall]]
);
break;
case 1:
CONS_DemoWaiter1_Birth(0, 0, 0, 0);
break;
case 2:
CONS_DemoWaiter1_StartPart2(0, 0, 0, 0);
break;
case 3:
CONS_DemoWaiter1_StartPart3(0, 0, 0, 0);
break;
case 4:
CONS_DemoWaiter1_StartPart4(0, 0, 0, 0);
break;
case 5:
CONS_DemoWaiter1_StartPart5(0, 0, 0, 0);
break;
default:
break;
}
}
void LogicManager::DemoWaiter1Call(CALL_PARAMS) {
getCharacter(kCharacterWaiter1).currentCall++;
(this->*functionPointer)(param1, param2, param3, param4);
}
void LogicManager::CONS_DemoWaiter1_DoSeqOtis(CONS_PARAMS) {
CharacterCallParams *params = &getCharacter(kCharacterWaiter1).callParams[getCharacter(kCharacterWaiter1).currentCall];
_engine->getMessageManager()->setMessageHandle(kCharacterWaiter1, &LogicManager::HAND_DemoWaiter1_DoSeqOtis);
getCharacter(kCharacterWaiter1).callbacks[getCharacter(kCharacterWaiter1).currentCall] = 1;
params->clear();
strncpy((char *)&params->parameters[0], param1.stringParam, 12);
fedEx(kCharacterWaiter1, kCharacterWaiter1, 12, 0);
}
void LogicManager::HAND_DemoWaiter1_DoSeqOtis(HAND_PARAMS) {
switch (msg->action) {
case 3:
getCharacter(kCharacterWaiter1).currentCall--;
_engine->getMessageManager()->setMessageHandle(kCharacterWaiter1, _functionsDemoWaiter1[getCharacter(kCharacterWaiter1).callbacks[getCharacter(kCharacterWaiter1).currentCall]]);
fedEx(kCharacterWaiter1, kCharacterWaiter1, 18, 0);
break;
case 5:
if (!getCharacterCurrentParams(kCharacterWaiter1)[3]) {
playChrExcuseMe(kCharacterWaiter1, kCharacterCath, 0);
getCharacterCurrentParams(kCharacterWaiter1)[3] = 1;
}
break;
case 12:
startSeqOtis(kCharacterWaiter1, (char *)&getCharacterCurrentParams(kCharacterWaiter1)[0]);
break;
default:
break;
}
}
void LogicManager::CONS_DemoWaiter1_Birth(CONS_PARAMS) {
CharacterCallParams *params = &getCharacter(kCharacterWaiter1).callParams[getCharacter(kCharacterWaiter1).currentCall];
_engine->getMessageManager()->setMessageHandle(kCharacterWaiter1, &LogicManager::HAND_DemoWaiter1_Birth);
getCharacter(kCharacterWaiter1).callbacks[getCharacter(kCharacterWaiter1).currentCall] = 2;
params->clear();
fedEx(kCharacterWaiter1, kCharacterWaiter1, 12, 0);
}
void LogicManager::HAND_DemoWaiter1_Birth(HAND_PARAMS) {
switch (msg->action) {
case 12:
getCharacter(kCharacterWaiter1).characterPosition.car = kCarRestaurant;
getCharacter(kCharacterWaiter1).characterPosition.position = 5900;
getCharacter(kCharacterWaiter1).characterPosition.location = 0;
break;
case 223712416:
getCharacter(kCharacterWaiter1).callbacks[getCharacter(kCharacterWaiter1).currentCall + 8] = 1;
DemoWaiter1Call(&LogicManager::CONS_DemoWaiter1_RebeccaFeedUs, 0, 0, 0, 0);
break;
default:
break;
}
}
void LogicManager::CONS_DemoWaiter1_RebeccaFeedUs(CONS_PARAMS) {
CharacterCallParams *params = &getCharacter(kCharacterWaiter1).callParams[getCharacter(kCharacterWaiter1).currentCall];
_engine->getMessageManager()->setMessageHandle(kCharacterWaiter1, &LogicManager::HAND_DemoWaiter1_RebeccaFeedUs);
getCharacter(kCharacterWaiter1).callbacks[getCharacter(kCharacterWaiter1).currentCall] = 3;
params->clear();
fedEx(kCharacterWaiter1, kCharacterWaiter1, 12, 0);
}
void LogicManager::HAND_DemoWaiter1_RebeccaFeedUs(HAND_PARAMS) {
switch (msg->action) {
case 12:
getCharacter(kCharacterWaiter1).characterPosition.position = 5800;
getCharacter(kCharacterWaiter1).characterPosition.location = 0;
getCharacter(kCharacterWaiter1).callbacks[getCharacter(kCharacterWaiter1).currentCall + 8] = 1;
DemoWaiter1Call(&LogicManager::CONS_DemoWaiter1_DoSeqOtis, "911", 0, 0, 0);
break;
case 18:
if (getCharacter(kCharacterWaiter1).callbacks[getCharacter(kCharacterWaiter1).currentCall + 8] == 1) {
endGraphics(kCharacterWaiter1);
send(kCharacterWaiter1, kCharacterRebecca, 123712592, 0);
} else if (getCharacter(kCharacterWaiter1).callbacks[getCharacter(kCharacterWaiter1).currentCall + 8] == 2) {
endGraphics(kCharacterWaiter1);
getCharacter(kCharacterWaiter1).characterPosition.position = 5900;
}
break;
case 136702400:
getCharacter(kCharacterWaiter1).callbacks[getCharacter(kCharacterWaiter1).currentCall + 8] = 2;
DemoWaiter1Call(&LogicManager::CONS_DemoWaiter1_DoSeqOtis, "913", 0, 0, 0);
break;
default:
break;
}
}
void LogicManager::CONS_DemoWaiter1_StartPart2(CONS_PARAMS) {
CharacterCallParams *params = &getCharacter(kCharacterWaiter1).callParams[getCharacter(kCharacterWaiter1).currentCall];
_engine->getMessageManager()->setMessageHandle(kCharacterWaiter1, &LogicManager::HAND_DemoWaiter1_StartPart2);
getCharacter(kCharacterWaiter1).callbacks[getCharacter(kCharacterWaiter1).currentCall] = 4;
params->clear();
fedEx(kCharacterWaiter1, kCharacterWaiter1, 12, 0);
}
void LogicManager::HAND_DemoWaiter1_StartPart2(HAND_PARAMS) {
// No-op
}
void LogicManager::CONS_DemoWaiter1_StartPart3(CONS_PARAMS) {
CharacterCallParams *params = &getCharacter(kCharacterWaiter1).callParams[getCharacter(kCharacterWaiter1).currentCall];
_engine->getMessageManager()->setMessageHandle(kCharacterWaiter1, &LogicManager::HAND_DemoWaiter1_StartPart3);
getCharacter(kCharacterWaiter1).callbacks[getCharacter(kCharacterWaiter1).currentCall] = 5;
params->clear();
fedEx(kCharacterWaiter1, kCharacterWaiter1, 12, 0);
}
void LogicManager::HAND_DemoWaiter1_StartPart3(HAND_PARAMS) {
// No-op
}
void LogicManager::CONS_DemoWaiter1_StartPart4(CONS_PARAMS) {
CharacterCallParams *params = &getCharacter(kCharacterWaiter1).callParams[getCharacter(kCharacterWaiter1).currentCall];
_engine->getMessageManager()->setMessageHandle(kCharacterWaiter1, &LogicManager::HAND_DemoWaiter1_StartPart4);
getCharacter(kCharacterWaiter1).callbacks[getCharacter(kCharacterWaiter1).currentCall] = 6;
params->clear();
fedEx(kCharacterWaiter1, kCharacterWaiter1, 12, 0);
}
void LogicManager::HAND_DemoWaiter1_StartPart4(HAND_PARAMS) {
// No-op
}
void LogicManager::CONS_DemoWaiter1_StartPart5(CONS_PARAMS) {
CharacterCallParams *params = &getCharacter(kCharacterWaiter1).callParams[getCharacter(kCharacterWaiter1).currentCall];
_engine->getMessageManager()->setMessageHandle(kCharacterWaiter1, &LogicManager::HAND_DemoWaiter1_StartPart5);
getCharacter(kCharacterWaiter1).callbacks[getCharacter(kCharacterWaiter1).currentCall] = 7;
params->clear();
fedEx(kCharacterWaiter1, kCharacterWaiter1, 12, 0);
}
void LogicManager::HAND_DemoWaiter1_StartPart5(HAND_PARAMS) {
// No-op
}
void (LogicManager::*LogicManager::_functionsDemoWaiter1[])(HAND_PARAMS) = {
nullptr,
&LogicManager::HAND_DemoWaiter1_DoSeqOtis,
&LogicManager::HAND_DemoWaiter1_Birth,
&LogicManager::HAND_DemoWaiter1_RebeccaFeedUs,
&LogicManager::HAND_DemoWaiter1_StartPart2,
&LogicManager::HAND_DemoWaiter1_StartPart3,
&LogicManager::HAND_DemoWaiter1_StartPart4,
&LogicManager::HAND_DemoWaiter1_StartPart5
};
} // End of namespace LastExpress