games/vcmi
1
0
Fork 0
mirror of https://github.com/vcmi/vcmi.git synced 2024-11-28 08:48:48 +02:00
Code Issues Releases Activity
6522cec969
vcmi/lib/GameConstants.h

1399 lines
36 KiB
C++
Raw Blame History

/*
* GameConstants.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 "ConstTransitivePtr.h"
VCMI_LIB_NAMESPACE_BEGIN
class Artifact;
class ArtifactService;
class Creature;
class CreatureService;
namespace spells
{
class Spell;
class Service;
}
class CArtifact;
class CArtifactInstance;
class CCreature;
class CHero;
class CSpell;
class CSkill;
class CGameInfoCallback;
class CNonConstInfoCallback;
struct IdTag
{};
namespace GameConstants
{
DLL_LINKAGE extern const std::string VCMI_VERSION;
constexpr int PUZZLE_MAP_PIECES = 48;
constexpr int MAX_HEROES_PER_PLAYER = 8;
constexpr int AVAILABLE_HEROES_PER_PLAYER = 2;
constexpr int ALL_PLAYERS = 255; //bitfield
constexpr int CREATURES_PER_TOWN = 7; //without upgrades
constexpr int SPELL_LEVELS = 5;
constexpr int SPELL_SCHOOL_LEVELS = 4;
constexpr int DEFAULT_SCHOOLS = 4;
constexpr int CRE_LEVELS = 10; // number of creature experience levels
constexpr int HERO_GOLD_COST = 2500;
constexpr int SPELLBOOK_GOLD_COST = 500;
constexpr int SKILL_GOLD_COST = 2000;
constexpr int BATTLE_SHOOTING_PENALTY_DISTANCE = 10; //if the distance is > than this, then shooting stack has distance penalty
constexpr int BATTLE_SHOOTING_RANGE_DISTANCE = std::numeric_limits<uint8_t>::max(); // used when shooting stack has no shooting range limit
constexpr int ARMY_SIZE = 7;
constexpr int SKILL_PER_HERO = 8;
constexpr ui32 HERO_HIGH_LEVEL = 10; // affects primary skill upgrade order
constexpr int SKILL_QUANTITY=28;
constexpr int PRIMARY_SKILLS=4;
constexpr int RESOURCE_QUANTITY=8;
constexpr int HEROES_PER_TYPE=8; //amount of heroes of each type
// amounts of OH3 objects. Can be changed by mods, should be used only during H3 loading phase
constexpr int F_NUMBER = 9;
constexpr int ARTIFACTS_QUANTITY=171;
constexpr int HEROES_QUANTITY=156;
constexpr int SPELLS_QUANTITY=70;
constexpr int CREATURES_COUNT = 197;
constexpr ui32 BASE_MOVEMENT_COST = 100; //default cost for non-diagonal movement
constexpr int HERO_PORTRAIT_SHIFT = 9;// 2 special frames + 7 extra portraits
constexpr std::array<int, 11> POSSIBLE_TURNTIME = {1, 2, 4, 6, 8, 10, 15, 20, 25, 30, 0};
}
#define ID_LIKE_CLASS_COMMON(CLASS_NAME, ENUM_NAME) \
constexpr CLASS_NAME(const CLASS_NAME & other) = default; \
constexpr CLASS_NAME & operator=(const CLASS_NAME & other) = default; \
explicit constexpr CLASS_NAME(si32 id) \
: num(static_cast<ENUM_NAME>(id)) \
{} \
constexpr operator ENUM_NAME() const \
{ \
return num; \
} \
constexpr si32 getNum() const \
{ \
return static_cast<si32>(num); \
} \
constexpr ENUM_NAME toEnum() const \
{ \
return num; \
} \
template <typename Handler> void serialize(Handler &h, const int version) \
{ \
h & num; \
} \
constexpr CLASS_NAME & advance(int i) \
{ \
num = static_cast<ENUM_NAME>(static_cast<int>(num) + i); \
return *this; \
}
// Operators are performance-critical and to be inlined they must be in header
#define ID_LIKE_OPERATORS_INTERNAL(A, B, AN, BN) \
STRONG_INLINE constexpr bool operator==(const A & a, const B & b) \
{ \
return AN == BN ; \
} \
STRONG_INLINE constexpr bool operator!=(const A & a, const B & b) \
{ \
return AN != BN ; \
} \
STRONG_INLINE constexpr bool operator<(const A & a, const B & b) \
{ \
return AN < BN ; \
} \
STRONG_INLINE constexpr bool operator<=(const A & a, const B & b) \
{ \
return AN <= BN ; \
} \
STRONG_INLINE constexpr bool operator>(const A & a, const B & b) \
{ \
return AN > BN ; \
} \
STRONG_INLINE constexpr bool operator>=(const A & a, const B & b) \
{ \
return AN >= BN ; \
}
#define ID_LIKE_OPERATORS(CLASS_NAME, ENUM_NAME) \
ID_LIKE_OPERATORS_INTERNAL(CLASS_NAME, CLASS_NAME, a.num, b.num) \
ID_LIKE_OPERATORS_INTERNAL(CLASS_NAME, ENUM_NAME, a.num, b) \
ID_LIKE_OPERATORS_INTERNAL(ENUM_NAME, CLASS_NAME, a, b.num)
#define INSTID_LIKE_CLASS_COMMON(CLASS_NAME, NUMERIC_NAME) \
public: \
constexpr CLASS_NAME(const CLASS_NAME & other): \
BaseForID<CLASS_NAME, NUMERIC_NAME>(other) \
{ \
} \
constexpr CLASS_NAME & operator=(const CLASS_NAME & other) = default; \
constexpr CLASS_NAME & operator=(NUMERIC_NAME other) { num = other; return *this; }; \
explicit constexpr CLASS_NAME(si32 id = -1) \
: BaseForID<CLASS_NAME, NUMERIC_NAME>(id) \
{}
template < typename Derived, typename NumericType>
class BaseForID : public IdTag
{
protected:
NumericType num;
public:
constexpr NumericType getNum() const
{
return num;
}
//to make it more similar to IDLIKE
constexpr NumericType toEnum() const
{
return num;
}
template <typename Handler> void serialize(Handler &h, const int version)
{
h & num;
}
constexpr explicit BaseForID(NumericType _num = -1) :
num(_num)
{
}
constexpr void advance(int change)
{
num += change;
}
constexpr bool operator == (const BaseForID & b) const { return num == b.num; }
constexpr bool operator <= (const BaseForID & b) const { return num <= b.num; }
constexpr bool operator >= (const BaseForID & b) const { return num >= b.num; }
constexpr bool operator != (const BaseForID & b) const { return num != b.num; }
constexpr bool operator < (const BaseForID & b) const { return num < b.num; }
constexpr bool operator > (const BaseForID & b) const { return num > b.num; }
constexpr BaseForID & operator++() { ++num; return *this; }
constexpr operator NumericType() const
{
return num;
}
};
template < typename T>
class Identifier : public IdTag
{
public:
using EnumType = T;
using NumericType = typename std::underlying_type<EnumType>::type;
private:
NumericType num;
public:
constexpr NumericType getNum() const
{
return num;
}
constexpr EnumType toEnum() const
{
return static_cast<EnumType>(num);
}
template <typename Handler> void serialize(Handler &h, const int version)
{
h & num;
}
constexpr explicit Identifier(NumericType _num = -1)
{
num = _num;
}
/* implicit */constexpr Identifier(EnumType _num):
num(static_cast<NumericType>(_num))
{
}
constexpr void advance(int change)
{
num += change;
}
constexpr bool operator == (const Identifier & b) const { return num == b.num; }
constexpr bool operator <= (const Identifier & b) const { return num <= b.num; }
constexpr bool operator >= (const Identifier & b) const { return num >= b.num; }
constexpr bool operator != (const Identifier & b) const { return num != b.num; }
constexpr bool operator < (const Identifier & b) const { return num < b.num; }
constexpr bool operator > (const Identifier & b) const { return num > b.num; }
constexpr Identifier & operator++()
{
++num;
return *this;
}
constexpr Identifier operator++(int)
{
Identifier ret(*this);
++num;
return ret;
}
constexpr operator NumericType() const
{
return num;
}
};
template<typename Der, typename Num>
std::ostream & operator << (std::ostream & os, BaseForID<Der, Num> id);
template<typename Der, typename Num>
std::ostream & operator << (std::ostream & os, BaseForID<Der, Num> id)
{
//We use common type with short to force char and unsigned char to be promoted and formatted as numbers.
typedef typename std::common_type<short, Num>::type Number;
return os << static_cast<Number>(id.getNum());
}
template<typename EnumType>
std::ostream & operator << (std::ostream & os, Identifier<EnumType> id)
{
//We use common type with short to force char and unsigned char to be promoted and formatted as numbers.
typedef typename std::common_type<short, typename Identifier<EnumType>::NumericType>::type Number;
return os << static_cast<Number>(id.getNum());
}
class ArtifactInstanceID : public BaseForID<ArtifactInstanceID, si32>
{
INSTID_LIKE_CLASS_COMMON(ArtifactInstanceID, si32)
friend class CGameInfoCallback;
friend class CNonConstInfoCallback;
};
class QueryID : public BaseForID<QueryID, si32>
{
INSTID_LIKE_CLASS_COMMON(QueryID, si32)
QueryID & operator++()
{
++num;
return *this;
}
};
class ObjectInstanceID : public BaseForID<ObjectInstanceID, si32>
{
INSTID_LIKE_CLASS_COMMON(ObjectInstanceID, si32)
DLL_LINKAGE static const ObjectInstanceID NONE;
friend class CGameInfoCallback;
friend class CNonConstInfoCallback;
};
class HeroClassID : public BaseForID<HeroClassID, si32>
{
INSTID_LIKE_CLASS_COMMON(HeroClassID, si32)
};
class HeroTypeID : public BaseForID<HeroTypeID, si32>
{
INSTID_LIKE_CLASS_COMMON(HeroTypeID, si32)
///json serialization helpers
static si32 decode(const std::string & identifier);
static std::string encode(const si32 index);
DLL_LINKAGE static const HeroTypeID NONE;
};
class SlotID : public BaseForID<SlotID, si32>
{
INSTID_LIKE_CLASS_COMMON(SlotID, si32)
friend class CGameInfoCallback;
friend class CNonConstInfoCallback;
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 PlayerColor : public BaseForID<PlayerColor, ui8>
{
INSTID_LIKE_CLASS_COMMON(PlayerColor, ui8)
enum EPlayerColor
{
PLAYER_LIMIT_I = 8,
};
using Mask = uint8_t;
DLL_LINKAGE static const PlayerColor SPECTATOR; //252
DLL_LINKAGE static const PlayerColor CANNOT_DETERMINE; //253
DLL_LINKAGE static const PlayerColor UNFLAGGABLE; //254 - neutral objects (pandora, banks)
DLL_LINKAGE static const PlayerColor NEUTRAL; //255
DLL_LINKAGE static const PlayerColor PLAYER_LIMIT; //player limit per map
DLL_LINKAGE bool isValidPlayer() const; //valid means < PLAYER_LIMIT (especially non-neutral)
DLL_LINKAGE bool isSpectator() const;
DLL_LINKAGE std::string getStr(bool L10n = false) const;
DLL_LINKAGE std::string getStrCap(bool L10n = false) const;
friend class CGameInfoCallback;
friend class CNonConstInfoCallback;
};
class TeamID : public BaseForID<TeamID, ui8>
{
INSTID_LIKE_CLASS_COMMON(TeamID, ui8)
DLL_LINKAGE static const TeamID NO_TEAM;
friend class CGameInfoCallback;
friend class CNonConstInfoCallback;
};
class TeleportChannelID : public BaseForID<TeleportChannelID, si32>
{
INSTID_LIKE_CLASS_COMMON(TeleportChannelID, si32)
friend class CGameInfoCallback;
friend class CNonConstInfoCallback;
};
// #ifndef INSTANTIATE_BASE_FOR_ID_HERE
// extern template std::ostream & operator << <ArtifactInstanceID>(std::ostream & os, BaseForID<ArtifactInstanceID> id);
// extern template std::ostream & operator << <ObjectInstanceID>(std::ostream & os, BaseForID<ObjectInstanceID> id);
// #endif
// Enum declarations
namespace PrimarySkill
{
enum PrimarySkill : int8_t { NONE = -1, ATTACK, DEFENSE, SPELL_POWER, KNOWLEDGE,
EXPERIENCE = 4}; //for some reason changePrimSkill uses it
}
class SecondarySkill
{
public:
enum ESecondarySkill
{
WRONG = -2,
DEFAULT = -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");
SecondarySkill(ESecondarySkill _num = WRONG) : num(_num)
{}
ID_LIKE_CLASS_COMMON(SecondarySkill, ESecondarySkill)
ESecondarySkill num;
};
ID_LIKE_OPERATORS(SecondarySkill, SecondarySkill::ESecondarySkill)
enum class EAlignment : uint8_t { GOOD, EVIL, NEUTRAL };
namespace ETownType//deprecated
{
enum ETownType
{
ANY = -1,
CASTLE, RAMPART, TOWER, INFERNO, NECROPOLIS, DUNGEON, STRONGHOLD, FORTRESS, CONFLUX, NEUTRAL
};
}
class FactionID : public BaseForID<FactionID, int32_t>
{
INSTID_LIKE_CLASS_COMMON(FactionID, si32)
DLL_LINKAGE static const FactionID NONE;
DLL_LINKAGE static const FactionID DEFAULT;
DLL_LINKAGE static const FactionID CASTLE;
DLL_LINKAGE static const FactionID RAMPART;
DLL_LINKAGE static const FactionID TOWER;
DLL_LINKAGE static const FactionID INFERNO;
DLL_LINKAGE static const FactionID NECROPOLIS;
DLL_LINKAGE static const FactionID DUNGEON;
DLL_LINKAGE static const FactionID STRONGHOLD;
DLL_LINKAGE static const FactionID FORTRESS;
DLL_LINKAGE static const FactionID CONFLUX;
DLL_LINKAGE static const FactionID NEUTRAL;
static si32 decode(const std::string& identifier);
static std::string encode(const si32 index);
static std::string entityType();
};
class TerrainID
{
//Dummy class used only for serialization
public:
static si32 decode(const std::string & identifier);
static std::string encode(const si32 index);
static std::string entityType();
};
class BuildingID
{
public:
//Quite useful as long as most of building mechanics hardcoded
// NOTE: all building with completely configurable mechanics will be removed from list
enum EBuildingID
{
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,
//Special buildings for towns.
LIGHTHOUSE = SPECIAL_1,
STABLES = SPECIAL_2, //Castle
BROTHERHOOD = SPECIAL_3,
MYSTIC_POND = SPECIAL_1,
FOUNTAIN_OF_FORTUNE = SPECIAL_2, //Rampart
TREASURY = SPECIAL_3,
ARTIFACT_MERCHANT = SPECIAL_1,
LOOKOUT_TOWER = SPECIAL_2, //Tower
LIBRARY = SPECIAL_3,
WALL_OF_KNOWLEDGE = SPECIAL_4,
STORMCLOUDS = SPECIAL_2,
CASTLE_GATE = SPECIAL_3, //Inferno
ORDER_OF_FIRE = SPECIAL_4,
COVER_OF_DARKNESS = SPECIAL_1,
NECROMANCY_AMPLIFIER = SPECIAL_2, //Necropolis
SKELETON_TRANSFORMER = SPECIAL_3,
//ARTIFACT_MERCHANT - same ID as in tower
MANA_VORTEX = SPECIAL_2,
PORTAL_OF_SUMMON = SPECIAL_3, //Dungeon
BATTLE_ACADEMY = SPECIAL_4,
ESCAPE_TUNNEL = SPECIAL_1,
FREELANCERS_GUILD = SPECIAL_2, //Stronghold
BALLISTA_YARD = SPECIAL_3,
HALL_OF_VALHALLA = SPECIAL_4,
CAGE_OF_WARLORDS = SPECIAL_1,
GLYPHS_OF_FEAR = SPECIAL_2, // Fortress
BLOOD_OBELISK = SPECIAL_3,
//ARTIFACT_MERCHANT - same ID as in tower
MAGIC_UNIVERSITY = SPECIAL_2, // Conflux
};
BuildingID(EBuildingID _num = NONE) : num(_num)
{}
STRONG_INLINE
bool IsSpecialOrGrail() const
{
return num == SPECIAL_1 || num == SPECIAL_2 || num == SPECIAL_3 || num == SPECIAL_4 || num == GRAIL;
}
ID_LIKE_CLASS_COMMON(BuildingID, EBuildingID)
EBuildingID num;
};
ID_LIKE_OPERATORS(BuildingID, BuildingID::EBuildingID)
namespace BuildingSubID
{
enum EBuildingSubID
{
DEFAULT = -50,
NONE = -1,
STABLES,
BROTHERHOOD_OF_SWORD,
CASTLE_GATE,
CREATURE_TRANSFORMER,
MYSTIC_POND,
FOUNTAIN_OF_FORTUNE,
ARTIFACT_MERCHANT,
LOOKOUT_TOWER,
LIBRARY,
MANA_VORTEX,
PORTAL_OF_SUMMONING,
ESCAPE_TUNNEL,
FREELANCERS_GUILD,
BALLISTA_YARD,
ATTACK_VISITING_BONUS,
MAGIC_UNIVERSITY,
SPELL_POWER_GARRISON_BONUS,
ATTACK_GARRISON_BONUS,
DEFENSE_GARRISON_BONUS,
DEFENSE_VISITING_BONUS,
SPELL_POWER_VISITING_BONUS,
KNOWLEDGE_VISITING_BONUS,
EXPERIENCE_VISITING_BONUS,
LIGHTHOUSE,
TREASURY,
CUSTOM_VISITING_BONUS,
CUSTOM_VISITING_REWARD
};
}
namespace EMarketMode
{
enum EMarketMode
{
RESOURCE_RESOURCE, RESOURCE_PLAYER, CREATURE_RESOURCE, RESOURCE_ARTIFACT,
ARTIFACT_RESOURCE, ARTIFACT_EXP, CREATURE_EXP, CREATURE_UNDEAD, RESOURCE_SKILL,
MARTKET_AFTER_LAST_PLACEHOLDER
};
}
namespace MappedKeys
{
static const std::map<std::string, BuildingID> BUILDING_NAMES_TO_TYPES =
{
{ "special1", BuildingID::SPECIAL_1 },
{ "special2", BuildingID::SPECIAL_2 },
{ "special3", BuildingID::SPECIAL_3 },
{ "special4", BuildingID::SPECIAL_4 },
{ "grail", BuildingID::GRAIL },
{ "mageGuild1", BuildingID::MAGES_GUILD_1 },
{ "mageGuild2", BuildingID::MAGES_GUILD_2 },
{ "mageGuild3", BuildingID::MAGES_GUILD_3 },
{ "mageGuild4", BuildingID::MAGES_GUILD_4 },
{ "mageGuild5", BuildingID::MAGES_GUILD_5 },
{ "tavern", BuildingID::TAVERN },
{ "shipyard", BuildingID::SHIPYARD },
{ "fort", BuildingID::FORT },
{ "citadel", BuildingID::CITADEL },
{ "castle", BuildingID::CASTLE },
{ "villageHall", BuildingID::VILLAGE_HALL },
{ "townHall", BuildingID::TOWN_HALL },
{ "cityHall", BuildingID::CITY_HALL },
{ "capitol", BuildingID::CAPITOL },
{ "marketplace", BuildingID::MARKETPLACE },
{ "resourceSilo", BuildingID::RESOURCE_SILO },
{ "blacksmith", BuildingID::BLACKSMITH },
{ "horde1", BuildingID::HORDE_1 },
{ "horde1Upgr", BuildingID::HORDE_1_UPGR },
{ "horde2", BuildingID::HORDE_2 },
{ "horde2Upgr", BuildingID::HORDE_2_UPGR },
{ "ship", BuildingID::SHIP },
{ "dwellingLvl1", BuildingID::DWELL_LVL_1 },
{ "dwellingLvl2", BuildingID::DWELL_LVL_2 },
{ "dwellingLvl3", BuildingID::DWELL_LVL_3 },
{ "dwellingLvl4", BuildingID::DWELL_LVL_4 },
{ "dwellingLvl5", BuildingID::DWELL_LVL_5 },
{ "dwellingLvl6", BuildingID::DWELL_LVL_6 },
{ "dwellingLvl7", BuildingID::DWELL_LVL_7 },
{ "dwellingUpLvl1", BuildingID::DWELL_LVL_1_UP },
{ "dwellingUpLvl2", BuildingID::DWELL_LVL_2_UP },
{ "dwellingUpLvl3", BuildingID::DWELL_LVL_3_UP },
{ "dwellingUpLvl4", BuildingID::DWELL_LVL_4_UP },
{ "dwellingUpLvl5", BuildingID::DWELL_LVL_5_UP },
{ "dwellingUpLvl6", BuildingID::DWELL_LVL_6_UP },
{ "dwellingUpLvl7", BuildingID::DWELL_LVL_7_UP },
};
static const std::map<std::string, BuildingSubID::EBuildingSubID> SPECIAL_BUILDINGS =
{
{ "mysticPond", BuildingSubID::MYSTIC_POND },
{ "artifactMerchant", BuildingSubID::ARTIFACT_MERCHANT },
{ "freelancersGuild", BuildingSubID::FREELANCERS_GUILD },
{ "magicUniversity", BuildingSubID::MAGIC_UNIVERSITY },
{ "castleGate", BuildingSubID::CASTLE_GATE },
{ "creatureTransformer", BuildingSubID::CREATURE_TRANSFORMER },//only skeleton transformer yet
{ "portalOfSummoning", BuildingSubID::PORTAL_OF_SUMMONING },
{ "ballistaYard", BuildingSubID::BALLISTA_YARD },
{ "stables", BuildingSubID::STABLES },
{ "manaVortex", BuildingSubID::MANA_VORTEX },
{ "lookoutTower", BuildingSubID::LOOKOUT_TOWER },
{ "library", BuildingSubID::LIBRARY },
{ "brotherhoodOfSword", BuildingSubID::BROTHERHOOD_OF_SWORD },//morale garrison bonus
{ "fountainOfFortune", BuildingSubID::FOUNTAIN_OF_FORTUNE },//luck garrison bonus
{ "spellPowerGarrisonBonus", BuildingSubID::SPELL_POWER_GARRISON_BONUS },//such as 'stormclouds', but this name is not ok for good towns
{ "attackGarrisonBonus", BuildingSubID::ATTACK_GARRISON_BONUS },
{ "defenseGarrisonBonus", BuildingSubID::DEFENSE_GARRISON_BONUS },
{ "escapeTunnel", BuildingSubID::ESCAPE_TUNNEL },
{ "attackVisitingBonus", BuildingSubID::ATTACK_VISITING_BONUS },
{ "defenceVisitingBonus", BuildingSubID::DEFENSE_VISITING_BONUS },
{ "spellPowerVisitingBonus", BuildingSubID::SPELL_POWER_VISITING_BONUS },
{ "knowledgeVisitingBonus", BuildingSubID::KNOWLEDGE_VISITING_BONUS },
{ "experienceVisitingBonus", BuildingSubID::EXPERIENCE_VISITING_BONUS },
{ "lighthouse", BuildingSubID::LIGHTHOUSE },
{ "treasury", BuildingSubID::TREASURY }
};
static const std::map<std::string, EMarketMode::EMarketMode> MARKET_NAMES_TO_TYPES =
{
{ "resource-resource", EMarketMode::RESOURCE_RESOURCE },
{ "resource-player", EMarketMode::RESOURCE_PLAYER },
{ "creature-resource", EMarketMode::CREATURE_RESOURCE },
{ "resource-artifact", EMarketMode::RESOURCE_ARTIFACT },
{ "artifact-resource", EMarketMode::ARTIFACT_RESOURCE },
{ "artifact-experience", EMarketMode::ARTIFACT_EXP },
{ "creature-experience", EMarketMode::CREATURE_EXP },
{ "creature-undead", EMarketMode::CREATURE_UNDEAD },
{ "resource-skill", EMarketMode::RESOURCE_SKILL },
};
}
namespace EAiTactic
{
enum EAiTactic
{
NONE = -1,
RANDOM,
WARRIOR,
BUILDER,
EXPLORER
};
}
namespace EBuildingState
{
enum EBuildingState
{
HAVE_CAPITAL, NO_WATER, FORBIDDEN, ADD_MAGES_GUILD, ALREADY_PRESENT, CANT_BUILD_TODAY,
NO_RESOURCES, ALLOWED, PREREQUIRES, MISSING_BASE, BUILDING_ERROR, TOWN_NOT_OWNED
};
}
namespace ESpellCastProblem
{
enum ESpellCastProblem
{
OK, NO_HERO_TO_CAST_SPELL, CASTS_PER_TURN_LIMIT, NO_SPELLBOOK,
HERO_DOESNT_KNOW_SPELL, NOT_ENOUGH_MANA, ADVMAP_SPELL_INSTEAD_OF_BATTLE_SPELL,
SPELL_LEVEL_LIMIT_EXCEEDED, NO_SPELLS_TO_DISPEL,
NO_APPROPRIATE_TARGET, STACK_IMMUNE_TO_SPELL, WRONG_SPELL_TARGET, ONGOING_TACTIC_PHASE,
MAGIC_IS_BLOCKED, //For Orb of Inhibition and similar - no casting at all
INVALID
};
}
namespace ECommander
{
enum SecondarySkills {ATTACK, DEFENSE, HEALTH, DAMAGE, SPEED, SPELL_POWER, CASTS, RESISTANCE};
const int MAX_SKILL_LEVEL = 5;
}
enum class EWallPart : int8_t
{
INDESTRUCTIBLE_PART_OF_GATE = -3, INDESTRUCTIBLE_PART = -2, INVALID = -1,
KEEP = 0, BOTTOM_TOWER, BOTTOM_WALL, BELOW_GATE, OVER_GATE, UPPER_WALL, UPPER_TOWER, GATE,
PARTS_COUNT /* This constant SHOULD always stay as the last item in the enum. */
};
enum class EWallState : int8_t
{
NONE = -1, //no wall
DESTROYED,
DAMAGED,
INTACT,
REINFORCED, // walls in towns with castle
};
enum class EGateState : uint8_t
{
NONE,
CLOSED,
BLOCKED, // gate is blocked in closed state, e.g. by creature
OPENED,
DESTROYED
};
namespace ESiegeHex
{
enum ESiegeHex : si16
{
DESTRUCTIBLE_WALL_1 = 29,
DESTRUCTIBLE_WALL_2 = 78,
DESTRUCTIBLE_WALL_3 = 130,
DESTRUCTIBLE_WALL_4 = 182,
GATE_BRIDGE = 94,
GATE_OUTER = 95,
GATE_INNER = 96
};
}
namespace ETileType
{
enum ETileType
{
FREE,
POSSIBLE,
BLOCKED,
USED
};
}
enum class ETeleportChannelType
{
IMPASSABLE,
BIDIRECTIONAL,
UNIDIRECTIONAL,
MIXED
};
class Obj
{
public:
enum EObj
{
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,
};
Obj(EObj _num = NO_OBJ) : num(_num)
{}
ID_LIKE_CLASS_COMMON(Obj, EObj)
EObj num;
};
ID_LIKE_OPERATORS(Obj, Obj::EObj)
enum class Road : int8_t
{
NO_ROAD = 0,
FIRST_REGULAR_ROAD = 1,
DIRT_ROAD = 1,
GRAVEL_ROAD = 2,
COBBLESTONE_ROAD = 3,
ORIGINAL_ROAD_COUNT //+1
};
enum class River : int8_t
{
NO_RIVER = 0,
FIRST_REGULAR_RIVER = 1,
WATER_RIVER = 1,
ICY_RIVER = 2,
MUD_RIVER = 3,
LAVA_RIVER = 4,
ORIGINAL_RIVER_COUNT //+1
};
namespace SecSkillLevel
{
enum SecSkillLevel
{
NONE,
BASIC,
ADVANCED,
EXPERT,
LEVELS_SIZE
};
}
namespace Date
{
enum EDateType
{
DAY = 0,
DAY_OF_WEEK = 1,
WEEK = 2,
MONTH = 3,
DAY_OF_MONTH
};
}
enum class EActionType : int32_t
{
CANCEL = -3,
END_TACTIC_PHASE = -2,
INVALID = -1,
NO_ACTION = 0,
HERO_SPELL,
WALK,
DEFEND,
RETREAT,
SURRENDER,
WALK_AND_ATTACK,
SHOOT,
WAIT,
CATAPULT,
MONSTER_SPELL,
BAD_MORALE,
STACK_HEAL,
};
DLL_LINKAGE std::ostream & operator<<(std::ostream & os, const EActionType actionType);
class DLL_LINKAGE EDiggingStatus
{
public:
enum EEDiggingStatus
{
UNKNOWN = -1,
CAN_DIG = 0,
LACK_OF_MOVEMENT,
WRONG_TERRAIN,
TILE_OCCUPIED,
BACKPACK_IS_FULL
};
EDiggingStatus(EEDiggingStatus _num = UNKNOWN) : num(_num)
{}
ID_LIKE_CLASS_COMMON(EDiggingStatus, EEDiggingStatus)
EEDiggingStatus num;
};
ID_LIKE_OPERATORS(EDiggingStatus, EDiggingStatus::EEDiggingStatus)
class DLL_LINKAGE EPathfindingLayer
{
public:
enum EEPathfindingLayer : ui8
{
LAND = 0, SAIL = 1, WATER, AIR, NUM_LAYERS, WRONG, AUTO
};
EPathfindingLayer(EEPathfindingLayer _num = WRONG) : num(_num)
{}
ID_LIKE_CLASS_COMMON(EPathfindingLayer, EEPathfindingLayer)
EEPathfindingLayer num;
};
DLL_LINKAGE std::ostream & operator<<(std::ostream & os, const EPathfindingLayer & pathfindingLayer);
ID_LIKE_OPERATORS(EPathfindingLayer, EPathfindingLayer::EEPathfindingLayer)
namespace EPlayerStatus
{
enum EStatus {WRONG = -1, INGAME, LOSER, WINNER};
}
namespace PlayerRelations
{
enum PlayerRelations {ENEMIES, ALLIES, SAME_PLAYER};
}
class ArtifactPosition
{
public:
enum EArtifactPosition
{
TRANSITION_POS = -3,
FIRST_AVAILABLE = -2,
PRE_FIRST = -1, //sometimes used as error, sometimes as first free in backpack
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
AFTER_LAST,
//cres
CREATURE_SLOT = 0,
COMMANDER1 = 0, COMMANDER2, COMMANDER3, COMMANDER4, COMMANDER5, COMMANDER6, COMMANDER_AFTER_LAST
};
static_assert (AFTER_LAST == 19, "incorrect number of artifact slots");
ArtifactPosition(EArtifactPosition _num = PRE_FIRST) : num(_num)
{}
ArtifactPosition(std::string slotName);
ID_LIKE_CLASS_COMMON(ArtifactPosition, EArtifactPosition)
EArtifactPosition num;
STRONG_INLINE EArtifactPosition operator+(const int arg)
{
return EArtifactPosition(static_cast<int>(num) + arg);
}
STRONG_INLINE EArtifactPosition operator+(const EArtifactPosition & arg)
{
return EArtifactPosition(static_cast<int>(num) + static_cast<int>(arg));
}
};
ID_LIKE_OPERATORS(ArtifactPosition, ArtifactPosition::EArtifactPosition)
namespace GameConstants
{
const auto BACKPACK_START = ArtifactPosition::AFTER_LAST;
}
class ArtifactID
{
public:
enum EArtifactID
{
NONE = -1,
SPELLBOOK = 0,
SPELL_SCROLL = 1,
GRAIL = 2,
CATAPULT = 3,
BALLISTA = 4,
AMMO_CART = 5,
FIRST_AID_TENT = 6,
//CENTAUR_AXE = 7,
//BLACKSHARD_OF_THE_DEAD_KNIGHT = 8,
VIAL_OF_DRAGON_BLOOD = 127,
ARMAGEDDONS_BLADE = 128,
TITANS_THUNDER = 135,
//CORNUCOPIA = 140,
//FIXME: the following is only true if WoG is enabled. Otherwise other mod artifacts will take these slots.
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
AXE_OF_SMASHING = 146,
MITHRIL_MAIL = 147,
SWORD_OF_SHARPNESS = 148,
HELM_OF_IMMORTALITY = 149,
PENDANT_OF_SORCERY = 150,
BOOTS_OF_HASTE = 151,
BOW_OF_SEEKING = 152,
DRAGON_EYE_RING = 153
//HARDENED_SHIELD = 154,
//SLAVAS_RING_OF_POWER = 155
};
ArtifactID(EArtifactID _num = NONE) : num(_num)
{}
DLL_LINKAGE const CArtifact * toArtifact() const;
DLL_LINKAGE const Artifact * toArtifact(const ArtifactService * service) const;
///json serialization helpers
static si32 decode(const std::string & identifier);
static std::string encode(const si32 index);
ID_LIKE_CLASS_COMMON(ArtifactID, EArtifactID)
EArtifactID num;
struct hash
{
size_t operator()(const ArtifactID & aid) const
{
return std::hash<int>()(aid.num);
}
};
};
ID_LIKE_OPERATORS(ArtifactID, ArtifactID::EArtifactID)
class CreatureID
{
public:
enum ECreatureID
{
NONE = -1,
ARCHER = 2,
CAVALIER = 10,
CHAMPION = 11,
STONE_GOLEM = 32,
IRON_GOLEM = 33,
IMP = 42,
SKELETON = 56,
WALKING_DEAD = 58,
WIGHTS = 60,
LICHES = 64,
BONE_DRAGON = 68,
TROGLODYTES = 70,
MEDUSA = 76,
HYDRA = 110,
CHAOS_HYDRA = 111,
AIR_ELEMENTAL = 112,
EARTH_ELEMENTAL = 113,
FIRE_ELEMENTAL = 114,
WATER_ELEMENTAL = 115,
GOLD_GOLEM = 116,
DIAMOND_GOLEM = 117,
PSYCHIC_ELEMENTAL = 120,
MAGIC_ELEMENTAL = 121,
CATAPULT = 145,
BALLISTA = 146,
FIRST_AID_TENT = 147,
AMMO_CART = 148,
ARROW_TOWERS = 149
};
CreatureID(ECreatureID _num = NONE) : num(_num)
{}
DLL_LINKAGE const CCreature * toCreature() const;
DLL_LINKAGE const Creature * toCreature(const CreatureService * creatures) const;
ID_LIKE_CLASS_COMMON(CreatureID, ECreatureID)
ECreatureID num;
///json serialization helpers
static si32 decode(const std::string & identifier);
static std::string encode(const si32 index);
};
ID_LIKE_OPERATORS(CreatureID, CreatureID::ECreatureID)
class SpellID
{
public:
enum ESpellID
{
SPELLBOOK_PRESET = -3,
PRESET = -2,
NONE = -1,
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,
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,
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,
FIRST_NON_SPELL = 70, AFTER_LAST = 82
};
SpellID(ESpellID _num = NONE) : num(_num)
{}
DLL_LINKAGE const CSpell * toSpell() const; //deprecated
DLL_LINKAGE const spells::Spell * toSpell(const spells::Service * service) const;
ID_LIKE_CLASS_COMMON(SpellID, ESpellID)
ESpellID num;
///json serialization helpers
static si32 decode(const std::string & identifier);
static std::string encode(const si32 index);
};
ID_LIKE_OPERATORS(SpellID, SpellID::ESpellID)
class BattleFieldInfo;
class BattleField : public BaseForID<BattleField, si32>
{
INSTID_LIKE_CLASS_COMMON(BattleField, si32)
DLL_LINKAGE static const BattleField NONE;
DLL_LINKAGE friend bool operator==(const BattleField & l, const BattleField & r);
DLL_LINKAGE friend bool operator!=(const BattleField & l, const BattleField & r);
DLL_LINKAGE friend bool operator<(const BattleField & l, const BattleField & r);
DLL_LINKAGE operator std::string() const;
DLL_LINKAGE const BattleFieldInfo * getInfo() const;
DLL_LINKAGE static BattleField fromString(const std::string & identifier);
};
enum class EBoatId : int32_t
{
NONE = -1,
NECROPOLIS = 0,
CASTLE,
FORTRESS
};
using BoatId = Identifier<EBoatId>;
enum class ETerrainId {
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
};
using TerrainId = Identifier<ETerrainId>;
using RoadId = Identifier<Road>;
using RiverId = Identifier<River>;
class ObstacleInfo;
class Obstacle : public BaseForID<Obstacle, si32>
{
INSTID_LIKE_CLASS_COMMON(Obstacle, si32)
DLL_LINKAGE const ObstacleInfo * getInfo() const;
DLL_LINKAGE operator std::string() const;
DLL_LINKAGE static Obstacle fromString(const std::string & identifier);
};
enum class ESpellSchool: int8_t
{
ANY = -1,
AIR = 0,
FIRE = 1,
WATER = 2,
EARTH = 3,
};
using SpellSchool = Identifier<ESpellSchool>;
enum class EMetaclass: ui8
{
INVALID = 0,
ARTIFACT,
CREATURE,
FACTION,
EXPERIENCE,
HERO,
HEROCLASS,
LUCK,
MANA,
MORALE,
MOVEMENT,
OBJECT,
PRIMARY_SKILL,
SECONDARY_SKILL,
SPELL,
RESOURCE
};
enum class EHealLevel: ui8
{
HEAL,
RESURRECT,
OVERHEAL
};
enum class EHealPower : ui8
{
ONE_BATTLE,
PERMANENT
};
// Typedef declarations
using TExpType = si64;
using TQuantity = si32;
using TRmgTemplateZoneId = int;
#undef ID_LIKE_CLASS_COMMON
#undef ID_LIKE_OPERATORS
#undef ID_LIKE_OPERATORS_INTERNAL
#undef INSTID_LIKE_CLASS_COMMON
VCMI_LIB_NAMESPACE_END
Reference in New Issue View Git Blame Copy Permalink