Skip to content

Zero Hour rebuilt from EA's source: x64, Direct3D 11, VS2022/CMake, ~60 original bugs fixed, an AI that builds a base. Bring your own game.

13.7 KB
Raw Blame
#include "test_harness.h"
#include "Platform/HazardCloudPolicy.h"
#include "Platform/HazardCloud.h"
#include "Platform/HazardCloudFlow.h"
#include "Platform/HazardCloudCore.h"

#include <initializer_list>
#include <limits>
#include <type_traits>

using namespace HazardCloudPolicy;

TEST(hazard_cloud_recognizes_only_known_particle_templates)
{
    const char *const names[][3] = {
        {"PoisonFieldSmall", "PoisonFieldMedium", "PoisonFieldLarge"},
        {"RadiationFieldSmall", "RadiationFieldMedium", "RadiationFieldLarge"},
        {"AnthraxFieldSmall", "AnthraxFieldMedium", "AnthraxFieldLarge"},
        {"GC_Chem_AnthraxGammaFieldSmall", "GC_Chem_AnthraxFieldGammaMedium",
            "GC_Chem_AnthraxFieldGammaLarge"}
    };
    for (int palette = 0; palette < 4; ++palette)
        for (const char *name : names[palette]) CHECK_EQ(paletteForTemplate(name), palette);
    CHECK_EQ(paletteForTemplate("NukeRadiationInitial"), 1);
    CHECK_EQ(paletteForTemplate("poisonfieldLARGE"), 0);
    for (const char *name : {static_cast<const char *>(nullptr), "", "PoisonFieldLargeExtra", "MyRadiationFieldLarge",
            "GC_Chem_AnthraxFieldGammaSmall", "ToxinTankPuddle", "NukeMushroomStem",
            "ToxinSpray", "PoisonFieldAnthraxBomb"})
        CHECK_EQ(paletteForTemplate(name), -1);
}

TEST(hazard_cloud_matches_actual_hazard_object_names)
{
    CHECK_EQ(paletteForOwner("PoisonFieldMedium"), 0);
    CHECK_EQ(paletteForOwner("PoisonFieldUpgradedLarge"), 2);
    CHECK_EQ(paletteForOwner("PoisonFieldAnthraxBomb"), 2);
    CHECK_EQ(paletteForOwner("PoisonFieldAnthraxGammaBomb"), 3);
    CHECK_EQ(paletteForOwner("NukeRadiationFieldWeapon"), 1);
    CHECK_EQ(paletteForOwner("Nuke_RadiationFieldSmall"), 1);
    for (const char *name : {"RadiationFieldSmall", "RadiationFieldMedium", "RadiationFieldLarge"})
        CHECK_EQ(paletteForOwner(name), 1);
    for (const char *name : {"Chem_PoisonFieldGammaSmall", "Chem_PoisonFieldGammaMedium",
            "Chem_PoisonFieldGammaLarge", "GC_Chem_PoisonFieldGammaSmall",
            "GC_Chem_PoisonFieldGammaMedium", "GC_Chem_PoisonFieldGammaLarge"})
        CHECK_EQ(paletteForOwner(name), 3);
    for (const char *name : {static_cast<const char *>(nullptr), "", "NukeRadiationInitial", "AnthraxFieldLarge",
            "GC_Chem_AnthraxGammaFieldSmall", "GLAVehicleToxinTruck", "Chem_GLAScudStorm",
            "LargePoisonFieldWeapon", "PoisonFieldMediumCustom"})
        CHECK_EQ(paletteForOwner(name), -1);
}

TEST(hazard_cloud_nuclear_fades_in_across_its_full_footprint)
{
    for (float age : {0.0f, 0.1f, 1.0f, 3.0f, 6.0f, 12.0f}) {
        const Buildup nuclear = visualBuildup(1, true, age, 30.0f);
        CHECK_EQ(nuclear.formation, 1.0f);
        CHECK(nuclear.density >= 0.0f && nuclear.density <= 1.0f);
        CHECK(nuclear.release >= 0.0f && nuclear.release <= 1.0f);
    }
    CHECK_NEAR(visualBuildup(1, true, 3.0f, 30.0f).density, 0.5f, 0.00001f);
    CHECK_NEAR(visualBuildup(1, true, 3.0f, 30.0f).release, 0.675f, 0.00001f);
    CHECK_EQ(visualBuildup(1, true, 6.0f, 30.0f).density, 1.0f);
    CHECK_EQ(visualBuildup(1, true, 6.0f, 30.0f).release, 0.0f);
    CHECK_EQ(visualBuildup(1, false, 3.0f, 30.0f).density, 1.0f);
}

