1
0
mirror of https://github.com/vcmi/vcmi.git synced 2024-12-22 22:13:35 +02:00
vcmi/lib/mapObjects/CGTownInstance.h

264 lines
9.3 KiB
C++
Raw Normal View History

/*
* CGTownInstance.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 "IMarket.h"
2023-04-26 20:55:56 +02:00
#include "CGDwelling.h"
2024-07-21 12:49:40 +02:00
#include "../entities/faction/CFaction.h" // TODO: remove
#include "../entities/faction/CTown.h" // TODO: remove
VCMI_LIB_NAMESPACE_BEGIN
class CCastleEvent;
2024-08-16 15:16:53 +02:00
class CTown;
class TownBuildingInstance;
struct TownFortifications;
class TownRewardableBuildingInstance;
struct DamageRange;
2024-08-16 15:16:53 +02:00
template<typename ContainedClass>
class LogicalExpression;
class DLL_LINKAGE CTownAndVisitingHero : public CBonusSystemNode
{
public:
CTownAndVisitingHero();
};
struct DLL_LINKAGE GrowthInfo
{
struct Entry
{
int count;
std::string description;
Entry(const std::string &format, int _count);
2023-02-12 22:39:17 +02:00
Entry(int subID, const BuildingID & building, int _count);
Entry(int _count, std::string fullDescription);
};
std::vector<Entry> entries;
int totalGrowth() const;
2024-07-29 22:54:42 +02:00
int handicapPercentage;
};
class DLL_LINKAGE CGTownInstance : public CGDwelling, public IShipyard, public IMarket, public INativeTerrainProvider, public ICreatureUpgrader
{
2023-09-27 23:57:05 +02:00
std::string nameTextId; // name of town
std::map<BuildingID, TownRewardableBuildingInstance*> convertOldBuildings(std::vector<TownRewardableBuildingInstance*> oldVector);
std::set<BuildingID> builtBuildings;
public:
2023-06-07 00:55:21 +02:00
using CGDwelling::getPosition;
enum EFortLevel {NONE = 0, FORT = 1, CITADEL = 2, CASTLE = 3};
CTownAndVisitingHero townAndVis;
const CTown * town;
si32 built; //how many buildings has been built this turn
si32 destroyed; //how many buildings has been destroyed this turn
ConstTransitivePtr<CGHeroInstance> garrisonHero, visitingHero;
ui32 identifier; //special identifier from h3m (only > RoE maps)
PlayerColor alignmentToPlayer; // if set to non-neutral, random town will have same faction as specified player
std::set<BuildingID> forbiddenBuildings;
std::map<BuildingID, TownRewardableBuildingInstance*> rewardableBuildings;
std::vector<SpellID> possibleSpells, obligatorySpells;
std::vector<std::vector<SpellID> > spells; //spells[level] -> vector of spells, first will be available in guild
std::vector<CCastleEvent> events;
2024-08-04 17:52:40 +02:00
std::pair<si32, si32> bonusValue;//var to store town bonuses (rampart = resources from mystic pond, factory = save debts);
2024-10-01 16:32:28 +02:00
int spellResearchCounterDay;
int spellResearchAcceptedCounter;
2024-09-28 14:25:11 +02:00
bool spellResearchAllowed;
//////////////////////////////////////////////////////////////////////////
template <typename Handler> void serialize(Handler &h)
{
h & static_cast<CGDwelling&>(*this);
2023-09-27 23:57:05 +02:00
h & nameTextId;
h & built;
h & destroyed;
h & identifier;
h & garrisonHero;
h & visitingHero;
h & alignmentToPlayer;
h & forbiddenBuildings;
h & builtBuildings;
h & bonusValue;
h & possibleSpells;
h & obligatorySpells;
h & spells;
h & events;
2024-09-28 01:18:10 +02:00
if (h.version >= Handler::Version::SPELL_RESEARCH)
2024-09-28 15:05:13 +02:00
{
2024-10-01 16:32:28 +02:00
h & spellResearchCounterDay;
h & spellResearchAcceptedCounter;
2024-09-28 15:05:13 +02:00
h & spellResearchAllowed;
}
2024-09-28 01:18:10 +02:00
if (h.version >= Handler::Version::NEW_TOWN_BUILDINGS)
{
h & rewardableBuildings;
}
else
{
std::vector<TownRewardableBuildingInstance*> oldVector;
h & oldVector;
rewardableBuildings = convertOldBuildings(oldVector);
}
2024-08-16 15:16:53 +02:00
if (h.saving)
{
CFaction * faction = town ? town->faction : nullptr;
h & faction;
}
else
{
2023-11-04 19:25:50 +02:00
CFaction * faction = nullptr;
h & faction;
town = faction ? faction->town : nullptr;
}
h & townAndVis;
BONUS_TREE_DESERIALIZATION_FIX
if (h.version < Handler::Version::NEW_TOWN_BUILDINGS)
{
std::set<BuildingID> overriddenBuildings;
h & overriddenBuildings;
}
2021-03-23 16:47:07 +02:00
if(!h.saving)
2024-08-16 15:16:53 +02:00
postDeserialize();
}
//////////////////////////////////////////////////////////////////////////
CBonusSystemNode & whatShouldBeAttached() override;
std::string nodeName() const override;
void updateMoraleBonusFromArmy() override;
void deserializationFix();
2024-08-16 15:16:53 +02:00
void postDeserialize();
void recreateBuildingsBonuses();
void setVisitingHero(CGHeroInstance *h);
void setGarrisonedHero(CGHeroInstance *h);
const CArmedInstance *getUpperArmy() const; //garrisoned hero if present or the town itself
std::string getNameTranslated() const;
2023-11-26 18:53:34 +02:00
std::string getNameTextID() const;
2023-09-27 23:57:05 +02:00
void setNameTextId(const std::string & newName);
//////////////////////////////////////////////////////////////////////////
bool passableFor(PlayerColor color) const override;
//int3 getSightCenter() const override; //"center" tile from which the sight distance is calculated
int getSightRadius() const override; //returns sight distance
2023-04-20 19:20:51 +02:00
BoatId getBoatType() const override; //0 - evil (if a ship can be evil...?), 1 - good, 2 - neutral
void getOutOffsets(std::vector<int3> &offsets) const override; //offsets to obj pos when we boat can be placed. Parameter will be cleared
2023-06-07 00:55:21 +02:00
EGeneratorState shipyardStatus() const override;
const IObjectInterface * getObject() const override;
int getMarketEfficiency() const override; //=market count
std::set<EMarketMode> availableModes() const override;
std::vector<TradeItemBuy> availableItemsIds(EMarketMode mode) const override;
2024-08-20 16:15:50 +02:00
ObjectInstanceID getObjInstanceID() const override;
void updateAppearance();
//////////////////////////////////////////////////////////////////////////
bool needsLastStack() const override;
CGTownInstance::EFortLevel fortLevel() const;
TownFortifications fortificationsLevel() const;
int hallLevel() const; // -1 - none, 0 - village, 1 - town, 2 - city, 3 - capitol
int mageGuildLevel() const; // -1 - none, 0 - village, 1 - town, 2 - city, 3 - capitol
int getHordeLevel(const int & HID) const; //HID - 0 or 1; returns creature level or -1 if that horde structure is not present
int creatureGrowth(const int & level) const;
GrowthInfo getGrowthInfo(int level) const;
bool hasFort() const;
bool hasCapitol() const;
2020-10-15 14:03:01 +02:00
bool hasBuiltSomeTradeBuilding() const;
//checks if special building with type buildingID is constructed
bool hasBuilt(BuildingSubID::EBuildingSubID buildingID) const;
//checks if building is constructed and town has same subID
2023-02-12 22:39:17 +02:00
bool hasBuilt(const BuildingID & buildingID) const;
2023-11-02 17:12:58 +02:00
bool hasBuilt(const BuildingID & buildingID, FactionID townID) const;
2024-08-16 17:00:02 +02:00
void addBuilding(const BuildingID & buildingID);
void removeBuilding(const BuildingID & buildingID);
void removeAllBuildings();
std::set<BuildingID> getBuildings() const;
2023-02-12 22:39:17 +02:00
TResources getBuildingCost(const BuildingID & buildingID) const;
ResourceSet dailyIncome() const override;
std::vector<CreatureID> providedCreatures() const override;
int spellsAtLevel(int level, bool checkGuild) const; //levels are counted from 1 (1 - 5)
bool armedGarrison() const; //true if town has creatures in garrison or garrisoned hero
int getTownLevel() const;
2024-07-21 12:49:40 +02:00
LogicalExpression<BuildingID> genBuildingRequirements(const BuildingID & build, bool deep = false) const;
void mergeGarrisonOnSiege() const; // merge garrison into army of visiting hero
2023-02-12 22:39:17 +02:00
void removeCapitols(const PlayerColor & owner) const;
void clearArmy() const;
void addHeroToStructureVisitors(const CGHeroInstance *h, si64 structureInstanceID) const; //hero must be visiting or garrisoned in town
void deleteTownBonus(BuildingID bid);
/// Returns damage range for secondary towers of this town
DamageRange getTowerDamageRange() const;
/// Returns damage range for central tower(keep) of this town
DamageRange getKeepDamageRange() const;
const CTown * getTown() const;
/// INativeTerrainProvider
FactionID getFaction() const override;
TerrainId getNativeTerrain() const override;
/// Returns ID of war machine that is produced by specified building or NONE if this is not built or if building does not produce war machines
ArtifactID getWarMachineInBuilding(BuildingID) const;
/// Returns true if provided war machine is available in any of built buildings of this town
bool isWarMachineAvailable(ArtifactID) const;
2024-01-01 16:37:48 +02:00
CGTownInstance(IGameCallback *cb);
virtual ~CGTownInstance();
///IObjectInterface overrides
void newTurn(vstd::RNG & rand) const override;
void onHeroVisit(const CGHeroInstance * h) const override;
void onHeroLeave(const CGHeroInstance * h) const override;
void initObj(vstd::RNG & rand) override;
void pickRandomObject(vstd::RNG & rand) override;
void battleFinished(const CGHeroInstance * hero, const BattleResult & result) const override;
std::string getObjectName() const override;
void fillUpgradeInfo(UpgradeInfo & info, const CStackInstance &stack) const override;
void afterAddToMap(CMap * map) override;
2022-09-17 13:04:01 +02:00
void afterRemoveFromMap(CMap * map) override;
2020-10-15 14:03:01 +02:00
inline bool isBattleOutsideTown(const CGHeroInstance * defendingHero) const
2021-03-23 16:47:07 +02:00
{
return defendingHero && garrisonHero && defendingHero != garrisonHero;
}
protected:
void setPropertyDer(ObjProperty what, ObjPropertyID identifier) override;
void serializeJsonOptions(JsonSerializeFormat & handler) override;
2020-10-15 14:03:01 +02:00
private:
FactionID randomizeFaction(vstd::RNG & rand);
2023-02-12 22:39:17 +02:00
void setOwner(const PlayerColor & owner) const;
void onTownCaptured(const PlayerColor & winner) const;
int getDwellingBonus(const std::vector<CreatureID>& creatureIds, const std::vector<const CGObjectInstance* >& dwellings) const;
2020-10-15 14:03:01 +02:00
bool townEnvisagesBuilding(BuildingSubID::EBuildingSubID bid) const;
2024-08-16 14:57:38 +02:00
void initializeConfigurableBuildings(vstd::RNG & rand);
void initializeNeutralTownGarrison(vstd::RNG & rand);
};
VCMI_LIB_NAMESPACE_END