mirror of
https://github.com/vcmi/vcmi.git
synced 2024-12-14 10:12:59 +02:00
1044 lines
24 KiB
C++
1044 lines
24 KiB
C++
/*
|
|
* EntityIdentifiers.h, part of VCMI engine
|
|
*
|
|
* Authors: listed in file AUTHORS in main folder
|
|
*
|
|
* License: GNU General Public License v2.0 or later
|
|
* Full text of license available in license.txt file, in main folder
|
|
*
|
|
*/
|
|
#pragma once
|
|
|
|
#include "NumericConstants.h"
|
|
#include "IdentifierBase.h"
|
|
|
|
VCMI_LIB_NAMESPACE_BEGIN
|
|
|
|
class Services;
|
|
class Artifact;
|
|
class ArtifactService;
|
|
class Creature;
|
|
class CreatureService;
|
|
class HeroType;
|
|
class CHero;
|
|
class CHeroClass;
|
|
class HeroClass;
|
|
class HeroTypeService;
|
|
class CFaction;
|
|
class Faction;
|
|
class Skill;
|
|
class RoadType;
|
|
class RiverType;
|
|
class TerrainType;
|
|
|
|
namespace spells
|
|
{
|
|
class Spell;
|
|
class Service;
|
|
}
|
|
|
|
class CArtifact;
|
|
class CArtifactInstance;
|
|
class CCreature;
|
|
class CHero;
|
|
class CSpell;
|
|
class CSkill;
|
|
class CGameInfoCallback;
|
|
class CNonConstInfoCallback;
|
|
|
|
class ArtifactInstanceID : public StaticIdentifier<ArtifactInstanceID>
|
|
{
|
|
public:
|
|
using StaticIdentifier<ArtifactInstanceID>::StaticIdentifier;
|
|
};
|
|
|
|
class QueryID : public StaticIdentifier<QueryID>
|
|
{
|
|
public:
|
|
using StaticIdentifier<QueryID>::StaticIdentifier;
|
|
DLL_LINKAGE static const QueryID NONE;
|
|
DLL_LINKAGE static const QueryID CLIENT;
|
|
};
|
|
|
|
class BattleID : public StaticIdentifier<BattleID>
|
|
{
|
|
public:
|
|
using StaticIdentifier<BattleID>::StaticIdentifier;
|
|
DLL_LINKAGE static const BattleID NONE;
|
|
};
|
|
class DLL_LINKAGE ObjectInstanceID : public StaticIdentifier<ObjectInstanceID>
|
|
{
|
|
public:
|
|
using StaticIdentifier<ObjectInstanceID>::StaticIdentifier;
|
|
static const ObjectInstanceID NONE;
|
|
|
|
static si32 decode(const std::string & identifier);
|
|
static std::string encode(const si32 index);
|
|
};
|
|
|
|
class HeroClassID : public EntityIdentifier<HeroClassID>
|
|
{
|
|
public:
|
|
using EntityIdentifier<HeroClassID>::EntityIdentifier;
|
|
///json serialization helpers
|
|
DLL_LINKAGE static si32 decode(const std::string & identifier);
|
|
DLL_LINKAGE static std::string encode(const si32 index);
|
|
static std::string entityType();
|
|
|
|
const CHeroClass * toHeroClass() const;
|
|
const HeroClass * toEntity(const Services * services) const;
|
|
};
|
|
|
|
class DLL_LINKAGE HeroTypeID : public EntityIdentifier<HeroTypeID>
|
|
{
|
|
public:
|
|
using EntityIdentifier<HeroTypeID>::EntityIdentifier;
|
|
///json serialization helpers
|
|
static si32 decode(const std::string & identifier);
|
|
static std::string encode(const si32 index);
|
|
static std::string entityType();
|
|
|
|
const CHero * toHeroType() const;
|
|
const HeroType * toEntity(const Services * services) const;
|
|
|
|
static const HeroTypeID NONE;
|
|
static const HeroTypeID RANDOM;
|
|
static const HeroTypeID GEM; // aka Gem, Sorceress in campaign
|
|
static const HeroTypeID SOLMYR; // aka Young Yog in campaigns
|
|
|
|
bool isValid() const
|
|
{
|
|
return getNum() >= 0;
|
|
}
|
|
};
|
|
|
|
class SlotID : public StaticIdentifier<SlotID>
|
|
{
|
|
public:
|
|
using StaticIdentifier<SlotID>::StaticIdentifier;
|
|
|
|
DLL_LINKAGE static const SlotID COMMANDER_SLOT_PLACEHOLDER;
|
|
DLL_LINKAGE static const SlotID SUMMONED_SLOT_PLACEHOLDER; ///<for all summoned creatures, only during battle
|
|
DLL_LINKAGE static const SlotID WAR_MACHINES_SLOT; ///<for all war machines during battle
|
|
DLL_LINKAGE static const SlotID ARROW_TOWERS_SLOT; ///<for all arrow towers during battle
|
|
|
|
bool validSlot() const
|
|
{
|
|
return getNum() >= 0 && getNum() < GameConstants::ARMY_SIZE;
|
|
}
|
|
};
|
|
|
|
class DLL_LINKAGE PlayerColor : public StaticIdentifier<PlayerColor>
|
|
{
|
|
public:
|
|
using StaticIdentifier<PlayerColor>::StaticIdentifier;
|
|
|
|
enum EPlayerColor
|
|
{
|
|
PLAYER_LIMIT_I = 8,
|
|
};
|
|
|
|
static const PlayerColor SPECTATOR; //252
|
|
static const PlayerColor CANNOT_DETERMINE; //253
|
|
static const PlayerColor UNFLAGGABLE; //254 - neutral objects (pandora, banks)
|
|
static const PlayerColor NEUTRAL; //255
|
|
static const PlayerColor PLAYER_LIMIT; //player limit per map
|
|
|
|
bool isValidPlayer() const; //valid means < PLAYER_LIMIT (especially non-neutral)
|
|
bool isSpectator() const;
|
|
|
|
std::string toString() const;
|
|
|
|
static si32 decode(const std::string& identifier);
|
|
static std::string encode(const si32 index);
|
|
static std::string entityType();
|
|
};
|
|
|
|
class TeamID : public StaticIdentifier<TeamID>
|
|
{
|
|
public:
|
|
using StaticIdentifier<TeamID>::StaticIdentifier;
|
|
|
|
DLL_LINKAGE static const TeamID NO_TEAM;
|
|
};
|
|
|
|
class TeleportChannelID : public StaticIdentifier<TeleportChannelID>
|
|
{
|
|
public:
|
|
using StaticIdentifier<TeleportChannelID>::StaticIdentifier;
|
|
};
|
|
|
|
class SecondarySkillBase : public IdentifierBase
|
|
{
|
|
public:
|
|
enum Type : int32_t
|
|
{
|
|
NONE = -1,
|
|
PATHFINDING = 0,
|
|
ARCHERY,
|
|
LOGISTICS,
|
|
SCOUTING,
|
|
DIPLOMACY,
|
|
NAVIGATION,
|
|
LEADERSHIP,
|
|
WISDOM,
|
|
MYSTICISM,
|
|
LUCK,
|
|
BALLISTICS,
|
|
EAGLE_EYE,
|
|
NECROMANCY,
|
|
ESTATES,
|
|
FIRE_MAGIC,
|
|
AIR_MAGIC,
|
|
WATER_MAGIC,
|
|
EARTH_MAGIC,
|
|
SCHOLAR,
|
|
TACTICS,
|
|
ARTILLERY,
|
|
LEARNING,
|
|
OFFENCE,
|
|
ARMORER,
|
|
INTELLIGENCE,
|
|
SORCERY,
|
|
RESISTANCE,
|
|
FIRST_AID,
|
|
SKILL_SIZE
|
|
};
|
|
static_assert(GameConstants::SKILL_QUANTITY == SKILL_SIZE, "Incorrect number of skills");
|
|
};
|
|
|
|
class DLL_LINKAGE SecondarySkill : public EntityIdentifierWithEnum<SecondarySkill, SecondarySkillBase>
|
|
{
|
|
public:
|
|
using EntityIdentifierWithEnum<SecondarySkill, SecondarySkillBase>::EntityIdentifierWithEnum;
|
|
static std::string entityType();
|
|
static si32 decode(const std::string& identifier);
|
|
static std::string encode(const si32 index);
|
|
|
|
const CSkill * toSkill() const;
|
|
const Skill * toEntity(const Services * services) const;
|
|
};
|
|
|
|
class DLL_LINKAGE PrimarySkill : public StaticIdentifier<PrimarySkill>
|
|
{
|
|
public:
|
|
using StaticIdentifier<PrimarySkill>::StaticIdentifier;
|
|
|
|
static const PrimarySkill NONE;
|
|
static const PrimarySkill ATTACK;
|
|
static const PrimarySkill DEFENSE;
|
|
static const PrimarySkill SPELL_POWER;
|
|
static const PrimarySkill KNOWLEDGE;
|
|
|
|
static const PrimarySkill BEGIN;
|
|
static const PrimarySkill END;
|
|
|
|
static const PrimarySkill EXPERIENCE;
|
|
|
|
static si32 decode(const std::string& identifier);
|
|
static std::string encode(const si32 index);
|
|
static std::string entityType();
|
|
};
|
|
|
|
class DLL_LINKAGE FactionID : public EntityIdentifier<FactionID>
|
|
{
|
|
public:
|
|
using EntityIdentifier<FactionID>::EntityIdentifier;
|
|
|
|
static const FactionID NONE;
|
|
static const FactionID DEFAULT;
|
|
static const FactionID RANDOM;
|
|
static const FactionID ANY;
|
|
static const FactionID CASTLE;
|
|
static const FactionID RAMPART;
|
|
static const FactionID TOWER;
|
|
static const FactionID INFERNO;
|
|
static const FactionID NECROPOLIS;
|
|
static const FactionID DUNGEON;
|
|
static const FactionID STRONGHOLD;
|
|
static const FactionID FORTRESS;
|
|
static const FactionID CONFLUX;
|
|
static const FactionID NEUTRAL;
|
|
|
|
static si32 decode(const std::string& identifier);
|
|
static std::string encode(const si32 index);
|
|
const CFaction * toFaction() const;
|
|
const Faction * toEntity(const Services * service) const;
|
|
static std::string entityType();
|
|
|
|
bool isValid() const
|
|
{
|
|
return getNum() >= 0;
|
|
}
|
|
};
|
|
|
|
class BuildingIDBase : public IdentifierBase
|
|
{
|
|
public:
|
|
//Quite useful as long as most of building mechanics hardcoded
|
|
// NOTE: all building with completely configurable mechanics will be removed from list
|
|
enum Type
|
|
{
|
|
DEFAULT = -50,
|
|
HORDE_PLACEHOLDER7 = -36,
|
|
HORDE_PLACEHOLDER6 = -35,
|
|
HORDE_PLACEHOLDER5 = -34,
|
|
HORDE_PLACEHOLDER4 = -33,
|
|
HORDE_PLACEHOLDER3 = -32,
|
|
HORDE_PLACEHOLDER2 = -31,
|
|
HORDE_PLACEHOLDER1 = -30,
|
|
NONE = -1,
|
|
FIRST_REGULAR_ID = 0,
|
|
MAGES_GUILD_1 = 0, MAGES_GUILD_2, MAGES_GUILD_3, MAGES_GUILD_4, MAGES_GUILD_5,
|
|
TAVERN, SHIPYARD, FORT, CITADEL, CASTLE,
|
|
VILLAGE_HALL, TOWN_HALL, CITY_HALL, CAPITOL, MARKETPLACE,
|
|
RESOURCE_SILO, BLACKSMITH, SPECIAL_1, HORDE_1, HORDE_1_UPGR,
|
|
SHIP, SPECIAL_2, SPECIAL_3, SPECIAL_4, HORDE_2,
|
|
HORDE_2_UPGR, GRAIL, EXTRA_TOWN_HALL, EXTRA_CITY_HALL, EXTRA_CAPITOL,
|
|
DWELL_FIRST=30, DWELL_LVL_2, DWELL_LVL_3, DWELL_LVL_4, DWELL_LVL_5, DWELL_LVL_6, DWELL_LAST=36,
|
|
DWELL_UP_FIRST=37, DWELL_LVL_2_UP, DWELL_LVL_3_UP, DWELL_LVL_4_UP, DWELL_LVL_5_UP,
|
|
DWELL_LVL_6_UP, DWELL_UP_LAST=43,
|
|
|
|
DWELL_LVL_1 = DWELL_FIRST,
|
|
DWELL_LVL_7 = DWELL_LAST,
|
|
DWELL_LVL_1_UP = DWELL_UP_FIRST,
|
|
DWELL_LVL_7_UP = DWELL_UP_LAST,
|
|
|
|
DWELL_UP2_FIRST = DWELL_LVL_7_UP + 1,
|
|
|
|
// //Special buildings for towns.
|
|
CASTLE_GATE = SPECIAL_3, //Inferno
|
|
FREELANCERS_GUILD = SPECIAL_2, //Stronghold
|
|
ARTIFACT_MERCHANT = SPECIAL_1,
|
|
|
|
};
|
|
|
|
bool IsSpecialOrGrail() const
|
|
{
|
|
return num == SPECIAL_1 || num == SPECIAL_2 || num == SPECIAL_3 || num == SPECIAL_4 || num == GRAIL;
|
|
}
|
|
};
|
|
|
|
class DLL_LINKAGE BuildingID : public StaticIdentifierWithEnum<BuildingID, BuildingIDBase>
|
|
{
|
|
public:
|
|
using StaticIdentifierWithEnum<BuildingID, BuildingIDBase>::StaticIdentifierWithEnum;
|
|
|
|
static BuildingID HALL_LEVEL(unsigned int level)
|
|
{
|
|
assert(level < 4);
|
|
return BuildingID(Type::VILLAGE_HALL + level);
|
|
}
|
|
static BuildingID FORT_LEVEL(unsigned int level)
|
|
{
|
|
assert(level < 3);
|
|
return BuildingID(Type::FORT + level);
|
|
}
|
|
|
|
static std::string encode(int32_t index);
|
|
static si32 decode(const std::string & identifier);
|
|
};
|
|
|
|
class MapObjectBaseID : public IdentifierBase
|
|
{
|
|
public:
|
|
enum Type
|
|
{
|
|
NO_OBJ = -1,
|
|
ALTAR_OF_SACRIFICE [[deprecated]] = 2,
|
|
ANCHOR_POINT = 3,
|
|
ARENA = 4,
|
|
ARTIFACT = 5,
|
|
PANDORAS_BOX = 6,
|
|
BLACK_MARKET [[deprecated]] = 7,
|
|
BOAT = 8,
|
|
BORDERGUARD = 9,
|
|
KEYMASTER = 10,
|
|
BUOY = 11,
|
|
CAMPFIRE = 12,
|
|
CARTOGRAPHER = 13,
|
|
SWAN_POND = 14,
|
|
COVER_OF_DARKNESS = 15,
|
|
CREATURE_BANK = 16,
|
|
CREATURE_GENERATOR1 = 17,
|
|
CREATURE_GENERATOR2 = 18,
|
|
CREATURE_GENERATOR3 = 19,
|
|
CREATURE_GENERATOR4 = 20,
|
|
CURSED_GROUND1 = 21,
|
|
CORPSE = 22,
|
|
MARLETTO_TOWER = 23,
|
|
DERELICT_SHIP = 24,
|
|
DRAGON_UTOPIA = 25,
|
|
EVENT = 26,
|
|
EYE_OF_MAGI = 27,
|
|
FAERIE_RING = 28,
|
|
FLOTSAM = 29,
|
|
FOUNTAIN_OF_FORTUNE = 30,
|
|
FOUNTAIN_OF_YOUTH = 31,
|
|
GARDEN_OF_REVELATION = 32,
|
|
GARRISON = 33,
|
|
HERO = 34,
|
|
HILL_FORT = 35,
|
|
GRAIL = 36,
|
|
HUT_OF_MAGI = 37,
|
|
IDOL_OF_FORTUNE = 38,
|
|
LEAN_TO = 39,
|
|
LIBRARY_OF_ENLIGHTENMENT = 41,
|
|
LIGHTHOUSE = 42,
|
|
MONOLITH_ONE_WAY_ENTRANCE = 43,
|
|
MONOLITH_ONE_WAY_EXIT = 44,
|
|
MONOLITH_TWO_WAY = 45,
|
|
MAGIC_PLAINS1 = 46,
|
|
SCHOOL_OF_MAGIC = 47,
|
|
MAGIC_SPRING = 48,
|
|
MAGIC_WELL = 49,
|
|
MARKET_OF_TIME = 50,
|
|
MERCENARY_CAMP = 51,
|
|
MERMAID = 52,
|
|
MINE = 53,
|
|
MONSTER = 54,
|
|
MYSTICAL_GARDEN = 55,
|
|
OASIS = 56,
|
|
OBELISK = 57,
|
|
REDWOOD_OBSERVATORY = 58,
|
|
OCEAN_BOTTLE = 59,
|
|
PILLAR_OF_FIRE = 60,
|
|
STAR_AXIS = 61,
|
|
PRISON = 62,
|
|
PYRAMID = 63,//subtype 0
|
|
WOG_OBJECT = 63,//subtype > 0
|
|
RALLY_FLAG = 64,
|
|
RANDOM_ART = 65,
|
|
RANDOM_TREASURE_ART = 66,
|
|
RANDOM_MINOR_ART = 67,
|
|
RANDOM_MAJOR_ART = 68,
|
|
RANDOM_RELIC_ART = 69,
|
|
RANDOM_HERO = 70,
|
|
RANDOM_MONSTER = 71,
|
|
RANDOM_MONSTER_L1 = 72,
|
|
RANDOM_MONSTER_L2 = 73,
|
|
RANDOM_MONSTER_L3 = 74,
|
|
RANDOM_MONSTER_L4 = 75,
|
|
RANDOM_RESOURCE = 76,
|
|
RANDOM_TOWN = 77,
|
|
REFUGEE_CAMP = 78,
|
|
RESOURCE = 79,
|
|
SANCTUARY = 80,
|
|
SCHOLAR = 81,
|
|
SEA_CHEST = 82,
|
|
SEER_HUT = 83,
|
|
CRYPT = 84,
|
|
SHIPWRECK = 85,
|
|
SHIPWRECK_SURVIVOR = 86,
|
|
SHIPYARD = 87,
|
|
SHRINE_OF_MAGIC_INCANTATION = 88,
|
|
SHRINE_OF_MAGIC_GESTURE = 89,
|
|
SHRINE_OF_MAGIC_THOUGHT = 90,
|
|
SIGN = 91,
|
|
SIRENS = 92,
|
|
SPELL_SCROLL = 93,
|
|
STABLES = 94,
|
|
TAVERN = 95,
|
|
TEMPLE = 96,
|
|
DEN_OF_THIEVES = 97,
|
|
TOWN = 98,
|
|
TRADING_POST [[deprecated]] = 99,
|
|
LEARNING_STONE = 100,
|
|
TREASURE_CHEST = 101,
|
|
TREE_OF_KNOWLEDGE = 102,
|
|
SUBTERRANEAN_GATE = 103,
|
|
UNIVERSITY [[deprecated]] = 104,
|
|
WAGON = 105,
|
|
WAR_MACHINE_FACTORY = 106,
|
|
SCHOOL_OF_WAR = 107,
|
|
WARRIORS_TOMB = 108,
|
|
WATER_WHEEL = 109,
|
|
WATERING_HOLE = 110,
|
|
WHIRLPOOL = 111,
|
|
WINDMILL = 112,
|
|
WITCH_HUT = 113,
|
|
BRUSH = 114, // TODO: How does it look like?
|
|
BUSH = 115,
|
|
CACTUS = 116,
|
|
CANYON = 117,
|
|
CRATER = 118,
|
|
DEAD_VEGETATION = 119,
|
|
FLOWERS = 120,
|
|
FROZEN_LAKE = 121,
|
|
HEDGE = 122,
|
|
HILL = 123,
|
|
HOLE = 124,
|
|
KELP = 125,
|
|
LAKE = 126,
|
|
LAVA_FLOW = 127,
|
|
LAVA_LAKE = 128,
|
|
MUSHROOMS = 129,
|
|
LOG = 130,
|
|
MANDRAKE = 131,
|
|
MOSS = 132,
|
|
MOUND = 133,
|
|
MOUNTAIN = 134,
|
|
OAK_TREES = 135,
|
|
OUTCROPPING = 136,
|
|
PINE_TREES = 137,
|
|
PLANT = 138,
|
|
RIVER_DELTA = 143,
|
|
ROCK = 147,
|
|
SAND_DUNE = 148,
|
|
SAND_PIT = 149,
|
|
SHRUB = 150,
|
|
SKULL = 151,
|
|
STALAGMITE = 152,
|
|
STUMP = 153,
|
|
TAR_PIT = 154,
|
|
TREES = 155,
|
|
VINE = 156,
|
|
VOLCANIC_VENT = 157,
|
|
VOLCANO = 158,
|
|
WILLOW_TREES = 159,
|
|
YUCCA_TREES = 160,
|
|
REEF = 161,
|
|
RANDOM_MONSTER_L5 = 162,
|
|
RANDOM_MONSTER_L6 = 163,
|
|
RANDOM_MONSTER_L7 = 164,
|
|
BORDER_GATE = 212,
|
|
FREELANCERS_GUILD [[deprecated]] = 213,
|
|
HERO_PLACEHOLDER = 214,
|
|
QUEST_GUARD = 215,
|
|
RANDOM_DWELLING = 216,
|
|
RANDOM_DWELLING_LVL = 217, //subtype = creature level
|
|
RANDOM_DWELLING_FACTION = 218, //subtype = faction
|
|
GARRISON2 = 219,
|
|
ABANDONED_MINE = 220,
|
|
TRADING_POST_SNOW [[deprecated]] = 221,
|
|
CLOVER_FIELD = 222,
|
|
CURSED_GROUND2 = 223,
|
|
EVIL_FOG = 224,
|
|
FAVORABLE_WINDS = 225,
|
|
FIERY_FIELDS = 226,
|
|
HOLY_GROUNDS = 227,
|
|
LUCID_POOLS = 228,
|
|
MAGIC_CLOUDS = 229,
|
|
MAGIC_PLAINS2 = 230,
|
|
ROCKLANDS = 231,
|
|
};
|
|
};
|
|
|
|
class DLL_LINKAGE MapObjectID : public EntityIdentifierWithEnum<MapObjectID, MapObjectBaseID>
|
|
{
|
|
public:
|
|
using EntityIdentifierWithEnum<MapObjectID, MapObjectBaseID>::EntityIdentifierWithEnum;
|
|
|
|
static std::string encode(int32_t index);
|
|
static si32 decode(const std::string & identifier);
|
|
|
|
// TODO: Remove
|
|
constexpr operator int32_t () const
|
|
{
|
|
return num;
|
|
}
|
|
};
|
|
|
|
class DLL_LINKAGE MapObjectSubID : public Identifier<MapObjectSubID>
|
|
{
|
|
public:
|
|
constexpr MapObjectSubID(const IdentifierBase & value):
|
|
Identifier<MapObjectSubID>(value.getNum())
|
|
{}
|
|
constexpr MapObjectSubID(int32_t value = -1):
|
|
Identifier<MapObjectSubID>(value)
|
|
{}
|
|
|
|
MapObjectSubID & operator =(int32_t value)
|
|
{
|
|
this->num = value;
|
|
return *this;
|
|
}
|
|
|
|
MapObjectSubID & operator =(const IdentifierBase & value)
|
|
{
|
|
this->num = value.getNum();
|
|
return *this;
|
|
}
|
|
|
|
static si32 decode(MapObjectID primaryID, const std::string & identifier);
|
|
static std::string encode(MapObjectID primaryID, si32 index);
|
|
|
|
// TODO: Remove
|
|
constexpr operator int32_t () const
|
|
{
|
|
return num;
|
|
}
|
|
|
|
template <typename Handler>
|
|
void serializeIdentifier(Handler &h, const MapObjectID & primaryID)
|
|
{
|
|
std::string secondaryStringID;
|
|
|
|
if (h.saving)
|
|
secondaryStringID = encode(primaryID, num);
|
|
|
|
h & secondaryStringID;
|
|
|
|
if (!h.saving)
|
|
num = decode(primaryID, secondaryStringID);
|
|
}
|
|
};
|
|
|
|
class DLL_LINKAGE RoadId : public EntityIdentifier<RoadId>
|
|
{
|
|
public:
|
|
using EntityIdentifier<RoadId>::EntityIdentifier;
|
|
static si32 decode(const std::string & identifier);
|
|
static std::string encode(const si32 index);
|
|
static std::string entityType();
|
|
|
|
static const RoadId NO_ROAD;
|
|
static const RoadId DIRT_ROAD;
|
|
static const RoadId GRAVEL_ROAD;
|
|
static const RoadId COBBLESTONE_ROAD;
|
|
|
|
const RoadType * toEntity(const Services * service) const;
|
|
};
|
|
|
|
class DLL_LINKAGE RiverId : public EntityIdentifier<RiverId>
|
|
{
|
|
public:
|
|
using EntityIdentifier<RiverId>::EntityIdentifier;
|
|
static si32 decode(const std::string & identifier);
|
|
static std::string encode(const si32 index);
|
|
static std::string entityType();
|
|
|
|
static const RiverId NO_RIVER;
|
|
static const RiverId WATER_RIVER;
|
|
static const RiverId ICY_RIVER;
|
|
static const RiverId MUD_RIVER;
|
|
static const RiverId LAVA_RIVER;
|
|
|
|
const RiverType * toEntity(const Services * service) const;
|
|
};
|
|
|
|
class DLL_LINKAGE EPathfindingLayerBase : public IdentifierBase
|
|
{
|
|
public:
|
|
enum Type : int32_t
|
|
{
|
|
LAND = 0, SAIL = 1, WATER, AIR, NUM_LAYERS, WRONG, AUTO
|
|
};
|
|
};
|
|
|
|
class EPathfindingLayer : public StaticIdentifierWithEnum<EPathfindingLayer, EPathfindingLayerBase>
|
|
{
|
|
public:
|
|
using StaticIdentifierWithEnum<EPathfindingLayer, EPathfindingLayerBase>::StaticIdentifierWithEnum;
|
|
};
|
|
|
|
class ArtifactPositionBase : public IdentifierBase
|
|
{
|
|
public:
|
|
enum Type
|
|
{
|
|
TRANSITION_POS = -3,
|
|
FIRST_AVAILABLE = -2,
|
|
PRE_FIRST = -1, //sometimes used as error, sometimes as first free in backpack
|
|
|
|
// Hero
|
|
HEAD, SHOULDERS, NECK, RIGHT_HAND, LEFT_HAND, TORSO, //5
|
|
RIGHT_RING, LEFT_RING, FEET, //8
|
|
MISC1, MISC2, MISC3, MISC4, //12
|
|
MACH1, MACH2, MACH3, MACH4, //16
|
|
SPELLBOOK, MISC5, //18
|
|
BACKPACK_START = 19,
|
|
|
|
// Creatures
|
|
CREATURE_SLOT = 0,
|
|
|
|
// Commander
|
|
COMMANDER1 = 0, COMMANDER2, COMMANDER3, COMMANDER4, COMMANDER5, COMMANDER6,
|
|
|
|
// Altar
|
|
ALTAR = BACKPACK_START
|
|
};
|
|
|
|
static_assert(MISC5 < BACKPACK_START, "incorrect number of artifact slots");
|
|
|
|
DLL_LINKAGE static si32 decode(const std::string & identifier);
|
|
DLL_LINKAGE static std::string encode(const si32 index);
|
|
};
|
|
|
|
class ArtifactPosition : public StaticIdentifierWithEnum<ArtifactPosition, ArtifactPositionBase>
|
|
{
|
|
public:
|
|
using StaticIdentifierWithEnum<ArtifactPosition, ArtifactPositionBase>::StaticIdentifierWithEnum;
|
|
|
|
// TODO: Remove
|
|
constexpr operator int32_t () const
|
|
{
|
|
return num;
|
|
}
|
|
};
|
|
|
|
class ArtifactIDBase : public IdentifierBase
|
|
{
|
|
public:
|
|
enum Type
|
|
{
|
|
NONE = -1,
|
|
SPELLBOOK = 0,
|
|
SPELL_SCROLL = 1,
|
|
GRAIL = 2,
|
|
CATAPULT = 3,
|
|
BALLISTA = 4,
|
|
AMMO_CART = 5,
|
|
FIRST_AID_TENT = 6,
|
|
VIAL_OF_DRAGON_BLOOD = 127,
|
|
ARMAGEDDONS_BLADE = 128,
|
|
ANGELIC_ALLIANCE = 129,
|
|
TITANS_THUNDER = 135,
|
|
ART_SELECTION = 144,
|
|
ART_LOCK = 145, // FIXME: We must get rid of this one since it's conflict with artifact from mods. See issue 2455
|
|
};
|
|
|
|
DLL_LINKAGE const CArtifact * toArtifact() const;
|
|
DLL_LINKAGE const Artifact * toEntity(const Services * service) const;
|
|
};
|
|
|
|
class ArtifactID : public EntityIdentifierWithEnum<ArtifactID, ArtifactIDBase>
|
|
{
|
|
public:
|
|
using EntityIdentifierWithEnum<ArtifactID, ArtifactIDBase>::EntityIdentifierWithEnum;
|
|
|
|
///json serialization helpers
|
|
DLL_LINKAGE static si32 decode(const std::string & identifier);
|
|
DLL_LINKAGE static std::string encode(const si32 index);
|
|
static std::string entityType();
|
|
};
|
|
|
|
class CreatureIDBase : public IdentifierBase
|
|
{
|
|
public:
|
|
enum Type
|
|
{
|
|
NONE = -1,
|
|
ARCHER = 2, // for debug / fallback
|
|
IMP = 42, // for Deity of Fire
|
|
FAMILIAR = 43, // for Deity of Fire
|
|
SKELETON = 56, // for Skeleton Transformer
|
|
BONE_DRAGON = 68, // for Skeleton Transformer
|
|
TROGLODYTES = 70, // for Abandoned Mine
|
|
MEDUSA = 76, // for Siege UI workaround
|
|
HYDRA = 110, // for Skeleton Transformer
|
|
CHAOS_HYDRA = 111, // for Skeleton Transformer
|
|
AIR_ELEMENTAL = 112, // for tests
|
|
FIRE_ELEMENTAL = 114, // for tests
|
|
PSYCHIC_ELEMENTAL = 120, // for hardcoded ability
|
|
MAGIC_ELEMENTAL = 121, // for hardcoded ability
|
|
AZURE_DRAGON = 132,
|
|
CATAPULT = 145,
|
|
BALLISTA = 146,
|
|
FIRST_AID_TENT = 147,
|
|
AMMO_CART = 148,
|
|
ARROW_TOWERS = 149
|
|
};
|
|
|
|
DLL_LINKAGE const CCreature * toCreature() const;
|
|
DLL_LINKAGE const Creature * toEntity(const Services * services) const;
|
|
DLL_LINKAGE const Creature * toEntity(const CreatureService * creatures) const;
|
|
};
|
|
|
|
class DLL_LINKAGE CreatureID : public EntityIdentifierWithEnum<CreatureID, CreatureIDBase>
|
|
{
|
|
public:
|
|
using EntityIdentifierWithEnum<CreatureID, CreatureIDBase>::EntityIdentifierWithEnum;
|
|
|
|
///json serialization helpers
|
|
static si32 decode(const std::string & identifier);
|
|
static std::string encode(const si32 index);
|
|
static std::string entityType();
|
|
};
|
|
|
|
class DLL_LINKAGE SpellIDBase : public IdentifierBase
|
|
{
|
|
public:
|
|
enum Type
|
|
{
|
|
// Special ID's
|
|
SPELLBOOK_PRESET = -3,
|
|
PRESET = -2,
|
|
NONE = -1,
|
|
|
|
// Adventure map spells
|
|
SUMMON_BOAT = 0,
|
|
SCUTTLE_BOAT = 1,
|
|
VISIONS = 2,
|
|
VIEW_EARTH = 3,
|
|
DISGUISE = 4,
|
|
VIEW_AIR = 5,
|
|
FLY = 6,
|
|
WATER_WALK = 7,
|
|
DIMENSION_DOOR = 8,
|
|
TOWN_PORTAL = 9,
|
|
|
|
// Combat spells
|
|
QUICKSAND = 10,
|
|
LAND_MINE = 11,
|
|
FORCE_FIELD = 12,
|
|
FIRE_WALL = 13,
|
|
EARTHQUAKE = 14,
|
|
MAGIC_ARROW = 15,
|
|
ICE_BOLT = 16,
|
|
LIGHTNING_BOLT = 17,
|
|
IMPLOSION = 18,
|
|
CHAIN_LIGHTNING = 19,
|
|
FROST_RING = 20,
|
|
FIREBALL = 21,
|
|
INFERNO = 22,
|
|
METEOR_SHOWER = 23,
|
|
DEATH_RIPPLE = 24,
|
|
DESTROY_UNDEAD = 25,
|
|
ARMAGEDDON = 26,
|
|
SHIELD = 27,
|
|
AIR_SHIELD = 28,
|
|
FIRE_SHIELD = 29,
|
|
PROTECTION_FROM_AIR = 30,
|
|
PROTECTION_FROM_FIRE = 31,
|
|
PROTECTION_FROM_WATER = 32,
|
|
PROTECTION_FROM_EARTH = 33,
|
|
ANTI_MAGIC = 34,
|
|
DISPEL = 35,
|
|
MAGIC_MIRROR = 36,
|
|
CURE = 37,
|
|
RESURRECTION = 38,
|
|
ANIMATE_DEAD = 39,
|
|
SACRIFICE = 40,
|
|
BLESS = 41,
|
|
CURSE = 42,
|
|
BLOODLUST = 43,
|
|
PRECISION = 44,
|
|
WEAKNESS = 45,
|
|
STONE_SKIN = 46,
|
|
DISRUPTING_RAY = 47,
|
|
PRAYER = 48,
|
|
MIRTH = 49,
|
|
SORROW = 50,
|
|
FORTUNE = 51,
|
|
MISFORTUNE = 52,
|
|
HASTE = 53,
|
|
SLOW = 54,
|
|
SLAYER = 55,
|
|
FRENZY = 56,
|
|
TITANS_LIGHTNING_BOLT = 57,
|
|
COUNTERSTRIKE = 58,
|
|
BERSERK = 59,
|
|
HYPNOTIZE = 60,
|
|
FORGETFULNESS = 61,
|
|
BLIND = 62,
|
|
TELEPORT = 63,
|
|
REMOVE_OBSTACLE = 64,
|
|
CLONE = 65,
|
|
SUMMON_FIRE_ELEMENTAL = 66,
|
|
SUMMON_EARTH_ELEMENTAL = 67,
|
|
SUMMON_WATER_ELEMENTAL = 68,
|
|
SUMMON_AIR_ELEMENTAL = 69,
|
|
|
|
// Creature abilities
|
|
STONE_GAZE = 70,
|
|
POISON = 71,
|
|
BIND = 72,
|
|
DISEASE = 73,
|
|
PARALYZE = 74,
|
|
AGE = 75,
|
|
DEATH_CLOUD = 76,
|
|
THUNDERBOLT = 77,
|
|
DISPEL_HELPFUL_SPELLS = 78,
|
|
DEATH_STARE = 79,
|
|
ACID_BREATH_DEFENSE = 80,
|
|
ACID_BREATH_DAMAGE = 81,
|
|
|
|
// Special ID's
|
|
FIRST_NON_SPELL = 70,
|
|
AFTER_LAST = 82
|
|
};
|
|
|
|
const CSpell * toSpell() const; //deprecated
|
|
const spells::Spell * toEntity(const Services * service) const;
|
|
const spells::Spell * toEntity(const spells::Service * service) const;
|
|
};
|
|
|
|
class DLL_LINKAGE SpellID : public EntityIdentifierWithEnum<SpellID, SpellIDBase>
|
|
{
|
|
public:
|
|
using EntityIdentifierWithEnum<SpellID, SpellIDBase>::EntityIdentifierWithEnum;
|
|
|
|
///json serialization helpers
|
|
static si32 decode(const std::string & identifier);
|
|
static std::string encode(const si32 index);
|
|
static std::string entityType();
|
|
};
|
|
|
|
class BattleFieldInfo;
|
|
class DLL_LINKAGE BattleField : public EntityIdentifier<BattleField>
|
|
{
|
|
public:
|
|
using EntityIdentifier<BattleField>::EntityIdentifier;
|
|
|
|
static const BattleField NONE;
|
|
const BattleFieldInfo * getInfo() const;
|
|
|
|
static si32 decode(const std::string & identifier);
|
|
static std::string encode(const si32 index);
|
|
};
|
|
|
|
class DLL_LINKAGE BoatId : public EntityIdentifier<BoatId>
|
|
{
|
|
public:
|
|
using EntityIdentifier<BoatId>::EntityIdentifier;
|
|
|
|
static si32 decode(const std::string & identifier);
|
|
static std::string encode(const si32 index);
|
|
|
|
static const BoatId NONE;
|
|
static const BoatId NECROPOLIS;
|
|
static const BoatId CASTLE;
|
|
static const BoatId FORTRESS;
|
|
};
|
|
|
|
class TerrainIdBase : public IdentifierBase
|
|
{
|
|
public:
|
|
enum Type : int32_t
|
|
{
|
|
NATIVE_TERRAIN = -4,
|
|
ANY_TERRAIN = -3,
|
|
NONE = -1,
|
|
FIRST_REGULAR_TERRAIN = 0,
|
|
DIRT = 0,
|
|
SAND,
|
|
GRASS,
|
|
SNOW,
|
|
SWAMP,
|
|
ROUGH,
|
|
SUBTERRANEAN,
|
|
LAVA,
|
|
WATER,
|
|
ROCK,
|
|
ORIGINAL_REGULAR_TERRAIN_COUNT = ROCK
|
|
};
|
|
};
|
|
|
|
class DLL_LINKAGE TerrainId : public EntityIdentifierWithEnum<TerrainId, TerrainIdBase>
|
|
{
|
|
public:
|
|
using EntityIdentifierWithEnum<TerrainId, TerrainIdBase>::EntityIdentifierWithEnum;
|
|
|
|
static si32 decode(const std::string & identifier);
|
|
static std::string encode(const si32 index);
|
|
static std::string entityType();
|
|
const TerrainType * toEntity(const Services * service) const;
|
|
};
|
|
|
|
class ObstacleInfo;
|
|
class Obstacle : public EntityIdentifier<Obstacle>
|
|
{
|
|
public:
|
|
using EntityIdentifier<Obstacle>::EntityIdentifier;
|
|
DLL_LINKAGE const ObstacleInfo * getInfo() const;
|
|
};
|
|
|
|
class DLL_LINKAGE SpellSchool : public StaticIdentifier<SpellSchool>
|
|
{
|
|
public:
|
|
using StaticIdentifier<SpellSchool>::StaticIdentifier;
|
|
|
|
static const SpellSchool ANY;
|
|
static const SpellSchool AIR;
|
|
static const SpellSchool FIRE;
|
|
static const SpellSchool WATER;
|
|
static const SpellSchool EARTH;
|
|
|
|
static si32 decode(const std::string & identifier);
|
|
static std::string encode(const si32 index);
|
|
static std::string entityType();
|
|
};
|
|
|
|
class GameResIDBase : public IdentifierBase
|
|
{
|
|
public:
|
|
enum Type : int32_t
|
|
{
|
|
WOOD = 0,
|
|
MERCURY,
|
|
ORE,
|
|
SULFUR,
|
|
CRYSTAL,
|
|
GEMS,
|
|
GOLD,
|
|
MITHRIL,
|
|
COUNT,
|
|
|
|
WOOD_AND_ORE = 127, // special case for town bonus resource
|
|
NONE = -1
|
|
};
|
|
};
|
|
|
|
class DLL_LINKAGE GameResID : public StaticIdentifierWithEnum<GameResID, GameResIDBase>
|
|
{
|
|
public:
|
|
using StaticIdentifierWithEnum<GameResID, GameResIDBase>::StaticIdentifierWithEnum;
|
|
|
|
static si32 decode(const std::string & identifier);
|
|
static std::string encode(const si32 index);
|
|
static std::string entityType();
|
|
|
|
static const std::array<GameResID, 7> & ALL_RESOURCES();
|
|
};
|
|
|
|
class DLL_LINKAGE BuildingTypeUniqueID : public Identifier<BuildingTypeUniqueID>
|
|
{
|
|
public:
|
|
BuildingTypeUniqueID(FactionID faction, BuildingID building );
|
|
|
|
static si32 decode(const std::string & identifier);
|
|
static std::string encode(const si32 index);
|
|
|
|
BuildingID getBuilding() const;
|
|
FactionID getFaction() const;
|
|
|
|
using Identifier<BuildingTypeUniqueID>::Identifier;
|
|
|
|
template <typename Handler>
|
|
void serialize(Handler & h)
|
|
{
|
|
FactionID faction = getFaction();
|
|
BuildingID building = getBuilding();
|
|
|
|
h & faction;
|
|
h & building;
|
|
|
|
if (!h.saving)
|
|
*this = BuildingTypeUniqueID(faction, building);
|
|
}
|
|
};
|
|
|
|
class DLL_LINKAGE CampaignScenarioID : public StaticIdentifier<CampaignScenarioID>
|
|
{
|
|
public:
|
|
using StaticIdentifier<CampaignScenarioID>::StaticIdentifier;
|
|
|
|
static si32 decode(const std::string & identifier);
|
|
static std::string encode(int32_t index);
|
|
|
|
static const CampaignScenarioID NONE;
|
|
};
|
|
|
|
// Deprecated
|
|
// TODO: remove
|
|
using Obj = MapObjectID;
|
|
using ETownType = FactionID;
|
|
using EGameResID = GameResID;
|
|
using River = RiverId;
|
|
using Road = RoadId;
|
|
using ETerrainId = TerrainId;
|
|
|
|
VCMI_LIB_NAMESPACE_END
|