0
\$\begingroup\$

My original method for doing this involved taking the player's position, dividing it by the grid cell size, and rounding the result. This works for most cases except when I move my player up above y-axis zero or to the left of x-axis 0. I use the grids to load chunks of procedurally generated tiles into my scene.

it keeps resulting in -0 being a component of the position vectors, which throws my system off. I fixed that by converting each component to integers, but that doesn't solve the greater problem.

There must be a more effective method for this available.

EDIT:

I am using Godot Engine and GDscript for the game I am creating.

This is my code:

    func calculate_grid_position():
    var grid_position = Vector2(int(round(position.x/ 1600)),
                                int(round(position.y/ 1600)))
    return grid_position
\$\endgroup\$
6
  • \$\begingroup\$ This isn't nearly enough information to help you. What engine and programming language are you using? What does your current code look like? \$\endgroup\$
    – Kevin
    Dec 2 '20 at 23:59
  • 1
    \$\begingroup\$ The code you've shown is what we typically use for this situation. Using this code, an x position between -800 and 800 maps to column 0, -2400 to -800 maps to column -1, and 800 to 2400 maps to column +1. How does this differ from what you need? \$\endgroup\$
    – DMGregory
    Dec 3 '20 at 2:31
  • \$\begingroup\$ @DMGregory I get my player to walk to the top left and instead of spawing the appropriate chunk it does nothing At grid position (-0,0), it just spawns the chunk at (0,0). I get (-0,0) instead of (-1,0) \$\endgroup\$ Dec 3 '20 at 3:08
  • \$\begingroup\$ Well, did you try drawing your algo with pen and paper? From the description it looks right, you might have a bug elsewhere. \$\endgroup\$
    – Kromster
    Dec 3 '20 at 9:33
  • \$\begingroup\$ @Kromster I'll investigate. \$\endgroup\$ Dec 3 '20 at 9:45
1
\$\begingroup\$

It's common for negative zero to behave in unintuitive ways. Complicating things, I wasn't able to find an official doc detailing what sort of behavior a programmer should expect from Godot regarding negative zero.

So the best suggestion I can offer is to special case -0 to behave as needed:

func calculate_grid_position():
    var tempX = int(round(position.x/ 1600)
    if tempX == -0:
        tempX = -1
    var tempY = int(round(position.y/ 1600)
    if tempY == -0:
        tempY = -1
    var grid_position = Vector2(tempX, tempY)
    return grid_position

It would be a good idea not to hard coded the cell size (int this case 1600), but without more knowledge about your code, I can't specifically tell you how to fix that other than suggesting you to move those values into a variable or a constant.

As an end note, the desired mapping as described in the question & comments seems a bit unusual. I generally wouldn't expect -0 to arise under most situations. When I have needed to handle it as a special case, I've either converted it to 0 or treat it as an error / exception.

\$\endgroup\$
2
  • 1
    \$\begingroup\$ I agree -0 can act in unintuitive ways but I suspect -0 should become 0 and not -1 in this case. Otherwise the grid cell for 0 would include 0 ≤ x < 800 instead of -800 ≤ x < 800. \$\endgroup\$
    – amitp
    Dec 4 '20 at 23:07
  • \$\begingroup\$ @amitp I agree that the mapping is unusual. My read was that OP specifically identified the the code given worked except that -0 needed to map to -1. But it probably bears mentioning - I'll add an edit & would gladly update further if OP provides additional info. \$\endgroup\$
    – Pikalek
    Dec 4 '20 at 23:30

Your Answer

By clicking “Post Your Answer”, you agree to our terms of service, privacy policy and cookie policy

Not the answer you're looking for? Browse other questions tagged or ask your own question.