1
0
mirror of https://github.com/vcmi/vcmi.git synced 2024-12-22 22:13:35 +02:00
vcmi/lib/CCreatureHandler.h
AlexVinS a31c28ec33 Unified war machine mechanics.
* it is possible to define new war machines
* added warMachine field to artifact configuration
2017-06-06 19:18:26 +03:00

249 lines
8.6 KiB
C++

#pragma once
#include "HeroBonus.h"
#include "ConstTransitivePtr.h"
#include "ResourceSet.h"
#include "GameConstants.h"
#include "JsonNode.h"
#include "IHandlerBase.h"
#include "CRandomGenerator.h"
/*
* CCreatureHandler.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
*
*/
class CLegacyConfigParser;
class CCreatureHandler;
class CCreature;
class DLL_LINKAGE CCreature : public CBonusSystemNode
{
public:
std::string identifier;
std::string nameRef; // reference name, stringID
std::string nameSing;// singular name, e.g. Centaur
std::string namePl; // plural name, e.g. Centaurs
std::string abilityText; //description of abilities
CreatureID idNumber;
TFaction faction;
ui8 level; // 0 - unknown; 1-7 for "usual" creatures
//stats that are not handled by bonus system
ui32 fightValue, AIValue, growth, hordeGrowth;
ui32 ammMin, ammMax; // initial size of stack of these creatures on adventure map (if not set in editor)
bool doubleWide;
bool special; // Creature is not available normally (war machines, commanders, several unused creatures, etc
TResources cost; //cost[res_id] - amount of that resource required to buy creature from dwelling
std::set<CreatureID> upgrades; // IDs of creatures to which this creature can be upgraded
std::string animDefName; // creature animation used during battles
std::string advMapDef; //for new creatures only, image for adventure map
si32 iconIndex; // index of icon in files like twcrport
/// names of files with appropriate icons. Used only during loading
std::string smallIconName;
std::string largeIconName;
struct CreatureAnimation
{
double timeBetweenFidgets, idleAnimationTime,
walkAnimationTime, attackAnimationTime, flightAnimationDistance;
int upperRightMissleOffsetX, rightMissleOffsetX, lowerRightMissleOffsetX,
upperRightMissleOffsetY, rightMissleOffsetY, lowerRightMissleOffsetY;
std::vector<double> missleFrameAngles;
int troopCountLocationOffset, attackClimaxFrame;
std::string projectileImageName;
//bool projectileSpin; //if true, appropriate projectile is spinning during flight
template <typename Handler> void serialize(Handler &h, const int version)
{
h & timeBetweenFidgets & idleAnimationTime;
h & walkAnimationTime & attackAnimationTime & flightAnimationDistance;
h & upperRightMissleOffsetX & rightMissleOffsetX & lowerRightMissleOffsetX;
h & upperRightMissleOffsetY & rightMissleOffsetY & lowerRightMissleOffsetY;
h & missleFrameAngles & troopCountLocationOffset & attackClimaxFrame;
h & projectileImageName;
}
} animation;
//sound info
struct CreatureBattleSounds
{
std::string attack;
std::string defend;
std::string killed; // was killed or died
std::string move;
std::string shoot; // range attack
std::string wince; // attacked but did not die
std::string startMoving;
std::string endMoving;
template <typename Handler> void serialize(Handler &h, const int version)
{
h & attack & defend & killed & move & shoot & wince & startMoving & endMoving;
}
} sounds;
ArtifactID warMachine;
bool isItNativeTerrain(int terrain) const;
bool isDoubleWide() const; //returns true if unit is double wide on battlefield
bool isFlying() const; //returns true if it is a flying unit
bool isShooting() const; //returns true if unit can shoot
bool isUndead() const; //returns true if unit is undead
bool isGood () const;
bool isEvil () const;
si32 maxAmount(const std::vector<si32> &res) const; //how many creatures can be bought
static int getQuantityID(const int & quantity); //0 - a few, 1 - several, 2 - pack, 3 - lots, 4 - horde, 5 - throng, 6 - swarm, 7 - zounds, 8 - legion
static int estimateCreatureCount(ui32 countID); //reverse version of above function, returns middle of range
bool isMyUpgrade(const CCreature *anotherCre) const;
bool valid() const;
void setId(CreatureID ID); //assigns idNumber and updates bonuses to reference it
void addBonus(int val, Bonus::BonusType type, int subtype = -1);
std::string nodeName() const override;
template<typename RanGen>
int getRandomAmount(RanGen ranGen) const
{
if(ammMax == ammMin)
return ammMax;
else
return ammMin + (ranGen() % (ammMax - ammMin));
}
template <typename Handler> void serialize(Handler &h, const int version)
{
h & static_cast<CBonusSystemNode&>(*this);
h & namePl & nameSing & nameRef
& cost & upgrades
& fightValue & AIValue & growth & hordeGrowth
& ammMin & ammMax & level
& abilityText & animDefName & advMapDef;
h & iconIndex & smallIconName & largeIconName;
h & idNumber & faction & sounds & animation;
h & doubleWide & special;
if(version>=759)
{
h & identifier;
}
if(version >= 771)
{
h & warMachine;
}
else if(!h.saving)
{
fillWarMachine();
}
}
CCreature();
private:
void fillWarMachine();
};
class DLL_LINKAGE CCreatureHandler : public IHandlerBase
{
private:
CBonusSystemNode allCreatures;
CBonusSystemNode creaturesOfLevel[GameConstants::CREATURES_PER_TOWN + 1];//index 0 is used for creatures of unknown tier or outside <1-7> range
/// load one creature from json config
CCreature * loadFromJson(const JsonNode & node, const std::string & identifier);
void loadJsonAnimation(CCreature * creature, const JsonNode & graphics);
void loadStackExperience(CCreature * creature, const JsonNode &input);
void loadCreatureJson(CCreature * creature, const JsonNode & config);
/// loading functions
/// adding abilities from ZCRTRAIT.TXT
void loadBonuses(JsonNode & creature, std::string bonuses);
/// load all creatures from H3 files
void load();
void loadCommanders();
/// load creature from json structure
void load(std::string creatureID, const JsonNode & node);
/// read cranim.txt file from H3
void loadAnimationInfo(std::vector<JsonNode> & h3Data);
/// read one line from cranim.txt
void loadUnitAnimInfo(JsonNode & unit, CLegacyConfigParser &parser);
/// parse crexpbon.txt file from H3
void loadStackExp(Bonus & b, BonusList & bl, CLegacyConfigParser &parser);
/// help function for parsing CREXPBON.txt
int stringToNumber(std::string & s);
public:
std::set<CreatureID> doubledCreatures; //they get double week
std::vector<ConstTransitivePtr<CCreature> > creatures; //creature ID -> creature info.
//stack exp
std::vector<std::vector<ui32> > expRanks; // stack experience needed for certain rank, index 0 for other tiers (?)
std::vector<ui32> maxExpPerBattle; //%, tiers same as above
si8 expAfterUpgrade;//multiplier in %
//Commanders
BonusList commanderLevelPremy; //bonus values added with each level-up
std::vector< std::vector <ui8> > skillLevels; //how much of a bonus will be given to commander with every level. SPELL_POWER also gives CASTS and RESISTANCE
std::vector <std::pair <std::shared_ptr<Bonus>, std::pair <ui8, ui8> > > skillRequirements; // first - Bonus, second - which two skills are needed to use it
const CCreature * getCreature(const std::string & scope, const std::string & identifier) const;
void deserializationFix();
CreatureID pickRandomMonster(CRandomGenerator & rand, int tier = -1) const; //tier <1 - CREATURES_PER_TOWN> or -1 for any
void addBonusForTier(int tier, std::shared_ptr<Bonus> b); //tier must be <1-7>
void addBonusForAllCreatures(std::shared_ptr<Bonus> b);
CCreatureHandler();
~CCreatureHandler();
/// load all creatures from H3 files
void loadCrExpBon();
/// generates tier-specific bonus tree entries
void buildBonusTreeForTiers();
void afterLoadFinalization() override;
std::vector<JsonNode> loadLegacyData(size_t dataSize) override;
void loadObject(std::string scope, std::string name, const JsonNode & data) override;
void loadObject(std::string scope, std::string name, const JsonNode & data, size_t index) override;
std::vector<bool> getDefaultAllowed() const override;
///json serialization helper
static si32 decodeCreature(const std::string & identifier);
///json serialization helper
static std::string encodeCreature(const si32 index);
template <typename Handler> void serialize(Handler &h, const int version)
{
//TODO: should be optimized, not all these informations needs to be serialized (same for ccreature)
h & doubledCreatures & creatures;
h & expRanks & maxExpPerBattle & expAfterUpgrade;
h & skillLevels & skillRequirements & commanderLevelPremy;
h & allCreatures;
h & creaturesOfLevel;
BONUS_TREE_DESERIALIZATION_FIX
}
};