dota_factory/src/test/ScrapTest.cpp

#include "catch.hpp"

#include <QVector2D>

#include "DespawnAtComponent.h"
#include "EntityAdmin.h"
#include "ScrapDataComponent.h"
#include "ScrapSystem.h"

// ---------------------------------------------------------------------------
// Spawn
// ---------------------------------------------------------------------------

TEST_CASE("ScrapSystem: spawn returns a valid entity with correct scrap data", "[scrap]")
{
    EntityAdmin admin;
    ScrapSystem ss(admin);

    const entt::entity e = ss.spawn(QVector2D(3.0f, 4.0f), 5, 100);

    REQUIRE(admin.isValid(e));
    REQUIRE(admin.get<ScrapDataComponent>(e).amount == 5);
    REQUIRE(admin.get<DespawnAtComponent>(e).tick == 100);
}

// ---------------------------------------------------------------------------
// Despawn timing
// ---------------------------------------------------------------------------

TEST_CASE("ScrapSystem: scrap still present one tick before despawnAt", "[scrap]")
{
    EntityAdmin admin;
    ScrapSystem ss(admin);

    const entt::entity e = ss.spawn(QVector2D(0.0f, 0.0f), 1, 50);

    ss.tickDespawn(49);
    REQUIRE(admin.isValid(e));
}

TEST_CASE("ScrapSystem: scrap removed at despawnAt tick", "[scrap]")
{
    EntityAdmin admin;
    ScrapSystem ss(admin);

    const entt::entity e = ss.spawn(QVector2D(0.0f, 0.0f), 1, 50);

    ss.tickDespawn(50);
    REQUIRE_FALSE(admin.isValid(e));
}

// ---------------------------------------------------------------------------
// Selective removal
// ---------------------------------------------------------------------------

TEST_CASE("ScrapSystem: tickDespawn removes only expired scraps", "[scrap]")
{
    EntityAdmin admin;
    ScrapSystem ss(admin);

    const entt::entity earlyE = ss.spawn(QVector2D(0.0f, 0.0f), 1, 30);
    const entt::entity lateE  = ss.spawn(QVector2D(1.0f, 0.0f), 2, 60);

    ss.tickDespawn(30);

    REQUIRE_FALSE(admin.isValid(earlyE));
    REQUIRE(admin.isValid(lateE));
}

// ---------------------------------------------------------------------------
// Consume
// ---------------------------------------------------------------------------

TEST_CASE("ScrapSystem: consume returns amount and destroys entity", "[scrap]")
{
    EntityAdmin admin;
    ScrapSystem ss(admin);

    const entt::entity e = ss.spawn(QVector2D(0.0f, 0.0f), 7, 100);

    const std::optional<int> amount = ss.consume(e);
    REQUIRE(amount.has_value());
    REQUIRE(*amount == 7);
    REQUIRE_FALSE(admin.isValid(e));
}

TEST_CASE("ScrapSystem: consume returns nullopt for invalid entity", "[scrap]")
{
    EntityAdmin admin;
    ScrapSystem ss(admin);

    const std::optional<int> amount = ss.consume(entt::null);
    REQUIRE_FALSE(amount.has_value());
}

// ---------------------------------------------------------------------------
// collectOne
// ---------------------------------------------------------------------------

TEST_CASE("ScrapSystem: collectOne depletes one scrap and keeps the pile until empty", "[scrap]")
{
    EntityAdmin admin;
    ScrapSystem ss(admin);

    const entt::entity e = ss.spawn(QVector2D(0.0f, 0.0f), 3, 100);

    REQUIRE(ss.collectOne(e));
    REQUIRE(admin.isValid(e));
    REQUIRE(admin.get<ScrapDataComponent>(e).amount == 2);

    REQUIRE(ss.collectOne(e));
    REQUIRE(admin.isValid(e));
    REQUIRE(admin.get<ScrapDataComponent>(e).amount == 1);

    // Final unit collected: the pile is removed once depleted.
    REQUIRE(ss.collectOne(e));
    REQUIRE_FALSE(admin.isValid(e));
}

TEST_CASE("ScrapSystem: collectOne returns false for an invalid entity", "[scrap]")
{
    EntityAdmin admin;
    ScrapSystem ss(admin);

    REQUIRE_FALSE(ss.collectOne(entt::null));
}

// ---------------------------------------------------------------------------
// allScrapInfo
// ---------------------------------------------------------------------------

TEST_CASE("ScrapSystem: allScrapInfo returns all spawned scrap", "[scrap]")
{
    EntityAdmin admin;
    ScrapSystem ss(admin);

    ss.spawn(QVector2D(1.0f, 2.0f), 3, 100);
    ss.spawn(QVector2D(4.0f, 5.0f), 6, 200);

    const std::vector<ScrapInfo> info = ss.allScrapInfo();
    REQUIRE(info.size() == 2);
}