1
0
mirror of https://github.com/vcmi/vcmi.git synced 2024-12-22 22:13:35 +02:00
vcmi/lib/rewardable/Reward.cpp

154 lines
5.1 KiB
C++
Raw Normal View History

2023-04-30 15:13:07 +02:00
/*
* Reward.cpp, 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
*
*/
#include "StdInc.h"
#include "Reward.h"
#include "../mapObjects/CGHeroInstance.h"
2023-09-15 10:06:06 +02:00
#include "../serializer/JsonSerializeFormat.h"
#include "../constants/StringConstants.h"
#include "../CSkillHandler.h"
2023-04-30 15:13:07 +02:00
VCMI_LIB_NAMESPACE_BEGIN
Rewardable::Reward::Reward()
: heroExperience(0)
, heroLevel(0)
, manaDiff(0)
, manaPercentage(-1)
, movePoints(0)
, movePercentage(-1)
, primary(4, 0)
, removeObject(false)
, spellCast(SpellID::NONE, SecSkillLevel::NONE)
{
}
Rewardable::Reward::~Reward() = default;
2023-04-30 15:13:07 +02:00
si32 Rewardable::Reward::calculateManaPoints(const CGHeroInstance * hero) const
{
si32 manaScaled = hero->mana;
if (manaPercentage >= 0)
manaScaled = hero->manaLimit() * manaPercentage / 100;
si32 manaMissing = std::max(0, hero->manaLimit() - manaScaled);
si32 manaGranted = std::min(manaMissing, manaDiff);
si32 manaOverflow = manaDiff - manaGranted;
si32 manaOverLimit = manaOverflow * manaOverflowFactor / 100;
si32 manaOutput = manaScaled + manaGranted + manaOverLimit;
return manaOutput;
}
Component Rewardable::Reward::getDisplayedComponent(const CGHeroInstance * h) const
{
std::vector<Component> comps;
loadComponents(comps, h);
assert(!comps.empty());
return comps.front();
}
void Rewardable::Reward::loadComponents(std::vector<Component> & comps,
const CGHeroInstance * h) const
{
for (auto comp : extraComponents)
comps.push_back(comp);
2023-09-17 16:04:34 +02:00
for (auto & bonus : bonuses)
{
if (bonus.type == BonusType::MORALE)
comps.emplace_back(Component::EComponentType::MORALE, 0, bonus.val, 0);
if (bonus.type == BonusType::LUCK)
comps.emplace_back(Component::EComponentType::LUCK, 0, bonus.val, 0);
}
2023-04-30 15:13:07 +02:00
if (heroExperience)
{
comps.emplace_back(Component::EComponentType::EXPERIENCE, 0, static_cast<si32>(h->calculateXp(heroExperience)), 0);
}
if (heroLevel)
comps.emplace_back(Component::EComponentType::EXPERIENCE, 1, heroLevel, 0);
if (manaDiff || manaPercentage >= 0)
comps.emplace_back(Component::EComponentType::PRIM_SKILL, 5, calculateManaPoints(h) - h->mana, 0);
for (size_t i=0; i<primary.size(); i++)
{
if (primary[i] != 0)
comps.emplace_back(Component::EComponentType::PRIM_SKILL, static_cast<ui16>(i), primary[i], 0);
}
for(const auto & entry : secondary)
comps.emplace_back(Component::EComponentType::SEC_SKILL, entry.first, entry.second, 0);
for(const auto & entry : artifacts)
comps.emplace_back(Component::EComponentType::ARTIFACT, entry, 1, 0);
for(const auto & entry : spells)
comps.emplace_back(Component::EComponentType::SPELL, entry, 1, 0);
for(const auto & entry : creatures)
comps.emplace_back(Component::EComponentType::CREATURE, entry.type->getId(), entry.count, 0);
for (size_t i=0; i<resources.size(); i++)
{
if (resources[i] !=0)
comps.emplace_back(Component::EComponentType::RESOURCE, static_cast<ui16>(i), resources[i], 0);
}
}
2023-09-15 10:06:06 +02:00
void Rewardable::Reward::serializeJson(JsonSerializeFormat & handler)
{
resources.serializeJson(handler, "resources");
handler.serializeBool("removeObject", removeObject);
handler.serializeInt("manaPercentage", manaPercentage);
handler.serializeInt("movePercentage", movePercentage);
handler.serializeInt("heroExperience", heroExperience);
handler.serializeInt("heroLevel", heroLevel);
handler.serializeInt("manaDiff", manaDiff);
handler.serializeInt("manaOverflowFactor", manaOverflowFactor);
handler.serializeInt("movePoints", movePoints);
handler.serializeIdArray("artifacts", artifacts);
handler.serializeIdArray("spells", spells);
handler.enterArray("creatures").serializeStruct(creatures);
2023-09-17 22:19:45 +02:00
handler.enterArray("primary").serializeArray(primary);
2023-09-15 10:06:06 +02:00
{
auto a = handler.enterArray("secondary");
2023-09-17 22:19:45 +02:00
std::vector<std::pair<SecondarySkill, si32>> fieldValue(secondary.begin(), secondary.end());
a.serializeStruct<std::pair<SecondarySkill, si32>>(fieldValue, [](JsonSerializeFormat & h, std::pair<SecondarySkill, si32> & e)
2023-09-15 10:06:06 +02:00
{
2023-09-17 22:19:45 +02:00
h.serializeId("skill", e.first, SecondarySkill{}, VLC->skillh->decodeSkill, VLC->skillh->encodeSkill);
h.serializeId("level", e.second, 0, [](const std::string & i){return vstd::find_pos(NSecondarySkill::levels, i);}, [](si32 i){return NSecondarySkill::levels.at(i);});
});
2023-09-15 10:06:06 +02:00
a.syncSize(fieldValue);
2023-09-17 22:19:45 +02:00
secondary = std::map<SecondarySkill, si32>(fieldValue.begin(), fieldValue.end());
2023-09-15 10:06:06 +02:00
}
{
auto a = handler.enterArray("creaturesChange");
2023-09-17 22:19:45 +02:00
std::vector<std::pair<CreatureID, CreatureID>> fieldValue(creaturesChange.begin(), creaturesChange.end());
a.serializeStruct<std::pair<CreatureID, CreatureID>>(fieldValue, [](JsonSerializeFormat & h, std::pair<CreatureID, CreatureID> & e)
2023-09-15 10:06:06 +02:00
{
2023-09-17 22:19:45 +02:00
h.serializeId("creature", e.first, CreatureID{});
h.serializeId("amount", e.second, CreatureID{});
});
creaturesChange = std::map<CreatureID, CreatureID>(fieldValue.begin(), fieldValue.end());
2023-09-15 10:06:06 +02:00
}
{
auto a = handler.enterStruct("spellCast");
a->serializeId("spell", spellCast.first, SpellID{});
a->serializeInt("level", spellCast.second);
}
}
2023-04-30 15:13:07 +02:00
VCMI_LIB_NAMESPACE_END