Vendor dependencies for 0.3.0 release

vendor/bevy/examples/time/time.rs

@@ -0,0 +1,121 @@
+//! An example that illustrates how Time is handled in ECS.
+
+use bevy::{app::AppExit, prelude::*};
+
+use std::{
+    io::{self, BufRead},
+    time::Duration,
+};
+
+fn banner() {
+    println!("This example is meant to intuitively demonstrate how Time works in Bevy.");
+    println!();
+    println!("Time will be printed in three different schedules in the app:");
+    println!("- PreUpdate: real time is printed");
+    println!("- FixedUpdate: fixed time step time is printed, may be run zero or multiple times");
+    println!("- Update: virtual game time is printed");
+    println!();
+    println!("Max delta time is set to 5 seconds. Fixed timestep is set to 1 second.");
+    println!();
+}
+
+fn help() {
+    println!("The app reads commands line-by-line from standard input.");
+    println!();
+    println!("Commands:");
+    println!("  empty line: Run app.update() once on the Bevy App");
+    println!("  q: Quit the app.");
+    println!("  f: Set speed to fast, 2x");
+    println!("  n: Set speed to normal, 1x");
+    println!("  s: Set speed to slow, 0.5x");
+    println!("  p: Pause");
+    println!("  u: Unpause");
+}
+
+fn runner(mut app: App) -> AppExit {
+    banner();
+    help();
+    let stdin = io::stdin();
+    for line in stdin.lock().lines() {
+        if let Err(err) = line {
+            println!("read err: {err:#}");
+            break;
+        }
+        match line.unwrap().as_str() {
+            "" => {
+                app.update();
+            }
+            "f" => {
+                println!("FAST: setting relative speed to 2x");
+                app.world_mut()
+                    .resource_mut::<Time<Virtual>>()
+                    .set_relative_speed(2.0);
+            }
+            "n" => {
+                println!("NORMAL: setting relative speed to 1x");
+                app.world_mut()
+                    .resource_mut::<Time<Virtual>>()
+                    .set_relative_speed(1.0);
+            }
+            "s" => {
+                println!("SLOW: setting relative speed to 0.5x");
+                app.world_mut()
+                    .resource_mut::<Time<Virtual>>()
+                    .set_relative_speed(0.5);
+            }
+            "p" => {
+                println!("PAUSE: pausing virtual clock");
+                app.world_mut().resource_mut::<Time<Virtual>>().pause();
+            }
+            "u" => {
+                println!("UNPAUSE: resuming virtual clock");
+                app.world_mut().resource_mut::<Time<Virtual>>().unpause();
+            }
+            "q" => {
+                println!("QUITTING!");
+                break;
+            }
+            _ => {
+                help();
+            }
+        }
+    }
+
+    AppExit::Success
+}
+
+fn print_real_time(time: Res<Time<Real>>) {
+    println!(
+        "PreUpdate: this is real time clock, delta is {:?} and elapsed is {:?}",
+        time.delta(),
+        time.elapsed()
+    );
+}
+
+fn print_fixed_time(time: Res<Time>) {
+    println!(
+        "FixedUpdate: this is generic time clock inside fixed, delta is {:?} and elapsed is {:?}",
+        time.delta(),
+        time.elapsed()
+    );
+}
+
+fn print_time(time: Res<Time>) {
+    println!(
+        "Update: this is generic time clock, delta is {:?} and elapsed is {:?}",
+        time.delta(),
+        time.elapsed()
+    );
+}
+
+fn main() {
+    App::new()
+        .add_plugins(MinimalPlugins)
+        .insert_resource(Time::<Virtual>::from_max_delta(Duration::from_secs(5)))
+        .insert_resource(Time::<Fixed>::from_duration(Duration::from_secs(1)))
+        .add_systems(PreUpdate, print_real_time)
+        .add_systems(FixedUpdate, print_fixed_time)
+        .add_systems(Update, print_time)
+        .set_runner(runner)
+        .run();
+}

vendor/bevy/examples/time/timers.rs

