From 21ebcf2af20bf96c32f5668952dba4ed7797a89c Mon Sep 17 00:00:00 2001 From: johndoe123 Date: Thu, 29 Sep 2011 18:30:58 +0000 Subject: NEVERHOOD: Add Module2100 and Scene2101 (not complete yet) --- engines/neverhood/gamemodule.cpp | 18 ++- engines/neverhood/klayman.cpp | 151 ++++++++++++++++++++ engines/neverhood/klayman.h | 13 ++ engines/neverhood/module.mk | 1 + engines/neverhood/module2100.cpp | 298 +++++++++++++++++++++++++++++++++++++++ engines/neverhood/module2100.h | 81 +++++++++++ 6 files changed, 561 insertions(+), 1 deletion(-) create mode 100644 engines/neverhood/module2100.cpp create mode 100644 engines/neverhood/module2100.h diff --git a/engines/neverhood/gamemodule.cpp b/engines/neverhood/gamemodule.cpp index 7f74590b68..7d463fb3e2 100644 --- a/engines/neverhood/gamemodule.cpp +++ b/engines/neverhood/gamemodule.cpp @@ -34,6 +34,7 @@ #include "neverhood/module1800.h" #include "neverhood/module1900.h" #include "neverhood/module2000.h" +#include "neverhood/module2100.h" #include "neverhood/module2200.h" #include "neverhood/module2300.h" #include "neverhood/module3000.h" @@ -281,10 +282,14 @@ void GameModule::startup() { _vm->gameState().which = 1; createModule(1600, -1); #endif -#if 1 +#if 0 _vm->gameState().sceneNum = 6; createModule(1900, -1); #endif +#if 1 + _vm->gameState().sceneNum = 0; + createModule(2100, 3); +#endif } void GameModule::createModule(int moduleNum, int which) { @@ -336,6 +341,10 @@ void GameModule::createModule(int moduleNum, int which) { setGlobalVar(0x91080831, 0x08250000); _childObject = new Module2000(_vm, this, which); break; + case 2100: + setGlobalVar(0x91080831, 0x10A10C14); + _childObject = new Module2100(_vm, this, which); + break; case 2200: setGlobalVar(0x91080831, 0x11391412); _childObject = new Module2200(_vm, this, which); @@ -428,6 +437,13 @@ void GameModule::updateModule() { case 2000: createModule(2900, 4); break; + case 2100: + if (_moduleResult == 1) { + createModule(2900, 1); + } else { + createModule(1600, 0); + } + break; case 2200: createModule(2300, 1); break; diff --git a/engines/neverhood/klayman.cpp b/engines/neverhood/klayman.cpp index 873ba68b8e..865c91a7a8 100644 --- a/engines/neverhood/klayman.cpp +++ b/engines/neverhood/klayman.cpp @@ -4091,6 +4091,157 @@ void KmScene2001::sub440270() { SetMessageHandler(&KmScene2001::handleMessage4401A0); } +KmScene2101::KmScene2101(NeverhoodEngine *vm, Entity *parentScene, int16 x, int16 y) + : Klayman(vm, parentScene, x, y, 1000, 1000), _flag1(false) { + + // Empty +} + +uint32 KmScene2101::xHandleMessage(int messageNum, const MessageParam ¶m) { + uint32 messageResult = 0; + switch (messageNum) { + case 0x2000: + _flag1 = param.asInteger() != 0; + messageResult = 1; + break; + case 0x4001: + case 0x4800: + sub41C930(param.asPoint().x, false); + break; + case 0x4004: + if (_flag1) + setCallback2(AnimationCallback(&Klayman::sub421350)); + else + setCallback2(AnimationCallback(&Klayman::sub41FC80)); + break; + case 0x4811: + setCallback2(AnimationCallback(&KmScene2101::sub4862C0)); + break; + case 0x4812: + if (param.asInteger() == 2) { + setCallback2(AnimationCallback(&Klayman::sub420060)); + } else if (param.asInteger() == 1) { + setCallback2(AnimationCallback(&Klayman::sub41FFF0)); + } else { + setCallback2(AnimationCallback(&Klayman::sub41FF80)); + } + break; + case 0x4816: + if (param.asInteger() == 1) { + setCallback2(AnimationCallback(&Klayman::sub420120)); + } else if (param.asInteger() == 2) { + setCallback2(AnimationCallback(&Klayman::sub420170)); + }else { + setCallback2(AnimationCallback(&Klayman::sub4200D0)); + } + break; + case 0x4817: + setDoDeltaX(param.asInteger()); + sub41C7B0(); + break; + case 0x481B: + if (param.asPoint().y != 0) { + sub41CC40(param.asPoint().y, param.asPoint().x); + } else { + sub41CCE0(param.asPoint().x); + } + break; + case 0x481D: + if (_flag1) + setCallback2(AnimationCallback(&Klayman::sub4214D0)); + break; + case 0x481E: + if (_flag) + setCallback2(AnimationCallback(&Klayman::sub421510)); + break; + case 0x4834: + setCallback2(AnimationCallback(&Klayman::sub421160)); + break; + case 0x4835: + sendMessage(_parentScene, 0x2000, 1); + _flag1 = true; + setCallback2(AnimationCallback(&Klayman::sub4212C0)); + break; + case 0x4836: + sendMessage(_parentScene, 0x2000, 0); + _flag1 = false; + setCallback2(AnimationCallback(&Klayman::sub421310)); + break; + case 0x483D: + sub486320(); + break; + case 0x483E: + sub486360(); + break; + } + return messageResult; +} + +uint32 KmScene2101::handleMessage486160(int messageNum, const MessageParam ¶m, Entity *sender) { + uint32 messageResult = handleMessage41D480(messageNum, param, sender); + int16 speedUpFrameIndex; + switch (messageNum) { + case 0x1008: + speedUpFrameIndex = getFrameIndex(kKlaymanSpeedUpHash); + if (_frameIndex < speedUpFrameIndex) { + setFileHash(0x35AA8059, speedUpFrameIndex, -1); + _y = 438; + } + messageResult = 0; + break; + case 0x100D: + if (param.asInteger() == 0x1A1A0785) { + _soundResource1.play(0x40F0A342); + } else if (param.asInteger() == 0x60428026) { + _soundResource1.play(0x40608A59); + } + break; + } + return messageResult; +} + +uint32 KmScene2101::handleMessage486230(int messageNum, const MessageParam ¶m, Entity *sender) { + uint32 messageResult = handleMessage41D480(messageNum, param, sender); + switch (messageNum) { + case 0x100D: + if (param.asInteger() == 0x4E0A2C24) { + _soundResource1.play(0x85B10BB8); + } else if (param.asInteger() == 0x4E6A0CA0) { + _soundResource1.play(0xC5B709B0); + } + break; + } + return messageResult; +} + +void KmScene2101::sub4862C0() { + _status2 = 1; + _flagE5 = false; + setFileHash(0x35AA8059, 0, -1); + SetUpdateHandler(&Klayman::update); + SetSpriteCallback(&AnimatedSprite::updateDeltaXY); + SetMessageHandler(&KmScene2101::handleMessage486160); + _soundResource1.play(0x402E82D4); +} + +void KmScene2101::sub486320() { + _status2 = 0; + _flagE5 = false; + setFileHash(0xFF290E30, 0, -1); + SetUpdateHandler(&Klayman::update); + SetSpriteCallback(NULL); + SetMessageHandler(&KmScene2101::handleMessage486230); +} + +void KmScene2101::sub486360() { + _status2 = 0; + _flagE5 = false; + setFileHash(0x9A28CA1C, 0, -1); + SetUpdateHandler(&Klayman::update); + SetSpriteCallback(NULL); + SetMessageHandler(&KmScene2101::handleMessage486230); +} + KmScene2201::KmScene2201(NeverhoodEngine *vm, Entity *parentScene, int16 x, int16 y, NRect *clipRects, int clipRectsCount) // TODO: NRect *rect1, int16 unk in Klayman ctor : Klayman(vm, parentScene, x, y, 1000, 1000) { diff --git a/engines/neverhood/klayman.h b/engines/neverhood/klayman.h index 5c0429ee32..eb6ab40931 100644 --- a/engines/neverhood/klayman.h +++ b/engines/neverhood/klayman.h @@ -452,6 +452,19 @@ protected: void sub440270(); }; +class KmScene2101 : public Klayman { +public: + KmScene2101(NeverhoodEngine *vm, Entity *parentScene, int16 x, int16 y); +protected: + bool _flag1; + uint32 xHandleMessage(int messageNum, const MessageParam ¶m); + uint32 handleMessage486160(int messageNum, const MessageParam ¶m, Entity *sender); + uint32 handleMessage486230(int messageNum, const MessageParam ¶m, Entity *sender); + void sub4862C0(); + void sub486320(); + void sub486360(); +}; + class KmScene2201 : public Klayman { public: KmScene2201(NeverhoodEngine *vm, Entity *parentScene, int16 x, int16 y, NRect *clipRects, int clipRectsCount); diff --git a/engines/neverhood/module.mk b/engines/neverhood/module.mk index 6530a7ff8c..9484e2e632 100644 --- a/engines/neverhood/module.mk +++ b/engines/neverhood/module.mk @@ -22,6 +22,7 @@ MODULE_OBJS = \ module1800.o \ module1900.o \ module2000.o \ + module2100.o \ module2200.o \ module2300.o \ module3000.o \ diff --git a/engines/neverhood/module2100.cpp b/engines/neverhood/module2100.cpp new file mode 100644 index 0000000000..e07e990dc2 --- /dev/null +++ b/engines/neverhood/module2100.cpp @@ -0,0 +1,298 @@ +/* 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/module2100.h" +#include "neverhood/gamemodule.h" +#include "neverhood/module1200.h" + +namespace Neverhood { + +Module2100::Module2100(NeverhoodEngine *vm, Module *parentModule, int which) + : Module(vm, parentModule) { + + // TODO Music18hList_add(0x10A10C14, 0x11482B95); + + if (which < 0) { + createScene(_vm->gameState().sceneNum, -1); + } else if (which == 1) { + createScene(0, 0); + } else if (which == 2) { + createScene(0, 3); + } else { + createScene(0, 1); + } + +} + +Module2100::~Module2100() { + // TODO Music18hList_deleteGroup(0x10A10C14); +} + +void Module2100::createScene(int sceneNum, int which) { + debug("Module2100::createScene(%d, %d)", sceneNum, which); + _vm->gameState().sceneNum = sceneNum; + switch (_vm->gameState().sceneNum) { + case 0: + // TODO Music18hList_play(0x11482B95, 0, 1, 1); + _childObject = new Scene2101(_vm, this, which); + break; + } + SetUpdateHandler(&Module2100::updateScene); + _childObject->handleUpdate(); +} + +void Module2100::updateScene() { + if (!updateChild()) { + switch (_vm->gameState().sceneNum) { + case 0: + if (_moduleResult == 1) { + setGlobalVar(0x2090590C, 1); + leaveModule(0); + } else { + leaveModule(1); + } + break; + } + } +} + +// Scene2101 + +Class538::Class538(NeverhoodEngine *vm, bool flag) + : AnimatedSprite(vm, 1100), _soundResource(vm) { + + // TODO createSurface3(100, dword_4B9018); + createSurface(100, 640, 480); //TODO: Remove once the line above is done + _x = 320; + _y = 240; + SetUpdateHandler(&AnimatedSprite::update); + SetMessageHandler(&Class538::handleMessage); + if (flag) { + setFileHash(0x0C202B9C, -1, -1); + _newHashListIndex = -2; + } else { + setVisible(false); + } +} + +uint32 Class538::handleMessage(int messageNum, const MessageParam ¶m, Entity *sender) { + uint32 messageResult = Sprite::handleMessage(messageNum, param, sender); + switch (messageNum) { + case 0x3002: + removeCallbacks(); + break; + case 0x4808: + openDoor(); + break; + case 0x4809: + closeDoor(); + break; + } + return messageResult; +} + +void Class538::openDoor() { + setFileHash(0x0C202B9C, 0, -1); + _newHashListIndex = -2; + setVisible(true); + _soundResource.play(calcHash("fxDoorOpen32")); +} + +void Class538::closeDoor() { + setFileHash(0xC222A8D4, 0, -1); + _newHashListIndex = -2; + setVisible(true); + SetAnimationCallback3(&Class538::hide); + _soundResource.play(calcHash("fxDoorClose32")); +} + +void Class538::hide() { + setFileHash1(); + setVisible(false); +} + +Class539::Class539(NeverhoodEngine *vm, Sprite *klayman) + : AnimatedSprite(vm, 1400), _klayman(klayman) { + + SetUpdateHandler(&AnimatedSprite::update); + SetMessageHandler(&Class539::handleMessage); + createSurface(1200, 88, 165); + setVisible(false); +} + +uint32 Class539::handleMessage(int messageNum, const MessageParam ¶m, Entity *sender) { + uint32 messageResult = Sprite::handleMessage(messageNum, param, sender); + switch (messageNum) { + case 0x2001: + _x = _klayman->getX(); + _y = _klayman->getY() - 132; + setFileHash(0x0422255A, 0, -1); + setVisible(true); + break; + case 0x3002: + setFileHash1(); + setVisible(false); + break; + } + return messageResult; +} + +Scene2101::Scene2101(NeverhoodEngine *vm, Module *parentModule, int which) + : Scene(vm, parentModule, true) { + + _surfaceFlag = true; + SetMessageHandler(&Scene2101::handleMessage); + SetUpdateHandler(&Scene2101::update); + + setBackground(0x44242305); + setPalette(0x44242305); + insertMouse433(0x4230144A); + + insertStaticSprite(0x00502330, 1100); + _sprite1 = insertStaticSprite(0x78492010, 1100); + // TODO _class427 = insertSprite(this, 0x72427010, 0x32423010, 200, 0); + _asTape1 = insertSprite(this, 18, 1100, 412, 443, 0x9148A011); + _vm->_collisionMan->addSprite(_asTape1); + _asTape2 = insertSprite(this, 11, 1100, 441, 443, 0x9148A011); + _vm->_collisionMan->addSprite(_asTape2); + + if (which < 0) { + insertKlayman(380, 438); + setMessageList(0x004B8E48); + sendMessage(this, 0x2000, 0); + _class538 = insertSprite(false); + _value1 = 1; + _countdown1 = 0; + } else if (which == 1) { + insertKlayman(640, 438); + setMessageList(0x004B8E50); + sendMessage(this, 0x2000, 0); + _class538 = insertSprite(true); + _value1 = 2; + _countdown1 = 48; + } else if (which == 2) { + insertKlayman(115, 438); + sendMessage(_klayman, 0x2000, 1); + setMessageList(0x004B8F58); + sendMessage(this, 0x2000, 1); + _class538 = insertSprite(false); + _value1 = 1; + _countdown1 = 0; + } else if (which == 3) { + insertKlayman(115, 438); + sendMessage(_klayman, 0x2000, 1); + setMessageList(0x004B8EB0); + sendMessage(this, 0x2000, 1); + _class538 = insertSprite(false); + _value1 = 1; + _countdown1 = 0; + } else { + insertKlayman(115, 438); + sendMessage(_klayman, 0x2000, 1); + setMessageList(0x004B8EA0); + sendMessage(this, 0x2000, 1); + _class538 = insertSprite(false); + _value1 = 1; + _countdown1 = 0; + } + + _class539 = insertSprite(_klayman); + _klayman->setClipRect(0, 0, _sprite1->getDrawRect().x2(), 480); + +} + +void Scene2101::update() { + if (_countdown1 != 0) { + if (_value1 == 2) { + if (--_countdown1 == 0) { + sendMessage(_class538, 0x4809, 0); + _value1 = 1; + } + } else { + if (_klayman->getX() > 575) + _messageListFlag = false; + if (--_countdown1 == 0) { + if (_klayman->getX() < 480) { + sendMessage(_class538, 0x4809, 0); + _value1 = 1; + } else if (_klayman->getX() >= 480 && _klayman->getX() <= 575) { + _klayman->setDoDeltaX(0); + setMessageList2(0x004B8F48); + sendMessage(_class538, 0x4809, 0); + sendMessage(_class539, 0x2001, 0); + _value1 = 1; + } + } + } + } else if (_value1 == 1 && _messageValue >= 0 && _klayman->getX() > 470 /* TODO ! && _messageList2 != 0x004B8F48*/) { + setMessageList2(0x004B8F50); + } + Scene::update(); +} + +uint32 Scene2101::handleMessage(int messageNum, const MessageParam ¶m, Entity *sender) { + Scene::handleMessage(messageNum, param, sender); + switch (messageNum) { + case 0x100D: + if (param.asInteger() == 0x02144CB1) { + sendEntityMessage(_klayman, 0x1014, _class427); + } else if (param.asInteger() == 0x21E64A00) { + if (_value1 == 0) { + setMessageList(0x004B8E80); + } else { + setMessageList(0x004B8EC8); + } + } else if (param.asInteger() == 0x41442820) { + messageList402220(); + } + break; + case 0x2000: + if (param.asInteger() != 0) { + setRectList(0x004B9008); + _klayman->setKlaymanTable3(); + } else { + setRectList(0x004B8FF8); + _klayman->setKlaymanTable1(); + } + break; + case 0x480B: + if (sender == _class427 && _value1 == 1) { + sendMessage(_class538, 0x4808, 0); + _value1 = 0; + _countdown1 = 90; + } + break; + case 0x4826: + if (sender == _asTape1 || sender == _asTape2) { + if (_klayman->getX() >= 228 && _klayman->getX() <= 500) { + sendEntityMessage(_klayman, 0x1014, sender); + setMessageList(0x004B8F78); + } else if (_klayman->getX() < 228) { + setMessageList2(0x004B8F00); + } + } + break; + } + return 0; +} + +} // End of namespace Neverhood diff --git a/engines/neverhood/module2100.h b/engines/neverhood/module2100.h new file mode 100644 index 0000000000..3e7f579281 --- /dev/null +++ b/engines/neverhood/module2100.h @@ -0,0 +1,81 @@ +/* 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_MODULE2100_H +#define NEVERHOOD_MODULE2100_H + +#include "neverhood/neverhood.h" +#include "neverhood/module.h" +#include "neverhood/scene.h" + +namespace Neverhood { + +class Module2100 : public Module { +public: + Module2100(NeverhoodEngine *vm, Module *parentModule, int which); + virtual ~Module2100(); +protected: + uint32 handleMessage(int messageNum, const MessageParam ¶m, Entity *sender); + void createScene(int sceneNum, int which); + void updateScene(); +}; + +// Scene1901 + +class Class538 : public AnimatedSprite { +public: + Class538(NeverhoodEngine *vm, bool flag); +protected: + SoundResource _soundResource; + uint32 handleMessage(int messageNum, const MessageParam ¶m, Entity *sender); + void openDoor(); + void closeDoor(); + void hide(); +}; + +class Class539 : public AnimatedSprite { +public: + Class539(NeverhoodEngine *vm, Sprite *klayman); +protected: + Sprite *_klayman; + uint32 handleMessage(int messageNum, const MessageParam ¶m, Entity *sender); +}; + +class Scene2101 : public Scene { +public: + Scene2101(NeverhoodEngine *vm, Module *parentModule, int which); +protected: + Sprite *_sprite1; + Sprite *_class427; + Sprite *_asTape1; + Sprite *_asTape2; + Sprite *_class538; + Sprite *_class539; + int _countdown1; + int _value1; + void update(); + uint32 handleMessage(int messageNum, const MessageParam ¶m, Entity *sender); +}; + +} // End of namespace Neverhood + +#endif /* NEVERHOOD_MODULE2100_H */ -- cgit v1.2.3