ModernIBarSkin.cpp

Go to the documentation of this file.

#include "ModernIBarSkin.hpp"
#include "IBarCameraButtonPlayback.hpp"
#include <algorithm>
#include <array>
#include <sstream>
#include <cmath>
 
namespace monopoly::ibar
{
    namespace
    {
        constexpr std::array<std::string_view, 28> French{
            "Enchères", "Acheter", "Vue", "Terminer", "Vendre", "Taxe fixe",
            "Pourcentage", "Construire", "Accepter", "Contre-offre", "Faillite",
            "Refuser", "Hypothéquer", "Plateau", "Options", "Payer",
            "Nouvelle partie", "Lancer", "Bilan", "Échanger", "Lever hyp.",
            "Quitter", "Rejouer", "Utiliser carte", "Enchère maison",
            "Enchère hôtel", "Placer maison", "Placer hôtel"};
        constexpr std::array<std::string_view, 28> English{
            "Auction", "Buy", "View", "Done", "Sell", "Flat tax", "Percentage",
            "Build", "Accept", "Counteroffer", "Bankrupt", "Reject", "Mortgage",
            "Board", "Options", "Pay", "New game", "Roll dice", "Status", "Trade",
            "Unmortgage", "Exit", "Play again", "Use card", "Auction house",
            "Auction hotel", "Place house", "Place hotel"};
        struct Button { unsigned index{}, state{}; bool grey{}; };
        std::optional<Button> button(data::DataId root)
        {
            if (data::dataGroup(root) != data::legacyGroupValue(data::LegacyGroupId::LanguageGraphics))
                return {};
            const auto tag = data::dataTag(root);
            for (const auto base : {ButtonBaseTag, AIButtonBaseTag})
                if (tag >= base && tag < base + 28 * ButtonAnimationsPerSet)
                    return Button{unsigned(tag - base) / 4, unsigned(tag - base) % 4,
                        base == AIButtonBaseTag};
            return {};
        }
        struct NativeActionShape { std::uint16_t root,leaf,width,height; std::int16_t x,y; };
        // Actual dat_lm01 CNK descriptions: Buy/Done/FlatTax/Percentage/Mortgage/Roll,
        // enabled and grey, all four authored states. Native geometry only.
        // Full production description/tick dump SHA256: 4883f86c5f70a4a19a4d40159f9f8720c04b2d15a5d56c94a04649c13a87fa03
        constexpr std::array<NativeActionShape,430> NativeActionShapes{{
            {0x8e,0x128d,92,13,271,470},
            {0x8e,0x128e,95,22,269,461},
            {0x8e,0x128f,96,28,269,455},
            {0x8e,0x1290,93,30,269,453},
            {0x8e,0x1291,96,30,266,453},
            {0x8e,0x1292,96,30,266,453},
            {0x8e,0x1293,96,30,266,453},
            {0x8e,0x1294,97,30,264,453},
            {0x8e,0x1295,99,30,261,453},
            {0x8e,0x1296,116,33,248,453},
            {0x8e,0x1297,120,84,240,453},
            {0x8f,0x1297,120,84,240,453},
            {0x8f,0x1298,120,84,240,453},
            {0x8f,0x1299,120,84,240,453},
            {0x8f,0x129a,120,84,240,453},
            {0x8f,0x129b,120,84,240,453},
            {0x8f,0x129c,120,84,240,453},
            {0x8f,0x129d,120,84,240,453},
            {0x8f,0x129e,120,84,240,453},
            {0x90,0x12a4,120,84,240,453},
            {0x90,0x12a5,120,84,240,453},
            {0x90,0x12a6,120,94,238,458},
            {0x90,0x12a7,145,93,210,462},
            {0x90,0x12a8,139,73,205,466},
            {0x90,0x12a9,144,75,154,467},
            {0x90,0x12aa,145,73,103,466},
            {0x90,0x12ab,142,73,126,466},
            {0x90,0x12ac,137,73,246,466},
            {0x90,0x12ad,141,74,433,465},
            {0x90,0x12ae,117,75,683,465},
            {0x91,0x129f,120,84,240,453},
            {0x91,0x12a0,120,85,240,452},
            {0x91,0x12a1,120,86,240,452},
            {0x91,0x12a2,120,85,240,452},
            {0x91,0x12a3,120,84,240,453},
            {0x91,0x12a4,120,84,240,453},
            {0x91,0x12a5,120,84,240,453},
            {0x91,0x12a6,120,94,238,458},
            {0x91,0x12a7,145,93,210,462},
            {0x91,0x12a8,139,73,205,466},
            {0x91,0x12a9,144,75,154,467},
            {0x91,0x12aa,145,73,103,466},
            {0x91,0x12ab,142,73,126,466},
            {0x91,0x12ac,137,73,246,466},
            {0x91,0x12ad,141,74,433,465},
            {0x91,0x12ae,117,75,683,465},
            {0x96,0x12c1,34,63,0,450},
            {0x96,0x12c2,141,101,41,451},
            {0x96,0x12c3,124,96,205,451},
            {0x96,0x12c4,119,42,352,453},
            {0x97,0x12c5,119,42,352,453},
            {0x97,0x12c6,119,42,352,453},
            {0x97,0x12c7,119,42,352,453},
            {0x97,0x12c8,119,42,352,453},
            {0x97,0x12c9,119,42,352,453},
            {0x97,0x12ca,119,42,352,453},
            {0x97,0x12cb,119,42,352,453},
            {0x98,0x12d1,119,42,352,453},
            {0x98,0x12d2,118,42,353,453},
            {0x98,0x12d3,120,85,451,453},
            {0x98,0x12d4,120,85,549,453},
            {0x98,0x12d5,120,95,645,453},
            {0x98,0x12d6,50,23,750,490},
            {0x99,0x12cc,118,42,352,453},
            {0x99,0x12cd,118,43,353,452},
            {0x99,0x12ce,118,43,352,452},
            {0x99,0x12cf,118,43,353,452},
            {0x99,0x12d0,118,42,353,453},
            {0x99,0x12d1,119,42,352,453},
            {0x99,0x12d2,118,42,353,453},
            {0x99,0x12d3,120,85,451,453},
            {0x99,0x12d4,120,85,549,453},
            {0x99,0x12d5,120,95,645,453},
            {0x99,0x12d6,50,23,750,490},
            {0x9e,0x12ee,89,12,273,471},
            {0x9e,0x12ef,94,22,270,461},
            {0x9e,0x12f0,95,29,269,454},
            {0x9e,0x12f1,95,30,269,453},
            {0x9e,0x12f2,97,30,267,453},
            {0x9e,0x12f3,94,30,267,453},
            {0x9e,0x12f4,96,31,265,452},
            {0x9e,0x12f5,109,32,256,452},
            {0x9e,0x12f6,117,33,248,453},
            {0x9e,0x12f7,122,84,243,453},
            {0x9f,0x12f7,122,84,243,453},
            {0xa0,0x12fd,122,84,243,453},
            {0xa0,0x12fe,122,84,243,453},
            {0xa0,0x12ff,117,33,250,453},
            {0xa0,0x1300,97,32,264,451},
            {0xa0,0x1301,95,31,266,452},
            {0xa0,0x1302,97,31,267,452},
            {0xa0,0x1303,95,30,269,453},
            {0xa0,0x1304,96,30,269,453},
            {0xa0,0x1305,96,30,269,453},
            {0xa0,0x1306,92,21,272,462},
            {0xa1,0x12f8,122,84,243,453},
            {0xa1,0x12f9,122,85,243,452},
            {0xa1,0x12fa,122,85,243,452},
            {0xa1,0x12fb,122,85,243,452},
            {0xa1,0x12fc,122,84,243,453},
            {0xa1,0x12fd,122,84,243,453},
            {0xa1,0x12fe,122,84,243,453},
            {0xa1,0x12ff,117,33,250,453},
            {0xa1,0x1300,97,32,264,451},
            {0xa1,0x1301,95,31,266,452},
            {0xa1,0x1302,97,31,267,452},
            {0xa1,0x1303,95,30,269,453},
            {0xa1,0x1304,96,30,269,453},
            {0xa1,0x1305,96,30,269,453},
            {0xa1,0x1306,92,21,272,462},
            {0xa2,0x1307,89,10,454,473},
            {0xa2,0x1308,95,26,452,457},
            {0xa2,0x1309,95,30,452,453},
            {0xa2,0x130a,95,30,454,453},
            {0xa2,0x130b,94,30,455,453},
            {0xa2,0x130c,94,30,456,453},
            {0xa2,0x130d,97,31,456,452},
            {0xa2,0x130e,108,32,457,452},
            {0xa2,0x130f,119,33,454,453},
            {0xa2,0x1310,120,85,459,453},
            {0xa3,0x1310,120,85,459,453},
            {0xa4,0x1316,120,85,459,453},
            {0xa4,0x1317,120,85,459,453},
            {0xa4,0x1318,119,73,459,453},
            {0xa4,0x1319,120,65,456,453},
            {0xa4,0x131a,120,33,454,453},
            {0xa4,0x131b,116,32,455,453},
            {0xa4,0x131c,115,32,455,453},
            {0xa4,0x131d,113,32,293,453},
            {0xa4,0x131e,93,32,154,453},
            {0xa4,0x131f,18,7,0,489},
            {0xa5,0x1311,120,85,459,453},
            {0xa5,0x1312,121,86,458,452},
            {0xa5,0x1313,120,86,459,452},
            {0xa5,0x1314,120,86,459,452},
            {0xa5,0x1315,120,85,459,453},
            {0xa5,0x1316,120,85,459,453},
            {0xa5,0x1317,120,85,459,453},
            {0xa5,0x1318,119,73,459,453},
            {0xa5,0x1319,120,65,456,453},
            {0xa5,0x131a,120,33,454,453},
            {0xa5,0x131b,116,32,455,453},
            {0xa5,0x131c,115,32,455,453},
            {0xa5,0x131d,113,32,293,453},
            {0xa5,0x131e,93,32,154,453},
            {0xa5,0x131f,18,7,0,489},
            {0xba,0x1353,175,84,510,474},
            {0xba,0x1354,152,74,493,467},
            {0xba,0x1355,150,93,481,462},
            {0xba,0x1356,136,95,471,457},
            {0xba,0x1357,120,85,459,453},
            {0xbb,0x1357,120,85,459,453},
            {0xbc,0x135d,121,85,458,453},
            {0xbc,0x135e,119,33,454,453},
            {0xbc,0x135f,110,31,453,453},
            {0xbc,0x1360,95,31,456,452},
            {0xbc,0x1361,95,30,455,453},
            {0xbc,0x1362,96,30,453,453},
            {0xbc,0x1363,97,30,452,453},
            {0xbc,0x1364,95,30,452,453},
            {0xbc,0x1365,95,30,452,453},
            {0xbc,0x1366,94,29,452,454},
            {0xbd,0x1358,120,85,459,453},
            {0xbd,0x1359,120,86,459,452},
            {0xbd,0x135a,120,86,459,452},
            {0xbd,0x135b,120,86,459,452},
            {0xbd,0x135c,120,85,459,453},
            {0xbd,0x135d,121,85,458,453},
            {0xbd,0x135e,119,33,454,453},
            {0xbd,0x135f,110,31,453,453},
            {0xbd,0x1360,95,31,456,452},
            {0xbd,0x1361,95,30,455,453},
            {0xbd,0x1362,96,30,453,453},
            {0xbd,0x1363,97,30,452,453},
            {0xbd,0x1364,95,30,452,453},
            {0xbd,0x1365,95,30,452,453},
            {0xbd,0x1366,94,29,452,454},
            {0xce,0x13f1,136,84,664,474},
            {0xce,0x13f2,162,84,337,474},
            {0xce,0x13f3,141,68,345,467},
            {0xce,0x13f4,131,93,348,462},
            {0xce,0x13f5,115,94,353,457},
            {0xce,0x13f6,121,42,349,453},
            {0xcf,0xae7,121,42,349,453},
            {0xcf,0xae8,121,42,349,453},
            {0xcf,0xae9,121,42,349,453},
            {0xcf,0xaea,121,42,349,453},
            {0xcf,0xaeb,121,42,349,453},
            {0xcf,0xaec,121,42,349,453},
            {0xcf,0xaed,121,42,349,453},
            {0xd0,0x13fc,121,42,350,453},
            {0xd0,0x13fd,115,33,352,453},
            {0xd0,0x13fe,109,31,355,453},
            {0xd0,0x13ff,93,31,362,452},
            {0xd0,0x1400,94,30,361,453},
            {0xd0,0x1401,94,30,361,453},
            {0xd0,0x1402,94,30,361,453},
            {0xd0,0x1403,95,30,361,453},
            {0xd0,0x1404,95,28,361,455},
            {0xd0,0x1405,95,28,361,455},
            {0xd1,0x13f7,121,42,350,453},
            {0xd1,0x13f8,121,43,350,452},
            {0xd1,0x13f9,122,43,349,452},
            {0xd1,0x13fa,121,43,350,452},
            {0xd1,0x13fb,120,42,350,453},
            {0xd1,0x13fc,121,42,350,453},
            {0xd1,0x13fd,115,33,352,453},
            {0xd1,0x13fe,109,31,355,453},
            {0xd1,0x13ff,93,31,362,452},
            {0xd1,0x1400,94,30,361,453},
            {0xd1,0x1401,94,30,361,453},
            {0xd1,0x1402,94,30,361,453},
            {0xd1,0x1403,95,30,361,453},
            {0xd1,0x1404,95,28,361,455},
            {0xd1,0x1405,95,28,361,455},
            {0x10a,0x14ce,92,13,271,470},
            {0x10a,0x14cf,95,22,269,461},
            {0x10a,0x14d0,96,28,269,455},
            {0x10a,0x14d1,93,30,269,453},
            {0x10a,0x14d2,96,30,266,453},
            {0x10a,0x14d3,96,30,266,453},
            {0x10a,0x14d4,96,30,266,453},
            {0x10a,0x14d5,97,30,264,453},
            {0x10a,0x14d6,99,30,261,453},
            {0x10a,0x14d7,116,33,248,453},
            {0x10a,0x14d8,120,84,240,453},
            {0x10b,0x14d8,120,84,240,453},
            {0x10b,0x14d9,120,84,240,453},
            {0x10b,0x14da,120,84,240,453},
            {0x10b,0x14db,120,84,240,453},
            {0x10b,0x14dc,120,84,240,453},
            {0x10b,0x14dd,120,84,240,453},
            {0x10b,0x14de,120,84,240,453},
            {0x10b,0x14df,120,84,240,453},
            {0x10c,0x14e5,120,84,240,453},
            {0x10c,0x14e6,120,84,240,453},
            {0x10c,0x14e7,120,94,238,458},
            {0x10c,0x14e8,145,93,210,462},
            {0x10c,0x14e9,139,73,205,466},
            {0x10c,0x14ea,144,75,154,467},
            {0x10c,0x14eb,145,73,103,466},
            {0x10c,0x14ec,142,73,126,466},
            {0x10c,0x14ed,137,73,246,466},
            {0x10c,0x14ee,141,74,433,465},
            {0x10c,0x14ef,117,75,683,465},
            {0x10d,0x14e0,120,84,240,453},
            {0x10d,0x14e1,120,85,240,452},
            {0x10d,0x14e2,120,86,240,452},
            {0x10d,0x14e3,120,85,240,452},
            {0x10d,0x14e4,120,84,240,453},
            {0x10d,0x14e5,120,84,240,453},
            {0x10d,0x14e6,120,84,240,453},
            {0x10d,0x14e7,120,94,238,458},
            {0x10d,0x14e8,145,93,210,462},
            {0x10d,0x14e9,139,73,205,466},
            {0x10d,0x14ea,144,75,154,467},
            {0x10d,0x14eb,145,73,103,466},
            {0x10d,0x14ec,142,73,126,466},
            {0x10d,0x14ed,137,73,246,466},
            {0x10d,0x14ee,141,74,433,465},
            {0x10d,0x14ef,117,75,683,465},
            {0x112,0x14f8,34,63,0,450},
            {0x112,0x14f9,141,101,41,451},
            {0x112,0x14fa,124,96,205,451},
            {0x112,0x14fb,119,42,352,453},
            {0x113,0x14fc,119,42,352,453},
            {0x113,0x14fd,119,42,352,453},
            {0x113,0x14fe,119,42,352,453},
            {0x113,0x14ff,119,42,352,453},
            {0x113,0x1500,119,42,352,453},
            {0x113,0x1501,119,42,352,453},
            {0x113,0x1502,119,42,352,453},
            {0x114,0x1508,119,42,352,453},
            {0x114,0x1509,118,42,353,453},
            {0x114,0x150a,120,85,451,453},
            {0x114,0x150b,120,85,549,453},
            {0x114,0x150c,120,97,645,451},
            {0x114,0x150d,61,59,739,454},
            {0x115,0x1503,118,42,352,453},
            {0x115,0x1504,118,43,353,452},
            {0x115,0x1505,118,43,352,452},
            {0x115,0x1506,118,43,353,452},
            {0x115,0x1507,118,42,353,453},
            {0x115,0x1508,119,42,352,453},
            {0x115,0x1509,118,42,353,453},
            {0x115,0x150a,120,85,451,453},
            {0x115,0x150b,120,85,549,453},
            {0x115,0x150c,120,97,645,451},
            {0x115,0x150d,61,59,739,454},
            {0x11a,0x1525,89,12,273,471},
            {0x11a,0x1526,94,22,270,461},
            {0x11a,0x1527,95,29,269,454},
            {0x11a,0x1528,95,30,269,453},
            {0x11a,0x1529,97,30,267,453},
            {0x11a,0x152a,94,30,267,453},
            {0x11a,0x152b,96,31,265,452},
            {0x11a,0x152c,109,32,256,452},
            {0x11a,0x152d,117,33,248,453},
            {0x11a,0x152e,122,84,243,453},
            {0x11b,0x152e,122,84,243,453},
            {0x11c,0x1534,122,84,243,453},
            {0x11c,0x1535,122,84,243,453},
            {0x11c,0x1536,117,33,250,453},
            {0x11c,0x1537,97,32,264,451},
            {0x11c,0x1538,95,31,266,452},
            {0x11c,0x1539,97,31,267,452},
            {0x11c,0x153a,95,30,269,453},
            {0x11c,0x153b,96,30,269,453},
            {0x11c,0x153c,96,30,269,453},
            {0x11c,0x153d,92,21,272,462},
            {0x11d,0x152f,122,84,243,453},
            {0x11d,0x1530,122,85,243,452},
            {0x11d,0x1531,122,85,243,452},
            {0x11d,0x1532,122,85,243,452},
            {0x11d,0x1533,122,84,243,453},
            {0x11d,0x1534,122,84,243,453},
            {0x11d,0x1535,122,84,243,453},
            {0x11d,0x1536,117,33,250,453},
            {0x11d,0x1537,97,32,264,451},
            {0x11d,0x1538,95,31,266,452},
            {0x11d,0x1539,97,31,267,452},
            {0x11d,0x153a,95,30,269,453},
            {0x11d,0x153b,96,30,269,453},
            {0x11d,0x153c,96,30,269,453},
            {0x11d,0x153d,92,21,272,462},
            {0x11e,0x153e,89,10,454,473},
            {0x11e,0x153f,95,26,452,457},
            {0x11e,0x1540,95,30,452,453},
            {0x11e,0x1541,95,30,454,453},
            {0x11e,0x1542,94,30,455,453},
            {0x11e,0x1543,94,30,456,453},
            {0x11e,0x1544,97,31,456,452},
            {0x11e,0x1545,108,32,457,452},
            {0x11e,0x1546,119,33,454,453},
            {0x11e,0x1547,120,85,459,453},
            {0x11f,0x1547,120,85,459,453},
            {0x120,0x154d,120,85,459,453},
            {0x120,0x154e,120,85,459,453},
            {0x120,0x154f,119,73,459,453},
            {0x120,0x1550,120,65,456,453},
            {0x120,0x1551,120,33,454,453},
            {0x120,0x1552,116,32,455,453},
            {0x120,0x1553,115,32,455,453},
            {0x120,0x1554,113,32,293,453},
            {0x120,0x1555,93,32,154,453},
            {0x120,0x1556,18,7,0,489},
            {0x121,0x1548,120,85,459,453},
            {0x121,0x1549,121,86,458,452},
            {0x121,0x154a,120,86,459,452},
            {0x121,0x154b,120,86,459,452},
            {0x121,0x154c,120,85,459,453},
            {0x121,0x154d,120,85,459,453},
            {0x121,0x154e,120,85,459,453},
            {0x121,0x154f,119,73,459,453},
            {0x121,0x1550,120,65,456,453},
            {0x121,0x1551,120,33,454,453},
            {0x121,0x1552,116,32,455,453},
            {0x121,0x1553,115,32,455,453},
            {0x121,0x1554,113,32,293,453},
            {0x121,0x1555,93,32,154,453},
            {0x121,0x1556,18,7,0,489},
            {0x136,0x158a,175,84,510,474},
            {0x136,0x158b,152,74,493,467},
            {0x136,0x158c,150,93,481,462},
            {0x136,0x158d,136,95,471,457},
            {0x136,0x158e,120,85,459,453},
            {0x137,0x158e,120,85,459,453},
            {0x138,0x1594,121,85,458,453},
            {0x138,0x1595,119,33,454,453},
            {0x138,0x1596,110,31,453,453},
            {0x138,0x1597,95,31,456,452},
            {0x138,0x1598,95,30,455,453},
            {0x138,0x1599,96,30,453,453},
            {0x138,0x159a,97,30,452,453},
            {0x138,0x159b,95,30,452,453},
            {0x138,0x159c,95,30,452,453},
            {0x138,0x159d,94,29,452,454},
            {0x139,0x158f,120,85,459,453},
            {0x139,0x1590,120,86,459,452},
            {0x139,0x1591,120,86,459,452},
            {0x139,0x1592,120,86,459,452},
            {0x139,0x1593,120,85,459,453},
            {0x139,0x1594,121,85,458,453},
            {0x139,0x1595,119,33,454,453},
            {0x139,0x1596,110,31,453,453},
            {0x139,0x1597,95,31,456,452},
            {0x139,0x1598,95,30,455,453},
            {0x139,0x1599,96,30,453,453},
            {0x139,0x159a,97,30,452,453},
            {0x139,0x159b,95,30,452,453},
            {0x139,0x159c,95,30,452,453},
            {0x139,0x159d,94,29,452,454},
            {0x14a,0x160b,136,84,664,474},
            {0x14a,0x160c,162,84,337,474},
            {0x14a,0x160d,141,68,345,467},
            {0x14a,0x160e,131,93,348,462},
            {0x14a,0x160f,115,94,353,457},
            {0x14a,0x1610,121,42,349,453},
            {0x14b,0x962,121,42,349,453},
            {0x14b,0x963,121,42,349,453},
            {0x14b,0x964,121,42,349,453},
            {0x14b,0x965,121,42,349,453},
            {0x14b,0x966,121,42,349,453},
            {0x14b,0x967,121,42,349,453},
            {0x14b,0x968,121,42,349,453},
            {0x14c,0x1616,121,42,350,453},
            {0x14c,0x1617,115,33,352,453},
            {0x14c,0x1618,109,31,355,453},
            {0x14c,0x1619,93,31,362,452},
            {0x14c,0x161a,94,30,361,453},
            {0x14c,0x161b,94,30,361,453},
            {0x14c,0x161c,94,30,361,453},
            {0x14c,0x161d,95,30,361,453},
            {0x14c,0x161e,95,28,361,455},
            {0x14c,0x161f,95,28,361,455},
            {0x14d,0x1611,121,42,350,453},
            {0x14d,0x1612,121,43,350,452},
            {0x14d,0x1613,122,43,349,452},
            {0x14d,0x1614,121,43,350,452},
            {0x14d,0x1615,120,42,350,453},
            {0x14d,0x1616,121,42,350,453},
            {0x14d,0x1617,115,33,352,453},
            {0x14d,0x1618,109,31,355,453},
            {0x14d,0x1619,93,31,362,452},
            {0x14d,0x161a,94,30,361,453},
            {0x14d,0x161b,94,30,361,453},
            {0x14d,0x161c,94,30,361,453},
            {0x14d,0x161d,95,30,361,453},
            {0x14d,0x161e,95,28,361,455},
            {0x14d,0x161f,95,28,361,455},
        }};
        bool nativeActionShape(data::DataId root,const data::BitmapRuntimeAsset& asset)
        {
            if(data::dataGroup(root)!=data::legacyGroupValue(data::LegacyGroupId::LanguageGraphics) ||
                data::dataGroup(asset.dataId)!=data::legacyGroupValue(data::LegacyGroupId::LanguageGraphics) ||
                asset.sourceType!=data::LegacyDataType::Uap || !asset.source) return false;
            const auto key=std::pair{data::dataTag(root),data::dataTag(asset.dataId)};
            const auto found=std::lower_bound(NativeActionShapes.begin(),NativeActionShapes.end(),key,
                [](const auto& shape,const auto& wanted){return std::pair{shape.root,shape.leaf}<wanted;});
            if(found==NativeActionShapes.end() || std::pair{found->root,found->leaf}!=key ||
                asset.image.width!=found->width || asset.image.height!=found->height) return false;
            const auto metadata=data::inspectLegacyUap(*asset.source);
            return metadata && metadata->width==found->width && metadata->height==found->height &&
                metadata->originX==found->x && metadata->originY==found->y;
        }
        std::optional<layout::ActionButtonSlot> buttonSlot(unsigned index)
        {
            using S = layout::ActionButtonSlot;
            // Same semantic roles as IBar::dispatchDirectRuleAction/handleLocalRuleAction.
            switch (index)
            {
            case 0: case 6: case 11: case 12: case 23: return S::General3;
            case 1: case 3: case 5: case 8: case 10: case 17: case 21: case 24: case 25: return S::Main;
            case 2: return S::Camera;
            case 4: case 9: case 15: case 16: return S::General2;
            case 7: return S::General1;
            case 13: case 18: return S::Status;
            case 14: return S::Options;
            case 19: return S::Trade;
            case 20: return S::General4;
            default: return {}; // Presentation-only/unknown roles retain retail pixels.
            }
        }
        std::optional<unsigned> scoreColour(data::DataId root)
        {
            if (data::dataGroup(root) != data::legacyGroupValue(data::LegacyGroupId::Main)) return {};
            const auto tag = data::dataTag(root);
            if (tag >= 0x01CB && tag <= 0x01D6) return unsigned(tag - 0x01CB) % 6;
            return {};
        }
        // Same six identities as the existing BoardLightingController palette.
        constexpr std::array<std::array<int, 3>, 6> PlayerColours{{
            {255, 0, 0}, {0, 0, 255}, {60, 150, 60},
            {255, 255, 0}, {255, 0, 255}, {255, 128, 0}}};
        struct Property { unsigned index{}, style{}; bool miniature{}; };
        std::optional<Property> property(data::DataId root)
        {
            if (data::dataGroup(root) == data::legacyGroupValue(data::LegacyGroupId::Patterns))
            {
                const auto tag=data::dataTag(root);
                if(tag>=0x05E6 && tag<=0x0601) return Property{unsigned(tag-0x05E6),0,true};
                if(tag>=0x05CA && tag<=0x05E5) return Property{unsigned(tag-0x05CA),2,true};
                return {};
            }
            if (data::dataGroup(root) != data::legacyGroupValue(data::LegacyGroupId::Main)) return {};
            const auto tag = data::dataTag(root);
            if (tag < 0x0163 || tag > 0x01B6) return {};
            return Property{unsigned(tag - 0x0163) % 28, unsigned(tag - 0x0163) / 28};
        }
        // Authored display-language group colours from EuropeanDeed::propertyColor.
        constexpr std::array<std::array<int,3>,10> OrdinaryGroups{{
            {134,103,86}, {35,158,206}, {221,3,109}, {253,128,61},
            {223,0,0}, {255,255,0}, {37,154,57}, {45,65,144},
            {188,157,94}, {22,69,70}}};
        constexpr std::array<std::array<int,3>,10> FrenchGroups{{
            {217,91,187}, {35,158,206}, {134,0,157}, {237,181,0},
            {223,0,0}, {255,255,0}, {0,128,52}, {45,65,144},
            {188,157,94}, {22,69,70}}};
        bool valid(const data::LegacyBitmapRGBA8& image)
        { return image.width && image.height && image.pixels.size() == std::size_t(image.width) * image.height * 4; }
        void caption(data::LegacyBitmapRGBA8& destination, const data::LegacyBitmapRGBA8& source,
            unsigned top, unsigned height, unsigned ink)
        {
            const float scale = std::min({1.0F, float(destination.width - 12) / source.width,
                float(height) / source.height});
            const unsigned w = std::max(1U, unsigned(source.width * scale));
            const unsigned h = std::max(1U, unsigned(source.height * scale));
            const unsigned ox = (destination.width - w) / 2;
            for (unsigned y = 0; y < h; ++y)
                for (unsigned x = 0; x < w; ++x)
                {
                    const auto src = (std::size_t(y * source.height / h) * source.width + x * source.width / w) * 4;
                    const auto dst = (std::size_t(y + top) * destination.width + x + ox) * 4;
                    const unsigned alpha = source.pixels[src + 3];
                    for (unsigned c = 0; c < 3; ++c)
                        destination.pixels[dst+c] = std::uint8_t((ink * alpha + destination.pixels[dst+c] * (255-alpha) + 127) / 255);
                }
        }
        std::optional<unsigned> currentPlayerToken(data::DataId root)
        {
            if (data::dataGroup(root)==data::legacyGroupValue(data::LegacyGroupId::Main) &&
                data::dataTag(root)>=0x005F && data::dataTag(root)<=0x0069)
                return unsigned(data::dataTag(root)-0x005F);
            return {};
        }
        struct CurrentPlayerShape { std::uint16_t root,leaf,width,height; std::int16_t x,y; };
        // Actual dat_main CNK_indstra..k: one bitmap per authored phase.
        // Position includes UDIBar StartXY(0,-4); preview255 is deliberately static.
        // Decoded eleven CNK payloads SHA256: defa68bcc66567106d6ebf675a54f42e808a1df17f2d6eb2aec9128888cc102a.
        constexpr std::array<CurrentPlayerShape,328> CurrentPlayerShapes{{
            {0x5f,0x01d7,43,23,351,501},
            {0x5f,0x01d8,43,23,350,502},
            {0x5f,0x01d9,42,23,350,502},
            {0x5f,0x01da,39,25,351,501},
            {0x5f,0x01db,34,25,353,501},
            {0x5f,0x01dc,28,25,356,501},
            {0x5f,0x01dd,23,24,359,501},
            {0x5f,0x01de,17,24,363,501},
            {0x5f,0x01df,18,24,364,501},
            {0x5f,0x01e0,24,24,362,501},
            {0x5f,0x01e1,30,24,359,501},
            {0x5f,0x01e2,36,24,356,501},
            {0x5f,0x01e3,40,24,354,501},
            {0x5f,0x01e4,43,24,352,501},
            {0x5f,0x01e5,44,22,351,502},
            {0x5f,0x01e6,43,24,351,500},
            {0x5f,0x01e7,43,26,352,499},
            {0x5f,0x01e8,42,30,353,497},
            {0x5f,0x01e9,39,33,355,495},
            {0x5f,0x01ea,35,36,358,494},
            {0x5f,0x01eb,28,37,362,493},
            {0x5f,0x01ec,23,38,364,493},
            {0x5f,0x01ed,18,38,365,492},
            {0x5f,0x01ee,19,38,363,492},
            {0x5f,0x01ef,24,38,359,493},
            {0x5f,0x01f0,30,37,356,494},
            {0x5f,0x01f1,36,35,353,495},
            {0x5f,0x01f2,39,33,352,496},
            {0x5f,0x01f3,42,30,351,498},
            {0x5f,0x01f4,43,27,351,499},
            {0x60,0x01f5,39,17,350,506},
            {0x60,0x01f6,39,18,350,506},
            {0x60,0x01f7,39,19,350,506},
            {0x60,0x01f8,38,21,350,505},
            {0x60,0x01f9,34,23,352,504},
            {0x60,0x01fa,30,23,354,504},
            {0x60,0x01fb,24,24,357,503},
            {0x60,0x01fc,17,23,361,503},
            {0x60,0x01fd,19,23,359,503},
            {0x60,0x01fe,25,23,356,503},
            {0x60,0x01ff,31,23,353,503},
            {0x60,0x0200,34,22,352,504},
            {0x60,0x0201,38,21,350,504},
            {0x60,0x0202,39,19,350,505},
            {0x60,0x0203,39,18,350,505},
            {0x60,0x0204,38,17,351,505},
            {0x60,0x0205,40,19,350,504},
            {0x60,0x0206,39,21,351,503},
            {0x60,0x0207,37,22,352,503},
            {0x60,0x0208,34,24,354,502},
            {0x60,0x0209,29,26,356,501},
            {0x60,0x020a,24,26,359,501},
            {0x60,0x020b,17,26,362,501},
            {0x60,0x020c,20,26,361,501},
            {0x60,0x020d,26,26,358,501},
            {0x60,0x020e,31,25,355,502},
            {0x60,0x020f,35,24,353,503},
            {0x60,0x0210,38,23,351,503},
            {0x60,0x0211,40,21,350,504},
            {0x60,0x0212,40,19,350,505},
            {0x61,0x0302,40,29,352,497},
            {0x61,0x0303,40,30,352,496},
            {0x61,0x0304,38,32,352,495},
            {0x61,0x0305,34,35,354,494},
            {0x61,0x0306,31,36,355,494},
            {0x61,0x0307,25,37,357,493},
            {0x61,0x0308,20,37,359,493},
            {0x61,0x0309,15,37,360,493},
            {0x61,0x030a,17,38,358,492},
            {0x61,0x030b,22,37,355,492},
            {0x61,0x030c,27,38,352,491},
            {0x61,0x030d,31,36,350,491},
            {0x61,0x030e,35,34,349,492},
            {0x61,0x030f,38,33,348,492},
            {0x61,0x0310,39,30,349,493},
            {0x61,0x0311,39,29,350,494},
            {0x61,0x0312,39,29,350,495},
            {0x61,0x0313,37,28,352,496},
            {0x61,0x0314,34,30,354,495},
            {0x61,0x0315,30,32,356,494},
            {0x61,0x0316,24,32,360,494},
            {0x61,0x0317,19,34,363,493},
            {0x61,0x0318,15,34,366,493},
            {0x61,0x0319,16,33,367,494},
            {0x61,0x031a,21,33,365,494},
            {0x61,0x031b,27,33,362,495},
            {0x61,0x031c,31,32,360,496},
            {0x61,0x031d,36,31,357,497},
            {0x61,0x031e,38,28,355,499},
            {0x61,0x031f,40,29,353,498},
            {0x62,0x0213,34,19,350,505},
            {0x62,0x0214,33,20,350,505},
            {0x62,0x0215,33,21,350,505},
            {0x62,0x0216,31,22,351,505},
            {0x62,0x0217,30,22,351,505},
            {0x62,0x0218,28,23,352,505},
            {0x62,0x0219,28,24,352,504},
            {0x62,0x021a,28,24,352,504},
            {0x62,0x021b,28,24,352,504},
            {0x62,0x021c,28,24,352,504},
            {0x62,0x021d,29,24,351,504},
            {0x62,0x021e,30,23,351,504},
            {0x62,0x021f,32,22,350,504},
            {0x62,0x0220,33,20,350,505},
            {0x62,0x0221,33,19,350,505},
            {0x62,0x0222,34,18,350,505},
            {0x62,0x0223,34,19,350,505},
            {0x62,0x0224,32,21,351,504},
            {0x62,0x0225,31,22,352,504},
            {0x62,0x0226,29,23,353,504},
            {0x62,0x0227,29,24,353,504},
            {0x62,0x0228,28,24,354,504},
            {0x62,0x0229,27,24,354,504},
            {0x62,0x022a,28,24,354,504},
            {0x62,0x022b,28,24,354,504},
            {0x62,0x022c,29,24,353,504},
            {0x62,0x022d,31,22,352,505},
            {0x62,0x022e,31,22,352,505},
            {0x62,0x022f,32,21,351,505},
            {0x62,0x0230,34,20,350,505},
            {0x63,0x0231,37,22,349,501},
            {0x63,0x0232,37,24,349,500},
            {0x63,0x0233,38,25,349,500},
            {0x63,0x0234,36,26,350,499},
            {0x63,0x0235,33,27,352,499},
            {0x63,0x0236,30,28,354,498},
            {0x63,0x0237,26,28,355,498},
            {0x63,0x0238,24,28,355,497},
            {0x63,0x0239,24,28,352,497},
            {0x63,0x023a,25,28,350,497},
            {0x63,0x023b,28,28,348,497},
            {0x63,0x023c,32,27,347,497},
            {0x63,0x023d,34,26,347,498},
            {0x63,0x023e,37,25,347,498},
            {0x63,0x023f,36,23,349,499},
            {0x63,0x0240,38,22,349,499},
            {0x63,0x0241,38,22,349,498},
            {0x63,0x0242,38,22,349,498},
            {0x63,0x0243,35,24,350,497},
            {0x63,0x0244,33,25,351,497},
            {0x63,0x0245,30,27,352,496},
            {0x63,0x0246,26,28,354,496},
            {0x63,0x0247,24,29,357,496},
            {0x63,0x0248,23,29,360,496},
            {0x63,0x0249,24,28,361,497},
            {0x63,0x024a,28,28,359,497},
            {0x63,0x024b,32,26,356,498},
            {0x63,0x024c,35,24,354,499},
            {0x63,0x024d,36,23,352,499},
            {0x63,0x024e,37,22,350,500},
            {0x64,0x0250,36,44,349,483},
            {0x64,0x0251,34,44,350,483},
            {0x64,0x0252,32,44,351,483},
            {0x64,0x0253,29,44,352,483},
            {0x64,0x0254,26,45,353,483},
            {0x64,0x0255,22,45,353,483},
            {0x64,0x0256,21,45,353,482},
            {0x64,0x0257,21,45,353,482},
            {0x64,0x0258,23,45,351,482},
            {0x64,0x0259,26,44,349,482},
            {0x64,0x025a,29,44,347,482},
            {0x64,0x025b,32,44,346,481},
            {0x64,0x025c,35,44,345,481},
            {0x64,0x025d,35,44,346,481},
            {0x64,0x025e,36,45,346,480},
            {0x64,0x025f,36,46,346,479},
            {0x64,0x0260,35,47,347,478},
            {0x64,0x0261,32,49,349,477},
            {0x64,0x0262,29,50,351,476},
            {0x64,0x0263,26,50,353,476},
            {0x64,0x0264,23,52,356,475},
            {0x64,0x0265,21,52,358,475},
            {0x64,0x0266,21,52,358,475},
            {0x64,0x0267,22,52,358,476},
            {0x64,0x0268,25,51,357,477},
            {0x64,0x0269,28,50,356,478},
            {0x64,0x026a,32,48,353,479},
            {0x64,0x026b,34,46,352,481},
            {0x64,0x026c,36,46,350,481},
            {0x65,0x026d,49,27,347,497},
            {0x65,0x026e,47,27,348,497},
            {0x65,0x026f,45,28,349,498},
            {0x65,0x0270,39,30,352,498},
            {0x65,0x0271,32,31,355,498},
            {0x65,0x0272,25,33,358,498},
            {0x65,0x0273,17,33,362,498},
            {0x65,0x0274,13,34,364,498},
            {0x65,0x0275,13,34,364,498},
            {0x65,0x0276,19,34,361,497},
            {0x65,0x0277,26,33,357,497},
            {0x65,0x0278,34,31,353,497},
            {0x65,0x0279,40,30,351,497},
            {0x65,0x027a,46,29,348,496},
            {0x65,0x027b,48,27,347,496},
            {0x65,0x027c,48,27,348,496},
            {0x65,0x027d,47,27,349,496},
            {0x65,0x027e,44,30,351,495},
            {0x65,0x027f,38,32,354,495},
            {0x65,0x0280,32,33,357,495},
            {0x65,0x0281,25,35,361,495},
            {0x65,0x0282,17,36,365,495},
            {0x65,0x0283,13,37,367,495},
            {0x65,0x0284,14,37,366,495},
            {0x65,0x0285,18,36,364,496},
            {0x65,0x0286,26,35,360,496},
            {0x65,0x0287,34,33,356,496},
            {0x65,0x0288,41,32,352,496},
            {0x65,0x0289,45,29,350,497},
            {0x65,0x028a,48,28,348,497},
            {0x66,0x028b,41,25,351,499},
            {0x66,0x028c,41,24,351,501},
            {0x66,0x028d,41,23,351,503},
            {0x66,0x028e,38,23,352,504},
            {0x66,0x028f,34,23,354,504},
            {0x66,0x0290,29,24,356,504},
            {0x66,0x0291,22,23,359,505},
            {0x66,0x0292,16,23,361,505},
            {0x66,0x0293,13,23,363,505},
            {0x66,0x0294,17,22,361,505},
            {0x66,0x0295,22,22,359,505},
            {0x66,0x0296,26,22,358,504},
            {0x66,0x0297,32,21,355,504},
            {0x66,0x0298,36,20,353,504},
            {0x66,0x0299,40,21,351,502},
            {0x66,0x029a,41,23,351,500},
            {0x66,0x029b,42,24,351,499},
            {0x66,0x029c,41,28,352,497},
            {0x66,0x029d,39,31,353,495},
            {0x66,0x029e,34,33,356,494},
            {0x66,0x029f,29,35,359,493},
            {0x66,0x02a0,23,37,362,492},
            {0x66,0x02a1,17,38,366,492},
            {0x66,0x02a2,13,38,368,492},
            {0x66,0x02a3,16,38,366,492},
            {0x66,0x02a4,21,38,363,492},
            {0x66,0x02a5,26,36,360,493},
            {0x66,0x02a6,31,34,357,494},
            {0x66,0x02a7,36,31,354,496},
            {0x66,0x02a8,39,28,352,497},
            {0x67,0x02a9,28,31,359,496},
            {0x67,0x02aa,26,31,360,496},
            {0x67,0x02ab,26,30,360,496},
            {0x67,0x02ac,26,30,360,496},
            {0x67,0x02ad,24,30,361,496},
            {0x67,0x02ae,24,29,361,496},
            {0x67,0x02af,23,28,361,496},
            {0x67,0x02b0,23,27,360,496},
            {0x67,0x02b1,23,27,359,496},
            {0x67,0x02b2,22,28,358,496},
            {0x67,0x02b3,23,29,357,496},
            {0x67,0x02b4,25,30,356,496},
            {0x67,0x02b5,25,30,356,496},
            {0x67,0x02b6,27,30,355,496},
            {0x67,0x02b7,27,31,355,496},
            {0x67,0x02b8,27,31,355,496},
            {0x67,0x02b9,27,31,355,496},
            {0x67,0x02ba,26,31,355,496},
            {0x67,0x02bb,25,30,356,497},
            {0x67,0x02bc,25,30,356,497},
            {0x67,0x02bd,23,29,357,497},
            {0x67,0x02be,23,29,358,497},
            {0x67,0x02bf,23,29,359,497},
            {0x67,0x02c0,23,29,360,497},
            {0x67,0x02c1,23,29,361,497},
            {0x67,0x02c2,24,29,361,497},
            {0x67,0x02c3,25,30,360,497},
            {0x67,0x02c4,26,30,360,497},
            {0x67,0x02c5,26,31,360,496},
            {0x67,0x02c6,27,31,359,496},
            {0x68,0x02c7,49,20,345,500},
            {0x68,0x02c8,50,23,343,499},
            {0x68,0x02c9,48,25,343,499},
            {0x68,0x02ca,44,27,344,498},
            {0x68,0x02cb,38,28,346,498},
            {0x68,0x02cc,31,30,349,497},
            {0x68,0x02cd,25,31,352,497},
            {0x68,0x02ce,17,31,357,497},
            {0x68,0x02cf,19,31,359,497},
            {0x68,0x02d0,26,30,357,497},
            {0x68,0x02d1,33,30,354,496},
            {0x68,0x02d2,40,29,350,496},
            {0x68,0x02d3,45,27,348,496},
            {0x68,0x02d4,48,24,346,497},
            {0x68,0x02d5,50,23,345,497},
            {0x68,0x02d6,48,21,346,497},
            {0x68,0x02d7,49,19,347,498},
            {0x68,0x02d8,47,21,349,497},
            {0x68,0x02d9,44,22,352,497},
            {0x68,0x02da,38,23,356,497},
            {0x68,0x02db,31,25,360,496},
            {0x68,0x02dc,25,25,363,496},
            {0x68,0x02dd,18,25,365,496},
            {0x68,0x02de,20,26,361,496},
            {0x68,0x02df,26,25,356,497},
            {0x68,0x02e0,33,25,352,497},
            {0x68,0x02e1,40,23,349,498},
            {0x68,0x02e2,45,22,346,499},
            {0x68,0x02e3,48,21,345,499},
            {0x68,0x02e4,49,19,345,500},
            {0x69,0x02e5,39,45,356,484},
            {0x69,0x02e6,39,45,356,484},
            {0x69,0x02e7,39,45,356,484},
            {0x69,0x02e8,39,44,356,484},
            {0x69,0x02e9,41,44,355,484},
            {0x69,0x02ea,41,44,355,484},
            {0x69,0x02eb,41,44,355,484},
            {0x69,0x02ec,41,45,355,483},
            {0x69,0x02ed,43,46,354,483},
            {0x69,0x02ee,42,46,355,483},
            {0x69,0x02ef,39,46,357,483},
            {0x69,0x02f0,40,46,356,483},
            {0x69,0x02f1,40,46,356,483},
            {0x69,0x02f2,40,46,356,483},
            {0x69,0x02f3,39,46,356,483},
            {0x69,0x02f4,39,46,356,483},
            {0x69,0x02f5,39,46,356,483},
            {0x69,0x02f6,39,46,356,483},
            {0x69,0x02f7,40,46,356,483},
            {0x69,0x02f8,40,45,356,484},
            {0x69,0x02f9,41,45,355,484},
            {0x69,0x02fa,42,45,355,484},
            {0x69,0x02fb,41,45,355,484},
            {0x69,0x02fc,43,45,354,484},
            {0x69,0x02fd,43,44,354,484},
            {0x69,0x02fe,39,44,356,484},
            {0x69,0x02ff,39,45,356,484},
            {0x69,0x0300,39,45,356,484},
            {0x69,0x0301,39,45,356,484},
        }};
        // Fixed static-thumbnail envelope, derived from every authentic phase.
        // World Y already includes root StartXY(0,-4). Roll ends at483 and
        // name starts at530: keep the rectangle within484..529 and retain
        // one logical pixel of transparent edge padding.
        constexpr auto CurrentPlayerWorldRects=[]
        {
            std::array<std::array<int,4>,11> boxes{};
            for(auto& box:boxes) box={1600,600,0,0};
            for(const auto& shape:CurrentPlayerShapes)
            {
                auto& box=boxes[shape.root-0x005F];
                box[0]=std::min(box[0],int(shape.x));
                box[1]=std::min(box[1],int(shape.y));
                box[2]=std::max(box[2],int(shape.x)+shape.width);
                box[3]=std::max(box[3],int(shape.y)+shape.height);
            }
            for(auto& box:boxes)
            {
                box[1]=std::max(box[1],484);
                box[3]=std::min(box[3],529);
            }
            return boxes;
        }();
        constexpr std::array<std::uint16_t,11> AuctionTokenRoots{4,5,6,10,8,7,3,12,9,13,11};
        std::optional<unsigned> auctionToken(data::DataId root)
        {
            if(data::dataGroup(root)!=data::legacyGroupValue(data::LegacyGroupId::Patterns))return {};
            const auto found=std::find(AuctionTokenRoots.begin(),AuctionTokenRoots.end(),data::dataTag(root));
            return found==AuctionTokenRoots.end() ? std::optional<unsigned>{} :
                std::optional{unsigned(found-AuctionTokenRoots.begin())};
        }
        struct AuctionTokenShape { std::uint16_t root,leaf,width,height; std::int16_t x,y; };
        // Actual dat_pat aa00n..aa10n bitmap descriptions, including repeated
        // UAPs at different positions. Static thumbnail255 has no spin mapping.
        // Eleven decoded CNKs SHA256: 8b329f40d2531137c74257f9c6ab0040773d3478260dab709bfc684444e6b2c3.
        constexpr std::array<AuctionTokenShape,196> AuctionTokenShapes{{
            {0x04,0x0b0,42,22,-19,-19},
            {0x04,0x0b5,42,21,-19,-21},
            {0x04,0x0b6,43,20,-20,-22},
            {0x04,0x0b7,44,21,-21,-22},
            {0x04,0x0b8,46,20,-22,-22},
            {0x04,0x0ba,49,18,-24,-18},
            {0x04,0x0bb,55,16,-29,-12},
            {0x04,0x0bc,53,17,-28,-13},
            {0x04,0x0bd,30,30,-10,-28},
            {0x04,0x0be,20,35,-3,-35},
            {0x04,0x0bf,21,33,-4,-36},
            {0x04,0x0c0,26,31,-6,-35},
            {0x04,0x0c1,27,30,-8,-32},
            {0x04,0x0c2,32,28,-11,-30},
            {0x04,0x0c3,36,24,-15,-26},
            {0x04,0x0c4,42,22,-19,-19},
            {0x04,0x0c5,45,20,-21,-16},
            {0x04,0x0c6,47,19,-23,-15},
            {0x04,0x0c7,40,22,-18,-18},
            {0x05,0x0c8,38,15,-18,-13},
            {0x05,0x0c9,41,15,-19,-13},
            {0x05,0x0ca,38,17,-15,-18},
            {0x05,0x0cb,39,17,-12,-15},
            {0x05,0x0cc,41,16,-13,-13},
            {0x05,0x0cd,42,17,-14,-13},
            {0x05,0x0ce,39,17,-13,-16},
            {0x05,0x0cf,36,17,-11,-19},
            {0x05,0x0d0,36,17,-10,-19},
            {0x05,0x0d1,38,17,-10,-17},
            {0x05,0x0d2,39,17,-9,-15},
            {0x05,0x0d3,41,17,-9,-14},
            {0x05,0x0d4,42,17,-10,-14},
            {0x05,0x0d5,38,17,-10,-18},
            {0x05,0x0d6,35,18,-12,-21},
            {0x05,0x0d7,34,18,-18,-17},
            {0x05,0x0d8,41,15,-19,-13},
            {0x05,0x0d9,38,15,-18,-13},
            {0x06,0x0da,29,21,-13,-18},
            {0x06,0x0db,26,24,-13,-21},
            {0x06,0x0dc,26,24,-13,-21},
            {0x06,0x0dd,26,23,-13,-20},
            {0x06,0x0de,29,20,-13,-17},
            {0x06,0x0df,33,24,-13,-21},
            {0x06,0x0e0,32,23,-13,-20},
            {0x06,0x0e1,33,24,-13,-21},
            {0x06,0x0e2,32,23,-13,-20},
            {0x06,0x0e3,31,21,-13,-18},
            {0x06,0x0e4,30,21,-13,-18},
            {0x06,0x0e5,33,24,-13,-21},
            {0x06,0x0e6,30,22,-13,-19},
            {0x06,0x0e7,27,20,-13,-17},
            {0x06,0x0e8,29,21,-13,-18},
            {0x0a,0x12c,31,13,-15,-11},
            {0x0a,0x12d,35,11,-17,-8},
            {0x0a,0x12e,36,11,-18,-7},
            {0x0a,0x12f,29,15,-14,-19},
            {0x0a,0x130,20,18,-9,-33},
            {0x0a,0x131,16,19,-7,-40},
            {0x0a,0x132,18,18,-8,-44},
            {0x0a,0x133,21,16,-10,-45},
            {0x0a,0x134,28,15,-13,-44},
            {0x0a,0x135,28,12,-13,-40},
            {0x0a,0x136,29,12,-13,-36},
            {0x0a,0x137,28,14,-12,-29},
            {0x0a,0x138,20,17,-9,-21},
            {0x0a,0x139,19,17,-8,-15},
            {0x0a,0x13a,29,13,-13,-12},
            {0x0a,0x13b,36,11,-18,-8},
            {0x0a,0x13c,31,13,-15,-11},
            {0x08,0x0fa,28,14,-13,-11},
            {0x08,0x0fb,32,13,-15,-10},
            {0x08,0x0fc,35,11,-17,-9},
            {0x08,0x0fd,34,11,-16,-9},
            {0x08,0x0fe,30,13,-14,-10},
            {0x08,0x0ff,28,14,-13,-11},
            {0x08,0x100,28,14,-13,-11},
            {0x08,0x101,30,13,-14,-10},
            {0x08,0x102,40,10,-19,-8},
            {0x08,0x103,34,12,-16,-10},
            {0x08,0x104,30,13,-14,-16},
            {0x08,0x105,30,13,-14,-23},
            {0x08,0x106,30,13,-14,-28},
            {0x08,0x106,30,13,-14,-29},
            {0x08,0x106,30,13,-14,-28},
            {0x08,0x107,30,13,-14,-25},
            {0x08,0x108,32,13,-15,-17},
            {0x08,0x109,30,14,-14,-12},
            {0x08,0x10a,36,11,-17,-9},
            {0x08,0x10b,28,14,-13,-11},
            {0x07,0x0e9,20,24,-9,-23},
            {0x07,0x0ea,20,24,-9,-23},
            {0x07,0x0eb,24,21,-11,-19},
            {0x07,0x0ec,17,27,-7,-25},
            {0x07,0x0ed,16,29,-7,-28},
            {0x07,0x0ee,18,25,-8,-28},
            {0x07,0x0ef,23,22,-11,-28},
            {0x07,0x0f0,24,20,-11,-29},
            {0x07,0x0f1,22,22,-10,-33},
            {0x07,0x0f2,20,25,-9,-36},
            {0x07,0x0f3,18,26,-8,-35},
            {0x07,0x0f4,18,27,-8,-32},
            {0x07,0x0f5,18,27,-8,-28},
            {0x07,0x0f6,20,24,-9,-23},
            {0x07,0x0f7,24,20,-11,-18},
            {0x07,0x0f8,20,24,-9,-23},
            {0x07,0x0f9,20,24,-9,-23},
            {0x03,0x0a0,34,19,-16,-18},
            {0x03,0x0a1,37,17,-17,-17},
            {0x03,0x0a2,30,22,-14,-21},
            {0x03,0x0a3,24,28,-11,-26},
            {0x03,0x0a4,23,30,-10,-29},
            {0x03,0x0a5,44,15,-21,-15},
            {0x03,0x0a6,34,19,-16,-20},
            {0x03,0x0a7,23,29,-10,-29},
            {0x03,0x0a8,24,32,-10,-32},
            {0x03,0x0a9,24,33,-10,-37},
            {0x03,0x0a9,24,33,-10,-38},
            {0x03,0x0aa,26,29,-11,-31},
            {0x03,0x0ab,30,22,-14,-26},
            {0x03,0x0ac,34,19,-16,-21},
            {0x03,0x0ad,34,19,-16,-21},
            {0x03,0x0ae,34,19,-16,-21},
            {0x0c,0x14c,27,16,-13,-15},
            {0x0c,0x14d,21,20,-7,-18},
            {0x0c,0x14e,18,22,-4,-19},
            {0x0c,0x14f,20,24,-6,-23},
            {0x0c,0x150,21,26,-7,-29},
            {0x0c,0x151,22,20,-11,-40},
            {0x0c,0x152,23,17,-12,-38},
            {0x0c,0x153,25,16,-14,-37},
            {0x0c,0x154,27,16,-15,-36},
            {0x0c,0x157,21,17,-12,-33},
            {0x0c,0x158,22,19,-14,-20},
            {0x0c,0x159,24,20,-13,-20},
            {0x0c,0x15a,29,11,-16,-9},
            {0x0c,0x15b,24,14,-11,-13},
            {0x0c,0x15c,26,15,-12,-14},
            {0x09,0x113,17,19,-8,-18},
            {0x09,0x114,16,20,-7,-20},
            {0x09,0x115,16,22,-7,-22},
            {0x09,0x116,17,22,-8,-23},
            {0x09,0x117,18,23,-9,-25},
            {0x09,0x118,16,22,-7,-24},
            {0x09,0x119,15,23,-7,-24},
            {0x09,0x11a,17,22,-8,-22},
            {0x09,0x11b,21,22,-9,-21},
            {0x09,0x11c,21,22,-9,-21},
            {0x09,0x11d,22,23,-10,-21},
            {0x09,0x11e,19,23,-10,-21},
            {0x09,0x11f,17,22,-10,-20},
            {0x09,0x120,16,22,-10,-20},
            {0x09,0x121,16,22,-10,-19},
            {0x09,0x122,20,22,-14,-19},
            {0x09,0x123,21,22,-15,-20},
            {0x09,0x124,21,22,-14,-20},
            {0x09,0x125,20,22,-13,-20},
            {0x09,0x126,17,22,-10,-19},
            {0x09,0x127,17,22,-9,-20},
            {0x09,0x128,17,21,-8,-19},
            {0x09,0x129,17,19,-8,-18},
            {0x09,0x12a,17,19,-8,-18},
            {0x09,0x12b,17,19,-8,-18},
            {0x0d,0x15d,41,15,-24,-12},
            {0x0d,0x15e,58,11,-32,-9},
            {0x0d,0x15f,43,41,-19,-36},
            {0x0d,0x160,19,55,4,-51},
            {0x0d,0x161,20,57,4,-53},
            {0x0d,0x162,14,57,10,-53},
            {0x0d,0x163,15,57,9,-53},
            {0x0d,0x164,15,57,8,-53},
            {0x0d,0x165,20,57,3,-53},
            {0x0d,0x166,21,56,2,-52},
            {0x0d,0x167,21,56,3,-52},
            {0x0d,0x168,20,56,4,-52},
            {0x0d,0x169,19,56,4,-51},
            {0x0d,0x160,19,55,4,-51},
            {0x0d,0x15f,43,41,-19,-36},
            {0x0d,0x15e,58,11,-32,-9},
            {0x0d,0x15d,41,15,-24,-12},
            {0x0b,0x13d,20,19,-9,-17},
            {0x0b,0x13e,28,14,-13,-11},
            {0x0b,0x13f,16,25,-7,-23},
            {0x0b,0x140,18,21,-8,-28},
            {0x0b,0x141,20,17,-9,-31},
            {0x0b,0x13f,16,25,-7,-32},
            {0x0b,0x143,18,18,-8,-33},
            {0x0b,0x144,19,17,-8,-34},
            {0x0b,0x144,19,17,-8,-35},
            {0x0b,0x144,19,17,-8,-36},
            {0x0b,0x145,18,20,-8,-36},
            {0x0b,0x146,18,22,-8,-35},
            {0x0b,0x147,17,25,-7,-34},
            {0x0b,0x148,28,14,-12,-12},
            {0x0b,0x149,19,21,-8,-18},
            {0x0b,0x14a,20,19,-9,-17},
            {0x0b,0x14b,20,19,-9,-17},
        }};
        std::optional<unsigned> scoreToken(data::DataId root)
        {
            if (data::dataGroup(root) == data::legacyGroupValue(data::LegacyGroupId::Main) &&
                data::dataTag(root) >= 0x01C0 && data::dataTag(root) <= 0x01CA)
                return unsigned(data::dataTag(root) - 0x01C0);
            return {};
        }
        constexpr std::array<std::array<unsigned,2>,11> ScoreTokenSizes{{
            {53,29},{52,22},{39,29},{39,26},{39,26},{22,29},
            {54,32},{47,28},{22,29},{49,20},{24,31}}};
        std::optional<std::array<unsigned,4>> deedArtworkRect(data::DataId root,
            ModernIBarSkin::DeedArtwork kind)
        {
            if(data::dataGroup(root)!=data::legacyGroupValue(data::LegacyGroupId::LanguageGraphics)) return {};
            const auto tag=data::dataTag(root);
            if(kind==ModernIBarSkin::DeedArtwork::Railroad &&
                (tag==0x0CD2 || tag==0x0CDA || tag==0x0CE1 || tag==0x0CE9)) return std::array<unsigned,4>{68,18,125,61};
            if(kind==ModernIBarSkin::DeedArtwork::Electric && tag==0x0CD7) return std::array<unsigned,4>{74,16,114,63};
            if(kind==ModernIBarSkin::DeedArtwork::Water && tag==0x0CE4) return std::array<unsigned,4>{73,18,127,63};
            return {};
        }
        constexpr std::array<unsigned,16> ChanceFaceBackgrounds{
            0x814,0x815,0x816,0x849,0x819,0x81B,0x81C,0x81D,
            0x81E,0x81F,0x820,0x821,0x812,0x823,0x824,0x813};
        constexpr std::array<unsigned,16> ChestFaceBackgrounds{
            0x8CB,0x8CC,0x8CD,0x8CE,0x8C8,0x8C9,0x8D1,0x8D2,
            0x8D3,0x8D4,0x8D5,0x8D6,0x8CA,0x8D8,0x86C,0x8DA};
        struct NativeIdleCardSource { data::DataId leaf; unsigned height; };
        data::DataId illustratedCardIdleOwner(data::DataId root) noexcept
        {
            //31 measured Out UAPs are byte-identical to their idle artwork.
            // Poor Tax's outgoing leaf50845 differs; keep that complete root retail.
            if((root>=0x50048 && root<=0x50057 && root!=0x50054) ||
                (root>=0x50079 && root<=0x50088)) return root-0x20;
            return root;
        }
        std::string_view readableIllustratedCardBody(data::DataId idleRoot) noexcept
        {
            // Exact baked-occlusion owners. Their measured Out faces are raw
            // byte-identical; the existing owner/leaf guards qualify each phase.
            switch(idleRoot)
            {
            case 0x5002B:return "Your building and loan matures. Collect $150.";
            case 0x5005D:return "Get out of jail, free. This card may be kept until needed or sold.";
            case 0x5005F:return "Bank error in your favour. Collect $200.";
            case 0x50060:return "Income tax refund. Collect $20.";
            case 0x50062:return "Go to jail. Go directly to jail. Do not pass GO. Do not collect $200.";
            default:return {};
            }
        }
        std::optional<NativeIdleCardSource> nativeIdleCardSource(data::DataId root)
        {
            // All32 licensed USA idle faces have a single measured UAP leaf.
            // St.Charles is239px high; do not expand its authored footprint.
            if(root>=0x00050028 && root<=0x00050037)
                return NativeIdleCardSource{0x00050982+root-0x00050028,root==0x00050029?239U:240U};
            if(root>=0x00050059 && root<=0x00050068)
                return NativeIdleCardSource{0x00050972+root-0x00050059,240U};
            if(root>=0x50048 && root<=0x50057 && root!=0x50054)
                return NativeIdleCardSource{0x50839+root-0x50048,root==0x50049?239U:240U};
            if(root>=0x50079 && root<=0x50088)
                return NativeIdleCardSource{0x508EB+root-0x50079,240U};
            return {};
        }
        std::optional<data::DataId> faceIdleRoot(data::DataId root)
        {
            if(root>=0x50018 && root<=0x50027) return root+0x10;
            if(root>=0x50008 && root<=0x50017) return root+0x51;
            return {};
        }
        bool faceBackground(data::DataId root,data::DataId leaf)
        {
            if(data::dataGroup(leaf)!=data::legacyGroupValue(data::LegacyGroupId::LanguageGraphics)) return false;
            const auto tag=data::dataTag(leaf);
            if(root>=0x50018 && root<=0x50027)
                return tag==ChanceFaceBackgrounds[root-0x50018] || (root==0x5001C && tag==0x81A);
            return root>=0x50008 && root<=0x50017 && tag==ChestFaceBackgrounds[root-0x50008];
        }
        struct FaceSprite
        {
            std::uint16_t rootTag,leafTag,width,height;
            std::int16_t x,y;
        };
        constexpr std::array<FaceSprite,1151> FaceSprites{{
#include "ModernCardFaceInSprites.inc"
        }};
        bool faceSprite(data::DataId root,const data::BitmapRuntimeAsset& asset)
        {
            if(data::dataGroup(asset.dataId)!=data::legacyGroupValue(data::LegacyGroupId::LanguageGraphics) || !asset.source) return false;
            const auto key=std::pair{data::dataTag(root),data::dataTag(asset.dataId)};
            const auto found=std::lower_bound(FaceSprites.begin(),FaceSprites.end(),key,
                [](const FaceSprite& item,const auto& wanted){return std::pair{item.rootTag,item.leafTag}<wanted;});
            if(found==FaceSprites.end() || std::pair{found->rootTag,found->leafTag}!=key ||
                asset.image.width!=found->width || asset.image.height!=found->height) return false;
            const auto metadata=data::inspectLegacyUap(*asset.source);
            return metadata && metadata->width==found->width && metadata->height==found->height &&
                metadata->originX==found->x && metadata->originY==found->y;
        }
 
