.add_systems(Update, snake_movement)

        .insert_resource(Time::<Fixed>::from_seconds(0.125))
        .add_systems(FixedUpdate, snake_movement)
        .add_systems(Update, snake_movement_input.before(snake_movement))

struct SnakeHead;

struct SnakeHead {
    direction: Direction,
}

#[derive(PartialEq, Copy, Clone)]
enum Direction {
    Left,
    Up,
    Right,
    Down,
}
impl Direction {
    pub fn opposite(self) -> Self {
        match self {
            Self::Left => Self::Right,
            Self::Right => Self::Left,
            Self::Up => Self::Down,
            Self::Down => Self::Up,
        }
    }
}

        .insert(SnakeHead)

        .insert(SnakeHead { direction: Direction::Up, })

fn snake_movement(
    time: Res<Time>,

fn snake_movement_input(

    mut head_position: Query<&mut Position, With<SnakeHead>>,

    mut heads: Query<&mut SnakeHead>,

    for mut transform in head_position.iter_mut() {
        if keyboard_input.pressed(KeyCode::KeyA) {
            transform.x -= 1;
        }
        if keyboard_input.pressed(KeyCode::KeyD) {
            transform.x += 1;
        }
        if keyboard_input.pressed(KeyCode::KeyS) {
            transform.y -= 1;
        }
        if keyboard_input.pressed(KeyCode::KeyW) {
            transform.y += 1;

    if let Some(mut head) = heads.iter_mut().next() {
        let dir: Direction =
            if keyboard_input.pressed(KeyCode::KeyA) {
                Direction::Left
            }
            else if keyboard_input.pressed(KeyCode::KeyD) {
                Direction::Right
            }
            else if keyboard_input.pressed(KeyCode::KeyS) {
                Direction::Down
            }
            else if keyboard_input.pressed(KeyCode::KeyW) {
                Direction::Up
            } else {
                head.direction
            };
        if dir != head.direction.opposite() {
            head.direction = dir;

fn snake_movement(mut heads: Query<(&mut Position, &SnakeHead)>) {
    if let Some((mut pos, head)) = heads.iter_mut().next() {
        match &head.direction {
            Direction::Left => pos.x -= 1,
            Direction::Right => pos.x += 1,
            Direction::Up => pos.y += 1,
            Direction::Down => pos.y -= 1,
        }
    };
}