pop
/
games
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

bevy 0.16 -> 0.17 saving my place

Browse Source
main
Elijah Voigt 3 months ago
parent 96583f4cea
commit 1e2d37ed60
15 changed files with 1055 additions and 653 deletions
Show Stats Download Patch File Download Diff File

1288
Cargo.lock generated
View File

File diff suppressed because it is too large Load Diff

6
Cargo.toml
Unescape Escape View File

@ -23,13 +23,13 @@ version = "1.0.219"
features = ["derive"] features = ["derive"]
[dependencies.avian3d] [dependencies.avian3d]
version = "0.3.1" version = "0.4.1"
[dependencies.avian2d] [dependencies.avian2d]
version = "0.3.1" version = "0.4.1"
[dependencies.bevy] [dependencies.bevy]
version = "0.16.1" version = "0.17.2"
features = ["wayland", "dynamic_linking"] features = ["wayland", "dynamic_linking"]
[dev-dependencies] [dev-dependencies]

4
examples/demos/parallax2d.rs
Unescape Escape View File

@ -78,7 +78,7 @@ fn move_camera(keys: Res<ButtonInput<KeyCode>>, mut camera: Single<&mut Transfor
} }
} }
#[derive(Event)] #[derive(Message)]
struct CameraMovement(Vec3); struct CameraMovement(Vec3);
fn track_camera_movement( fn track_camera_movement(
@ -93,7 +93,7 @@ fn track_camera_movement(
} }
fn parallax( fn parallax(
mut events: EventReader<CameraMovement>, mut events: MessageReader<CameraMovement>,
mut query: Query<(&mut Transform, &ParallaxDistance)>, mut query: Query<(&mut Transform, &ParallaxDistance)>,
) { ) {
events.read().for_each(|CameraMovement(v)| { events.read().for_each(|CameraMovement(v)| {

12
examples/scroll.rs
Unescape Escape View File

@ -14,7 +14,7 @@ fn main() {
.add_systems(Update, draw_gizmos) .add_systems(Update, draw_gizmos)
.add_systems( .add_systems(
Update, Update,
event_detection.run_if(on_event::<CollisionStarted>.or(on_event::<CollisionEnded>)), event_detection.run_if(on_message::<CollisionStarted>.or(on_message::<CollisionEnded>)),
) )
.add_observer(set_tree_position) .add_observer(set_tree_position)
.run(); .run();
@ -88,18 +88,18 @@ fn setup(
} }
fn set_tree_position( fn set_tree_position(
trigger: Trigger<OnAdd, TreePos>, event: On<Add, TreePos>,
tree_pos: Query<&TreePos>, tree_pos: Query<&TreePos>,
mut commands: Commands, mut commands: Commands,
) { ) {
let TreePos(pos) = tree_pos.get(trigger.target()).unwrap(); let TreePos(pos) = tree_pos.get(event.entity).unwrap();
let x = if (*pos) > 0 { let x = if (*pos) > 0 {
(200.0 * (*pos) as f32) - 100.0 (200.0 * (*pos) as f32) - 100.0
} else { } else {
(200.0 * (*pos) as f32) + 100.0 (200.0 * (*pos) as f32) + 100.0
}; };
let t = Transform::from_xyz(x, 0.0, 0.0); let t = Transform::from_xyz(x, 0.0, 0.0);
commands.entity(trigger.target()).insert(t); commands.entity(event.entity).insert(t);
} }
fn move_player( fn move_player(
@ -132,8 +132,8 @@ fn draw_gizmos(mut gizmos: Gizmos, play_area: Single<&GlobalTransform, With<Rend
} }
fn event_detection( fn event_detection(
mut start_events: EventReader<CollisionStarted>, mut start_events: MessageReader<CollisionStarted>,
mut end_events: EventReader<CollisionEnded>, mut end_events: MessageReader<CollisionEnded>,
player: Single<&Player>, player: Single<&Player>,
trees: Query<&TreePos>, trees: Query<&TreePos>,
keyboard_input: Res<ButtonInput<KeyCode>>, keyboard_input: Res<ButtonInput<KeyCode>>,

2
examples/sensors.rs
Unescape Escape View File

@ -191,7 +191,7 @@ impl Display for InsideArea {
/// Read collision events and procss them into resource updates to be displayed to the user /// Read collision events and procss them into resource updates to be displayed to the user
fn process_events( fn process_events(
mut events: EventReader<CollisionEvent>, mut events: MessageReader<CollisionEvent>,
areas: Query<&AreaMarker>, areas: Query<&AreaMarker>,
mut inside: ResMut<InsideArea>, mut inside: ResMut<InsideArea>,
) { ) {

4
examples/sync_resource_to_ui.rs
Unescape Escape View File

@ -9,7 +9,7 @@ fn main() {
Update, Update,
( (
sync_resource_to_ui::<Thing>.run_if(resource_changed::<Thing>), sync_resource_to_ui::<Thing>.run_if(resource_changed::<Thing>),
update_foo.run_if(on_event::<MouseMotion>), update_foo.run_if(on_message::<MouseMotion>),
), ),
) )
.run(); .run();
@ -44,7 +44,7 @@ fn init_ui(mut commands: Commands) {
)); ));
} }
fn update_foo(mut events: EventReader<MouseMotion>, mut thing: ResMut<Thing>) { fn update_foo(mut events: MessageReader<MouseMotion>, mut thing: ResMut<Thing>) {
events.read().for_each(|_| { events.read().for_each(|_| {
thing.0 = thing.0.overflowing_add(1).0; thing.0 = thing.0.overflowing_add(1).0;
}); });

6
examples/ui.rs
Unescape Escape View File

@ -15,7 +15,7 @@ fn main() {
Update, Update,
( (
hide_menu, hide_menu,
control_menu.run_if(on_event::<Pointer<Over>>.or(on_event::<Pointer<Out>>)), control_menu.run_if(on_message::<Pointer<Over>>.or(on_message::<Pointer<Out>>)),
), ),
); );
app.run(); app.run();
@ -129,8 +129,8 @@ fn hide_menu(mut nodes: Query<(&mut Visibility, &NavState), Changed<NavState>>)
// When you pointer goes off of the '+' or any of it's children make the entire menu invisible // When you pointer goes off of the '+' or any of it's children make the entire menu invisible
fn control_menu( fn control_menu(
mut over_events: EventReader<Pointer<Over>>, mut over_events: MessageReader<Pointer<Over>>,
mut out_events: EventReader<Pointer<Out>>, mut out_events: MessageReader<Pointer<Out>>,
children: Query<&ChildOf>, children: Query<&ChildOf>,
parents: Query<&Children>, parents: Query<&Children>,
mut nav: Query<&mut NavState>, mut nav: Query<&mut NavState>,

90
src/bin/flappy/main.rs
Unescape Escape View File

@ -99,8 +99,8 @@ fn main() {
(update_tooltip, debug_trail).run_if(in_state(DebuggingState::On)), (update_tooltip, debug_trail).run_if(in_state(DebuggingState::On)),
// TODO: Add run_if to this system // TODO: Add run_if to this system
update_batch_position.run_if(any_component_changed::<Batch>), update_batch_position.run_if(any_component_changed::<Batch>),
move_batches.run_if(on_event::<CollisionStarted>.or(on_event::<CollisionEnded>)), move_batches.run_if(on_message::<CollisionStarted>.or(on_message::<CollisionEnded>)),
manage_score.run_if(on_event::<CollisionStarted>.or(on_event::<CollisionEnded>)), manage_score.run_if(on_message::<CollisionStarted>.or(on_message::<CollisionEnded>)),
shimmer_button::<RewindButton>.run_if(in_state(PlayerState::Stasis)), shimmer_button::<RewindButton>.run_if(in_state(PlayerState::Stasis)),
shimmer_button::<FlapButton>.run_if(in_state(PlayerState::Pause)), shimmer_button::<FlapButton>.run_if(in_state(PlayerState::Pause)),
), ),
@ -265,20 +265,20 @@ fn init_first_batches(mut commands: Commands) {
/// * The pipe obstacle /// * The pipe obstacle
/// * The pipe scoring sensor /// * The pipe scoring sensor
/// ///
/// These are all populated via `OnAdd` observers for the respected components. /// These are all populated via `On<Add, >` observers for the respected components.
/// This makes it much more concise to spawn each part of the environment. /// This makes it much more concise to spawn each part of the environment.
fn populate_batch( fn populate_batch(
trigger: Trigger<OnAdd, Batch>, event: On<Add, Batch>,
batches: Query<&Batch>, batches: Query<&Batch>,
children: Query<&ChildOf>, children: Query<&ChildOf>,
mut commands: Commands, mut commands: Commands,
) { ) {
// Only run this for top level batch entities, // Only run this for top level batch entities,
// not children containing a reference to their batch, like hitboxes // not children containing a reference to their batch, like hitboxes
if !children.contains(trigger.target()) { if !children.contains(event.entity) {
let Batch(batch_id) = batches.get(trigger.target()).unwrap(); let Batch(batch_id) = batches.get(event.entity).unwrap();
commands commands
.entity(trigger.target()) .entity(event.entity)
.insert(( .insert((
Transform::from_xyz(500.0 * (*batch_id) as f32, 0.0, 0.0), Transform::from_xyz(500.0 * (*batch_id) as f32, 0.0, 0.0),
Visibility::Inherited, Visibility::Inherited,
@ -313,14 +313,14 @@ fn update_batch_position(
} }
fn populate_ground( fn populate_ground(
trigger: Trigger<OnAdd, Ground>, event: On<Add, Ground>,
grounds: Query<&Ground>, grounds: Query<&Ground>,
ground_assets: Res<GroundAssets>, ground_assets: Res<GroundAssets>,
mut commands: Commands, mut commands: Commands,
) { ) {
let Ground(idx) = grounds.get(trigger.target()).unwrap(); let Ground(idx) = grounds.get(event.entity).unwrap();
debug!("populating ground {:?}", idx); debug!("populating ground {:?}", idx);
commands.entity(trigger.target()).insert(( commands.entity(event.entity).insert((
ground_assets.material.clone(), ground_assets.material.clone(),
ground_assets.mesh.clone(), ground_assets.mesh.clone(),
Name::new("ground"), Name::new("ground"),
@ -331,14 +331,14 @@ fn populate_ground(
} }
fn populate_ceiling( fn populate_ceiling(
trigger: Trigger<OnAdd, Ceiling>, event: On<Add, Ceiling>,
ceiling: Query<&Ceiling>, ceiling: Query<&Ceiling>,
ceiling_assets: Res<CeilingAssets>, ceiling_assets: Res<CeilingAssets>,
mut commands: Commands, mut commands: Commands,
) { ) {
let Ceiling(idx) = ceiling.get(trigger.target()).unwrap(); let Ceiling(idx) = ceiling.get(event.entity).unwrap();
debug!("populating ceiling{:?}", idx); debug!("populating ceiling{:?}", idx);
commands.entity(trigger.target()).insert(( commands.entity(event.entity).insert((
ceiling_assets.material.clone(), ceiling_assets.material.clone(),
ceiling_assets.mesh.clone(), ceiling_assets.mesh.clone(),
Name::new("ceiling"), Name::new("ceiling"),
@ -349,11 +349,11 @@ fn populate_ceiling(
} }
fn move_pipe( fn move_pipe(
trigger: Trigger<OnInsert, Batch>, event: On<OnInsert, Batch>,
mut pipes: Query<(&Batch, &Pipe, &mut Transform)>, mut pipes: Query<(&Batch, &Pipe, &mut Transform)>,
rand: Res<Rand>, rand: Res<Rand>,
) { ) {
if let Ok((Batch(id), pipe, mut pipe_t)) = pipes.get_mut(trigger.target()) { if let Ok((Batch(id), pipe, mut pipe_t)) = pipes.get_mut(event.entity) {
*pipe_t = *pipe_t =
{ {
let offset = { let offset = {
@ -382,14 +382,14 @@ fn move_pipe(
/// Based on if this is a Top or Bottom pipe the placement changes /// Based on if this is a Top or Bottom pipe the placement changes
/// Otherwise this just spawns in the center of the batch. /// Otherwise this just spawns in the center of the batch.
fn populate_pipe( fn populate_pipe(
trigger: Trigger<OnAdd, Pipe>, event: On<Add, Pipe>,
pipes: Query<(&Batch, &Pipe)>, pipes: Query<(&Batch, &Pipe)>,
pipe_assets: Res<PipeAssets>, pipe_assets: Res<PipeAssets>,
mut commands: Commands, mut commands: Commands,
rand: Res<Rand>, rand: Res<Rand>,
) { ) {
let pipe_t = { let pipe_t = {
let (Batch(id), pipe) = pipes.get(trigger.target()).unwrap(); let (Batch(id), pipe) = pipes.get(event.entity).unwrap();
let offset = { let offset = {
let val = rand.0.hash_one(id); let val = rand.0.hash_one(id);
@ -413,7 +413,7 @@ fn populate_pipe(
} }
}; };
commands.entity(trigger.target()).insert(( commands.entity(event.entity).insert((
pipe_t, pipe_t,
pipe_assets.material.clone(), pipe_assets.material.clone(),
pipe_assets.mesh.clone(), pipe_assets.mesh.clone(),
@ -425,8 +425,8 @@ fn populate_pipe(
/// The hitbox should cover the entire height of the screen so if the player /// The hitbox should cover the entire height of the screen so if the player
/// passes between the pipes it registers a point /// passes between the pipes it registers a point
fn populate_hitbox(trigger: Trigger<OnAdd, Hitbox>, mut commands: Commands) { fn populate_hitbox(event: On<Add, Hitbox>, mut commands: Commands) {
commands.entity(trigger.target()).insert(( commands.entity(event.entity).insert((
RigidBody::Static, RigidBody::Static,
Collider::rectangle(1.0, 10.0), Collider::rectangle(1.0, 10.0),
Sensor, Sensor,
@ -517,7 +517,7 @@ fn init_ui(mut commands: Commands, server: Res<AssetServer>) {
}, },
BorderRadius::all(Val::Px(5.0)), BorderRadius::all(Val::Px(5.0)),
BackgroundColor(Color::WHITE), BackgroundColor(Color::WHITE),
BorderColor(BLACK.into()), BorderColor::all(BLACK),
PlayerState::Stasis, PlayerState::Stasis,
)) ))
.with_children(|parent| { .with_children(|parent| {
@ -569,7 +569,7 @@ fn init_ui(mut commands: Commands, server: Res<AssetServer>) {
},)) },))
.with_children(|parent| { .with_children(|parent| {
fn show_credits( fn show_credits(
_trigger: Trigger<Pointer<Click>>, _event: On<Pointer<Click>>,
mut state: ResMut<NextState<PlayerState>>, mut state: ResMut<NextState<PlayerState>>,
) { ) {
state.set(PlayerState::Credits); state.set(PlayerState::Credits);
@ -579,7 +579,7 @@ fn init_ui(mut commands: Commands, server: Res<AssetServer>) {
.spawn(( .spawn((
Button, Button,
BorderRadius::all(Val::Px(5.0)), BorderRadius::all(Val::Px(5.0)),
BorderColor(BLACK.into()), BorderColor::all(BLACK),
Node { ..default() }, Node { ..default() },
children![(TextColor(BLACK.into()), Text::new("Credits")),], children![(TextColor(BLACK.into()), Text::new("Credits")),],
)) ))
@ -588,7 +588,7 @@ fn init_ui(mut commands: Commands, server: Res<AssetServer>) {
#[cfg(not(target_arch = "wasm32"))] #[cfg(not(target_arch = "wasm32"))]
{ {
fn quit_game( fn quit_game(
_trigger: Trigger<Pointer<Click>>, _event: On<Pointer<Click>>,
mut exit: EventWriter<AppExit>, mut exit: EventWriter<AppExit>,
) { ) {
warn!("Quitting game"); warn!("Quitting game");
@ -598,7 +598,7 @@ fn init_ui(mut commands: Commands, server: Res<AssetServer>) {
parent parent
.spawn(( .spawn((
BorderRadius::all(Val::Px(5.0)), BorderRadius::all(Val::Px(5.0)),
BorderColor(BLACK.into()), BorderColor::all(BLACK),
Button, Button,
Node { ..default() }, Node { ..default() },
children![(Text::new("Quit"), TextColor(BLACK.into()))], children![(Text::new("Quit"), TextColor(BLACK.into()))],
@ -608,7 +608,7 @@ fn init_ui(mut commands: Commands, server: Res<AssetServer>) {
}); });
}); });
fn hide_credits(_trigger: Trigger<Pointer<Click>>, mut state: ResMut<NextState<PlayerState>>) { fn hide_credits(_event: On<Pointer<Click>>, mut state: ResMut<NextState<PlayerState>>) {
state.set(PlayerState::Stasis) state.set(PlayerState::Stasis)
} }
@ -624,7 +624,7 @@ fn init_ui(mut commands: Commands, server: Res<AssetServer>) {
}, },
BorderRadius::all(Val::Px(5.0)), BorderRadius::all(Val::Px(5.0)),
BackgroundColor(WHITE.into()), BackgroundColor(WHITE.into()),
BorderColor(BLACK.into()), BorderColor::all(BLACK),
PlayerState::Credits, PlayerState::Credits,
children![( children![(
Text::new(credits_str), Text::new(credits_str),
@ -639,7 +639,7 @@ fn init_ui(mut commands: Commands, server: Res<AssetServer>) {
..default() ..default()
}, },
BorderRadius::all(Val::Px(5.0)), BorderRadius::all(Val::Px(5.0)),
BorderColor(BLACK.into()), BorderColor::all(BLACK),
Button, Button,
children![(Text::new("Close"), TextColor(BLACK.into()))], children![(Text::new("Close"), TextColor(BLACK.into()))],
)); ));
@ -679,7 +679,7 @@ fn init_ui(mut commands: Commands, server: Res<AssetServer>) {
..default() ..default()
}, },
BorderRadius::all(Val::Px(5.0)), BorderRadius::all(Val::Px(5.0)),
BorderColor(BLACK.into()), BorderColor::all(BLACK),
Text::new("(paused)"), Text::new("(paused)"),
TextColor(BLACK.into()), TextColor(BLACK.into()),
) )
@ -714,7 +714,7 @@ fn init_ui(mut commands: Commands, server: Res<AssetServer>) {
..default() ..default()
}, },
BorderRadius::all(Val::Px(5.0)), BorderRadius::all(Val::Px(5.0)),
BorderColor(BLACK.into()), BorderColor::all(BLACK),
BackgroundColor(Color::WHITE.with_alpha(0.9)), BackgroundColor(Color::WHITE.with_alpha(0.9)),
Button, Button,
RewindButton, RewindButton,
@ -757,7 +757,7 @@ fn init_ui(mut commands: Commands, server: Res<AssetServer>) {
..default() ..default()
}, },
BorderRadius::all(Val::Px(5.0)), BorderRadius::all(Val::Px(5.0)),
BorderColor(BLACK.into()), BorderColor::all(BLACK),
BackgroundColor(Color::WHITE.with_alpha(0.9)), BackgroundColor(Color::WHITE.with_alpha(0.9)),
Button, Button,
FlapButton, FlapButton,
@ -792,7 +792,7 @@ fn init_ui(mut commands: Commands, server: Res<AssetServer>) {
}, },
BorderRadius::all(Val::Px(5.0)), BorderRadius::all(Val::Px(5.0)),
BackgroundColor(Color::WHITE), BackgroundColor(Color::WHITE),
BorderColor(BLACK.into()), BorderColor::all(BLACK),
children![( children![(
SyncResource::<Score>::default(), SyncResource::<Score>::default(),
Text::default(), Text::default(),
@ -845,16 +845,16 @@ fn init_background(
} }
} }
fn start_rewind(_trigger: Trigger<Pointer<Pressed>>, mut next: ResMut<NextState<PlayerState>>) { fn start_rewind(_event: On<Pointer<Pressed>>, mut next: ResMut<NextState<PlayerState>>) {
next.set(PlayerState::Rewind); next.set(PlayerState::Rewind);
} }
fn end_rewind(_trigger: Trigger<Pointer<Released>>, mut next: ResMut<NextState<PlayerState>>) { fn end_rewind(_event: On<Pointer<Released>>, mut next: ResMut<NextState<PlayerState>>) {
next.set(PlayerState::Alive); next.set(PlayerState::Alive);
} }
fn flap_button( fn flap_button(
_trigger: Trigger<Pointer<Pressed>>, _event: On<Pointer<Pressed>>,
mut commands: Commands, mut commands: Commands,
bird: Single<Entity, With<Bird>>, bird: Single<Entity, With<Bird>>,
curr: Res<State<PlayerState>>, curr: Res<State<PlayerState>>,
@ -865,7 +865,7 @@ fn flap_button(
} }
let e = *bird; let e = *bird;
debug!("Flapping {:?}", e); debug!("Flapping {:?}", e);
commands.trigger_targets(Flap, e); commands.event_targets(Flap, e);
} }
/// Pause the game when the player presses "Escape" /// Pause the game when the player presses "Escape"
@ -877,21 +877,21 @@ fn un_pause_game(mut next: ResMut<NextState<PlayerState>>) {
next.set(PlayerState::Alive); next.set(PlayerState::Alive);
} }
#[derive(Component, Clone, Event)] #[derive(Component, Clone, Message)]
struct Flap; struct Flap;
// Observer for flapping // Observer for flapping
fn flap( fn flap(
trigger: Trigger<Flap>, event: On<Flap>,
mut bird: Query<&mut ExternalImpulse, With<Bird>>, mut bird: Query<&mut ExternalImpulse, With<Bird>>,
mut flaps: ResMut<Flaps>, mut flaps: ResMut<Flaps>,
) { ) {
debug!("real flap for {:?}", trigger.target()); debug!("real flap for {:?}", event.entity);
// Increment flap stat // Increment flap stat
flaps.0 += 1; flaps.0 += 1;
// Flap birds wings // Flap birds wings
if let Ok(mut f) = bird.get_mut(trigger.target()) { if let Ok(mut f) = bird.get_mut(event.entity) {
f.apply_impulse(Vec2::Y * 5000.0 + Vec2::X * 1000.0); f.apply_impulse(Vec2::Y * 5000.0 + Vec2::X * 1000.0);
} }
} }
@ -916,7 +916,7 @@ fn flap_kb(
birds.iter().for_each(|e| { birds.iter().for_each(|e| {
debug!("Flapping {:?}", e); debug!("Flapping {:?}", e);
commands.trigger_targets(Flap, e); commands.event_targets(Flap, e);
}); });
} }
@ -1138,8 +1138,8 @@ impl Display for Deaths {
} }
fn manage_score( fn manage_score(
mut start: EventReader<CollisionStarted>, mut start: MessageReader<CollisionStarted>,
mut end: EventReader<CollisionEnded>, mut end: MessageReader<CollisionEnded>,
state: Res<State<PlayerState>>, state: Res<State<PlayerState>>,
hitboxes: Query<&Batch, With<Hitbox>>, hitboxes: Query<&Batch, With<Hitbox>>,
mut score: ResMut<Score>, mut score: ResMut<Score>,
@ -1182,8 +1182,8 @@ fn manage_score(
/// Finally we iterate over all entities with the old batch ID and upsert the new batch ID /// Finally we iterate over all entities with the old batch ID and upsert the new batch ID
/// This includes root batch entities as well as pipes and hitboxes /// This includes root batch entities as well as pipes and hitboxes
fn move_batches( fn move_batches(
mut start: EventReader<CollisionStarted>, mut start: MessageReader<CollisionStarted>,
mut end: EventReader<CollisionEnded>, mut end: MessageReader<CollisionEnded>,
hitboxes: Query<Entity, With<Hitbox>>, hitboxes: Query<Entity, With<Hitbox>>,
batches: Query<(Entity, &Batch)>, batches: Query<(Entity, &Batch)>,
state: Res<State<PlayerState>>, state: Res<State<PlayerState>>,

76
src/bin/tetris/main.rs
Unescape Escape View File

@ -53,7 +53,7 @@ fn main() {
.add_systems( .add_systems(
Update, Update,
( (
kb_input.run_if(on_event::<KeyboardInput>), kb_input.run_if(on_message::<KeyboardInput>),
toggle_state_visibility::<GameState>.run_if(state_changed::<GameState>), toggle_state_visibility::<GameState>.run_if(state_changed::<GameState>),
), ),
) )
@ -510,7 +510,7 @@ fn init_ui(mut commands: Commands, output_images: Res<OutputImages>, images: Res
border: UiRect::all(Val::Px(5.0)), border: UiRect::all(Val::Px(5.0)),
..default() ..default()
}, },
BorderColor(WHITE.into()), BorderColor(WHITE),
)) ))
.with_children(|parent| { .with_children(|parent| {
let img = images.get(&output_images.tetris).unwrap(); let img = images.get(&output_images.tetris).unwrap();
@ -536,7 +536,7 @@ fn init_ui(mut commands: Commands, output_images: Res<OutputImages>, images: Res
border: UiRect::all(Val::Px(5.0)), border: UiRect::all(Val::Px(5.0)),
..default() ..default()
}, },
BorderColor(WHITE.into()), BorderColor(WHITE),
)) ))
.with_children(|parent| { .with_children(|parent| {
let img = images.get(&output_images.battler).unwrap(); let img = images.get(&output_images.battler).unwrap();
@ -773,7 +773,7 @@ impl Shape {
} }
} }
// TODO: move to trigger // TODO: move to event
fn update_position( fn update_position(
mut changed: Query< mut changed: Query<
(Entity, &GridPosition, &mut Transform), (Entity, &GridPosition, &mut Transform),
@ -792,7 +792,7 @@ fn update_position(
}); });
} }
// TODO: Move to trigger // TODO: Move to event
fn update_shape_blocks( fn update_shape_blocks(
query: Query< query: Query<
(Entity, &Shape, &GridPosition), (Entity, &Shape, &GridPosition),
@ -832,7 +832,7 @@ fn update_shape_blocks(
} }
fn kb_input( fn kb_input(
mut events: EventReader<KeyboardInput>, mut events: MessageReader<KeyboardInput>,
mut query: Query<(Entity, &mut Shape)>, mut query: Query<(Entity, &mut Shape)>,
curr: Res<State<GameState>>, curr: Res<State<GameState>>,
mut next: ResMut<NextState<GameState>>, mut next: ResMut<NextState<GameState>>,
@ -848,22 +848,22 @@ fn kb_input(
// Up arrow should rotate if in falling mode // Up arrow should rotate if in falling mode
// Only move up if in falling::off mode // Only move up if in falling::off mode
KeyCode::ArrowUp => { KeyCode::ArrowUp => {
commands.entity(e).trigger(Movement::Rotate); commands.entity(e).event(Movement::Rotate);
} }
KeyCode::ArrowDown => { KeyCode::ArrowDown => {
commands.entity(e).trigger(Movement::Down); commands.entity(e).event(Movement::Down);
} }
KeyCode::ArrowLeft => { KeyCode::ArrowLeft => {
commands.entity(e).trigger(Movement::Left); commands.entity(e).event(Movement::Left);
} }
KeyCode::ArrowRight => { KeyCode::ArrowRight => {
commands.entity(e).trigger(Movement::Right); commands.entity(e).event(Movement::Right);
} }
KeyCode::Enter => { KeyCode::Enter => {
commands.entity(e).trigger(Movement::Skip); commands.entity(e).event(Movement::Skip);
} }
KeyCode::Space => { KeyCode::Space => {
commands.entity(e).trigger(Swap); commands.entity(e).event(Swap);
} }
KeyCode::Escape => next.set(match curr.get() { KeyCode::Escape => next.set(match curr.get() {
GameState::Falling => GameState::Pause, GameState::Falling => GameState::Pause,
@ -887,7 +887,7 @@ fn kb_input(
fn falling(mut shape: Query<Entity, With<Shape>>, mut commands: Commands) { fn falling(mut shape: Query<Entity, With<Shape>>, mut commands: Commands) {
shape.iter_mut().for_each(|e| { shape.iter_mut().for_each(|e| {
debug!("Making {:?} fall", e); debug!("Making {:?} fall", e);
commands.entity(e).trigger(Movement::Down); commands.entity(e).event(Movement::Down);
}); });
} }
@ -1003,11 +1003,11 @@ fn adjust_block_lines(
} }
/// Swap the current piece out /// Swap the current piece out
#[derive(Event, Copy, Clone, PartialEq)] #[derive(Message, Copy, Clone, PartialEq)]
struct Swap; struct Swap;
/// Movement events triggered on the piece /// Movement events evented on the piece
#[derive(Event, Copy, Clone, PartialEq)] #[derive(Message, Copy, Clone, PartialEq)]
enum Movement { enum Movement {
Down, Down,
Left, Left,
@ -1018,7 +1018,7 @@ enum Movement {
// TODO: When out of bounds left/right, try to move piece away from wall // TODO: When out of bounds left/right, try to move piece away from wall
fn movement( fn movement(
trigger: Trigger<Movement>, event: On<Movement>,
mut grid_positions: Query< mut grid_positions: Query<
&mut GridPosition, &mut GridPosition,
Or<(With<ShapeBlock>, With<ShapeBlocks>, Without<LineBlock>)>, Or<(With<ShapeBlock>, With<ShapeBlocks>, Without<LineBlock>)>,
@ -1028,10 +1028,10 @@ fn movement(
mut commands: Commands, mut commands: Commands,
) { ) {
if let (Ok(this_shape), Ok(center)) = ( if let (Ok(this_shape), Ok(center)) = (
shape.get_mut(trigger.target()), shape.get_mut(event.entity),
grid_positions.get(trigger.target()), grid_positions.get(event.entity),
) { ) {
let new_positions = match trigger.event() { let new_positions = match event.event() {
Movement::Down => vec![center.with_offset(0, -1)], Movement::Down => vec![center.with_offset(0, -1)],
Movement::Left => vec![center.with_offset(-1, 0)], Movement::Left => vec![center.with_offset(-1, 0)],
Movement::Right => vec![center.with_offset(1, 0)], Movement::Right => vec![center.with_offset(1, 0)],
@ -1040,7 +1040,7 @@ fn movement(
.map(|i| center.with_offset(0, -(i as isize))) .map(|i| center.with_offset(0, -(i as isize)))
.collect(), .collect(),
}; };
let new_shape = match trigger.event() { let new_shape = match event.event() {
Movement::Down | Movement::Left | Movement::Right | Movement::Skip => *this_shape, Movement::Down | Movement::Left | Movement::Right | Movement::Skip => *this_shape,
Movement::Rotate => this_shape.rotated(), Movement::Rotate => this_shape.rotated(),
}; };
@ -1053,7 +1053,7 @@ fn movement(
match position { match position {
Err(GameError::OutOfBoundsLeft) | Err(GameError::OutOfBoundsRight) => (), // Do nothing Err(GameError::OutOfBoundsLeft) | Err(GameError::OutOfBoundsRight) => (), // Do nothing
Err(GameError::OutOfBoundsDown) => { Err(GameError::OutOfBoundsDown) => {
commands.entity(trigger.target()).remove::<Shape>(); commands.entity(event.entity).remove::<Shape>();
} }
Err(GameError::Collision) => panic!("This shouldn't happen!"), Err(GameError::Collision) => panic!("This shouldn't happen!"),
Ok(new_center) => { Ok(new_center) => {
@ -1064,7 +1064,7 @@ fn movement(
return; return;
} // Do nothing } // Do nothing
Err(GameError::OutOfBoundsDown) => { Err(GameError::OutOfBoundsDown) => {
commands.entity(trigger.target()).remove::<Shape>(); commands.entity(event.entity).remove::<Shape>();
return; return;
} }
Err(GameError::Collision) => panic!("This shouldn't happen!"), Err(GameError::Collision) => panic!("This shouldn't happen!"),
@ -1073,9 +1073,9 @@ fn movement(
// If there would be a collision between blocks // If there would be a collision between blocks
if gp == *other_gp { if gp == *other_gp {
// And we are moving down // And we are moving down
if *trigger.event() == Movement::Down { if *event.event() == Movement::Down {
// De-activate this piece // De-activate this piece
commands.entity(trigger.target()).remove::<Shape>(); commands.entity(event.entity).remove::<Shape>();
} }
// Regardless, cancel the move // Regardless, cancel the move
return; return;
@ -1087,22 +1087,22 @@ fn movement(
debug!("Checks passed for {position:?}, committing change"); debug!("Checks passed for {position:?}, committing change");
// Update center // Update center
let mut gp = grid_positions.get_mut(trigger.target()).unwrap(); let mut gp = grid_positions.get_mut(event.entity).unwrap();
*gp = new_center; *gp = new_center;
// Update shape/rotation // Update shape/rotation
let mut s = shape.get_mut(trigger.target()).unwrap(); let mut s = shape.get_mut(event.entity).unwrap();
*s = new_shape; *s = new_shape;
} }
} }
} }
} else { } else {
warn!("Triggered movement on non-shape entity"); warn!("Oned movement on non-shape entity");
} }
} }
fn swap( fn swap(
trigger: Trigger<Swap>, event: On<Swap>,
mut shapes: Query<&mut Shape>, mut shapes: Query<&mut Shape>,
mut store: ResMut<ShapeStore>, mut store: ResMut<ShapeStore>,
mut commands: Commands, mut commands: Commands,
@ -1112,16 +1112,16 @@ fn swap(
None => { None => {
// Copy current shape into store // Copy current shape into store
// De-activate entity // De-activate entity
store.0 = Some(*shapes.get(trigger.target()).unwrap()); store.0 = Some(*shapes.get(event.entity).unwrap());
commands commands
.entity(trigger.target()) .entity(event.entity)
.despawn_related::<ShapeBlocks>() .despawn_related::<ShapeBlocks>()
.despawn(); .despawn();
} }
Some(inner) => { Some(inner) => {
// Copy current shape into store // Copy current shape into store
// Copy old shape into entity // Copy old shape into entity
let mut curr = shapes.get_mut(trigger.target()).unwrap(); let mut curr = shapes.get_mut(event.entity).unwrap();
std::mem::swap(&mut (*inner), &mut (*curr)); std::mem::swap(&mut (*inner), &mut (*curr));
} }
} }
@ -1209,16 +1209,16 @@ fn sync_health(
}) })
} }
#[derive(Event)] #[derive(Message)]
struct Damage { struct Damage {
quantity: f32 quantity: f32
} }
fn deal_damage( fn deal_damage(
trigger: Trigger<Damage>, event: On<Damage>,
mut healths: Query<&mut Health> mut healths: Query<&mut Health>
) { ) {
healths.get_mut(trigger.target()).unwrap().0 -= trigger.event().quantity healths.get_mut(event.entity).unwrap().0 -= event.event().quantity
} }
fn damage_on_place_shape( fn damage_on_place_shape(
@ -1228,7 +1228,7 @@ fn damage_on_place_shape(
) { ) {
events.read().for_each(|_| { events.read().for_each(|_| {
enemies.iter().for_each(|e| { enemies.iter().for_each(|e| {
commands.entity(e).trigger(Damage { quantity: 1.0 }); commands.entity(e).event(Damage { quantity: 1.0 });
}); });
}); });
} }
@ -1240,7 +1240,7 @@ fn damage_on_clear_line(
) { ) {
events.read().for_each(|_| { events.read().for_each(|_| {
enemies.iter().for_each(|e| { enemies.iter().for_each(|e| {
commands.entity(e).trigger(Damage { quantity: 1.0 }); commands.entity(e).event(Damage { quantity: 1.0 });
}); });
}); });
} }
@ -1249,5 +1249,5 @@ fn damage_over_time(
protagonist: Single<Entity, With<Protagonist>>, protagonist: Single<Entity, With<Protagonist>>,
mut commands: Commands, mut commands: Commands,
) { ) {
commands.entity(*protagonist).trigger(Damage { quantity: 1.0 }); commands.entity(*protagonist).event(Damage { quantity: 1.0 });
} }

50
src/bin/trees/debug.rs
Unescape Escape View File

@ -8,15 +8,15 @@ impl Plugin for TreesDebugPlugin {
.add_systems( .add_systems(
Update, Update,
( (
(spawn_debug_buttons.run_if(on_event::<AssetEvent<Monologue>>),), (spawn_debug_buttons.run_if(on_message::<AssetEvent<Monologue>>),),
( (
monologue_asset_tooltip monologue_asset_tooltip
.run_if(on_event::<Pointer<Over>>.or(on_event::<Pointer<Out>>)), .run_if(on_message::<Pointer<Over>>.or(on_message::<Pointer<Out>>)),
hide_menu.run_if(any_component_changed::<NavState>), hide_menu.run_if(any_component_changed::<NavState>),
clear_monologue.run_if(any_component_changed::<NavState>), clear_monologue.run_if(any_component_changed::<NavState>),
control_menu.run_if(on_event::<Pointer<Over>>.or(on_event::<Pointer<Out>>)), control_menu.run_if(on_message::<Pointer<Over>>.or(on_message::<Pointer<Out>>)),
delete_tree.run_if(on_event::<Pointer<Click>>), delete_tree.run_if(on_message::<Pointer<Click>>),
drag_tree.run_if(on_event::<Pointer<Drag>>), drag_tree.run_if(on_message::<Pointer<Drag>>),
) )
.run_if(in_state(DebuggingState::On)), .run_if(in_state(DebuggingState::On)),
), ),
@ -35,7 +35,7 @@ struct MonologuesList;
struct MonologuePreview; struct MonologuePreview;
fn drag_tree( fn drag_tree(
mut events: EventReader<Pointer<Drag>>, mut events: MessageReader<Pointer<Drag>>,
state: Res<State<DebuggingState>>, state: Res<State<DebuggingState>>,
mut query: Query<&mut Transform, With<Tree>>, mut query: Query<&mut Transform, With<Tree>>,
camera: Single<(&Camera, &GlobalTransform), With<Camera>>, camera: Single<(&Camera, &GlobalTransform), With<Camera>>,
@ -154,8 +154,8 @@ fn init_debug_ui(mut commands: Commands) {
// When you pointer goes off of the '+' or any of it's children make the entire menu invisible // When you pointer goes off of the '+' or any of it's children make the entire menu invisible
fn control_menu( fn control_menu(
mut over_events: EventReader<Pointer<Over>>, mut over_events: MessageReader<Pointer<Over>>,
mut out_events: EventReader<Pointer<Out>>, mut out_events: MessageReader<Pointer<Out>>,
nav_children: Query<&NavParent>, nav_children: Query<&NavParent>,
children: Query<&ChildOf>, children: Query<&ChildOf>,
nav_parents: Query<&NavChildren>, nav_parents: Query<&NavChildren>,
@ -207,9 +207,9 @@ fn control_menu(
/// 1. Add the Button component /// 1. Add the Button component
/// 2. Change the color to Orange /// 2. Change the color to Orange
/// 3. Add observers for click (select) and hover (change color) /// 3. Add observers for click (select) and hover (change color)
fn add_dialog_option(trigger: Trigger<OnAdd, DialogOption>, mut commands: Commands) { fn add_dialog_option(event: On<Add, DialogOption>, mut commands: Commands) {
commands commands
.entity(trigger.target()) .entity(event.entity)
.insert(Button) .insert(Button)
.insert(Node { .insert(Node {
width: Val::Percent(100.0), width: Val::Percent(100.0),
@ -223,16 +223,16 @@ fn add_dialog_option(trigger: Trigger<OnAdd, DialogOption>, mut commands: Comman
} }
fn assign_monologue_event( fn assign_monologue_event(
trigger: Trigger<Pointer<Click>>, event: On<Pointer<Click>>,
mut events: EventWriter<AssignMonologue>, mut events: EventWriter<AssignMonologue>,
monologues: Query<&TreeMonologue>, monologues: Query<&TreeMonologue>,
) { ) {
let TreeMonologue(handle) = monologues.get(trigger.target()).unwrap(); let TreeMonologue(handle) = monologues.get(event.entity).unwrap();
events.write(AssignMonologue(handle.clone())); events.write(AssignMonologue(handle.clone()));
} }
/// Observer for the "Plant a new tree" button in the debug UI /// Observer for the "Plant a new tree" button in the debug UI
fn spawn_tree(_trigger: Trigger<Pointer<Click>>, mut events: EventWriter<PlantTree>) { fn spawn_tree(_event: On<Pointer<Click>>, mut events: EventWriter<PlantTree>) {
events.write(PlantTree(None)); events.write(PlantTree(None));
} }
@ -261,7 +261,7 @@ fn hide_menu(mut nodes: Query<(&mut Visibility, &NavState), Changed<NavState>>)
} }
fn delete_tree( fn delete_tree(
mut events: EventReader<Pointer<Click>>, mut events: MessageReader<Pointer<Click>>,
mut commands: Commands, mut commands: Commands,
query: Query<Entity, With<Tree>>, query: Query<Entity, With<Tree>>,
) { ) {
@ -275,21 +275,21 @@ fn delete_tree(
/// Add the "script: path/to/file.mono" tooltip info /// Add the "script: path/to/file.mono" tooltip info
fn monologue_asset_tooltip( fn monologue_asset_tooltip(
mut over_events: EventReader<Pointer<Over>>, mut over_events: MessageReader<Pointer<Over>>,
mut out_events: EventReader<Pointer<Out>>, mut out_events: MessageReader<Pointer<Out>>,
mut tooltip: ResMut<ToolTip>, mut tooltip: ResMut<ToolTip>,
trees: Query<(&Tree, Option<&TreeMonologue>)>, trees: Query<(&Tree, Option<&TreeMonologue>)>,
) { ) {
out_events out_events
.read() .read()
.filter_map(|Pointer { target, .. }| trees.contains(*target).then_some(*target)) .filter_map(|Pointer { entity, .. }| trees.contains(*entity).then_some(*entity))
.for_each(|_| { .for_each(|_| {
tooltip.remove("Script"); tooltip.remove("Script");
}); });
over_events over_events
.read() .read()
.filter_map(|Pointer { target, .. }| trees.contains(*target).then_some(*target)) .filter_map(|Pointer { entity, .. }| trees.contains(*entity).then_some(*entity))
.for_each(|e| match trees.get(e) { .for_each(|e| match trees.get(e) {
Ok((_tree, Some(TreeMonologue(handle)))) => match handle.path() { Ok((_tree, Some(TreeMonologue(handle)))) => match handle.path() {
Some(p) => tooltip.insert("Script", format!("{p}")), Some(p) => tooltip.insert("Script", format!("{p}")),
@ -304,14 +304,14 @@ fn monologue_asset_tooltip(
/// When a dialog option is chosen (clicked on) we do the following: /// When a dialog option is chosen (clicked on) we do the following:
fn choose_dialog_option( fn choose_dialog_option(
trigger: Trigger<Pointer<Click>>, event: On<Pointer<Click>>,
mut dialog_events: EventWriter<DialogEvent>, mut dialog_events: EventWriter<DialogEvent>,
mut commands: Commands, mut commands: Commands,
texts: Query<&Text>, texts: Query<&Text>,
options: Query<Entity, With<DialogOption>>, options: Query<Entity, With<DialogOption>>,
dialog_box: Single<Entity, With<DialogBox>>, dialog_box: Single<Entity, With<DialogBox>>,
) { ) {
debug!("Choosing dialog {:?}", trigger.target()); debug!("Choosing dialog {:?}", event.entity);
debug!("Despawning dialog options"); debug!("Despawning dialog options");
options.iter().for_each(|e| { options.iter().for_each(|e| {
@ -319,25 +319,25 @@ fn choose_dialog_option(
}); });
debug!("Inserting dialog line"); debug!("Inserting dialog line");
if let Ok(t) = texts.get(trigger.target()) { if let Ok(t) = texts.get(event.entity) {
commands.entity(*dialog_box).with_children(|parent| { commands.entity(*dialog_box).with_children(|parent| {
parent.spawn((t.clone(), DialogLine)); parent.spawn((t.clone(), DialogLine));
}); });
} }
// trigger the next dialog line // event the next dialog line
dialog_events.write(DialogEvent::NextBatch); dialog_events.write(DialogEvent::NextBatch);
} }
fn preview_monologue( fn preview_monologue(
trigger: Trigger<Pointer<Over>>, event: On<Pointer<Over>>,
container: Single<Entity, (With<MonologuePreview>, Without<Button>, Without<Text>)>, container: Single<Entity, (With<MonologuePreview>, Without<Button>, Without<Text>)>,
tree_monologue: Query<&TreeMonologue, With<Button>>, tree_monologue: Query<&TreeMonologue, With<Button>>,
monologues: Res<Assets<Monologue>>, monologues: Res<Assets<Monologue>>,
mut commands: Commands, mut commands: Commands,
) { ) {
// Get the handle for this button's monologuie // Get the handle for this button's monologuie
if let Ok(TreeMonologue(handle)) = tree_monologue.get(trigger.target()) { if let Ok(TreeMonologue(handle)) = tree_monologue.get(event.entity) {
// Get the monologue data // Get the monologue data
if let Some(monologue) = monologues.get(handle) { if let Some(monologue) = monologues.get(handle) {
commands.entity(*container).despawn_related::<Children>(); commands.entity(*container).despawn_related::<Children>();
@ -366,7 +366,7 @@ fn preview_monologue(
} }
fn spawn_debug_buttons( fn spawn_debug_buttons(
mut events: EventReader<AssetEvent<Monologue>>, mut events: MessageReader<AssetEvent<Monologue>>,
mut commands: Commands, mut commands: Commands,
container: Single<Entity, (With<MonologuesList>, Without<Button>)>, container: Single<Entity, (With<MonologuesList>, Without<Button>)>,
server: Res<AssetServer>, server: Res<AssetServer>,

60
src/bin/trees/main.rs
Unescape Escape View File

@ -43,20 +43,20 @@ fn main() {
start_dialog start_dialog
.run_if(in_state(DebuggingState::Off)) .run_if(in_state(DebuggingState::Off))
.run_if(in_state(DialogState::None)) .run_if(in_state(DialogState::None))
.run_if(on_event::<Pointer<Click>>), .run_if(on_message::<Pointer<Click>>),
// Close the dialog box if it is idle (not choosing) // Close the dialog box if it is idle (not choosing)
end_dialog end_dialog
.run_if(in_state(DebuggingState::Off)) .run_if(in_state(DebuggingState::Off))
.run_if(in_state(DialogState::Idle)) .run_if(in_state(DialogState::Idle))
.run_if(on_event::<Pointer<Click>>), .run_if(on_message::<Pointer<Click>>),
handle_plant_tree.run_if(on_event::<PlantTree>), handle_plant_tree.run_if(on_message::<PlantTree>),
assign_monologue_to_tree assign_monologue_to_tree
.run_if(on_event::<AssignMonologue>) .run_if(on_message::<AssignMonologue>)
.after(handle_plant_tree), .after(handle_plant_tree),
dialog_engine.run_if(on_event::<DialogEvent>), dialog_engine.run_if(on_message::<DialogEvent>),
auto_scroll.run_if(any_component_added::<DialogOption>), auto_scroll.run_if(any_component_added::<DialogOption>),
dialog_box_visibility.run_if(state_changed::<DialogState>), dialog_box_visibility.run_if(state_changed::<DialogState>),
scale_window.run_if(on_event::<WindowResized>), scale_window.run_if(on_message::<WindowResized>),
), ),
) )
.add_observer(add_tree_monologue) .add_observer(add_tree_monologue)
@ -110,19 +110,19 @@ fn init_ui(mut commands: Commands) {
} }
fn hover_dialog_box_over( fn hover_dialog_box_over(
trigger: Trigger<Pointer<Over>>, event: On<Pointer<Over>>,
mut query: Query<&mut BackgroundColor, With<DialogBox>>, mut query: Query<&mut BackgroundColor, With<DialogBox>>,
) { ) {
if let Ok(mut bg) = query.get_mut(trigger.target()) { if let Ok(mut bg) = query.get_mut(event.entity) {
bg.0.set_alpha(0.95); bg.0.set_alpha(0.95);
} }
} }
fn hover_dialog_box_out( fn hover_dialog_box_out(
trigger: Trigger<Pointer<Out>>, event: On<Pointer<Out>>,
mut query: Query<&mut BackgroundColor, With<DialogBox>>, mut query: Query<&mut BackgroundColor, With<DialogBox>>,
) { ) {
if let Ok(mut bg) = query.get_mut(trigger.target()) { if let Ok(mut bg) = query.get_mut(event.entity) {
bg.0.set_alpha(0.9); bg.0.set_alpha(0.9);
} }
} }
@ -162,7 +162,7 @@ struct DialogOption;
struct DialogLine; struct DialogLine;
/// Events that drive the dialog engine /// Events that drive the dialog engine
#[derive(Event, PartialEq)] #[derive(Message, PartialEq)]
enum DialogEvent { enum DialogEvent {
Start(Entity, Handle<Monologue>), Start(Entity, Handle<Monologue>),
NextBatch, NextBatch,
@ -183,7 +183,7 @@ enum DialogState {
/// Start dialog /// Start dialog
fn start_dialog( fn start_dialog(
mut click_events: EventReader<Pointer<Click>>, mut click_events: MessageReader<Pointer<Click>>,
mut dialog_events: EventWriter<DialogEvent>, mut dialog_events: EventWriter<DialogEvent>,
query: Query<&TreeMonologue, With<Tree>>, query: Query<&TreeMonologue, With<Tree>>,
) { ) {
@ -199,12 +199,12 @@ fn start_dialog(
/// When dialog is complete and you click away from the dialog box, close it out /// When dialog is complete and you click away from the dialog box, close it out
fn end_dialog( fn end_dialog(
mut click_events: EventReader<Pointer<Click>>, mut click_events: MessageReader<Pointer<Click>>,
mut dialog_events: EventWriter<DialogEvent>, mut dialog_events: EventWriter<DialogEvent>,
query: Query<Entity, Or<(With<TreeMonologue>, With<DialogBox>, With<DialogOption>)>>, query: Query<Entity, Or<(With<TreeMonologue>, With<DialogBox>, With<DialogOption>)>>,
) { ) {
click_events.read().for_each(|event| { click_events.read().for_each(|event| {
debug!("Click even triggered end of dialog: {:?}", event.target); debug!("Click even evented end of dialog: {:?}", event.target);
if !query.contains(event.target) { if !query.contains(event.target) {
dialog_events.write(DialogEvent::End); dialog_events.write(DialogEvent::End);
} }
@ -214,7 +214,7 @@ fn end_dialog(
/// System which puts DialogOptions into the DialogBox /// System which puts DialogOptions into the DialogBox
fn dialog_engine( fn dialog_engine(
// React to dialog events // React to dialog events
mut events: EventReader<DialogEvent>, mut events: MessageReader<DialogEvent>,
// Reference to DialogBox // Reference to DialogBox
dialog_box: Single<Entity, With<DialogBox>>, dialog_box: Single<Entity, With<DialogBox>>,
// EntityCommands for Dialog Box // EntityCommands for Dialog Box
@ -234,7 +234,7 @@ fn dialog_engine(
) { ) {
debug_assert!( debug_assert!(
!events.is_empty(), !events.is_empty(),
"Dialog engine is triggered by Dialog Events" "Dialog engine is evented by Dialog Events"
); );
events.read().for_each(|event| { events.read().for_each(|event| {
@ -300,20 +300,20 @@ fn dialog_engine(
} }
fn hover_dialog_option_over( fn hover_dialog_option_over(
trigger: Trigger<Pointer<Over>>, event: On<Pointer<Over>>,
mut query: Query<(&mut TextColor, &mut BackgroundColor)>, mut query: Query<(&mut TextColor, &mut BackgroundColor)>,
) { ) {
if let Ok((mut tc, mut bg)) = query.get_mut(trigger.target()) { if let Ok((mut tc, mut bg)) = query.get_mut(event.entity) {
*tc = TextColor(DARK_ORANGE.into()); *tc = TextColor(DARK_ORANGE.into());
bg.0.set_alpha(1.0); bg.0.set_alpha(1.0);
} }
} }
fn hover_dialog_option_out( fn hover_dialog_option_out(
trigger: Trigger<Pointer<Out>>, event: On<Pointer<Out>>,
mut query: Query<(&mut TextColor, &mut BackgroundColor)>, mut query: Query<(&mut TextColor, &mut BackgroundColor)>,
) { ) {
if let Ok((mut tc, mut bg)) = query.get_mut(trigger.target()) { if let Ok((mut tc, mut bg)) = query.get_mut(event.entity) {
*tc = TextColor(ORANGE.into()); *tc = TextColor(ORANGE.into());
bg.0.set_alpha(0.0); bg.0.set_alpha(0.0);
} }
@ -331,12 +331,12 @@ fn dialog_box_visibility(
} }
fn add_tree_monologue( fn add_tree_monologue(
trigger: Trigger<OnAdd, TreeMonologue>, event: On<Add, TreeMonologue>,
query: Query<&MeshMaterial3d<StandardMaterial>>, query: Query<&MeshMaterial3d<StandardMaterial>>,
mut materials: ResMut<Assets<StandardMaterial>>, mut materials: ResMut<Assets<StandardMaterial>>,
) { ) {
// Get the affected entity's MeshMaterial3d // Get the affected entity's MeshMaterial3d
if let Ok(handle) = query.get(trigger.target()) { if let Ok(handle) = query.get(event.entity) {
// Get the concrete StandardMaterial // Get the concrete StandardMaterial
if let Some(material) = materials.get_mut(handle) { if let Some(material) = materials.get_mut(handle) {
material.base_color = WHITE.with_alpha(1.0).into(); material.base_color = WHITE.with_alpha(1.0).into();
@ -345,12 +345,12 @@ fn add_tree_monologue(
} }
fn remove_tree_monologue( fn remove_tree_monologue(
trigger: Trigger<OnRemove, TreeMonologue>, event: On<Remove, TreeMonologue>,
query: Query<&MeshMaterial3d<StandardMaterial>>, query: Query<&MeshMaterial3d<StandardMaterial>>,
mut materials: ResMut<Assets<StandardMaterial>>, mut materials: ResMut<Assets<StandardMaterial>>,
) { ) {
// Get the affected entity's MeshMaterial3d // Get the affected entity's MeshMaterial3d
if let Ok(handle) = query.get(trigger.target()) { if let Ok(handle) = query.get(event.entity) {
// Get the concrete StandardMaterial // Get the concrete StandardMaterial
if let Some(material) = materials.get_mut(handle) { if let Some(material) = materials.get_mut(handle) {
// Make it dull // Make it dull
@ -359,7 +359,7 @@ fn remove_tree_monologue(
} }
} }
fn scale_window(events: EventReader<WindowResized>, mut window: Single<&mut Window>) { fn scale_window(events: MessageReader<WindowResized>, mut window: Single<&mut Window>) {
debug_assert!(!events.is_empty(), "Only scale window when resized"); debug_assert!(!events.is_empty(), "Only scale window when resized");
let r = &mut window.resolution; let r = &mut window.resolution;
@ -388,7 +388,7 @@ fn scale_window(events: EventReader<WindowResized>, mut window: Single<&mut Wind
); );
} }
/// Load all monologues so they are in the asset store and trigger on-load events /// Load all monologues so they are in the asset store and event on-load events
fn load_monologues(server: ResMut<AssetServer>, mut loaded_assets: Local<Vec<Handle<Monologue>>>) { fn load_monologues(server: ResMut<AssetServer>, mut loaded_assets: Local<Vec<Handle<Monologue>>>) {
*loaded_assets = include_str!("../../../assets/trees/MONOLOGUES") *loaded_assets = include_str!("../../../assets/trees/MONOLOGUES")
.split("\n") .split("\n")
@ -396,13 +396,13 @@ fn load_monologues(server: ResMut<AssetServer>, mut loaded_assets: Local<Vec<Han
.collect(); .collect();
} }
#[derive(Event)] #[derive(Message)]
struct PlantTree(Option<Handle<Monologue>>); struct PlantTree(Option<Handle<Monologue>>);
/// Plan a tree in the world /// Plan a tree in the world
/// Handles random placement, 3d model, materials, and observers /// Handles random placement, 3d model, materials, and observers
fn handle_plant_tree( fn handle_plant_tree(
mut events: EventReader<PlantTree>, mut events: MessageReader<PlantTree>,
mut assignments: EventWriter<AssignMonologue>, mut assignments: EventWriter<AssignMonologue>,
trees: Query<Entity, With<Tree>>, trees: Query<Entity, With<Tree>>,
server: Res<AssetServer>, server: Res<AssetServer>,
@ -448,12 +448,12 @@ fn handle_plant_tree(
}); });
} }
#[derive(Event, Debug)] #[derive(Message, Debug)]
struct AssignMonologue(Handle<Monologue>); struct AssignMonologue(Handle<Monologue>);
/// Assign the given monologue to a tree /// Assign the given monologue to a tree
fn assign_monologue_to_tree( fn assign_monologue_to_tree(
mut events: EventReader<AssignMonologue>, mut events: MessageReader<AssignMonologue>,
query: Query<Entity, (With<Tree>, Without<TreeMonologue>)>, query: Query<Entity, (With<Tree>, Without<TreeMonologue>)>,
mut notice: ResMut<Notice>, mut notice: ResMut<Notice>,
mut commands: Commands, mut commands: Commands,

52
src/debug.rs
Unescape Escape View File

@ -25,7 +25,7 @@ impl Plugin for DebuggingPlugin {
(toggle_light_gizmo, toggle_aabb_gizmo).run_if(state_changed::<DebuggingState>), (toggle_light_gizmo, toggle_aabb_gizmo).run_if(state_changed::<DebuggingState>),
( (
(hover_mesh, hover_ui) (hover_mesh, hover_ui)
.run_if(on_event::<Pointer<Over>>.or(on_event::<Pointer<Out>>)), .run_if(on_message::<Pointer<Over>>.or(on_message::<Pointer<Out>>)),
tooltip_follow.run_if(any_component_changed::<Window>), tooltip_follow.run_if(any_component_changed::<Window>),
tooltip_update_transform.run_if(any_component_changed::<Transform>), tooltip_update_transform.run_if(any_component_changed::<Transform>),
tooltip_draw.run_if(any_component_changed::<ToolTip>), tooltip_draw.run_if(any_component_changed::<ToolTip>),
@ -79,7 +79,7 @@ fn init_debug_ui(mut commands: Commands) {
children![(TextColor(BLACK.into()), Text::new(VERSION),)], children![(TextColor(BLACK.into()), Text::new(VERSION),)],
GlobalZIndex(i32::MAX - 1), GlobalZIndex(i32::MAX - 1),
BorderRadius::all(Val::Px(5.0)), BorderRadius::all(Val::Px(5.0)),
BorderColor(BLACK.into()), BorderColor::all(BLACK),
BackgroundColor(Color::WHITE), BackgroundColor(Color::WHITE),
Node { Node {
max_width: Val::Percent(50.0), max_width: Val::Percent(50.0),
@ -100,7 +100,7 @@ fn init_debug_ui(mut commands: Commands) {
)], )],
GlobalZIndex(i32::MAX - 1), GlobalZIndex(i32::MAX - 1),
BorderRadius::all(Val::Px(5.0)), BorderRadius::all(Val::Px(5.0)),
BorderColor(BLACK.into()), BorderColor::all(BLACK),
BackgroundColor(Color::WHITE), BackgroundColor(Color::WHITE),
Node { Node {
max_width: Val::Percent(50.0), max_width: Val::Percent(50.0),
@ -129,7 +129,7 @@ fn init_debug_ui(mut commands: Commands) {
Name::new("Debug Indicator"), Name::new("Debug Indicator"),
GlobalZIndex(i32::MAX - 1), GlobalZIndex(i32::MAX - 1),
BorderRadius::all(Val::Px(5.0)), BorderRadius::all(Val::Px(5.0)),
BorderColor(BLACK.into()), BorderColor::all(BLACK),
BackgroundColor(Color::WHITE), BackgroundColor(Color::WHITE),
children![(Text("Debug: OFF".into()), TextColor(BLACK.into()),)], children![(Text("Debug: OFF".into()), TextColor(BLACK.into()),)],
Button, Button,
@ -146,7 +146,7 @@ fn init_debug_ui(mut commands: Commands) {
..default() ..default()
}, },
BorderRadius::all(Val::Px(5.0)), BorderRadius::all(Val::Px(5.0)),
BorderColor(BLACK.into()), BorderColor::all(BLACK),
BackgroundColor(Color::WHITE), BackgroundColor(Color::WHITE),
)) ))
.with_children(|parent| { .with_children(|parent| {
@ -197,7 +197,7 @@ fn init_debug_ui(mut commands: Commands) {
Pickable::IGNORE, Pickable::IGNORE,
GlobalZIndex(i32::MAX), GlobalZIndex(i32::MAX),
BorderRadius::all(Val::Px(5.0)), BorderRadius::all(Val::Px(5.0)),
BorderColor(BLACK.into()), BorderColor::all(BLACK),
BackgroundColor(Color::WHITE), BackgroundColor(Color::WHITE),
Node { Node {
position_type: PositionType::Absolute, position_type: PositionType::Absolute,
@ -219,7 +219,7 @@ fn init_debug_ui(mut commands: Commands) {
}); });
} }
/// Toggles the debug state from off -> on // off -> on when triggered /// Toggles the debug state from off -> on // off -> on when evented
fn toggle_debug_state( fn toggle_debug_state(
mut next: ResMut<NextState<DebuggingState>>, mut next: ResMut<NextState<DebuggingState>>,
curr: Res<State<DebuggingState>>, curr: Res<State<DebuggingState>>,
@ -306,24 +306,24 @@ fn lock_tooltip(q: Query<Option<&ToolTip>>, hover_map: Res<HoverMap>, mut comman
} }
/// when a tooltip is added to an entity, insert the text component /// when a tooltip is added to an entity, insert the text component
fn add_tooltip_text(trigger: Trigger<OnAdd, ToolTip>, mut commands: Commands) { fn add_tooltip_text(event: On<Add, ToolTip>, mut commands: Commands) {
info!("Adding text2d to {:?}", trigger.target()); info!("Adding text2d to {:?}", event.entity);
commands.entity(trigger.target()).with_children(|parent| { commands.entity(event.entity).with_children(|parent| {
parent.spawn(( parent.spawn((
TextColor(BLACK.into()), TextColor(BLACK.into()),
Text2d("Placeholder".into()), Text2d("Placeholder".into()),
Transform::from_xyz(0.5, 0.0, 1.0).with_scale(Vec3::splat(0.01)), Transform::from_xyz(0.5, 0.0, 1.0).with_scale(Vec3::splat(0.01)),
Anchor::CenterLeft, Anchor::CENTER_LEFT,
DebuggingState::On, DebuggingState::On,
)); ));
}); });
} }
fn populate_tooltip_info( fn populate_tooltip_info(
trigger: Trigger<OnAdd, ToolTip>, event: On<Add, ToolTip>,
mut tooltips: Query<(&mut ToolTip, Entity, &Transform, &Name)>, mut tooltips: Query<(&mut ToolTip, Entity, &Transform, &Name)>,
) { ) {
if let Ok((mut tt, e, t, n)) = tooltips.get_mut(trigger.target()) { if let Ok((mut tt, e, t, n)) = tooltips.get_mut(event.entity) {
tt.insert("ID", format!("{e}")); tt.insert("ID", format!("{e}"));
tt.insert("Name", n.into()); tt.insert("Name", n.into());
tt.insert( tt.insert(
@ -350,13 +350,13 @@ fn tooltip_update_transform(mut events: Query<(&mut ToolTip, &Transform), Change
/// when a tooltip is removed to an entity, remove the text components /// when a tooltip is removed to an entity, remove the text components
fn remove_tooltip_text( fn remove_tooltip_text(
trigger: Trigger<OnRemove, ToolTip>, event: On<Remove, ToolTip>,
mut commands: Commands, mut commands: Commands,
parents: Query<&Children>, parents: Query<&Children>,
text_2d: Query<Entity, With<Text2d>>, text_2d: Query<Entity, With<Text2d>>,
) { ) {
// Get lis of children for this entity // Get lis of children for this entity
let children = parents.get(trigger.target()).unwrap(); let children = parents.get(event.entity).unwrap();
// Find the tooltip text child // Find the tooltip text child
if let Some(child) = children.iter().find_map(|child| text_2d.get(child).ok()) { if let Some(child) = children.iter().find_map(|child| text_2d.get(child).ok()) {
// Remove it from the world // Remove it from the world
@ -381,14 +381,14 @@ fn tooltip_draw(
/// When you hover over a mesh, update the tooltip with some info /// When you hover over a mesh, update the tooltip with some info
fn hover_mesh( fn hover_mesh(
mut over_events: EventReader<Pointer<Over>>, mut over_events: MessageReader<Pointer<Over>>,
mut out_events: EventReader<Pointer<Out>>, mut out_events: MessageReader<Pointer<Out>>,
mut tooltip: ResMut<ToolTip>, mut tooltip: ResMut<ToolTip>,
meshes: Query<(&Transform, Option<&Name>), Or<(With<Mesh3d>, With<Mesh2d>)>>, meshes: Query<(&Transform, Option<&Name>), Or<(With<Mesh3d>, With<Mesh2d>)>>,
) { ) {
out_events out_events
.read() .read()
.filter_map(|Pointer { target, .. }| meshes.contains(*target).then_some(*target)) .filter_map(|Pointer { entity, .. }| meshes.contains(*entity).then_some(*entity))
.for_each(|_| { .for_each(|_| {
tooltip.remove("ID"); tooltip.remove("ID");
tooltip.remove("Pos"); tooltip.remove("Pos");
@ -396,7 +396,7 @@ fn hover_mesh(
}); });
over_events over_events
.read() .read()
.filter_map(|Pointer { target, .. }| meshes.contains(*target).then_some(*target)) .filter_map(|Pointer { entity, .. }| meshes.contains(*entity).then_some(*entity))
.for_each(|e| { .for_each(|e| {
if let Ok((t, n)) = meshes.get(e) { if let Ok((t, n)) = meshes.get(e) {
let pos = (t.translation.x, t.translation.y, t.translation.z); let pos = (t.translation.x, t.translation.y, t.translation.z);
@ -414,21 +414,21 @@ fn hover_mesh(
} }
fn hover_ui( fn hover_ui(
mut over_events: EventReader<Pointer<Over>>, mut over_events: MessageReader<Pointer<Over>>,
mut out_events: EventReader<Pointer<Out>>, mut out_events: MessageReader<Pointer<Out>>,
mut tooltip: ResMut<ToolTip>, mut tooltip: ResMut<ToolTip>,
nodes: Query<Option<&Name>, With<Node>>, nodes: Query<Option<&Name>, With<Node>>,
) { ) {
out_events out_events
.read() .read()
.filter_map(|Pointer { target, .. }| nodes.contains(*target).then_some(*target)) .filter_map(|Pointer { entity, .. }| nodes.contains(*entity).then_some(*entity))
.for_each(|_| { .for_each(|_| {
tooltip.remove("ID"); tooltip.remove("ID");
tooltip.remove("Name"); tooltip.remove("Name");
}); });
over_events over_events
.read() .read()
.filter_map(|Pointer { target, .. }| nodes.contains(*target).then_some(*target)) .filter_map(|Pointer { entity, .. }| nodes.contains(*entity).then_some(*entity))
.for_each(|e| { .for_each(|e| {
if let Ok(n) = nodes.get(e) { if let Ok(n) = nodes.get(e) {
let name = match n { let name = match n {
@ -538,7 +538,7 @@ fn track_window_info(window: Single<&Window>, mut info: ResMut<WindowInfo>) {
/// Toggle the debug state when a button is clicked /// Toggle the debug state when a button is clicked
fn toggle_debug( fn toggle_debug(
_trigger: Trigger<Pointer<Click>>, _event: On<Pointer<Click>>,
curr: Res<State<DebuggingState>>, curr: Res<State<DebuggingState>>,
mut next: ResMut<NextState<DebuggingState>>, mut next: ResMut<NextState<DebuggingState>>,
) { ) {
@ -548,8 +548,8 @@ fn toggle_debug(
}); });
} }
fn close_on_click(trigger: Trigger<Pointer<Click>>, mut query: Query<&mut Visibility>) { fn close_on_click(event: On<Pointer<Click>>, mut query: Query<&mut Visibility>) {
if let Ok(mut v) = query.get_mut(trigger.target()) { if let Ok(mut v) = query.get_mut(event.entity) {
*v = Visibility::Hidden; *v = Visibility::Hidden;
} }
} }

3
src/lib.rs
Unescape Escape View File

@ -20,6 +20,7 @@ pub use std::fmt::Display;
// Community libraries // Community libraries
pub use bevy::{ pub use bevy::{
asset::{AssetLoader, AssetMetaCheck, LoadContext, LoadState, LoadedFolder, io::Reader}, asset::{AssetLoader, AssetMetaCheck, LoadContext, LoadState, LoadedFolder, io::Reader},
camera::primitives::*,
color::palettes::css::*, color::palettes::css::*,
gizmos::{aabb::AabbGizmoPlugin, light::LightGizmoPlugin}, gizmos::{aabb::AabbGizmoPlugin, light::LightGizmoPlugin},
input::{ input::{
@ -33,7 +34,7 @@ pub use bevy::{
platform::{collections::HashMap, hash::RandomState}, platform::{collections::HashMap, hash::RandomState},
prelude::*, prelude::*,
reflect::TypePath, reflect::TypePath,
sprite::AlphaMode2d, sprite_render::*,
window::{WindowResized, WindowResolution}, window::{WindowResized, WindowResolution},
}; };
pub use serde::Deserialize; pub use serde::Deserialize;

3
src/parallax.rs
Unescape Escape View File

@ -1,6 +1,3 @@
use bevy::render::mesh::MeshAabb;
use bevy::render::primitives::Aabb;
use super::*; use super::*;
pub struct ParallaxPlugin; pub struct ParallaxPlugin;

52
src/ui.rs
Unescape Escape View File

@ -40,41 +40,41 @@ impl Default for Style {
fn add_ui_button(added: Query<Entity, Added<Button>>, mut commands: Commands) { fn add_ui_button(added: Query<Entity, Added<Button>>, mut commands: Commands) {
fn over( fn over(
trigger: Trigger<Pointer<Over>>, event: On<Pointer<Over>>,
mut query: Query<&mut BorderColor>, mut query: Query<&mut BorderColor>,
style: Res<Style>, style: Res<Style>,
) { ) {
if let Ok(mut bc) = query.get_mut(trigger.target()) { if let Ok(mut bc) = query.get_mut(event.entity) {
debug!("pointer over {:?}", trigger.target()); debug!("pointer over {:?}", event.entity);
bc.0 = style.accent; bc.set_all(style.accent);
} }
} }
fn out(trigger: Trigger<Pointer<Out>>, mut query: Query<&mut BorderColor>, style: Res<Style>) { fn out(event: On<Pointer<Out>>, mut query: Query<&mut BorderColor>, style: Res<Style>) {
if let Ok(mut bc) = query.get_mut(trigger.target()) { if let Ok(mut bc) = query.get_mut(event.entity) {
debug!("pointer out {:?}", trigger.target()); debug!("pointer out {:?}", event.entity);
bc.0 = style.secondary; bc.set_all(style.secondary);
} }
} }
fn pressed( fn pressed(
trigger: Trigger<Pointer<Pressed>>, event: On<Pointer<Press>>,
mut query: Query<&mut BackgroundColor>, mut query: Query<&mut BackgroundColor>,
style: Res<Style>, style: Res<Style>,
) { ) {
if let Ok(mut bg) = query.get_mut(trigger.target()) { if let Ok(mut bg) = query.get_mut(event.entity) {
debug!("pointer pressed {:?}", trigger.target()); debug!("pointer pressed {:?}", event.entity);
bg.0 = style.accent; bg.0 = style.accent;
} }
} }
fn released( fn released(
trigger: Trigger<Pointer<Released>>, event: On<Pointer<Release>>,
mut query: Query<&mut BackgroundColor>, mut query: Query<&mut BackgroundColor>,
style: Res<Style>, style: Res<Style>,
) { ) {
if let Ok(mut bg) = query.get_mut(trigger.target()) { if let Ok(mut bg) = query.get_mut(event.entity) {
debug!("pointer released {:?}", trigger.target()); debug!("pointer released {:?}", event.entity);
bg.0 = style.primary; bg.0 = style.primary;
} }
} }
@ -93,31 +93,31 @@ fn add_ui_button(added: Query<Entity, Added<Button>>, mut commands: Commands) {
fn add_ui_text(added: Query<Entity, Added<Text>>, mut commands: Commands) { fn add_ui_text(added: Query<Entity, Added<Text>>, mut commands: Commands) {
fn pressed( fn pressed(
trigger: Trigger<Pointer<Pressed>>, event: On<Pointer<Press>>,
mut query: Query<(&mut TextColor, &ChildOf)>, mut query: Query<(&mut TextColor, &ChildOf)>,
buttons: Query<Entity, With<Button>>, buttons: Query<Entity, With<Button>>,
style: Res<Style>, style: Res<Style>,
) { ) {
// ONLY DO THIS IF CHILD OF BUTTON // ONLY DO THIS IF CHILD OF BUTTON
if let Ok((mut tc, ChildOf(p))) = query.get_mut(trigger.target()) if let Ok((mut tc, ChildOf(p))) = query.get_mut(event.entity)
&& buttons.contains(*p) && buttons.contains(*p)
{ {
debug!("pointer pressed {:?}", trigger.target()); debug!("pointer pressed {:?}", event.entity);
tc.0 = style.primary; tc.0 = style.primary;
} }
} }
fn released( fn released(
trigger: Trigger<Pointer<Released>>, event: On<Pointer<Release>>,
mut query: Query<(&mut TextColor, &ChildOf)>, mut query: Query<(&mut TextColor, &ChildOf)>,
buttons: Query<Entity, With<Button>>, buttons: Query<Entity, With<Button>>,
style: Res<Style>, style: Res<Style>,
) { ) {
// ONLY DO THIS IF CHILD OF BUTTON // ONLY DO THIS IF CHILD OF BUTTON
if let Ok((mut tc, ChildOf(p))) = query.get_mut(trigger.target()) if let Ok((mut tc, ChildOf(p))) = query.get_mut(event.entity)
&& buttons.contains(*p) && buttons.contains(*p)
{ {
debug!("pointer released {:?}", trigger.target()); debug!("pointer released {:?}", event.entity);
tc.0 = style.secondary; tc.0 = style.secondary;
} }
} }
@ -152,7 +152,7 @@ fn add_ui_node(
// Add extra stuff for non-text nodes // Add extra stuff for non-text nodes
this.insert_if_new(BackgroundColor(style.primary)); this.insert_if_new(BackgroundColor(style.primary));
this.insert_if_new(BorderColor(style.secondary)); this.insert_if_new(BorderColor::all(style.secondary));
this.insert_if_new(BorderRadius::all(Val::Px(5.0))); this.insert_if_new(BorderRadius::all(Val::Px(5.0)));
} }
}) })
@ -193,20 +193,20 @@ pub fn sync_singleton_to_ui<C: Component + Default + Display>(
} }
/// Updates the scroll position of scrollable nodes in response to mouse input /// Updates the scroll position of scrollable nodes in response to mouse input
pub fn scroll(trigger: Trigger<Pointer<Scroll>>, mut scrollers: Query<&mut ScrollPosition>) { pub fn scroll(event: On<Pointer<Scroll>>, mut scrollers: Query<&mut ScrollPosition>) {
let Pointer { let Pointer {
event: Scroll { unit, x, y, .. }, event: Scroll { unit, x, y, .. },
.. ..
} = trigger.event(); } = event.event();
let (dx, dy) = match unit { let (dx, dy) = match unit {
MouseScrollUnit::Line => (x * 16.0, y * 16.0), MouseScrollUnit::Line => (x * 16.0, y * 16.0),
MouseScrollUnit::Pixel => (x * 1., y * 1.), MouseScrollUnit::Pixel => (x * 1., y * 1.),
}; };
if let Ok(mut pos) = scrollers.get_mut(trigger.target()) { if let Ok(mut pos) = scrollers.get_mut(event.entity) {
pos.offset_x -= dx; pos.x -= dx;
pos.offset_y -= dy; pos.y -= dy;
} }
} }

Write Preview
Loading…
Cancel
Save