Something is wrong with calculation of TilePos to real x/y

[miketwenty1]

While having a sprite walk to a TilePos, I think there may be a bug/logic issue in my code with how the X or Y axis is being produced.

Below is a function of a Sprite "Hal" walking to a TilePos. The Tilemap and the TileBundle have an anchor of TilemapAnchor::BottomLeft used for their Transform. I need to invert the Y value, which seems reasonable (y: -tile_center.y,), but in order for me to get him to walk to the correct location I need to also add half the amount of the total height of the TilemapBundle. (i.e. y: -tile_center.y + (BUILDING_CHUNK_SIZE.x as f32 * TILE_SIZE.x / 2.),).

Granted pub const BUILDING_CHUNK_SIZE: UVec2 = UVec2 { x: 16, y: 16 };
So in other words he's off by 8 tiles in the downward direction and I need to compensate for this as show above.

If I instead use TilemapAnchor::Center My Sprite is off by the same 8 tiles or half the chunk size in the X axis direction (left of the mark).

I feel like I'm doing my due diligence when setting the Transform of these tiles when I spawn them. i.e

let tile_center_noz = tile_pos
                    .center_in_world(&map_size, &grid_size, &tile_size, &map_type, &anchor)
                    .extend(1.0);

Any ideas if this is a bug with my code or a bug with how the original Tile Transforms?

pub fn random_hal_walk(
    time: Res<Time>,
    mut hal_query: Query<&mut Transform, With<RunningHal>>,
    building_tile_q: Query<(&TilePos, &UlamComp), With<BuildingTileComp>>,
    //castle_q: Query<&ChildOf, With<Castle>>,
    building_map_q: Query<
        (
            &TilemapType,
            &TilemapGridSize,
            &TilemapTileSize,
            &TileStorage,
            &TilemapSize,
            &TilemapAnchor,
        ),
        With<ChunkBuildingMapComp>,
    >,
    mut state: Local<HalMoveState>,
) {
    let dt = time.delta_secs();

    if let Ok(mut hal_transform) = hal_query.single_mut() {
        if state.target.is_none() && !state.there {
            for (map_type, grid_size, tile_size, tilemap_storage, map_size, anchor) in
                building_map_q.iter()
            {
                for tile_entity in tilemap_storage.iter().flatten() {
                    let tile_pos = building_tile_q.get(*tile_entity);
                    if let Ok((tp, ulam)) = tile_pos {
                        if ulam.0 == 535 {
                            let tile_center = tp
                                .center_in_world(map_size, grid_size, tile_size, map_type, anchor)
                                .extend(1.0);
                            state.target = Some(Vec2 {
                                x: tile_center.x,
                                y: -tile_center.y,
                            });
                            state.speed = 50.0;
                        }
                    }
                }
            }
        }

        if let Some(target_pos) = state.target {
            let distance_left = hal_transform.translation.xy().distance(target_pos.xy());
            if distance_left < 20.0 {
                state.target = None;
                state.there = true;
                info!("hal now unset");
            } else {
                let starting_xy = hal_transform.translation.xy();
                // Fix the direction by normalizing the vector from starting to target
                let direction = (target_pos - starting_xy).normalize();
                let change = direction * state.speed * dt;
                let new_pos = starting_xy + change;

                info!(
                    "starting_xy {} change {} new_pos {} distance_left {} tgt {}",
                    starting_xy,
                    change,
                    new_pos,
                    distance_left,
                    target_pos.xy()
                );

                hal_transform.translation = Vec3::new(new_pos.x, new_pos.y, ANIMATED_SPRITE_Z);
            }
        }
    }
}