2

I had written before about implementing a map in my libgdx project.

I did that using a snapshot of said google map, importing the GPS bounds of the snapshot, the route-latlong values, a locationservice (via interface) and the snapshot as Gdx.files.local string.

Hopefully, the last issue I have right now is that the route is rotated about 45 degrees clockwise. Otherwise my 'enemies' walk a perfect path. I already figured out that I had to 'flip' my y-axis; before that it was rotated AND flipped upside down.

I was hoping someone here with more experience might have dealt with something similar before and has some advice :)

This is basically the code that creates a Waypoint array, after converting the GPS coordinates to pixel-coordinates that correspond to the gps-bounds of the map-snapshot (bottom-left-corner and upper-right-corner see here, as well as the width and height of the map-texture.

private void convertPathToScreen(double[] gpsRoute){
    for(int i = 0; i<gpsRoute.length; i++){
        if(i % 2 != 0) {
            screenRouteCoordinates[i] = 
x_GpsToScreenConversion(gpsRouteCoordinates[i]);
        }
        else{
            screenRouteCoordinates[i] = 
y_GpsToScreenConversion(gpsRouteCoordinates[i]);
        }

    }
}

public int x_GpsToScreenConversion(double x_pointInGpsCoords){
    double percentage = 1 - Math.abs((x_pointInGpsCoords - x_GpsMin) / 
(x_GpsMax - x_GpsMin));
    return  (int)((percentage* Math.abs(mapWidth - mapOrigin)) + mapOrigin);
}


public int y_GpsToScreenConversion(double y_pointInGpsCoords){
    double percentage = (y_pointInGpsCoords - y_GpsMin) / (y_GpsMax - y_GpsMin);
    return  (int)((percentage* Math.abs(mapHeight - mapOrigin)) + mapOrigin);
}

Edit: Now that I think of it, the error might be in my pathfinding code, although I tested it before moving my project forward and it worked solidly for all values I put in. Anyway, for completness...es sake

private void calculatePathing(){
    angle = (float) (Math.atan2(waypointsToGoal[waypoint].y - getY(), waypointsToGoal[waypoint].x - getX()));
    velocity.set((float) Math.cos(angle) * speed, (float) Math.sin(angle) * speed);
}

So the question is basically: How do I fix the 90° clockwise rotation that buggers up my game? Can I rotate the coordinates of the array around the center of the map (where all enemies walk to) or is there a mistake in the conversion-code here?

Thall
  • 51
  • 5

1 Answers1

0

Solution: (Patchwork, but it gets the job done!)

I simply rotated my waypoints by the degree I needed around the destination-point. It doesn't solve the underlying issue, but it solves the symptom.

private void createWaypointArray(){

    //formula requires radians
    double angle = Math.toRadians(90);

    double current_x;
    double current_y;

    // waypointCache.size()-1 gets me the last waypoint, the destination around which I rotate
    double center_x = waypointCache.get(waypointCache.size()-1).x;
    double center_y= waypointCache.get(waypointCache.size()-1).y;

    // Loop through Vector2 Array, rotate the points around destination and save them
    for(int i = 0; i < waypointCache.size()-1; i++){
        current_x = waypointCache.get(i).x;
        current_y = waypointCache.get(i).y;

        waypointCache.get(i).x = (float)((current_x-center_x) * Math.cos(angle) - (current_y-center_y) * Math.sin(angle) + center_x);
        waypointCache.get(i).y = (float)((current_x-center_x) * Math.sin(angle) + (current_y-center_y) * Math.cos(angle) + center_y);

    //  this does work, but also translates the points because it rotates around the 
    //  worldaxis, usable when points lie on normal kartesian axis I guess
    //  waypointCache.get(i).rotate(90);
    }
    this.wayPointArray = waypointCache.toArray(new Vector2[waypointCache.size()]);

}
Thall
  • 51
  • 5