TEST(hazard_cloud_toxin_formation_and_release_preserve_palette_identity)
{
    for (int palette : {0, 2, 3}) {
        const Buildup beginning = visualBuildup(palette, false, 0.0f, 30.0f);
        const Buildup middle = visualBuildup(palette, false, 1.5f, 30.0f);
        const Buildup formed = visualBuildup(palette, false, 3.0f, 30.0f);
        CHECK_EQ(beginning.formation, 0.0f);
        CHECK_EQ(beginning.density, 0.0f);
        CHECK_EQ(beginning.release, 1.0f);
        CHECK_NEAR(middle.formation, 0.5f, 0.00001f);
        CHECK_EQ(middle.density, 1.0f);
        CHECK_EQ(formed.formation, 1.0f);
        CHECK_EQ(formed.density, 1.0f);
        CHECK_EQ(formed.release, 0.0f);
        CHECK_NEAR(visualBuildup(palette, true, 1.5f, 30.0f).formation,
            middle.formation, 0.00001f); // Large-nuclear flag must not slow toxin.
    }
}

TEST(hazard_cloud_short_lifetimes_have_a_visible_lingering_phase)
{
    for (float lifetime : {0.04f, 0.5f, 2.5f, 10.0f, 30.0f, 180.0f})
        for (int palette = 0; palette < 4; ++palette) {
            const Buildup formed = visualBuildup(palette, true, lifetime * 0.25f, lifetime);
            CHECK_EQ(formed.formation, 1.0f);
            CHECK_EQ(formed.density, 1.0f);
            CHECK_EQ(formed.release, 0.0f);
            CHECK_EQ(visualBuildup(palette, true, lifetime, lifetime).density, 0.0f);
            CHECK_EQ(visualBuildup(palette, true, lifetime + 1.0f, lifetime).density, 0.0f);
        }
    CHECK(visualBuildup(1, false, 0.3f, 2.5f).density > 0.4f);
}

TEST(hazard_cloud_invalid_buildup_is_hidden_and_finite)
{
    const float nan = std::numeric_limits<float>::quiet_NaN();
    const float inf = std::numeric_limits<float>::infinity();
    for (int palette : {-1, 0, 1, 4})
        for (float value : {-1.0f, nan, inf}) {
            const Buildup badAge = visualBuildup(palette, true, value, 30.0f);
            const Buildup badLife = visualBuildup(palette, true, 1.0f, value);
            CHECK_EQ(badAge.density, 0.0f);
            CHECK_EQ(badLife.density, 0.0f);
            CHECK(std::isfinite(badAge.formation));
            CHECK(std::isfinite(badLife.formation));
        }
    CHECK_EQ(visualBuildup(1, true, 0.0f, 0.0f).density, 0.0f);
    CHECK_EQ(visualBuildup(-1, true, 1.0f, 30.0f).density, 0.0f);
}

TEST(hazard_cloud_fringe_covers_original_rotated_breathing_quads)
{
    CHECK_EQ(visualFringe(0.0f), 0.0f);
    CHECK_NEAR(visualFringe(42.82f), std::sqrt(2.0f) * 1.04f * 42.82f, 0.000001f);
    CHECK(visualFringe(50.0f) > 50.0f * std::sqrt(2.0f));
    CHECK_EQ(visualFringe(-1.0f), 0.0f);
    CHECK_EQ(visualFringe(std::numeric_limits<float>::infinity()), 0.0f);
    CHECK_EQ(visualFringe((std::numeric_limits<float>::max)()), 0.0f);
}

TEST(hazard_cloud_admission_rejects_invalid_values_without_changing_footprints)
{
    CHECK(validField(-100.0f, 200.0f, 30.0f, 300.0f, 18.0f, 1.0f, 1.0f, 89.0f, 2));
    CHECK(validField(0.0f, 0.0f, 0.0f, 7.5f, 18.0f, 0.0f, 0.0f, 0.0f, 3));
    const float good[] = {0.0f, 0.0f, 30.0f, 80.0f, 18.0f, 1.0f, 1.0f, 63.0f};
    for (int slot = 0; slot < 8; ++slot)
        for (float invalid : {std::numeric_limits<float>::quiet_NaN(),
                std::numeric_limits<float>::infinity()}) {
            float values[8];
            for (int i = 0; i < 8; ++i) values[i] = i == slot ? invalid : good[i];
            CHECK(!validField(values[0], values[1], values[2], values[3], values[4],
                values[5], values[6], values[7], 0));
        }
    CHECK(!validField(0, 0, 0, 0, 18, 1, 1, 0, 0));
    CHECK(!validField(0, 0, 0, 80, 0, 1, 1, 0, 0));
    CHECK(!validField(0, 0, 0, 80, 18, -0.1f, 1, 0, 0));
    CHECK(!validField(0, 0, 0, 80, 18, 1.1f, 1, 0, 0));
    CHECK(!validField(0, 0, 0, 80, 18, 1, 1.1f, 0, 0));
    CHECK(!validField(0, 0, 0, 80, 18, 1, 1, -1, 0));
    CHECK(!validField(0, 0, 0, 80, 18, 1, 1, 0, -1));
    CHECK(!validField(0, 0, 0, 80, 18, 1, 1, 0, 4));
    CHECK(!validField(0, 0, 0, 1e30f, 18, 1, 1, 0, 0));
}