        bool playerCashPlacement(const sequence::Matrix2D& world)
        {
            bool column=false;
            for(int width:{130,198})for(int index=0;index<(width==130?6:4);++index)
                for(int shown:{0,index})
                    column=column || std::abs(world.values[6]-(index*width+8+shown*3))<=.0001F;
            const std::array<float,9> expected{1,0,0,0,1,0,world.values[6],254,1};
            for(unsigned i=0;i<9;++i)
                if(!std::isfinite(world.values[i]) || std::abs(world.values[i]-expected[i])>.0001F)return false;
            return column;
        }
        bool cashCoinPlacement(const sequence::Matrix2D& world,std::uint16_t priority)
        {
            if(priority==501)return playerCashPlacement(world);
            if(priority<100 || priority>103)return false;
            // UDTrade StartXY TAB_snpscsh1: exact four owner/priority positions.
            constexpr std::array<std::array<float,2>,4> positions{{{9,395},{609,395},{209,358},{409,358}}};
            const auto& position=positions[priority-100];
            const auto expected=sequence::translate2D(position[0],position[1]);
            for(unsigned i=0;i<9;++i)
                if(!std::isfinite(world.values[i]) || std::abs(world.values[i]-expected.values[i])>.0001F)return false;
            return true;
        }
        bool originalPlayerCash(const data::BitmapRuntimeAsset& asset)
        {
            if(asset.dataId!=0x00020355 || asset.sourceType!=data::LegacyDataType::Uap || !asset.source ||
                asset.source->size()!=4404 || asset.image.width!=52 || asset.image.height!=45 ||
                asset.image.pixels.size()!=52*45*4)return false;
            const auto header=data::inspectLegacyUap(*asset.source);
            if(!header || header->originX || header->originY || header->width!=52 || header->height!=45 ||
                header->flags!=6 || header->colourCount!=256 || header->alphaCount!=17)return false;
            // Exact retail bytes and decoded RGBA, not merely an arbitrary52x45 icon.
            // Payload SHA2566727a50b4bb0a4aca60e08539585c907311f44896765d0086d5cbed0698e3718.
            std::uint64_t source=14695981039346656037ULL,pixels=source;
            for(const auto value:*asset.source)source=(source^std::to_integer<std::uint8_t>(value))*1099511628211ULL;
            for(const auto value:asset.image.pixels)pixels=(pixels^value)*1099511628211ULL;
            return source==0x9cf37537e7999931ULL && pixels==0x7a62522977daf2e7ULL;
        }
        data::LegacyBitmapRGBA8 playerCashCoin(const data::LegacyBitmapRGBA8& native)
        {
            data::LegacyBitmapRGBA8 image{156,135,std::vector<std::uint8_t>(156*135*4)};
            const auto segment=[](float x,float y,float ax,float ay,float bx,float by)
            {
                const auto dx=bx-ax,dy=by-ay;
                const float t=std::clamp(((x-ax)*dx+(y-ay)*dy)/(dx*dx+dy*dy),0.0F,1.0F);
                return std::hypot(x-ax-t*dx,y-ay-t*dy);
            };
            const auto curve=[](float t,const std::array<float,8>& p)
            {
                const float u=1-t;
                return std::array<float,2>{u*u*u*p[0]+3*u*u*t*p[2]+3*u*t*t*p[4]+t*t*t*p[6],
                    u*u*u*p[1]+3*u*u*t*p[3]+3*u*t*t*p[5]+t*t*t*p[7]};
            };
            constexpr std::array<std::array<float,8>,2> strokes{{
                {30,9,20,5,19,15,26,15},{26,15,34,15,33,25,22,21}}};
            for(unsigned y=0;y<135;++y)for(unsigned x=0;x<156;++x)
            {
                const auto at=(std::size_t(y)*156+x)*4,old=(std::size_t(y/3)*52+x/3)*4;
                std::copy_n(native.pixels.begin()+old,4,image.pixels.begin()+at);
                if(y>=93)continue; // Socle31..44 retains every straight RGBA byte exactly.
                const float px=(x+.5F)/3,py=(y+.5F)/3;
                const float radius=std::hypot(px-26,py-15);
                std::array<float,3> color{22,55,56};
                const auto mix=[&](std::array<float,3> ink,float coverage)
                {for(unsigned c=0;c<3;++c)color[c]+=std::clamp(coverage,0.0F,1.0F)*(ink[c]-color[c]);};
                mix({192,158,90},(14.1F-radius)*3+.5F);
                mix({242,231,197},(11.8F-radius)*3+.5F);
                float distance=segment(px,py,26,5.5F,26,25);
                for(const auto& stroke:strokes)
                {
                    auto previous=curve(0,stroke);
                    for(unsigned step=1;step<=24;++step)
                    {
                        const auto next=curve(float(step)/24,stroke);
                        distance=std::min(distance,segment(px,py,previous[0],previous[1],next[0],next[1]));
                        previous=next;
                    }
                }
                mix({22,69,70},(.8F-distance)*3+.5F);
                for(unsigned c=0;c<3;++c)image.pixels[at+c]=image.pixels[at+3]?std::uint8_t(std::lround(color[c])):native.pixels[old+c];
                // Preserve the native transparent/partial-alpha mask exactly at3x.
            }
            return image;
        }
        bool backdrop(data::DataId root)
        {
            return data::dataGroup(root) == data::legacyGroupValue(data::LegacyGroupId::Main) &&
                (data::dataTag(root) >= 0x015B && data::dataTag(root) <= 0x0160 ||
                 data::dataTag(root) == 0x0162);
        }
    }
 
