C# 如何有效地制作假瓷砖阴影？

所以我正在制作一个基于瓷砖的游戏，我想在瓷砖上添加一些假阴影。这有点难以解释，所以我会用图片来解释：

假设这是我的瓷砖世界：

我希望它有这样的阴影：

struct surroundingTiles
{
    static bool blockNE;
    static bool blockN;
    static bool blockNW;
    static bool blockW;
    static bool blockSW;
    static bool blockS;
    static bool blockSE;
    static bool blockE;
}
foreach(object tile in floor)
{
    if(currentTile.surroundingTiles.blockW && currentTile.surroundingTiles.blockNW && currentTile.surroundingTiles.blockN)
        useTexture(currentTile, shadowSEtexture);
}

因为世界是基于瓷砖的，所以我可以将所有阴影部分分割为单独的图像：

但现在我不知道如何将其应用到代码中。嗯，实际上我确实有一些想法，但它们令人难以置信地乏味，而且不能达到最佳效果

我尝试了一个大规模的if声明

bool ul = adjacentBlocks[0, 0] == Block.Type.Rock; //Upper Left
bool um = adjacentBlocks[1, 0] == Block.Type.Rock; //Upper Middle
bool ur = adjacentBlocks[2, 0] == Block.Type.Rock; //Upper Right

bool ml = adjacentBlocks[0, 1] == Block.Type.Rock; //Center Left
//bool cm = adjacentBlocks[1, 1] == Block.Type.Rock; //CURRENT BLOCK - NOT NEEDED
bool mr = adjacentBlocks[2, 1] == Block.Type.Rock; //Center Right

bool ll = adjacentBlocks[0, 2] == Block.Type.Rock; //Lower Left
bool lm = adjacentBlocks[1, 2] == Block.Type.Rock; //Lower Middle
bool lr = adjacentBlocks[2, 2] == Block.Type.Rock; //Lower Right

if (ml) { texture = "Horizontal"; flipX = false; flipY = false; }
if (mr) { texture = "Horizontal"; flipX = true;  flipY = false; }
if (um) { texture = "Vertical"; flipX = false; flipY = false; }
if (lm) { texture = "Vertical"; flipX = false; flipY = true; }
if (ml && ul && um) texture = "HorizontalVertical";
//More if statements I can't be bothered to write
if (ul && um && ur && ml && mr && ll && lm & lr) texture = "Full";

还有一个庞大的查找表

var table = new List<TextureBlockLayout>
                                        {
                                            new TextureBlockLayout("Horizontal", false, false, new[,]
                                                                                         {
                                                                                             { true, true, false },
                                                                                             { true, true, false },
                                                                                             { true, true, false }
                                                                                         }),
                                            new TextureBlockLayout("Horizontal", true, false, new[,]
                                                                                         {
                                                                                             { false, true, true },
                                                                                             { false, true, true },
                                                                                             { false, true, true }
                                                                                         }),
                                            new TextureBlockLayout("Full", false, false, new[,]
                                                                                         {
                                                                                             { true, true, true },
                                                                                             { true, true, true },
                                                                                             { true, true, true }
                                                                                         })
                                        };

var表=新列表
{
新的TextureBlockLayout（“水平”，假，假，新[，]
{
{对，对，错}，
{对，对，错}，
{对，对，错}
}),
新的TextureBlockLayout（“水平”，真，假，新[，]
{
{假，真，真}，
{假，真，真}，
{假，真，真}
}),
新的TextureBlockLayout（“完整”、假、假、新[，]
{
{真的，真的，真的}，
{真的，真的，真的}，
{真的，真的，真的}
})
};

---

但不是我做错了什么，就是他们根本拒绝工作。有什么想法吗？

每个瓷砖都有八个邻居。每个邻居有两种可能的状态。将邻居的状态映射为字节中的位，并将该字节用作256元素查找表的索引

是的，这是“蛮力”解决方案，您可以使用一些更聪明的方法使用更小的表。但是256个元素并没有那么多（您可以轻松地从数据文件加载它），这种方法的优点是它是完全通用的——如果您愿意，您可以让所有256个平铺看起来有细微的不同

---

好的，仔细看看示例平铺的着色方式，看起来您实际上只需要四位（因此是一个16元素的表）：

如果北部、西部和西北部的邻居都是绿色的，则设置此位

如果北部、东部和东北部的邻居都是绿色的，则设置此位

如果南部、西部和西南部的邻居都是绿色的，则设置此位

如果南部、东部和东南部的邻居都是绿色的，则设置此位

---

即使这16个磁贴中的某些磁贴仍然是彼此的旋转/镜像版本，但将方向存储在磁贴索引旁边的表格中可能比在代码中计算方向更容易。

我会尝试以下方法：

struct surroundingTiles
{
    static bool blockNE;
    static bool blockN;
    static bool blockNW;
    static bool blockW;
    static bool blockSW;
    static bool blockS;
    static bool blockSE;
    static bool blockE;
}
foreach(object tile in floor)
{
    if(currentTile.surroundingTiles.blockW && currentTile.surroundingTiles.blockNW && currentTile.surroundingTiles.blockN)
        useTexture(currentTile, shadowSEtexture);
}

---

你说“他们拒绝工作”是什么意思？基本上他们给出了完全错误的阴影纹理。好吧，但既然你没有列出任何绘图代码，“完全错误”没有多大帮助。但这不是绘图代码的问题，而是纹理选择逻辑的问题，我从中发布了一些片段。无论如何，我并不是真的要求有人为我编写完整的逻辑，我只是要求有一种更好的方法来编写此代码，从而更好地选择阴影纹理。如果阴影应该在墙中，您可以将foreach视为（墙中的对象块）