RustのBevy(0.14.2)でスネークゲームを作る

use bevy::prelude::*;

fn main() {
    App::new().run();
}

fn main() {
    App::new().add_plugins(DefaultPlugins).run();
}

fn setup_camera(mut commands: Commands) {
    commands.spawn((
        Camera2dBundle {
            camera: Camera {
                hdr: true,
                ..default()
            },
            ..default()
        },
        BloomSettings::NATURAL,
    ));
}

App::new()
    .add_systems(Startup, setup_camera)
    .add_plugins(DefaultPlugins)
    .run();

#[derive(Component)]
struct SnakeHead;

const SNAKE_HEAD_COLOR: Color = Color::linear_rgb(0.7, 0.7, 0.7);

fn spawn_snake(mut commands: Commands) {
    commands
        .spawn(SpriteBundle {
            sprite: Sprite {
                color: SNAKE_HEAD_COLOR,
                ..default()
            },
            transform: Transform {
                scale: Vec3::new(10.0, 10.0, 10.0),
                ..default()
            },
            ..default()
        })
        .insert(SnakeHead);
}

App::new()
    .add_systems(Startup, (setup_camera, spawn_snake))
    .add_plugins(DefaultPlugins)
    .run();

fn snake_movement(mut head_positions: Query<(&SnakeHead, &mut Transform)>) {
    for (_head, mut transform) in head_positions.iter_mut() {
        transform.translation.y += 2.;
    }
}

fn snake_movement(
    keyboard_input: Res<ButtonInput<KeyCode>>,
    mut head_position: Query<(&SnakeHead, &mut Transform)>,
) {
    for (_head, mut transform) in head_position.iter_mut() {
        if keyboard_input.pressed(KeyCode::ArrowUp) {
            transform.translation.y += 2.;
        }
        if keyboard_input.pressed(KeyCode::ArrowDown) {
            transform.translation.y -= 2.;
        }
        if keyboard_input.pressed(KeyCode::ArrowRight) {
            transform.translation.x += 2.;
        }
        if keyboard_input.pressed(KeyCode::ArrowLeft) {
            transform.translation.x -= 2.;
        }
    }
}

fn size_scaling(window: Query<&Window>, mut q: Query<(&Size, &mut Transform)>) {
    let window = window.single();
    for (sprite_size, mut transform) in q.iter_mut() {
        transform.scale = Vec3::new(
            sprite_size.width / ARENA_WIDTH as f32 * window.width(),
            sprite_size.height / ARENA_HEIGHT as f32 * window.height(),
            1.0,
        );
    }
}

fn position_translation(window: Query<&Window>, mut q: Query<(&Position, &mut Transform)>) {
    fn convert(pos: f32, bound_window: f32, bound_game: f32) -> f32 {
        let tile_size = bound_window / bound_game;
        pos / bound_game * bound_window - (bound_window / 2.) + (tile_size / 2.)
    }
    let window = window.single();
    for (pos, mut transform) in q.iter_mut() {
        transform.translation = Vec3::new(
            convert(pos.x as f32, window.width(), ARENA_WIDTH as f32),
            convert(pos.y as f32, window.height(), ARENA_HEIGHT as f32),
            0.0,
        );
    }
}

fn snake_movement(
    keyboard_input: Res<ButtonInput<KeyCode>>,
    mut head_position: Query<&mut Position, With<SnakeHead>>,
) {
    for mut pos in head_position.iter_mut() {
        if keyboard_input.pressed(KeyCode::ArrowUp) {
            pos.y += 1;
        }
        if keyboard_input.pressed(KeyCode::ArrowDown) {
            pos.y -= 1;
        }
        if keyboard_input.pressed(KeyCode::ArrowRight) {
            pos.x += 1;
        }
        if keyboard_input.pressed(KeyCode::ArrowLeft) {
            pos.x -= 1;
        }
    }
}

.add_plugins(DefaultPlugins.set(WindowPlugin {
    primary_window: Some(Window {
        title: "Snake!".into(),
        resolution: (500., 500.).into(),
        ..default()
    }),
    ..default()
}))

let window = window.single();
let window_size = window.width().min(window.height());
for (sprite_size, mut transform) in q.iter_mut() {
    transform.scale = Vec3::new(
        sprite_size.width / ARENA_WIDTH as f32 * window_size,
        sprite_size.height / ARENA_HEIGHT as f32 * window_size,
        1.0,
    );
}

fn food_spawner(mut commands: Commands) {
    commands
        .spawn(SpriteBundle {
            sprite: Sprite {
                color: FOOD_COLOR,
                ..default()
            },
            ..default()
        })
        .insert(Food)
        .insert(Position {
            x: (random::<f32>() * ARENA_WIDTH as f32) as i32,
            y: (random::<f32>() * ARENA_HEIGHT as f32) as i32,
        })
        .insert(Size::square(0.8));
}

.add_systems(FixedMain, food_spawner)
...
.insert_resource(Time::<Fixed>::from_duration(Duration::from_secs(1)))

