Question

explanation http://i45.tinypic.com/35aq7hv.png

嘿伙计，

好的，所以过去几天我一直想弄清楚这一点，我真的没有留下任何东西，因此我为什么在这里。

我正处于制作2D游戏的早期阶段。我为开发者模式创建了一个“库存”，它显示了一个图块网格（如图所示）。

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

一切都按预期运作。但是，我希望这样当我在地图上放置路径图块（红色边框）时，如果被其他路径图块（蓝色边框）包围，它将更改为正确的边框图块。

这是我的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地图;

我试图更新瓷砖，因为我将它们放在mouseClicked（MouseEvent e）方法中，方法是检查即将放置的瓷砖的上，下，左，右瓷砖。

    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构造函数，它使用基于网格的精灵表。 getSprite（为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;
    }
}

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

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

我喜欢编程，但不是那么多大声笑......

有人可以帮我找出算法，或者至少指出我正确的方向吗？

我知道这是一个非常大的问题，但所有的帮助将不胜感激！

的Sav。

编辑：这就是解决这个问题的方法。他使用类似于我的网格精灵表。然而，为了获得预期的精灵，他有一个x＆amp; 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）方法接收为精灵添加的所需数字。

我遇到的问题是找出一种方法，我可以使用类似的算法来找出我需要使用的精灵。

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

由于

Answer 1

我将给出4方向16个版本的答案（更容易可视化，写出更短），但这个想法延伸到8方向的情况。如果我正确阅读，你想弄清楚如何布置你的精灵，这样你就可以根据你，你，d，r找出你需要的位置。

这里基本上有一个4位数 - 其中每个位对应一个方向的连通性。所以你可以生成你的精灵：

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 strip（精灵的一维条带）。 Sprite [0] = 0000，Sprite [1] = 0001，.... Sprite [15] = 1111.然后要获得你的精灵，你只需要寻找：

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

现在，如果由于某种原因你想要一个2D精灵（比如说它是作为一个需要大小为2 ^ nx 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);

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

   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的连通性。如果你按照上面的方式布置精灵，并使用上面的算法，它应该工作（除非我拧紧并翻转我的X和Y，我有时会这样做:)

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

UL U UR L R DL D DR

但这只是将所有内容扩展到8位数的问题： UUUL L R RDDD 0000 0001 0010 0011 0100 0101 0110 0111 1000 ... L R 0000 0001 0010 。。

希望有意义（希望我回答正确的问题）。

二维游戏平铺放置算法

1 个答案: