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

#ifndef ULTIMA0_DATA_H
#define ULTIMA0_DATA_H

#include "common/array.h"
#include "common/keyboard.h"
#include "common/rect.h"
#include "common/serializer.h"
#include "ultima/ultima0/data/defines.h"

namespace Ultima {
namespace Ultima0 {

enum Direction { DIR_NORTH, DIR_EAST, DIR_SOUTH, DIR_WEST };

struct PlayerInfo;

struct ObjectInfo {
    const char *_name;
    int _cost;
    int _maxDamage;
    int _action;
};
struct MonsterInfo {
    const char *_name;
    int _level;
};

extern const ObjectInfo OBJECT_INFO[];
extern const MonsterInfo MONSTER_INFO[];
extern const char *ATTRIB_NAMES[];
extern const char *const DIRECTION_NAMES[];

struct MonsterEntry {
    Common::Point _loc;     // Position
    int _type = 0;          // Monster type
    int _strength = 0;      // Strength
    bool _alive = false;    // Alive flag

    void synchronize(Common::Serializer &s);
};

struct DungeonMapInfo {
private:
    void addMonster(const PlayerInfo &player, int type);
    int generateContent(int c);

public:
    byte _map[DUNGEON_MAP_SIZE][DUNGEON_MAP_SIZE] = {}; // Map information
    Common::Array<MonsterEntry> _monsters;              // Monster records

    void create(const PlayerInfo &player);
    void synchronize(Common::Serializer &s);

    int findMonster(const Common::Point &c) const;

    void addMonsterAtPos(const PlayerInfo &player, const Common::Point &pt, int type);
};

struct PlayerInfo {
    char _name[MAX_NAME + 1] = {};          // Player Name
    Common::Point _worldPos;                // World map position
    Common::Point _dungeonPos;              // Dungeon map position
    Common::Point _dungeonDir;              // Dungeon direction facing
    byte _class = '?';                      // Player class (F or M)
    int _hpGain = 0;                        // HPs gained in dungeon
    int _level = 0;                     // Dungeon level, 0 = world map
    int _skill = 0;                     // Skill level
    int _task = 0;                          // Task set (-1 = none)
    bool _taskCompleted = 0;                // Task completed
    uint32 _luckyNumber = 0;                    // Value used for seeding
    int _attr[MAX_ATTR] = {};               // Attribute values
    double _object[MAX_OBJ] = {};           // Object counts

    void init();
    void rollAttributes();
    void synchronize(Common::Serializer &s);

    Direction dungeonDir() const;

    void setDungeonDir(Direction newDir);

    void dungeonTurnLeft();

    void dungeonTurnRight();
};

struct WorldMapInfo {
    byte _map[WORLD_MAP_SIZE][WORLD_MAP_SIZE] = {}; // Map information

    void init(PlayerInfo &p);
    int read(int x, int y) const;
    void synchronize(Common::Serializer &s);
};

} // namespace Ultima0
} // namespace Ultima

#endif