#[derive(Resource)]
struct IntervalSetting<T> {
    last_update: Instant,
    phantom: PhantomData<T>,
}

impl<T> Default for IntervalSetting<T> {
    fn default() -> Self {
        Self {
            last_update: Instant::now(),
            phantom: PhantomData,
        }
    }
}

impl<T> IntervalSetting<T> {
    fn check(&self, time: Instant, diff: Duration) -> bool {
        time - self.last_update >= diff
    }

    fn update(&mut self, time: Instant) {
        self.last_update = time;
    }
}

fn food_spawner(mut commands: Commands, mut time: ResMut<IntervalSetting<Food>>) {
    let now = Instant::now();
    if !time.check(now, Duration::from_secs(1)) {
        return;
    }
    time.update(now);
    // ...
    // 元の処理
    // ...
}

#[derive(PartialEq, Clone, Copy)]
enum Direction {
    UP,
    DOWN,
    LEFT,
    RIGHT,
}

impl Direction {
    fn opposite(self) -> Self {
        match self {
            Self::UP => Self::DOWN,
            Self::DOWN => Self::UP,
            Self::LEFT => Self::RIGHT,
            Self::RIGHT => Self::LEFT,
        }
    }
}

#[derive(Component)]
struct SnakeHead {
    direction: Direction,
}

fn spawn_snake(mut commands: Commands) {
    // ...
        .insert(SnakeHead {
            direction: Direction::UP,
        })
    // ...
}

fn snake_movement(
    keyboard_input: Res<ButtonInput<KeyCode>>,
    mut head_position: Query<(&SnakeHead, &mut Transform)>,
    mut time: ResMut<IntervalSetting<SnakeHead>>,
) {
    let now = Instant::now();
    if !time.check(now, Duration::from_millis(150)) {
        return;
    }
    time.update(now);
    // ...
    // 元の処理
    // ...
}

fn snake_movement_input(
    keyboard_input: Res<ButtonInput<KeyCode>>,
    mut heads: Query<&mut SnakeHead>,
) {
    if let Some(mut head) = heads.iter_mut().next() {
        let dir: Direction = if keyboard_input.pressed(KeyCode::ArrowUp) {
            Direction::UP
        } else if keyboard_input.pressed(KeyCode::ArrowDown) {
            Direction::DOWN
        } else if keyboard_input.pressed(KeyCode::ArrowRight) {
            Direction::RIGHT
        } else if keyboard_input.pressed(KeyCode::ArrowLeft) {
            Direction::LEFT
        } else {
            head.direction
        };
        if dir != head.direction.opposite() {
            head.direction = dir;
        }
    }
}

fn snake_movement(
    mut heads: Query<(&mut Position, &SnakeHead)>,
    mut time: ResMut<IntervalSetting<SnakeHead>>,
) {
    let now = Instant::now();
    if !time.check(now, Duration::from_millis(150)) {
        return;
    }
    time.update(now);
    if let Some((mut head_pos, head)) = heads.iter_mut().next() {
        match &head.direction {
            Direction::UP => {
                head_pos.y += 1;
            }
            Direction::DOWN => {
                head_pos.y -= 1;
            }
            Direction::RIGHT => {
                head_pos.x += 1;
            }
            Direction::LEFT => {
                head_pos.x -= 1;
            }
        };
    }
}

.add_systems(
    Update,
    (
        snake_movement_input.before(snake_movement),
        snake_movement,
        food_spawner,
    ),
)

const SNAKE_SEGMENT_COLOR: Color = Color::linear_rgb(0.3, 0.3, 0.3);

#[derive(Component)]
struct SnakeSegment;

#[derive(Default, Resource)]
struct SnakeSegments(Vec<Entity>);

.insert_resource(SnakeSegments::default())

fn spawn_segment(mut commands: Commands, position: Position) -> Entity {
    commands
        .spawn(SpriteBundle {
            sprite: Sprite {
                color: SNAKE_SEGMENT_COLOR,
                ..default()
            },
            ..default()
        })
        .insert(SnakeSegment)
        .insert(position)
        .insert(Size::square(0.5))
        .id()
}

fn spawn_snake(mut commands: Commands, mut segments: ResMut<SnakeSegments>) {
    *segments = SnakeSegments(vec![
        commands
            .spawn(SpriteBundle {
                sprite: Sprite {
                    color: SNAKE_HEAD_COLOR,
                    ..default()
                },
                transform: Transform {
                    scale: Vec3::new(10.0, 10.0, 10.0),
                    ..default()
                },
                ..default()
            })
            .insert(SnakeHead {
                direction: Direction::UP,
            })
            .insert(SnakeSegment)
            .insert(Position { x: 3, y: 3 })
            .insert(Size::square(0.8))
            .id(),
        spawn_segment(commands, Position { x: 3, y: 2 }),
    ]);
}

