2020-11-27 12:39:33 -07:00
|
|
|
use bevy::{log::info, prelude::*};
|
|
|
|
|
|
|
|
fn main() {
|
2021-07-27 20:21:06 +00:00
|
|
|
App::new()
|
2020-11-27 12:39:33 -07:00
|
|
|
.add_plugins(DefaultPlugins)
|
2021-09-13 14:02:28 +00:00
|
|
|
.init_resource::<Countdown>()
|
2022-02-03 23:56:57 +00:00
|
|
|
.add_startup_system(setup)
|
|
|
|
.add_system(countdown)
|
|
|
|
.add_system(print_when_completed)
|
2020-11-27 12:39:33 -07:00
|
|
|
.run();
|
|
|
|
}
|
|
|
|
|
bevy_derive: Add derives for `Deref` and `DerefMut` (#4328)
# Objective
A common pattern in Rust is the [newtype](https://doc.rust-lang.org/rust-by-example/generics/new_types.html). This is an especially useful pattern in Bevy as it allows us to give common/foreign types different semantics (such as allowing it to implement `Component` or `FromWorld`) or to simply treat them as a "new type" (clever). For example, it allows us to wrap a common `Vec<String>` and do things like:
```rust
#[derive(Component)]
struct Items(Vec<String>);
fn give_sword(query: Query<&mut Items>) {
query.single_mut().0.push(String::from("Flaming Poisoning Raging Sword of Doom"));
}
```
> We could then define another struct that wraps `Vec<String>` without anything clashing in the query.
However, one of the worst parts of this pattern is the ugly `.0` we have to write in order to access the type we actually care about. This is why people often implement `Deref` and `DerefMut` in order to get around this.
Since it's such a common pattern, especially for Bevy, it makes sense to add a derive macro to automatically add those implementations.
## Solution
Added a derive macro for `Deref` and another for `DerefMut` (both exported into the prelude). This works on all structs (including tuple structs) as long as they only contain a single field:
```rust
#[derive(Deref)]
struct Foo(String);
#[derive(Deref, DerefMut)]
struct Bar {
name: String,
}
```
This allows us to then remove that pesky `.0`:
```rust
#[derive(Component, Deref, DerefMut)]
struct Items(Vec<String>);
fn give_sword(query: Query<&mut Items>) {
query.single_mut().push(String::from("Flaming Poisoning Raging Sword of Doom"));
}
```
### Alternatives
There are other alternatives to this such as by using the [`derive_more`](https://crates.io/crates/derive_more) crate. However, it doesn't seem like we need an entire crate just yet since we only need `Deref` and `DerefMut` (for now).
### Considerations
One thing to consider is that the Rust std library recommends _not_ using `Deref` and `DerefMut` for things like this: "`Deref` should only be implemented for smart pointers to avoid confusion" ([reference](https://doc.rust-lang.org/std/ops/trait.Deref.html)). Personally, I believe it makes sense to use it in the way described above, but others may disagree.
### Additional Context
Discord: https://discord.com/channels/691052431525675048/692572690833473578/956648422163746827 (controversiality discussed [here](https://discord.com/channels/691052431525675048/692572690833473578/956711911481835630))
---
## Changelog
- Add `Deref` derive macro (exported to prelude)
- Add `DerefMut` derive macro (exported to prelude)
- Updated most newtypes in examples to use one or both derives
Co-authored-by: MrGVSV <49806985+MrGVSV@users.noreply.github.com>
2022-03-29 02:10:06 +00:00
|
|
|
#[derive(Component, Deref, DerefMut)]
|
2022-02-03 23:56:57 +00:00
|
|
|
pub struct PrintOnCompletionTimer(Timer);
|
|
|
|
|
2020-11-27 12:39:33 -07:00
|
|
|
pub struct Countdown {
|
|
|
|
pub percent_trigger: Timer,
|
|
|
|
pub main_timer: Timer,
|
|
|
|
}
|
|
|
|
|
|
|
|
impl Countdown {
|
|
|
|
pub fn new() -> Self {
|
|
|
|
Self {
|
|
|
|
percent_trigger: Timer::from_seconds(4.0, true),
|
|
|
|
main_timer: Timer::from_seconds(20.0, false),
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
impl Default for Countdown {
|
|
|
|
fn default() -> Self {
|
|
|
|
Self::new()
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2022-02-03 23:56:57 +00:00
|
|
|
fn setup(mut commands: Commands) {
|
2020-11-27 12:39:33 -07:00
|
|
|
// Add an entity to the world with a timer
|
2022-02-03 23:56:57 +00:00
|
|
|
commands
|
|
|
|
.spawn()
|
|
|
|
.insert(PrintOnCompletionTimer(Timer::from_seconds(5.0, false)));
|
2020-11-27 12:39:33 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
/// This system ticks all the `Timer` components on entities within the scene
|
|
|
|
/// using bevy's `Time` resource to get the delta between each update.
|
2022-02-03 23:56:57 +00:00
|
|
|
fn print_when_completed(time: Res<Time>, mut query: Query<&mut PrintOnCompletionTimer>) {
|
2020-11-27 12:39:33 -07:00
|
|
|
for mut timer in query.iter_mut() {
|
bevy_derive: Add derives for `Deref` and `DerefMut` (#4328)
# Objective
A common pattern in Rust is the [newtype](https://doc.rust-lang.org/rust-by-example/generics/new_types.html). This is an especially useful pattern in Bevy as it allows us to give common/foreign types different semantics (such as allowing it to implement `Component` or `FromWorld`) or to simply treat them as a "new type" (clever). For example, it allows us to wrap a common `Vec<String>` and do things like:
```rust
#[derive(Component)]
struct Items(Vec<String>);
fn give_sword(query: Query<&mut Items>) {
query.single_mut().0.push(String::from("Flaming Poisoning Raging Sword of Doom"));
}
```
> We could then define another struct that wraps `Vec<String>` without anything clashing in the query.
However, one of the worst parts of this pattern is the ugly `.0` we have to write in order to access the type we actually care about. This is why people often implement `Deref` and `DerefMut` in order to get around this.
Since it's such a common pattern, especially for Bevy, it makes sense to add a derive macro to automatically add those implementations.
## Solution
Added a derive macro for `Deref` and another for `DerefMut` (both exported into the prelude). This works on all structs (including tuple structs) as long as they only contain a single field:
```rust
#[derive(Deref)]
struct Foo(String);
#[derive(Deref, DerefMut)]
struct Bar {
name: String,
}
```
This allows us to then remove that pesky `.0`:
```rust
#[derive(Component, Deref, DerefMut)]
struct Items(Vec<String>);
fn give_sword(query: Query<&mut Items>) {
query.single_mut().push(String::from("Flaming Poisoning Raging Sword of Doom"));
}
```
### Alternatives
There are other alternatives to this such as by using the [`derive_more`](https://crates.io/crates/derive_more) crate. However, it doesn't seem like we need an entire crate just yet since we only need `Deref` and `DerefMut` (for now).
### Considerations
One thing to consider is that the Rust std library recommends _not_ using `Deref` and `DerefMut` for things like this: "`Deref` should only be implemented for smart pointers to avoid confusion" ([reference](https://doc.rust-lang.org/std/ops/trait.Deref.html)). Personally, I believe it makes sense to use it in the way described above, but others may disagree.
### Additional Context
Discord: https://discord.com/channels/691052431525675048/692572690833473578/956648422163746827 (controversiality discussed [here](https://discord.com/channels/691052431525675048/692572690833473578/956711911481835630))
---
## Changelog
- Add `Deref` derive macro (exported to prelude)
- Add `DerefMut` derive macro (exported to prelude)
- Updated most newtypes in examples to use one or both derives
Co-authored-by: MrGVSV <49806985+MrGVSV@users.noreply.github.com>
2022-03-29 02:10:06 +00:00
|
|
|
if timer.tick(time.delta()).just_finished() {
|
2022-02-13 22:33:55 +00:00
|
|
|
info!("Entity timer just finished");
|
2020-11-27 12:39:33 -07:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/// This system controls ticking the timer within the countdown resource and
|
|
|
|
/// handling its state.
|
2022-02-03 23:56:57 +00:00
|
|
|
fn countdown(time: Res<Time>, mut countdown: ResMut<Countdown>) {
|
2021-03-05 19:59:14 +00:00
|
|
|
countdown.main_timer.tick(time.delta());
|
2020-11-27 12:39:33 -07:00
|
|
|
|
|
|
|
// The API encourages this kind of timer state checking (if you're only checking for one value)
|
2021-03-11 00:27:30 +00:00
|
|
|
// Additionally, `finished()` would accomplish the same thing as `just_finished` due to the
|
|
|
|
// timer being repeating, however this makes more sense visually.
|
2021-03-05 19:59:14 +00:00
|
|
|
if countdown.percent_trigger.tick(time.delta()).just_finished() {
|
2020-11-27 12:39:33 -07:00
|
|
|
if !countdown.main_timer.finished() {
|
|
|
|
// Print the percent complete the main timer is.
|
|
|
|
info!(
|
|
|
|
"Timer is {:0.0}% complete!",
|
|
|
|
countdown.main_timer.percent() * 100.0
|
|
|
|
);
|
|
|
|
} else {
|
|
|
|
// The timer has finished so we pause the percent output timer
|
|
|
|
countdown.percent_trigger.pause();
|
2022-02-13 22:33:55 +00:00
|
|
|
info!("Paused percent trigger timer");
|
2020-11-27 12:39:33 -07:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|