Pre Update functions

pub fn set_starting_scene(
    mut commands: Commands,
    starting_game_scene: Res<StartingGameScene>,
    mut current_game_scenes: ResMut<CurrentGameScenes>
) {
    info!("starting scene set");

    current_game_scenes.0.clear();
    current_game_scenes.0.insert(starting_game_scene.0.clone());

    commands.remove_resource::<StartingGameScene>();
}

pub fn build_world_path_finding_grid(
    mut commands: Commands,
    tiled_worlds: Res<Assets<TiledWorld>>,
    tiled_maps: Res<Assets<TiledMap>>,
    s_world: Single<(Entity, &TiledWorldHandle, &TilemapAnchor), Without<Grid<CardinalNeighborhood>>>,
) {
    let (entity, world_handle, anchor) = s_world.into_inner();

    let Some(tiled_world) = tiled_worlds.get(world_handle.0.id()) else {
        return;
    };

    let Some(first_map) = tiled_world.maps.first() else {
        return;
    };

    let Some(first_tiled_map) = tiled_maps.get(first_map.1.id()) else {
        return;
    };

    let tile_size = Vec2::new(first_tiled_map.map.tile_width as f32, first_tiled_map.map.tile_height as f32);

    let grid_size = tiled_world.rect.max / tile_size as Vec2;

    let mut chunk_size = 10;
    for count in 0..10 {
        let grid_size_scale = (grid_size.x * grid_size.y) as u32;
        let divider = 20 - count as u32;

        if grid_size_scale % divider.pow(2) != 0 || grid_size_scale / divider.pow(2) == 1 {
            continue;
        }

        chunk_size = divider;
        break;
    }

    let mut grid = Grid::<CardinalNeighborhood>::new(&GridSettings {
        width: grid_size.x as u32,
        height: grid_size.y as u32,
        depth: 1,
        chunk_size: chunk_size,
        chunk_depth: 1,
        chunk_ordinal: false,
        default_cost: 1,
        default_wall: true,
        collision: true,
        avoidance_distance: 4,
    });

    for (rect, _) in tiled_world.maps.iter() {
        let min = rect.min / tile_size;
        let max = rect.max / tile_size;

        for x in (min.x as u32)..(max.x as u32) {
            for y in (min.y as u32)..(max.y as u32) {
                grid.set_point(UVec3::new(x, y, 0), Point::new(1, false));
            }
        }

    }

    grid.build();

    let offset = anchor.as_offset(
        &TilemapSize::new(grid_size.x as u32, grid_size.y as u32),
        &TilemapGridSize::new(tile_size.x, tile_size.y),
        &TilemapTileSize::new(tile_size.x, tile_size.y),
        &TilemapType::Square,
    );

    commands.entity(entity).insert((
        grid,
        GridTileSize(tile_size),
        children![
            (
                DebugMap {
                    tile_width: tile_size.x as u32,
                    tile_height: tile_size.y as u32,
                    map_type: DebugMapType::Square,
                    draw_chunks: true,
                    draw_points: true,
                    draw_entrances: false,
                    draw_cached_paths: false,
                },
                Transform::from_translation(offset.extend(0.0))
            ),
            (
                Collider::rectangle(tile_size.x - 2., tile_size.y - 2.),
                ScanCollider
            )
        ]
    ));
}

pub fn handle_colliders_spawned(
    mut commands: Commands,
    e_collider_created: EventReader<TiledColliderCreated>,
    q_tiled_entities: Query<Entity, (Without<TiledCollidersSpawned>, Or<(With<TiledMapMarker>, With<TiledMapLayer>, With<TiledMapObject>)>)>,
) {
    if e_collider_created.is_empty() {
        return;
    }

    info!("spawned colliders");

    for entity in q_tiled_entities {
        commands.entity(entity).insert(TiledCollidersSpawned);
    }
}