// This target deliberately links the no-backend implementation on every
// platform. It keeps the public API and device-free transport independently
// usable when a game build has no volumetric renderer (Windows today).
static_assert(std::is_abstract<HazardCloud::Layer>::value, "Layer must remain a backend interface");
static_assert(std::has_virtual_destructor<HazardCloud::Layer>::value, "Layer is owned through the interface");
static_assert(std::is_same<HazardCloud::Body, HazardCloudFlow::Body>::value, "Flow and renderer share body geometry");

TEST(hazard_cloud_no_backend_reports_unavailable_and_creates_no_layer)
{
    CHECK(!HazardCloud::Supported());
    CHECK(HazardCloud::CreateLayer() == nullptr);
}

TEST(hazard_cloud_neutral_palette_and_cache_policy_need_no_device)
{
    using HazardCloud::Layer;
    CHECK_EQ(HazardCloud::TerrainGridSide, 129u);
    CHECK_EQ(&HazardCloud::defaultPalette(4), &HazardCloud::defaultPalette(0));
    for (unsigned index = 0; index < 4; ++index) {
        const HazardCloud::Palette &palette = HazardCloud::defaultPalette(index);
        CHECK(std::isfinite(palette.main.r) && std::isfinite(palette.shadow.r));
        CHECK(palette.brightness > 0.0f && palette.brightness <= 2.0f);
        CHECK(palette.transparency >= 0.0f && palette.transparency <= 1.0f);
    }
    HazardCloud::FieldState fields[2] = {
        {{0, 0, 0}, 40, 18, 1, 0, 1, 0, 0},
        {{80, 0, 0}, 80, 18, 1, 1, 1, 0, 0}
    };
    const std::uint64_t shared = Layer::estimateCacheBytes(nullptr, 0);
    const std::uint64_t first = Layer::estimateCacheBytes(fields, 1);
    const std::uint64_t second = Layer::estimateCacheBytes(fields + 1, 1);
    CHECK(first > shared);
    CHECK(second > first);
    CHECK_EQ(Layer::estimateCacheBytes(fields, 2), first + second - shared);
    const std::uint64_t rejected = (std::numeric_limits<std::uint64_t>::max)();
    CHECK_EQ(Layer::estimateCacheBytes(nullptr, 1), rejected);
    CHECK_EQ(Layer::estimateCacheBytes(fields, 3), rejected);
    fields[0].radius = std::numeric_limits<float>::quiet_NaN();
    CHECK_EQ(Layer::estimateCacheBytes(fields, 1), rejected);
}

TEST(hazard_cloud_neutral_flow_advances_and_resets_without_a_renderer)
{
    HazardCloudFlow::Flow flow;
    CHECK(!flow.valid());
    flow.setDomain(-80, -40, 80, 40);
    CHECK(flow.valid());
    const HazardCloud::Body body = {0, 0, 0, 30, 0, 3, 15};
    for (unsigned step = 0; step < 30; ++step)
        flow.step(1.0f / 60.0f, &body, 1);
    CHECK(flow.valid());
    CHECK_EQ(flow.activeBodies(), 1u);
    CHECK(flow.maxDisturbance() > 0.0f && flow.maxDisturbance() <= 1.0f);
    const float disturbance = flow.maxDisturbance();
    flow.step(0.0f, nullptr, 0);
    CHECK_EQ(flow.maxDisturbance(), disturbance);
    flow.reset();
    CHECK(flow.valid());
    CHECK_EQ(flow.domainMinX(), -80.0f);
    CHECK_EQ(flow.domainMaxY(), 40.0f);
    CHECK_EQ(flow.activeBodies(), 0u);
    CHECK_EQ(flow.maxDisturbance(), 0.0f);
    for (unsigned slot = 0; slot < flow.width() * flow.height() * 4; ++slot)
        if (flow.data()[slot] != 0.0f) {
            CHECK(false);
            break;
        }
}

