aboutsummaryrefslogtreecommitdiff
diff options
context:
space:
mode:
Diffstat
-rw-r--r--engines/neverhood/gamemodule.cpp15
-rw-r--r--engines/neverhood/klayman.cpp51
-rw-r--r--engines/neverhood/klayman.h8
-rw-r--r--engines/neverhood/module.mk1
-rw-r--r--engines/neverhood/module2500.cpp387
-rw-r--r--engines/neverhood/module2500.h96
-rw-r--r--engines/neverhood/module2700.cpp1
-rw-r--r--engines/neverhood/scene.cpp5
-rw-r--r--engines/neverhood/scene.h1
9 files changed, 563 insertions, 2 deletions
diff --git a/engines/neverhood/gamemodule.cpp b/engines/neverhood/gamemodule.cpp
index 32082835e9..9953492362 100644
--- a/engines/neverhood/gamemodule.cpp
+++ b/engines/neverhood/gamemodule.cpp
@@ -37,6 +37,7 @@
#include "neverhood/module2100.h"
#include "neverhood/module2200.h"
#include "neverhood/module2300.h"
+#include "neverhood/module2500.h"
#include "neverhood/module2600.h"
#include "neverhood/module2700.h"
#include "neverhood/module2800.h"
@@ -327,10 +328,15 @@ void GameModule::startup() {
_vm->gameState().sceneNum = 1;
createModule(2700, -1);
#endif
-#if 1
+#if 0
_vm->gameState().sceneNum = 11;
createModule(2800, -1);
#endif
+#if 1
+ _vm->gameState().which = 2;
+ _vm->gameState().sceneNum = 0;
+ createModule(2500, -1);
+#endif
}
void GameModule::createModule(int moduleNum, int which) {
@@ -394,6 +400,10 @@ void GameModule::createModule(int moduleNum, int which) {
setGlobalVar(0x91080831, 0x1A214010);
_childObject = new Module2300(_vm, this, which);
break;
+ case 2500:
+ setGlobalVar(0x91080831, 0x29220120);
+ _childObject = new Module2500(_vm, this, which);
+ break;
case 2600:
setGlobalVar(0x91080831, 0x40271018);
_childObject = new Module2600(_vm, this, which);
@@ -513,6 +523,9 @@ void GameModule::updateModule() {
createModule(1000, 1);
}
break;
+ case 2500:
+ createModule(2600, 1);
+ break;
case 2600:
if (_moduleResult == 1) {
createModule(2500, 0);
diff --git a/engines/neverhood/klayman.cpp b/engines/neverhood/klayman.cpp
index f69686aa66..9d28b5f046 100644
--- a/engines/neverhood/klayman.cpp
+++ b/engines/neverhood/klayman.cpp
@@ -5215,6 +5215,57 @@ void KmScene2247::sub453520() {
FinalizeState(&Klayman::stStartWalkingDone);
}
+KmScene2501::KmScene2501(NeverhoodEngine *vm, Entity *parentScene, int16 x, int16 y)
+ : Klayman(vm, parentScene, x, y, 1000, 1000), _isSittingInTeleporter(false) {
+ // Empty
+}
+
+uint32 KmScene2501::xHandleMessage(int messageNum, const MessageParam &param) {
+ uint32 messageResult = 0;
+ switch (messageNum) {
+ case 0x2000:
+ _isSittingInTeleporter = param.asInteger() != 0;
+ messageResult = 1;
+ break;
+ case 0x4001:
+ case 0x4800:
+ startWalkToX(param.asPoint().x, false);
+ break;
+ case 0x4004:
+ if (_isSittingInTeleporter)
+ GotoState(&Klayman::sub421350);
+ else
+ GotoState(&Klayman::stTryStandIdle);
+ break;
+ case 0x4817:
+ setDoDeltaX(param.asInteger());
+ gotoNextStateExt();
+ break;
+ case 0x481D:
+ if (_isSittingInTeleporter)
+ GotoState(&Klayman::stTurnToUseInTeleporter);
+ break;
+ case 0x481E:
+ if (_isSittingInTeleporter)
+ GotoState(&Klayman::stReturnFromUseInTeleporter);
+ break;
+ case 0x4834:
+ GotoState(&Klayman::stStepOver);
+ break;
+ case 0x4835:
+ sendMessage(_parentScene, 0x2000, 1);
+ _isSittingInTeleporter = true;
+ GotoState(&Klayman::stSitInTeleporter);
+ break;
+ case 0x4836:
+ sendMessage(_parentScene, 0x2000, 0);
+ _isSittingInTeleporter = false;
+ GotoState(&Klayman::stGetUpFromTeleporter);
+ break;
+ }
+ return messageResult;
+}
+
KmScene2801::KmScene2801(NeverhoodEngine *vm, Entity *parentScene, int16 x, int16 y)
: Klayman(vm, parentScene, x, y, 1000, 1000) {
// Empty
diff --git a/engines/neverhood/klayman.h b/engines/neverhood/klayman.h
index 6cfb0fc733..fea543cdc9 100644
--- a/engines/neverhood/klayman.h
+++ b/engines/neverhood/klayman.h
@@ -578,6 +578,14 @@ protected:
void sub453520();
};
+class KmScene2501 : public Klayman {
+public:
+ KmScene2501(NeverhoodEngine *vm, Entity *parentScene, int16 x, int16 y);
+protected:
+ bool _isSittingInTeleporter;
+ uint32 xHandleMessage(int messageNum, const MessageParam &param);
+};
+
class KmScene2801 : public Klayman {
public:
KmScene2801(NeverhoodEngine *vm, Entity *parentScene, int16 x, int16 y);
diff --git a/engines/neverhood/module.mk b/engines/neverhood/module.mk
index 780ee76ae1..ac4064bf81 100644
--- a/engines/neverhood/module.mk
+++ b/engines/neverhood/module.mk
@@ -25,6 +25,7 @@ MODULE_OBJS = \
module2100.o \
module2200.o \
module2300.o \
+ module2500.o \
module2600.o \
module2700.o \
module2800.o \
diff --git a/engines/neverhood/module2500.cpp b/engines/neverhood/module2500.cpp
new file mode 100644
index 0000000000..0f746d1488
--- /dev/null
+++ b/engines/neverhood/module2500.cpp
@@ -0,0 +1,387 @@
+/* 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/module2500.h"
+
+namespace Neverhood {
+
+Module2500::Module2500(NeverhoodEngine *vm, Module *parentModule, int which)
+ : Module(vm, parentModule), _soundResource1(vm), _soundResource2(vm),
+ _soundResource3(vm), _soundResource4(vm), _soundIndex(0) {
+
+ // TODO Music18hList_add(0x29220120, 0x05343184);
+ // TODO Music18hList_play(0x05343184, 0, 0, 1);
+ SetMessageHandler(&Module2500::handleMessage);
+
+ if (which < 0) {
+ createScene(_vm->gameState().sceneNum, _vm->gameState().which);
+ } else {
+ createScene(0, 0);
+ }
+
+ _soundResource1.load(0x00880CCC);
+ _soundResource2.load(0x00880CC0);
+ _soundResource3.load(0x00880CCC);
+ _soundResource4.load(0x00880CC0);
+
+}
+
+Module2500::~Module2500() {
+}
+
+void Module2500::createScene(int sceneNum, int which) {
+ debug("Module2500::createScene(%d, %d)", sceneNum, which);
+ _vm->gameState().sceneNum = sceneNum;
+ switch (_vm->gameState().sceneNum) {
+ case 0:
+ _childObject = new Scene2501(_vm, this, which);
+ break;
+ }
+ SetUpdateHandler(&Module2500::updateScene);
+ _childObject->handleUpdate();
+}
+
+void Module2500::updateScene() {
+ if (!updateChild()) {
+ switch (_vm->gameState().sceneNum) {
+ case 0:
+ if (_moduleResult == 1)
+ createScene(2, 0);
+ else if (_moduleResult == 2)
+ createScene(1, 0);
+ else
+ leaveModule(0);
+ break;
+ }
+ }
+}
+
+uint32 Module2500::handleMessage(int messageNum, const MessageParam &param, Entity *sender) {
+ uint32 messageResult = Module::handleMessage(messageNum, param, sender);
+ switch (messageNum) {
+ case 0x200D:
+ switch (_soundIndex) {
+ case 0:
+ _soundResource1.play();
+ break;
+ case 1:
+ _soundResource2.play();
+ break;
+ case 2:
+ _soundResource3.play();
+ break;
+ case 3:
+ _soundResource4.play();
+ break;
+ }
+ _soundIndex++;
+ if (_soundIndex >= 4)
+ _soundIndex = 0;
+ break;
+ }
+ return messageResult;
+}
+
+Class541::Class541(NeverhoodEngine *vm, int16 x, int16 y)
+ : AnimatedSprite(vm, 0x1209E09F, 1100, x, y) {
+
+ startAnimation(0x1209E09F, 1, -1);
+ _newStickFrameIndex = 1;
+ setDoDeltaX(1);
+}
+
+Class542::Class542(NeverhoodEngine *vm, int16 x, int16 y)
+ : AnimatedSprite(vm, 0x1209E09F, 100, x, y) {
+
+ _newStickFrameIndex = 0;
+ setDoDeltaX(1);
+}
+
+Scene2501::Scene2501(NeverhoodEngine *vm, Module *parentModule, int which)
+ : Scene(vm, parentModule, true) {
+
+ _sceneInfos[0] = _vm->_staticData->getSceneInfo2700(0x004B2628);
+ _sceneInfos[1] = _vm->_staticData->getSceneInfo2700(0x004B264C);
+ _sceneInfos[2] = _vm->_staticData->getSceneInfo2700(0x004B2670);
+
+ setGlobalVar(0x21E60190, 1);
+ SetUpdateHandler(&Scene2501::update);
+ _surfaceFlag = true;
+ setBackground(0x1B8E8115);
+ setPalette(0x1B8E8115);
+ _palette->addPalette(0x00128842, 65, 31, 65);
+ _palette->addPalette("paKlayRed", 0, 64, 0);
+ insertMouse433(0xE81111B0);
+
+ _class437 = createSprite<Class437>(0x99BE9015); // Don't add this to the sprite list
+ addEntity(_class437);
+
+ _class521 = createSprite<Class521>(this, 211, 400); // Create but don't add to the sprite list yet
+ _class541 = insertSprite<Class541>(211, 400);
+ _class542 = insertSprite<Class542>(211, 400);
+ insertStaticSprite(0xC42AC521, 1500);
+
+ if (which < 0) {
+ insertKlayman<KmScene2501>(162, 393);
+ _kmScene2501 = _klayman;
+ _klaymanInCar = false;
+ setMessageList(0x004B2538);
+ setRectList(0x004B2608);
+ SetMessageHandler(&Scene2501::handleMessage);
+ SetUpdateHandler(&Scene2501::update);
+ sendMessage(_class521, 0x2009, 0);
+ _class521->setVisible(false);
+ _currTrackIndex = 0;
+ } else if (which == 1 || which == 2) {
+ addSprite(_class521);
+ _kmScene2501 = (Klayman*)new KmScene2501(_vm, this, 275, 393);
+ _klaymanInCar = true;
+ sendMessage(_kmScene2501, 0x2000, 1);
+ _kmScene2501->setDoDeltaX(1);
+ SetMessageHandler(&Scene2501::hmRidingCar);
+ SetUpdateHandler(&Scene2501::upRidingCar);
+ _class541->setVisible(false);
+ _class542->setVisible(false);
+ _currTrackIndex = which;
+ } else {
+ insertKlayman<KmScene2501>(162, 393);
+ _kmScene2501 = _klayman;
+ _klaymanInCar = false;
+ setMessageList(0x004B2538);
+ setRectList(0x004B2608);
+ SetMessageHandler(&Scene2501::handleMessage);
+ SetUpdateHandler(&Scene2501::update);
+ sendMessage(_class521, 0x2009, 0);
+ _class521->setVisible(false);
+ _currTrackIndex = 0;
+ }
+
+ // TODO _class517 = insertSprite<Class517>(_class521, _class437->getSurface(), 4);
+ // TODO _class520 = insertSprite<Class520>(_class521, _class437->getSurface(), 4);
+ // TODO _class519 = insertSprite<Class519>(_class521, _class437->getSurface(), 4);
+ insertSprite<Class518>(_class521);
+
+ _pointListsCount = 3;
+ _newTrackIndex = -1;
+ _dataResource.load(calcHash("Ashooded"));
+
+ _trackPoints = _dataResource.getPointArray(_sceneInfos[_currTrackIndex]->pointListName);
+ _class521->setPathPoints(_trackPoints);
+
+ if (which >= 0 && _sceneInfos[_currTrackIndex]->which2 == which) {
+ NPoint testPoint = (*_trackPoints)[_trackPoints->size() - 1];
+ sendMessage(_class521, 0x2002, _trackPoints->size() - 1);
+ if (testPoint.x < 0 || testPoint.x >= 640 || testPoint.y < 0 || testPoint.y >= 480)
+ sendMessage(_class521, 0x2007, 150);
+ } else {
+ NPoint testPoint = (*_trackPoints)[0];
+ sendMessage(_class521, 0x2002, 0);
+ if (testPoint.x < 0 || testPoint.x >= 640 || testPoint.y < 0 || testPoint.y >= 480)
+ sendMessage(_class521, 0x2008, 150);
+ }
+
+ _carStatus = 0;
+
+}
+
+Scene2501::~Scene2501() {
+ // Free sprites not currently in the sprite list
+ if (_klaymanInCar)
+ delete _kmScene2501;
+ else
+ delete _class521;
+}
+
+void Scene2501::update() {
+ Scene::update();
+ if (_carStatus == 1) {
+ removeSprite(_klayman);
+ addSprite(_class521);
+ clearRectList();
+ _klaymanInCar = true;
+ SetMessageHandler(&Scene2501::hmCarAtHome);
+ SetUpdateHandler(&Scene2501::upCarAtHome);
+ _class541->setVisible(false);
+ _class542->setVisible(false);
+ _class521->setVisible(true);
+ sendMessage(_class521, 0x2009, 0);
+ _class521->handleUpdate();
+ _klayman = NULL;
+ _carStatus = 0;
+ }
+ updateKlaymanCliprect();
+}
+
+void Scene2501::upCarAtHome() {
+ Scene::update();
+ if (_mouseClicked) {
+ if (_mouseClickPos.x <= 210 && _class521->getX() == 211 && _class521->getY() == 400) {
+ sendMessage(_class521, 0x200A, 0);
+ SetUpdateHandler(&Scene2501::upGettingOutOfCar);
+ } else {
+ findClosestTrack(_mouseClickPos);
+ SetMessageHandler(&Scene2501::hmRidingCar);
+ SetUpdateHandler(&Scene2501::upRidingCar);
+ }
+ _mouseClicked = false;
+ }
+ updateKlaymanCliprect();
+}
+
+void Scene2501::upGettingOutOfCar() {
+ Scene::update();
+ if (_carStatus == 2) {
+ _klayman = _kmScene2501;
+ removeSprite(_class521);
+ addSprite(_klayman);
+ _klaymanInCar = false;
+ SetMessageHandler(&Scene2501::handleMessage);
+ SetUpdateHandler(&Scene2501::update);
+ setRectList(0x004B2608);
+ _class541->setVisible(true);
+ _class542->setVisible(true);
+ _class521->setVisible(false);
+ setMessageList(0x004B2570);
+ runMessageList();
+ _klayman->handleUpdate();
+ _carStatus = 0;
+ }
+ updateKlaymanCliprect();
+}
+
+void Scene2501::upRidingCar() {
+ Scene::update();
+ if (_mouseClicked) {
+ findClosestTrack(_mouseClickPos);
+ _mouseClicked = false;
+ }
+}
+
+uint32 Scene2501::handleMessage(int messageNum, const MessageParam &param, Entity *sender) {
+ uint32 messageResult = Scene::handleMessage(messageNum, param, sender);
+ switch (messageNum) {
+ case 0x100D:
+ if (param.asInteger() == 0x60842040)
+ _carStatus = 1;
+ break;
+ case 0x200D:
+ sendMessage(_parentModule, 0x200D, 0);
+ break;
+ }
+ return messageResult;
+}
+
+uint32 Scene2501::hmRidingCar(int messageNum, const MessageParam &param, Entity *sender) {
+ uint32 messageResult = Scene::handleMessage(messageNum, param, sender);
+ switch (messageNum) {
+ case 0x2005:
+ if (_sceneInfos[_currTrackIndex]->which1 < 0 && _newTrackIndex >= 0) {
+ changeTrack();
+ } else if (_sceneInfos[_currTrackIndex]->which1 == 0) {
+ SetMessageHandler(&Scene2501::hmCarAtHome);
+ SetUpdateHandler(&Scene2501::upCarAtHome);
+ sendMessage(_class521, 0x200F, 1);
+ } else if (_sceneInfos[_currTrackIndex]->which1 > 0) {
+ leaveScene(_sceneInfos[_currTrackIndex]->which1);
+ }
+ break;
+ case 0x2006:
+ if (_sceneInfos[_currTrackIndex]->which2 < 0 && _newTrackIndex >= 0) {
+ changeTrack();
+ } else if (_sceneInfos[_currTrackIndex]->which2 == 0) {
+ SetMessageHandler(&Scene2501::hmCarAtHome);
+ SetUpdateHandler(&Scene2501::upCarAtHome);
+ sendMessage(_class521, 0x200F, 1);
+ } else if (_sceneInfos[_currTrackIndex]->which2 > 0) {
+ leaveScene(_sceneInfos[_currTrackIndex]->which2);
+ }
+ break;
+ case 0x200D:
+ sendMessage(_parentModule, 0x200D, 0);
+ break;
+ }
+ return messageResult;
+}
+
+uint32 Scene2501::hmCarAtHome(int messageNum, const MessageParam &param, Entity *sender) {
+ uint32 messageResult = Scene::handleMessage(messageNum, param, sender);
+ switch (messageNum) {
+ case 0x200A:
+ _carStatus = 2;
+ break;
+ case 0x200D:
+ sendMessage(_parentModule, 0x200D, 0);
+ break;
+ }
+ return messageResult;
+}
+
+void Scene2501::changeTrack() {
+ _currTrackIndex = _newTrackIndex;
+ _trackPoints = _dataResource.getPointArray(_sceneInfos[_currTrackIndex]->pointListName);
+ _class521->setPathPoints(_trackPoints);
+ if (_currTrackIndex == 0) {
+ sendMessage(_class521, 0x2002, _trackPoints->size() - 1);
+ } else {
+ sendMessage(_class521, 0x2002, 0);
+ }
+ sendPointMessage(_class521, 0x2004, _clickPoint);
+ _newTrackIndex = -1;
+}
+
+void Scene2501::findClosestTrack(NPoint &pt) {
+ // TODO NOTE This is uses with minor variations in other scenes, maybe merge them?
+ int minMatchDistance = 640;
+ int minMatchTrackIndex = -1;
+ // Find the track which contains a point closest to pt
+ for (int infoIndex = 0; infoIndex < _pointListsCount; infoIndex++) {
+ NPointArray *pointList = _dataResource.getPointArray(_sceneInfos[infoIndex]->pointListName);
+ for (uint pointIndex = 0; pointIndex < pointList->size(); pointIndex++) {
+ NPoint testPt = (*pointList)[pointIndex];
+ int distance = calcDistance(testPt.x, testPt.y, pt.x, pt.y);
+ if (distance < minMatchDistance) {
+ minMatchTrackIndex = infoIndex;
+ minMatchDistance = distance;
+ }
+ }
+ }
+ if (minMatchTrackIndex >= 0 && minMatchTrackIndex != _currTrackIndex) {
+ _newTrackIndex = minMatchTrackIndex;
+ _clickPoint = pt;
+ if (_currTrackIndex == 0)
+ sendMessage(_class521, 0x2003, _trackPoints->size() - 1);
+ else
+ sendMessage(_class521, 0x2003, 0);
+ } else {
+ _newTrackIndex = -1;
+ sendMessage(_class521, 0x2004, pt);
+ }
+}
+
+void Scene2501::updateKlaymanCliprect() {
+ if (_kmScene2501->getX() <= 211)
+ _kmScene2501->setClipRect(0, 0, 640, 480);
+ else
+ _kmScene2501->setClipRect(0, 0, 640, 388);
+}
+
+} // End of namespace Neverhood
diff --git a/engines/neverhood/module2500.h b/engines/neverhood/module2500.h
new file mode 100644
index 0000000000..d907d5fbda
--- /dev/null
+++ b/engines/neverhood/module2500.h
@@ -0,0 +1,96 @@
+/* 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_MODULE2500_H
+#define NEVERHOOD_MODULE2500_H
+
+#include "neverhood/neverhood.h"
+#include "neverhood/module.h"
+#include "neverhood/scene.h"
+#include "neverhood/module1600.h"
+#include "neverhood/module2700.h"
+
+namespace Neverhood {
+
+// Module2500
+
+class Module2500 : public Module {
+public:
+ Module2500(NeverhoodEngine *vm, Module *parentModule, int which);
+ virtual ~Module2500();
+protected:
+ SoundResource _soundResource1;
+ SoundResource _soundResource2;
+ SoundResource _soundResource3;
+ SoundResource _soundResource4;
+ int _soundIndex;
+ void createScene(int sceneNum, int which);
+ void updateScene();
+ uint32 handleMessage(int messageNum, const MessageParam &param, Entity *sender);
+};
+
+class Class541 : public AnimatedSprite {
+public:
+ Class541(NeverhoodEngine *vm, int16 x, int16 y);
+};
+
+class Class542 : public AnimatedSprite {
+public:
+ Class542(NeverhoodEngine *vm, int16 x, int16 y);
+};
+
+class Scene2501 : public Scene {
+public:
+ Scene2501(NeverhoodEngine *vm, Module *parentModule, int which);
+ virtual ~Scene2501();
+protected:
+ Class521 *_class521;
+ Sprite *_class437;
+ // TODO Sprite *_class517;
+ // TODO Sprite *_class519;
+ // TODO Sprite *_class520;
+ Sprite *_class541;
+ Sprite *_class542;
+ Klayman *_kmScene2501;
+ NPointArray *_trackPoints;
+ SceneInfo2700 *_sceneInfos[3];
+ int _currTrackIndex;
+ NPoint _clickPoint;
+ int _pointListsCount;
+ int _newTrackIndex;
+ int _carStatus;
+ bool _klaymanInCar;
+ void update();
+ void upCarAtHome();
+ void upGettingOutOfCar();
+ void upRidingCar();
+ uint32 handleMessage(int messageNum, const MessageParam &param, Entity *sender);
+ uint32 hmRidingCar(int messageNum, const MessageParam &param, Entity *sender);
+ uint32 hmCarAtHome(int messageNum, const MessageParam &param, Entity *sender);
+ void findClosestTrack(NPoint &pt);
+ void changeTrack();
+ void updateKlaymanCliprect();
+};
+
+} // End of namespace Neverhood
+
+#endif /* NEVERHOOD_MODULE2500_H */
diff --git a/engines/neverhood/module2700.cpp b/engines/neverhood/module2700.cpp
index 096e33546e..862b832654 100644
--- a/engines/neverhood/module2700.cpp
+++ b/engines/neverhood/module2700.cpp
@@ -90,7 +90,6 @@ Module2700::Module2700(NeverhoodEngine *vm, Module *parentModule, int which)
// TODO Music18hList_play(0x04020210, 24, 2, 1);
SetMessageHandler(&Module2700::handleMessage);
-
if (which < 0) {
which = _vm->gameState().which;
if (_vm->gameState().sceneNum == 0 || _vm->gameState().sceneNum == 30 || _vm->gameState().sceneNum == 31)
diff --git a/engines/neverhood/scene.cpp b/engines/neverhood/scene.cpp
index 457d5866d0..d189fad240 100644
--- a/engines/neverhood/scene.cpp
+++ b/engines/neverhood/scene.cpp
@@ -158,6 +158,11 @@ Sprite *Scene::addSprite(Sprite *sprite) {
return sprite;
}
+void Scene::removeSprite(Sprite *sprite) {
+ removeSurface(sprite->getSurface());
+ removeEntity(sprite);
+}
+
void Scene::setSurfacePriority(BaseSurface *surface, int priority) {
surface->setPriority(priority);
if (removeSurface(surface))
diff --git a/engines/neverhood/scene.h b/engines/neverhood/scene.h
index e962266168..f9e221a6da 100644
--- a/engines/neverhood/scene.h
+++ b/engines/neverhood/scene.h
@@ -47,6 +47,7 @@ public:
void addSurface(BaseSurface *surface);
bool removeSurface(BaseSurface *surface);
Sprite *addSprite(Sprite *sprite);
+ void removeSprite(Sprite *sprite);
void setSurfacePriority(BaseSurface *surface, int priority);
void deleteSprite(Sprite **sprite);
Background *addBackground(Background *background);
generated by cgit v1.2.3 (git 2.25.1) at 2024-09-18 18:39:46 +0000