1
0
mirror of https://github.com/vcmi/vcmi.git synced 2024-12-12 10:03:53 +02:00
vcmi/lib/bonuses/Bonus.cpp

305 lines
8.1 KiB
C++
Raw Normal View History

2012-12-19 17:54:10 +03:00
/*
2023-05-01 19:29:53 +02:00
* Bonus.cpp, part of VCMI engine
2012-12-19 17:54:10 +03:00
*
* 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
*
*/
#include "StdInc.h"
2023-05-01 19:29:53 +02:00
#include "Bonus.h"
#include "CBonusSystemNode.h"
2023-04-30 15:52:48 +02:00
#include "Limiters.h"
#include "Updaters.h"
#include "Propagators.h"
#include "../VCMI_Lib.h"
#include "../spells/CSpellHandler.h"
#include "../CCreatureHandler.h"
#include "../CCreatureSet.h"
#include "../CHeroHandler.h"
#include "../CTownHandler.h"
#include "../CGeneralTextHandler.h"
#include "../CSkillHandler.h"
#include "../CArtHandler.h"
#include "../CModHandler.h"
#include "../TerrainHandler.h"
#include "../StringConstants.h"
#include "../battle/BattleInfo.h"
2010-04-03 06:33:46 +03:00
VCMI_LIB_NAMESPACE_BEGIN
2023-03-13 23:26:44 +02:00
//This constructor should be placed here to avoid side effects
CAddInfo::CAddInfo() = default;
CAddInfo::CAddInfo(si32 value)
{
if(value != CAddInfo::NONE)
push_back(value);
}
bool CAddInfo::operator==(si32 value) const
{
switch(size())
{
case 0:
return value == CAddInfo::NONE;
case 1:
return operator[](0) == value;
default:
return false;
}
}
bool CAddInfo::operator!=(si32 value) const
{
return !operator==(value);
}
si32 & CAddInfo::operator[](size_type pos)
{
if(pos >= size())
resize(pos + 1, CAddInfo::NONE);
return vector::operator[](pos);
}
si32 CAddInfo::operator[](size_type pos) const
{
return pos < size() ? vector::operator[](pos) : CAddInfo::NONE;
}
std::string CAddInfo::toString() const
{
return toJsonNode().toJson(true);
}
JsonNode CAddInfo::toJsonNode() const
{
if(size() < 2)
{
return JsonUtils::intNode(operator[](0));
}
else
{
JsonNode node(JsonNode::JsonType::DATA_VECTOR);
for(si32 value : *this)
node.Vector().push_back(JsonUtils::intNode(value));
return node;
}
}
2023-04-16 19:42:56 +02:00
std::string Bonus::Description(std::optional<si32> customValue) const
{
std::ostringstream str;
2016-08-18 14:03:20 +02:00
if(description.empty())
{
if(stacking.empty() || stacking == "ALWAYS")
{
switch(source)
{
case BonusSource::ARTIFACT:
str << ArtifactID(sid).toArtifact(VLC->artifacts())->getNameTranslated();
break;
case BonusSource::SPELL_EFFECT:
str << SpellID(sid).toSpell(VLC->spells())->getNameTranslated();
break;
case BonusSource::CREATURE_ABILITY:
str << CreatureID(sid).toCreature(VLC->creatures())->getNamePluralTranslated();
break;
case BonusSource::SECONDARY_SKILL:
str << VLC->skills()->getByIndex(sid)->getNameTranslated();
break;
case BonusSource::HERO_SPECIAL:
str << VLC->heroTypes()->getByIndex(sid)->getNameTranslated();
break;
default:
//todo: handle all possible sources
str << "Unknown";
break;
}
}
else
str << stacking;
}
else
{
str << description;
}
2016-08-18 14:03:20 +02:00
if(auto value = customValue.value_or(val))
str << " " << std::showpos << value;
2016-08-18 14:03:20 +02:00
return str.str();
}
static JsonNode subtypeToJson(BonusType type, int subtype)
{
switch(type)
{
case BonusType::PRIMARY_SKILL:
return JsonUtils::stringNode("primSkill." + PrimarySkill::names[subtype]);
case BonusType::SPECIAL_SPELL_LEV:
case BonusType::SPECIFIC_SPELL_DAMAGE:
case BonusType::SPELL:
case BonusType::SPECIAL_PECULIAR_ENCHANT:
case BonusType::SPECIAL_ADD_VALUE_ENCHANT:
case BonusType::SPECIAL_FIXED_VALUE_ENCHANT:
return JsonUtils::stringNode(CModHandler::makeFullIdentifier("", "spell", SpellID::encode(subtype)));
case BonusType::IMPROVED_NECROMANCY:
case BonusType::SPECIAL_UPGRADE:
return JsonUtils::stringNode(CModHandler::makeFullIdentifier("", "creature", CreatureID::encode(subtype)));
case BonusType::GENERATE_RESOURCE:
return JsonUtils::stringNode("resource." + GameConstants::RESOURCE_NAMES[subtype]);
default:
2017-09-12 10:56:59 +02:00
return JsonUtils::intNode(subtype);
}
2017-09-12 10:56:59 +02:00
}
static JsonNode additionalInfoToJson(BonusType type, CAddInfo addInfo)
2017-09-12 10:56:59 +02:00
{
switch(type)
{
case BonusType::SPECIAL_UPGRADE:
return JsonUtils::stringNode(CModHandler::makeFullIdentifier("", "creature", CreatureID::encode(addInfo[0])));
2017-09-12 10:56:59 +02:00
default:
return addInfo.toJsonNode();
}
}
JsonNode Bonus::toJsonNode() const
{
2017-09-12 10:56:59 +02:00
JsonNode root(JsonNode::JsonType::DATA_STRUCT);
// only add values that might reasonably be found in config files
root["type"].String() = vstd::findKey(bonusNameMap, type);
if(subtype != -1)
root["subtype"] = subtypeToJson(type, subtype);
if(additionalInfo != CAddInfo::NONE)
2017-09-12 10:56:59 +02:00
root["addInfo"] = additionalInfoToJson(type, additionalInfo);
if(turnsRemain != 0)
root["turns"].Integer() = turnsRemain;
if(source != BonusSource::OTHER)
root["sourceType"].String() = vstd::findKey(bonusSourceMap, source);
if(targetSourceType != BonusSource::OTHER)
root["targetSourceType"].String() = vstd::findKey(bonusSourceMap, targetSourceType);
if(sid != 0)
root["sourceID"].Integer() = sid;
if(val != 0)
root["val"].Integer() = val;
if(valType != BonusValueType::ADDITIVE_VALUE)
root["valueType"].String() = vstd::findKey(bonusValueMap, valType);
if(!stacking.empty())
root["stacking"].String() = stacking;
if(!description.empty())
root["description"].String() = description;
if(effectRange != BonusLimitEffect::NO_LIMIT)
root["effectRange"].String() = vstd::findKey(bonusLimitEffect, effectRange);
if(duration != BonusDuration::PERMANENT)
root["duration"] = BonusDuration::toJson(duration);
if(turnsRemain)
root["turns"].Integer() = turnsRemain;
if(limiter)
root["limiters"] = limiter->toJsonNode();
if(updater)
root["updater"] = updater->toJsonNode();
if(propagator)
root["propagator"].String() = vstd::findKey(bonusPropagatorMap, propagator);
return root;
}
Bonus::Bonus(BonusDuration::Type Duration, BonusType Type, BonusSource Src, si32 Val, ui32 ID, std::string Desc, si32 Subtype):
duration(Duration),
2023-03-13 23:26:44 +02:00
type(Type),
subtype(Subtype),
source(Src),
val(Val),
sid(ID),
description(std::move(Desc))
{
boost::algorithm::trim(description);
targetSourceType = BonusSource::OTHER;
}
Bonus::Bonus(BonusDuration::Type Duration, BonusType Type, BonusSource Src, si32 Val, ui32 ID, si32 Subtype, BonusValueType ValType):
duration(Duration),
2023-03-13 23:26:44 +02:00
type(Type),
subtype(Subtype),
source(Src),
val(Val),
sid(ID),
valType(ValType)
{
turnsRemain = 0;
effectRange = BonusLimitEffect::NO_LIMIT;
targetSourceType = BonusSource::OTHER;
}
2023-03-13 23:26:44 +02:00
std::shared_ptr<Bonus> Bonus::addPropagator(const TPropagatorPtr & Propagator)
{
propagator = Propagator;
return this->shared_from_this();
}
DLL_LINKAGE std::ostream & operator<<(std::ostream &out, const Bonus &bonus)
{
2023-03-13 23:26:44 +02:00
for(const auto & i : bonusNameMap)
if(i.second == bonus.type)
out << "\tType: " << i.first << " \t";
#define printField(field) out << "\t" #field ": " << (int)bonus.field << "\n"
printField(val);
printField(subtype);
printField(duration.to_ulong());
printField(source);
printField(sid);
if(bonus.additionalInfo != CAddInfo::NONE)
out << "\taddInfo: " << bonus.additionalInfo.toString() << "\n";
printField(turnsRemain);
printField(valType);
if(!bonus.stacking.empty())
out << "\tstacking: \"" << bonus.stacking << "\"\n";
printField(effectRange);
#undef printField
if(bonus.limiter)
out << "\tLimiter: " << bonus.limiter->toString() << "\n";
2017-09-11 02:36:02 +02:00
if(bonus.updater)
out << "\tUpdater: " << bonus.updater->toString() << "\n";
return out;
}
2013-01-20 15:06:18 +03:00
2023-03-13 23:26:44 +02:00
std::shared_ptr<Bonus> Bonus::addLimiter(const TLimiterPtr & Limiter)
{
2013-01-20 15:06:18 +03:00
if (limiter)
{
//If we already have limiter list, retrieve it
auto limiterList = std::dynamic_pointer_cast<AllOfLimiter>(limiter);
2013-01-20 15:06:18 +03:00
if(!limiterList)
{
//Create a new limiter list with old limiter and the new one will be pushed later
limiterList = std::make_shared<AllOfLimiter>();
2013-01-20 15:06:18 +03:00
limiterList->add(limiter);
limiter = limiterList;
}
limiterList->add(Limiter);
}
else
{
limiter = Limiter;
}
return this->shared_from_this();
}
2017-09-10 05:20:47 +02:00
// Updaters
2023-03-13 23:26:44 +02:00
std::shared_ptr<Bonus> Bonus::addUpdater(const TUpdaterPtr & Updater)
{
updater = Updater;
return this->shared_from_this();
}
VCMI_LIB_NAMESPACE_END