namespace {

// The device-free core with no device under it: what a backend would bake and upload.
class CoreProbe final : public HazardCloud::LayerCore {
public:
    bool initialize() override { initialized = true; return true; }
    bool render(const HazardCloud::Camera &) override { return false; }
    std::uint64_t estimatedCacheBytes() const override { return 0; }
    void shutdown() override {}
    using LayerCore::flowUploaded;
    bool bakesFrom(float cameraX)
    {
        // A perspective camera standing back from the field, moved sideways by cameraX.
        HazardCloud::Camera camera = {
            {1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, cameraX, 0, 400, 1},
            {1, 0, 0, 0, 0, 1.7f, 0, 0, 0, 0, 1.001f, 1, 0, 0, -1.001f, 0},
            0, 0, 1280, 720, 0, 1 };
        HazardCloud::Uniforms uniforms;
        float viewProjection[16];
        CHECK(buildUniforms(camera, 1280, 720, uniforms, viewProjection));
        return takeBake(uniforms);
    }
};

} // namespace

TEST(hazard_cloud_atlases_rebake_on_a_change_and_at_most_twenty_times_a_second)
{
    CoreProbe layer;
    layer.initialize();
    const HazardCloud::FieldState field = {{0, 0, 0}, 40, 18.61f, 1, 0, 1, 0, 10};
    layer.setFields(&field, 1);
    layer.update(1.0f);
    CHECK(layer.bakesFrom(0));
    CHECK(!layer.bakesFrom(0));
    CHECK(!layer.bakesFrom(50));      // the camera never reaches the atlases
    layer.update(1.01f);              // aging inside one bake period
    CHECK(!layer.bakesFrom(0));
    layer.update(1.06f);              // and into the next
    CHECK(layer.bakesFrom(0));
    HazardCloud::Palette palette = HazardCloud::defaultPalette(0);
    palette.brightness = 1.0f;
    layer.setPalette(0, palette);     // a structural change shows on the next frame
    CHECK(layer.bakesFrom(0));
    HazardCloud::FieldState wider = field;
    wider.radius = 60;
    layer.setFields(&wider, 1);
    CHECK(layer.bakesFrom(0));
    CHECK_EQ(layer.bakes(), 4u);
}

TEST(hazard_cloud_quiet_wake_grid_uploads_nothing)
{
    CoreProbe layer;
    layer.initialize();
    const HazardCloud::FieldState field = {{0, 0, 0}, 40, 18.61f, 1, 0, 1, 0, 10};
    layer.setFields(&field, 1);
    CHECK(layer.flowNeedsUpload());
    layer.flowUploaded();
    float seconds = 1.0f;
    for (unsigned frame = 0; frame < 30; ++frame) layer.update(seconds += 1.0f / 60.0f);
    CHECK(!layer.flowNeedsUpload());  // no infantry, nothing to heal
    const HazardCloud::Body walker = {0, 0, 0, 30, 0, 3, 15};
    layer.setBodies(&walker, 1);
    for (unsigned frame = 0; frame < 10; ++frame) layer.update(seconds += 1.0f / 60.0f);
    CHECK(layer.flowNeedsUpload());
    CHECK(layer.maxDisturbance() > 0.0f);
    layer.flowUploaded();
    layer.setBodies(nullptr, 0);
    for (unsigned frame = 0; frame < 60 * 20 && layer.maxDisturbance() > 0.0f; ++frame)
        layer.update(seconds += 1.0f / 60.0f);
    CHECK_EQ(layer.maxDisturbance(), 0.0f);  // healed, then put at rest
    layer.flowUploaded();
    layer.update(seconds += 1.0f / 60.0f);
    CHECK(!layer.flowNeedsUpload());
    CHECK(layer.valid());
}

TEST(hazard_cloud_shader_text_drops_register_spaces_only_for_direct3d_11)
{
    using HazardCloud::Pass;
    for (Pass pass : {Pass::Volume, Pass::Composite, Pass::Density, Pass::Lighting, Pass::Heat}) {
        CHECK(HazardCloud::pixelShader(pass, true).find(", space2)") != std::string::npos);
        CHECK(HazardCloud::pixelShader(pass, false).find(", space") == std::string::npos);
    }
    CHECK(HazardCloud::emberVertexShader(false).find(", space") == std::string::npos);
    CHECK(HazardCloud::emberPixelShader(false).find("register(b0)") != std::string::npos);
}