Marlon Dias - 1 month ago 10
Java Question

# Efficient code for checking offset in pixel coordinates

I'm making a tile-based rendering method for a game, using Java.

There is the possibility of the first row (and column) of tiles be partially drawn on screen and i want to know how many pixel of these tiles are on screen.

I came up with this (for checking the max X coordinates of broken tiles):

``````int brokenX = xOffset; //xOffset can be any number
while (brokenX < 0){
brokenX += tileSet.getTileSize(); //corrects if the number is negative
}
while (brokenX >= tileSet.getTileSize()){
brokenX -= tileSet.getTileSize(); //corrects if the number is too big
}
``````

This works fine. But it seems like a waste of resources (considering it will be done twice for each frame).

Is there some efficient way (bit masks and such) of doing this?

I'd suggest to use a library function. Obviously, it's an huge overkill for this task, but there's much more in a good library. My favorite is Guava and this is the `mod` method:

``````int result = x % m;
return (result >= 0) ? result : result + m;
``````

An example should make it clear. I'm trying the numbers `13, 3, -7, -17` modulo `10`, which all should return the same result.

• `13 % 10 = 3`, that's OK
• `3 % 10 = 3`, still OK
• `-7 % 10 = -7` is negative and unusable as index, but with`-7 % 10 + 10 = 3` it's fine.
• `-17 % 10 + 10 = 3` is fine, too.

So for `result < 0`, or equivalently `m < 0`, you need to add `m` to get a positive result.