vcmi/lib/constants/EntityIdentifiers.h

/*
 * 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,
		HOLE = 124,
		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