Initial commit

engines/hugo/object.h

@@ -0,0 +1,164 @@
+/* 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 3 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, see <http://www.gnu.org/licenses/>.
+ *
+ */
+
+/*
+ * This code is based on original Hugo Trilogy source code
+ *
+ * Copyright (c) 1989-1995 David P. Gray
+ *
+ */
+
+#ifndef HUGO_OBJECT_H
+#define HUGO_OBJECT_H
+
+#include "common/file.h"
+
+namespace Hugo {
+
+struct Target {                                      // Secondary target for action
+	uint16 _nounIndex;                               // Secondary object
+	uint16 _verbIndex;                               // Action on secondary object
+};
+
+struct Uses {                                        // Define uses of certain objects
+	int16     _objId;                                // Primary object
+	uint16    _dataIndex;                            // String if no secondary object matches
+	Target   *_targets;                              // List of secondary targets
+};
+
+class ObjectHandler {
+public:
+	ObjectHandler(HugoEngine *vm);
+	virtual ~ObjectHandler();
+
+	Overlay   _objBound;
+	Overlay   _boundary;                             // Boundary overlay file
+	Overlay   _overlay;                              // First overlay file
+	Overlay   _ovlBase;                              // First overlay base file
+
+	Object   *_objects;
+	uint16    _numObj;
+
+	byte getBoundaryOverlay(uint16 index) const;
+	byte getObjectBoundary(uint16 index) const;
+	byte getBaseBoundary(uint16 index) const;
+	byte getFirstOverlay(uint16 index) const;
+
+	int  deltaX(const int x1, const int x2, const int vx, int y) const;
+	int  deltaY(const int x1, const int x2, const int vy, const int y) const;
+	void boundaryCollision(Object *obj);
+	void clearBoundary(const int x1, const int x2, const int y);
+	void clearScreenBoundary(const int x1, const int x2, const int y);
+	void storeBoundary(const int x1, const int x2, const int y);
+
+	virtual void homeIn(const int objIndex1, const int objIndex2, const int8 objDx, const int8 objDy) = 0;
+	virtual void moveObjects() = 0;
+	virtual void updateImages() = 0;
+	virtual void swapImages(int objIndex1, int objIndex2, bool restoring) = 0;
+
+	bool isCarrying(uint16 wordIndex);
+	bool findObjectSpace(Object *obj, int16 *destx, int16 *desty);
+
+	int   calcMaxScore();
+	int16 findObject(uint16 x, uint16 y);
+	void freeObjects();
+	void loadObjectArr(Common::ReadStream &in);
+	void loadObjectUses(Common::ReadStream &in);
+	void loadNumObj(Common::ReadStream &in);
+	void lookObject(Object *obj);
+	void readObjectImages();
+	void readObject(Common::ReadStream &in, Object &curObject);
+	void readUse(Common::ReadStream &in, Uses &curUse);
+	void restoreAllSeq();
+	void restoreObjects(Common::SeekableReadStream *in);
+	void saveObjects(Common::WriteStream *out);
+	void saveSeq(Object *obj);
+	void setCarriedScreen(int screenNum);
+	void showTakeables();
+	void useObject(int16 objId);
+
+	static int y2comp(const void *a, const void *b);
+
+	bool isCarried(int objIndex) const;
+	void setCarry(int objIndex, bool val);
+	void setVelocity(int objIndex, int8 vx, int8 vy);
+	void setPath(int objIndex, Path pathType, int16 vxPath, int16 vyPath);
+
+protected:
+	HugoEngine *_vm;
+
+	static const int kEdge = 10;                    // Closest object can get to edge of screen
+	static const int kEdge2 = kEdge * 2;            // Push object further back on edge collision
+	static const int kMaxObjNumb = 128;             // Used in Update_images()
+
+	uint16    _objCount;
+	Uses     *_uses;
+	uint16    _usesSize;
+
+	void restoreSeq(Object *obj);
+
+	inline bool checkBoundary(int16 x, int16 y);
+	static inline int sign(int a) { return (a < 0) ? -1 : 1; }
+};
+
+class ObjectHandler_v1d : public ObjectHandler {
+public:
+	ObjectHandler_v1d(HugoEngine *vm);
+	~ObjectHandler_v1d() override;
+
+	void homeIn(const int objIndex1, const int objIndex2, const int8 objDx, const int8 objDy) override;
+	void moveObjects() override;
+	void updateImages() override;
+	void swapImages(int objIndex1, int objIndex2, bool restoring) override;
+};
+
+class ObjectHandler_v2d : public ObjectHandler_v1d {
+public:
+	ObjectHandler_v2d(HugoEngine *vm);
+	~ObjectHandler_v2d() override;
+
+	void moveObjects() override;
+	void updateImages() override;
+
+	void homeIn(const int objIndex1, const int objIndex2, const int8 objDx, const int8 objDy) override;
+};
+
+class ObjectHandler_v3d : public ObjectHandler_v2d {
+public:
+	ObjectHandler_v3d(HugoEngine *vm);
+	~ObjectHandler_v3d() override;
+
+	void moveObjects() override;
+	void swapImages(int objIndex1, int objIndex2, bool restoring) override;
+};
+
+class ObjectHandler_v1w : public ObjectHandler_v3d {
+public:
+	ObjectHandler_v1w(HugoEngine *vm);
+	~ObjectHandler_v1w() override;
+
+	void moveObjects() override;
+	void updateImages() override;
+	void swapImages(int objIndex1, int objIndex2, bool restoring) override;
+};
+
+} // End of namespace Hugo
+#endif //HUGO_OBJECT_H