java - 2D 游戏方 block 放置算法

Question

大家好，

好吧，过去几天我一直在努力解决这个问题，但我真的什么都没有了，所以我才来这里。

我正处于制作 2D 游戏的早期阶段。我为开发者模式创建了一个“ list ”，它显示了一个方 block 网格(如图底部所示)。

您可以将这些图 block 放在 map 网格中，然后将它们作为字符保存到文本文件中，以供将来加载 map 。

一切正常。但是，我希望这样当我在 map 上放置一个路径图 block (红色边框)时，当它被其他路径图 block (蓝色边框)包围时，它会更改为正确的边图 block 。

这是我的 Tilemap.java。

 public class TileMap {

private Tile[][] tiles;

public TileMap(int width, int height) {
    tiles = new Tile[width][height];
}

public int getWidth() {
    return tiles.length;
}

public int getHeight() {
    return tiles[0].length;
}

public Tile getTile(int x, int y) {
    if (x < 0 || x >= getWidth() || y < 0 || y >= getHeight()) {
        return new VoidTile();
    } else {
        return tiles[x][y];
    }
}

public void setTile(int x, int y, Tile tile) {
    if (x >= 0 && y >= 0) {
        tiles[x][y] = tile;
    }
}

}

好的，所以在我的主游戏类中我有一个 TileMap map ；

我尝试在 mouseClicked(MouseEvent e) 方法中通过检查即将放置的图 block 的上下左右图 block 来更新图 block 。

    public void mouseClicked(MouseEvent e) {
    Inventory.click(e);

    if (e.getButton() == 1) {
        tempTile = Inventory.getSelectedTile();
        System.out.println("Selected Tile is " + tempTile);
    } else if (e.getButton() == 3) {
        
        boolean u = map.getTile(mouseGridX, mouseGridY - 1).connectsToPath;
        boolean d = map.getTile(mouseGridX, mouseGridY + 1).connectsToPath;
        boolean l = map.getTile(mouseGridX - 1, mouseGridY).connectsToPath;
        boolean r = map.getTile(mouseGridX + 1, mouseGridY).connectsToPath;
        boolean ul = map.getTile(mouseGridX - 1, mouseGridY - 1).connectsToPath;
        boolean ur = map.getTile(mouseGridX + 1, mouseGridY - 1).connectsToPath;   
        boolean dl = map.getTile(mouseGridX - 1, mouseGridY + 1).connectsToPath; 
        boolean dr = map.getTile(mouseGridX + 1, mouseGridY + 1).connectsToPath;   
             
                    if (!u && !l && !d && !r) {
                       map.setTile(mouseGridX, mouseGridY new PathTile(5));
                    }
            }
  }

这是我的 PathTile.java 构造函数，它使用基于网格的 Sprite 表。获取 Sprite (GridX,GridY)

    public PathTile(int tile) {
    this.tile = tile;
    connectsToPath = true;
    
    switch (tile) {
    case 1:
        this.image = Sprite.getSprite(1, 1);
        break;
    case 2:
        this.image = Sprite.getSprite(2, 1);
        break;
    case 3:
        this.image = Sprite.getSprite(3, 1);
        break;
    case 4:
        this.image = Sprite.getSprite(1, 2);
        break;
    case 5:
        this.image = Sprite.getSprite(2, 2);
        break;
    case 6:
        this.image = Sprite.getSprite(3, 2);
        break;
    case 7:
        this.image = Sprite.getSprite(1, 3);
        break;
    case 8:
        this.image = Sprite.getSprite(2, 3);
        break;
    case 9:
        this.image = Sprite.getSprite(3, 3);
        break;
    case 10:
        this.image = Sprite.getSprite(4, 2);
        break;
    case 11:
        this.image = Sprite.getSprite(5, 2);
        break;
    case 12:
        this.image = Sprite.getSprite(4, 3);
        break;
    case 13:
        this.image = Sprite.getSprite(5, 3);
        break;
    }
}

这是基于 notch 的 Ludum Dare 游戏“MiniCraft”。但是，我似乎无法找到一种有效的方法来用我的方法来实现它。

如果我的数学是正确的(可能不正确)，但这是否意味着有 65,535 种可能的结果？ (4 * 4 * 4 * 4 * 4 * 4 * 4 * 4)??

我喜欢编程，但不是很喜欢……

谁能帮我想出一个算法，或者至少给我指明正确的方向？

我知道这是一个很大的问题，但我们将不胜感激所有的帮助!

