Bevyを使ったタイミングゲームを作る

#[derive(Component)]
struct Slider;

#[derive(Component)]
struct Cue;

#[derive(Component)]
struct Reflector;

#[derive(Component, Deref, DerefMut)]
struct Velocity(Vec2);

#[derive(Component)]
struct Collider;

// Cue
commands.spawn((
    SpriteBundle {
        sprite: Sprite {
            color: Color::YELLOW,
            custom_size: Some(CUE_SIZE),
            ..default()
        },
        ..default()
    },
    Cue,
    Velocity(INITIAL_CUE_DIRECTION.normalize() * CUE_SPEED),
));

commands.spawn((
    SpriteBundle {
        sprite: Sprite {
            color: Color::RED,
            custom_size: Some(REFLECTOR_SIZE),
            ..default()
        },
        transform: Transform {
            translation: Vec3::new(-SLIDER_SIZE.x / 2.0, 0.0, 0.0),
            ..default()
        },
        ..default()
    },
    Reflector,
    Collider,
));

fn main() {
    App::new()
        // ...
        .add_systems((
            check_for_collisions,
            apply_velocity.before(check_for_collisions),
            decide_timing
                .before(check_for_collisions)
                .after(apply_velocity),
        ))
        // ...
        .run();
}

fn decide_timing(keyboard_input: Res<Input<KeyCode>>, query: Query<&Transform, With<Cue>>) {
    let cue_transform = query.single();

    if keyboard_input.just_pressed(KeyCode::Space) {
        let cue_translation_x = cue_transform.translation.x;
        println!("{}", cue_translation_x);

        if cue_translation_x < PERFECT_TIMING_RANGE && cue_translation_x > -PERFECT_TIMING_RANGE {
            println!("Perfect timing!");
        } else if cue_translation_x < GOOD_TIMING_RANGE && cue_translation_x > -GOOD_TIMING_RANGE {
            println!("Good timing!");
        } else if cue_translation_x < OK_TIMING_RANGE && cue_translation_x > -OK_TIMING_RANGE {
            println!("OK timing!");
        } else {
            println!("Bad timing!");
        }
    }
}

fn main() {
    App::new()
        .add_plugins(DefaultPlugins)
        .insert_resource(Scoreboard { score: 0 })
        // ...
 }

#[derive(Resource)]
struct Scoreboard {
    score: isize,
}

fn setup() {
    // ...

    // Scoreboard
    commands.spawn(
        TextBundle::from_sections([
            TextSection::new(
                "Score: ",
                TextStyle {
                    font: asset_server.load("fonts/FiraSans-Bold.ttf"),
                    font_size: SCOREBOARD_FONT_SIZE,
                    color: Color::BLACK,
                    ..default()
                },
            ),
            TextSection::from_style(TextStyle {
                font: asset_server.load("fonts/FiraMono-Medium.ttf"),
                font_size: SCOREBOARD_FONT_SIZE,
                color: Color::GRAY,
                ..default()
            }),
        ])
        .with_style(Style {
            position_type: PositionType::Absolute,
            position: UiRect {
                top: SCOREBOARD_TEXT_PADDING,
                left: SCOREBOARD_TEXT_PADDING,
                ..default()
            },
            ..default()
        }),
    );
}

fn main() {
    App::new()
        // ...
        .add_system(update_scoreboard)
        // ...
}

fn decide_timing(
    keyboard_input: Res<Input<KeyCode>>,
    mut scoreboard: ResMut<Scoreboard>,
    query: Query<&Transform, With<Cue>>,
) {
    let cue_transform = query.single();

    if keyboard_input.just_pressed(KeyCode::Space) {
        let cue_translation_x = cue_transform.translation.x;
        println!("{}", cue_translation_x);

        if cue_translation_x < PERFECT_TIMING_RANGE && cue_translation_x > -PERFECT_TIMING_RANGE {
            scoreboard.score += 100;
        } else if cue_translation_x < GOOD_TIMING_RANGE && cue_translation_x > -GOOD_TIMING_RANGE {
            scoreboard.score += 50;
        } else if cue_translation_x < OK_TIMING_RANGE && cue_translation_x > -OK_TIMING_RANGE {
            scoreboard.score += 10;
        } else {
            scoreboard.score += -100;
        }
    }
}

fn update_scoreboard(scoreboard: Res<Scoreboard>, mut query: Query<&mut Text>) {
    let mut text = query.single_mut();
    text.sections[1].value = scoreboard.score.to_string();
}

#[derive(Default)]
struct TimingEvent;

#[derive(Resource)]
struct TimingSound(Handle<AudioSource>);

fn setup(mut commands: Commands, asset_server: Res<AssetServer>) {
    // Sound
    let cue_timing_sound = asset_server.load("sounds/timing_decide.ogg");
    commands.insert_resource(TimingSound(cue_timing_sound));
    // ...
}

fn main() {
    App::new()
        // ...
        .add_systems((
            play_timing_sound.after(check_for_collisions),
        ))
        // ...
}

fn decide_timing(
    // ...
    mut timing_events: EventWriter<TimingEvent>,
) {
    // ...
    if keyboard_input.just_pressed(KeyCode::Space) {
        // Sends a timing event so that other systems can react to the timing
        timing_events.send_default();
        // ...
    }
}

fn play_timing_sound(
    mut timing_events: EventReader<TimingEvent>,
    audio: Res<Audio>,
    sound: Res<TimingSound>,
) {
    // Play a sound once per frame if a timing occurred.
    if !timing_events.is_empty() {
        // This prevents events staying active on the next frame.
        timing_events.clear();
        audio.play(sound.0.clone());
    }
}