okooooooo/EVEngine
1
0 Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Files
ad38d51c295a8b1b9f95bf1d6f42994de3696f76
EVEngine/test/rpg.cpp
T

864 lines
30 KiB
C++
Raw Blame History

#include "zeroerr/assert.h"
#include "zeroerr/unittest.h"
#include "rpg/AttributeTypes.h"
#include "rpg/AttributeSystem.h"
#include "rpg/RPGActor.h"
#include "rpg/Effect.h"
#include "rpg/StatusSystem.h"
#include "rpg/Skill.h"
#include "rpg/SkillSystem.h"
#include "rpg/Settlement.h"
#include "rpg/RPG.h"
#include <cmath>
#include <string>
#include <vector>
using namespace eve::rpg;
namespace {
bool approxEq(double a, double b, double eps = 1e-9) { return std::abs(a - b) < eps; }
} // namespace
// ---------------------------------------------------------------------------
// Attribute math (pure function, no ECS)
// ---------------------------------------------------------------------------
TEST_CASE("rpg.attribute.pureCompute.addMulAddMulMul") {
AttributeValue av;
av.base = 100.0;
av.modifiers.push_back({"m1", "src", "add", 10.0, 0});
av.modifiers.push_back({"m2", "src", "mulAdd", 0.5, 0}); // +50%
av.modifiers.push_back({"m3", "src", "mulMul", 0.1, 0}); // *1.1
// (100 + 10) * (1 + 0.5) * (1 + 0.1) = 181.5
CHECK(approxEq(computeAttributeValue(av), 181.5));
}
TEST_CASE("rpg.attribute.pureCompute.overridePriorityWins") {
AttributeValue av;
av.base = 5.0;
av.modifiers.push_back({"a", "src", "override", 50.0, 5});
av.modifiers.push_back({"b", "src", "override", 20.0, 1}); // lower priority: applied first
// sequential ascending priority: override 20 first, then override 50 -> final 50
CHECK_EQ(computeAttributeValue(av), 50.0);
}
TEST_CASE("rpg.attribute.pureCompute.clamp") {
AttributeValue av;
av.base = 200.0;
av.modifiers.push_back({"a", "src", "clampMax", 100.0, 0});
av.modifiers.push_back({"b", "src", "clampMin", 10.0, 0});
CHECK_EQ(computeAttributeValue(av), 100.0);
}
TEST_CASE("rpg.attribute.pureCompute.customOp") {
AttributeOpTable table;
table.registerOp("square", [](double, double value) { return value * value; });
AttributeValue av;
av.base = 1.0;
av.modifiers.push_back({"a", "src", "square", 4.0, 0});
CHECK_EQ(computeAttributeValue(av, &table), 16.0);
// Unknown custom op falls back to leaving result untouched.
AttributeValue av2;
av2.base = 7.0;
av2.modifiers.push_back({"a", "src", "totallyUnknownOp", 4.0, 0});
CHECK_EQ(computeAttributeValue(av2, &table), 7.0);
}
// ---------------------------------------------------------------------------
// AttributeSystem (actor-facing, with caching)
// ---------------------------------------------------------------------------
TEST_CASE("rpg.attributeSystem.setGetFinalWithModifiers") {
RPGActor *actor = RPGActor::createActor();
actor->setBaseAttribute("strength", 10.0);
CHECK_EQ(actor->getBaseAttribute("strength"), 10.0);
CHECK(actor->hasAttribute("strength"));
CHECK(!actor->hasAttribute("nope"));
CHECK_EQ(actor->getFinalAttribute("strength"), 10.0);
std::string modId = actor->addAttributeModifier("strength", "gear:sword", "add", 5.0);
CHECK(!modId.empty());
CHECK_EQ(actor->getFinalAttribute("strength"), 15.0);
actor->modifyBaseAttribute("strength", 2.0);
CHECK_EQ(actor->getBaseAttribute("strength"), 12.0);
CHECK_EQ(actor->getFinalAttribute("strength"), 17.0);
CHECK(actor->removeAttributeModifier("strength", modId));
CHECK_EQ(actor->getFinalAttribute("strength"), 12.0);
// Removing again is a no-op.
CHECK(!actor->removeAttributeModifier("strength", modId));
actor->release();
}
TEST_CASE("rpg.attributeSystem.removeBySource") {
RPGActor *actor = RPGActor::createActor();
actor->setBaseAttribute("hp", 100.0);
actor->addAttributeModifier("hp", "buffA", "add", 10.0);
actor->addAttributeModifier("hp", "buffA", "add", 5.0);
actor->addAttributeModifier("mana", "buffA", "add", 20.0);
actor->setBaseAttribute("mana", 50.0);
CHECK_EQ(actor->getFinalAttribute("hp"), 115.0);
CHECK_EQ(actor->removeAttributeModifiersBySource("hp", "buffA"), 2);
CHECK_EQ(actor->getFinalAttribute("hp"), 100.0);
CHECK_EQ(actor->getFinalAttribute("mana"), 70.0);
CHECK_EQ(actor->removeAllAttributeModifiersBySource("buffA"), 1);
CHECK_EQ(actor->getFinalAttribute("mana"), 50.0);
actor->release();
}
// ---------------------------------------------------------------------------
// Effect registry
// ---------------------------------------------------------------------------
TEST_CASE("rpg.effect.registryCRUD") {
EffectDefinition def;
def.id = "test.effect.crud";
def.durationPolicy = "duration";
def.duration = 3.f;
def.modifiers.push_back({"attack", "mulAdd", 0.2, 0});
def.tags = {"buff"};
EffectRegistry::registerEffect(def);
const EffectDefinition *found = EffectRegistry::find("test.effect.crud");
REQUIRE(found != nullptr);
CHECK_EQ(found->duration, 3.f);
CHECK(found->hasTag("buff"));
CHECK(EffectRegistry::remove("test.effect.crud"));
CHECK(EffectRegistry::find("test.effect.crud") == nullptr);
}
TEST_CASE("rpg.effect.loadFromJsonArray") {
const char *json = R"([
{"id":"test.effect.json.a","durationPolicy":"duration","duration":2,
"modifiers":[{"attribute":"speed","op":"add","value":3}]},
{"id":"test.effect.json.b","durationPolicy":"infinite","period":1,
"stackPolicy":"stack","maxStacks":3,"tags":["dot","poison"]}
])";
std::string err;
int n = EffectRegistry::loadFromJson(json, &err);
CHECK_EQ(n, 2);
CHECK(err.empty());
const EffectDefinition *a = EffectRegistry::find("test.effect.json.a");
REQUIRE(a != nullptr);
CHECK_EQ(a->duration, 2.f);
REQUIRE(a->modifiers.size() == 1);
CHECK_EQ(a->modifiers[0].attribute, "speed");
const EffectDefinition *b = EffectRegistry::find("test.effect.json.b");
REQUIRE(b != nullptr);
CHECK_EQ(b->period, 1.f);
CHECK_EQ(b->maxStacks, 3);
CHECK(b->hasTag("poison"));
EffectRegistry::remove("test.effect.json.a");
EffectRegistry::remove("test.effect.json.b");
}
TEST_CASE("rpg.effect.loadFromJsonExtraAndGetExtra") {
const char *json = R"({
"id":"test.effect.extra","durationPolicy":"duration","duration":3,
"tags":["buff"],
"extra":{"icon":"ui/power.png","vfx":"fx.glow"}
})";
std::string err;
CHECK_EQ(EffectRegistry::loadFromJson(json, &err), 1);
CHECK(err.empty());
const EffectDefinition *def = EffectRegistry::find("test.effect.extra");
REQUIRE(def != nullptr);
CHECK_EQ(def->getExtra("icon"), "ui/power.png");
CHECK_EQ(def->getExtra("vfx"), "fx.glow");
CHECK_EQ(def->getExtra("missing", "fallback"), "fallback");
EffectRegistry::remove("test.effect.extra");
}
// ---------------------------------------------------------------------------
// StatusSystem: instant / duration / stacking / periodic ticks
// ---------------------------------------------------------------------------
TEST_CASE("rpg.status.instantEffectAppliesImmediatelyNoInstance") {
EffectDefinition heal;
heal.id = "test.status.instantHeal";
heal.durationPolicy = "instant";
heal.modifiers.push_back({"health", "add", 25.0, 0});
EffectRegistry::registerEffect(heal);
RPGActor *actor = RPGActor::createActor();
actor->setBaseAttribute("health", 50.0);
int result = actor->applyEffect("test.status.instantHeal");
CHECK_EQ(result, 0);
CHECK_EQ(actor->getBaseAttribute("health"), 75.0);
CHECK_EQ(actor->getStatusCount(), 0);
actor->release();
EffectRegistry::remove("test.status.instantHeal");
}
TEST_CASE("rpg.status.durationBuffAppliesAndExpires") {
EffectDefinition buff;
buff.id = "test.status.durationBuff";
buff.durationPolicy = "duration";
buff.duration = 1.0f;
buff.modifiers.push_back({"attack", "add", 10.0, 0});
EffectRegistry::registerEffect(buff);
RPGActor *actor = RPGActor::createActor();
actor->setBaseAttribute("attack", 20.0);
int instanceId = actor->applyEffect("test.status.durationBuff", "test-source");
CHECK(instanceId > 0);
CHECK_EQ(actor->getFinalAttribute("attack"), 30.0);
CHECK_EQ(actor->getStatusCount(), 1);
CHECK(actor->hasEffect("test.status.durationBuff"));
CHECK(StatusSystem::update(0.5).ok());
CHECK_EQ(actor->getStatusCount(), 1);
CHECK_EQ(actor->getFinalAttribute("attack"), 30.0);
CHECK(StatusSystem::update(0.6).ok()); // total elapsed 1.1s > duration 1.0s
CHECK_EQ(actor->getStatusCount(), 0);
CHECK_EQ(actor->getFinalAttribute("attack"), 20.0);
CHECK(!actor->hasEffect("test.status.durationBuff"));
actor->release();
EffectRegistry::remove("test.status.durationBuff");
}
TEST_CASE("rpg.status.stackPolicyNoneRejectsDuplicate") {
EffectDefinition def;
def.id = "test.status.stackNone";
def.durationPolicy = "infinite";
def.stackPolicy = "none";
EffectRegistry::registerEffect(def);
RPGActor *actor = RPGActor::createActor();
int id1 = actor->applyEffect("test.status.stackNone");
CHECK(id1 > 0);
int id2 = actor->applyEffect("test.status.stackNone");
CHECK_EQ(id2, -1);
CHECK_EQ(actor->getStatusCount(), 1);
actor->removeStatusByEffect("test.status.stackNone");
actor->release();
EffectRegistry::remove("test.status.stackNone");
}
TEST_CASE("rpg.status.stackPolicyRefreshAndExtend") {
EffectDefinition refreshDef;
refreshDef.id = "test.status.refresh";
refreshDef.durationPolicy = "duration";
refreshDef.duration = 2.0f;
refreshDef.stackPolicy = "refresh";
EffectRegistry::registerEffect(refreshDef);
EffectDefinition extendDef;
extendDef.id = "test.status.extend";
extendDef.durationPolicy = "duration";
extendDef.duration = 2.0f;
extendDef.stackPolicy = "extend";
EffectRegistry::registerEffect(extendDef);
RPGActor *actor = RPGActor::createActor();
int r1 = actor->applyEffect("test.status.refresh");
CHECK(StatusSystem::update(1.5).ok());
CHECK(approxEq(actor->getStatusRemaining(0), 0.5, 1e-4));
int r2 = actor->applyEffect("test.status.refresh");
CHECK_EQ(r1, r2);
CHECK(approxEq(actor->getStatusRemaining(0), 2.0, 1e-4));
actor->removeStatusByEffect("test.status.refresh");
int e1 = actor->applyEffect("test.status.extend");
CHECK(StatusSystem::update(1.0).ok());
int e2 = actor->applyEffect("test.status.extend");
CHECK_EQ(e1, e2);
// remaining was ~1.0 before extend, +2.0 duration = ~3.0
CHECK(approxEq(actor->getStatusRemaining(0), 3.0, 1e-4));
actor->removeStatusByEffect("test.status.extend");
actor->release();
EffectRegistry::remove("test.status.refresh");
EffectRegistry::remove("test.status.extend");
}
TEST_CASE("rpg.status.stackPolicyStackScalesModifierAndCaps") {
EffectDefinition def;
def.id = "test.status.stack";
def.durationPolicy = "infinite";
def.stackPolicy = "stack";
def.maxStacks = 2;
def.modifiers.push_back({"armor", "add", 5.0, 0});
EffectRegistry::registerEffect(def);
RPGActor *actor = RPGActor::createActor();
actor->setBaseAttribute("armor", 0.0);
int id1 = actor->applyEffect("test.status.stack");
CHECK_EQ(actor->getFinalAttribute("armor"), 5.0);
CHECK_EQ(actor->getStatusStacks(0), 1);
int id2 = actor->applyEffect("test.status.stack");
CHECK_EQ(id1, id2);
CHECK_EQ(actor->getStatusStacks(0), 2);
CHECK_EQ(actor->getFinalAttribute("armor"), 10.0);
// Already at maxStacks: stays capped.
actor->applyEffect("test.status.stack");
CHECK_EQ(actor->getStatusStacks(0), 2);
CHECK_EQ(actor->getFinalAttribute("armor"), 10.0);
actor->removeStatus(id1);
CHECK_EQ(actor->getFinalAttribute("armor"), 0.0);
CHECK_EQ(actor->getStatusCount(), 0);
actor->release();
EffectRegistry::remove("test.status.stack");
}
TEST_CASE("rpg.status.periodicEffectProducesTickEvents") {
EffectDefinition dot;
dot.id = "test.status.periodicDot";
dot.durationPolicy = "duration";
dot.duration = 2.5f;
dot.period = 1.0f;
EffectRegistry::registerEffect(dot);
RPGActor *actor = RPGActor::createActor();
int instanceId = actor->applyEffect("test.status.periodicDot", "caster-1");
CHECK(instanceId > 0);
// Periodic effects do not touch attributes directly.
CHECK(!actor->hasAttribute("health"));
std::vector<StatusTickEvent> ticks;
CHECK(StatusSystem::update(1.0).ok());
StatusSystem::pollTicks(ticks);
REQUIRE(ticks.size() == 1);
CHECK_EQ(ticks[0].actor, actor);
CHECK_EQ(ticks[0].effectId, "test.status.periodicDot");
CHECK_EQ(ticks[0].source, "caster-1");
ticks.clear();
CHECK(StatusSystem::update(1.0).ok()); // t=2.0 -> another tick
StatusSystem::pollTicks(ticks);
REQUIRE(ticks.size() == 1);
ticks.clear();
CHECK(StatusSystem::update(1.0).ok()); // t=3.0 > duration 2.5 -> expires; no more ticks after expiry
StatusSystem::pollTicks(ticks);
CHECK(ticks.size() <= 1); // may or may not tick exactly at expiry boundary depending on order
CHECK_EQ(actor->getStatusCount(), 0);
ticks.clear();
CHECK(StatusSystem::update(5.0).ok());
StatusSystem::pollTicks(ticks);
CHECK_EQ(ticks.size(), 0u); // expired: no further ticks ever
actor->release();
EffectRegistry::remove("test.status.periodicDot");
}
TEST_CASE("rpg.status.removeByTagAndBySource") {
EffectDefinition a;
a.id = "test.status.tagA";
a.durationPolicy = "infinite";
a.tags = {"debuff", "curse"};
EffectRegistry::registerEffect(a);
EffectDefinition b;
b.id = "test.status.tagB";
b.durationPolicy = "infinite";
b.tags = {"debuff"};
EffectRegistry::registerEffect(b);
RPGActor *actor = RPGActor::createActor();
actor->applyEffect("test.status.tagA", "dispellSrc");
actor->applyEffect("test.status.tagB", "otherSrc");
CHECK_EQ(actor->getStatusCount(), 2);
CHECK_EQ(actor->removeStatusByTag("curse"), 1);
CHECK_EQ(actor->getStatusCount(), 1);
CHECK(!actor->hasEffect("test.status.tagA"));
CHECK_EQ(actor->removeStatusBySource("otherSrc"), 1);
CHECK_EQ(actor->getStatusCount(), 0);
actor->release();
EffectRegistry::remove("test.status.tagA");
EffectRegistry::remove("test.status.tagB");
}
TEST_CASE("rpg.buff.applyConditionRejectsAndEmitsChange") {
// Drain any leftover change events from prior cases.
std::vector<StatusChangeEvent> drain;
StatusSystem::pollChanges(drain);
EffectDefinition buff;
buff.id = "test.buff.immuneTarget";
buff.durationPolicy = "duration";
buff.duration = 5.f;
buff.tags = {"buff", "magic"};
EffectRegistry::registerEffect(buff);
StatusSystem::registerApplyCondition("blockMagic",
[](RPGActor *, const EffectDefinition &def,
const std::string &, std::string &reason) {
if (def.hasTag("magic")) {
reason = "immune:magic";
return false;
}
return true;
});
CHECK(StatusSystem::hasApplyCondition("blockMagic"));
RPGActor *actor = RPGActor::createActor();
const int rejected = actor->applyBuff("test.buff.immuneTarget");
CHECK_EQ(rejected, -1);
CHECK(!actor->hasBuff("test.buff.immuneTarget"));
CHECK_EQ(actor->getBuffCount(), 0);
std::vector<StatusChangeEvent> changes;
StatusSystem::pollChanges(changes);
REQUIRE(changes.size() == 1);
CHECK_EQ(changes[0].action, "reject");
CHECK_EQ(changes[0].effectId, "test.buff.immuneTarget");
CHECK_EQ(changes[0].reason, "immune:magic");
StatusSystem::unregisterApplyCondition("blockMagic");
int id = actor->applyBuff("test.buff.immuneTarget", "caster");
CHECK(id > 0);
CHECK(actor->hasBuff("test.buff.immuneTarget"));
CHECK(actor->hasBuffTag("buff"));
CHECK_EQ(actor->getBuffSource(0), "caster");
actor->setBuffProp(id, "iconOverride", "ui/custom.png");
CHECK_EQ(actor->getBuffProp(id, "iconOverride"), "ui/custom.png");
CHECK_EQ(actor->getBuffProp(id, "missing", "n/a"), "n/a");
changes.clear();
StatusSystem::pollChanges(changes);
REQUIRE(changes.size() == 1);
CHECK_EQ(changes[0].action, "apply");
CHECK_EQ(changes[0].instanceId, id);
CHECK(actor->removeBuff(id));
changes.clear();
StatusSystem::pollChanges(changes);
REQUIRE(changes.size() == 1);
CHECK_EQ(changes[0].action, "remove");
actor->release();
EffectRegistry::remove("test.buff.immuneTarget");
StatusSystem::clearApplyConditions();
}
TEST_CASE("rpg.buff.customStackPolicyAndLifecycleHook") {
std::vector<StatusChangeEvent> drain;
StatusSystem::pollChanges(drain);
EffectDefinition def;
def.id = "test.buff.customStack";
def.durationPolicy = "duration";
def.duration = 2.f;
def.stackPolicy = "additiveDuration";
def.modifiers.push_back({"attack", "add", 3.0, 0});
EffectRegistry::registerEffect(def);
StatusSystem::registerStackPolicy(
"additiveDuration",
[](RPGActor *, StatusInstance &existing, const EffectDefinition &effect,
const std::string &) {
// Each re-apply adds duration and one stack, uncapped for the test.
existing.stacks += 1;
if (existing.remaining >= 0.f) existing.remaining += effect.duration;
return existing.instanceId;
});
CHECK(StatusSystem::hasStackPolicy("additiveDuration"));
int hookCalls = 0;
std::string lastAction;
StatusSystem::registerLifecycleHook("counter", [&](const StatusChangeEvent &ev) {
++hookCalls;
lastAction = ev.action;
});
RPGActor *actor = RPGActor::createActor();
actor->setBaseAttribute("attack", 10.0);
int id1 = actor->applyBuff("test.buff.customStack");
CHECK(id1 > 0);
CHECK_EQ(actor->getFinalAttribute("attack"), 13.0);
CHECK_EQ(hookCalls, 1);
CHECK_EQ(lastAction, "apply");
int id2 = actor->applyBuff("test.buff.customStack");
CHECK_EQ(id2, id1);
CHECK_EQ(actor->getBuffStacks(0), 2);
CHECK(approxEq(actor->getBuffRemaining(0), 4.0, 1e-4));
CHECK_EQ(actor->getFinalAttribute("attack"), 16.0); // 3 * 2 stacks
CHECK_EQ(lastAction, "stack");
CHECK(StatusSystem::update(4.1).ok());
CHECK_EQ(actor->getBuffCount(), 0);
CHECK_EQ(actor->getFinalAttribute("attack"), 10.0);
CHECK_EQ(lastAction, "expire");
std::vector<StatusChangeEvent> changes;
StatusSystem::pollChanges(changes);
CHECK(changes.size() >= 3);
CHECK_EQ(changes.back().action, "expire");
actor->release();
EffectRegistry::remove("test.buff.customStack");
StatusSystem::clearStackPolicies();
StatusSystem::clearLifecycleHooks();
}
TEST_CASE("rpg.buff.facadeStatusChangeEvents") {
std::vector<StatusChangeEvent> drain;
StatusSystem::pollChanges(drain);
RPG *rpg = RPG::create();
rpg->clearEffectDefinitions();
CHECK_EQ(rpg->registerEffectsFromJson(R"([
{"id":"buff.facade","durationPolicy":"duration","duration":0.5,
"stackPolicy":"refresh","tags":["buff"],
"extra":{"icon":"ui/buff.png"}}
])"),
1);
RPGActor *actor = rpg->newActor();
int id = actor->applyBuff("buff.facade");
CHECK(id > 0);
// apply happens before update; changes are polled inside update().
rpg->update(0.f);
CHECK_EQ(rpg->getStatusChangeEventCount(), 1);
CHECK_EQ(rpg->getStatusChangeEventAction(0), "apply");
CHECK_EQ(rpg->getStatusChangeEventEffectId(0), "buff.facade");
CHECK_EQ(rpg->getStatusChangeEventInstanceId(0), id);
rpg->update(0.6f);
CHECK_EQ(rpg->getStatusChangeEventCount(), 1);
CHECK_EQ(rpg->getStatusChangeEventAction(0), "expire");
CHECK_EQ(actor->getBuffCount(), 0);
actor->release();
rpg->clearEffectDefinitions();
}
// ---------------------------------------------------------------------------
// Skill / SkillSystem
// ---------------------------------------------------------------------------
TEST_CASE("rpg.skill.registryAndCanCastChecks") {
SkillDefinition def;
def.id = "test.skill.bolt";
def.cooldown = 4.0f;
def.castTime = 0.f;
auto boltCost = eve::resource::CostSpec::single("mana", 10);
REQUIRE(boltCost.hasValue());
def.cost = std::move(boltCost).takeValue();
SkillRegistry::registerSkill(def);
RPGActor *actor = RPGActor::createActor();
actor->setBaseAttribute("mana", 5.0);
CHECK(!actor->canCastSkill("test.skill.bolt"));
CHECK_EQ(actor->canCastSkillReason("test.skill.bolt"), "not_learned");
actor->learnSkill("test.skill.bolt");
CHECK(actor->knowsSkill("test.skill.bolt"));
CHECK(!actor->canCastSkill("test.skill.bolt"));
CHECK_EQ(actor->canCastSkillReason("test.skill.bolt"), "insufficient_cost");
actor->setBaseAttribute("mana", 50.0);
CHECK(actor->canCastSkill("test.skill.bolt"));
actor->release();
SkillRegistry::remove("test.skill.bolt");
}
TEST_CASE("rpg.skill.instantCastDeductsCostSetsCooldownAndAppliesEffect") {
EffectDefinition burn;
burn.id = "test.skill.effect.burn";
burn.durationPolicy = "duration";
burn.duration = 5.f;
burn.modifiers.push_back({"defense", "add", -3.0, 0});
EffectRegistry::registerEffect(burn);
SkillDefinition def;
def.id = "test.skill.instant";
def.cooldown = 3.0f;
def.castTime = 0.f;
auto instantCost = eve::resource::CostSpec::single("mana", 10);
REQUIRE(instantCost.hasValue());
def.cost = std::move(instantCost).takeValue();
def.grantedEffects.push_back("test.skill.effect.burn");
SkillRegistry::registerSkill(def);
RPGActor *caster = RPGActor::createActor();
RPGActor *target = RPGActor::createActor();
caster->setBaseAttribute("mana", 20.0);
target->setBaseAttribute("defense", 10.0);
caster->learnSkill("test.skill.instant");
CHECK(caster->beginCastSkill("test.skill.instant", target));
CHECK_EQ(caster->getBaseAttribute("mana"), 10.0);
CHECK_EQ(caster->getSkillCooldown("test.skill.instant"), 3.0f);
CHECK(!caster->canCastSkill("test.skill.instant"));
CHECK_EQ(caster->canCastSkillReason("test.skill.instant"), "on_cooldown");
CHECK_EQ(target->getFinalAttribute("defense"), 7.0);
std::vector<SkillCastEvent> events;
SkillSystem::pollCastEvents(events);
REQUIRE(events.size() == 1);
CHECK_EQ(events[0].caster, caster);
CHECK_EQ(events[0].target, target);
CHECK_EQ(events[0].skillId, "test.skill.instant");
SkillSystem::update(3.1f);
CHECK(caster->canCastSkill("test.skill.instant"));
caster->release();
target->release();
SkillRegistry::remove("test.skill.instant");
EffectRegistry::remove("test.skill.effect.burn");
}
TEST_CASE("rpg.skill.castTimeProgressAndResolution") {
SkillDefinition def;
def.id = "test.skill.channeled";
def.cooldown = 0.f;
def.castTime = 2.0f;
SkillRegistry::registerSkill(def);
RPGActor *actor = RPGActor::createActor();
actor->learnSkill("test.skill.channeled");
CHECK(actor->beginCastSkill("test.skill.channeled"));
CHECK(actor->isCastingSkill());
CHECK_EQ(actor->getCastingSkillId(), "test.skill.channeled");
CHECK_EQ(actor->getCastProgress(), 0.f);
SkillSystem::update(1.0f);
CHECK(actor->isCastingSkill());
CHECK(approxEq(actor->getCastProgress(), 0.5, 1e-4));
std::vector<SkillCastEvent> events;
SkillSystem::pollCastEvents(events);
CHECK(events.empty()); // not resolved yet
SkillSystem::update(1.1f);
CHECK(!actor->isCastingSkill());
SkillSystem::pollCastEvents(events);
REQUIRE(events.size() == 1);
CHECK_EQ(events[0].skillId, "test.skill.channeled");
actor->release();
SkillRegistry::remove("test.skill.channeled");
}
TEST_CASE("rpg.skill.cancelCastStopsResolution") {
SkillDefinition def;
def.id = "test.skill.cancelable";
def.castTime = 5.0f;
SkillRegistry::registerSkill(def);
RPGActor *actor = RPGActor::createActor();
actor->learnSkill("test.skill.cancelable");
actor->beginCastSkill("test.skill.cancelable");
CHECK(actor->isCastingSkill());
actor->cancelCastSkill();
CHECK(!actor->isCastingSkill());
SkillSystem::update(10.0f);
std::vector<SkillCastEvent> events;
SkillSystem::pollCastEvents(events);
CHECK(events.empty());
actor->release();
SkillRegistry::remove("test.skill.cancelable");
}
TEST_CASE("rpg.skill.customCastConditionBlocksCast") {
SkillDefinition def;
def.id = "test.skill.guarded";
SkillRegistry::registerSkill(def);
RPGActor *actor = RPGActor::createActor();
actor->learnSkill("test.skill.guarded");
SkillSystem::registerCastCondition("no_silence", [](RPGActor *a, const SkillDefinition &,
std::string &reason) {
if (a->hasEffect("silence")) {
reason = "silenced";
return false;
}
return true;
});
CHECK(actor->canCastSkill("test.skill.guarded"));
EffectDefinition silence;
silence.id = "silence";
silence.durationPolicy = "infinite";
EffectRegistry::registerEffect(silence);
actor->applyEffect("silence");
CHECK(!actor->canCastSkill("test.skill.guarded"));
CHECK_EQ(actor->canCastSkillReason("test.skill.guarded"), "silenced");
SkillSystem::unregisterCastCondition("no_silence");
CHECK(actor->canCastSkill("test.skill.guarded"));
actor->removeStatusByEffect("silence");
actor->release();
SkillRegistry::remove("test.skill.guarded");
EffectRegistry::remove("silence");
}
// ---------------------------------------------------------------------------
// Settlement pipeline
// ---------------------------------------------------------------------------
TEST_CASE("rpg.settlement.stagesRunInPriorityOrder") {
SettlementPipeline::clearPipeline("test.pipeline.order");
std::vector<std::string> order;
SettlementPipeline::registerStage("test.pipeline.order", "second", 10,
[&order](SettlementContext &) { order.push_back("second"); });
SettlementPipeline::registerStage("test.pipeline.order", "first", 1,
[&order](SettlementContext &) { order.push_back("first"); });
SettlementPipeline::registerStage("test.pipeline.order", "third", 20,
[&order](SettlementContext &) { order.push_back("third"); });
SettlementContext ctx;
SettlementPipeline::run("test.pipeline.order", ctx);
REQUIRE(order.size() == 3);
CHECK_EQ(order[0], "first");
CHECK_EQ(order[1], "second");
CHECK_EQ(order[2], "third");
SettlementPipeline::clearPipeline("test.pipeline.order");
}
TEST_CASE("rpg.settlement.cancelStopsLaterStages") {
SettlementPipeline::clearPipeline("test.pipeline.cancel");
bool laterRan = false;
SettlementPipeline::registerStage("test.pipeline.cancel", "dodge", 0,
[](SettlementContext &ctx) { ctx.cancelled = true; });
SettlementPipeline::registerStage("test.pipeline.cancel", "damage", 10,
[&laterRan](SettlementContext &) { laterRan = true; });
SettlementContext ctx;
SettlementPipeline::run("test.pipeline.cancel", ctx);
CHECK(!laterRan);
CHECK(ctx.cancelled);
SettlementPipeline::clearPipeline("test.pipeline.cancel");
}
TEST_CASE("rpg.settlement.damageCalcExampleWithCrit") {
SettlementPipeline::clearPipeline("test.pipeline.damage");
SettlementPipeline::registerStage(
"test.pipeline.damage", "base", 0,
[](SettlementContext &ctx) { ctx.set("result", ctx.get("attack") - ctx.get("defense")); });
SettlementPipeline::registerStage("test.pipeline.damage", "crit", 10, [](SettlementContext &ctx) {
if (ctx.hasTag("crit")) ctx.set("result", ctx.get("result") * 2.0);
});
SettlementPipeline::registerStage("test.pipeline.damage", "minFloor", 20, [](SettlementContext &ctx) {
if (ctx.get("result") < 1.0) ctx.set("result", 1.0);
});
SettlementContext ctx;
ctx.set("attack", 50.0);
ctx.set("defense", 20.0);
ctx.addTag("crit");
SettlementPipeline::run("test.pipeline.damage", ctx);
CHECK_EQ(ctx.get("result"), 60.0); // (50-20) * 2
SettlementContext ctx2;
ctx2.set("attack", 5.0);
ctx2.set("defense", 50.0);
SettlementPipeline::run("test.pipeline.damage", ctx2);
CHECK_EQ(ctx2.get("result"), 1.0); // floored
CHECK_EQ(SettlementPipeline::stageCount("test.pipeline.damage"), 3);
CHECK(SettlementPipeline::setStageEnabled("test.pipeline.damage", "crit", false));
SettlementContext ctx3;
ctx3.set("attack", 50.0);
ctx3.set("defense", 20.0);
ctx3.addTag("crit");
SettlementPipeline::run("test.pipeline.damage", ctx3);
CHECK_EQ(ctx3.get("result"), 30.0); // crit stage disabled
CHECK(SettlementPipeline::unregisterStage("test.pipeline.damage", "minFloor"));
CHECK_EQ(SettlementPipeline::stageCount("test.pipeline.damage"), 2);
SettlementPipeline::clearPipeline("test.pipeline.damage");
CHECK_EQ(SettlementPipeline::stageCount("test.pipeline.damage"), 0);
}
// ---------------------------------------------------------------------------
// RPG module facade smoke test (end-to-end via the same entry points scripts use)
// ---------------------------------------------------------------------------
TEST_CASE("rpg.module.endToEndSkillTriggersEffectViaFacade") {
auto *rpg = RPG::create();
rpg->clearEffectDefinitions();
rpg->clearSkillDefinitions();
int effectsLoaded = rpg->registerEffectsFromJson(R"([
{"id":"e2e.poison","durationPolicy":"duration","duration":2,"period":1}
])");
CHECK_EQ(effectsLoaded, 1);
int skillsLoaded = rpg->registerSkillsFromJson(R"([
{"id":"e2e.dart","cooldown":1,"castTime":0,
"costs":[{"attribute":"stamina","amount":5}],
"grantedEffects":["e2e.poison"]}
])");
CHECK_EQ(skillsLoaded, 1);
RPGActor *caster = rpg->newActor();
RPGActor *target = rpg->newActor();
caster->setBaseAttribute("stamina", 10.0);
caster->learnSkill("e2e.dart");
CHECK(caster->beginCastSkill("e2e.dart", target));
rpg->update(1.0f);
CHECK_EQ(rpg->getCastEventCount(), 1);
CHECK_EQ(rpg->getCastEventCaster(0), caster);
CHECK_EQ(rpg->getCastEventTarget(0), target);
CHECK_EQ(rpg->getCastEventSkillId(0), "e2e.dart");
CHECK_EQ(rpg->getTickEventCount(), 1);
CHECK_EQ(rpg->getTickEventActor(0), target);
CHECK_EQ(rpg->getTickEventEffectId(0), "e2e.poison");
rpg->update(1.5f); // effect (duration 2, already 1s elapsed) expires
CHECK_EQ(target->getStatusCount(), 0);
caster->release();
target->release();
rpg->clearEffectDefinitions();
rpg->clearSkillDefinitions();
}
Reference in new issue View Git Blame Copy Permalink