Initial commit

engines/immortal/story.h

@@ -0,0 +1,259 @@
+/* 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/>.
+ *
+ */
+
+// Definitions are the enum for the set of global definitions in Story.GS
+#include "immortal/definitions.h"
+
+// Sprite List is a list of all sprite definitions (could be included in definitions.h, but sprite_list.gs was a separate source file and is sprite specific)
+#include "immortal/sprite_list.h"
+
+#ifndef IMMORTAL_STORY_H
+#define IMMORTAL_STORY_H
+
+namespace Immortal {
+
+// These maximum numbers aren't really needed, because most of these are vectors and have .size()
+enum StoryMaxes {
+	kMaxRooms        = 16,
+	kMaxDoors        = 10,
+	kMaxFlames       = 32,
+	kMaxFlamesInRoom = 5,
+	kMaxObjects      = 42,
+	kMaxMonsters     = 20,
+	kMaxGenSprites   = 6,
+	kMaxCycles       = 32
+};
+
+// These are flags that are relevant to their specific story data structures
+enum RoomFlag : uint8 {                         // Generic properties available to each room
+	kRoomFlag0 = 0x01,
+	kRoomFlag1 = 0x02,
+	kRoomFlag2 = 0x04,
+	kRoomFlag3 = 0x08
+};
+
+enum ObjFlag : uint8 {                          // Properties of the object essentially
+	kObjUsesFireButton = 0x40,
+	kObjIsInvisible    = 0x20,
+	kObjIsRunning      = 0x10,
+	kObjIsChest        = 0x08,
+	kObjIsOnGround     = 0x04,
+	kObjIsF1           = 0x02,
+	kObjIsF2           = 0x01,
+	kObjNone           = 0x0
+};
+
+enum IsA : uint8 {                              // To be completely honest, I'm not really sure what this is. It seems to be more object flags, but they act a little strangely
+	kIsAF1   = 0x20,
+	kIsAF2   = 0x40,
+	kIsANone = 0x0,
+};
+
+enum MonsterFlag : uint8 {                      // Mostly properties of the AI for a given monster, *including the player*
+	kMonstIsNone   = 0x00,
+	kMonstIsTough  = 0x10,
+	kMonstIsDead   = 0x20,
+	kMonstIsPoss   = 0x40,
+	kMonstIsBaby   = 0x40,
+	kMonstIsEngage = 0x80,
+	kMonstPlayer   = 0x00,
+	kMonstMonster  = 0x01,
+	kMonstAnybody  = 0x02,
+	kMonstNobody   = 0x03,
+	kMonstA        = 0x04,
+	kMonstB        = 0x05,
+	kMonstC        = 0x06,
+	kMonstD        = 0x07
+};
+
+// Flame pattern is used by the story data, in-room data, *and* the level based total flame data. So it needs to be in story.h to be used by immortal.h and room.h
+enum FPattern : uint8 {                         // This defines which Cyc animation it uses
+	kFlameNormal,
+	kFlameCandle,
+	kFlameOff,
+	kFlameGusty
+};
+
+// Object Pickup defines how an object can be picked up by the player, with different functions
+enum SObjPickup {
+};
+
+struct Pickup {
+	int _param;
+	// This will be a pointer to function
+};
+
+// Damage is used by object types as well as enemy types
+enum SDamage {
+};
+
+struct Damage {
+};
+
+// Use defines the function and parameters for using an object
+enum SObjUse {
+};
+
+struct Use {
+	int _param;
+	// This will be a pointer to function
+};
+
+struct ObjType {
+	Str _str = kStrNull;
+	Str _desc = kStrNull;
+	int _size = 0;
+	Use _use;
+	Use _run;
+	Pickup _pickup;
+};
+
+// Cycles define the animation of sprites within a level. There is a fixed total of cycles available, and they are not room dependant
+struct Cycle {
+	int  _index;                       // In source this is actually the position within the *instruction list*, but since cycle's are structs, it's just the index of frames now
+	CycID _cycList;
+};
+
+/* Strictly speaking, many of these structs (which were rom data written dynamically
+ * with compiler macros) combine multiple properties into single bytes (ex. room uses
+ * bits 0-2 of X to also hold the roomOP, and bits 0-2 of Y to hold flags). However
+ * for the moment there's no need to replicate this particular bit of space saving.
+ */
+struct SCycle {
+	SpriteName  _sName;
+	Common::Array<int> _frames;
+	bool  _repeat;
+	SCycle() {}
+	SCycle(SpriteName s, bool r, Common::Array<int> f) {
+		_sName  = s;
+		_repeat = r;
+		_frames = f;
+	}
+};
+
+struct SRoom {
+	uint16 _x = 0;
+	uint16 _y = 0;
+
+	RoomFlag _flags = kRoomFlag0;
+	SRoom() {}
+	SRoom(uint16 x, uint16 y, RoomFlag f) {
+		_x = x;
+		_y = y;
+		_flags = f;
+	}
+};
+
+struct SDoor {
+	uint8 _dir = 0;
+	uint16 _x  = 0;
+	uint16 _y  = 0;
+
+	uint16 _fromRoom = 0;
+	uint16 _toRoom   = 0;
+
+	bool _isLocked = false;
+	SDoor() {}
+	SDoor(uint8 d, uint16 x, uint16 y, uint16 f, uint16 t, bool l) {
+		_dir = d;
+		_x = x;
+		_y = y;
+
+		_fromRoom = f;
+		_toRoom = t;
+
+		_isLocked = l;
+	}
+};
+
+struct SFlame {
+	uint16 _x = 0;
+	uint16 _y = 0;
+
+	FPattern _p = kFlameOff;
+	SFlame() {}
+	SFlame(uint16 x, uint16 y, FPattern p) {
+		_x = x;
+		_y = y;
+		_p = p;
+	}
+};
+
+struct SObj {
+	uint16 _x = 0;
+	uint16 _y = 0;
+	uint8 _flags = 0;
+
+	SObjType _type = kTypeTrap;
+	SpriteFrame _frame = kNoFrame;
+	Common::Array<uint8> _traps;
+	SObj() {}
+	SObj(uint16 x, uint16 y, SObjType t, SpriteFrame s, uint8 f, Common::Array<uint8> traps) {
+		_x = x;
+		_y = y;
+		_type = t;
+		_flags = f;
+		_traps = traps;
+		_frame = s;
+	}
+};
+
+struct SMonster {
+	uint16 _x = 0;
+	uint16 _y = 0;
+	uint16 _hits = 0;
+	uint8 _flags = 0;
+
+	MonsterFlag _madAt = kMonstIsNone;
+	SpriteName _sprite = kCandle;
+	Common::Array<Motive> _program;
+	SMonster() {}
+	SMonster(uint16 x, uint16 y, uint16 h, MonsterFlag m, uint8 f, Common::Array<Motive> p, SpriteName s) {
+		_x = x;
+		_y = y;
+		_hits = h;
+		_madAt = m;
+		_flags = f;
+		_program = p;
+		_sprite = s;
+	}
+};
+
+struct Story {
+	int _level = 0;
+	int _part  = 1;
+
+	uint16 _initialUnivX = 0;
+	uint16 _initialUnivY = 0;
+	uint16 _playerPointX = 0;
+	uint16 _playerPointY = 0;
+
+	Common::Array<int> _ladders;
+	Common::Array<SRoom> _rooms;
+	Common::Array<SDoor> _doors;
+	CArray2D<SFlame> _flames;
+	CArray2D<SObj> _objects;
+	CArray2D<SMonster> _monsters;
+};
+
+} // namespace Immortal
+
+#endif