dungeon.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 ULTIMA4_MAP_DUNGEON_H
#define ULTIMA4_MAP_DUNGEON_H

#include "ultima/ultima4/controllers/combat_controller.h"
#include "ultima/ultima4/core/types.h"
#include "ultima/ultima4/map/map.h"

namespace Ultima {
namespace Ultima4 {

#define DNGROOM_NTRIGGERS 4

enum StatsBonusType {
    STATSBONUS_INT = 0x1,
    STATSBONUS_DEX = 0x2,
    STATSBONUS_STR = 0x4
};

struct Trigger {
    byte _tile;
    byte x, y;
    byte _changeX1, _changeY1, changeX2, changeY2;
};

struct PartyEntry {
private:
    Common::Point *_array[5];
public:
    Common::Point _northStart;
    Common::Point _eastStart;
    Common::Point _southStart;
    Common::Point _westStart;

    PartyEntry() {
        _array[DIR_NONE] = nullptr;
        _array[DIR_NORTH] = &_northStart;
        _array[DIR_EAST] = &_eastStart;
        _array[DIR_SOUTH] = &_southStart;
        _array[DIR_WEST] = &_westStart;
    }

    Common::Point &operator[](int dir) {
        return *_array[dir];
    }
};

struct DngRoom {
    Trigger _triggers[DNGROOM_NTRIGGERS];
    byte _creatureTiles[16];
    Common::Point _creatureStart[16];
    PartyEntry _partyStart[8];

    MapData  _mapData;  // This is OK to change to MapData since sizeof(DngRoom) or
    // anything like it is not being used.
    byte _buffer[7];

    void load(Common::SeekableReadStream &s);

    void hythlothFix7();
    void hythlothFix9();
};

enum DungeonToken {
    DUNGEON_CORRIDOR            = 0x00,
    DUNGEON_LADDER_UP           = 0x10,
    DUNGEON_LADDER_DOWN         = 0x20,
    DUNGEON_LADDER_UPDOWN       = 0x30,
    DUNGEON_CHEST               = 0x40,
    DUNGEON_CEILING_HOLE        = 0x50,
    DUNGEON_FLOOR_HOLE          = 0x60,
    DUNGEON_MAGIC_ORB           = 0x70,
    DUNGEON_TRAP                = 0x80,
    DUNGEON_FOUNTAIN            = 0x90,
    DUNGEON_FIELD               = 0xA0,
    DUNGEON_ALTAR               = 0xB0,
    DUNGEON_DOOR                = 0xC0,
    DUNGEON_ROOM                = 0xD0,
    DUNGEON_SECRET_DOOR         = 0xE0,
    DUNGEON_WALL                = 0xF0
};

class Dungeon : public Map {
public:
    Dungeon();
    ~Dungeon() override {}

    // Members
    Common::String getName() override;

    DungeonToken tokenForTile(MapTile tile);

    DungeonToken currentToken();

    byte currentSubToken();

    DungeonToken tokenAt(MapCoords coords);

    byte subTokenAt(MapCoords coords);

    bool ladderUpAt(MapCoords coords);

    bool ladderDownAt(MapCoords coords);

    bool validTeleportLocation(MapCoords coords);

    // Properties
    Common::String _name;
    uint _nRooms;
    Std::vector<byte> _dataSubTokens;
    DngRoom *_rooms;
    CombatMap **_roomMaps;
    int _currentRoom;
    byte _partyStartX[8];
    byte _partyStartY[8];
};

enum TrapType {
    TRAP_WINDS                  = 0x0,
    TRAP_FALLING_ROCK           = 0x1,
    TRAP_PIT                    = 0xe
};

enum FountainType {
    FOUNTAIN_NORMAL             = 0x0,
    FOUNTAIN_HEALING            = 0x1,
    FOUNTAIN_ACID               = 0x2,
    FOUNTAIN_CURE               = 0x3,
    FOUNTAIN_POISON             = 0x4
};

enum FieldType {
    FIELD_POISON                = 0x0,
    FIELD_ENERGY                = 0x1,
    FIELD_FIRE                  = 0x2,
    FIELD_SLEEP                 = 0x3
};

void dungeonSearch();

void dungeonDrinkFountain();

void dungeonTouchOrb();

bool dungeonHandleTrap(TrapType trap);

bool isDungeon(Map *punknown);

} // End of namespace Ultima4
} // End of namespace Ultima

#endif