保存。

编辑: 这就是 notch 解决这个问题的方式。 他使用类似于我的网格 Sprite 表。然而，为了获得预期的 Sprite ，他有一个 x 和 y 坐标，他将其乘以 32(网格框的大小)。

    boolean u = !level.getTile(x, y - 1).connectsToGrass;
    boolean d = !level.getTile(x, y + 1).connectsToGrass;
    boolean l = !level.getTile(x - 1, y).connectsToGrass;
    boolean r = !level.getTile(x + 1, y).connectsToGrass;

    if (!u && !l) {
        screen.render(x * 16 + 0, y * 16 + 0, 0, col, 0);
    } else
        screen.render(x * 16 + 0, y * 16 + 0, (l ? 11 : 12) + (u ? 0 : 1) * 32, transitionColor, 0);

    if (!u && !r) {
        screen.render(x * 16 + 8, y * 16 + 0, 1, col, 0);
    } else
        screen.render(x * 16 + 8, y * 16 + 0, (r ? 13 : 12) + (u ? 0 : 1) * 32, transitionColor, 0);

    if (!d && !l) {
        screen.render(x * 16 + 0, y * 16 + 8, 2, col, 0);
    } else
        screen.render(x * 16 + 0, y * 16 + 8, (l ? 11 : 12) + (d ? 2 : 1) * 32, transitionColor, 0);
    if (!d && !r) {
        screen.render(x * 16 + 8, y * 16 + 8, 3, col, 0);
    } else
        screen.render(x * 16 + 8, y * 16 + 8, (r ? 13 : 12) + (d ? 2 : 1) * 32, transitionColor, 0);
}

如您所见，他使用 (boolean ? true : false) 方法接收要为 Sprite 添加的所需数字。

我遇到的问题是找出一种方法，我可以使用类似的算法来确定我需要使用哪个 Sprite 。

这就是我的要求。我什至很高兴看到其他人如何克服这个问题。

谢谢

Answer 1

我将给出 4 向 16 案例版本的答案(更容易可视化，并且写出来更短)但这个想法扩展到 8 向案例。如果我没看错，你想弄清楚如何布置你的 Sprite ，这样你就可以根据 u,l,d,r 找出你需要的位置。

这里基本上有一个 4 位数字 - 每个位对应一个方向的连通性。所以你可以生成你的 Sprite :

ULDR 
0000: No connections
0001: Right side connected
0010: Down connected
0011: Down and right connected
0100: Left connected
0101: Left and right connected
0110: Left and down connected
0111: Left, right, and down connected
...
1111: Up, left, down and right all connected.

您可以按照该顺序制作 Sprite 条( Sprite 的一维 strip )。 Sprite[0] = 0000, Sprite[1] = 0001, .... Sprite[15] = 1111。然后为了得到你的 Sprite ，你只需要寻找:

index = (up ? 0x8 : 0) | (left ? 0x4 : 0) | (down ? 0x2 : 0) | (right ? 0x1 : 0); 
s = sprite.getSprite(index, 0); 

现在，如果出于某种原因你想要一个 2D Sprite (假设它是作为一个纹理完成的，需要将大小设置为 2^n x 2^n 或其他东西 - 我不是图形专家，我不知道)，你可以这样做:

x_index = (up ? 0x2 : 0) | (left ? 0x1 : 0);
y_index = (right ? 0x2 : 0) | (down ? 0x1 :0); 
s = sprite.getSprite(x_index, y_index); 

在任何一种情况下，您只需要安排 Sprite 以匹配模式。我在上面列出了第一个的顺序。对于一个二维 Sprite ，你基本上有一个相应的 Sprite 布局:

   DR
UL      00   01   10   11 
   00 0000 0001 0010 0011
   01 0100 0101 0110 0111
   10 1000 1001 1010 1011 
   11 1100 1101 1110 1111 

同样，其中的位分别对应于与 ULDR 的连接。如果你像上面那样布置 Sprite ，并使用上面的算法，它应该可以工作(除非我搞砸了并翻转了我的 Xs 和 Ys，我有时会这样做:)

现在，如果你想使用 8 维的情况，想法是一样的，除了你有 8 位而不是 4 位:

UL U UR L R DL D DR

但这只是将所有内容扩展到 8 位数字的问题: UUUL 大号 RDDD 0000 0001 0010 0011 0100 0101 0110 0111 1000 ... 大号 0000 0001 0010 . . .

希望这是有道理的(并希望我回答的是正确的问题)。