1
0
mirror of https://github.com/vcmi/vcmi.git synced 2024-12-24 22:14:36 +02:00
vcmi/lib/spells/effects/Damage.cpp
AlexVinS ecaa9f5d0b Entities redesign and a few ERM features
* Made most Handlers derived from CHandlerBase and moved service API there.
* Declared existing Entity APIs.
* Added basic script context caching
* Started Lua script module
* Started Lua spell effect API
* Started script state persistence
* Started battle info callback binding
* CommitPackage removed
* Extracted spells::Caster to own header; Expanded Spell API.
* implemented !!MC:S, !!FU:E, !!FU:P, !!MA, !!VR:H, !!VR:C
* !!BU:C, !!BU:E, !!BU:G, !!BU:M implemented
* Allow use of "MC:S@varName@" to declare normal variable (technically v-variable with string key)
* Re-enabled VERM macros.
* !?GM0 added
* !?TM implemented
* Added !!MF:N
* Started !?OB, !!BM, !!HE, !!OW, !!UN
* Added basic support of w-variables
* Added support for ERM indirect variables
* Made !?FU regular trigger
* !!re (ERA loop receiver) implemented
* Fixed ERM receivers with zero args.
2021-02-14 19:05:43 +03:00

228 lines
5.2 KiB
C++

/*
* Damage.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 "Damage.h"
#include "Registry.h"
#include "../ISpellMechanics.h"
#include "../../NetPacks.h"
#include "../../CStack.h"
#include "../../battle/IBattleState.h"
#include "../../battle/CBattleInfoCallback.h"
#include "../../CGeneralTextHandler.h"
#include "../../serializer/JsonSerializeFormat.h"
static const std::string EFFECT_NAME = "core:damage";
namespace spells
{
namespace effects
{
VCMI_REGISTER_SPELL_EFFECT(Damage, EFFECT_NAME);
Damage::Damage()
: UnitEffect(),
customEffectId(-1),
killByPercentage(false),
killByCount(false)
{
}
Damage::~Damage() = default;
void Damage::apply(ServerCallback * server, const Mechanics * m, const EffectTarget & target) const
{
StacksInjured stacksInjured;
BattleLogMessage blm;
size_t targetIndex = 0;
const battle::Unit * firstTarget = nullptr;
const bool describe = server->describeChanges();
int64_t damageToDisplay = 0;
uint32_t killed = 0;
bool multiple = false;
for(auto & t : target)
{
const battle::Unit * unit = t.unitValue;
if(unit && unit->alive())
{
BattleStackAttacked bsa;
bsa.damageAmount = damageForTarget(targetIndex, m, unit);
bsa.stackAttacked = unit->unitId();
bsa.attackerID = -1;
auto newState = unit->acquireState();
CStack::prepareAttacked(bsa, *server->getRNG(), newState);
if(describe)
{
if(!firstTarget)
firstTarget = unit;
else
multiple = true;
damageToDisplay += bsa.damageAmount;
killed += bsa.killedAmount;
}
if(customEffectId >= 0)
{
bsa.effect = 82;
bsa.flags |= BattleStackAttacked::EFFECT;
}
stacksInjured.stacks.push_back(bsa);
}
targetIndex++;
}
if(describe && firstTarget && damageToDisplay > 0)
{
describeEffect(blm.lines, m, firstTarget, killed, damageToDisplay, multiple);
}
if(!stacksInjured.stacks.empty())
server->apply(&stacksInjured);
if(!blm.lines.empty())
server->apply(&blm);
}
bool Damage::isReceptive(const Mechanics * m, const battle::Unit * unit) const
{
if(!UnitEffect::isReceptive(m, unit))
return false;
//elemental immunity for damage
auto filter = m->getElementalImmunity();
for(auto element : filter)
{
if(!m->isPositiveSpell() && unit->hasBonusOfType(element, 2))
return false;
}
return true;
}
void Damage::serializeJsonUnitEffect(JsonSerializeFormat & handler)
{
handler.serializeInt("customEffectId", customEffectId, -1);
handler.serializeBool("killByPercentage", killByPercentage);
handler.serializeBool("killByCount", killByCount);
}
int64_t Damage::damageForTarget(size_t targetIndex, const Mechanics * m, const battle::Unit * target) const
{
int64_t baseDamage;
if(killByPercentage)
{
int64_t amountToKill = target->getCount() * m->getEffectValue() / 100;
baseDamage = amountToKill * target->MaxHealth();
}
else if(killByCount)
{
baseDamage = m->getEffectValue() * target->MaxHealth();
}
else
{
baseDamage = m->adjustEffectValue(target);
}
if(chainLength > 1 && targetIndex > 0)
{
double indexedFactor = std::pow(chainFactor, (double) targetIndex);
return (int64_t) (indexedFactor * baseDamage);
}
return baseDamage;
}
void Damage::describeEffect(std::vector<MetaString> & log, const Mechanics * m, const battle::Unit * firstTarget, uint32_t kills, int64_t damage, bool multiple) const
{
if(m->getSpellIndex() == SpellID::DEATH_STARE && !multiple)
{
MetaString line;
if(kills > 1)
{
line.addTxt(MetaString::GENERAL_TXT, 119); //%d %s die under the terrible gaze of the %s.
line.addReplacement(kills);
firstTarget->addNameReplacement(line, true);
}
else
{
line.addTxt(MetaString::GENERAL_TXT, 118); //One %s dies under the terrible gaze of the %s.
firstTarget->addNameReplacement(line, false);
}
m->caster->getCasterName(line);
log.push_back(line);
}
else if(m->getSpellIndex() == SpellID::THUNDERBOLT && !multiple)
{
{
MetaString line;
firstTarget->addText(line, MetaString::GENERAL_TXT, -367, true);
firstTarget->addNameReplacement(line, true);
log.push_back(line);
}
{
MetaString line;
//todo: handle newlines in metastring
std::string text = VLC->generaltexth->allTexts.at(343); //Does %d points of damage.
boost::algorithm::trim(text);
line << text;
line.addReplacement((int)damage); //no more text afterwards
log.push_back(line);
}
}
else
{
{
MetaString line;
line.addTxt(MetaString::GENERAL_TXT, 376);
line.addReplacement(MetaString::SPELL_NAME, m->getSpellIndex());
line.addReplacement((int)damage);
log.push_back(line);
}
{
MetaString line;
const int textId = (kills > 1) ? 379 : 378;
line.addTxt(MetaString::GENERAL_TXT, textId);
if(kills > 1)
line.addReplacement(kills);
if(kills > 1)
{
if(multiple)
line.addReplacement(MetaString::GENERAL_TXT, 43);
else
firstTarget->addNameReplacement(line, true);
}
else
{
if(multiple)
line.addReplacement(MetaString::GENERAL_TXT, 42);
else
firstTarget->addNameReplacement(line, false);
}
log.push_back(line);
}
}
}
}
}