NEVERHOOD: Add Module2100 and Scene2101 (not complete yet)

6 files changed, 561 insertions, 1 deletions

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 &param) {
+	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 &param, 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 &param, 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 &param);
+	uint32 handleMessage486160(int messageNum, const MessageParam &param, Entity *sender);
+	uint32 handleMessage486230(int messageNum, const MessageParam &param, 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 &param, 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 &param, 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<Class427>(this, 0x72427010, 0x32423010, 200, 0);
+	_asTape1 = insertSprite<AsScene1201Tape>(this, 18, 1100, 412, 443, 0x9148A011);
+	_vm->_collisionMan->addSprite(_asTape1);
+	_asTape2 = insertSprite<AsScene1201Tape>(this, 11, 1100, 441, 443, 0x9148A011);
+	_vm->_collisionMan->addSprite(_asTape2);
+	
+	if (which < 0) {
+		insertKlayman<KmScene2101>(380, 438);
+		setMessageList(0x004B8E48);
+		sendMessage(this, 0x2000, 0);
+		_class538 = insertSprite<Class538>(false);
+		_value1 = 1;
+		_countdown1 = 0;
+	} else if (which == 1) {
+		insertKlayman<KmScene2101>(640, 438);
+		setMessageList(0x004B8E50);
+		sendMessage(this, 0x2000, 0);
+		_class538 = insertSprite<Class538>(true);
+		_value1 = 2;
+		_countdown1 = 48;
+	} else if (which == 2) {
+		insertKlayman<KmScene2101>(115, 438);
+		sendMessage(_klayman, 0x2000, 1);
+		setMessageList(0x004B8F58);
+		sendMessage(this, 0x2000, 1);
+		_class538 = insertSprite<Class538>(false);
+		_value1 = 1;
+		_countdown1 = 0;
+	} else if (which == 3) {
+		insertKlayman<KmScene2101>(115, 438);
+		sendMessage(_klayman, 0x2000, 1);
+		setMessageList(0x004B8EB0);
+		sendMessage(this, 0x2000, 1);
+		_class538 = insertSprite<Class538>(false);
+		_value1 = 1;
+		_countdown1 = 0;
+	} else {
+		insertKlayman<KmScene2101>(115, 438);
+		sendMessage(_klayman, 0x2000, 1);
+		setMessageList(0x004B8EA0);
+		sendMessage(this, 0x2000, 1);
+		_class538 = insertSprite<Class538>(false);
+		_value1 = 1;
+		_countdown1 = 0;
+	}
+	
+	_class539 = insertSprite<Class539>(_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 &param, 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 &param, 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 &param, 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 &param, 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 &param, Entity *sender);
+};
+
+} // End of namespace Neverhood
+
+#endif /* NEVERHOOD_MODULE2100_H */