How to make wall collision for game using tilemap.txt file

[Abubakar1122331]

this is the txt file that im using to generate tilemap and its for pacman.
map.txt

and im using dots to make collision right now but its not working.
And here is the code:

pub fn map_collision(
    mut commands: Commands,
    asset_server: Res<AssetServer>,
    mut windows: ResMut<Windows>,
    mut texture_atlases: ResMut<Assets<TextureAtlas>>,
) {

    
    let window = windows.get_primary_mut().unwrap();
    let (w, h) = (window.width(), window.height());
    let file = File::open("assets/map_with_corners.txt").expect("No map file found");
    let MAP_OFFSET: Vec3 = Vec3::new( -w / 2. + WALL_SCALE, 1000. / 2. + WALL_SCALE, 0.);
    // let MAP_OFFSET: Vec3 = Vec3::new(-900. / 1.88 - 9.3, h / 2.02, 0.);
    let mut walls = Vec::new();


    for (col, line) in BufReader::new(file).lines().flatten().enumerate() {
        // for (col, char) in line.chars().filter(|c| *c == '1' || *c == '2' || *c == '3' || *c == '4' || *c == '5' || *c == '6' || *c == '7' || *c == '8' || *c == '9').enumerate() {
                for (row, char) in line.chars().enumerate() {

                    if char ==  '#' {
                        let wall = commands.spawn(SpriteBundle{
                            visibility: Visibility { is_visible: true },
                            sprite: Sprite{
                                color: Color::rgb(1., 1., 1.),
                                ..default()
                            },
                            transform: Transform{
                                translation: MAP_OFFSET + Vec3::new(row as f32 * GRID_SIZE * 3.3, -(col as f32) * GRID_SIZE * 3.3, 1.),
                                scale: Vec3::new(WALL_SCALE, WALL_SCALE, 1.0),
                                ..default()
                            },
                            ..default()
                        })
                        .insert(TileCollider)
                        .insert(Name::new("TileCollider")).id();
                        walls.push(wall);
                    }
                }
            // }
        }
        commands
        .spawn(SpatialBundle{
            transform: Transform {
                translation: Vec3::new(1.0, 1.0, 0.0),
                scale: Vec3::new(1., 1., 1.0),
                ..default()
            },
            visibility: Visibility {is_visible: true},
            ..default()
        })
        .insert(Name::new("Wall"))
        .push_children(&walls)
        .insert(Velocity { x: 0.0, y: 0.0 })
        .insert(FuelCell { capacity: 10.0 });

this is the code for player movement But there is problem, i want the player to move constantly without stopping (Like the real pacman) but when i stop pressing the key the player/pacman stops.

pub fn player_movement(
    kb: Res<Input<KeyCode>>,
    mut right_left_query: Query<(&mut Velocity, &mut Engine, &mut Transform), With<Player>>,
    wall_query: Query<&Transform, (With<TileCollider>, Without<Player>)>
) {
    let (mut velocity, mut engine, mut transform) = right_left_query.single_mut(); 
        
    let mut x_delta = 0.0;
        if kb.pressed(KeyCode::Right) || kb.pressed(KeyCode::D) {
                transform.rotation = Quat::default();
                engine.is_pressed = true;
                velocity.y = 0.;
                x_delta += velocity.x + 1. / 60. * 300.;
            }
        else if kb.pressed(KeyCode::Left) || kb.pressed(KeyCode::A) {
                transform.rotation = Quat::from_rotation_z(std::f32::consts::PI);
                engine.is_pressed = true;
                velocity.y = 0.;
                x_delta -= velocity.x + 1. / 60. * 300.;
            }
            let mut y_delta = 0.0;
        if kb.pressed(KeyCode::Up) || kb.pressed(KeyCode::W) {
                transform.rotation = Quat::from_rotation_z(std::f32::consts::PI / 2.);
                engine.is_pressed = true;
                velocity.x = 0.;
                y_delta += velocity.y + 1. / 60. * 300.;
                x_delta += velocity.x +0.;
            }
        else if kb.pressed(KeyCode::Down) || kb.pressed(KeyCode::S) {
                transform.rotation = Quat::from_rotation_z(std::f32::consts::PI / -2.);
                engine.is_pressed = true;
                velocity.x = 0.;
                y_delta -= velocity.y + 1. / 60. * 300.;
        }
        else {
            engine.is_pressed = true;
        };
        let target = transform.translation + Vec3::new(x_delta, 0.0, 0.0);
    if wall_collision_check(target, &wall_query) {
        transform.translation = target;
    }
    let target = transform.translation + Vec3::new(0.0, y_delta, 0.0);
    if wall_collision_check(target, &wall_query) {
        transform.translation = target;
    }
    }

Hope you understand what im trying to say. Can you help me with this.

[tigregalis]

Currently all movement is reliant on whether there is input, but what you really want is for the player to move, independently of input.

What you want to do is split input from movement/collision detection. A sketch:

1. In your input system: only set the Velocity of the player (up, down, left, right), do nothing else.
2. In your movement system, it knows nothing about input: "try" to move based on the player's Velocity, check if there's a collision between that "future" move and a wall: if there's a collision, abort the move; if there's no collision, proceed with the move i.e. set move = future move.

pub fn input(
    // 1. We take the input
    kb: Res<Input<KeyCode>>,
    // 2. We set the Velocity
    // I don't know what Engine is but I assume you need it for something
    mut right_left_query: Query<(&mut Velocity, &mut Engine), With<Player>>, 
) {
}
pub fn player_movement(
    // 1. We read the Velocity
    // 3. We update the Transform if there are no collisions
    mut right_left_query: Query<(&Velocity, &mut Transform), With<Player>>,
    // 2. We check for collisions
    wall_query: Query<&Transform, (With<TileCollider>, Without<Player>)>,
) {
}

Next, what you'll find is that it's moving too fast, so you'll probably need to put in a FixedTimestep or at least use Time in your player movement system.