    bool ModernIBarSkin::supportsCardFaceIn(data::DataId root) const noexcept
    {
        const auto idle=faceIdleRoot(root);
        return language_==data::LanguageId::EnglishUs && presentationContext_ && idle && drawCards_.contains(*idle);
    }
 
    bool ModernIBarSkin::supportsAuctionToken(data::DataId root) const noexcept
    {
        return auctionToken(root) && language_==data::LanguageId::EnglishUs && tokenImages_ && presentationContext_;
    }
 
    bool ModernIBarSkin::supports(data::DataId root) const noexcept
    {
        if(supportsCardFaceIn(root) || supportsAuctionToken(root)) return true;
        if(root==0x00020355)return language_==data::LanguageId::EnglishUs && bool(presentationContext_);
        if(const auto p=property(root);p && p->miniature)
            return language_==data::LanguageId::EnglishUs && properties_ && propertyText_ && presentationContext_;
        const bool language = language_ == data::LanguageId::French ||
            language_ == data::LanguageId::EnglishUs || language_ == data::LanguageId::EnglishUk;
        if (scoreToken(root) || currentPlayerToken(root)) return language_ == data::LanguageId::EnglishUs && tokenImages_ && presentationContext_;
        if (deedText_ && deeds_.contains(root)) return true;
        if (drawText_ && drawCards_.contains(illustratedCardIdleOwner(root))) return true;
        return language && text_ && (backdrop(root) || (button(root).has_value() && layout_) || scoreColour(root).has_value() ||
            (property(root).has_value() && properties_ && propertyText_));
    }
 