fn snake_movement(
    segments: ResMut<SnakeSegments>,
    mut heads: Query<(Entity, &SnakeHead)>,
    mut positions: Query<&mut Position>,
    mut time: ResMut<IntervalSetting<SnakeHead>>,
) {
    let now = Instant::now();
    if !time.check(now, Duration::from_millis(150)) {
        return;
    }
    time.update(now);

    if let Some((head_entity, head)) = heads.iter_mut().next() {
        let segment_positions = segments
            .0
            .iter()
            .map(|e| *positions.get_mut(*e).unwrap())
            .collect::<Vec<Position>>();
        let mut head_pos = positions.get_mut(head_entity).unwrap();
        match &head.direction {
            Direction::UP => {
                head_pos.y += 1;
            }
            Direction::DOWN => {
                head_pos.y -= 1;
            }
            Direction::RIGHT => {
                head_pos.x += 1;
            }
            Direction::LEFT => {
                head_pos.x -= 1;
            }
        };
        segment_positions
            .iter()
            .zip(segments.0.iter().skip(1))
            .for_each(|(pos, segment)| {
                *positions.get_mut(*segment).unwrap() = *pos;
            });
    }
}

fn snake_eating(
    mut commands: Commands,
    mut growth_writer: EventWriter<GrowthEvent>,
    food_positions: Query<(Entity, &Position), With<Food>>,
    head_positions: Query<&Position, With<SnakeHead>>,
) {
    for head_pos in head_positions.iter() {
        for (ent, food_pos) in food_positions.iter() {
            if food_pos == head_pos {
                commands.entity(ent).despawn();
                growth_writer.send(GrowthEvent);
            }
        }
    }
}

.add_systems(
    Update,
    (
        snake_movement_input.before(snake_movement),
        snake_movement,
        snake_eating.after(snake_movement),
        food_spawner,
    ),
)

#[derive(Event)]
struct GrowthEvent;

.add_event::<GrowthEvent>()

#[derive(Default, Resource)]
struct LastTailPosition(Option<Position>);

.insert_resource(LastTailPosition::default())

fn snake_movement(
    // ...
    mut last_tail_position: ResMut<LastTailPosition>,
    // ...
) {
    // ...
    if let Some((head_entity, head)) = heads.iter_mut().next() {
        // ...
        *last_tail_position = LastTailPosition(Some(*segment_positions.last().unwrap()))
    }
}

fn snake_growth(
    commands: Commands,
    last_tail_position: Res<LastTailPosition>,
    mut segments: ResMut<SnakeSegments>,
    mut growth_reader: EventReader<GrowthEvent>,
) {
    if growth_reader.read().next().is_some() {
        segments.0.push(spawn_segment(
            commands,
            last_tail_position.0.unwrap(),
            Size::square(0.5),
        ));
    }
}

.add_systems(
    Update,
    (
        snake_movement_input.before(snake_movement),
        snake_movement,
        snake_eating.after(snake_movement),
        snake_growth.after(snake_eating),
        food_spawner,
    ),
)

#[derive(Event)]
struct GameOverEvent;

.add_event::<GameOverEvent>()

fn snake_movement(
    // ...
    mut game_over_writer: EventWriter<GameOverEvent>,
    // ...
) {
    // ...
    if let Some((head_entity, head)) = heads.iter_mut().next() {
        // ...
        match &head.direction {
            // ...
        };
        if head_pos.x < 0
            || head_pos.y < 0
            || head_pos.x as u32 >= ARENA_WIDTH
            || head_pos.y as u32 >= ARENA_HEIGHT
        {
            game_over_writer.send(GameOverEvent);
        }
        // ...
    }
}

fn game_over(
    mut commands: Commands,
    mut reader: EventReader<GameOverEvent>,
    segments_res: ResMut<SnakeSegments>,
    food: Query<Entity, With<Food>>,
    segments: Query<Entity, With<SnakeSegment>>,
) {
    if reader.read().next().is_some() {
        for ent in food.iter().chain(segments.iter()) {
            commands.entity(ent).despawn();
        }
        spawn_snake(commands, segments_res);
    }
}

fn snake_movement(
    // ...
) {
    // ...
    if let Some((head_entity, head)) = heads.iter_mut().next() {
        // ...
        if head_pos.x < 0
            || head_pos.y < 0
            || head_pos.x as u32 >= ARENA_WIDTH
            || head_pos.y as u32 >= ARENA_HEIGHT
        {
            game_over_writer.send(GameOverEvent);
        }
        if segment_positions.contains(&head_pos) {
            game_over_writer.send(GameOverEvent);
        }
        // ...
    }
}

.add_systems(
    Update,
    (
        snake_movement_input.before(snake_movement),
        snake_movement,
        snake_eating.after(snake_movement),
        snake_growth.after(snake_eating),
        game_over.after(snake_movement), // <--
        food_spawner,
    ),
)

fn setup_camera(mut commands: Commands) {
    commands.spawn(Camera2d);
}

.spawn(Sprite {
    color: SNAKE_SEGMENT_COLOR,
    ..default()
})