Question

我想存储一个二维世界，由块（具有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，所以每个Chunk代表8x8 = 64块，但这是要改变的内容，我必须动态地进行！

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

-100＆gt; = y＆gt; MAXINT -MAXINT＆gt; x> MAXINT

块坐标具有相同的规则，但是从左上方的块中计算：

块（0 | 0）= 0＆lt; = x / y＆lt; 8 块（-1 | 0）= -8＆lt; = x / y＆lt; 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;
}

说实话，这是一个真正的混乱，因为我已经尝试了所有的东西，以使模数工作负数... 有时，Chunk（-1 | 0）有时会到达位置（0 | 0），x＆lt; -1的块会移动一个块。我已经考虑了很长时间但是对这个问题视而不见，你能帮忙吗？

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

修改

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

Answer 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是积极的？

访问数据时对负索引的模数出错

1 个答案: