story.h

/* 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