@@ -0,0 +1,77 @@
+//! Illustrates how `Timer`s can be used both as resources and components.
+
+use bevy::{log::info, prelude::*};
+
+fn main() {
+    App::new()
+        .add_plugins(DefaultPlugins)
+        .init_resource::<Countdown>()
+        .add_systems(Startup, setup)
+        .add_systems(Update, (countdown, print_when_completed))
+        .run();
+}
+
+#[derive(Component, Deref, DerefMut)]
+struct PrintOnCompletionTimer(Timer);
+
+#[derive(Resource)]
+struct Countdown {
+    percent_trigger: Timer,
+    main_timer: Timer,
+}
+
+impl Countdown {
+    pub fn new() -> Self {
+        Self {
+            percent_trigger: Timer::from_seconds(4.0, TimerMode::Repeating),
+            main_timer: Timer::from_seconds(20.0, TimerMode::Once),
+        }
+    }
+}
+
+impl Default for Countdown {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
+fn setup(mut commands: Commands) {
+    // Add an entity to the world with a timer
+    commands.spawn(PrintOnCompletionTimer(Timer::from_seconds(
+        5.0,
+        TimerMode::Once,
+    )));
+}
+
+/// This system ticks the `Timer` on the entity with the `PrintOnCompletionTimer`
+/// component using bevy's `Time` resource to get the delta between each update.
+fn print_when_completed(time: Res<Time>, mut query: Query<&mut PrintOnCompletionTimer>) {
+    for mut timer in &mut query {
+        if timer.tick(time.delta()).just_finished() {
+            info!("Entity timer just finished");
+        }
+    }
+}
+
+/// This system controls ticking the timer within the countdown resource and
+/// handling its state.
+fn countdown(time: Res<Time>, mut countdown: ResMut<Countdown>) {
+    countdown.main_timer.tick(time.delta());
+
+    // The API encourages this kind of timer state checking (if you're only checking for one value)
+    // Additionally, `finished()` would accomplish the same thing as `just_finished` due to the
+    // timer being repeating, however this makes more sense visually.
+    if countdown.percent_trigger.tick(time.delta()).just_finished() {
+        if !countdown.main_timer.finished() {
+            // Print the percent complete the main timer is.
+            info!(
+                "Timer is {:0.0}% complete!",
+                countdown.main_timer.fraction() * 100.0
+            );
+        } else {
+            // The timer has finished so we pause the percent output timer
+            countdown.percent_trigger.pause();
+            info!("Paused percent trigger timer");
+        }
+    }
+}

vendor/bevy/examples/time/virtual_time.rs

@@ -0,0 +1,199 @@
+//! Shows how `Time<Virtual>` can be used to pause, resume, slow down
+//! and speed up a game.
+
+use std::time::Duration;
+
+use bevy::{
+    color::palettes::css::*, input::common_conditions::input_just_pressed, prelude::*,
+    time::common_conditions::on_real_timer,
+};
+
+fn main() {
+    App::new()
+        .add_plugins(DefaultPlugins)
+        .add_systems(Startup, setup)
+        .add_systems(
+            Update,
+            (
+                move_virtual_time_sprites,
+                move_real_time_sprites,
+                toggle_pause.run_if(input_just_pressed(KeyCode::Space)),
+                change_time_speed::<1>.run_if(input_just_pressed(KeyCode::ArrowUp)),
+                change_time_speed::<-1>.run_if(input_just_pressed(KeyCode::ArrowDown)),
+                (update_virtual_time_info_text, update_real_time_info_text)
+                    // update the texts on a timer to make them more readable
+                    // `on_timer` run condition uses `Virtual` time meaning it's scaled
+                    // and would result in the UI updating at different intervals based
+                    // on `Time<Virtual>::relative_speed` and `Time<Virtual>::is_paused()`
+                    .run_if(on_real_timer(Duration::from_millis(250))),
+            ),
+        )
+        .run();
+}
+
+/// `Real` time related marker
+#[derive(Component)]
+struct RealTime;
+
+/// `Virtual` time related marker
+#[derive(Component)]
+struct VirtualTime;
+
+/// Setup the example
+fn setup(mut commands: Commands, asset_server: Res<AssetServer>, mut time: ResMut<Time<Virtual>>) {
+    // start with double `Virtual` time resulting in one of the sprites moving at twice the speed
+    // of the other sprite which moves based on `Real` (unscaled) time
+    time.set_relative_speed(2.);
+
+    commands.spawn(Camera2d);
+
+    let virtual_color = GOLD.into();
+    let sprite_scale = Vec2::splat(0.5).extend(1.);
+    let texture_handle = asset_server.load("branding/icon.png");
+
+    // the sprite moving based on real time
+    commands.spawn((
+        Sprite::from_image(texture_handle.clone()),
+        Transform::from_scale(sprite_scale),
+        RealTime,
+    ));
+
+    // the sprite moving based on virtual time
+    commands.spawn((
+        Sprite {
+            image: texture_handle,
+            color: virtual_color,
+            ..Default::default()
+        },
+        Transform {
+            scale: sprite_scale,
+            translation: Vec3::new(0., -160., 0.),
+            ..default()
+        },
+        VirtualTime,
+    ));
+
+    // info UI
+    let font_size = 33.;
+
+    commands.spawn((
+        Node {
+            display: Display::Flex,
+            justify_content: JustifyContent::SpaceBetween,
+            width: Val::Percent(100.),
+            position_type: PositionType::Absolute,
+            top: Val::Px(0.),
+            padding: UiRect::all(Val::Px(20.0)),
+            ..default()
+        },
+        children![
+            (
+                Text::default(),
+                TextFont {
+                    font_size,
+                    ..default()
+                },
+                RealTime,
+            ),
+            (
+                Text::new("CONTROLS\nUn/Pause: Space\nSpeed+: Up\nSpeed-: Down"),
+                TextFont {
+                    font_size,
+                    ..default()
+                },
+                TextColor(Color::srgb(0.85, 0.85, 0.85)),
+                TextLayout::new_with_justify(JustifyText::Center),
+            ),
+            (
+                Text::default(),
+                TextFont {
+                    font_size,
+                    ..default()
+                },
+                TextColor(virtual_color),
+                TextLayout::new_with_justify(JustifyText::Right),
+                VirtualTime,
+            ),
+        ],
+    ));
+}
+
+/// Move sprites using `Real` (unscaled) time
+fn move_real_time_sprites(
+    mut sprite_query: Query<&mut Transform, (With<Sprite>, With<RealTime>)>,
+    // `Real` time which is not scaled or paused
+    time: Res<Time<Real>>,
+) {
+    for mut transform in sprite_query.iter_mut() {
+        // move roughly half the screen in a `Real` second
+        // when the time is scaled the speed is going to change
+        // and the sprite will stay still the time is paused
+        transform.translation.x = get_sprite_translation_x(time.elapsed_secs());
+    }
+}
+
+/// Move sprites using `Virtual` (scaled) time
+fn move_virtual_time_sprites(
+    mut sprite_query: Query<&mut Transform, (With<Sprite>, With<VirtualTime>)>,
+    // the default `Time` is either `Time<Virtual>` in regular systems
+    // or `Time<Fixed>` in fixed timestep systems so `Time::delta()`,
+    // `Time::elapsed()` will return the appropriate values either way
+    time: Res<Time>,
+) {
+    for mut transform in sprite_query.iter_mut() {
+        // move roughly half the screen in a `Virtual` second
+        // when time is scaled using `Time<Virtual>::set_relative_speed` it's going
+        // to move at a different pace and the sprite will stay still when time is
+        // `Time<Virtual>::is_paused()`
+        transform.translation.x = get_sprite_translation_x(time.elapsed_secs());
+    }
+}
+
+fn get_sprite_translation_x(elapsed: f32) -> f32 {
+    ops::sin(elapsed) * 500.
+}
+
+/// Update the speed of `Time<Virtual>.` by `DELTA`
+fn change_time_speed<const DELTA: i8>(mut time: ResMut<Time<Virtual>>) {
+    let time_speed = (time.relative_speed() + DELTA as f32)
+        .round()
+        .clamp(0.25, 5.);
+
+    // set the speed of the virtual time to speed it up or slow it down
+    time.set_relative_speed(time_speed);
+}
+
+/// pause or resume `Relative` time
+fn toggle_pause(mut time: ResMut<Time<Virtual>>) {
+    if time.is_paused() {
+        time.unpause();
+    } else {
+        time.pause();
+    }
+}
+
+/// Update the `Real` time info text
+fn update_real_time_info_text(time: Res<Time<Real>>, mut query: Query<&mut Text, With<RealTime>>) {
+    for mut text in &mut query {
+        **text = format!(
+            "REAL TIME\nElapsed: {:.1}\nDelta: {:.5}\n",
+            time.elapsed_secs(),
+            time.delta_secs(),
+        );
+    }
+}
+
+/// Update the `Virtual` time info text
+fn update_virtual_time_info_text(
+    time: Res<Time<Virtual>>,
+    mut query: Query<&mut Text, With<VirtualTime>>,
+) {
+    for mut text in &mut query {
+        **text = format!(
+            "VIRTUAL TIME\nElapsed: {:.1}\nDelta: {:.5}\nSpeed: {:.2}",
+            time.elapsed_secs(),
+            time.delta_secs(),
+            time.relative_speed()
+        );
+    }
+}