0

我想存储一个二维世界，由块（具有 x 和 y 坐标）组成，这些块（具有 x 和 y 坐标）分组在块（具有 x 和 y 坐标）中。

这段代码显示了一个块如何对一些块进行分组：

public class Chunk {

    Block[][] blocks = new Block[GameProperties.MAP_SIZE_CHUNK][GameProperties.MAP_SIZE_CHUNK];
    int xpos, ypos;
    public Chunk(int posx, int posy){
        this.xpos = posx;
        this.ypos = posy;
        for (int x = 0; x < blocks.length; x++) {
            for (int y = 0; y < blocks.length; y++) {
                int blockx = xpos*GameProperties.MAP_SIZE_CHUNK + x;
                int blocky = ypos*GameProperties.MAP_SIZE_CHUNK + y;
                blocks[x][y] = new Block(blockx, blocky);
            }
        }
    }

}

目前GameProperties.MAP_SIZE_CHUNK = 8，所以每个块代表 8x8 = 64 块，但这是内容要更改，我必须动态进行！

坐标是整数，可以是正数和负数。

-100 >= y > MAXINT -MAXINT > x > MAXINT

块坐标具有相同的规则，但从左上块开始计算：

块 (0|0) = 0 <= x/y < 8 块 (-1|0) = -8 <= x/y < 0

这就是我从块坐标计算块和相对块的方式：

public int modulo(int a, int b){
    if(a < 0){
        return (a % b + b) % b;
    }
    return a % b;
}

public Block getBlock(int x, int y){
    int chunkx;
    int blockx;
    if(x < 0){
        int xn = x-GameProperties.MAP_SIZE_CHUNK;
        if(xn > GameProperties.MAP_SIZE_CHUNK){
            xn--;
        }
        chunkx = (xn)/GameProperties.MAP_SIZE_CHUNK;
        blockx = modulo((xn),GameProperties.MAP_SIZE_CHUNK);
    }else{
        chunkx = x/GameProperties.MAP_SIZE_CHUNK;
        blockx = modulo(x,GameProperties.MAP_SIZE_CHUNK);
    }

    int chunky;
    int blocky;
    if(y < 0){
        chunky = y/GameProperties.MAP_SIZE_CHUNK;
        if(chunky == 0){
            chunky = -1;
        }
        blocky = modulo(y,GameProperties.MAP_SIZE_CHUNK);
    }else{
        chunky = y/GameProperties.MAP_SIZE_CHUNK;
        blocky = modulo((y),GameProperties.MAP_SIZE_CHUNK);
    }
    Chunk c = getChunk(chunkx, chunky);
    Block b = c.getRelativeBlock(blockx, blocky);
    System.out.println("<<< " + x + " | " + b.getxPos() + "   = " + (x-b.getxPos()));
    return b;
}

公平地说，这真是一团糟，因为我已经尝试了所有方法来使模对负数起作用...有时，块（-1 | 0）有时会到达位置（0 | 0），块与x <- 1 被移动一个街区。我想了很久，但对这个问题视而不见，你能帮忙吗？

GetChunk 和 Chunk.getRelativeBlock 功能齐全，只是从 Map/Array 返回放置的块/块。

编辑

因为不清楚我在问什么：我在 Java 中遇到了负模数的问题。但即使最终结果有问题，也可能是模函数，也可能在其他地方。 有人知道我的代码哪里有问题吗？

4

1 回答 1

1

也许你可以使用这个：

public int modulo(int a, int b){
    if(a < 0){
        return (a + b) % b;
    }
    return a % b;
}

而不是这个：

public int modulo(int a, int b){
    if(a < 0){
        return (a % b + (1 + (Math.abs(a) / b)) * b) % b;
    }
    return a % b;
}

另一个问题：你怎么知道 b 是正数？

于 2013-01-11T15:20:58.490 回答