From 720050bec1477b1e7df5bb34bb6ecf992d2a8ca1 Mon Sep 17 00:00:00 2001 From: johndoe123 Date: Mon, 18 Jul 2011 18:54:43 +0000 Subject: NEVERHOOD: Start with Module1200/Scene1201 (not complete yet) - Fix an odd bug with the game variables (index of newly added subvar was sometimes -1) --- engines/neverhood/gamemodule.cpp | 44 ++- engines/neverhood/gamemodule.h | 5 + engines/neverhood/gamevars.cpp | 20 +- engines/neverhood/klayman.cpp | 254 ++++++++++++- engines/neverhood/klayman.h | 21 ++ engines/neverhood/module.mk | 1 + engines/neverhood/module1200.cpp | 772 +++++++++++++++++++++++++++++++++++++++ engines/neverhood/module1200.h | 141 +++++++ engines/neverhood/scene.cpp | 7 + engines/neverhood/scene.h | 1 + 10 files changed, 1245 insertions(+), 21 deletions(-) create mode 100644 engines/neverhood/module1200.cpp create mode 100644 engines/neverhood/module1200.h (limited to 'engines') diff --git a/engines/neverhood/gamemodule.cpp b/engines/neverhood/gamemodule.cpp index 4800923d2d..95a6a5f48a 100644 --- a/engines/neverhood/gamemodule.cpp +++ b/engines/neverhood/gamemodule.cpp @@ -24,6 +24,7 @@ #include "neverhood/graphics.h" #include "neverhood/module1000.h" +#include "neverhood/module1200.h" #include "neverhood/module1500.h" #include "neverhood/module2300.h" @@ -108,8 +109,9 @@ uint32 GameModule::handleMessage(int messageNum, const MessageParam ¶m, Enti void GameModule::startup() { // TODO: Displaying of error text probably not needed in ScummVM // createModule1500(0); // Logos and intro video //Real -// createModule1000(0); - createModule2300(0); +// createModule1000(-1); +// createModule2300(0); + createModule1200(0); } void GameModule::createModule1000(int which) { @@ -132,6 +134,30 @@ void GameModule::updateModule1000() { } } +void GameModule::createModule1200(int which) { + setGlobalVar(0x91080831, 0x00478311); + _childObject = new Module1200(_vm, this, which); + SetUpdateHandler(&GameModule::updateModule1200); +} + +void GameModule::updateModule1200() { + if (!_childObject) + return; + _childObject->handleUpdate(); + if (_done) { + _done = false; + delete _childObject; + _childObject = NULL; + if (_field20 == 1) { + // TODO createModule2600(0); + // TODO _childObject->handleUpdate(); + } else { + createModule2300(2); + _childObject->handleUpdate(); + } + } +} + void GameModule::createModule1500(int which) { _someFlag1 = false; setGlobalVar(0x91080831, 0x00F10114); @@ -170,8 +196,8 @@ void GameModule::updateModule2300() { // TODO createModule2200(0); // TODO _childObject->handleUpdate(); } else if (_field20 == 2) { - // TODO createModule1200(0); - // TODO _childObject->handleUpdate(); + createModule1200(0); + _childObject->handleUpdate(); } else if (_field20 == 3) { // TODO createModule2400(0); // TODO _childObject->handleUpdate(); @@ -196,4 +222,14 @@ void GameModule::updateModule2300() { } } +void GameModule::createModule2400(int which) { + debug("createModule2400"); + _vm->_system->quit(); +} + +void GameModule::createModule3000(int which) { + debug("createModule3000"); + _vm->_system->quit(); +} + } // End of namespace Neverhood diff --git a/engines/neverhood/gamemodule.h b/engines/neverhood/gamemodule.h index 7977ea51a0..d95c31e47d 100644 --- a/engines/neverhood/gamemodule.h +++ b/engines/neverhood/gamemodule.h @@ -51,10 +51,15 @@ protected: void startup(); void createModule1000(int which); void updateModule1000(); + void createModule1200(int which); + void updateModule1200(); void createModule1500(int which); void updateModule1500(); + void createModule2200(int which); void createModule2300(int which); void updateModule2300(); + void createModule2400(int which); + void createModule3000(int which); }; } // End of namespace Neverhood diff --git a/engines/neverhood/gamevars.cpp b/engines/neverhood/gamevars.cpp index 98ae709cfd..caf79b2ad9 100644 --- a/engines/neverhood/gamevars.cpp +++ b/engines/neverhood/gamevars.cpp @@ -57,7 +57,16 @@ uint32 GameVars::getSubVar(uint32 nameHash, uint32 subNameHash) { void GameVars::setSubVar(uint32 nameHash, uint32 subNameHash, uint32 value) { debug("GameVars::setSubVar(%08X, %08X, %d)", nameHash, subNameHash, value); - _vars[getSubVarIndex(getSubVarIndex(0, nameHash), subNameHash)].value = value; + + int16 varIndex = getSubVarIndex(0, nameHash); + debug(" varIndex = %d", varIndex); + + int16 subVarIndex = getSubVarIndex(varIndex, subNameHash); + debug(" subVarIndex = %d", subVarIndex); + + _vars[subVarIndex].value = value; + + //_vars[getSubVarIndex(getSubVarIndex(0, nameHash), subNameHash)].value = value; } int16 GameVars::addVar(uint32 nameHash, uint32 value) { @@ -89,16 +98,19 @@ int16 GameVars::addSubVar(int16 varIndex, uint32 subNameHash, uint32 value) { } else { while (_vars[nextIndex].nextIndex != -1) nextIndex = _vars[nextIndex].nextIndex; - _vars[nextIndex].nextIndex = addVar(subNameHash, value); - return _vars[nextIndex].nextIndex; + int16 index = addVar(subNameHash, value); + _vars[nextIndex].nextIndex = index; + return index; } } int16 GameVars::getSubVarIndex(int16 varIndex, uint32 subNameHash) { debug("GameVars::getSubVarIndex(%d, %08X)", varIndex, subNameHash); int16 subVarIndex = findSubVarIndex(varIndex, subNameHash); - if (subVarIndex == -1) + if (subVarIndex == -1) { subVarIndex = addSubVar(varIndex, subNameHash, 0); + debug("need to create: subVarIndex = %d", subVarIndex); + } return subVarIndex; } diff --git a/engines/neverhood/klayman.cpp b/engines/neverhood/klayman.cpp index d5c320536f..145d645e01 100644 --- a/engines/neverhood/klayman.cpp +++ b/engines/neverhood/klayman.cpp @@ -84,8 +84,7 @@ uint32 Klayman::xHandleMessage(int messageNum, const MessageParam ¶m) { setCallback2(AnimationCallback(&Klayman::sub41FC80)); break; case 0x4818: - debug("TODO sub41C930"); - // TODO sub41C930(_rectResource.getRectangle1(param.asInteger()).x, false); + sub41C930(_dataResource.getPoint(param.asInteger()).x, false); break; } return 0; @@ -461,6 +460,7 @@ uint32 Klayman::handleMessage41F140(int messageNum, const MessageParam ¶m, E void Klayman::sub41C930(int16 x, bool flag) { debug("Klayman::sub41C930(%d, %d)", x, flag); int16 xdiff = ABS(x - _x); + debug("xdiff = %d", xdiff); if (x == _x) { _x4 = x; if (!_flagE1 && !_flagE2 && !_flagE3) { @@ -485,6 +485,7 @@ void Klayman::sub41C930(int16 x, bool flag) { error("// TODO AnimatedSprite_setCallback2(AnimationCallback(&Klayman::sub421550));"); // TODO AnimatedSprite_setCallback2(AnimationCallback(&Klayman::sub421550)); } else { + debug("##################################################################"); _x4 = x; setCallback2(AnimationCallback(&Klayman::sub41F950)); } @@ -688,6 +689,9 @@ void Klayman::sub41F950() { _status2 = 0; _flagE1 = true; _flagE5 = true; + + debug("222222222222222222222 x = %d; x4 = %d", _x, _x4); + setDoDeltaX(_x4 < _x); setFileHash(0x242C0198, 0, -1); SetUpdateHandler(&Klayman::update); @@ -821,9 +825,12 @@ void Klayman::spriteUpdate41F320() { sendMessage(0x1019, 0, this); } else { HitRect *hitRectPrev = _vm->_collisionMan->findHitRectAtPos(_x, _y); + + debug("xxxxxxxxxxxxxxxxxxxxxxxxx xdelta = %d", xdelta); + _x += xdelta; if (_field114) { - debug("_field114"); + error("_field114"); // TODO Klayman_sub_41CF70 } else { HitRect *hitRectNext = _vm->_collisionMan->findHitRectAtPos(_x, _y); @@ -980,22 +987,28 @@ void Klayman::sub41CD00(int16 x) { void Klayman::sub41CC40(int16 x1, int16 x2) { if (_x > x1) { if (_x == x1 + x2) { + debug("sub41CC40 #1"); _x4 = x1 + x2; setCallback2(NULL); sub41C7B0(); } else if (_x < x1 + x2) { + debug("sub41CC40 #2"); sub41CAC0(x1 + x2); } else { + debug("sub41CC40 #3"); sub41C930(x1 + x2, false); } } else { if (_x == x1 - x2) { + debug("sub41CC40 #4"); _x4 = x1 - x2; setCallback2(NULL); sub41C7B0(); } else if (_x > x1 - x2) { + debug("sub41CC40 #5"); sub41CAC0(x1 - x2); } else { + debug("sub41CC40 #6"); sub41C930(x1 - x2, false); } } @@ -1593,6 +1606,26 @@ uint32 Klayman::handleMessage41E2F0(int messageNum, const MessageParam ¶m, E return messageResult; } +void Klayman::sub4207A0() { + if (!sub41CEB0(AnimationCallback(&Klayman::sub4207A0))) { + _status2 = 2; + _flagE5 = false; + setFileHash(0x9B250AD2, 0, -1); + SetUpdateHandler(&Klayman::update); + SetSpriteCallback(&Klayman::spriteUpdate41F230); + SetMessageHandler(&Klayman::handleMessage41EEF0); + } +} + +void Klayman::sub4207F0() { + _status2 = 2; + _flagE5 = false; + setFileHash(0x98F88391, 0, -1); + SetUpdateHandler(&Klayman::update); + SetSpriteCallback(&Klayman::spriteUpdate41F230); + SetMessageHandler(&Klayman::handleMessage41EEF0); +} + //############################################################################## // KmScene1001 @@ -1635,16 +1668,14 @@ uint32 KmScene1001::xHandleMessage(int messageNum, const MessageParam ¶m) { setDoDeltaX(param.asInteger()); sub41C7B0(); break; - case 0x481B: // TODO: It's not really a point but an x1/x2 pair - if (param.asPoint().x != 0) { - sub41CC40(param.asPoint().x, param.asPoint().y); + if (param.asPoint().y != 0) { + sub41CC40(param.asPoint().y, param.asPoint().x); } else { - sub41CCE0(param.asPoint().y); + sub41CCE0(param.asPoint().x); } break; - case 0x481F: if (param.asInteger() == 0) { setCallback2(AnimationCallback(&Klayman::sub420870)); @@ -1658,28 +1689,23 @@ uint32 KmScene1001::xHandleMessage(int messageNum, const MessageParam ¶m) { setCallback2(AnimationCallback(&Klayman::sub420830)); } break; - case 0x482D: setDoDeltaX(_x > (int16)param.asInteger()); sub41C7B0(); break; - case 0x4836: if (param.asInteger() == 1) { _parentScene->sendMessage(0x2002, 0, this); setCallback2(AnimationCallback(&Klayman::sub4211F0)); } break; - case 0x483F: sub41CD00(param.asInteger()); break; - case 0x4840: sub41CD70(param.asInteger()); break; } - return 0; } @@ -2325,4 +2351,206 @@ void KmScene1004::sub478170() { SetSpriteCallback(&AnimatedSprite::updateDeltaXY); } +// KmScene1201 + +KmScene1201::KmScene1201(NeverhoodEngine *vm, Entity *parentScene, Entity *class464, int16 x, int16 y) + : Klayman(vm, parentScene, x, y, 1000, 1000), _class464(class464), _countdown(0) { + + // TODO setKlaymanTable(dword_4AEF10, 3); + _flagF6 = true; + +} + +uint32 KmScene1201::xHandleMessage(int messageNum, const MessageParam ¶m) { + switch (messageNum) { + case 0x4001: + case 0x4800: + sub41C930(param.asPoint().x, false); + break; + case 0x4004: + setCallback2(AnimationCallback(&Klayman::sub41FC80)); + break; + case 0x480A: + setCallback2(AnimationCallback(&KmScene1201::sub40DF00)); + break; + case 0x4812: + setCallback2(AnimationCallback(&Klayman::sub41FF80)); + break; + case 0x4813: + setCallback2(AnimationCallback(&KmScene1201::sub40DD20)); + break; + case 0x4814: + setCallback2(AnimationCallback(&KmScene1201::sub40DFA0)); + break; + case 0x4815: + setCallback2(AnimationCallback(&KmScene1201::sub40E040)); + break; + case 0x4816: + if (param.asInteger() == 0) { + setCallback2(AnimationCallback(&Klayman::sub4200D0)); + } + break; + case 0x4817: + setDoDeltaX(param.asInteger() != 0 ? 1 : 0); + sub41C7B0(); + break; + case 0x481B: + if (param.asPoint().y != 0) { + sub41CC40(param.asPoint().y, param.asPoint().x); + } else { + sub41CCE0(param.asPoint().x); + } + break; + case 0x481D: + setCallback2(AnimationCallback(&Klayman::sub4207A0)); + break; + case 0x481E: + setCallback2(AnimationCallback(&Klayman::sub4207F0)); + break; + case 0x481F: + setCallback2(AnimationCallback(&Klayman::sub420830)); + break; + case 0x482D: + setDoDeltaX(_x > (int16)param.asInteger() ? 1 : 0); + sub41C7B0(); + break; + case 0x483F: + sub41CD00(param.asInteger()); + break; + case 0x4840: + sub41CD70(param.asInteger()); + break; + } + return 0; +} + +void KmScene1201::update40DBE0() { + if (_x >= 380) + sub41C7B0(); + Klayman::update(); +} + +uint32 KmScene1201::handleMessage40DC00(int messageNum, const MessageParam ¶m, Entity *sender) { + uint32 messageResult = Klayman::handleMessage41D480(messageNum, param, sender); + switch (messageNum) { + case 0x100D: + if (param.asInteger() == 0x51281850) { + setGlobalVar(0x20A0C516, 1); + } else if (param.asInteger() == 0x43000538) { + _soundResource1.play(0x21043059); + } else if (param.asInteger() == 0x02B20220) { + _soundResource1.play(0xC5408620); + } else if (param.asInteger() == 0x0A720138) { + _soundResource1.play(0xD4C08010); + } else if (param.asInteger() == 0xB613A180) { + _soundResource1.play(0x44051000); + } + break; + } + return messageResult; +} + +void KmScene1201::sub40DD20() { + if (!sub41CEB0(AnimationCallback(&KmScene1201::sub40DD20))) { + _status2 = 0; + _flagE5 = false; + setDoDeltaX(((Sprite*)_attachedSprite)->getX() < _x ? 1 : 0); + setFileHash(0x9CAA0218, 0, -1); + SetUpdateHandler(&Klayman::update); + SetSpriteCallback(NULL); + SetMessageHandler(&KmScene1201::handleMessage40DC00); + SetAnimationCallback3(&KmScene1201::sub40DD90); + } +} + +void KmScene1201::sub40DD90() { + _status2 = 1; + _flagE5 = false; + setDoDeltaX(((Sprite*)_attachedSprite)->getX() < _x ? 1 : 0); + setFileHash(0x1222A513, 0, -1); + SetUpdateHandler(&Klayman::update); + SetSpriteCallback(NULL); + SetMessageHandler(&KmScene1201::handleMessage40DC00); +} + +uint32 KmScene1201::handleMessage40DDF0(int messageNum, const MessageParam ¶m, Entity *sender) { + switch (messageNum) { + case 0x100D: + if (param.asInteger() == 0x01084280) { + _soundResource1.play(0x405002D8); + if (_attachedSprite) { + _attachedSprite->sendMessage(0x480B, 0, this); + } + } else if (param.asInteger() == 0x02421405) { + if (_countdown != 0) { + _countdown--; + sub40DF60(); + } else { + SetMessageHandler(&Klayman::handleMessage41D480); + } + } + break; + } + return Klayman::handleMessage41D480(messageNum, param, sender); +} + +uint32 KmScene1201::handleMessage40DEA0(int messageNum, const MessageParam ¶m, Entity *sender) { + uint32 messageResult = Klayman::handleMessage41D480(messageNum, param, sender); + switch (messageNum) { + case 0x100D: + if (param.asInteger() == 0x000F0082) { + _soundResource1.play(0x74E2810F); + } + break; + } + return messageResult; +} + +void KmScene1201::sub40DF00() { + if (!sub41CEB0(AnimationCallback(&KmScene1201::sub40DF00))) { + _status2 = 2; + _flagE5 = false; + _countdown = 8; + setDoDeltaX(0); + setFileHash(0x0C1CA072, 0, -1); + SetUpdateHandler(&KmScene1201::update40DBE0); + SetSpriteCallback(&AnimatedSprite::updateDeltaXY); + SetMessageHandler(&KmScene1201::handleMessage40DDF0); + } +} + +void KmScene1201::sub40DF60() { + _flagE5 = false; + setFileHash2(0x0C1CA072, 0x01084280, 0); + SetUpdateHandler(&KmScene1201::update40DBE0); + SetSpriteCallback(&AnimatedSprite::updateDeltaXY); + SetMessageHandler(&KmScene1201::handleMessage40DDF0); +} + +void KmScene1201::sub40DFA0() { + if (!sub41CF10(AnimationCallback(&KmScene1201::sub40DFA0))) { + _status2 = 1; + _flagE5 = false; + setDoDeltaX(0); + setFileHash(0x2821C590, 0, -1); + SetUpdateHandler(&Klayman::update); + SetSpriteCallback(&AnimatedSprite::updateDeltaXY); + SetMessageHandler(&KmScene1201::handleMessage40DEA0); + SetAnimationCallback3(&Klayman::sub41FC80); + _class464->sendMessage(0x2006, 0, this); + _soundResource1.play(0x62E0A356); + } +} + +void KmScene1201::sub40E040() { + if (!sub41CF10(AnimationCallback(&KmScene1201::sub40E040))) { + _status2 = 1; + _flagE5 = false; + setFileHash(0x5420E254, 0, -1); + SetUpdateHandler(&Klayman::update); + SetSpriteCallback(NULL); + SetMessageHandler(&Klayman::handleMessage41D360); + } +} + } // End of namespace Neverhood diff --git a/engines/neverhood/klayman.h b/engines/neverhood/klayman.h index 8ec33bceab..3c87104125 100644 --- a/engines/neverhood/klayman.h +++ b/engines/neverhood/klayman.h @@ -82,6 +82,8 @@ public: void sub421070(); void sub420420(); void sub420ED0(); + void sub4207A0(); + void sub4207F0(); void spriteUpdate41F250(); void spriteUpdate41F5F0(); @@ -264,6 +266,25 @@ protected: void sub478170(); }; +class KmScene1201 : public Klayman { +public: + KmScene1201(NeverhoodEngine *vm, Entity *parentScene, Entity *class464, int16 x, int16 y); +protected: + Entity *_class464; + int _countdown; + uint32 xHandleMessage(int messageNum, const MessageParam ¶m); + void update40DBE0(); + uint32 handleMessage40DC00(int messageNum, const MessageParam ¶m, Entity *sender); + void sub40DD20(); + void sub40DD90(); + uint32 handleMessage40DDF0(int messageNum, const MessageParam ¶m, Entity *sender); + uint32 handleMessage40DEA0(int messageNum, const MessageParam ¶m, Entity *sender); + void sub40DF00(); + void sub40DF60(); + void sub40DFA0(); + void sub40E040(); +}; + } // End of namespace Neverhood #endif /* NEVERHOOD_KLAYMAN_H */ diff --git a/engines/neverhood/module.mk b/engines/neverhood/module.mk index ed7077e337..17424765e0 100644 --- a/engines/neverhood/module.mk +++ b/engines/neverhood/module.mk @@ -11,6 +11,7 @@ MODULE_OBJS = \ klayman.o \ module.o \ module1000.o \ + module1200.o \ module1500.o \ module2300.o \ mouse.o \ diff --git a/engines/neverhood/module1200.cpp b/engines/neverhood/module1200.cpp new file mode 100644 index 0000000000..8075c5c391 --- /dev/null +++ b/engines/neverhood/module1200.cpp @@ -0,0 +1,772 @@ +/* ScummVM - Graphic Adventure Engine + * + * ScummVM is the legal property of its developers, whose names + * are too numerous to list here. Please refer to the COPYRIGHT + * file distributed with this source distribution. + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. + + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. + * + */ + +#include "neverhood/module1200.h" +#include "neverhood/smackerscene.h" + +namespace Neverhood { + +Module1200::Module1200(NeverhoodEngine *vm, Module *parentModule, int which) + : Module(vm, parentModule), _moduleDone(false) { + + // TODO _resourceTable.setResourceList(0x004B3E68); + SetMessageHandler(&Module1200::handleMessage); + + if (which < 0) { + switch (_vm->gameState().sceneNum) { + case 0: + createScene1201(-1); + break; + case 1: + createScene1202(-1); + break; + case 2: + createScene1203(-1); + break; + } + } else if (which == 1) { + createScene1201(2); + } else { + createScene1201(0); + } + + // TODO Music18hList_add(0x00478311, 0x62222CAE); + // TODO Music18hList_play(0x62222CAE, 0, 0, 1); +} + +Module1200::~Module1200() { + // TODO Music18hList_deleteGroup(0x00478311); +} + +uint32 Module1200::handleMessage(int messageNum, const MessageParam ¶m, Entity *sender) { + uint32 messageResult = Module::handleMessage(messageNum, param, sender); + switch (messageNum) { + case 0x1009: + _moduleDone = true; + _moduleDoneStatus = param.asInteger(); + break; + } + return messageResult; +} + +void Module1200::createScene1201(int which) { + _vm->gameState().sceneNum = 0; + _childObject = new Scene1201(_vm, this, which); + SetUpdateHandler(&Module1200::updateScene1201); +} + +void Module1200::createScene1202(int which) { + _vm->gameState().sceneNum = 1; + //_childObject = new Scene1202(_vm, this, which); + //SetUpdateHandler(&Module1200::updateScene1202); +} + +void Module1200::createScene1203(int which) { + SmackerScene *smackerScene; + _vm->gameState().sceneNum = 2; + // TODO Music18hList_stop(0x62222CAE, 0, 0); + smackerScene = new SmackerScene(_vm, this, true, true, false); + smackerScene->setFileHash(0x31890001); + smackerScene->nextVideo(); + _childObject = smackerScene; + setGlobalVar(0x2A02C07B, 1); + SetUpdateHandler(&Module1200::updateScene1203); +} + +void Module1200::updateScene1201() { + _childObject->handleUpdate(); + if (_moduleDone) { + _moduleDone = false; + delete _childObject; + _childObject = NULL; + if (_moduleDoneStatus == 1) { + createScene1202(0); + _childObject->handleUpdate(); + } else if (_moduleDoneStatus == 2) { + _parentModule->sendMessage(0x1009, 0, this); + } else if (getGlobalVar(0x0A18CA33) && !getGlobalVar(0x2A02C07B)) { + createScene1203(-1); + } else { + _parentModule->sendMessage(0x1009, 1, this); + } + } +} + +void Module1200::updateScene1202() { + _childObject->handleUpdate(); + if (_moduleDone) { + _moduleDone = false; + delete _childObject; + _childObject = NULL; + createScene1201(1); + _childObject->handleUpdate(); + } +} + +void Module1200::updateScene1203() { + _childObject->handleUpdate(); + if (_moduleDone) { + _moduleDone = false; + delete _childObject; + _childObject = NULL; + createScene1201(3); + _childObject->handleUpdate(); + // TODO Music18hList_play(0x62222CAE, 0, 0, 1); + } +} + +// Scene1201 + +static const uint32 kScene1201InitArray[] = { + 1, 0, 2, 4, 5, 3, 6, 7, 8, 10, 9, 11, 13, 14, 12, 16, 17, 15 +}; + +static const NPoint kScene1201PointArray[] = { + {218, 193}, + {410, 225}, + {368, 277}, + {194, 227}, + {366, 174}, + {458, 224}, + {242, 228}, + {512, 228}, + {458, 277}, + {217, 233}, + {458, 173}, + {410, 276}, + {203, 280}, + {371, 226}, + {508, 279}, + {230, 273}, + {410, 171}, + {493, 174} +}; + +static const uint32 kScene1201SsScene1201TntFileHashList1[] = { + 0x2098212D, + 0x1600437E, + 0x1600437E, + 0x00A840E3, + 0x1A1830F6, + 0x1A1830F6, + 0x00212062, + 0x384010B6, + 0x384010B6, + 0x07A01080, + 0xD80C2837, + 0xD80C2837, + 0x03A22092, + 0xD8802CB6, + 0xD8802CB6, + 0x03A93831, + 0xDA460476, + 0xDA460476 +}; + +static const uint32 kScene1201SsScene1201TntFileHashList2[] = { + 0x3040C676, + 0x10914448, + 0x10914448, + 0x3448A066, + 0x1288C049, + 0x1288C049, + 0x78C0E026, + 0x3098D05A, + 0x3098D05A, + 0x304890E6, + 0x1284E048, + 0x1284E048, + 0xB140A1E6, + 0x5088A068, + 0x5088A068, + 0x74C4C866, + 0x3192C059, + 0x3192C059 +}; + +SsScene1201Tnt::SsScene1201Tnt(NeverhoodEngine *vm, uint32 elemIndex, uint32 pointIndex, int16 clipY2) + : StaticSprite(vm, 900), _field7A(-1) { + + int16 x = kScene1201PointArray[pointIndex].x; + int16 y = kScene1201PointArray[pointIndex].y; + if (x < 300) { + _spriteResource.load2(kScene1201SsScene1201TntFileHashList1[elemIndex]); + _x = _spriteResource.getPosition().x; + _y = _spriteResource.getPosition().y; + _drawRect.x = 0; + _drawRect.y = 0; + _drawRect.width = _spriteResource.getDimensions().width; + _drawRect.height = _spriteResource.getDimensions().height; + } else { + _spriteResource.load2(kScene1201SsScene1201TntFileHashList2[elemIndex]); + _x = x; + _y = y; + _drawRect.x = -(_spriteResource.getDimensions().width / 2); + _drawRect.y = -_spriteResource.getDimensions().height; + _drawRect.width = _spriteResource.getDimensions().width; + _drawRect.height = _spriteResource.getDimensions().height; + + } + createSurface(50, _spriteResource.getDimensions().width, _spriteResource.getDimensions().height); + _surface->getClipRect().x1 = 0; + _surface->getClipRect().y1 = 0; + _surface->getClipRect().x2 = 640; + _surface->getClipRect().y2 = clipY2; + _needRefresh = true; + StaticSprite::update(); +} + +AsScene1201Tape::AsScene1201Tape(NeverhoodEngine *vm, Scene *parentScene, uint32 nameHash, int surfacePriority, int16 x, int16 y, uint32 fileHash) + : AnimatedSprite(vm, fileHash, surfacePriority, x, y), _parentScene(parentScene), _nameHash(nameHash) { + + if (!getSubVar(0x02038314, _nameHash) && !getSubVar(0x02720344, _nameHash)) { + SetMessageHandler(&AsScene1201Tape::handleMessage); + } else { + _surface->setVisible(false); + SetMessageHandler(NULL); + } +} + +uint32 AsScene1201Tape::handleMessage(int messageNum, const MessageParam ¶m, Entity *sender) { + uint32 messageResult = Sprite::handleMessage(messageNum, param, sender); + switch (messageNum) { + case 0x1011: + _parentScene->sendMessage(0x4826, 0, this); + messageResult = 1; + break; + case 0x4806: + setSubVar(0x02038314, _nameHash, 1); + _surface->setVisible(false); + SetMessageHandler(NULL); + break; + } + return messageResult; +} + +Class466::Class466(NeverhoodEngine *vm, bool flag) + : AnimatedSprite(vm, 1200), _soundResource(vm) { + + SetUpdateHandler(&AnimatedSprite::update); + SetMessageHandler(&Class466::handleMessage); + createSurface(10, 34, 149); + _x = 202; + _y = -32; + if (flag) { + sub40D380(); + } else { + sub40D340(); + } +} + +uint32 Class466::handleMessage(int messageNum, const MessageParam ¶m, Entity *sender) { + uint32 messageResult = Sprite::handleMessage(messageNum, param, sender); + switch (messageNum) { + case 0x100D: + if (param.asInteger() == 0x02060018) { + _soundResource.play(0x47900E06); + } + break; + case 0x2006: + sub40D360(); + break; + } + return messageResult; +} + +void Class466::sub40D340() { + setFileHash(0x928F0C10, 0, -1); + _newHashListIndex = 0; +} + +void Class466::sub40D360() { + setFileHash(0x928F0C10, 1, -1); + _newHashListIndex = -2; +} + +void Class466::sub40D380() { + setFileHash(0x928F0C10, 15, -1); + _newHashListIndex = -2; +} + +Class468::Class468(NeverhoodEngine *vm, Sprite *klayman, bool flag) + : AnimatedSprite(vm, 1100), _soundResource(vm), _klayman(klayman), _countdown(0) { + + createSurface1(100, 0xD088AC30); + _x = 320; + _y = 240; + SetUpdateHandler(&Class468::update); + SetMessageHandler(&Class468::handleMessage); + _newHashListIndex = -2; + if (flag) { + setFileHash(0xD088AC30, -1, -1); + _newHashListIndex = -2; + _countdown = 25; + } else { + setFileHash1(); + _surface->setVisible(false); + } +} + +void Class468::update() { + if (_countdown != 0 && (--_countdown == 0)) { + sub40D830(); + } + AnimatedSprite::update(); +} + +uint32 Class468::handleMessage(int messageNum, const MessageParam ¶m, Entity *sender) { + uint32 messageResult = Sprite::handleMessage(messageNum, param, sender); + switch (messageNum) { + case 0x3002: + removeCallbacks(); + break; + case 0x4829: + sub40D7E0(); + break; + } + return messageResult; +} + +void Class468::sub40D7E0() { + setFileHash(0xD088AC30, 0, -1); + _newHashListIndex = -2; + _surface->setVisible(true); + _soundResource.play(calcHash("fxDoorOpen20")); +} + +void Class468::sub40D830() { + setFileHash(0xD088AC30, -1, -1); + _playBackwards = true; + _surface->setVisible(true); + _soundResource.play(calcHash("fxDoorClose20")); + SetAnimationCallback3(&Class468::sub40D880); +} + +void Class468::sub40D880() { + setFileHash1(); + _surface->setVisible(false); +} + +Class464::Class464(NeverhoodEngine *vm) + : AnimatedSprite(vm, 1200) { + + createSurface(1200, 69, 98); + SetUpdateHandler(&AnimatedSprite::update); + SetMessageHandler(&Class464::handleMessage); + SetSpriteCallback(&AnimatedSprite::updateDeltaXY); + _surface->setVisible(false); +} + +uint32 Class464::handleMessage(int messageNum, const MessageParam ¶m, Entity *sender) { + uint32 messageResult = Sprite::handleMessage(messageNum, param, sender); + switch (messageNum) { + case 0x2006: + _x = 436; + _y = 339; + setFileHash(0xA060C599, 0, -1); + _surface->setVisible(true); + break; + case 0x3002: + setFileHash1(); + _surface->setVisible(false); + removeCallbacks(); + break; + } + return messageResult; +} + +Class463::Class463(NeverhoodEngine *vm, Scene *parentScene, Sprite *class466, bool flag) + : AnimatedSprite(vm, 1100), _soundResource(vm), _parentScene(parentScene), _class466(class466), + _flag(false) { + + //TODO_field_F0 = -1; + + SetUpdateHandler(&AnimatedSprite::update); + SetMessageHandler(&Class463::handleMessage); + createSurface(990, 106, 181); + _x = 201; + if (flag) { + _y = 297; + sub40CD60(); + } else { + _y = 334; + sub40CD30(); + } +} + +Class463::~Class463() { + // TODO Sound1ChList_sub_407AF0(0x01D00560); +} + +uint32 Class463::handleMessage(int messageNum, const MessageParam ¶m, Entity *sender) { + uint32 messageResult = Sprite::handleMessage(messageNum, param, sender); + switch (messageNum) { + case 0x100D: + if (param.asInteger() == 0x092870C0) { + _class466->sendMessage(0x2006, 0, this); + } else if (param.asInteger() == 0x11CA0144) { + _soundResource.play(0x51800A04); + } + break; + case 0x1011: + _parentScene->sendMessage(0x2002, 0, this); + messageResult = 1; + case 0x480B: + if (!_flag) { + _sprite = (Sprite*)sender; + sub40CD90(); + } + break; + } + return messageResult; + +} + +uint32 Class463::handleMessage40CCD0(int messageNum, const MessageParam ¶m, Entity *sender) { + uint32 messageResult = Class463::handleMessage(messageNum, param, sender); + switch (messageNum) { + case 0x3002: + removeCallbacks(); + break; + } + return messageResult; +} + +void Class463::spriteUpdate40CD10() { + _x = _sprite->getX() + 100; +} + +void Class463::sub40CD30() { + setFileHash(0x654913D0, 0, -1); + SetMessageHandler(&Class463::handleMessage); + SetSpriteCallback(NULL); +} + +void Class463::sub40CD60() { + setFileHash(0x356803D0, 0, -1); + SetMessageHandler(&Class463::handleMessage40CCD0); + SetSpriteCallback(&AnimatedSprite::updateDeltaXY); + SetAnimationCallback3(&Class463::sub40CD30); +} + +void Class463::sub40CD90() { + // TODO Sound1ChList_addSoundResource(0x01D00560, 0x4B044624, true); + // TODO Sound1ChList_playLooping(0x4B044624); + _flag = true; + setFileHash(0x85084190, 0, -1); + SetMessageHandler(&Class463::handleMessage); + SetSpriteCallback(&Class463::spriteUpdate40CD10); + _newHashListIndex = -2; +} + + +Scene1201::Scene1201(NeverhoodEngine *vm, Module *parentModule, int which) + : Scene(vm, parentModule, true), _flag(false) { + + int16 topY1, topY2, topY3, topY4; + int16 x1, x2; + Sprite *tempSprite, *class464; + + // TODO _resourceTable2.setResourceList(ex_sub_41C730(), true); + if (getGlobalVar(0x0A18CA33)) { + // TODO _resourceTable1.setResourceList(0x004AEA10, true); + } else if (getGlobalVar(0x0A310817)) { + // TODO _resourceTable1.setResourceList(0x004AEA70, true); + } else { + // TODO _resourceTable1.setResourceList(0x004AEB18, true); + } + + SetUpdateHandler(&Scene1201::update); + SetMessageHandler(&Scene1201::handleMessage); + + _vm->_collisionMan->setHitRects(0x004AEBD0); + + _surfaceFlag = true; + + if (!getSubVar(0x40050052, 0xE8058B52)) { + setSubVar(0x40050052, 0xE8058B52, 1); + for (uint32 index = 0; index < 18; index++) { + setSubVar(0x10055D14, index, kScene1201InitArray[index]); + } + } + + _mouseCursor = addSprite(new Mouse433(_vm, 0x9A2C0409, NULL)); + + _asTape = addSprite(new AsScene1201Tape(_vm, this, 3, 1100, 243, 340, 0x9148A011)); + _vm->_collisionMan->addSprite(_asTape); + + tempSprite = addSprite(new StaticSprite(_vm, 0x03C82530, 100)); + topY1 = tempSprite->getY() + tempSprite->getSurface()->getDrawRect().height; + + tempSprite = addSprite(new StaticSprite(_vm, 0x88182069, 200)); + topY2 = tempSprite->getY() + tempSprite->getSurface()->getDrawRect().height; + + tempSprite = addSprite(new StaticSprite(_vm, 0x476014E0, 300)); + topY3 = tempSprite->getY() + tempSprite->getSurface()->getDrawRect().height; + + tempSprite = addSprite(new StaticSprite(_vm, 0x04063110, 500)); + topY4 = tempSprite->getY() + 1; + + _class466 = addSprite(new Class466(_vm, getGlobalVar(0x000CF819) && which != 1 ? 1 : 0)); + _class466->getSurface()->getClipRect().x1 = 0; + _class466->getSurface()->getClipRect().y1 = topY4; + _class466->getSurface()->getClipRect().x2 = 640; + _class466->getSurface()->getClipRect().y2 = 480; + + addSprite(new StaticSprite(_vm, 0x400B04B0, 1200)); + + tempSprite = addSprite(new StaticSprite(_vm, 0x40295462, 1200)); + x1 = tempSprite->getX(); + + tempSprite = addSprite(new StaticSprite(_vm, 0xA29223FA, 1200)); + x2 = tempSprite->getX() + tempSprite->getSurface()->getDrawRect().width; + + class464 = addSprite(new Class464(_vm)); + + if (which < 0) { + _klayman = new KmScene1201(_vm, this, class464, 364, 333); + setMessageList(0x004AEC08); + } else if (which == 3) { + _klayman = new KmScene1201(_vm, this, class464, 400, 329); + setMessageList(0x004AEC08); + } else if (which == 2) { + if (getGlobalVar(0x0A310817) && !getGlobalVar(0x0A18CA33)) { + _klayman = new KmScene1201(_vm, this, class464, 374, 333); + setMessageList(0x004AEC08); + } else { + _klayman = new KmScene1201(_vm, this, class464, 640, 329); + setMessageList(0x004AEC20); + } + } else if (which == 1) { + if (getGlobalVar(0xC0418A02)) { + _klayman = new KmScene1201(_vm, this, class464, 364, 333); + _klayman->setDoDeltaX(1); + } else { + _klayman = new KmScene1201(_vm, this, class464, 246, 333); + } + setMessageList(0x004AEC30); + } else { + _klayman = new KmScene1201(_vm, this, class464, 0, 336); + setMessageList(0x004AEC10); + } + + _klayman->getSurface()->getClipRect().x1 = x1; + _klayman->getSurface()->getClipRect().y1 = 0; + _klayman->getSurface()->getClipRect().x2 = x2; + _klayman->getSurface()->getClipRect().y2 = 480; + _klayman->setRepl(64, 0); + + addSprite(_klayman); + + if (getGlobalVar(0x0A310817) && !getGlobalVar(0x0A18CA33)) { + _background = addBackground(new DirtyBackground(_vm, 0x4019A2C4, 0, 0)); + _palette = new Palette(_vm, 0x4019A2C4); + _palette->usePalette(); + _class468 = NULL; + } else { + _background = addBackground(new DirtyBackground(_vm, 0x40206EC5, 0, 0)); + _palette = new Palette(_vm, 0x40206EC5); + _palette->usePalette(); + _class468 = addSprite(new Class468(_vm, _klayman, which - 2 != 1)); // CHECKME??? + } + + if (getGlobalVar(0x000CF819)) { + addSprite(new StaticSprite(_vm, 0x10002ED8, 500)); + if (!getGlobalVar(0x0A18CA33)) { + Class463 *class463; + class463 = new Class463(_vm, this, _class466, which - 1 != 1); + class463->getSurface()->getClipRect().x1 = x1; + class463->getSurface()->getClipRect().y1 = 0; + class463->getSurface()->getClipRect().x2 = x2; + class463->getSurface()->getClipRect().y2 = 480; + _vm->_collisionMan->addSprite(_class463); + _class463 = addSprite(class463); +#if 0 + tempSprite = addSprite(new Class465(_vm, _class463)); + tempSprite->getSurface()->getClipRect().x1 = x1; + tempSprite->getSurface()->getClipRect().y1 = 0; + tempSprite->getSurface()->getClipRect().x2 = x2; + tempSprite->getSurface()->getClipRect().y2 = 480; +#endif + class463->setRepl(64, 0); + } + + uint32 tntIndex = 1; + while (tntIndex < 18) { + uint32 elemIndex = getSubVar(0x10055D14, tntIndex); + int16 clipY2; + if (kScene1201PointArray[elemIndex].y < 175) + clipY2 = topY1; + else if (kScene1201PointArray[elemIndex].y < 230) + clipY2 = topY2; + else + clipY2 = topY3; + addSprite(new SsScene1201Tnt(_vm, tntIndex, getSubVar(0x10055D14, tntIndex), clipY2)); + elemIndex = getSubVar(0x10055D14, tntIndex + 1); + if (kScene1201PointArray[elemIndex].y < 175) + clipY2 = topY1; + else if (kScene1201PointArray[elemIndex].y < 230) + clipY2 = topY2; + else + clipY2 = topY3; + addSprite(new SsScene1201Tnt(_vm, tntIndex + 1, getSubVar(0x10055D14, tntIndex + 1), clipY2)); + tntIndex += 3; + } + + if (getGlobalVar(0x0A310817) && !getGlobalVar(0x0A18CA33)) { + setRectList(0x004AEE58); + } else { + setRectList(0x004AEDC8); + } + + } else { + + addSprite(new StaticSprite(_vm, 0x8E8A1981, 900)); + + uint32 tntIndex = 0; + while (tntIndex < 18) { + uint32 elemIndex = getSubVar(0x10055D14, tntIndex); + int16 clipY2; + if (kScene1201PointArray[elemIndex].x < 300) { + clipY2 = 480; + } else { + if (kScene1201PointArray[elemIndex].y < 175) + clipY2 = topY1; + else if (kScene1201PointArray[elemIndex].y < 230) + clipY2 = topY2; + else + clipY2 = topY3; + } + addSprite(new SsScene1201Tnt(_vm, tntIndex, getSubVar(0x10055D14, tntIndex), clipY2)); + tntIndex++; + } + + if (getGlobalVar(0x0A310817) && !getGlobalVar(0x0A18CA33)) { + setRectList(0x004AEE18); + } else { + setRectList(0x004AED88); + } + + } + + tempSprite = addSprite(new StaticSprite(_vm, 0x63D400BC, 900)); + +#if 0 + _class467 = addSprite(new Class467(_vm, _klayman)); + _class467->getSurface()->getClipRect().x1 = x1; + _class467->getSurface()->getClipRect().y1 = tempSprite->getSurface()->getDrawRect().y; + _class467->getSurface()->getClipRect().x2 = tempSprite->getSurface()->getDrawRect().x + tempSprite->getSurface()->getDrawRect().width; + _class467->getSurface()->getClipRect().y2 = 480; +#endif + + if (getGlobalVar(0x0A310817) && ! getGlobalVar(0x0112090A)) { + setGlobalVar(0x0112090A, 1); + } + + _class461 = NULL; + +#if 0 + if (getGlobalVar(0x0112090A) < 3) { + _class461 = addSprite(new Class461(_vm, this)); + _vm->_collisionMan->addSprite(_class461); + } + + if (getGlobalVar(0x0A310817) && !getGlobalVar(0x0A18CA33)) { + _class462 = addSprite(new Class462(_vm, this, _klayman)); + _class462->getSurface()->getClipRect().x1 = x1; + _class462->getSurface()->getClipRect().y1 = 0; + _class462->getSurface()->getClipRect().x2 = x2; + _class462->getSurface()->getClipRect().y2 = 480; + } +#endif + +} + +Scene1201::~Scene1201() { +} + +void Scene1201::update() { + Scene::update(); + if (_class461 && getGlobalVar(0x0112090A)) { + deleteSprite(&_class461); + } +} + +uint32 Scene1201::handleMessage(int messageNum, const MessageParam ¶m, Entity *sender) { + debug("Scene1201::handleMessage(%04X)", messageNum); + uint32 messageResult = Scene::handleMessage(messageNum, param, sender); + switch (messageNum) { + case 0x100D: + if (param.asInteger() == 0x07053000) { + _flag = true; + _class462->sendMessage(0x2004, 0, this); + } else if (param.asInteger() == 0x140E5744) { + _class462->sendMessage(0x2005, 0, this); + } else if (param.asInteger() == 0x40253C40) { + _messageListFlag = false; + _class462->sendMessage(0x2006, 0, this); + } else if (param.asInteger() == 0x090EB048) { + if (_klayman->getX() < 572) { + setMessageList2(0x004AEC90); + } else { + setMessageList2(0x004AEC20); + } + } + break; + case 0x2001: + if (!getGlobalVar(0x0112090A)) { + setMessageList2(0x004AECB0); + } else { + _klayman->sendEntityMessage(0x1014, _class461, this); + setMessageList2(0x004AECC0); + } + break; + case 0x2002: + if (getGlobalVar(0x20A0C516)) { + _klayman->sendEntityMessage(0x1014, _class463, this); + setMessageList2(0x004AECF0); + } else if (getGlobalVar(0x0112090A) == 3) { + _klayman->sendEntityMessage(0x1014, _class463, this); + if (_klayman->getX() > _class463->getX()) { + setMessageList(0x004AECD0); + } else { + setMessageList(0x004AECE0); + } + } + break; + case 0x4814: + messageList402220(); + break; + case 0x4826: + if (sender == _asTape) { + _klayman->sendEntityMessage(0x1014, _asTape, this); + setMessageList(0x004AED38); + } + break; + case 0x4829: + _class468->sendMessage(0x4829, 0, this); + break; + } + return messageResult; +} + +} // End of namespace Neverhood diff --git a/engines/neverhood/module1200.h b/engines/neverhood/module1200.h new file mode 100644 index 0000000000..bbdfaeb634 --- /dev/null +++ b/engines/neverhood/module1200.h @@ -0,0 +1,141 @@ +/* ScummVM - Graphic Adventure Engine + * + * ScummVM is the legal property of its developers, whose names + * are too numerous to list here. Please refer to the COPYRIGHT + * file distributed with this source distribution. + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. + + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. + * + */ + +#ifndef NEVERHOOD_MODULE1200_H +#define NEVERHOOD_MODULE1200_H + +#include "neverhood/neverhood.h" +#include "neverhood/module.h" +#include "neverhood/scene.h" + +namespace Neverhood { + +// Module1200 + +class Module1200 : public Module { +public: + Module1200(NeverhoodEngine *vm, Module *parentModule, int which); + virtual ~Module1200(); +protected: + // TODO ResourceTable _resourceTable; + bool _moduleDone; + uint32 _moduleDoneStatus; + uint32 handleMessage(int messageNum, const MessageParam ¶m, Entity *sender); + void createScene1201(int which); + void createScene1202(int which); + void createScene1203(int which); + void updateScene1201(); + void updateScene1202(); + void updateScene1203(); +}; + +// Scene1201 + +class AsScene1201Tape : public AnimatedSprite { +public: + AsScene1201Tape(NeverhoodEngine *vm, Scene *parentScene, uint32 nameHash, int surfacePriority, int16 x, int16 y, uint32 fileHash); +protected: + Scene *_parentScene; + uint32 _nameHash; + uint32 handleMessage(int messageNum, const MessageParam ¶m, Entity *sender); +}; + +class Class466 : public AnimatedSprite { +public: + Class466(NeverhoodEngine *vm, bool flag); +protected: + SoundResource _soundResource; + uint32 handleMessage(int messageNum, const MessageParam ¶m, Entity *sender); + void sub40D340(); + void sub40D360(); + void sub40D380(); +}; + +class Class468 : public AnimatedSprite { +public: + Class468(NeverhoodEngine *vm, Sprite *klayman, bool flag); +protected: + SoundResource _soundResource; + Sprite *_klayman; + int _countdown; + void update(); + uint32 handleMessage(int messageNum, const MessageParam ¶m, Entity *sender); + void sub40D7E0(); + void sub40D830(); + void sub40D880(); +}; + +class Class464 : public AnimatedSprite { +public: + Class464(NeverhoodEngine *vm); +protected: + uint32 handleMessage(int messageNum, const MessageParam ¶m, Entity *sender); +}; + +class Class463 : public AnimatedSprite { +public: + Class463(NeverhoodEngine *vm, Scene *parentScene, Sprite *class466, bool flag); + virtual ~Class463(); +protected: + Scene *_parentScene; + Sprite *_class466; + Sprite *_sprite; + SoundResource _soundResource; + bool _flag; + uint32 handleMessage(int messageNum, const MessageParam ¶m, Entity *sender); + uint32 handleMessage40CCD0(int messageNum, const MessageParam ¶m, Entity *sender); + void spriteUpdate40CD10(); + void sub40CD30(); + void sub40CD60(); + void sub40CD90(); +}; + +class SsScene1201Tnt : public StaticSprite { +public: + SsScene1201Tnt(NeverhoodEngine *vm, uint32 elemIndex, uint32 pointIndex, int16 clipY2); +protected: + uint32 _elemIndex; + int16 _field7A; +}; + +class Scene1201 : public Scene { +public: + Scene1201(NeverhoodEngine *vm, Module *parentModule, int which); + virtual ~Scene1201(); +protected: + // TODO ResourceTable _resourceTable1; + // TODO ResourceTable _resourceTable2; + Sprite *_class461; + Sprite *_class463; + Sprite *_class462; + Sprite *_class466; + Sprite *_class467; + Sprite *_class468; + Sprite *_asTape; + bool _flag; + void update(); + uint32 handleMessage(int messageNum, const MessageParam ¶m, Entity *sender); +}; + +} // End of namespace Neverhood + +#endif /* NEVERHOOD_MODULE1200_H */ diff --git a/engines/neverhood/scene.cpp b/engines/neverhood/scene.cpp index 8f49a0033d..43f1ca79bc 100644 --- a/engines/neverhood/scene.cpp +++ b/engines/neverhood/scene.cpp @@ -485,6 +485,13 @@ void Scene::runMessageList() { } +void Scene::messageList402220() { + _messageListFlag1 = false; + _messageList = NULL; + _messageListFlag = true; + _klayman->sendMessage(0x4004, 0, this); +} + void Scene::setRectList(uint32 id) { setRectList(_vm->_staticData->getRectList(id)); } diff --git a/engines/neverhood/scene.h b/engines/neverhood/scene.h index 8f0b79a5ee..47114053b0 100644 --- a/engines/neverhood/scene.h +++ b/engines/neverhood/scene.h @@ -102,6 +102,7 @@ protected: void runMessageList(); void setRectList(uint32 id); void setRectList(RectList *rectList); + void messageList402220(); void loadDataResource(uint32 fileHash); }; -- cgit v1.2.3