ASYLUM: Add stubs for puzzles saveLoadWithSerializer()

engines/asylum/puzzles/boardkeyhidesto.cpp

@@ -52,6 +52,10 @@ static const PuzzleBoard::PuzzleData puzzleKeyHidesToData = {
 PuzzleBoardKeyHidesTo::PuzzleBoardKeyHidesTo(AsylumEngine *engine) : PuzzleBoard(engine, puzzleKeyHidesToData) {
 }
 
+void PuzzleBoardKeyHidesTo::saveLoadWithSerializer(Common::Serializer &s) {
+	error("[PuzzleBoardKeyHidesTo::saveLoadWithSerializer] Not implemented");
+}
+
 //////////////////////////////////////////////////////////////////////////
 // Event Handling
 //////////////////////////////////////////////////////////////////////////

engines/asylum/puzzles/boardkeyhidesto.h

@@ -33,6 +33,9 @@ class PuzzleBoardKeyHidesTo : public PuzzleBoard {
 public:
 	PuzzleBoardKeyHidesTo(AsylumEngine *engine);
 
+	// Serializable
+	virtual void saveLoadWithSerializer(Common::Serializer &s);
+
 private:
 	//////////////////////////////////////////////////////////////////////////
 	// Event Handling

engines/asylum/puzzles/boardsalvation.cpp

@@ -57,6 +57,10 @@ static const uint32 puzzleSalvationSoundResourceIndex[11] = {5, 6, 7, 10, 11, 28
 PuzzleBoardSalvation::PuzzleBoardSalvation(AsylumEngine *engine) : PuzzleBoard(engine, puzzleSalvationData) {
 }
 
+void PuzzleBoardSalvation::saveLoadWithSerializer(Common::Serializer &s) {
+	error("[PuzzleBoardSalvation::saveLoadWithSerializer] Not implemented");
+}
+
 //////////////////////////////////////////////////////////////////////////
 // Event Handling
 //////////////////////////////////////////////////////////////////////////

engines/asylum/puzzles/boardsalvation.h

@@ -33,6 +33,9 @@ class PuzzleBoardSalvation : public PuzzleBoard {
 public:
 	PuzzleBoardSalvation(AsylumEngine *engine);
 
+	// Serializable
+	virtual void saveLoadWithSerializer(Common::Serializer &s);
+
 private:
 	//////////////////////////////////////////////////////////////////////////
 	// Event Handling

engines/asylum/puzzles/boardyouth.cpp

@@ -50,6 +50,10 @@ static const PuzzleBoard::PuzzleData puzzleYouthData = {
 PuzzleBoardYouth::PuzzleBoardYouth(AsylumEngine *engine) : PuzzleBoard(engine, puzzleYouthData) {
 }
 
+void PuzzleBoardYouth::saveLoadWithSerializer(Common::Serializer &s) {
+	error("[PuzzleBoardYouth::saveLoadWithSerializer] Not implemented");
+}
+
 //////////////////////////////////////////////////////////////////////////
 // Event Handling
 //////////////////////////////////////////////////////////////////////////

engines/asylum/puzzles/boardyouth.h

@@ -33,6 +33,9 @@ class PuzzleBoardYouth : public PuzzleBoard {
 public:
 	PuzzleBoardYouth(AsylumEngine *engine);
 
+	// Serializable
+	virtual void saveLoadWithSerializer(Common::Serializer &s);
+
 private:
 	//////////////////////////////////////////////////////////////////////////
 	// Event Handling

engines/asylum/puzzles/clock.cpp

@@ -72,6 +72,10 @@ PuzzleClock::PuzzleClock(AsylumEngine *engine) : Puzzle(engine) {
 PuzzleClock::~PuzzleClock() {
 }
 
+void PuzzleClock::saveLoadWithSerializer(Common::Serializer &s) {
+	error("[PuzzleClock::saveLoadWithSerializer] Not implemented");
+}
+
 //////////////////////////////////////////////////////////////////////////
 // Event Handling
 //////////////////////////////////////////////////////////////////////////

engines/asylum/puzzles/clock.h

@@ -34,6 +34,9 @@ public:
 	PuzzleClock(AsylumEngine *engine);
 	~PuzzleClock();
 
+	// Serializable
+	virtual void saveLoadWithSerializer(Common::Serializer &s);
+
 private:
 	uint32 _frameIndexes[3];
 	bool _showCursor;

engines/asylum/puzzles/fisherman.cpp

@@ -57,6 +57,10 @@ PuzzleFisherman::PuzzleFisherman(AsylumEngine *engine) : Puzzle(engine) {
 PuzzleFisherman::~PuzzleFisherman() {
 }
 
+void PuzzleFisherman::saveLoadWithSerializer(Common::Serializer &s) {
+	error("[PuzzleFisherman::saveLoadWithSerializer] Not implemented");
+}
+
 //////////////////////////////////////////////////////////////////////////
 // Event Handling
 //////////////////////////////////////////////////////////////////////////

engines/asylum/puzzles/fisherman.h

@@ -34,6 +34,9 @@ public:
 	PuzzleFisherman(AsylumEngine *engine);
 	~PuzzleFisherman();
 
+	// Serializable
+	virtual void saveLoadWithSerializer(Common::Serializer &s);
+
 private:
 	bool _state[6];
 	int32 _counter;

engines/asylum/puzzles/hivecontrol.cpp

@@ -68,6 +68,10 @@ PuzzleHiveControl::PuzzleHiveControl(AsylumEngine *engine) : Puzzle(engine) {
 PuzzleHiveControl::~PuzzleHiveControl() {
 }
 
+void PuzzleHiveControl::saveLoadWithSerializer(Common::Serializer &s) {
+	error("[PuzzleHiveControl::saveLoadWithSerializer] Not implemented");
+}
+
 void PuzzleHiveControl::reset() {
 	_leverPosition = 3;
 	_leverDelta = 0;

engines/asylum/puzzles/hivecontrol.h

@@ -59,6 +59,9 @@ public:
 	PuzzleHiveControl(AsylumEngine *engine);
 	~PuzzleHiveControl();
 
+	// Serializable
+	virtual void saveLoadWithSerializer(Common::Serializer &s);
+
 private:
 	enum Element {
 		kElementSwirl		= 31,

engines/asylum/puzzles/lock.cpp

@@ -51,6 +51,10 @@ PuzzleLock::PuzzleLock(AsylumEngine *engine) : Puzzle(engine) {
 PuzzleLock::~PuzzleLock() {
 }
 
+void PuzzleLock::saveLoadWithSerializer(Common::Serializer &s) {
+	error("[PuzzleLock::saveLoadWithSerializer] Not implemented");
+}
+
 //////////////////////////////////////////////////////////////////////////
 // Event Handling
 //////////////////////////////////////////////////////////////////////////

engines/asylum/puzzles/lock.h

@@ -34,6 +34,9 @@ public:
 	PuzzleLock(AsylumEngine *engine);
 	~PuzzleLock();
 
+	// Serializable
+	virtual void saveLoadWithSerializer(Common::Serializer &s);
+
 private:
 	int32 _frameIndexes[7];
 	bool _incrementLock;

engines/asylum/puzzles/morguedoor.cpp

@@ -57,9 +57,8 @@ PuzzleMorgueDoor::PuzzleMorgueDoor(AsylumEngine *engine) : Puzzle(engine) {
 PuzzleMorgueDoor::~PuzzleMorgueDoor() {
 }
 
-void PuzzleMorgueDoor::reset() {
-	_data_45A9D8 = 0;
-	_data_45A9DC = 0;
+void PuzzleMorgueDoor::saveLoadWithSerializer(Common::Serializer &s) {
+	error("[PuzzleMorgueDoor::saveLoadWithSerializer] Not implemented");
 }
 
 //////////////////////////////////////////////////////////////////////////

engines/asylum/puzzles/morguedoor.h

@@ -34,7 +34,8 @@ public:
 	PuzzleMorgueDoor(AsylumEngine *engine);
 	~PuzzleMorgueDoor();
 
-	void reset();
+	// Serializable
+	virtual void saveLoadWithSerializer(Common::Serializer &s);
 
 private:
 	enum PuzzleObject {

engines/asylum/puzzles/pipes.cpp

@@ -321,6 +321,10 @@ PuzzlePipes::~PuzzlePipes() {
 	delete [] _frameIndexSpider;
 }
 
+void PuzzlePipes::saveLoadWithSerializer(Common::Serializer &s) {
+	error("[PuzzlePipes::saveLoadWithSerializer] Not implemented");
+}
+
 //////////////////////////////////////////////////////////////////////////
 // Event Handling
 //////////////////////////////////////////////////////////////////////////

engines/asylum/puzzles/pipes.h

@@ -154,6 +154,9 @@ public:
 	PuzzlePipes(AsylumEngine *engine);
 	~PuzzlePipes();
 
+	// Serializable
+	virtual void saveLoadWithSerializer(Common::Serializer &s);
+
 private:
 	int32 _previousMusicVolume;
 	int32 _rectIndex;

engines/asylum/puzzles/puzzle.h

@@ -47,7 +47,7 @@ public:
 	bool handleEvent(const AsylumEvent &evt);
 
 	// Serializable
-	void saveLoadWithSerializer(Common::Serializer &s);
+	virtual void saveLoadWithSerializer(Common::Serializer &s);
 
 protected:
 	AsylumEngine *_vm;

engines/asylum/puzzles/puzzles.cpp

@@ -76,30 +76,41 @@ EventHandler *Puzzles::getPuzzle(uint32 index) const {
 }
 
 void Puzzles::initPuzzles() {
-	_puzzles[0] = new PuzzleVCR(_vm);
-	_puzzles[1] = new PuzzlePipes(_vm);
-	_puzzles[2] = new PuzzleTicTacToe(_vm);
-	_puzzles[3] = new PuzzleLock(_vm);
-	_puzzles[4] = NULL;    // No event handler for Puzzle 5
-	_puzzles[5] = new PuzzleWheel(_vm);
-	_puzzles[6] = new PuzzleBoardSalvation(_vm);
-	_puzzles[7] = new PuzzleBoardYouth(_vm);
-	_puzzles[8] = new PuzzleBoardKeyHidesTo(_vm);
-	_puzzles[9] = new PuzzleWritings(_vm);
-	_puzzles[10] = new Puzzle11(_vm);
-	_puzzles[11] = new PuzzleMorgueDoor(_vm);
-	_puzzles[12] = new PuzzleClock(_vm);
-	_puzzles[13] = new PuzzleTimeMachine(_vm);
-	_puzzles[14] = new PuzzleFisherman(_vm);
-	_puzzles[15] = new PuzzleHiveMachine(_vm);
-	_puzzles[16] = new PuzzleHiveControl(_vm);
+	_puzzles[kPuzzleVCR]             = new PuzzleVCR(_vm);
+	_puzzles[kPuzzlePipes]           = new PuzzlePipes(_vm);
+	_puzzles[kPuzzleTicTacToe]       = new PuzzleTicTacToe(_vm);
+	_puzzles[kPuzzleLock]            = new PuzzleLock(_vm);
+	_puzzles[kPuzzle4]               = NULL;    // No event handler for Puzzle 5
+	_puzzles[kPuzzleWheel]           = new PuzzleWheel(_vm);
+	_puzzles[kPuzzleBoardSalvation]  = new PuzzleBoardSalvation(_vm);
+	_puzzles[kPuzzleBoardYouth]      = new PuzzleBoardYouth(_vm);
+	_puzzles[kPuzzleBoardKeyHidesTo] = new PuzzleBoardKeyHidesTo(_vm);
+	_puzzles[kPuzzleWritings]        = new PuzzleWritings(_vm);
+	_puzzles[kPuzzle11]              = new Puzzle11(_vm);
+	_puzzles[kPuzzleMorgueDoor]      = new PuzzleMorgueDoor(_vm);
+	_puzzles[kPuzzleClock]           = new PuzzleClock(_vm);
+	_puzzles[kPuzzleTimeMachine]     = new PuzzleTimeMachine(_vm);
+	_puzzles[kPuzzleFisherman]       = new PuzzleFisherman(_vm);
+	_puzzles[kPuzzleHiveMachine]     = new PuzzleHiveMachine(_vm);
+	_puzzles[kPuzzleHiveControl]     = new PuzzleHiveControl(_vm);
 }
 
 void Puzzles::saveLoadWithSerializer(Common::Serializer &s) {
-	for (int32 i = 0; i < ARRAYSIZE(_puzzles); i++) {
-		if (_puzzles[i])
-			_puzzles[i]->saveLoadWithSerializer(s);
-	}
+	_puzzles[kPuzzleVCR]->saveLoadWithSerializer(s);
+	s.skip(4);
+	_puzzles[kPuzzleLock]->saveLoadWithSerializer(s);
+	_puzzles[kPuzzlePipes]->saveLoadWithSerializer(s);
+	_puzzles[kPuzzleWheel]->saveLoadWithSerializer(s);
+	_puzzles[kPuzzleBoardSalvation]->saveLoadWithSerializer(s);
+	_puzzles[kPuzzleBoardYouth]->saveLoadWithSerializer(s);
+	s.skip(8);
+	_puzzles[kPuzzleBoardKeyHidesTo]->saveLoadWithSerializer(s);
+	_puzzles[kPuzzleMorgueDoor]->saveLoadWithSerializer(s);
+	_puzzles[kPuzzle11]->saveLoadWithSerializer(s);
+	_puzzles[kPuzzleTimeMachine]->saveLoadWithSerializer(s);
+	_puzzles[kPuzzleClock]->saveLoadWithSerializer(s);
+	_puzzles[kPuzzleFisherman]->saveLoadWithSerializer(s);
+	_puzzles[kPuzzleHiveControl]->saveLoadWithSerializer(s);
 }
 
 } // End of namespace Asylum

engines/asylum/puzzles/timemachine.cpp

@@ -76,17 +76,8 @@ PuzzleTimeMachine::PuzzleTimeMachine(AsylumEngine *engine) : Puzzle(engine) {
 PuzzleTimeMachine::~PuzzleTimeMachine() {
 }
 
-void PuzzleTimeMachine::reset() {
-	_frameIndexes[0] = 0;
-	_frameIndexes[1] = 4;
-	_frameIndexes[2] = 20;
-	_frameIndexes[3] = 16;
-	_frameIndexes[4] = 20;
-	memset(&_state, 0, sizeof(_state));
-	_data_45AAAC = 0;
-
-	// Reset point only (the other values are static)
-	_point = Common::Point(-65, -30);
+void PuzzleTimeMachine::saveLoadWithSerializer(Common::Serializer &s) {
+	error("[PuzzleTimeMachine::saveLoadWithSerializer] Not implemented");
 }
 
 //////////////////////////////////////////////////////////////////////////

engines/asylum/puzzles/timemachine.h

@@ -34,7 +34,8 @@ public:
 	PuzzleTimeMachine(AsylumEngine *engine);
 	~PuzzleTimeMachine();
 
-	void reset();
+	// Serializable
+	virtual void saveLoadWithSerializer(Common::Serializer &s);
 
 private:
 	bool _leftButtonClicked;

engines/asylum/puzzles/vcr.cpp

@@ -49,6 +49,10 @@ PuzzleVCR::PuzzleVCR(AsylumEngine *engine): Puzzle(engine) {
 PuzzleVCR::~PuzzleVCR() {
 }
 
+void PuzzleVCR::saveLoadWithSerializer(Common::Serializer &s) {
+	error("[PuzzleVCR::saveLoadWithSerializer] Not implemented");
+}
+
 //////////////////////////////////////////////////////////////////////////
 // Event Handling
 //////////////////////////////////////////////////////////////////////////

engines/asylum/puzzles/vcr.h

@@ -57,6 +57,9 @@ public:
 	PuzzleVCR(AsylumEngine *engine);
 	~PuzzleVCR();
 
+	// Serializable
+	virtual void saveLoadWithSerializer(Common::Serializer &s);
+
 private:
 	enum Color {
 		kNone   = -1,

engines/asylum/puzzles/wheel.cpp

@@ -149,20 +149,8 @@ PuzzleWheel::PuzzleWheel(AsylumEngine *engine) : Puzzle(engine) {
 PuzzleWheel::~PuzzleWheel() {
 }
 
-void PuzzleWheel::reset() {
-	getSpecial()->reset(true);
-
-	_resourceIndex = 0;
-	_resourceIndexLever = 13;
-
-	_frameIndexWheel = 0;
-
-	_frameIndexes[0] = 0;
-	_frameIndexes[9] = 0;
-	_frameIndexes[10] = 0;
-	_frameIndexes[11] = 0;
-
-	_turnWheelRight = false;
+void PuzzleWheel::saveLoadWithSerializer(Common::Serializer &s) {
+	error("[PuzzleWheel::saveLoadWithSerializer] Not implemented");
 }
 
 //////////////////////////////////////////////////////////////////////////

engines/asylum/puzzles/wheel.h

@@ -34,7 +34,8 @@ public:
 	PuzzleWheel(AsylumEngine *engine);
 	~PuzzleWheel();
 
-	void reset();
+	// Serializable
+	virtual void saveLoadWithSerializer(Common::Serializer &s);
 
 private:
 	int32 _currentRect;

engines/asylum/shared.h

@@ -647,6 +647,29 @@ enum ObjectFlag {
 	kObjectFlag40000     = 0x40000
 };
 
+//////////////////////////////////////////////////////////////////////////
+// Puzzles
+//////////////////////////////////////////////////////////////////////////
+enum PuzzleId {
+	kPuzzleVCR = 0,
+	kPuzzlePipes,
+	kPuzzleTicTacToe,
+	kPuzzleLock,
+	kPuzzle4,
+	kPuzzleWheel,                 // 5
+	kPuzzleBoardSalvation,
+	kPuzzleBoardYouth,
+	kPuzzleBoardKeyHidesTo,
+	kPuzzleWritings,
+	kPuzzle11,                    // 10
+	kPuzzleMorgueDoor,
+	kPuzzleClock,
+	kPuzzleTimeMachine,
+	kPuzzleFisherman,
+	kPuzzleHiveMachine,           // 15
+	kPuzzleHiveControl
+};
+
 //////////////////////////////////////////////////////////////////////////
 // Helpers
 //////////////////////////////////////////////////////////////////////////