HeroBonus.h 38 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797798799800801802803804805806807808809810811812813814815816817818819820821822823824825826827828829830831832833834835836837838839840841842843844845846847848849850851852853854855856857858859860861862863864865866867868869870871872873874875876877878879880881882883884885886887888889890891892893894895896897898899900901902903904905906907908909910911912913914915916917918919920921922923924925926927928929930931932933934935936937938939940941942943944945946947948949950951952953954955956957958959960961962963964965966967968969970971972973974975976977978979980981982983984985986987988
  1. /*
  2. * HeroBonus.h, part of VCMI engine
  3. *
  4. * Authors: listed in file AUTHORS in main folder
  5. *
  6. * License: GNU General Public License v2.0 or later
  7. * Full text of license available in license.txt file, in main folder
  8. *
  9. */
  10. #pragma once
  11. #include "GameConstants.h"
  12. class CCreature;
  13. struct Bonus;
  14. class IBonusBearer;
  15. class CBonusSystemNode;
  16. class ILimiter;
  17. class IPropagator;
  18. class BonusList;
  19. typedef std::shared_ptr<BonusList> TBonusListPtr;
  20. typedef std::shared_ptr<ILimiter> TLimiterPtr;
  21. typedef std::shared_ptr<IPropagator> TPropagatorPtr;
  22. typedef std::set<CBonusSystemNode*> TNodes;
  23. typedef std::set<const CBonusSystemNode*> TCNodes;
  24. typedef std::vector<CBonusSystemNode *> TNodesVector;
  25. class CSelector : std::function<bool(const Bonus*)>
  26. {
  27. typedef std::function<bool(const Bonus*)> TBase;
  28. public:
  29. CSelector() {}
  30. template<typename T>
  31. CSelector(const T &t, //SFINAE trick -> include this c-tor in overload resolution only if parameter is class
  32. //(includes functors, lambdas) or function. Without that VC is going mad about ambiguities.
  33. typename std::enable_if < boost::mpl::or_ < std::is_class<T>, std::is_function<T >> ::value>::type *dummy = nullptr)
  34. : TBase(t)
  35. {}
  36. CSelector(std::nullptr_t)
  37. {}
  38. CSelector And(CSelector rhs) const
  39. {
  40. //lambda may likely outlive "this" (it can be even a temporary) => we copy the OBJECT (not pointer)
  41. auto thisCopy = *this;
  42. return [thisCopy, rhs](const Bonus *b) mutable { return thisCopy(b) && rhs(b); };
  43. }
  44. CSelector Or(CSelector rhs) const
  45. {
  46. auto thisCopy = *this;
  47. return [thisCopy, rhs](const Bonus *b) mutable { return thisCopy(b) || rhs(b); };
  48. }
  49. bool operator()(const Bonus *b) const
  50. {
  51. return TBase::operator()(b);
  52. }
  53. operator bool() const
  54. {
  55. return !!static_cast<const TBase&>(*this);
  56. }
  57. };
  58. class DLL_LINKAGE CBonusProxy : public boost::noncopyable
  59. {
  60. public:
  61. CBonusProxy(const IBonusBearer * Target, CSelector Selector);
  62. TBonusListPtr get() const;
  63. const BonusList * operator->() const;
  64. private:
  65. mutable int cachedLast;
  66. const IBonusBearer * target;
  67. CSelector selector;
  68. mutable TBonusListPtr data;
  69. };
  70. #define BONUS_TREE_DESERIALIZATION_FIX if(!h.saving && h.smartPointerSerialization) deserializationFix();
  71. #define BONUS_LIST \
  72. BONUS_NAME(NONE) \
  73. BONUS_NAME(LEVEL_COUNTER) /* for commander artifacts*/ \
  74. BONUS_NAME(MOVEMENT) /*both water/land*/ \
  75. BONUS_NAME(LAND_MOVEMENT) \
  76. BONUS_NAME(SEA_MOVEMENT) \
  77. BONUS_NAME(MORALE) \
  78. BONUS_NAME(LUCK) \
  79. BONUS_NAME(PRIMARY_SKILL) /*uses subtype to pick skill; additional info if set: 1 - only melee, 2 - only distance*/ \
  80. BONUS_NAME(SIGHT_RADIOUS) /*the correct word is RADIUS, but this one's already used in mods */\
  81. BONUS_NAME(MANA_REGENERATION) /*points per turn apart from normal (1 + mysticism)*/ \
  82. BONUS_NAME(FULL_MANA_REGENERATION) /*all mana points are replenished every day*/ \
  83. BONUS_NAME(NONEVIL_ALIGNMENT_MIX) /*good and neutral creatures can be mixed without morale penalty*/ \
  84. BONUS_NAME(SECONDARY_SKILL_PREMY) /*%*/ \
  85. BONUS_NAME(SURRENDER_DISCOUNT) /*%*/ \
  86. BONUS_NAME(STACKS_SPEED) /*additional info - percent of speed bonus applied after direct bonuses; >0 - added, <0 - subtracted to this part*/ \
  87. BONUS_NAME(FLYING_MOVEMENT) /*value - penalty percentage*/ \
  88. BONUS_NAME(SPELL_DURATION) \
  89. BONUS_NAME(AIR_SPELL_DMG_PREMY) \
  90. BONUS_NAME(EARTH_SPELL_DMG_PREMY) \
  91. BONUS_NAME(FIRE_SPELL_DMG_PREMY) \
  92. BONUS_NAME(WATER_SPELL_DMG_PREMY) \
  93. BONUS_NAME(WATER_WALKING) /*value - penalty percentage*/ \
  94. BONUS_NAME(NEGATE_ALL_NATURAL_IMMUNITIES) \
  95. BONUS_NAME(STACK_HEALTH) \
  96. BONUS_NAME(BLOCK_MORALE) \
  97. BONUS_NAME(BLOCK_LUCK) \
  98. BONUS_NAME(FIRE_SPELLS) \
  99. BONUS_NAME(AIR_SPELLS) \
  100. BONUS_NAME(WATER_SPELLS) \
  101. BONUS_NAME(EARTH_SPELLS) \
  102. BONUS_NAME(GENERATE_RESOURCE) /*daily value, uses subtype (resource type)*/ \
  103. BONUS_NAME(CREATURE_GROWTH) /*for legion artifacts: value - week growth bonus, subtype - monster level if aplicable*/ \
  104. BONUS_NAME(WHIRLPOOL_PROTECTION) /*hero won't lose army when teleporting through whirlpool*/ \
  105. BONUS_NAME(SPELL) /*hero knows spell, val - skill level (0 - 3), subtype - spell id*/ \
  106. BONUS_NAME(SPELLS_OF_LEVEL) /*hero knows all spells of given level, val - skill level; subtype - level*/ \
  107. BONUS_NAME(BATTLE_NO_FLEEING) /*for shackles of war*/ \
  108. BONUS_NAME(MAGIC_SCHOOL_SKILL) /* //eg. for magic plains terrain, subtype: school of magic (0 - all, 1 - fire, 2 - air, 4 - water, 8 - earth), value - level*/ \
  109. BONUS_NAME(FREE_SHOOTING) /*stacks can shoot even if otherwise blocked (sharpshooter's bow effect)*/ \
  110. BONUS_NAME(OPENING_BATTLE_SPELL) /*casts a spell at expert level at beginning of battle, val - spell power, subtype - spell id*/ \
  111. BONUS_NAME(IMPROVED_NECROMANCY) /*allows Necropolis units other than skeletons to be raised by necromancy*/ \
  112. BONUS_NAME(CREATURE_GROWTH_PERCENT) /*increases growth of all units in all towns, val - percentage*/ \
  113. BONUS_NAME(FREE_SHIP_BOARDING) /*movement points preserved with ship boarding and landing*/ \
  114. BONUS_NAME(NO_TYPE) \
  115. BONUS_NAME(FLYING) \
  116. BONUS_NAME(SHOOTER) \
  117. BONUS_NAME(CHARGE_IMMUNITY) \
  118. BONUS_NAME(ADDITIONAL_ATTACK) \
  119. BONUS_NAME(UNLIMITED_RETALIATIONS) \
  120. BONUS_NAME(NO_MELEE_PENALTY) \
  121. BONUS_NAME(JOUSTING) /*for champions*/ \
  122. BONUS_NAME(HATE) /*eg. angels hate devils, subtype - ID of hated creature, val - damage bonus percent */ \
  123. BONUS_NAME(KING1) \
  124. BONUS_NAME(KING2) \
  125. BONUS_NAME(KING3) \
  126. BONUS_NAME(MAGIC_RESISTANCE) /*in % (value)*/ \
  127. BONUS_NAME(CHANGES_SPELL_COST_FOR_ALLY) /*in mana points (value) , eg. mage*/ \
  128. BONUS_NAME(CHANGES_SPELL_COST_FOR_ENEMY) /*in mana points (value) , eg. pegasus */ \
  129. BONUS_NAME(SPELL_AFTER_ATTACK) /* subtype - spell id, value - chance %, additional info % 1000 - level, (additional info)/1000 -> [0 - all attacks, 1 - shot only, 2 - melee only*/ \
  130. BONUS_NAME(SPELL_BEFORE_ATTACK) /* subtype - spell id, value - chance %, additional info % 1000 - level, (additional info)/1000 -> [0 - all attacks, 1 - shot only, 2 - melee only*/ \
  131. BONUS_NAME(SPELL_RESISTANCE_AURA) /*eg. unicorns, value - resistance bonus in % for adjacent creatures*/ \
  132. BONUS_NAME(LEVEL_SPELL_IMMUNITY) /*creature is immune to all spell with level below or equal to value of this bonus */ \
  133. BONUS_NAME(BLOCK_MAGIC_ABOVE) /*blocks casting spells of the level > value */ \
  134. BONUS_NAME(BLOCK_ALL_MAGIC) /*blocks casting spells*/ \
  135. BONUS_NAME(TWO_HEX_ATTACK_BREATH) /*eg. dragons*/ \
  136. BONUS_NAME(SPELL_DAMAGE_REDUCTION) /*eg. golems; value - reduction in %, subtype - spell school; -1 - all, 0 - air, 1 - fire, 2 - water, 3 - earth*/ \
  137. BONUS_NAME(NO_WALL_PENALTY) \
  138. BONUS_NAME(NON_LIVING) /*eg. gargoyle*/ \
  139. BONUS_NAME(RANDOM_SPELLCASTER) /*eg. master genie, val - level*/ \
  140. BONUS_NAME(BLOCKS_RETALIATION) /*eg. naga*/ \
  141. BONUS_NAME(SPELL_IMMUNITY) /*subid - spell id*/ \
  142. BONUS_NAME(MANA_CHANNELING) /*value in %, eg. familiar*/ \
  143. BONUS_NAME(SPELL_LIKE_ATTACK) /*subtype - spell, value - spell level; range is taken from spell, but damage from creature; eg. magog*/ \
  144. BONUS_NAME(THREE_HEADED_ATTACK) /*eg. cerberus*/ \
  145. BONUS_NAME(DAEMON_SUMMONING) /*pit lord, subtype - type of creatures, val - hp per unit*/ \
  146. BONUS_NAME(FIRE_IMMUNITY) /*subtype 0 - all, 1 - all except positive, 2 - only damage spells*/ \
  147. BONUS_NAME(WATER_IMMUNITY) \
  148. BONUS_NAME(EARTH_IMMUNITY) \
  149. BONUS_NAME(AIR_IMMUNITY) \
  150. BONUS_NAME(MIND_IMMUNITY) \
  151. BONUS_NAME(FIRE_SHIELD) \
  152. BONUS_NAME(UNDEAD) \
  153. BONUS_NAME(HP_REGENERATION) /*creature regenerates val HP every new round*/ \
  154. BONUS_NAME(FULL_HP_REGENERATION) /*first creature regenerates all HP every new round; subtype 0 - animation 4 (trolllike), 1 - animation 47 (wightlike)*/ \
  155. BONUS_NAME(MANA_DRAIN) /*value - spell points per turn*/ \
  156. BONUS_NAME(LIFE_DRAIN) \
  157. BONUS_NAME(DOUBLE_DAMAGE_CHANCE) /*value in %, eg. dread knight*/ \
  158. BONUS_NAME(RETURN_AFTER_STRIKE) \
  159. BONUS_NAME(SELF_MORALE) /*eg. minotaur*/ \
  160. BONUS_NAME(SPELLCASTER) /*subtype - spell id, value - level of school, additional info - weighted chance. use SPECIFIC_SPELL_POWER, CREATURE_SPELL_POWER or CREATURE_ENCHANT_POWER for calculating the power*/ \
  161. BONUS_NAME(CATAPULT) \
  162. BONUS_NAME(ENEMY_DEFENCE_REDUCTION) /*in % (value) eg. behemots*/ \
  163. BONUS_NAME(GENERAL_DAMAGE_REDUCTION) /* shield / air shield effect */ \
  164. BONUS_NAME(GENERAL_ATTACK_REDUCTION) /*eg. while stoned or blinded - in %,// subtype not used, use ONLY_MELEE_FIGHT / DISTANCE_FIGHT*/ \
  165. BONUS_NAME(DEFENSIVE_STANCE) /* val - bonus to defense while defending */ \
  166. BONUS_NAME(ATTACKS_ALL_ADJACENT) /*eg. hydra*/ \
  167. BONUS_NAME(MORE_DAMAGE_FROM_SPELL) /*value - damage increase in %, subtype - spell id*/ \
  168. BONUS_NAME(FEAR) \
  169. BONUS_NAME(FEARLESS) \
  170. BONUS_NAME(NO_DISTANCE_PENALTY) \
  171. BONUS_NAME(SELF_LUCK) /*halfling*/ \
  172. BONUS_NAME(ENCHANTER)/* for Enchanter spells, val - skill level, subtype - spell id, additionalInfo - cooldown */ \
  173. BONUS_NAME(HEALER) \
  174. BONUS_NAME(SIEGE_WEAPON) \
  175. BONUS_NAME(HYPNOTIZED) \
  176. BONUS_NAME(NO_RETALIATION) /*temporary bonus for basilisk, unicorn and scorpicore paralyze*/\
  177. BONUS_NAME(ADDITIONAL_RETALIATION) /*value - number of additional retaliations*/ \
  178. BONUS_NAME(MAGIC_MIRROR) /* value - chance of redirecting in %*/ \
  179. BONUS_NAME(ALWAYS_MINIMUM_DAMAGE) /*unit does its minimum damage from range; subtype: -1 - any attack, 0 - melee, 1 - ranged, value: additional damage penalty (it'll subtracted from dmg), additional info - multiplicative anti-bonus for dmg in % [eg 20 means that creature will inflict 80% of normal minimal dmg]*/ \
  180. BONUS_NAME(ALWAYS_MAXIMUM_DAMAGE) /*eg. bless effect, subtype: -1 - any attack, 0 - melee, 1 - ranged, value: additional damage, additional info - multiplicative bonus for dmg in %*/ \
  181. BONUS_NAME(ATTACKS_NEAREST_CREATURE) /*while in berserk*/ \
  182. BONUS_NAME(IN_FRENZY) /*value - level*/ \
  183. BONUS_NAME(SLAYER) /*value - level*/ \
  184. BONUS_NAME(FORGETFULL) /*forgetfulness spell effect, value - level*/ \
  185. BONUS_NAME(NOT_ACTIVE) /* subtype - spell ID (paralyze, blind, stone gaze) for graphical effect*/ \
  186. BONUS_NAME(NO_LUCK) /*eg. when fighting on cursed ground*/ \
  187. BONUS_NAME(NO_MORALE) /*eg. when fighting on cursed ground*/ \
  188. BONUS_NAME(DARKNESS) /*val = radius */ \
  189. BONUS_NAME(SPECIAL_SECONDARY_SKILL) /*val = id, additionalInfo = value per level in percent*/ \
  190. BONUS_NAME(SPECIAL_SPELL_LEV) /*val = id, additionalInfo = value per level in percent*/\
  191. BONUS_NAME(SPELL_DAMAGE) /*val = value*/\
  192. BONUS_NAME(SPECIFIC_SPELL_DAMAGE) /*subtype = id of spell, val = value*/\
  193. BONUS_NAME(SPECIAL_BLESS_DAMAGE) /*val = spell (bless), additionalInfo = value per level in percent*/\
  194. BONUS_NAME(MAXED_SPELL) /*val = id*/\
  195. BONUS_NAME(SPECIAL_PECULIAR_ENCHANT) /*blesses and curses with id = val dependent on unit's level, subtype = 0 or 1 for Coronius*/\
  196. BONUS_NAME(SPECIAL_UPGRADE) /*val = base, additionalInfo = target */\
  197. BONUS_NAME(DRAGON_NATURE) \
  198. BONUS_NAME(CREATURE_DAMAGE)/*subtype 0 = both, 1 = min, 2 = max*/\
  199. BONUS_NAME(EXP_MULTIPLIER)/* val - percent of additional exp gained by stack/commander (base value 100)*/\
  200. BONUS_NAME(SHOTS)\
  201. BONUS_NAME(DEATH_STARE) /*subtype 0 - gorgon, 1 - commander*/\
  202. BONUS_NAME(POISON) /*val - max health penalty from poison possible*/\
  203. BONUS_NAME(BIND_EFFECT) /*doesn't do anything particular, works as a marker)*/\
  204. BONUS_NAME(ACID_BREATH) /*additional val damage per creature after attack, additional info - chance in percent*/\
  205. BONUS_NAME(RECEPTIVE) /*accepts friendly spells even with immunity*/\
  206. BONUS_NAME(DIRECT_DAMAGE_IMMUNITY) /*direct damage spells, that is*/\
  207. BONUS_NAME(CASTS) /*how many times creature can cast activated spell*/ \
  208. BONUS_NAME(SPECIFIC_SPELL_POWER) /* value used for Thunderbolt and Resurrection cast by units, subtype - spell id */\
  209. BONUS_NAME(CREATURE_SPELL_POWER) /* value per unit, divided by 100 (so faerie Dragons have 800)*/ \
  210. BONUS_NAME(CREATURE_ENCHANT_POWER) /* total duration of spells cast by creature */ \
  211. BONUS_NAME(ENCHANTED) /* permanently enchanted with spell subID of level = val, if val > 3 then spell is mass and has level of val-3*/ \
  212. BONUS_NAME(REBIRTH) /* val - percent of life restored, subtype = 0 - regular, 1 - at least one unit (sacred Phoenix) */\
  213. BONUS_NAME(ADDITIONAL_UNITS) /*val of units with id = subtype will be added to hero's army at the beginning of battle */\
  214. BONUS_NAME(SPOILS_OF_WAR) /*val * 10^-6 * gained exp resources of subtype will be given to hero after battle*/\
  215. BONUS_NAME(BLOCK)\
  216. BONUS_NAME(DISGUISED) /* subtype - spell level */\
  217. BONUS_NAME(VISIONS) /* subtype - spell level */\
  218. BONUS_NAME(NO_TERRAIN_PENALTY) /* subtype - terrain type */\
  219. BONUS_NAME(SOUL_STEAL) /*val - number of units gained per enemy killed, subtype = 0 - gained units survive after battle, 1 - they do not*/ \
  220. BONUS_NAME(TRANSMUTATION) /*val - chance to trigger in %, subtype = 0 - resurrection based on HP, 1 - based on unit count, additional info - target creature ID (attacker default)*/\
  221. BONUS_NAME(SUMMON_GUARDIANS) /*val - amount in % of stack count, subtype = creature ID*/\
  222. BONUS_NAME(CATAPULT_EXTRA_SHOTS) /*val - number of additional shots, requires CATAPULT bonus to work*/\
  223. BONUS_NAME(RANGED_RETALIATION) /*allows shooters to perform ranged retaliation*/\
  224. BONUS_NAME(BLOCKS_RANGED_RETALIATION) /*disallows ranged retaliation for shooter unit, BLOCKS_RETALIATION bonus is for melee retaliation only*/\
  225. BONUS_NAME(SECONDARY_SKILL_VAL2) /*for secondary skills that have multiple effects, like eagle eye (max level and chance)*/ \
  226. BONUS_NAME(MANUAL_CONTROL) /* manually control warmachine with id = subtype, chance = val */ \
  227. /* end of list */
  228. #define BONUS_SOURCE_LIST \
  229. BONUS_SOURCE(ARTIFACT)\
  230. BONUS_SOURCE(ARTIFACT_INSTANCE)\
  231. BONUS_SOURCE(OBJECT)\
  232. BONUS_SOURCE(CREATURE_ABILITY)\
  233. BONUS_SOURCE(TERRAIN_NATIVE)\
  234. BONUS_SOURCE(TERRAIN_OVERLAY)\
  235. BONUS_SOURCE(SPELL_EFFECT)\
  236. BONUS_SOURCE(TOWN_STRUCTURE)\
  237. BONUS_SOURCE(HERO_BASE_SKILL)\
  238. BONUS_SOURCE(SECONDARY_SKILL)\
  239. BONUS_SOURCE(HERO_SPECIAL)\
  240. BONUS_SOURCE(ARMY)\
  241. BONUS_SOURCE(CAMPAIGN_BONUS)\
  242. BONUS_SOURCE(SPECIAL_WEEK)\
  243. BONUS_SOURCE(STACK_EXPERIENCE)\
  244. BONUS_SOURCE(COMMANDER) /*TODO: consider using simply STACK_INSTANCE */\
  245. BONUS_SOURCE(OTHER) /*used for defensive stance and default value of spell level limit*/
  246. #define BONUS_VALUE_LIST \
  247. BONUS_VALUE(ADDITIVE_VALUE)\
  248. BONUS_VALUE(BASE_NUMBER)\
  249. BONUS_VALUE(PERCENT_TO_ALL)\
  250. BONUS_VALUE(PERCENT_TO_BASE)\
  251. BONUS_VALUE(INDEPENDENT_MAX) /*used for SPELL bonus */\
  252. BONUS_VALUE(INDEPENDENT_MIN) //used for SECONDARY_SKILL_PREMY bonus
  253. /// Struct for handling bonuses of several types. Can be transferred to any hero
  254. struct DLL_LINKAGE Bonus : public std::enable_shared_from_this<Bonus>
  255. {
  256. enum { EVERY_TYPE = -1 };
  257. enum BonusType
  258. {
  259. #define BONUS_NAME(x) x,
  260. BONUS_LIST
  261. #undef BONUS_NAME
  262. };
  263. enum BonusDuration //when bonus is automatically removed
  264. {
  265. PERMANENT = 1,
  266. ONE_BATTLE = 2, //at the end of battle
  267. ONE_DAY = 4, //at the end of day
  268. ONE_WEEK = 8, //at the end of week (bonus lasts till the end of week, thats NOT 7 days
  269. N_TURNS = 16, //used during battles, after battle bonus is always removed
  270. N_DAYS = 32,
  271. UNTIL_BEING_ATTACKED = 64, /*removed after attack and counterattacks are performed*/
  272. UNTIL_ATTACK = 128, /*removed after attack and counterattacks are performed*/
  273. STACK_GETS_TURN = 256, /*removed when stack gets its turn - used for defensive stance*/
  274. COMMANDER_KILLED = 512
  275. };
  276. enum BonusSource
  277. {
  278. #define BONUS_SOURCE(x) x,
  279. BONUS_SOURCE_LIST
  280. #undef BONUS_SOURCE
  281. };
  282. enum LimitEffect
  283. {
  284. NO_LIMIT = 0,
  285. ONLY_DISTANCE_FIGHT=1, ONLY_MELEE_FIGHT, //used to mark bonuses for attack/defense primary skills from spells like Precision (distance only)
  286. ONLY_ENEMY_ARMY
  287. };
  288. enum ValueType
  289. {
  290. #define BONUS_VALUE(x) x,
  291. BONUS_VALUE_LIST
  292. #undef BONUS_VALUE
  293. };
  294. ui16 duration; //uses BonusDuration values
  295. si16 turnsRemain; //used if duration is N_TURNS, N_DAYS or ONE_WEEK
  296. BonusType type; //uses BonusType values - says to what is this bonus - 1 byte
  297. TBonusSubtype subtype; //-1 if not applicable - 4 bytes
  298. BonusSource source;//source type" uses BonusSource values - what gave that bonus
  299. si32 val;
  300. ui32 sid; //source id: id of object/artifact/spell
  301. ValueType valType;
  302. si32 additionalInfo;
  303. LimitEffect effectRange; //if not NO_LIMIT, bonus will be omitted by default
  304. TLimiterPtr limiter;
  305. TPropagatorPtr propagator;
  306. std::string description;
  307. Bonus(ui16 Dur, BonusType Type, BonusSource Src, si32 Val, ui32 ID, std::string Desc, si32 Subtype=-1);
  308. Bonus(ui16 Dur, BonusType Type, BonusSource Src, si32 Val, ui32 ID, si32 Subtype=-1, ValueType ValType = ADDITIVE_VALUE);
  309. Bonus();
  310. template <typename Handler> void serialize(Handler &h, const int version)
  311. {
  312. h & duration;
  313. h & type;
  314. h & subtype;
  315. h & source;
  316. h & val;
  317. h & sid;
  318. h & description;
  319. h & additionalInfo;
  320. h & turnsRemain;
  321. h & valType;
  322. h & effectRange;
  323. h & limiter;
  324. h & propagator;
  325. }
  326. template <typename Ptr>
  327. static bool compareByAdditionalInfo(const Ptr& a, const Ptr& b)
  328. {
  329. return a->additionalInfo < b->additionalInfo;
  330. }
  331. static bool NDays(const Bonus *hb)
  332. {
  333. return hb->duration & Bonus::N_DAYS;
  334. }
  335. static bool NTurns(const Bonus *hb)
  336. {
  337. return hb->duration & Bonus::N_TURNS;
  338. }
  339. static bool OneDay(const Bonus *hb)
  340. {
  341. return hb->duration & Bonus::ONE_DAY;
  342. }
  343. static bool OneWeek(const Bonus *hb)
  344. {
  345. return hb->duration & Bonus::ONE_WEEK;
  346. }
  347. static bool OneBattle(const Bonus *hb)
  348. {
  349. return hb->duration & Bonus::ONE_BATTLE;
  350. }
  351. static bool Permanent(const Bonus *hb)
  352. {
  353. return hb->duration & Bonus::PERMANENT;
  354. }
  355. static bool UntilGetsTurn(const Bonus *hb)
  356. {
  357. return hb->duration & Bonus::STACK_GETS_TURN;
  358. }
  359. static bool UntilAttack(const Bonus *hb)
  360. {
  361. return hb->duration & Bonus::UNTIL_ATTACK;
  362. }
  363. static bool UntilBeingAttacked(const Bonus *hb)
  364. {
  365. return hb->duration & Bonus::UNTIL_BEING_ATTACKED;
  366. }
  367. static bool UntilCommanderKilled(const Bonus *hb)
  368. {
  369. return hb->duration & Bonus::COMMANDER_KILLED;
  370. }
  371. inline bool operator == (const BonusType & cf) const
  372. {
  373. return type == cf;
  374. }
  375. inline void operator += (const ui32 Val) //no return
  376. {
  377. val += Val;
  378. }
  379. std::string Description() const;
  380. std::shared_ptr<Bonus> addLimiter(TLimiterPtr Limiter); //returns this for convenient chain-calls
  381. std::shared_ptr<Bonus> addPropagator(TPropagatorPtr Propagator); //returns this for convenient chain-calls
  382. };
  383. DLL_LINKAGE std::ostream & operator<<(std::ostream &out, const Bonus &bonus);
  384. class DLL_LINKAGE BonusList
  385. {
  386. public:
  387. typedef std::vector<std::shared_ptr<Bonus>> TInternalContainer;
  388. private:
  389. TInternalContainer bonuses;
  390. bool belongsToTree;
  391. void changed();
  392. public:
  393. typedef TInternalContainer::const_reference const_reference;
  394. typedef TInternalContainer::value_type value_type;
  395. typedef TInternalContainer::const_iterator const_iterator;
  396. typedef TInternalContainer::iterator iterator;
  397. BonusList(bool BelongsToTree = false);
  398. BonusList(const BonusList &bonusList);
  399. BonusList(BonusList && other);
  400. BonusList& operator=(const BonusList &bonusList);
  401. // wrapper functions of the STL vector container
  402. TInternalContainer::size_type size() const { return bonuses.size(); }
  403. void push_back(std::shared_ptr<Bonus> x);
  404. TInternalContainer::iterator erase (const int position);
  405. void clear();
  406. bool empty() const { return bonuses.empty(); }
  407. void resize(TInternalContainer::size_type sz, std::shared_ptr<Bonus> c = nullptr );
  408. std::shared_ptr<Bonus> &operator[] (TInternalContainer::size_type n) { return bonuses[n]; }
  409. const std::shared_ptr<Bonus> &operator[] (TInternalContainer::size_type n) const { return bonuses[n]; }
  410. std::shared_ptr<Bonus> &back() { return bonuses.back(); }
  411. std::shared_ptr<Bonus> &front() { return bonuses.front(); }
  412. const std::shared_ptr<Bonus> &back() const { return bonuses.back(); }
  413. const std::shared_ptr<Bonus> &front() const { return bonuses.front(); }
  414. // There should be no non-const access to provide solid,robust bonus caching
  415. TInternalContainer::const_iterator begin() const { return bonuses.begin(); }
  416. TInternalContainer::const_iterator end() const { return bonuses.end(); }
  417. TInternalContainer::size_type operator-=(std::shared_ptr<Bonus> const &i);
  418. // BonusList functions
  419. int totalValue() const;
  420. void getBonuses(BonusList &out, const CSelector &selector, const CSelector &limit) const;
  421. void getAllBonuses(BonusList &out) const;
  422. void getBonuses(BonusList & out, const CSelector &selector) const;
  423. //special find functions
  424. std::shared_ptr<Bonus> getFirst(const CSelector &select);
  425. const std::shared_ptr<Bonus> getFirst(const CSelector &select) const;
  426. int valOfBonuses(const CSelector &select) const;
  427. void eliminateDuplicates();
  428. // remove_if implementation for STL vector types
  429. template <class Predicate>
  430. void remove_if(Predicate pred)
  431. {
  432. BonusList newList;
  433. for (ui32 i = 0; i < bonuses.size(); i++)
  434. {
  435. auto b = bonuses[i];
  436. if (!pred(b.get()))
  437. newList.push_back(b);
  438. }
  439. bonuses.clear();
  440. bonuses.resize(newList.size());
  441. std::copy(newList.begin(), newList.end(), bonuses.begin());
  442. }
  443. template <class InputIterator>
  444. void insert(const int position, InputIterator first, InputIterator last);
  445. void insert(TInternalContainer::iterator position, TInternalContainer::size_type n, std::shared_ptr<Bonus> const &x);
  446. template <typename Handler>
  447. void serialize(Handler &h, const int version)
  448. {
  449. h & static_cast<TInternalContainer&>(bonuses);
  450. }
  451. // C++ for range support
  452. auto begin () -> decltype (bonuses.begin())
  453. {
  454. return bonuses.begin();
  455. }
  456. auto end () -> decltype (bonuses.end())
  457. {
  458. return bonuses.end();
  459. }
  460. };
  461. // Extensions for BOOST_FOREACH to enable iterating of BonusList objects
  462. // Don't touch/call this functions
  463. inline BonusList::iterator range_begin(BonusList & x)
  464. {
  465. return x.begin();
  466. }
  467. inline BonusList::iterator range_end(BonusList & x)
  468. {
  469. return x.end();
  470. }
  471. inline BonusList::const_iterator range_begin(BonusList const &x)
  472. {
  473. return x.begin();
  474. }
  475. inline BonusList::const_iterator range_end(BonusList const &x)
  476. {
  477. return x.end();
  478. }
  479. DLL_LINKAGE std::ostream & operator<<(std::ostream &out, const BonusList &bonusList);
  480. class DLL_LINKAGE IPropagator
  481. {
  482. public:
  483. virtual ~IPropagator();
  484. virtual bool shouldBeAttached(CBonusSystemNode *dest);
  485. template <typename Handler> void serialize(Handler &h, const int version)
  486. {}
  487. };
  488. class DLL_LINKAGE CPropagatorNodeType : public IPropagator
  489. {
  490. int nodeType; //CBonusSystemNode::ENodeTypes
  491. public:
  492. CPropagatorNodeType();
  493. CPropagatorNodeType(int NodeType);
  494. bool shouldBeAttached(CBonusSystemNode *dest) override;
  495. template <typename Handler> void serialize(Handler &h, const int version)
  496. {
  497. h & nodeType;
  498. }
  499. };
  500. struct BonusLimitationContext
  501. {
  502. const std::shared_ptr<Bonus> b;
  503. const CBonusSystemNode &node;
  504. const BonusList &alreadyAccepted;
  505. };
  506. class DLL_LINKAGE ILimiter
  507. {
  508. public:
  509. enum EDecision {ACCEPT, DISCARD, NOT_SURE};
  510. virtual ~ILimiter();
  511. virtual int limit(const BonusLimitationContext &context) const; //0 - accept bonus; 1 - drop bonus; 2 - delay (drops eventually)
  512. template <typename Handler> void serialize(Handler &h, const int version)
  513. {
  514. }
  515. };
  516. class DLL_LINKAGE IBonusBearer
  517. {
  518. public:
  519. //new bonusing node interface
  520. // * selector is predicate that tests if HeroBonus matches our criteria
  521. // * root is node on which call was made (nullptr will be replaced with this)
  522. //interface
  523. virtual const TBonusListPtr getAllBonuses(const CSelector &selector, const CSelector &limit, const CBonusSystemNode *root = nullptr, const std::string &cachingStr = "") const = 0;
  524. int valOfBonuses(const CSelector &selector, const std::string &cachingStr = "") const;
  525. bool hasBonus(const CSelector &selector, const std::string &cachingStr = "") const;
  526. bool hasBonus(const CSelector &selector, const CSelector &limit, const std::string &cachingStr = "") const;
  527. const TBonusListPtr getBonuses(const CSelector &selector, const CSelector &limit, const std::string &cachingStr = "") const;
  528. const TBonusListPtr getBonuses(const CSelector &selector, const std::string &cachingStr = "") const;
  529. const std::shared_ptr<Bonus> getBonus(const CSelector &selector) const; //returns any bonus visible on node that matches (or nullptr if none matches)
  530. //legacy interface
  531. int valOfBonuses(Bonus::BonusType type, const CSelector &selector) const;
  532. int valOfBonuses(Bonus::BonusType type, int subtype = -1) const; //subtype -> subtype of bonus, if -1 then anyt;
  533. bool hasBonusOfType(Bonus::BonusType type, int subtype = -1) const;//determines if hero has a bonus of given type (and optionally subtype)
  534. bool hasBonusFrom(Bonus::BonusSource source, ui32 sourceID) const;
  535. //various hlp functions for non-trivial values
  536. ui32 getMinDamage() const; //used for stacks and creatures only
  537. ui32 getMaxDamage() const;
  538. int MoraleVal() const; //range [-3, +3]
  539. int LuckVal() const; //range [-3, +3]
  540. si32 Attack() const; //get attack of stack with all modificators
  541. si32 Defense(bool withFrenzy = true) const; //get defense of stack with all modificators
  542. ui32 MaxHealth() const; //get max HP of stack with all modifiers
  543. bool isLiving() const; //non-undead, non-non living or alive
  544. virtual si32 magicResistance() const;
  545. ui32 Speed(int turn = 0, bool useBind = false) const; //get speed of creature with all modificators
  546. si32 manaLimit() const; //maximum mana value for this hero (basically 10*knowledge)
  547. int getPrimSkillLevel(PrimarySkill::PrimarySkill id) const;
  548. };
  549. class DLL_LINKAGE CBonusSystemNode : public IBonusBearer, public boost::noncopyable
  550. {
  551. public:
  552. enum ENodeTypes
  553. {
  554. UNKNOWN, STACK_INSTANCE, STACK_BATTLE, SPECIALTY, ARTIFACT, CREATURE, ARTIFACT_INSTANCE, HERO, PLAYER, TEAM,
  555. TOWN_AND_VISITOR, BATTLE, COMMANDER, GLOBAL_EFFECTS
  556. };
  557. private:
  558. BonusList bonuses; //wielded bonuses (local or up-propagated here)
  559. BonusList exportedBonuses; //bonuses coming from this node (wielded or propagated away)
  560. TNodesVector parents; //parents -> we inherit bonuses from them, we may attach our bonuses to them
  561. TNodesVector children;
  562. ENodeTypes nodeType;
  563. std::string description;
  564. static const bool cachingEnabled;
  565. mutable BonusList cachedBonuses;
  566. mutable int cachedLast;
  567. static int treeChanged;
  568. // Setting a value to cachingStr before getting any bonuses caches the result for later requests.
  569. // This string needs to be unique, that's why it has to be setted in the following manner:
  570. // [property key]_[value] => only for selector
  571. mutable std::map<std::string, TBonusListPtr > cachedRequests;
  572. void getBonusesRec(BonusList &out, const CSelector &selector, const CSelector &limit) const;
  573. void getAllBonusesRec(BonusList &out) const;
  574. const TBonusListPtr getAllBonusesWithoutCaching(const CSelector &selector, const CSelector &limit, const CBonusSystemNode *root = nullptr) const;
  575. public:
  576. explicit CBonusSystemNode();
  577. CBonusSystemNode(CBonusSystemNode && other);
  578. virtual ~CBonusSystemNode();
  579. void limitBonuses(const BonusList &allBonuses, BonusList &out) const; //out will bo populed with bonuses that are not limited here
  580. TBonusListPtr limitBonuses(const BonusList &allBonuses) const; //same as above, returns out by val for convienence
  581. const TBonusListPtr getAllBonuses(const CSelector &selector, const CSelector &limit, const CBonusSystemNode *root = nullptr, const std::string &cachingStr = "") const override;
  582. void getParents(TCNodes &out) const; //retrieves list of parent nodes (nodes to inherit bonuses from),
  583. const std::shared_ptr<Bonus> getBonusLocalFirst(const CSelector &selector) const;
  584. //non-const interface
  585. void getParents(TNodes &out); //retrieves list of parent nodes (nodes to inherit bonuses from)
  586. void getRedParents(TNodes &out); //retrieves list of red parent nodes (nodes bonuses propagate from)
  587. void getRedAncestors(TNodes &out);
  588. void getRedChildren(TNodes &out);
  589. void getRedDescendants(TNodes &out);
  590. std::shared_ptr<Bonus> getBonusLocalFirst(const CSelector &selector);
  591. void attachTo(CBonusSystemNode *parent);
  592. void detachFrom(CBonusSystemNode *parent);
  593. void detachFromAll();
  594. virtual void addNewBonus(const std::shared_ptr<Bonus>& b);
  595. void accumulateBonus(const std::shared_ptr<Bonus>& b); //add value of bonus with same type/subtype or create new
  596. void newChildAttached(CBonusSystemNode *child);
  597. void childDetached(CBonusSystemNode *child);
  598. void propagateBonus(std::shared_ptr<Bonus> b);
  599. void unpropagateBonus(std::shared_ptr<Bonus> b);
  600. void removeBonus(const std::shared_ptr<Bonus>& b);
  601. void newRedDescendant(CBonusSystemNode *descendant); //propagation needed
  602. void removedRedDescendant(CBonusSystemNode *descendant); //de-propagation needed
  603. bool isIndependentNode() const; //node is independent when it has no parents nor children
  604. bool actsAsBonusSourceOnly() const;
  605. ///removes bonuses by selector
  606. void popBonuses(const CSelector &s);
  607. ///updates count of remaining turns and removes outdated bonuses by selector
  608. void updateBonuses(const CSelector &s);
  609. virtual std::string bonusToString(const std::shared_ptr<Bonus>& bonus, bool description) const {return "";}; //description or bonus name
  610. virtual std::string nodeName() const;
  611. void deserializationFix();
  612. void exportBonus(std::shared_ptr<Bonus> b);
  613. void exportBonuses();
  614. const BonusList &getBonusList() const;
  615. BonusList &getExportedBonusList();
  616. CBonusSystemNode::ENodeTypes getNodeType() const;
  617. void setNodeType(CBonusSystemNode::ENodeTypes type);
  618. const TNodesVector &getParentNodes() const;
  619. const TNodesVector &getChildrenNodes() const;
  620. const std::string &getDescription() const;
  621. void setDescription(const std::string &description);
  622. static void treeHasChanged();
  623. template <typename Handler> void serialize(Handler &h, const int version)
  624. {
  625. // h & bonuses;
  626. h & nodeType;
  627. h & exportedBonuses;
  628. h & description;
  629. BONUS_TREE_DESERIALIZATION_FIX
  630. //h & parents & children;
  631. }
  632. friend class CBonusProxy;
  633. };
  634. namespace NBonus
  635. {
  636. //set of methods that may be safely called with nullptr objs
  637. DLL_LINKAGE int valOf(const CBonusSystemNode *obj, Bonus::BonusType type, int subtype = -1); //subtype -> subtype of bonus, if -1 then any
  638. DLL_LINKAGE bool hasOfType(const CBonusSystemNode *obj, Bonus::BonusType type, int subtype = -1);//determines if hero has a bonus of given type (and optionally subtype)
  639. }
  640. template<typename T>
  641. class CSelectFieldEqual
  642. {
  643. T Bonus::*ptr;
  644. public:
  645. CSelectFieldEqual(T Bonus::*Ptr)
  646. : ptr(Ptr)
  647. {
  648. }
  649. CSelector operator()(const T &valueToCompareAgainst) const
  650. {
  651. auto ptr2 = ptr; //We need a COPY because we don't want to reference this (might be outlived by lambda)
  652. return [ptr2, valueToCompareAgainst](const Bonus *bonus) { return bonus->*ptr2 == valueToCompareAgainst; };
  653. }
  654. };
  655. template<typename T> //can be same, needed for subtype field
  656. class CSelectFieldEqualOrEvery
  657. {
  658. T Bonus::*ptr;
  659. T val;
  660. public:
  661. CSelectFieldEqualOrEvery(T Bonus::*Ptr, const T &Val)
  662. : ptr(Ptr), val(Val)
  663. {
  664. }
  665. bool operator()(const Bonus *bonus) const
  666. {
  667. return (bonus->*ptr == val) || (bonus->*ptr == static_cast<T>(Bonus::EVERY_TYPE));
  668. }
  669. CSelectFieldEqualOrEvery& operator()(const T &setVal)
  670. {
  671. val = setVal;
  672. return *this;
  673. }
  674. };
  675. class DLL_LINKAGE CWillLastTurns
  676. {
  677. public:
  678. int turnsRequested;
  679. bool operator()(const Bonus *bonus) const
  680. {
  681. return turnsRequested <= 0 //every present effect will last zero (or "less") turns
  682. || !Bonus::NTurns(bonus) //so do every not expriing after N-turns effect
  683. || bonus->turnsRemain > turnsRequested;
  684. }
  685. CWillLastTurns& operator()(const int &setVal)
  686. {
  687. turnsRequested = setVal;
  688. return *this;
  689. }
  690. };
  691. class DLL_LINKAGE CWillLastDays
  692. {
  693. public:
  694. int daysRequested;
  695. bool operator()(const Bonus *bonus) const
  696. {
  697. if(daysRequested <= 0 || Bonus::Permanent(bonus) || Bonus::OneBattle(bonus))
  698. return true;
  699. else if(Bonus::OneDay(bonus))
  700. return false;
  701. else if(Bonus::NDays(bonus) || Bonus::OneWeek(bonus))
  702. {
  703. return bonus->turnsRemain > daysRequested;
  704. }
  705. return false; // TODO: ONE_WEEK need support for turnsRemain, but for now we'll exclude all unhandled durations
  706. }
  707. CWillLastDays& operator()(const int &setVal)
  708. {
  709. daysRequested = setVal;
  710. return *this;
  711. }
  712. };
  713. //Stores multiple limiters. If any of them fails -> bonus is dropped.
  714. class DLL_LINKAGE LimiterList : public ILimiter
  715. {
  716. std::vector<TLimiterPtr> limiters;
  717. public:
  718. int limit(const BonusLimitationContext &context) const override;
  719. void add(TLimiterPtr limiter);
  720. };
  721. class DLL_LINKAGE CCreatureTypeLimiter : public ILimiter //affect only stacks of given creature (and optionally it's upgrades)
  722. {
  723. public:
  724. const CCreature *creature;
  725. bool includeUpgrades;
  726. CCreatureTypeLimiter();
  727. CCreatureTypeLimiter(const CCreature &Creature, bool IncludeUpgrades = true);
  728. void setCreature (CreatureID id);
  729. int limit(const BonusLimitationContext &context) const override;
  730. template <typename Handler> void serialize(Handler &h, const int version)
  731. {
  732. h & static_cast<ILimiter&>(*this);
  733. h & creature;
  734. h & includeUpgrades;
  735. }
  736. };
  737. class DLL_LINKAGE HasAnotherBonusLimiter : public ILimiter //applies only to nodes that have another bonus working
  738. {
  739. public:
  740. Bonus::BonusType type;
  741. TBonusSubtype subtype;
  742. bool isSubtypeRelevant; //check for subtype only if this is true
  743. HasAnotherBonusLimiter(Bonus::BonusType bonus = Bonus::NONE);
  744. HasAnotherBonusLimiter(Bonus::BonusType bonus, TBonusSubtype _subtype);
  745. int limit(const BonusLimitationContext &context) const override;
  746. template <typename Handler> void serialize(Handler &h, const int version)
  747. {
  748. h & static_cast<ILimiter&>(*this);
  749. h & type;
  750. h & subtype;
  751. h & isSubtypeRelevant;
  752. }
  753. };
  754. class DLL_LINKAGE CreatureNativeTerrainLimiter : public ILimiter //applies only to creatures that are on their native terrain
  755. {
  756. public:
  757. int terrainType;
  758. CreatureNativeTerrainLimiter();
  759. CreatureNativeTerrainLimiter(int TerrainType);
  760. int limit(const BonusLimitationContext &context) const override;
  761. template <typename Handler> void serialize(Handler &h, const int version)
  762. {
  763. h & static_cast<ILimiter&>(*this);
  764. h & terrainType;
  765. }
  766. };
  767. class DLL_LINKAGE CreatureFactionLimiter : public ILimiter //applies only to creatures of given faction
  768. {
  769. public:
  770. si8 faction;
  771. CreatureFactionLimiter();
  772. CreatureFactionLimiter(int TerrainType);
  773. int limit(const BonusLimitationContext &context) const override;
  774. template <typename Handler> void serialize(Handler &h, const int version)
  775. {
  776. h & static_cast<ILimiter&>(*this);
  777. h & faction;
  778. }
  779. };
  780. class DLL_LINKAGE CreatureAlignmentLimiter : public ILimiter //applies only to creatures of given alignment
  781. {
  782. public:
  783. si8 alignment;
  784. CreatureAlignmentLimiter();
  785. CreatureAlignmentLimiter(si8 Alignment);
  786. int limit(const BonusLimitationContext &context) const override;
  787. template <typename Handler> void serialize(Handler &h, const int version)
  788. {
  789. h & static_cast<ILimiter&>(*this);
  790. h & alignment;
  791. }
  792. };
  793. class DLL_LINKAGE StackOwnerLimiter : public ILimiter //applies only to creatures of given alignment
  794. {
  795. public:
  796. PlayerColor owner;
  797. StackOwnerLimiter();
  798. StackOwnerLimiter(PlayerColor Owner);
  799. int limit(const BonusLimitationContext &context) const override;
  800. template <typename Handler> void serialize(Handler &h, const int version)
  801. {
  802. h & static_cast<ILimiter&>(*this);
  803. h & owner;
  804. }
  805. };
  806. class DLL_LINKAGE RankRangeLimiter : public ILimiter //applies to creatures with min <= Rank <= max
  807. {
  808. public:
  809. ui8 minRank, maxRank;
  810. RankRangeLimiter();
  811. RankRangeLimiter(ui8 Min, ui8 Max = 255);
  812. int limit(const BonusLimitationContext &context) const override;
  813. template <typename Handler> void serialize(Handler &h, const int version)
  814. {
  815. h & static_cast<ILimiter&>(*this);
  816. h & minRank;
  817. h & maxRank;
  818. }
  819. };
  820. namespace Selector
  821. {
  822. extern DLL_LINKAGE CSelectFieldEqual<Bonus::BonusType> type;
  823. extern DLL_LINKAGE CSelectFieldEqual<TBonusSubtype> subtype;
  824. extern DLL_LINKAGE CSelectFieldEqual<si32> info;
  825. extern DLL_LINKAGE CSelectFieldEqual<Bonus::BonusSource> sourceType;
  826. extern DLL_LINKAGE CSelectFieldEqual<Bonus::LimitEffect> effectRange;
  827. extern DLL_LINKAGE CWillLastTurns turns;
  828. extern DLL_LINKAGE CWillLastDays days;
  829. CSelector DLL_LINKAGE typeSubtype(Bonus::BonusType Type, TBonusSubtype Subtype);
  830. CSelector DLL_LINKAGE typeSubtypeInfo(Bonus::BonusType type, TBonusSubtype subtype, si32 info);
  831. CSelector DLL_LINKAGE source(Bonus::BonusSource source, ui32 sourceID);
  832. CSelector DLL_LINKAGE sourceTypeSel(Bonus::BonusSource source);
  833. CSelector DLL_LINKAGE valueType(Bonus::ValueType valType);
  834. /**
  835. * Selects all bonuses
  836. * Usage example: Selector::all.And(<functor>).And(<functor>)...)
  837. */
  838. extern DLL_LINKAGE CSelector all;
  839. /**
  840. * Selects nothing
  841. * Usage example: Selector::none.Or(<functor>).Or(<functor>)...)
  842. */
  843. extern DLL_LINKAGE CSelector none;
  844. bool DLL_LINKAGE matchesType(const CSelector &sel, Bonus::BonusType type);
  845. bool DLL_LINKAGE matchesTypeSubtype(const CSelector &sel, Bonus::BonusType type, TBonusSubtype subtype);
  846. }
  847. extern DLL_LINKAGE const std::map<std::string, Bonus::BonusType> bonusNameMap;
  848. extern DLL_LINKAGE const std::map<std::string, Bonus::ValueType> bonusValueMap;
  849. extern DLL_LINKAGE const std::map<std::string, Bonus::BonusSource> bonusSourceMap;
  850. extern DLL_LINKAGE const std::map<std::string, ui16> bonusDurationMap;
  851. extern DLL_LINKAGE const std::map<std::string, Bonus::LimitEffect> bonusLimitEffect;
  852. extern DLL_LINKAGE const std::map<std::string, TLimiterPtr> bonusLimiterMap;
  853. extern DLL_LINKAGE const std::map<std::string, TPropagatorPtr> bonusPropagatorMap;
  854. // BonusList template that requires full interface of CBonusSystemNode
  855. template <class InputIterator>
  856. void BonusList::insert(const int position, InputIterator first, InputIterator last)
  857. {
  858. bonuses.insert(bonuses.begin() + position, first, last);
  859. changed();
  860. }