1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139
|
/*
* DemonSummon.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 "DemonSummon.h"
#include "Registry.h"
#include "../ISpellMechanics.h"
#include "../../battle/CBattleInfoCallback.h"
#include "../../battle/BattleInfo.h"
#include "../../battle/CUnitState.h"
#include "../../networkPacks/PacksForClientBattle.h"
#include "../../serializer/JsonSerializeFormat.h"
VCMI_LIB_NAMESPACE_BEGIN
namespace spells
{
namespace effects
{
int DemonSummon::raisedCreatureAmount(const Mechanics * m, const battle::Unit * unit) const
{
if(!unit || unit->alive() || unit->isGhost())
return 0;
const auto *creatureType = creature.toEntity(m->creatures());
int32_t deadCount = unit->unitBaseAmount();
int32_t deadTotalHealth = unit->getTotalHealth();
int32_t raisedMaxHealth = creatureType->getMaxHealth();
int32_t raisedTotalHealth = m->applySpellBonus(m->getEffectValue(), unit);
// Can't raise stack with more HP than original stack
int32_t maxAmountFromHealth = deadTotalHealth / raisedMaxHealth;
// Can't raise stack with more creatures than original stack
int32_t maxAmountFromAmount = deadCount;
// Can't raise stack with more HP than our spellpower
int32_t maxAmountFromSpellpower = raisedTotalHealth / raisedMaxHealth;
int32_t finalAmount = std::min( { maxAmountFromHealth, maxAmountFromAmount, maxAmountFromSpellpower } );
return finalAmount;
}
void DemonSummon::apply(ServerCallback * server, const Mechanics * m, const EffectTarget & target) const
{
BattleUnitsChanged pack;
pack.battleID = m->battle()->getBattle()->getBattleID();
for(const Destination & dest : target)
{
const battle::Unit * targetStack = dest.unitValue;
//we shall have all targets to be stacks
if(!targetStack || targetStack->alive() || targetStack->isGhost())
{
server->complain("No corpse to demonize! Invalid effect target transformation.");
continue;
}
auto hex = m->battle()->getAvailableHex(targetStack->creatureId(), m->casterSide, targetStack->getPosition().toInt());
if(!hex.isValid())
{
server->complain("No place to put new summon!");
break;
}
int32_t finalAmount = raisedCreatureAmount(m, targetStack);
if(finalAmount < 1)
{
server->complain("Summoning didn't summon any!");
continue;
}
battle::UnitInfo info;
info.id = m->battle()->battleNextUnitId();
info.count = finalAmount;
info.type = creature;
info.side = m->casterSide;
info.position = dest.hexValue;
info.summoned = !permanent;
// add newly created creature
pack.changedStacks.emplace_back(info.id, UnitChanges::EOperation::ADD);
info.save(pack.changedStacks.back().data);
// and remove corpse to prevent second raising or resurrection
pack.changedStacks.emplace_back(targetStack->unitId(), UnitChanges::EOperation::REMOVE);
}
if(!pack.changedStacks.empty())
server->apply(pack);
}
bool DemonSummon::isValidTarget(const Mechanics * m, const battle::Unit * unit) const
{
if(!unit->isDead())
return false;
//check if alive unit blocks rising
for(const BattleHex & hex : unit->getHexes())
{
auto blocking = m->battle()->battleGetUnitsIf([hex, unit](const battle::Unit * other)
{
return other->isValidTarget(false) && other->coversPos(hex) && other != unit;
});
if(!blocking.empty())
return false;
}
if (unit->isGhost())
return false;
if (raisedCreatureAmount(m, unit) == 0)
return false;
return m->isReceptive(unit);
}
void DemonSummon::serializeJsonUnitEffect(JsonSerializeFormat & handler)
{
handler.serializeId("id", creature, CreatureID());
handler.serializeBool("permanent", permanent, false);
}
}
}
VCMI_LIB_NAMESPACE_END
|