    bool ModernIBarSkin::supportsIdleCardPresentation(data::DataId root) const noexcept
    {
        return language_==data::LanguageId::EnglishUs && drawCards_.contains(root) &&
            ((root>=0x50028 && root<=0x50037) || (root>=0x50059 && root<=0x50068));
    }
 
    std::shared_ptr<const data::BitmapRuntimeAsset> ModernIBarSkin::substitute(
        data::DataId root, std::shared_ptr<const data::BitmapRuntimeAsset> original, bool principal,
        std::optional<sequence::Matrix2D> rasterToWorld, std::optional<std::uint16_t> priority,
        std::optional<sequence::Matrix2D> sequenceToWorld)
    {
        if (!original || !supports(root)) return original;
        const auto w = original->image.width, h = original->image.height;
        if (!w || !h || w > 1600 || h > 600) return original;
        if(root==0x00020355)
        {
            if(!principal || !presentationContext_ || !presentationContext_() || !priority ||
                !rasterToWorld || !cashCoinPlacement(*rasterToWorld,*priority) || !originalPlayerCash(*original))return original;
            const Key key{root,w,h,true,{},501,{},original.get()};
            if(const auto found=cache_.find(key);found!=cache_.end())return found->second.replacement;
            auto result=std::make_shared<data::BitmapRuntimeAsset>();result->dataId=original->dataId;
            result->sourceType=data::LegacyDataType::Native;result->source=original->source;
            result->image=playerCashCoin(original->image);result->preferLinearFiltering=true;
            result->presentationRect=std::array<float,4>{0,0,52,45};
            if(cache_.size()>=128)cache_.clear();cache_.emplace(key,CachedArtwork{result,original});return result;
        }
        if(faceIdleRoot(root))
        {
            if(!supportsCardFaceIn(root) || !presentationContext_() || original->sourceType!=data::LegacyDataType::Uap || !valid(original->image)) return original;
            const bool background=faceBackground(root,original->dataId) && w==400 && h==240;
            if(!background && !faceSprite(root,*original)) return original;
            const Key key{root,w,h,false,std::array<float,9>{},0,{},original.get()};
            if(const auto found=cache_.find(key);found!=cache_.end()) return found->second.replacement;
            bool warm=false,ink=false;
            const auto& pixels=original->image.pixels;
            // Actual USA backgrounds/sprites contain warm fill plus dark/grayscale ink.
            // Unexpected coloured artwork fails closed rather than losing its colour.
            for(std::size_t i=0;i<pixels.size();i+=4)
            {
                const unsigned r=pixels[i],g=pixels[i+1],b=pixels[i+2];
                const auto low=std::min({r,g,b}),high=std::max({r,g,b});
                if(pixels[i+3]==0) continue; // Preserve even the transparent magenta colour key.
                if(high<=40 || high-low<=8) { ink|=high<64; continue; }
                if(r+8<g || g+8<b) return original;
                warm=true;
            }
            if(!warm || (background && !ink)) return original;
            auto result=std::make_shared<data::BitmapRuntimeAsset>(*original);
            result->sourceType=data::LegacyDataType::Native;
            constexpr std::array<unsigned,3> cream{237,232,215};
            for(std::size_t i=0;i<pixels.size();i+=4)
            {
                const unsigned r=pixels[i],g=pixels[i+1],b=pixels[i+2];
                if(pixels[i+3]==0 || std::max({r,g,b})<=40 || std::max({r,g,b})-std::min({r,g,b})<=8) continue;
                for(unsigned c=0;c<3;++c) result->image.pixels[i+c]=std::uint8_t((r*cream[c]+127)/255);
            }
            if(cache_.size()>=128) cache_.clear();
            cache_.emplace(key,CachedArtwork{result,original});
            return result;
        }
        const auto miniature=property(root);
        if(miniature && miniature->miniature &&
            (!principal || original->dataId!=root || original->sourceType!=data::LegacyDataType::Uap ||
             w!=36 || h!=42 || original->image.pixels.size()!=std::size_t(w)*h*4 ||
             !presentationContext_ || !presentationContext_())) return original;
        const auto currentToken=currentPlayerToken(root);
        const auto auctionOwner=auctionToken(root);
        if (const auto token = currentToken ? currentToken : auctionOwner ? auctionOwner : scoreToken(root))
        {
            std::optional<std::array<float,4>> currentRect;
            if (!principal || !presentationContext_ || !presentationContext_() ||
                original->image.pixels.size()!=std::size_t(w)*h*4) return original;
            if (currentToken)
            {
                if (!rasterToWorld || original->sourceType!=data::LegacyDataType::Uap ||
                    (priority && *priority!=258) ||
                    data::dataGroup(original->dataId)!=data::legacyGroupValue(data::LegacyGroupId::Main)) return original;
                const auto shape=std::find_if(CurrentPlayerShapes.begin(),CurrentPlayerShapes.end(),
                    [&](const auto& value) { return value.root==data::dataTag(root) &&
                        value.leaf==data::dataTag(original->dataId) && value.width==w && value.height==h; });
                if (shape==CurrentPlayerShapes.end()) return original;
                // Exact phase guards stay authored, but static thumbnail255 must
                // retain one size and anchor across the old rotating UAP phases.
                // Convert the measured world union back to local coordinates;
                // the renderer applies unchanged root StartXY(0,-4) once.
                const auto& box=CurrentPlayerWorldRects[*currentToken];
                currentRect=std::array<float,4>{float(box[0]),float(box[1]+4),
                    float(box[2]),float(box[3]+4)};
                const std::array<float,9> expected{1,0,0,0,1,0,float(shape->x),float(shape->y),1};
                for(unsigned i=0;i<9;++i)
                    if(!std::isfinite(rasterToWorld->values[i]) ||
                        std::abs(rasterToWorld->values[i]-expected[i])>0.0001F) return original;
            }
            else if(auctionOwner)
            {
                if(!rasterToWorld || !sequenceToWorld || !priority || *priority<316 || *priority>321 ||
                    original->sourceType!=data::LegacyDataType::Uap ||
                    data::dataGroup(original->dataId)!=data::legacyGroupValue(data::LegacyGroupId::Patterns))return original;
                const unsigned player=*priority-316;
                bool column=false;
                for(unsigned count=player+1;count<=6;++count)
                {
                    const int width=count>4 ? 134 : 201;
                    const int spacing=(800-int(count)*width)/int(count+1);
                    const int center=spacing+int(player)*(width+spacing)+width/2;
                    column=column || std::abs(sequenceToWorld->values[6]-center)<=0.0001F;
                }
                if(!column)return original;
                const std::array<float,9> expectedSequence{1,0,0,0,1,0,sequenceToWorld->values[6],560,1};
                for(unsigned i=0;i<9;++i)
                    if(!std::isfinite(sequenceToWorld->values[i]) ||
                        std::abs(sequenceToWorld->values[i]-expectedSequence[i])>0.0001F)return original;
                const auto shape=std::find_if(AuctionTokenShapes.begin(),AuctionTokenShapes.end(),[&](const auto& value)
                {
                    if(value.root!=data::dataTag(root) || value.leaf!=data::dataTag(original->dataId) || value.width!=w || value.height!=h)return false;
                    const std::array<float,9> expected{1,0,0,0,1,0,
                        sequenceToWorld->values[6]+value.x,560.0F+value.y,1};
                    for(unsigned i=0;i<9;++i)
                        if(!std::isfinite(rasterToWorld->values[i]) ||
                            std::abs(rasterToWorld->values[i]-expected[i])>0.0001F)return false;
                    return true;
                });
                if(shape==AuctionTokenShapes.end())return original;
                // Complete name surface ends550; cash surface starts565.
                // Fixed54x15 logical canvas leaves both untouched for every phase.
                currentRect=std::array<float,4>{-27,-10,27,5};
            }
            else if(original->dataId!=root || w!=ScoreTokenSizes[*token][0] || h!=ScoreTokenSizes[*token][1]) return original;
            const bool retainSource=currentToken.has_value() || auctionOwner.has_value();
            const Key key{root,w,h,true,currentToken ? rasterToWorld->values :
                auctionOwner ? sequenceToWorld->values : std::array<float,9>{},
                auctionOwner ? int(*priority) : 0,{},retainSource ? original.get() : nullptr};
            if (const auto found=cache_.find(key);found!=cache_.end())return found->second.replacement;
            const auto source=tokenImages_(std::uint8_t(*token));
            if (!source || source->width!=768 || source->height!=640 || source->pixels.size()!=std::size_t(768)*640*4)
                return original;
            unsigned left=768,top=640,right=0,bottom=0;
            bool transparent=false;
            for(unsigned y=0;y<640;++y)for(unsigned x=0;x<768;++x)
            {
                if(source->pixels[(std::size_t(y)*768+x)*4+3])
                {left=std::min(left,x);top=std::min(top,y);right=std::max(right,x+1);bottom=std::max(bottom,y+1);}
                else transparent=true;
            }
            if(!transparent || right<=left || bottom<=top)return original;
            auto result=std::make_shared<data::BitmapRuntimeAsset>();
            result->dataId=original->dataId;result->sourceType=data::LegacyDataType::Native;
            if(retainSource) result->source=original->source;
            result->preferLinearFiltering=true;
            result->presentationRect=currentRect ? currentRect : std::optional{std::array<float,4>{0,0,float(w),float(h)}};
            auto& image=result->image;
            const unsigned canvasWidth=currentRect ? unsigned((*currentRect)[2]-(*currentRect)[0]) : w;
            const unsigned canvasHeight=currentRect ? unsigned((*currentRect)[3]-(*currentRect)[1]) : h;
            image={canvasWidth*3,canvasHeight*3,
                std::vector<std::uint8_t>(std::size_t(canvasWidth)*canvasHeight*36,0)};
            const double fit=std::min(double(image.width-6)/(right-left),double(image.height-6)/(bottom-top));
            const unsigned iw=std::max(1U,unsigned((right-left)*fit)),ih=std::max(1U,unsigned((bottom-top)*fit));
            const unsigned ox=(image.width-iw)/2,oy=(image.height-ih)/2;
            for(unsigned y=0;y<ih;++y)for(unsigned x=0;x<iw;++x)
            {
                const auto src=(std::size_t(top+y*(bottom-top)/ih)*768+left+x*(right-left)/iw)*4;
                const auto dst=(std::size_t(y+oy)*image.width+x+ox)*4;
                std::copy_n(source->pixels.data()+src,4,image.pixels.data()+dst);
            }
            if(cache_.size()>=128)cache_.clear();
            cache_.emplace(key,CachedArtwork{result,retainSource ? original : nullptr});return result;
        }
        const auto deed = deeds_.find(root);
        const auto idleOwner=illustratedCardIdleOwner(root);
        const auto draw = drawCards_.find(idleOwner);
        if(const auto native=nativeIdleCardSource(root);native && draw!=drawCards_.end())
        {
            // Each production idle UAP contains both its Morris illustration
            // and printed caption. Artwork often overlaps the caption.
            // Preserve that authored ink rather than covering it with a new
            // title/body; no generic crop can safely separate these layers.
            if(!principal || original->dataId!=native->leaf || w!=400 || h!=native->height ||
                original->sourceType!=data::LegacyDataType::Uap || !valid(original->image) ||
                language_!=data::LanguageId::EnglishUs || !presentationContext_ ||
                !presentationContext_()) return original;
            if(idleOwner!=root)
            {
                // Out keeps its original moving CNK and supplementary1x1 leaf.
                // Only the real zero-origin opaque UAP face is qualified here.
                if(!original->source)return original;
                const auto metadata=data::inspectLegacyUap(*original->source);
                if(!metadata || metadata->width!=400 || metadata->height!=native->height ||
                    metadata->originX!=0 || metadata->originY!=0 || metadata->flags!=5) return original;
            }
            std::optional<IdleCardPresentation> presentation;
            if(supportsIdleCardPresentation(root) && priority==1005 && sequenceToWorld && idleCardPresentation_)
            {
                const auto& m=sequenceToWorld->values;
                // Only the two native root placements qualify, without rotations/scales.
                if(m[0]!=1 || m[1]!=0 || m[2]!=0 || m[3]!=0 || m[4]!=1 || m[5]!=0 ||
                    m[6]!=0 || (m[7]!=0 && m[7]!=136) || m[8]!=1)return original;
                presentation=idleCardPresentation_(root,*priority,*sequenceToWorld);
                if(presentation)
                {
                    const auto& box=presentation->localRect;
                    if(!std::ranges::all_of(box,[](float value){return std::isfinite(value);}) ||
                        box[0]!=600 || box[2]!=800 || box[1]+m[7]!=(225-h/2.0F)/2.0F ||
                        box[3]+m[7]!=(225+h/2.0F)/2.0F)return original;
                }
            }
            const auto placement=presentation ? std::optional{presentation->localRect} : std::nullopt;
            const int occlusionMode=presentation && presentation->occluded ? 1 : 0;
            const Key key{root,w,h,true,std::array<float,9>{},occlusionMode,placement,original.get()};
            if(const auto found=cache_.find(key);found!=cache_.end()) return found->second.replacement;
            bool warm=false,ink=false;
            const auto& pixels=original->image.pixels;
            for(std::size_t i=0;i<pixels.size();i+=4)
            {
                if(pixels[i+3]==0) continue;
                const unsigned r=pixels[i],g=pixels[i+1],b=pixels[i+2];
                const auto low=std::min({r,g,b}),high=std::max({r,g,b});
                if(high<=40 || high-low<=8) { ink|=high<64; continue; }
                if(r+8<g || g+8<b) return original;
                warm=true;
            }
            if(!warm || !ink) return original;
            auto result=std::make_shared<data::BitmapRuntimeAsset>(*original);
            result->sourceType=data::LegacyDataType::Native;
            constexpr std::array<unsigned,3> cream{237,232,215};
            for(std::size_t i=0;i<pixels.size();i+=4)
            {
                const unsigned r=pixels[i],g=pixels[i+1],b=pixels[i+2];
                if(pixels[i+3]==0 || std::max({r,g,b})<=40 ||
                    std::max({r,g,b})-std::min({r,g,b})<=8) continue;
                for(unsigned c=0;c<3;++c) result->image.pixels[i+c]=std::uint8_t((r*cream[c]+127)/255);
            }
            // Five measured baked-occlusion cards: keep the entire licensed image,
            // including baked title/caption/art, and repeat its authentic body
            // legibly below. No guessed illustration crop or restored glyphs.
            if(const auto body=readableIllustratedCardBody(idleOwner); !body.empty() && draw->second.body==body)
            {
                if(!original->source || !drawText_)return original;
                const auto header=data::inspectLegacyUap(*original->source);
                if(!header || header->width!=400 || header->height!=240 || header->originX!=0 ||
                    header->originY!=0 || header->flags!=5)return original;
                for(std::size_t at=3;at<pixels.size();at+=4)if(pixels[at]!=255)return original;
                std::vector<data::LegacyBitmapRGBA8> lines;
                std::istringstream words(draw->second.body);std::string word,line;
                std::optional<data::LegacyBitmapRGBA8> accepted;
                while(words>>word)
                {
                    const auto candidate=line.empty()?word:line+" "+word;
                    auto measured=drawText_(candidate,48,false,false);
                    if(!measured || !valid(*measured))return original;
                    if(measured->width>368*3)
                    {
                        if(line.empty() || lines.size()>=1)return original;
                        lines.push_back(std::move(*accepted));line=word;
                        auto single=drawText_(word,48,false,false);
                        if(!single || !valid(*single) || single->width>368*3)return original;
                        accepted=std::move(*single);
                    }
                    else {line=candidate;accepted=std::move(*measured);}
                }
                if(!accepted)return original;
                lines.push_back(std::move(*accepted));
                unsigned textHeight=0;for(const auto& glyphs:lines)textHeight+=glyphs.height;
                if(lines.size()>2 || textHeight>52*3)return original;
                auto artwork=std::move(result->image);
                auto& composed=result->image;
                composed={1200,720,std::vector<std::uint8_t>(1200*720*4,255)};
                for(std::size_t at=0;at<composed.pixels.size();at+=4)
                    for(unsigned c=0;c<3;++c)composed.pixels[at+c]=std::uint8_t(cream[c]);
                // Full400x240 input maps to logical300x180 at(50,0), aspect5:3.
                for(unsigned y=0;y<540;++y)for(unsigned x=0;x<900;++x)
                {
                    const auto src=(std::size_t(y*240/540)*400+x*400/900)*4;
                    const auto dst=(std::size_t(y)*1200+x+150)*4;
                    std::copy_n(artwork.pixels.data()+src,4,composed.pixels.data()+dst);
                }
                unsigned y=184*3+(52*3-textHeight)/2;
                for(const auto& glyphs:lines)
                {
                    const unsigned x=(1200-glyphs.width)/2;
                    for(unsigned py=0;py<glyphs.height;++py)for(unsigned px=0;px<glyphs.width;++px)
                    {
                        const auto src=(std::size_t(py)*glyphs.width+px)*4;
                        const auto dst=(std::size_t(y+py)*1200+x+px)*4;
                        const unsigned alpha=glyphs.pixels[src+3];
                        for(unsigned c=0;c<3;++c)composed.pixels[dst+c]=std::uint8_t(
                            (25*alpha+composed.pixels[dst+c]*(255-alpha)+127)/255);
                    }
                    y+=glyphs.height;
                }
                result->preferLinearFiltering=true;
            }
            if(presentation)
            {
                result->presentationRect=presentation->localRect;
                result->preferLinearFiltering=true;
                if(presentation->occluded)
                    for(std::size_t i=3;i<result->image.pixels.size();i+=4)result->image.pixels[i]=0;
            }
            if(cache_.size()>=128) cache_.clear();
            cache_.emplace(key,CachedArtwork{result,original});return result;
        }
        const bool fullCard = deed != deeds_.end() || draw != drawCards_.end();
        if ((fullCard || property(root).has_value()) && presentationContext_ && !presentationContext_()) return original;
        if (fullCard && presentationContext_ && !presentationContext_()) return original;
        if (deed != deeds_.end() && principal && (w != 199 || h != 227)) return original;
        std::optional<std::array<unsigned,4>> artwork;
        if(deed!=deeds_.end() && deed->second.artwork)
        {
            artwork=deedArtworkRect(root,*deed->second.artwork);
            if(!artwork || language_!=data::LanguageId::EnglishUs) return original;
            if(principal)
            {
                if(original->dataId!=root || !valid(original->image)) return original;
                bool ink=false;
                for(unsigned y=(*artwork)[1];y<(*artwork)[3];++y)
                    for(unsigned x=(*artwork)[0];x<(*artwork)[2];++x)
                    {
                        const auto i=(std::size_t(y)*w+x)*4;const auto& pixels=original->image.pixels;
                        if(pixels[i]!=pixels[i+1] || pixels[i]!=pixels[i+2] || pixels[i+3]!=255) return original;
                        ink|=pixels[i]<250;
                    }
                if(!ink) return original;
            }
        }
        if (draw != drawCards_.end() && principal &&
            (w != draw->second.nativeWidth || h != draw->second.nativeHeight || w < 199 || h < 150 || w > 600 || h > 400 ||
             draw->second.title.empty() || draw->second.title.size()>128 || draw->second.body.empty())) return original;
        std::optional<std::array<float,4>> deedPlacement;
        if (deed != deeds_.end() && principal && priority == 1002 && rasterToWorld && deedPlacement_)
        {
            if (!std::ranges::all_of(rasterToWorld->values, [](float value){return std::isfinite(value);})) return original;
            deedPlacement = deedPlacement_(root,*priority,*rasterToWorld);
            if (deedPlacement)
            {
                const auto& rect = *deedPlacement;
                if (!std::ranges::all_of(rect, [](float value){return std::isfinite(value);}) ||
                    rect[2] <= rect[0] || rect[3] <= rect[1] || rect[2]-rect[0] > 800 || rect[3]-rect[1] > 600)
                    return original;
            }
        }
        const auto b = !fullCard ? button(root) : std::optional<Button>{};
        if (b && presentationContext_ && !presentationContext_()) return original;
        layout::Rect band{0,0,int(w),int(h)};
        std::optional<layout::Rect> hit;
        const int activeLayout = b && layout_ ? int(layout_()) : 0;
        // Only the measured native transition fallback changes. Settled highres
        // artwork still follows the original whole-band qualification below.
        const auto nativeTransition = [&]() -> std::shared_ptr<const data::BitmapRuntimeAsset>
        {
            if(!b || !principal || language_!=data::LanguageId::EnglishUs ||
                !presentationContext_ || !presentationContext_() || !rasterToWorld ||
                !valid(original->image) || !nativeActionShape(root,*original)) return original;
            for(const float value:rasterToWorld->values) if(!std::isfinite(value)) return original;
            const auto& transform=rasterToWorld->values;
            const float determinant=transform[0]*transform[4]-transform[1]*transform[3];
            if(!std::isfinite(determinant) || std::abs(determinant)<1e-8F)return original;
            const Key nativeKey{root,w,h,false,std::array<float,9>{},-1,{},original.get()};
            if(const auto found=cache_.find(nativeKey);found!=cache_.end())return found->second.replacement;
            auto result=std::make_shared<data::BitmapRuntimeAsset>(*original);
            // Retain the actual printed caption, transparent colour key, alpha,
            // highlights and dark ink; tint only the measured neutral chrome.
            const auto& pixels=original->image.pixels;
            bool chrome=false;
            for(std::size_t i=0;i<pixels.size();i+=4)
            {
                const unsigned low=std::min({pixels[i],pixels[i+1],pixels[i+2]});
                const unsigned high=std::max({pixels[i],pixels[i+1],pixels[i+2]});
                if(!pixels[i+3] || high<=48 || low>=240)continue;
                if(high-low>24) continue; // Authored coloured caption/glow pixels stay exact.
                chrome=true;
                result->image.pixels[i]=std::uint8_t((unsigned(pixels[i])*70+50)/100);
                result->image.pixels[i+1]=std::uint8_t((unsigned(pixels[i+1])*92+50)/100);
                result->image.pixels[i+2]=std::uint8_t((unsigned(pixels[i+2])*88+50)/100);
            }
            if(!chrome)return original;
            result->sourceType=data::LegacyDataType::Native;
            if(cache_.size()>=128)cache_.clear();
            cache_.emplace(nativeKey,CachedArtwork{result,original});return result;
        };
        if (b && principal)
        {
            const auto slot = buttonSlot(b->index);
            if (!slot || !rasterToWorld) return nativeTransition();
            hit = layout::actionButtonRect(*slot, layout::ActionButtonLayout(activeLayout));
            const auto& m = rasterToWorld->values;
            const float det = m[0]*m[4] - m[1]*m[3];
            if (!std::isfinite(det) || std::abs(det) < 1e-8F) return nativeTransition();
            auto local = [&](float x, float y)
            {
                x -= m[6]; y -= m[7];
                return std::array<float,2>{(x*m[4]-y*m[3])/det, (y*m[0]-x*m[1])/det};
            };
            const auto center = local((hit->left+hit->right)*.5F,(hit->top+hit->bottom)*.5F);
            if (center[0] < 0 || center[0] >= w || center[1] < 0 || center[1] >= h) return nativeTransition();
            const std::array corners{local(float(hit->left),float(hit->top)),
                local(float(hit->right),float(hit->top)), local(float(hit->left),float(hit->bottom)),
                local(float(hit->right),float(hit->bottom))};
            float left = float(w), top = float(h), right = 0, bottom = 0;
            for (const auto& c : corners)
            { left=std::min(left,c[0]); top=std::min(top,c[1]); right=std::max(right,c[0]); bottom=std::max(bottom,c[1]); }
            // A moving CNK that cannot carry its whole interactive band retains
            // its actual retail transition; idle artwork never centres in a glow.
            // Actual USA Trade idle UAP is60x32 at70,454, while its legacy
            // interactive rectangle ends at132: two clickable pixels are outside
            // the authored bitmap ending at130. Clip only this proven settled
            // payload; moving/pressed frames keep their original transition.
            const bool settledTrade = b->index == 19 && b->state < 3 && w == 60 && h == 32 &&
                original->dataId == data::packDataId(data::LegacyGroupId::LanguageGraphics,
                    b->grey ? 0x1628 : 0x140E) &&
                m == std::array<float,9>{1,0,0,0,1,0,70,454,1} &&
                left == 0 && top == 1 && right == 62 && bottom == 29;
            if (!settledTrade && (left < -.01F || top < -.01F || right > w+.01F || bottom > h+.01F)) return nativeTransition();
            band = {std::clamp(int(std::floor(left)),0,int(w)),std::clamp(int(std::floor(top)),0,int(h)),
                std::clamp(int(std::ceil(right)),0,int(w)),std::clamp(int(std::ceil(bottom)),0,int(h))};
            if (band.right-band.left < 8 || band.bottom-band.top < 8) return nativeTransition();
        }
        const bool modernAction=b && actionText_ &&
            (b->index==0 || b->index==1 || b->index==3 || b->index==12 || b->index==17 ||
             b->index==13 || b->index==14 || b->index==18 || b->index==19);
        if(modernAction && principal && !valid(original->image))return original;
        const Key key{root, w, h, principal, b && rasterToWorld ? rasterToWorld->values : std::array<float,9>{},
            activeLayout, deedPlacement, (miniature && miniature->miniature) || modernAction ? original.get() : nullptr};
        if (const auto it = cache_.find(key); it != cache_.end()) return it->second.replacement;
        const auto p = property(root);
        std::optional<PropertyDescriptor> descriptor;
        if (p && principal)
        {
            descriptor = properties_(p->index);
            if (!descriptor || descriptor->name.empty() || descriptor->name.size() > 512 ||
                descriptor->purchaseText.size() > 128 || descriptor->group >= 10 ||
                w < 16 || h < 20 || w > 128 || h > 128) return original;
        }
        auto result = std::make_shared<data::BitmapRuntimeAsset>();
        result->dataId = original->dataId;
        result->sourceType = data::LegacyDataType::Native;
        result->preferLinearFiltering = true;
        result->presentationRect = deedPlacement;
        auto& image = result->image;
        image = {w, h, std::vector<std::uint8_t>(std::size_t(w) * h * 4)};
        if(modernAction)
        {
            // Intrinsic UAP origin remains authoritative in the production slot.
            image={w*3,h*3,std::vector<std::uint8_t>(std::size_t(w)*h*36,0)};
            if(principal)
            {
                const auto label=actionText_((language_==data::LanguageId::French?French:English)[b->index]);
                if(!label || !valid(*label))return original;
                const bool pressed=b->state==3;
                const std::array<unsigned,3> fill=b->grey?std::array<unsigned,3>{35,55,57}:
                    pressed?std::array<unsigned,3>{13,47,48}:std::array<unsigned,3>{22,69,70};
                const std::array<unsigned,3> trim=b->grey?std::array<unsigned,3>{110,116,104}:std::array<unsigned,3>{188,157,94};
                for(unsigned y=unsigned(band.top)*3;y<unsigned(band.bottom)*3;++y)
                    for(unsigned x=unsigned(band.left)*3;x<unsigned(band.right)*3;++x)
                    {
                        const auto i=(std::size_t(y)*image.width+x)*4;
                        const auto native=(std::size_t(y/3)*w+x/3)*4;
                        const bool edge=x<unsigned(band.left)*3+2 || y<unsigned(band.top)*3+2 ||
                            x+2>=unsigned(band.right)*3 || y+2>=unsigned(band.bottom)*3;
                        for(unsigned c=0;c<3;++c)image.pixels[i+c]=std::uint8_t(edge?trim[c]:fill[c]);
                        image.pixels[i+3]=original->image.pixels[native+3];
                    }
                const float fit=std::min({1.0F,float((band.right-band.left-8)*3)/label->width,float((band.bottom-band.top-6)*3)/label->height});
                const unsigned tw=std::max(1U,unsigned(label->width*fit)),th=std::max(1U,unsigned(label->height*fit));
                const unsigned ox=unsigned(band.left)*3+(unsigned(band.right-band.left)*3-tw)/2;
                const unsigned oy=unsigned(band.top)*3+(unsigned(band.bottom-band.top)*3-th)/2;
                for(unsigned y=0;y<th;++y)for(unsigned x=0;x<tw;++x)
                {
                    const auto src=(std::size_t(y*label->height/th)*label->width+x*label->width/tw)*4;
                    const auto dst=(std::size_t(y+oy)*image.width+x+ox)*4;
                    const unsigned alpha=label->pixels[src+3];
                    for(unsigned c=0;c<3;++c)
                    {
                        const unsigned ink=b->grey?180:(c==2?214:239);
                        image.pixels[dst+c]=std::uint8_t((ink*alpha+image.pixels[dst+c]*(255-alpha)+127)/255);
                    }
                }
                // Hit clipping uses subpixel centres but sourcealpha remains
                // exactly authored; no opacity invented for moving leaves.
                const auto& m=rasterToWorld->values;
                for(unsigned y=0;y<image.height;++y)for(unsigned x=0;x<image.width;++x)
                {
                    const float lx=(x+.5F)/3,ly=(y+.5F)/3;
                    const float wx=lx*m[0]+ly*m[3]+m[6],wy=lx*m[1]+ly*m[4]+m[7];
                    if(wx<hit->left || wx>=hit->right || wy<hit->top || wy>=hit->bottom)
                        image.pixels[(std::size_t(y)*image.width+x)*4+3]=0;
                }
            }
            if(cache_.size()>=128)cache_.clear();
            cache_.emplace(key,CachedArtwork{result,original});return result;
        }
        if (fullCard)
        {
            DeedDescriptor drawPlan;
            const DeedDescriptor* content = deed != deeds_.end() ? &deed->second : &drawPlan;
            const auto& rasterizer = deed != deeds_.end() ? deedText_ : drawText_;
            if (draw != drawCards_.end())
            {
                const bool community = data::dataGroup(root)==data::legacyGroupValue(data::LegacyGroupId::LanguageGraphics) &&
                    data::dataTag(root)>=0x0059;
                drawPlan.fills={{14,10,int(w)-28,48,community ? (22U|(69U<<8)|(70U<<16)) : (162U|(98U<<8)|(33U<<16))}};
                drawPlan.text={{draw->second.title,17,32,1,2,22,0x00EFEFEF,true,false,true},
                    {draw->second.body,70,int(h)-91,1,0,16,0x00191919,false,false,false}};
            }
            image = {w*3,h*3,std::vector<std::uint8_t>(std::size_t(w)*h*36)};
            if (principal)
            {
                if (content->text.empty() || content->text.size() > 64 || content->fills.size() > 32) return original;
                for (unsigned y=0; y<image.height; ++y)
                    for (unsigned x=0; x<image.width; ++x)
                    {
                        const bool border = x<6 || y<6 || x+6>=image.width || y+6>=image.height;
                        const bool brass = !border && (x==8 || y==8 || x+9==image.width || y+9==image.height);
                        const std::array<unsigned,3> color = border ? std::array<unsigned,3>{22,69,70} :
                            brass ? std::array<unsigned,3>{188,157,94} : std::array<unsigned,3>{237,232,215};
                        const auto i=(std::size_t(y)*image.width+x)*4;
                        for (unsigned c=0;c<3;++c) image.pixels[i+c]=std::uint8_t(color[c]);
                        image.pixels[i+3]=255;
                    }
                for (const auto& fill : content->fills)
                {
                    if (fill.x<0 || fill.y<0 || fill.width<0 || fill.height<0 ||
                        fill.x>w || fill.y>h || fill.width>int(w)-fill.x || fill.height>int(h)-fill.y) return original;
                    for (int y=fill.y*3; y<(fill.y+fill.height)*3; ++y)
                        for (int x=fill.x*3; x<(fill.x+fill.width)*3; ++x)
                        {
                            const auto i=(std::size_t(y)*image.width+unsigned(x))*4;
                            for (unsigned c=0;c<3;++c) image.pixels[i+c]=std::uint8_t(fill.color>>(c*8));
                        }
                }
                if(artwork)
                    for(unsigned y=(*artwork)[1]*3;y<(*artwork)[3]*3;++y)
                        for(unsigned x=(*artwork)[0]*3;x<(*artwork)[2]*3;++x)
                        {
                            const auto source=(std::size_t(y/3)*w+x/3)*4;
                            const auto destination=(std::size_t(y)*image.width+x)*4;
                            // Original opaque white-backed grayscale yields
                            // exact ink coverage255-gray; no generated icon.
                            const unsigned gray=original->image.pixels[source];
                            for(unsigned c=0;c<3;++c)
                                image.pixels[destination+c]=std::uint8_t((image.pixels[destination+c]*gray+127)/255);
                        }
                for(std::size_t textIndex=0;textIndex<content->text.size();++textIndex)
                {
                    auto region=content->text[textIndex];
                    const bool artTitle=artwork && textIndex==0;
                    if(artTitle)
                    {region.y=70;region.height=20;region.fontSize=16;region.bold=true;region.verticalLeeway=0;region.verticalCenter=true;}
                    const unsigned textInset=artTitle?12U:21U;
                    if (region.text.empty()) continue;
                    if (region.text.size()>2048 || region.y<0 || region.y>=int(h) || region.height<=0 ||
                        region.height>int(h)-region.y || region.verticalLeeway<0 || region.verticalLeeway>12 ||
                        region.fontSize<=0 || region.fontSize>32 || region.justification<0 || region.justification>2) return original;
                    bool fitted=false;
                    for (int size=region.fontSize; size>=1 && !fitted; --size)
                    {
                        std::vector<data::LegacyBitmapRGBA8> lines;
                        std::istringstream words(region.text);
                        std::string word,line;
                        std::optional<data::LegacyBitmapRGBA8> accepted;
                        bool tooWide=false;
                        while (words>>word)
                        {
                            const auto candidate=line.empty()?word:line+" "+word;
                            auto measure=rasterizer(candidate,size*3,region.bold,region.italic);
                            if (!measure || !valid(*measure)) return original;
                            if (measure->width>(w-textInset*2)*3)
                            {
                                if (line.empty()) { tooWide=true; break; }
                                // The last fitting candidate already contains this exact line.
                                // Reusing it avoids another font resize/render/restore cycle.
                                lines.push_back(std::move(*accepted)); line=word;
                                auto one=rasterizer(word,size*3,region.bold,region.italic);
                                if (!one || !valid(*one)) return original;
                                if (one->width>(w-textInset*2)*3) { tooWide=true; break; }
                                accepted=std::move(*one);
                            }
                            else { line=candidate; accepted=std::move(*measure); }
                        }
                        if (tooWide) continue;
                        if (line.empty()) return original;
                        lines.push_back(std::move(*accepted));
                        unsigned total=0;
                        for (const auto& rendered:lines) total+=rendered.height;
                        if (total>unsigned(region.height+region.verticalLeeway)*3) continue;
                        int y=region.y*3;
                        const int overflow=std::max(0,int(total)-region.height*3);
                        if (overflow<=region.verticalLeeway*3) y+=overflow;
                        if (region.verticalCenter && lines.size()==1) y+=(region.height*3-int(total))/2;
                        for (const auto& rendered:lines)
                        {
                            const int x=region.justification==0?int(textInset*3):region.justification==1?
                                (int(image.width)-int(rendered.width))/2:int(image.width)-int(textInset*3)-int(rendered.width);
                            if (x<0 || y<0 || x+int(rendered.width)>int(image.width) || y+int(rendered.height)>int(image.height)) return original;
                            for (unsigned py=0;py<rendered.height;++py)
                                for (unsigned px=0;px<rendered.width;++px)
                                {
                                    const auto src=(std::size_t(py)*rendered.width+px)*4;
                                    const auto dst=(std::size_t(y+int(py))*image.width+x+px)*4;
                                    const unsigned alpha=rendered.pixels[src+3];
                                    std::uint32_t inkColor=region.color;
                                    // Modern title contrast changes ink only; the exact
                                    // title/canonical group colour remain unchanged.
                                    if (region.bold && region.verticalCenter)
                                        for (const auto& fill:content->fills)
                                            if (region.y>=fill.y && region.y<fill.y+fill.height &&
                                                0.2126*(fill.color&255)+0.7152*((fill.color>>8)&255)+0.0722*((fill.color>>16)&255)<125)
                                                inkColor=0x00EFEFEF;
                                    for (unsigned c=0;c<3;++c)
                                    {
                                        const unsigned ink=(inkColor>>(c*8))&255;
                                        image.pixels[dst+c]=std::uint8_t((ink*alpha+image.pixels[dst+c]*(255-alpha)+127)/255);
                                    }
                                }
                            y+=int(rendered.height);
                        }
                        fitted=true;
                    }
                    if (!fitted) return original;
                }
            }
            if (cache_.size()>=128) cache_.clear();
            cache_.emplace(key,CachedArtwork{result,{}});
            return result;
        }
        if (p)
        {
            image = {w * 3, h * 3, std::vector<std::uint8_t>(std::size_t(w) * h * 36)};
            if (principal)
            {
                const auto group = (language_ == data::LanguageId::French ? FrenchGroups : OrdinaryGroups)[descriptor->group];
                for (unsigned y = 0; y < image.height; ++y)
                    for (unsigned x = 0; x < image.width; ++x)
                    {
                        const auto i = (std::size_t(y) * image.width + x) * 4;
                        const bool border = x < 3 || x + 3 >= image.width || y < 3 || y + 3 >= image.height;
                        const bool groupBand = !border && y < 22;
                        const bool mortgage = p->style == 2;
                        for (unsigned c = 0; c < 3; ++c)
                        {
                            int colour = border ? (mortgage ? std::array<int,3>{155,57,54}[c] : std::array<int,3>{22,69,70}[c]) :
                                groupBand ? group[c] : (mortgage ? std::array<int,3>{242,222,216}[c] : std::array<int,3>{237,232,215}[c]);
                            if (p->style == 1 && groupBand) colour = (colour + 2 * 155) / 3;
                            // A red diagonal across the header marks the mortgaged
                            // state without replacing or inventing translated text.
                            if (mortgage && groupBand && (x + y) % image.width < 4) colour = std::array<int,3>{155,57,54}[c];
                            image.pixels[i+c] = std::uint8_t(colour);
                        }
                        image.pixels[i+3] = 255;
                    }
                std::vector<data::LegacyBitmapRGBA8> lines;
                std::istringstream words(descriptor->name);
                std::string word, line;
                while (words >> word)
                {
                    const auto candidate = line.empty() ? word : line + " " + word;
                    auto measured = propertyText_(candidate);
                    if (!measured || !valid(*measured)) return original;
                    if (!line.empty() && measured->width > image.width - 12)
                    {
                        auto previous = propertyText_(line);
                        if (!previous || !valid(*previous)) return original;
                        lines.push_back(std::move(*previous));
                        line = word;
                    }
                    else line = candidate;
                }
                if (line.empty()) return original;
                auto last = propertyText_(line);
                if (!last || !valid(*last)) return original;
                lines.push_back(std::move(*last));
                const bool mortgageBadge = p->miniature && p->style == 2;
                const auto readableCaption = [&](const data::LegacyBitmapRGBA8& text, unsigned height,
                    unsigned minimumInkHeight)
                {
                    const float scale = std::min({1.0F, float(image.width - 12) / float(text.width),
                        float(height) / float(text.height)});
                    unsigned first = text.height, last = 0;
                    for (unsigned y = 0; y < text.height; ++y)
                        for (unsigned x = 0; x < text.width; ++x)
                            if (text.pixels[(std::size_t(y) * text.width + x) * 4 + 3] > 16)
                            {
                                first = std::min(first, y);
                                last = std::max(last, y);
                            }
                    if (first == text.height) return false;
                    const unsigned inkHeight = last - first + 1;
                    // Runtime uses 96 DPI: a point-size18 surface is27px high.
                    // Judge fitted visible ink, not its transparent font padding.
                    return float(inkHeight) * scale >= float(std::min(minimumInkHeight, inkHeight));
                };
                if (mortgageBadge)
                {
                    // Authentic US TRANS label: EuropeanDeedText.inc / retail UDPENNY.
                    // Style 1 is the unselected face, not a mortgage indicator.
                    auto label = propertyText_("Mortgaged");
                    if (!label || !valid(*label) || !readableCaption(*label, 18, 14)) return original;
                    for (unsigned y = 23; y < 42; ++y)
                        for (unsigned x = 3; x + 3 < image.width; ++x)
                        {
                            const auto i = (std::size_t(y) * image.width + x) * 4;
                            image.pixels[i] = 155;
                            image.pixels[i + 1] = 57;
                            image.pixels[i + 2] = 54;
                        }
                    caption(image, *label, 24, 18, 241);
                }
                const unsigned textHeight = mortgageBadge ? image.height - 72 : image.height - 54;
                if (lines.size() > textHeight) return original;
                const unsigned lineHeight = std::max(1U, textHeight / unsigned(lines.size()));
                if (mortgageBadge)
                    for (const auto& name : lines)
                        if (!readableCaption(name, lineHeight, 10)) return original;
                unsigned y = mortgageBadge ? 46 : 28;
                for (const auto& name : lines)
                {
                    caption(image, name, y, lineHeight, p->style == 1 ? 115 : 25);
                    y += lineHeight;
                }
                if (!descriptor->purchaseText.empty())
                {
                    auto price = propertyText_(descriptor->purchaseText);
                    if (!price || !valid(*price) ||
                        (mortgageBadge && !readableCaption(*price, 17, 12))) return original;
                    caption(image, *price, image.height - 23, 17, p->style == 1 ? 115 : 25);
                }
            }
            if(p->miniature)
                for(unsigned y=0;y<image.height;++y)for(unsigned x=0;x<image.width;++x)
                    image.pixels[(std::size_t(y)*image.width+x)*4+3]=original->image.pixels[(std::size_t(y/3)*w+x/3)*4+3];
            if (cache_.size() >= 128) cache_.clear();
            cache_.emplace(key, CachedArtwork{result,p->miniature?original:nullptr});
            return result;
        }
        const auto playerColour = scoreColour(root);
        if (principal)
        {
            for (unsigned y = unsigned(band.top); y < unsigned(band.bottom); ++y)
                for (unsigned x = unsigned(band.left); x < unsigned(band.right); ++x)
                {
                    const auto i = (std::size_t(y) * w + x) * 4;
                    const bool edge = x == unsigned(band.left) || y == unsigned(band.top) ||
                        x + 1 == unsigned(band.right) || y + 1 == unsigned(band.bottom);
                    const bool corner = b && ((x < unsigned(band.left+3) || x+3 >= unsigned(band.right)) &&
                        (y < unsigned(band.top+3) || y+3 >= unsigned(band.bottom)));
                    if (corner) continue;
                    const int gradient = int(8 * (h - y) / h);
                    const bool pressed = b && b->state == 3;
                    const bool grey = b && b->grey;
                    const std::array<int, 3> fill = playerColour ? std::array<int, 3>{237, 232, 215} : grey ? std::array<int, 3>{57, 64, 65} :
                        pressed ? std::array<int, 3>{13, 47, 48} : std::array<int, 3>{22, 69, 70};
                    const std::array<int, 3> trim = playerColour ? std::array<int, 3>{22, 69, 70} : grey ? std::array<int, 3>{104, 111, 111} :
                        std::array<int, 3>{188, 157, 94};
                    for (unsigned c = 0; c < 3; ++c)
                    {
                        // Black name/cash overlays require a light interior. The
                        // left player stripe does not enter their authored x>=57 region.
                        const bool stripe = playerColour && x >= 2 && x < 5 && y >= 2 && y + 2 < h;
                        const bool brass = playerColour && !edge && y == 1;
                        image.pixels[i + c] = std::uint8_t(stripe ? PlayerColours[*playerColour][c] :
                            brass ? std::array<int, 3>{188, 157, 94}[c] :
                            edge ? trim[c] : fill[c] + (playerColour ? 0 : gradient));
                    }
                    image.pixels[i + 3] = b || playerColour ? 255 : 244;
                }
            if (b)
            {
                auto label = text_((language_ == data::LanguageId::French ? French : English)[b->index]);
                if (!label || !label->width || !label->height ||
                    label->pixels.size() != std::size_t(label->width) * label->height * 4 || w < 8 || h < 8)
                    return original;
                const float scale = std::min({1.0F, float(band.right-band.left-8) / label->width, float(band.bottom-band.top-6) / label->height});
                const unsigned tw = std::max(1U, unsigned(label->width * scale));
                const unsigned th = std::max(1U, unsigned(label->height * scale));
                const unsigned ox = unsigned(band.left) + (unsigned(band.right-band.left) - tw) / 2,
                    oy = unsigned(band.top) + (unsigned(band.bottom-band.top) - th) / 2;
                for (unsigned y = 0; y < th; ++y)
                    for (unsigned x = 0; x < tw; ++x)
                    {
                        const auto src = (std::size_t(y * label->height / th) * label->width + x * label->width / tw) * 4;
                        const auto dst = (std::size_t(y + oy) * w + x + ox) * 4;
                        const unsigned a = label->pixels[src + 3];
                        for (unsigned c = 0; c < 3; ++c)
                        {
                            const unsigned ink = b->grey ? 180 : (c == 2 ? 214 : 239);
                            image.pixels[dst + c] = std::uint8_t((ink * a + image.pixels[dst + c] * (255 - a) + 127) / 255);
                        }
                    }
            }
        }
        if (b && principal && hit && rasterToWorld)
        {
            const auto& m = rasterToWorld->values;
            for (unsigned y = 0; y < h; ++y)
                for (unsigned x = 0; x < w; ++x)
                {
                    const float wx = (x+.5F)*m[0] + (y+.5F)*m[3] + m[6];
                    const float wy = (x+.5F)*m[1] + (y+.5F)*m[4] + m[7];
                    if (wx < hit->left || wx >= hit->right || wy < hit->top || wy >= hit->bottom)
                        image.pixels[(std::size_t(y)*w+x)*4+3] = 0;
                }
        }
        if (cache_.size() >= 128) cache_.clear();
        cache_.emplace(key, CachedArtwork{result,{}});
        return result;
    }
}