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

426 lines
14 KiB
C++
Raw Blame History

#include "zeroerr/assert.h"
#include "zeroerr/unittest.h"
#include "ScriptTest.h"
#include "card/Card.h"
#include "common/ECS.h"
#include <cmath>
using namespace eve::card;
namespace {
int countCardView() {
int n = 0;
auto view = ecs::View<CardData, CardData::Identity>();
for (auto it = view.begin(); it != view.end(); ++it) ++n;
return n;
}
bool near(float a, float b, float eps = 1e-3f) { return std::fabs(a - b) < eps; }
const char *kDefs = R"JSON(
[{"id":"flame","name":"Flame","kind":"creature","cost":2,"attack":3,"health":2},
{"id":"bolt","name":"Bolt","kind":"spell","cost":3}]
)JSON";
} // namespace
TEST_CASE("card.factory.newCardFromJson") {
Card mod;
CHECK_EQ(mod.registerCardsFromJson(kDefs), 2);
CHECK(mod.hasCardDefinition("flame"));
CardData *c = mod.newCard("flame");
REQUIRE(c != nullptr);
CHECK_EQ(c->identity()->name, std::string("Flame"));
CHECK_EQ(c->stats()->cost, 2);
CHECK_EQ(c->stats()->attack, 3);
CHECK_EQ(mod.newCard("missing"), nullptr);
}
TEST_CASE("card.authoring.stableDefinitionEnumerationAndMutation") {
Card mod;
REQUIRE_EQ(mod.registerCardsFromJson(kDefs), 2);
CHECK_EQ(mod.getCardDefinitionId(0), std::string("bolt"));
CHECK_EQ(mod.getCardDefinitionId(1), std::string("flame"));
REQUIRE(mod.setCardDefinition("archer", "Archer", "creature", 4, 5, 3, 1.2f, -0.2f, 0.5f));
CHECK_EQ(mod.getCardDefinitionId(0), std::string("archer"));
CHECK_EQ(mod.getCardDefinitionAttack("archer"), 5);
CHECK_EQ(mod.getCardDefinitionTintR("archer"), 1.f);
CHECK_EQ(mod.getCardDefinitionTintG("archer"), 0.f);
CHECK(!mod.setCardDefinition("", "Invalid", "", 0, 0, 0, 0.f, 0.f, 0.f));
REQUIRE(mod.removeCardDefinition("bolt"));
CHECK(!mod.hasCardDefinition("bolt"));
CHECK(!mod.removeCardDefinition("bolt"));
}
TEST_CASE("card.presentation.stableIdentityAndSnapshot") {
Card mod;
CHECK_EQ(mod.registerCardsFromJson(kDefs), 2);
CardData *first = mod.newCard("flame");
CardData *second = mod.newCard("flame");
REQUIRE(first != nullptr);
REQUIRE(second != nullptr);
CHECK_EQ(first->identity()->definitionId, "flame");
CHECK_EQ(second->identity()->definitionId, "flame");
CHECK_NE(first->identity()->id, second->identity()->id);
first->layout()->x = 42.f;
first->layout()->angle = 12.f;
CHECK_EQ(mod.capturePresentation(), 2);
auto *snapshot = mod.getPresentation(0);
REQUIRE(snapshot != nullptr);
CHECK_EQ(snapshot->instanceId, first->identity()->id);
CHECK_EQ(snapshot->definitionId, "flame");
CHECK_EQ(snapshot->x, 42.f);
CHECK_EQ(snapshot->angle, 12.f);
CHECK_EQ(mod.getPresentation(2), nullptr);
}
TEST_CASE("card.presentation.planeMapperRoundTrip") {
CardPlaneMapper mapper;
mapper.setLogicalRect(0.f, 0.f, 1280.f, 700.f);
mapper.setPlane(-6.4f, 0.6f, -7.f, 12.8f, 0.f, 0.f, 0.f, 0.f, 14.f);
CHECK(mapper.mapLayout(640.f, 350.f));
CHECK_LT(std::abs(mapper.getWorldX()), 0.0001f);
CHECK_LT(std::abs(mapper.getWorldY() - 0.6f), 0.0001f);
CHECK_LT(std::abs(mapper.getWorldZ()), 0.0001f);
CHECK(mapper.mapRay(0.f, 10.f, 0.f, 0.f, -1.f, 0.f));
CHECK_LT(std::abs(mapper.getLogicalX() - 640.f), 0.0001f);
CHECK_LT(std::abs(mapper.getLogicalY() - 350.f), 0.0001f);
CHECK(!mapper.mapRay(0.f, 10.f, 0.f, 1.f, 0.f, 0.f));
}
TEST_CASE("card.hand.membershipOrder") {
Card mod;
mod.registerCardsFromJson(kDefs);
LayoutConfig *cfg = mod.newConfig();
Hand *h = mod.newHand(cfg);
h->meta()->owner = "player";
CardData *a = mod.newCard("flame");
CardData *b = mod.newCard("bolt");
h->addCard(a);
h->addCard(b);
CHECK_EQ(h->count(), 2);
CHECK_EQ(h->get(0), a);
CHECK_EQ(h->get(1), b);
CHECK_EQ(mod.findHand("player"), h);
}
TEST_CASE("card.deck.stackOrder") {
Card mod;
mod.registerCardsFromJson(kDefs);
Deck *d = mod.newDeck();
CardData *a = mod.newCard("flame");
CardData *b = mod.newCard("bolt");
d->push(a);
d->push(b);
CHECK_EQ(d->count(), 2);
CHECK_EQ(d->peek(), b);
CHECK_EQ(d->draw(), b);
CHECK_EQ(d->draw(), a);
CHECK(d->isEmpty());
}
TEST_CASE("card.ecs.viewCountsFactoryCards") {
const int before = countCardView();
{
Card mod;
mod.registerCardsFromJson(kDefs);
CHECK(mod.newCard("flame") != nullptr);
CHECK(mod.newCard("bolt") != nullptr);
CHECK_EQ(countCardView(), before + 2);
}
CHECK_EQ(countCardView(), before);
}
TEST_CASE("card.ecs.removeKeepsEntityInView") {
Card mod;
mod.registerCardsFromJson(kDefs);
const int before = countCardView();
LayoutConfig *cfg = mod.newConfig();
Hand *h = mod.newHand(cfg);
CardData *c = mod.newCard("flame");
h->addCard(c);
CHECK_EQ(countCardView(), before + 1);
CHECK(h->removeCard(c));
CHECK_EQ(h->count(), 0);
CHECK_EQ(countCardView(), before + 1);
CHECK_EQ(c->identity()->name, std::string("Flame"));
}
TEST_CASE("card.drawCardMovesDeckToHand") {
Card mod;
mod.registerCardsFromJson(kDefs);
LayoutConfig *cfg = mod.newConfig();
Hand *h = mod.newHand(cfg);
h->meta()->owner = "player";
Deck *d = mod.newDeck();
d->push(mod.newCard("flame"));
CardData *drawn = mod.drawCard("player");
REQUIRE(drawn != nullptr);
CHECK_EQ(h->count(), 1);
CHECK(d->isEmpty());
CHECK_EQ(h->get(0), drawn);
}
static const char *kCardViewScript = R"SQ(
function testCardCppView() {
local card = eve.Card()
card.registerCardsFromJson("[{\"id\":\"flame\",\"name\":\"Flame\"}]")
local c = card.newCard("flame")
if (c == null) return false
local all = eve.view(eve.CardData)
foreach (e in all) {
if (e.getId() == c.getId()) return true
}
return false
}
)SQ";
UnitSciptTest(CardViewScriptTest, kCardViewScript);
TEST_CASE_FIXTURE(CardViewScriptTest, "card.script.viewSeesNewCard") {
CHECK(vm.callFunc(vm.findFunc("testCardCppView"), vm).toBool());
}
TEST_CASE("card.cardStateName") {
CHECK_EQ(std::string(cardStateName(CardState::Deck)), std::string("deck"));
CHECK_EQ(std::string(cardStateName(CardState::Hand)), std::string("hand"));
CHECK_EQ(std::string(cardStateName(CardState::Hovered)), std::string("hovered"));
CHECK_EQ(std::string(cardStateName(CardState::Dragging)), std::string("dragging"));
CHECK_EQ(std::string(cardStateName(CardState::Returning)), std::string("returning"));
CHECK_EQ(std::string(cardStateName(CardState::Played)), std::string("played"));
CHECK_EQ(std::string(cardStateName(CardState::Discarded)), std::string("discarded"));
CHECK_EQ(std::string(cardStateName(CardState::Disabled)), std::string("disabled"));
}
TEST_CASE("card.cardData.hitAndDescribe") {
Card mod;
mod.registerCardsFromJson(kDefs);
CardData *c = mod.newCard("flame");
c->layout()->x = 100.f;
c->layout()->y = 100.f;
c->layout()->w = 50.f;
c->layout()->h = 70.f;
c->layout()->scale = 1.f;
CHECK(c->hit(100.f, 100.f));
CHECK(c->hit(125.f, 135.f));
CHECK(!c->hit(126.f, 100.f));
CHECK(!c->hit(100.f, 136.f));
c->layout()->scale = 2.f; // enlarged hit box
CHECK(c->hit(140.f, 100.f));
c->layout()->w = 0.f; // zero-size never hits
CHECK(!c->hit(100.f, 100.f));
const std::string creature = c->describe();
CHECK(creature.find("Flame") != std::string::npos);
CHECK(creature.find("3/2") != std::string::npos);
CardData *spell = mod.newCard("bolt");
CHECK(spell->describe().find("\xe6\xb3\x95\xe6\x9c\xaf") != std::string::npos); // 法术
}
TEST_CASE("card.deck.drawPeekBoundsAndShuffle") {
Card mod;
mod.registerCardsFromJson(kDefs);
Deck *d = mod.newDeck();
CHECK(d->isEmpty());
CHECK_EQ(d->draw(), nullptr);
CHECK_EQ(d->peek(), nullptr);
CHECK_EQ(d->get(-1), nullptr);
CHECK_EQ(d->get(0), nullptr);
CardData *a = mod.newCard("flame");
CardData *b = mod.newCard("bolt");
d->push(a);
d->push(b);
CHECK_EQ(d->get(0), a);
CHECK_EQ(d->get(1), b);
CHECK_EQ(d->get(2), nullptr);
d->shuffle(); // membership preserved, order may change
CHECK_EQ(d->count(), 2);
const bool top0 = d->get(0) == a || d->get(0) == b;
const bool top1 = d->get(1) == a || d->get(1) == b;
CHECK(top0);
CHECK(top1);
CHECK(d->get(0) != d->get(1));
d->clear();
CHECK(d->isEmpty());
}
TEST_CASE("card.zone.containsAndAccepts") {
Card mod;
mod.registerCardsFromJson(kDefs);
Zone *z = mod.newZone("board", "Board", 10.f, 20.f, 100.f, 60.f);
CHECK(z->contains(10.f, 20.f));
CHECK(z->contains(109.f, 79.f));
CHECK(!z->contains(9.f, 20.f));
CHECK(!z->contains(111.f, 81.f)); // rect bounds are inclusive
CardData *flame = mod.newCard("flame");
CardData *bolt = mod.newCard("bolt");
CHECK(z->accepts(flame));
CHECK(z->accepts(bolt));
CHECK(!z->accepts(nullptr));
z->filter()->acceptKinds = {"spell"};
CHECK(!z->accepts(flame));
CHECK(z->accepts(bolt));
z->rect()->enabled = false;
CHECK(!z->accepts(bolt));
}
TEST_CASE("card.hand.addCardSetsLayoutAndPhase") {
Card mod;
mod.registerCardsFromJson(kDefs);
LayoutConfig *cfg = mod.newConfig();
Hand *h = mod.newHand(cfg);
CardData *flame = mod.newCard("flame");
h->addCard(flame);
CHECK(static_cast<int>(flame->state()->phase) == static_cast<int>(CardState::Hand));
CHECK_EQ(flame->layout()->w, cfg->cardW);
CHECK(std::fabs(flame->layout()->scale - 0.01f) < 1e-5f);
CardData *bolt = mod.newCard("bolt");
bolt->visual()->disabled = true;
h->addCard(bolt);
CHECK(static_cast<int>(bolt->state()->phase) == static_cast<int>(CardState::Disabled));
CHECK(std::fabs(bolt->layout()->alpha - cfg->disabledAlpha) < 1e-5f);
CardData *other = mod.newCard("flame");
CHECK(!h->removeCard(other));
CHECK(h->removeCard(flame));
CHECK_EQ(h->count(), 1);
CHECK_EQ(h->find(bolt->identity()->id), bolt);
CHECK_EQ(h->find("nope"), nullptr);
CHECK_EQ(h->get(5), nullptr);
h->clear();
CHECK_EQ(h->count(), 0);
}
TEST_CASE("card.hand.pickTopmostAndFanSlot") {
Card mod;
mod.registerCardsFromJson(kDefs);
LayoutConfig *cfg = mod.newConfig();
Hand *h = mod.newHand(cfg);
CardData *a = mod.newCard("flame");
CardData *b = mod.newCard("bolt");
h->addCard(a);
h->addCard(b);
a->layout()->x = 100.f;
a->layout()->y = 100.f;
a->layout()->w = 50.f;
a->layout()->h = 70.f;
a->layout()->scale = 1.f;
b->layout()->x = 100.f;
b->layout()->y = 100.f;
b->layout()->w = 50.f;
b->layout()->h = 70.f;
b->layout()->scale = 1.f;
CHECK_EQ(h->pick(100.f, 100.f), b); // top-most = last added
CHECK_EQ(h->pick(300.f, 300.f), nullptr);
float ox = 0.f, oy = 0.f, ang = 0.f;
h->slotTransform(0, 1, ox, oy, ang);
CHECK(std::fabs(ox - cfg->handX) < 1e-3f);
CHECK(std::fabs(oy - cfg->handY) < 1e-3f);
CHECK(std::fabs(ang) < 1e-4f);
h->slotTransform(0, 3, ox, oy, ang);
CHECK(ang < 0.f);
h->slotTransform(1, 3, ox, oy, ang);
CHECK(std::fabs(ang) < 1e-4f);
h->slotTransform(2, 3, ox, oy, ang);
CHECK(ang > 0.f);
}
namespace {
void settleHand(Hand *h, const std::vector<Zone *> &zones, std::vector<CardEvent> &out) {
for (int i = 0; i < 120; ++i) h->update(1.f / 60.f, 0.f, 0.f, false, zones, out);
out.clear();
}
} // namespace
TEST_CASE("card.hand.updateClickDragDrop") {
Card mod;
mod.registerCardsFromJson(kDefs);
LayoutConfig *cfg = mod.newConfig();
cfg->dragThreshold = 4.f;
cfg->cardW = 50.f;
cfg->cardH = 70.f;
cfg->handX = 100.f;
cfg->handY = 100.f;
cfg->spacing = 20.f;
cfg->arcHeight = 0.f;
cfg->rotationAngle = 0.f;
Hand *h = mod.newHand(cfg);
h->meta()->owner = "p1";
CardData *a = mod.newCard("flame"); // creature
CardData *b = mod.newCard("bolt"); // spell
h->addCard(a);
h->addCard(b);
Zone *board = mod.newZone("board", "Board", 100.f, 300.f, 200.f, 60.f);
board->filter()->acceptKinds = {"creature"};
Zone *spellOnly = mod.newZone("magic", "Magic", 100.f, 400.f, 200.f, 60.f);
spellOnly->filter()->acceptKinds = {"spell"};
std::vector<Zone *> zones = {board, spellOnly};
std::vector<CardEvent> out;
settleHand(h, zones, out);
// After settling with two cards: a at (65,100), b at (135,100).
CHECK(near(a->layout()->x, 65.f, 0.5f));
CHECK(near(b->layout()->x, 135.f, 0.5f));
// Click: press + release without moving beyond threshold.
h->update(1.f / 60.f, 135.f, 100.f, true, zones, out);
CHECK_EQ(out.size(), 0u);
h->update(1.f / 60.f, 136.f, 100.f, false, zones, out);
REQUIRE_EQ(out.size(), 1u);
CHECK_EQ(out[0].type, std::string("click"));
CHECK_EQ(out[0].hand, std::string("p1"));
CHECK(out[0].cardId.find("bolt") == 0); // instance id is "bolt#<n>"
out.clear();
// Drag spell onto the creature-only board -> dropRejected.
h->update(1.f / 60.f, 135.f, 100.f, true, zones, out);
h->update(1.f / 60.f, 145.f, 100.f, true, zones, out);
CHECK_EQ(b->state()->dragging, true);
h->update(1.f / 60.f, 145.f, 330.f, true, zones, out);
h->update(1.f / 60.f, 145.f, 330.f, false, zones, out);
REQUIRE_EQ(out.size(), 1u);
CHECK_EQ(out[0].type, std::string("dropRejected"));
CHECK_EQ(out[0].zoneId, std::string("board"));
CHECK_EQ(out[0].reason, std::string("kind_not_allowed"));
CHECK(static_cast<int>(b->state()->phase) == static_cast<int>(CardState::Returning));
out.clear();
settleHand(h, zones, out);
// Drag spell onto the spell-only zone -> drop accepted.
h->update(1.f / 60.f, 135.f, 100.f, true, zones, out);
h->update(1.f / 60.f, 145.f, 100.f, true, zones, out);
h->update(1.f / 60.f, 145.f, 430.f, true, zones, out);
h->update(1.f / 60.f, 145.f, 430.f, false, zones, out);
REQUIRE_EQ(out.size(), 1u);
CHECK_EQ(out[0].type, std::string("drop"));
CHECK_EQ(out[0].zoneId, std::string("magic"));
out.clear();
settleHand(h, zones, out);
// Non-interactive hand: press produces no click/drag events.
h->meta()->interactive = false;
h->update(1.f / 60.f, 135.f, 100.f, true, zones, out);
h->update(1.f / 60.f, 136.f, 100.f, false, zones, out);
CHECK_EQ(out.size(), 0u);
}
Reference in new issue View Git Blame Copy Permalink