¿Cómo podría hacer de manera eficiente sombras de mosaicos falsas?

Question

Así que estoy haciendo un juego basado en fichas y me gustaría agregar algunas sombras falsas a las fichas. Es un poco difícil de explicar así que haré con las imágenes:

Digamos que este es mi mundo baldosas:

Y yo quiero que tenga sombras como esto:

Porque el mundo se basa azulejo, que puede dividir todas las partes de sombra en imágenes separadas:

Pero ahora no tengo idea de cómo iba a traer esto al código. Bueno, en realidad tengo ideas, pero son increíblemente tediosas y no funcionan de manera óptima.

He intentado una masiva sentencia 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"; 

Y una tabla de búsqueda masiva ...

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 } 
                         }) 
             }; 

Pero ya sea que estoy haciendo algo mal o que simplemente se niegan para trabajar en absoluto. ¿Algunas ideas?

Answer 1

Cada azulejo tiene ocho vecinos. Cada vecino tiene dos estados posibles. Ubique los estados de los vecinos en bits en un byte y utilice el byte como un índice en una tabla de búsqueda de 256 elementos.

Sí, esta es la solución de "fuerza bruta", y es posible que pueda obtener una tabla mucho más pequeña con un enfoque más inteligente. Pero 256 elementos no son demasiado (puede cargarlo fácilmente desde un archivo de datos), y lo bueno de este enfoque es que es completamente general. — puede hacer que los 256 mosaicos se vean sutilmente diferentes si lo desea.

---

bien, echar un vistazo más de cerca la forma en que sus tejas de los ejemplos están a la sombra, que parece que realmente sólo necesita cuatro bits (y por lo tanto una tabla de 16 elementos):

1. este bit si los vecinos del norte, oeste y noroeste son todos verdes.
2. Establezca este bit si los vecinos norte, este y noreste son todos verdes.
3. Establezca este bit si los vecinos del sur, oeste y suroeste son todos verdes.
4. Establezca este bit si los vecinos del sur, este y sureste son todos verdes.

Incluso algunas de estas 16 fichas siguen siendo versiones giradas/duplicadas entre sí, pero puede ser más fácil almacenar la orientación en la tabla junto con el índice del mosaico en lugar de intentar calcularlo en el código.

Answer 2

me gustaría probar algo como esto:

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); 
}