jeirmeister/Cockatrice
1
0
Fork 0
mirror of https://github.com/Cockatrice/Cockatrice.git synced 2026-09-29 17:32:17 -07:00
Code Issues Projects Releases Packages Wiki Activity Actions

[Playmats] Add fixed override and configurable fallbacks to settings.

Browse source 
Took 29 minutes

Took 43 seconds
This commit is contained in:
Lukas Brübach 2026-08-13 12:40:04 +02:00
parent 92c8f1a1a1
commit fa669544d3
19 changed files with 845 additions and 16 deletions
Download patch file Download diff file Expand all files Collapse all files

7
tests/CMakeLists.txt
View file

@ -7,6 +7,7 @@ add_test(NAME expression_test COMMAND expression_test)
add_test(NAME clamped_arithmetic_test COMMAND clamped_arithmetic_test)
add_test(NAME test_age_formatting COMMAND test_age_formatting)
add_test(NAME password_hash_test COMMAND password_hash_test)
add_test(NAME playmat_resolver_test COMMAND playmat_resolver_test)
add_test(NAME server_card_counter_test COMMAND server_card_counter_test)
add_test(NAME server_counter_test COMMAND server_counter_test)
add_test(NAME server_rate_limiter_test COMMAND server_rate_limiter_test)
@ -21,6 +22,7 @@ add_executable(expression_test expression_test.cpp)
add_executable(clamped_arithmetic_test clamped_arithmetic_test.cpp)
add_executable(test_age_formatting test_age_formatting.cpp)
add_executable(password_hash_test password_hash_test.cpp)
add_executable(playmat_resolver_test playmat_resolver_test.cpp)
add_executable(deck_hash_performance_test deck_hash_performance_test.cpp)
add_executable(server_card_counter_test server_card_counter_test.cpp)
add_executable(server_counter_test server_counter_test.cpp)
@ -56,6 +58,7 @@ if(NOT GTEST_FOUND)
add_dependencies(clamped_arithmetic_test gtest)
add_dependencies(test_age_formatting gtest)
add_dependencies(password_hash_test gtest)
add_dependencies(playmat_resolver_test gtest)
add_dependencies(deck_hash_performance_test gtest)
add_dependencies(server_card_counter_test gtest)
add_dependencies(server_counter_test gtest)
@ -74,6 +77,10 @@ target_link_libraries(
target_link_libraries(
password_hash_test libcockatrice_utility Threads::Threads ${GTEST_BOTH_LIBRARIES} ${TEST_QT_MODULES}
)
target_link_libraries(
playmat_resolver_test libcockatrice_deck_list libcockatrice_utility Threads::Threads ${GTEST_BOTH_LIBRARIES}
${TEST_QT_MODULES}
)
target_link_libraries(
deck_hash_performance_test libcockatrice_deck_list libcockatrice_utility Threads::Threads ${GTEST_BOTH_LIBRARIES}
${TEST_QT_MODULES}

140
tests/playmat_resolver_test.cpp Normal file
View file

@ -0,0 +1,140 @@
#include <gtest/gtest.h>
#include <libcockatrice/deck_list/deck_list.h>
#include <libcockatrice/deck_list/playmat_resolver.h>
namespace
{
PlaymatResolution makeResolution(const QString &name, const QString &providerId = QString())
{
PlaymatResolution resolution;
resolution.card = {name, providerId};
return resolution;
}
} // namespace
TEST(PlaymatResolverTest, EmptyChainReturnsEmpty)
{
DeckList deck;
int rotationIndex = 0;
const PlaymatResolution resolved = resolveEffectivePlaymat(deck, {}, {}, PlaymatFallbackMode::Fixed, rotationIndex);
EXPECT_TRUE(resolved.card.isEmpty());
}
TEST(PlaymatResolverTest, OverrideWinsOverDeckAndFallback)
{
DeckList deck;
deck.setPlaymatCard({QStringLiteral("Deck Mat"), QStringLiteral("deck-provider")});
const PlaymatResolution force = makeResolution(QStringLiteral("Force Mat"), QStringLiteral("force-provider"));
const QList<PlaymatResolution> fallback = {makeResolution(QStringLiteral("Fallback Mat"))};
int rotationIndex = 0;
const PlaymatResolution resolved =
resolveEffectivePlaymat(deck, force, fallback, PlaymatFallbackMode::Fixed, rotationIndex);
EXPECT_EQ(resolved.card.name, QStringLiteral("Force Mat"));
EXPECT_EQ(resolved.card.providerId, QStringLiteral("force-provider"));
}
TEST(PlaymatResolverTest, DeckWinsOverFallback)
{
DeckList deck;
deck.setPlaymatCard({QStringLiteral("Deck Mat"), QStringLiteral("deck-provider")});
deck.setPlaymatParams({0.1, 0.2, 0.3, 1.5});
const QList<PlaymatResolution> fallback = {makeResolution(QStringLiteral("Fallback Mat"))};
int rotationIndex = 0;
const PlaymatResolution resolved =
resolveEffectivePlaymat(deck, {}, fallback, PlaymatFallbackMode::Fixed, rotationIndex);
EXPECT_EQ(resolved.card.name, QStringLiteral("Deck Mat"));
EXPECT_EQ(resolved.card.providerId, QStringLiteral("deck-provider"));
EXPECT_DOUBLE_EQ(resolved.params.marginPctL, 0.1);
EXPECT_DOUBLE_EQ(resolved.params.verticalOffset, 0.3);
}
TEST(PlaymatResolverTest, FallbackUsedWhenDeckHasNone)
{
DeckList deck;
const QList<PlaymatResolution> fallback = {makeResolution(QStringLiteral("Fallback Mat"))};
int rotationIndex = 0;
const PlaymatResolution resolved =
resolveEffectivePlaymat(deck, {}, fallback, PlaymatFallbackMode::Fixed, rotationIndex);
EXPECT_EQ(resolved.card.name, QStringLiteral("Fallback Mat"));
}
TEST(PlaymatResolverTest, FixedAlwaysUsesFirst)
{
DeckList deck;
const QList<PlaymatResolution> fallback = {makeResolution(QStringLiteral("First")),
makeResolution(QStringLiteral("Second"))};
int rotationIndex = 3; // ignored in Fixed mode
for (int i = 0; i < 5; ++i) {
const PlaymatResolution resolved =
resolveEffectivePlaymat(deck, {}, fallback, PlaymatFallbackMode::Fixed, rotationIndex);
EXPECT_EQ(resolved.card.name, QStringLiteral("First"));
}
}
TEST(PlaymatResolverTest, RoundRobinCyclesAndWraps)
{
DeckList deck;
const QList<PlaymatResolution> fallback = {makeResolution(QStringLiteral("First")),
makeResolution(QStringLiteral("Second")),
makeResolution(QStringLiteral("Third"))};
int rotationIndex = 0;
const QStringList expected = {QStringLiteral("First"), QStringLiteral("Second"), QStringLiteral("Third"),
QStringLiteral("First"), QStringLiteral("Second"), QStringLiteral("Third")};
for (const QString &name : expected) {
const PlaymatResolution resolved =
resolveEffectivePlaymat(deck, {}, fallback, PlaymatFallbackMode::RoundRobin, rotationIndex);
EXPECT_EQ(resolved.card.name, name);
}
EXPECT_EQ(rotationIndex, expected.size());
}
TEST(PlaymatResolverTest, RoundRobinRespectsExistingCursor)
{
DeckList deck;
const QList<PlaymatResolution> fallback = {makeResolution(QStringLiteral("First")),
makeResolution(QStringLiteral("Second"))};
int rotationIndex = 5;
const PlaymatResolution resolved =
resolveEffectivePlaymat(deck, {}, fallback, PlaymatFallbackMode::RoundRobin, rotationIndex);
EXPECT_EQ(resolved.card.name, QStringLiteral("Second")); // 5 % 2 == 1
EXPECT_EQ(rotationIndex, 6);
}
TEST(PlaymatResolverTest, RandomStaysWithinList)
{
DeckList deck;
const QList<PlaymatResolution> fallback = {makeResolution(QStringLiteral("First")),
makeResolution(QStringLiteral("Second")),
makeResolution(QStringLiteral("Third"))};
int rotationIndex = 0;
for (int i = 0; i < 50; ++i) {
const PlaymatResolution resolved =
resolveEffectivePlaymat(deck, {}, fallback, PlaymatFallbackMode::Random, rotationIndex);
ASSERT_FALSE(resolved.card.name.isEmpty());
EXPECT_TRUE(fallback.contains(resolved));
}
}
TEST(PlaymatResolverTest, ForceWithEmptyCardIgnoresFallbackParamsButNotFallback)
{
DeckList deck;
deck.setPlaymatCard({QStringLiteral("Deck Mat")});
// An empty force entry must not mask the deck-configured playmat.
const PlaymatResolution emptyForce;
int rotationIndex = 0;
const PlaymatResolution resolved =
resolveEffectivePlaymat(deck, emptyForce, {}, PlaymatFallbackMode::Fixed, rotationIndex);
EXPECT_EQ(resolved.card.name, QStringLiteral("Deck Mat"));
}