1
0
mirror of https://github.com/vcmi/vcmi.git synced 2024-12-04 09:42:40 +02:00
vcmi/lib/CArtHandler.h

344 lines
13 KiB
C
Raw Normal View History

#pragma once
2010-12-17 20:47:07 +02:00
#include "../lib/HeroBonus.h"
//#include "../lib/ConstTransitivePtr.h"
//#include "JsonNode.h"
#include "GameConstants.h"
#include "IHandlerBase.h"
/*
* CArtHandler.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 CArtHandler;
class CDefHandler;
class CArtifact;
class CGHeroInstance;
struct ArtifactLocation;
class CArtifactSet;
class CArtifactInstance;
class CRandomGenerator;
2016-02-13 18:43:05 +02:00
class CMap;
#define ART_BEARER_LIST \
ART_BEARER(HERO)\
ART_BEARER(CREATURE)\
ART_BEARER(COMMANDER)
namespace ArtBearer
{
enum ArtBearer
{
#define ART_BEARER(x) x,
ART_BEARER_LIST
#undef ART_BEARER
};
}
class DLL_LINKAGE CArtifact : public CBonusSystemNode //container for artifacts
{
protected:
std::string name, description; //set if custom
std::string eventText; //short story displayed upon picking
public:
enum EartClass {ART_SPECIAL=1, ART_TREASURE=2, ART_MINOR=4, ART_MAJOR=8, ART_RELIC=16}; //artifact classes
2016-01-24 01:27:14 +02:00
std::string identifier;
std::string image;
std::string large; // big image for cutom artifacts, used in drag & drop
std::string advMapDef; //used for adventure map object
si32 iconIndex;
const std::string &Name() const; //getter
const std::string &Description() const; //getter
const std::string &EventText() const;
bool isBig () const;
bool isTradable () const;
int getArtClassSerial() const; //0 - treasure, 1 - minor, 2 - major, 3 - relic, 4 - spell scroll, 5 - other
std::string nodeName() const override;
void addNewBonus(Bonus *b) override;
virtual void levelUpArtifact (CArtifactInstance * art){};
ui32 price;
std::map<ArtBearer::ArtBearer, std::vector<ArtifactPosition> > possibleSlots; //Bearer Type => ids of slots where artifact can be placed
std::unique_ptr<std::vector<CArtifact *> > constituents; // Artifacts IDs a combined artifact consists of, or nullptr.
std::vector<CArtifact *> constituentOf; // Reverse map of constituents - combined arts that include this art
EartClass aClass;
ArtifactID id;
template <typename Handler> void serialize(Handler &h, const int version)
{
2011-01-18 20:56:14 +02:00
h & static_cast<CBonusSystemNode&>(*this);
h & name & description & eventText & image & large & advMapDef & iconIndex &
price & possibleSlots & constituents & constituentOf & aClass & id;
2016-02-04 11:28:12 +02:00
if(version>=759)
{
h & identifier;
}
}
CArtifact();
~CArtifact();
friend class CArtHandler;
};
class DLL_LINKAGE CGrowingArtifact : public CArtifact //for example commander artifacts getting bonuses after battle
{
public:
std::vector <std::pair <ui16, Bonus> > bonusesPerLevel; //bonus given each n levels
std::vector <std::pair <ui16, Bonus> > thresholdBonuses; //after certain level they will be added once
void levelUpArtifact (CArtifactInstance * art) override;
template <typename Handler> void serialize(Handler &h, const int version)
{
h & static_cast<CArtifact&>(*this);
h & bonusesPerLevel & thresholdBonuses;
}
};
class DLL_LINKAGE CArtifactInstance : public CBonusSystemNode
2010-12-17 20:47:07 +02:00
{
2011-01-18 20:56:14 +02:00
protected:
2010-12-25 03:43:40 +02:00
void init();
2011-01-18 20:56:14 +02:00
CArtifactInstance(CArtifact *Art);
2010-12-17 20:47:07 +02:00
public:
2011-01-18 20:56:14 +02:00
CArtifactInstance();
2013-01-21 21:27:00 +03:00
ConstTransitivePtr<CArtifact> artType;
ArtifactInstanceID id;
2010-12-17 20:47:07 +02:00
2011-01-18 20:56:14 +02:00
//CArtifactInstance(int aid);
2010-12-17 20:47:07 +02:00
std::string nodeName() const override;
void deserializationFix();
2010-12-17 20:47:07 +02:00
void setType(CArtifact *Art);
std::string getEffectiveDescription(const CGHeroInstance *hero = nullptr) const;
2013-02-12 22:49:40 +03:00
ArtifactPosition firstAvailableSlot(const CArtifactSet *h) const;
ArtifactPosition firstBackpackSlot(const CArtifactSet *h) const;
2013-02-13 01:24:48 +03:00
SpellID getGivenSpellID() const; //to be used with scrolls (and similar arts), -1 if none
2010-12-29 23:04:22 +02:00
2013-02-12 22:49:40 +03:00
virtual bool canBePutAt(const CArtifactSet *artSet, ArtifactPosition slot, bool assumeDestRemoved = false) const;
bool canBePutAt(const ArtifactLocation & al, bool assumeDestRemoved = false) const; //forwards to the above one
2010-12-29 23:04:22 +02:00
virtual bool canBeDisassembled() const;
2012-04-14 19:28:36 +03:00
virtual void putAt(ArtifactLocation al);
virtual void removeFrom(ArtifactLocation al);
2016-01-22 11:53:01 +02:00
/// Checks if this a part of this artifact: artifact instance is a part
/// of itself, additionally truth is returned for constituents of combined arts
virtual bool isPart(const CArtifactInstance *supposedPart) const;
std::vector<const CArtifact *> assemblyPossibilities(const CArtifactSet *h) const;
2012-04-14 19:28:36 +03:00
void move(ArtifactLocation src, ArtifactLocation dst);
2010-12-17 20:47:07 +02:00
template <typename Handler> void serialize(Handler &h, const int version)
{
h & static_cast<CBonusSystemNode&>(*this);
h & artType & id;
BONUS_TREE_DESERIALIZATION_FIX
2010-12-17 20:47:07 +02:00
}
static CArtifactInstance *createScroll(const CSpell *s);
static CArtifactInstance *createScroll(SpellID sid);
2011-01-18 20:56:14 +02:00
static CArtifactInstance *createNewArtifactInstance(CArtifact *Art);
static CArtifactInstance *createNewArtifactInstance(int aid);
2016-02-13 18:43:05 +02:00
/**
* Creates an artifact instance.
*
* @param aid the id of the artifact
* @param spellID optional. the id of a spell if a spell scroll object should be created
* @return the created artifact instance
*/
static CArtifactInstance * createArtifact(CMap * map, int aid, int spellID = -1);
2010-12-17 20:47:07 +02:00
};
class DLL_LINKAGE CCombinedArtifactInstance : public CArtifactInstance
2010-12-25 03:43:40 +02:00
{
2011-01-18 20:56:14 +02:00
CCombinedArtifactInstance(CArtifact *Art);
2010-12-25 03:43:40 +02:00
public:
2011-01-18 20:56:14 +02:00
struct ConstituentInfo
{
ConstTransitivePtr<CArtifactInstance> art;
2013-02-12 22:49:40 +03:00
ArtifactPosition slot;
2011-01-18 20:56:14 +02:00
template <typename Handler> void serialize(Handler &h, const int version)
{
h & art & slot;
}
bool operator==(const ConstituentInfo &rhs) const;
ConstituentInfo(CArtifactInstance *art = nullptr, ArtifactPosition slot = ArtifactPosition::PRE_FIRST);
2011-01-18 20:56:14 +02:00
};
std::vector<ConstituentInfo> constituentsInfo;
bool canBePutAt(const CArtifactSet *artSet, ArtifactPosition slot, bool assumeDestRemoved = false) const override;
bool canBeDisassembled() const override;
void putAt(ArtifactLocation al) override;
void removeFrom(ArtifactLocation al) override;
bool isPart(const CArtifactInstance *supposedPart) const override;
2011-01-18 20:56:14 +02:00
void createConstituents();
2013-02-12 22:49:40 +03:00
void addAsConstituent(CArtifactInstance *art, ArtifactPosition slot);
2016-01-22 11:53:01 +02:00
CArtifactInstance *figureMainConstituent(const ArtifactLocation al); //main constituent is replaced with us (combined art), not lock
2011-01-22 05:43:20 +02:00
CCombinedArtifactInstance();
2011-01-18 20:56:14 +02:00
void deserializationFix();
2011-01-18 20:56:14 +02:00
friend class CArtifactInstance;
2011-05-04 05:38:58 +03:00
friend struct AssembledArtifact;
2011-01-18 20:56:14 +02:00
template <typename Handler> void serialize(Handler &h, const int version)
{
h & static_cast<CArtifactInstance&>(*this);
h & constituentsInfo;
BONUS_TREE_DESERIALIZATION_FIX
2011-01-18 20:56:14 +02:00
}
2010-12-25 03:43:40 +02:00
};
class DLL_LINKAGE CArtHandler : public IHandlerBase //handles artifacts
{
public:
2013-02-13 01:24:48 +03:00
std::vector<CArtifact*> treasures, minors, majors, relics; //tmp vectors!!! do not touch if you don't know what you are doing!!!
2010-12-17 20:47:07 +02:00
std::vector< ConstTransitivePtr<CArtifact> > artifacts;
std::vector<CArtifact *> allowedArtifacts;
std::set<ArtifactID> bigArtifacts; // Artifacts that cannot be moved to backpack, e.g. war machines.
std::set<ArtifactID> growingArtifacts;
void addBonuses(CArtifact *art, const JsonNode &bonusList);
void fillList(std::vector<CArtifact*> &listToBeFilled, CArtifact::EartClass artifactClass); //fills given empty list with allowed artifacts of gibven class. No side effects
boost::optional<std::vector<CArtifact*>&> listFromClass(CArtifact::EartClass artifactClass);
ArtifactPosition stringToSlot(std::string slotName);
CArtifact::EartClass stringToClass(std::string className);
/// Gets a artifact ID randomly and removes the selected artifact from this handler.
ArtifactID pickRandomArtifact(CRandomGenerator & rand, int flags);
ArtifactID pickRandomArtifact(CRandomGenerator & rand, std::function<bool(ArtifactID)> accepts);
ArtifactID pickRandomArtifact(CRandomGenerator & rand, int flags, std::function<bool(ArtifactID)> accepts);
2013-02-13 01:24:48 +03:00
bool legalArtifact(ArtifactID id);
//void getAllowedArts(std::vector<ConstTransitivePtr<CArtifact> > &out, std::vector<CArtifact*> *arts, int flag);
//void getAllowed(std::vector<ConstTransitivePtr<CArtifact> > &out, int flags);
bool isBigArtifact (ArtifactID artID) const {return bigArtifacts.find(artID) != bigArtifacts.end();}
bool isTradableArtifact (ArtifactID id) const;
2013-02-05 00:58:42 +03:00
void initAllowedArtifactsList(const std::vector<bool> &allowed); //allowed[art_id] -> 0 if not allowed, 1 if allowed
static ArtifactID creatureToMachineID(CreatureID id);
static CreatureID machineIDToCreature(ArtifactID id);
void makeItCreatureArt (CArtifact * a, bool onlyCreature = true);
2013-02-13 01:24:48 +03:00
void makeItCreatureArt (ArtifactID aid, bool onlyCreature = true);
void makeItCommanderArt (CArtifact * a, bool onlyCommander = true);
2013-02-13 01:24:48 +03:00
void makeItCommanderArt (ArtifactID aid, bool onlyCommander = true);
CArtHandler();
~CArtHandler();
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;
void afterLoadFinalization() override;
std::vector<bool> getDefaultAllowed() const override;
2016-02-21 19:58:09 +02:00
///json serialization helper
static si32 decodeArfifact(const std::string & identifier);
///json serialization helper
static std::string encodeArtifact(const si32 index);
template <typename Handler> void serialize(Handler &h, const int version)
{
h & artifacts & allowedArtifacts & treasures & minors & majors & relics
& growingArtifacts;
//if(!h.saving) sortArts();
}
private:
CArtifact * loadFromJson(const JsonNode & node, const std::string & identifier);
void addSlot(CArtifact * art, const std::string & slotID);
void loadSlots(CArtifact * art, const JsonNode & node);
void loadClass(CArtifact * art, const JsonNode & node);
void loadType(CArtifact * art, const JsonNode & node);
void loadComponents(CArtifact * art, const JsonNode & node);
void loadGrowingArt(CGrowingArtifact * art, const JsonNode & node);
void giveArtBonus(ArtifactID aid, Bonus::BonusType type, int val, int subtype = -1, Bonus::ValueType valType = Bonus::BASE_NUMBER, std::shared_ptr<ILimiter> limiter = std::shared_ptr<ILimiter>(), int additionalinfo = 0);
void giveArtBonus(ArtifactID aid, Bonus::BonusType type, int val, int subtype, std::shared_ptr<IPropagator> propagator, int additionalinfo = 0);
void giveArtBonus(ArtifactID aid, Bonus *bonus);
void erasePickedArt(ArtifactID id);
};
struct DLL_LINKAGE ArtSlotInfo
{
ConstTransitivePtr<CArtifactInstance> artifact;
ui8 locked; //if locked, then artifact points to the combined artifact
2016-01-22 11:53:01 +02:00
ArtSlotInfo() : locked(false) {}
template <typename Handler> void serialize(Handler &h, const int version)
{
h & artifact & locked;
}
};
class DLL_LINKAGE CArtifactSet
{
public:
std::vector<ArtSlotInfo> artifactsInBackpack; //hero's artifacts from bag
std::map<ArtifactPosition, ArtSlotInfo> artifactsWorn; //map<position,artifact_id>; positions: 0 - head; 1 - shoulders; 2 - neck; 3 - right hand; 4 - left hand; 5 - torso; 6 - right ring; 7 - left ring; 8 - feet; 9 - misc1; 10 - misc2; 11 - misc3; 12 - misc4; 13 - mach1; 14 - mach2; 15 - mach3; 16 - mach4; 17 - spellbook; 18 - misc5
ArtSlotInfo &retreiveNewArtSlot(ArtifactPosition slot);
void setNewArtSlot(ArtifactPosition slot, CArtifactInstance *art, bool locked);
2013-02-12 22:49:40 +03:00
void eraseArtSlot(ArtifactPosition slot);
2013-02-12 22:49:40 +03:00
const ArtSlotInfo *getSlot(ArtifactPosition pos) const;
const CArtifactInstance* getArt(ArtifactPosition pos, bool excludeLocked = true) const; //nullptr - no artifact
CArtifactInstance* getArt(ArtifactPosition pos, bool excludeLocked = true); //nullptr - no artifact
2016-01-22 11:53:01 +02:00
/// Looks for equipped artifact with given ID and returns its slot ID or -1 if none
/// (if more than one such artifact lower ID is returned)
ArtifactPosition getArtPos(int aid, bool onlyWorn = true) const;
2013-02-12 22:49:40 +03:00
ArtifactPosition getArtPos(const CArtifactInstance *art) const;
const CArtifactInstance *getArtByInstanceId(ArtifactInstanceID artInstId) const;
2016-01-22 11:53:01 +02:00
/// Search for constituents of assemblies in backpack which do not have an ArtifactPosition
const CArtifactInstance *getHiddenArt(int aid) const;
const CCombinedArtifactInstance *getAssemblyByConstituent(int aid) const;
/// Checks if hero possess artifact of given id (either in backack or worn)
bool hasArt(ui32 aid, bool onlyWorn = false, bool searchBackpackAssemblies = false) const;
2013-02-12 22:49:40 +03:00
bool isPositionFree(ArtifactPosition pos, bool onlyLockCheck = false) const;
si32 getArtTypeId(ArtifactPosition pos) const;
virtual ArtBearer::ArtBearer bearerType() const = 0;
virtual ~CArtifactSet();
template <typename Handler> void serialize(Handler &h, const int version)
{
h & artifactsInBackpack & artifactsWorn;
}
2013-01-21 21:27:00 +03:00
void artDeserializationFix(CBonusSystemNode *node);
2016-01-24 01:27:14 +02:00
protected:
void writeJson(JsonNode & json) const;
void readJson(const JsonNode & json);
2016-01-22 11:53:01 +02:00
protected:
std::pair<const CCombinedArtifactInstance *, const CArtifactInstance *> searchForConstituent(int aid) const;
};