mirror of
https://github.com/bevyengine/bevy
synced 2024-11-22 20:53:53 +00:00
73605f43b6
As mentioned in #2926, it's better to have an explicit type that clearly communicates the intent of the timer mode rather than an opaque boolean, which can be only understood when knowing the signature or having to look up the documentation. This also opens up a way to merge different timers, such as `Stopwatch`, and possibly future ones, such as `DiscreteStopwatch` and `DiscreteTimer` from #2683, into one struct. Signed-off-by: Lena Milizé <me@lvmn.org> # Objective Fixes #2926. ## Solution Introduce `TimerMode` which replaces the `bool` argument of `Timer` constructors. A `Default` value for `TimerMode` is `Once`. --- ## Changelog ### Added - `TimerMode` enum, along with variants `TimerMode::Once` and `TimerMode::Repeating` ### Changed - Replace `bool` argument of `Timer::new` and `Timer::from_seconds` with `TimerMode` - Change `repeating: bool` field of `Timer` with `mode: TimerMode` ## Migration Guide - Replace `Timer::new(duration, false)` with `Timer::new(duration, TimerMode::Once)`. - Replace `Timer::new(duration, true)` with `Timer::new(duration, TimerMode::Repeating)`. - Replace `Timer::from_seconds(seconds, false)` with `Timer::from_seconds(seconds, TimerMode::Once)`. - Replace `Timer::from_seconds(seconds, true)` with `Timer::from_seconds(seconds, TimerMode::Repeating)`. - Change `timer.repeating()` to `timer.mode() == TimerMode::Repeating`.
89 lines
2.9 KiB
Rust
89 lines
2.9 KiB
Rust
//! Generic types allow us to reuse logic across many related systems,
|
|
//! allowing us to specialize our function's behavior based on which type (or types) are passed in.
|
|
//!
|
|
//! This is commonly useful for working on related components or resources,
|
|
//! where we want to have unique types for querying purposes but want them all to work the same way.
|
|
//! This is particularly powerful when combined with user-defined traits to add more functionality to these related types.
|
|
//! Remember to insert a specialized copy of the system into the schedule for each type that you want to operate on!
|
|
//!
|
|
//! For more advice on working with generic types in Rust, check out <https://doc.rust-lang.org/book/ch10-01-syntax.html>
|
|
//! or <https://doc.rust-lang.org/rust-by-example/generics.html>
|
|
|
|
use bevy::prelude::*;
|
|
|
|
#[derive(Debug, Clone, Eq, PartialEq, Hash)]
|
|
enum AppState {
|
|
MainMenu,
|
|
InGame,
|
|
}
|
|
|
|
#[derive(Component)]
|
|
struct TextToPrint(String);
|
|
|
|
#[derive(Component, Deref, DerefMut)]
|
|
struct PrinterTick(Timer);
|
|
|
|
#[derive(Component)]
|
|
struct MenuClose;
|
|
|
|
#[derive(Component)]
|
|
struct LevelUnload;
|
|
|
|
fn main() {
|
|
App::new()
|
|
.add_plugins(DefaultPlugins)
|
|
.add_state(AppState::MainMenu)
|
|
.add_startup_system(setup_system)
|
|
.add_system(print_text_system)
|
|
.add_system_set(
|
|
SystemSet::on_update(AppState::MainMenu).with_system(transition_to_in_game_system),
|
|
)
|
|
// add the cleanup systems
|
|
.add_system_set(
|
|
// Pass in the types your system should operate on using the ::<T> (turbofish) syntax
|
|
SystemSet::on_exit(AppState::MainMenu).with_system(cleanup_system::<MenuClose>),
|
|
)
|
|
.add_system_set(
|
|
SystemSet::on_exit(AppState::InGame).with_system(cleanup_system::<LevelUnload>),
|
|
)
|
|
.run();
|
|
}
|
|
|
|
fn setup_system(mut commands: Commands) {
|
|
commands.spawn((
|
|
PrinterTick(Timer::from_seconds(1.0, TimerMode::Repeating)),
|
|
TextToPrint("I will print until you press space.".to_string()),
|
|
MenuClose,
|
|
));
|
|
|
|
commands.spawn((
|
|
PrinterTick(Timer::from_seconds(1.0, TimerMode::Repeating)),
|
|
TextToPrint("I will always print".to_string()),
|
|
LevelUnload,
|
|
));
|
|
}
|
|
|
|
fn print_text_system(time: Res<Time>, mut query: Query<(&mut PrinterTick, &TextToPrint)>) {
|
|
for (mut timer, text) in &mut query {
|
|
if timer.tick(time.delta()).just_finished() {
|
|
info!("{}", text.0);
|
|
}
|
|
}
|
|
}
|
|
|
|
fn transition_to_in_game_system(
|
|
mut state: ResMut<State<AppState>>,
|
|
keyboard_input: Res<Input<KeyCode>>,
|
|
) {
|
|
if keyboard_input.pressed(KeyCode::Space) {
|
|
state.set(AppState::InGame).unwrap();
|
|
}
|
|
}
|
|
|
|
// Type arguments on functions come after the function name, but before ordinary arguments.
|
|
// Here, the `Component` trait is a trait bound on T, our generic type
|
|
fn cleanup_system<T: Component>(mut commands: Commands, query: Query<Entity, With<T>>) {
|
|
for e in &query {
|
|
commands.entity(e).despawn_recursive();
|
|
}
|
|
}
|