test: cover sameLook and rowsToWalk

tests/testTilePalette.cpp

@@ -0,0 +1,146 @@
+#include <cstdio>
+#include <cstring>
+#include <vector>
+
+#include "testHarness.h"
+#include "vf/Block.h"
+#include "vf/TilePalette.h"
+
+using namespace vf;
+
+namespace {
+
+const Face allFaces[6] = {Face::PosX, Face::NegX, Face::PosY,
+                          Face::NegY, Face::PosZ, Face::NegZ};
+
+bool sameLook(const TileSpec& a, const TileSpec& b) {
+    return a.base == b.base && a.accent == b.accent && a.pattern == b.pattern;
+}
+
+// A palette short of a row is exactly what these tests are here to catch, so
+// they must report it rather than walk off the end of the table proving it.
+int rowsToWalk(const TilePalette& palette) {
+    return palette.size() < tileCount ? palette.size() : tileCount;
+}
+
+} // namespace
+
+// The whole point of the palette: 157 tiles, 157 entries. The old generator had
+// a switch covering fifteen of them and one grey default for the other one
+// hundred and forty two, and nothing could tell you that from the outside.
+VF_TEST(everyAtlasTileHasItsOwnPaletteEntry) {
+    TilePalette palette;
+    CHECK_EQ(palette.size(), tileCount);
+
+    for (int tile = 0; tile < rowsToWalk(palette); ++tile) {
+        const TileSpec& spec = palette.specFor(tile);
+        bool named = spec.name != nullptr && std::strlen(spec.name) > 0;
+        CHECK(named);
+        if (!named) std::printf("  unnamed tile: %d\n", tile);
+        CHECK(spec.noise >= 0.0f);
+        CHECK(spec.noise <= 0.30f);
+        CHECK(spec.scale >= 0.0f);
+        CHECK(spec.scale <= 1.0f);
+        CHECK(spec.density >= 0.0f);
+        CHECK(spec.density <= 1.0f);
+        CHECK(spec.pattern != TilePattern::Count);
+        CHECK(spec.material != TileMaterial::Count);
+    }
+}
+
+// Two tiles that agree on base colour, accent colour and pattern render the
+// same picture, which means one of them is a copy nobody meant to ship.
+VF_TEST(noTwoTilesShareTheSameBaseAccentAndPattern) {
+    TilePalette palette;
+    int duplicates = 0;
+    for (int a = 0; a < palette.size(); ++a) {
+        for (int b = a + 1; b < palette.size(); ++b) {
+            if (!sameLook(palette.specFor(a), palette.specFor(b))) continue;
+            ++duplicates;
+            if (duplicates <= 8) {
+                std::printf("  duplicate tiles: %d (%s) and %d (%s)\n", a, palette.specFor(a).name,
+                            b, palette.specFor(b).name);
+            }
+        }
+    }
+    CHECK_EQ(duplicates, 0);
+}
+
+// The palette is indexed by whatever faceTile hands out, so the two have to
+// agree over the entire block list, not over the blocks that existed when the
+// palette was written.
+VF_TEST(everyBlockFaceLandsOnATileThatHasASpec) {
+    TilePalette palette;
+    for (int id = 1; id < static_cast<int>(Block::Count); ++id) {
+        Block block = static_cast<Block>(id);
+        for (Face face : allFaces) {
+            int tile = faceTile(block, face);
+            CHECK(tile >= 0);
+            CHECK(tile < palette.size());
+            if (tile < 0 || tile >= palette.size()) {
+                std::printf("  block %d has no spec for tile %d\n", id, tile);
+                continue;
+            }
+            CHECK(std::strlen(palette.specFor(tile).name) > 0);
+        }
+    }
+}
+
+// Regression on the look of the world that already exists. These fifteen
+// numbers are copied out of the generator that render/Atlas.cpp used to carry;
+// if the palette drifts from them, old terrain changes colour.
+VF_TEST(theFifteenOriginalTilesKeepTheirExactColours) {
+    TilePalette palette;
+    const TileRgb historical[15] = {
+        {86, 154, 66},    // 0  grass top
+        {112, 92, 58},    // 1  grass side, dirt under the green lip
+        {119, 88, 58},    // 2  dirt
+        {129, 129, 132},  // 3  stone
+        {214, 199, 143},  // 4  sand
+        {104, 78, 46},    // 5  wood bark
+        {160, 128, 78},   // 6  wood rings
+        {58, 122, 52},    // 7  leaves
+        {54, 96, 168},    // 8  water
+        {236, 240, 245},  // 9  snow
+        {129, 129, 132},  // 10 coal ore, stone base
+        {129, 129, 132},  // 11 iron ore, stone base
+        {129, 129, 132},  // 12 gold ore, stone base
+        {122, 120, 120},  // 13 gravel
+        {242, 220, 132},  // 14 glowstone
+    };
+    CHECK(palette.size() >= 15);
+    for (int tile = 0; tile < rowsToWalk(palette) && tile < 15; ++tile) {
+        bool kept = palette.specFor(tile).base == historical[tile];
+        CHECK(kept);
+        if (!kept) {
+            const TileRgb& now = palette.specFor(tile).base;
+            std::printf("  tile %d drifted to %u,%u,%u\n", tile, now.r, now.g, now.b);
+        }
+    }
+
+    // The accents the old code drew on top: the green lip on the grass side and
+    // the three ore vein colours.
+    TileRgb grassGreen{86, 154, 66};
+    TileRgb coal{38, 38, 42};
+    TileRgb iron{196, 156, 120};
+    TileRgb gold{238, 214, 96};
+    CHECK(palette.specFor(1).accent == grassGreen);
+    CHECK(palette.specFor(10).accent == coal);
+    CHECK(palette.specFor(11).accent == iron);
+    CHECK(palette.specFor(12).accent == gold);
+}
+
+// The grey the old generator returned for every unhandled tile. Nothing may
+// still be sitting on it, and the TileSpec default is that same grey so an
+// entry that was declared and never filled in is caught here too.
+VF_TEST(noTileIsLeftOnTheOldDefaultGrey) {
+    TilePalette palette;
+    TileSpec untouched;
+    for (int tile = 0; tile < palette.size(); ++tile) {
+        const TileSpec& spec = palette.specFor(tile);
+        bool blank = spec.base == untouched.base && spec.accent == untouched.accent;
+        CHECK(!blank);
+        if (blank) std::printf("  tile %d is still default grey\n", tile);
+    }
+}
+