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"]
[dependencies.avian3d]
version = "0.3.1"
version = "0.4.1"
[dependencies.avian2d]
version = "0.3.1"
version = "0.4.1"
[dependencies.bevy]
version = "0.16.1"
version = "0.17.2"
features = ["wayland", "dynamic_linking"]
[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);
fn track_camera_movement(
@ -93,7 +93,7 @@ fn track_camera_movement(
}
fn parallax(
mut events: EventReader<CameraMovement>,
mut events: MessageReader<CameraMovement>,
mut query: Query<(&mut Transform, &ParallaxDistance)>,
) {
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,
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)
.run();
@ -88,18 +88,18 @@ fn setup(
}
fn set_tree_position(
trigger: Trigger<OnAdd, TreePos>,
event: On<Add, TreePos>,
tree_pos: Query<&TreePos>,
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 {
(200.0 * (*pos) as f32) - 100.0
} else {
(200.0 * (*pos) as f32) + 100.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(
@ -132,8 +132,8 @@ fn draw_gizmos(mut gizmos: Gizmos, play_area: Single<&GlobalTransform, With<Rend
}
fn event_detection(
mut start_events: EventReader<CollisionStarted>,
mut end_events: EventReader<CollisionEnded>,
mut start_events: MessageReader<CollisionStarted>,
mut end_events: MessageReader<CollisionEnded>,
player: Single<&Player>,
trees: Query<&TreePos>,
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
fn process_events(
mut events: EventReader<CollisionEvent>,
mut events: MessageReader<CollisionEvent>,
areas: Query<&AreaMarker>,
mut inside: ResMut<InsideArea>,
) {

4
examples/sync_resource_to_ui.rs
Unescape Escape View File

@ -9,7 +9,7 @@ fn main() {
Update,
(
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();
@ -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(|_| {
thing.0 = thing.0.overflowing_add(1).0;
});

6
examples/ui.rs
Unescape Escape View File

@ -15,7 +15,7 @@ fn main() {
Update,
(
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();
@ -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
fn control_menu(
mut over_events: EventReader<Pointer<Over>>,
mut out_events: EventReader<Pointer<Out>>,
mut over_events: MessageReader<Pointer<Over>>,
mut out_events: MessageReader<Pointer<Out>>,
children: Query<&ChildOf>,
parents: Query<&Children>,
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)),
// TODO: Add run_if to this system
update_batch_position.run_if(any_component_changed::<Batch>),
move_batches.run_if(on_event::<CollisionStarted>.or(on_event::<CollisionEnded>)),
manage_score.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_message::<CollisionStarted>.or(on_message::<CollisionEnded>)),
shimmer_button::<RewindButton>.run_if(in_state(PlayerState::Stasis)),
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 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.
fn populate_batch(
trigger: Trigger<OnAdd, Batch>,
event: On<Add, Batch>,
batches: Query<&Batch>,
children: Query<&ChildOf>,
mut commands: Commands,
) {
// Only run this for top level batch entities,
// not children containing a reference to their batch, like hitboxes
if !children.contains(trigger.target()) {
let Batch(batch_id) = batches.get(trigger.target()).unwrap();
if !children.contains(event.entity) {
let Batch(batch_id) = batches.get(event.entity).unwrap();
commands
.entity(trigger.target())
.entity(event.entity)
.insert((
Transform::from_xyz(500.0 * (*batch_id) as f32, 0.0, 0.0),
Visibility::Inherited,
@ -313,14 +313,14 @@ fn update_batch_position(
}
fn populate_ground(
trigger: Trigger<OnAdd, Ground>,
event: On<Add, Ground>,
grounds: Query<&Ground>,
ground_assets: Res<GroundAssets>,
mut commands: Commands,
) {
let Ground(idx) = grounds.get(trigger.target()).unwrap();
let Ground(idx) = grounds.get(event.entity).unwrap();
debug!("populating ground {:?}", idx);
commands.entity(trigger.target()).insert((
commands.entity(event.entity).insert((
ground_assets.material.clone(),
ground_assets.mesh.clone(),
Name::new("ground"),
@ -331,14 +331,14 @@ fn populate_ground(
}
fn populate_ceiling(
trigger: Trigger<OnAdd, Ceiling>,
event: On<Add, Ceiling>,
ceiling: Query<&Ceiling>,
ceiling_assets: Res<CeilingAssets>,
mut commands: Commands,
) {
let Ceiling(idx) = ceiling.get(trigger.target()).unwrap();
let Ceiling(idx) = ceiling.get(event.entity).unwrap();
debug!("populating ceiling{:?}", idx);
commands.entity(trigger.target()).insert((
commands.entity(event.entity).insert((
ceiling_assets.material.clone(),
ceiling_assets.mesh.clone(),
Name::new("ceiling"),
@ -349,11 +349,11 @@ fn populate_ceiling(
}
fn move_pipe(
trigger: Trigger<OnInsert, Batch>,
event: On<OnInsert, Batch>,
mut pipes: Query<(&Batch, &Pipe, &mut Transform)>,
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 =
{
let offset = {
@ -382,14 +382,14 @@ fn move_pipe(
/// Based on if this is a Top or Bottom pipe the placement changes
/// Otherwise this just spawns in the center of the batch.
fn populate_pipe(
trigger: Trigger<OnAdd, Pipe>,
event: On<Add, Pipe>,
pipes: Query<(&Batch, &Pipe)>,
pipe_assets: Res<PipeAssets>,
mut commands: Commands,
rand: Res<Rand>,
) {
let pipe_t = {
let (Batch(id), pipe) = pipes.get(trigger.target()).unwrap();
let (Batch(id), pipe) = pipes.get(event.entity).unwrap();
let offset = {
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_assets.material.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
/// passes between the pipes it registers a point
fn populate_hitbox(trigger: Trigger<OnAdd, Hitbox>, mut commands: Commands) {
commands.entity(trigger.target()).insert((
fn populate_hitbox(event: On<Add, Hitbox>, mut commands: Commands) {
commands.entity(event.entity).insert((
RigidBody::Static,
Collider::rectangle(1.0, 10.0),
Sensor,
@ -517,7 +517,7 @@ fn init_ui(mut commands: Commands, server: Res<AssetServer>) {
},
BorderRadius::all(Val::Px(5.0)),
BackgroundColor(Color::WHITE),
BorderColor(BLACK.into()),
BorderColor::all(BLACK),
PlayerState::Stasis,
))
.with_children(|parent| {
@ -569,7 +569,7 @@ fn init_ui(mut commands: Commands, server: Res<AssetServer>) {
},))
.with_children(|parent| {
fn show_credits(
_trigger: Trigger<Pointer<Click>>,
_event: On<Pointer<Click>>,
mut state: ResMut<NextState<PlayerState>>,
) {
state.set(PlayerState::Credits);
@ -579,7 +579,7 @@ fn init_ui(mut commands: Commands, server: Res<AssetServer>) {
.spawn((
Button,
BorderRadius::all(Val::Px(5.0)),
BorderColor(BLACK.into()),
BorderColor::all(BLACK),
Node { ..default() },
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"))]
{
fn quit_game(
_trigger: Trigger<Pointer<Click>>,
_event: On<Pointer<Click>>,
mut exit: EventWriter<AppExit>,
) {
warn!("Quitting game");
@ -598,7 +598,7 @@ fn init_ui(mut commands: Commands, server: Res<AssetServer>) {
parent
.spawn((
BorderRadius::all(Val::Px(5.0)),
BorderColor(BLACK.into()),
BorderColor::all(BLACK),
Button,
Node { ..default() },
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)
}
@ -624,7 +624,7 @@ fn init_ui(mut commands: Commands, server: Res<AssetServer>) {
},
BorderRadius::all(Val::Px(5.0)),
BackgroundColor(WHITE.into()),
BorderColor(BLACK.into()),
BorderColor::all(BLACK),
PlayerState::Credits,
children![(
Text::new(credits_str),
@ -639,7 +639,7 @@ fn init_ui(mut commands: Commands, server: Res<AssetServer>) {
..default()
},
BorderRadius::all(Val::Px(5.0)),
BorderColor(BLACK.into()),
BorderColor::all(BLACK),
Button,
children![(Text::new("Close"), TextColor(BLACK.into()))],
));
@ -679,7 +679,7 @@ fn init_ui(mut commands: Commands, server: Res<AssetServer>) {
..default()
},
BorderRadius::all(Val::Px(5.0)),
BorderColor(BLACK.into()),
BorderColor::all(BLACK),
Text::new("(paused)"),
TextColor(BLACK.into()),
)
@ -714,7 +714,7 @@ fn init_ui(mut commands: Commands, server: Res<AssetServer>) {
..default()
},
BorderRadius::all(Val::Px(5.0)),
BorderColor(BLACK.into()),
BorderColor::all(BLACK),
BackgroundColor(Color::WHITE.with_alpha(0.9)),
Button,
RewindButton,
@ -757,7 +757,7 @@ fn init_ui(mut commands: Commands, server: Res<AssetServer>) {
..default()
},
BorderRadius::all(Val::Px(5.0)),
BorderColor(BLACK.into()),
BorderColor::all(BLACK),
BackgroundColor(Color::WHITE.with_alpha(0.9)),
Button,
FlapButton,
@ -792,7 +792,7 @@ fn init_ui(mut commands: Commands, server: Res<AssetServer>) {
},
BorderRadius::all(Val::Px(5.0)),
BackgroundColor(Color::WHITE),
BorderColor(BLACK.into()),
BorderColor::all(BLACK),
children![(
SyncResource::<Score>::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);
}
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);
}
fn flap_button(
_trigger: Trigger<Pointer<Pressed>>,
_event: On<Pointer<Pressed>>,
mut commands: Commands,
bird: Single<Entity, With<Bird>>,
curr: Res<State<PlayerState>>,
@ -865,7 +865,7 @@ fn flap_button(
}
let e = *bird;
debug!("Flapping {:?}", e);
commands.trigger_targets(Flap, e);
commands.event_targets(Flap, e);
}
/// 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);
}
#[derive(Component, Clone, Event)]
#[derive(Component, Clone, Message)]
struct Flap;
// Observer for flapping
fn flap(
trigger: Trigger<Flap>,
event: On<Flap>,
mut bird: Query<&mut ExternalImpulse, With<Bird>>,
mut flaps: ResMut<Flaps>,
) {
debug!("real flap for {:?}", trigger.target());
debug!("real flap for {:?}", event.entity);
// Increment flap stat
flaps.0 += 1;
// 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);
}
}
@ -916,7 +916,7 @@ fn flap_kb(
birds.iter().for_each(|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(
mut start: EventReader<CollisionStarted>,
mut end: EventReader<CollisionEnded>,
mut start: MessageReader<CollisionStarted>,
mut end: MessageReader<CollisionEnded>,
state: Res<State<PlayerState>>,
hitboxes: Query<&Batch, With<Hitbox>>,
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
/// This includes root batch entities as well as pipes and hitboxes
fn move_batches(
mut start: EventReader<CollisionStarted>,
mut end: EventReader<CollisionEnded>,
mut start: MessageReader<CollisionStarted>,
mut end: MessageReader<CollisionEnded>,
hitboxes: Query<Entity, With<Hitbox>>,
batches: Query<(Entity, &Batch)>,
state: Res<State<PlayerState>>,

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

@ -53,7 +53,7 @@ fn main() {
.add_systems(
Update,
(
kb_input.run_if(on_event::<KeyboardInput>),
kb_input.run_if(on_message::<KeyboardInput>),
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)),
..default()
},
BorderColor(WHITE.into()),
BorderColor(WHITE),
))
.with_children(|parent| {
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)),
..default()
},
BorderColor(WHITE.into()),
BorderColor(WHITE),
))
.with_children(|parent| {
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(
mut changed: Query<
(Entity, &GridPosition, &mut Transform),
@ -792,7 +792,7 @@ fn update_position(
});
}
// TODO: Move to trigger
// TODO: Move to event
fn update_shape_blocks(
query: Query<
(Entity, &Shape, &GridPosition),
@ -832,7 +832,7 @@ fn update_shape_blocks(
}
fn kb_input(
mut events: EventReader<KeyboardInput>,
mut events: MessageReader<KeyboardInput>,
mut query: Query<(Entity, &mut Shape)>,
curr: Res<State<GameState>>,
mut next: ResMut<NextState<GameState>>,
@ -848,22 +848,22 @@ fn kb_input(
// Up arrow should rotate if in falling mode
// Only move up if in falling::off mode
KeyCode::ArrowUp => {
commands.entity(e).trigger(Movement::Rotate);
commands.entity(e).event(Movement::Rotate);
}
KeyCode::ArrowDown => {
commands.entity(e).trigger(Movement::Down);
commands.entity(e).event(Movement::Down);
}
KeyCode::ArrowLeft => {
commands.entity(e).trigger(Movement::Left);
commands.entity(e).event(Movement::Left);
}
KeyCode::ArrowRight => {
commands.entity(e).trigger(Movement::Right);
commands.entity(e).event(Movement::Right);
}
KeyCode::Enter => {
commands.entity(e).trigger(Movement::Skip);
commands.entity(e).event(Movement::Skip);
}
KeyCode::Space => {
commands.entity(e).trigger(Swap);
commands.entity(e).event(Swap);
}
KeyCode::Escape => next.set(match curr.get() {
GameState::Falling => GameState::Pause,
@ -887,7 +887,7 @@ fn kb_input(
fn falling(mut shape: Query<Entity, With<Shape>>, mut commands: Commands) {
shape.iter_mut().for_each(|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
#[derive(Event, Copy, Clone, PartialEq)]
#[derive(Message, Copy, Clone, PartialEq)]
struct Swap;
/// Movement events triggered on the piece
#[derive(Event, Copy, Clone, PartialEq)]
/// Movement events evented on the piece
#[derive(Message, Copy, Clone, PartialEq)]
enum Movement {
Down,
Left,
@ -1018,7 +1018,7 @@ enum Movement {
// TODO: When out of bounds left/right, try to move piece away from wall
fn movement(
trigger: Trigger<Movement>,
event: On<Movement>,
mut grid_positions: Query<
&mut GridPosition,
Or<(With<ShapeBlock>, With<ShapeBlocks>, Without<LineBlock>)>,
@ -1028,10 +1028,10 @@ fn movement(
mut commands: Commands,
) {
if let (Ok(this_shape), Ok(center)) = (
shape.get_mut(trigger.target()),
grid_positions.get(trigger.target()),
shape.get_mut(event.entity),
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::Left => 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)))
.collect(),
};
let new_shape = match trigger.event() {
let new_shape = match event.event() {
Movement::Down | Movement::Left | Movement::Right | Movement::Skip => *this_shape,
Movement::Rotate => this_shape.rotated(),
};
@ -1053,7 +1053,7 @@ fn movement(
match position {
Err(GameError::OutOfBoundsLeft) | Err(GameError::OutOfBoundsRight) => (), // Do nothing
Err(GameError::OutOfBoundsDown) => {
commands.entity(trigger.target()).remove::<Shape>();
commands.entity(event.entity).remove::<Shape>();
}
Err(GameError::Collision) => panic!("This shouldn't happen!"),
Ok(new_center) => {
@ -1064,7 +1064,7 @@ fn movement(
return;
} // Do nothing
Err(GameError::OutOfBoundsDown) => {
commands.entity(trigger.target()).remove::<Shape>();
commands.entity(event.entity).remove::<Shape>();
return;
}
Err(GameError::Collision) => panic!("This shouldn't happen!"),
@ -1073,9 +1073,9 @@ fn movement(
// If there would be a collision between blocks
if gp == *other_gp {
// And we are moving down
if *trigger.event() == Movement::Down {
if *event.event() == Movement::Down {
// De-activate this piece
commands.entity(trigger.target()).remove::<Shape>();
commands.entity(event.entity).remove::<Shape>();
}
// Regardless, cancel the move
return;
@ -1087,22 +1087,22 @@ fn movement(
debug!("Checks passed for {position:?}, committing change");
// 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;
// Update shape/rotation
let mut s = shape.get_mut(trigger.target()).unwrap();
let mut s = shape.get_mut(event.entity).unwrap();
*s = new_shape;
}
}
}
} else {
warn!("Triggered movement on non-shape entity");
warn!("Oned movement on non-shape entity");
}
}
fn swap(
trigger: Trigger<Swap>,
event: On<Swap>,
mut shapes: Query<&mut Shape>,
mut store: ResMut<ShapeStore>,
mut commands: Commands,
@ -1112,16 +1112,16 @@ fn swap(
None => {
// Copy current shape into store
// De-activate entity
store.0 = Some(*shapes.get(trigger.target()).unwrap());
store.0 = Some(*shapes.get(event.entity).unwrap());
commands
.entity(trigger.target())
.entity(event.entity)
.despawn_related::<ShapeBlocks>()
.despawn();
}
Some(inner) => {
// Copy current shape into store
// 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));
}
}
@ -1209,16 +1209,16 @@ fn sync_health(
})
}
#[derive(Event)]
#[derive(Message)]
struct Damage {
quantity: f32
}
fn deal_damage(
trigger: Trigger<Damage>,
event: On<Damage>,
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(
@ -1228,7 +1228,7 @@ fn damage_on_place_shape(
) {
events.read().for_each(|_| {
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(|_| {
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>>,
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(
Update,
(
(spawn_debug_buttons.run_if(on_event::<AssetEvent<Monologue>>),),
(spawn_debug_buttons.run_if(on_message::<AssetEvent<Monologue>>),),
(
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>),
clear_monologue.run_if(any_component_changed::<NavState>),
control_menu.run_if(on_event::<Pointer<Over>>.or(on_event::<Pointer<Out>>)),
delete_tree.run_if(on_event::<Pointer<Click>>),
drag_tree.run_if(on_event::<Pointer<Drag>>),
control_menu.run_if(on_message::<Pointer<Over>>.or(on_message::<Pointer<Out>>)),
delete_tree.run_if(on_message::<Pointer<Click>>),
drag_tree.run_if(on_message::<Pointer<Drag>>),
)
.run_if(in_state(DebuggingState::On)),
),
@ -35,7 +35,7 @@ struct MonologuesList;
struct MonologuePreview;
fn drag_tree(
mut events: EventReader<Pointer<Drag>>,
mut events: MessageReader<Pointer<Drag>>,
state: Res<State<DebuggingState>>,
mut query: Query<&mut Transform, With<Tree>>,
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
fn control_menu(
mut over_events: EventReader<Pointer<Over>>,
mut out_events: EventReader<Pointer<Out>>,
mut over_events: MessageReader<Pointer<Over>>,
mut out_events: MessageReader<Pointer<Out>>,
nav_children: Query<&NavParent>,
children: Query<&ChildOf>,
nav_parents: Query<&NavChildren>,
@ -207,9 +207,9 @@ fn control_menu(
/// 1. Add the Button component
/// 2. Change the color to Orange
/// 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
.entity(trigger.target())
.entity(event.entity)
.insert(Button)
.insert(Node {
width: Val::Percent(100.0),
@ -223,16 +223,16 @@ fn add_dialog_option(trigger: Trigger<OnAdd, DialogOption>, mut commands: Comman
}
fn assign_monologue_event(
trigger: Trigger<Pointer<Click>>,
event: On<Pointer<Click>>,
mut events: EventWriter<AssignMonologue>,
monologues: Query<&TreeMonologue>,
) {
let TreeMonologue(handle) = monologues.get(trigger.target()).unwrap();
let TreeMonologue(handle) = monologues.get(event.entity).unwrap();
events.write(AssignMonologue(handle.clone()));
}
/// 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));
}
@ -261,7 +261,7 @@ fn hide_menu(mut nodes: Query<(&mut Visibility, &NavState), Changed<NavState>>)
}
fn delete_tree(
mut events: EventReader<Pointer<Click>>,
mut events: MessageReader<Pointer<Click>>,
mut commands: Commands,
query: Query<Entity, With<Tree>>,
) {
@ -275,21 +275,21 @@ fn delete_tree(
/// Add the "script: path/to/file.mono" tooltip info
fn monologue_asset_tooltip(
mut over_events: EventReader<Pointer<Over>>,
mut out_events: EventReader<Pointer<Out>>,
mut over_events: MessageReader<Pointer<Over>>,
mut out_events: MessageReader<Pointer<Out>>,
mut tooltip: ResMut<ToolTip>,
trees: Query<(&Tree, Option<&TreeMonologue>)>,
) {
out_events
.read()
.filter_map(|Pointer { target, .. }| trees.contains(*target).then_some(*target))
.filter_map(|Pointer { entity, .. }| trees.contains(*entity).then_some(*entity))
.for_each(|_| {
tooltip.remove("Script");
});
over_events
.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) {
Ok((_tree, Some(TreeMonologue(handle)))) => match handle.path() {
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:
fn choose_dialog_option(
trigger: Trigger<Pointer<Click>>,
event: On<Pointer<Click>>,
mut dialog_events: EventWriter<DialogEvent>,
mut commands: Commands,
texts: Query<&Text>,
options: Query<Entity, With<DialogOption>>,
dialog_box: Single<Entity, With<DialogBox>>,
) {
debug!("Choosing dialog {:?}", trigger.target());
debug!("Choosing dialog {:?}", event.entity);
debug!("Despawning dialog options");
options.iter().for_each(|e| {
@ -319,25 +319,25 @@ fn choose_dialog_option(
});
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| {
parent.spawn((t.clone(), DialogLine));
});
}
// trigger the next dialog line
// event the next dialog line
dialog_events.write(DialogEvent::NextBatch);
}
fn preview_monologue(
trigger: Trigger<Pointer<Over>>,
event: On<Pointer<Over>>,
container: Single<Entity, (With<MonologuePreview>, Without<Button>, Without<Text>)>,
tree_monologue: Query<&TreeMonologue, With<Button>>,
monologues: Res<Assets<Monologue>>,
mut commands: Commands,
) {
// 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
if let Some(monologue) = monologues.get(handle) {
commands.entity(*container).despawn_related::<Children>();
@ -366,7 +366,7 @@ fn preview_monologue(
}
fn spawn_debug_buttons(
mut events: EventReader<AssetEvent<Monologue>>,
mut events: MessageReader<AssetEvent<Monologue>>,
mut commands: Commands,
container: Single<Entity, (With<MonologuesList>, Without<Button>)>,
server: Res<AssetServer>,

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

@ -43,20 +43,20 @@ fn main() {
start_dialog
.run_if(in_state(DebuggingState::Off))
.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)
end_dialog
.run_if(in_state(DebuggingState::Off))
.run_if(in_state(DialogState::Idle))
.run_if(on_event::<Pointer<Click>>),
handle_plant_tree.run_if(on_event::<PlantTree>),
.run_if(on_message::<Pointer<Click>>),
handle_plant_tree.run_if(on_message::<PlantTree>),
assign_monologue_to_tree
.run_if(on_event::<AssignMonologue>)
.run_if(on_message::<AssignMonologue>)
.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>),
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)
@ -110,19 +110,19 @@ fn init_ui(mut commands: Commands) {
}
fn hover_dialog_box_over(
trigger: Trigger<Pointer<Over>>,
event: On<Pointer<Over>>,
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);
}
}
fn hover_dialog_box_out(
trigger: Trigger<Pointer<Out>>,
event: On<Pointer<Out>>,
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);
}
}
@ -162,7 +162,7 @@ struct DialogOption;
struct DialogLine;
/// Events that drive the dialog engine
#[derive(Event, PartialEq)]
#[derive(Message, PartialEq)]
enum DialogEvent {
Start(Entity, Handle<Monologue>),
NextBatch,
@ -183,7 +183,7 @@ enum DialogState {
/// Start dialog
fn start_dialog(
mut click_events: EventReader<Pointer<Click>>,
mut click_events: MessageReader<Pointer<Click>>,
mut dialog_events: EventWriter<DialogEvent>,
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
fn end_dialog(
mut click_events: EventReader<Pointer<Click>>,
mut click_events: MessageReader<Pointer<Click>>,
mut dialog_events: EventWriter<DialogEvent>,
query: Query<Entity, Or<(With<TreeMonologue>, With<DialogBox>, With<DialogOption>)>>,
) {
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) {
dialog_events.write(DialogEvent::End);
}
@ -214,7 +214,7 @@ fn end_dialog(
/// System which puts DialogOptions into the DialogBox
fn dialog_engine(
// React to dialog events
mut events: EventReader<DialogEvent>,
mut events: MessageReader<DialogEvent>,
// Reference to DialogBox
dialog_box: Single<Entity, With<DialogBox>>,
// EntityCommands for Dialog Box
@ -234,7 +234,7 @@ fn dialog_engine(
) {
debug_assert!(
!events.is_empty(),
"Dialog engine is triggered by Dialog Events"
"Dialog engine is evented by Dialog Events"
);
events.read().for_each(|event| {
@ -300,20 +300,20 @@ fn dialog_engine(
}
fn hover_dialog_option_over(
trigger: Trigger<Pointer<Over>>,
event: On<Pointer<Over>>,
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());
bg.0.set_alpha(1.0);
}
}
fn hover_dialog_option_out(
trigger: Trigger<Pointer<Out>>,
event: On<Pointer<Out>>,
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());
bg.0.set_alpha(0.0);
}
@ -331,12 +331,12 @@ fn dialog_box_visibility(
}
fn add_tree_monologue(
trigger: Trigger<OnAdd, TreeMonologue>,
event: On<Add, TreeMonologue>,
query: Query<&MeshMaterial3d<StandardMaterial>>,
mut materials: ResMut<Assets<StandardMaterial>>,
) {
// 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
if let Some(material) = materials.get_mut(handle) {
material.base_color = WHITE.with_alpha(1.0).into();
@ -345,12 +345,12 @@ fn add_tree_monologue(
}
fn remove_tree_monologue(
trigger: Trigger<OnRemove, TreeMonologue>,
event: On<Remove, TreeMonologue>,
query: Query<&MeshMaterial3d<StandardMaterial>>,
mut materials: ResMut<Assets<StandardMaterial>>,
) {
// 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
if let Some(material) = materials.get_mut(handle) {
// 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");
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>>>) {
*loaded_assets = include_str!("../../../assets/trees/MONOLOGUES")
.split("\n")
@ -396,13 +396,13 @@ fn load_monologues(server: ResMut<AssetServer>, mut loaded_assets: Local<Vec<Han
.collect();
}
#[derive(Event)]
#[derive(Message)]
struct PlantTree(Option<Handle<Monologue>>);
/// Plan a tree in the world
/// Handles random placement, 3d model, materials, and observers
fn handle_plant_tree(
mut events: EventReader<PlantTree>,
mut events: MessageReader<PlantTree>,
mut assignments: EventWriter<AssignMonologue>,
trees: Query<Entity, With<Tree>>,
server: Res<AssetServer>,
@ -448,12 +448,12 @@ fn handle_plant_tree(
});
}
#[derive(Event, Debug)]
#[derive(Message, Debug)]
struct AssignMonologue(Handle<Monologue>);
/// Assign the given monologue to a tree
fn assign_monologue_to_tree(
mut events: EventReader<AssignMonologue>,
mut events: MessageReader<AssignMonologue>,
query: Query<Entity, (With<Tree>, Without<TreeMonologue>)>,
mut notice: ResMut<Notice>,
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>),
(
(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_update_transform.run_if(any_component_changed::<Transform>),
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),)],
GlobalZIndex(i32::MAX - 1),
BorderRadius::all(Val::Px(5.0)),
BorderColor(BLACK.into()),
BorderColor::all(BLACK),
BackgroundColor(Color::WHITE),
Node {
max_width: Val::Percent(50.0),
@ -100,7 +100,7 @@ fn init_debug_ui(mut commands: Commands) {
)],
GlobalZIndex(i32::MAX - 1),
BorderRadius::all(Val::Px(5.0)),
BorderColor(BLACK.into()),
BorderColor::all(BLACK),
BackgroundColor(Color::WHITE),
Node {
max_width: Val::Percent(50.0),
@ -129,7 +129,7 @@ fn init_debug_ui(mut commands: Commands) {
Name::new("Debug Indicator"),
GlobalZIndex(i32::MAX - 1),
BorderRadius::all(Val::Px(5.0)),
BorderColor(BLACK.into()),
BorderColor::all(BLACK),
BackgroundColor(Color::WHITE),
children![(Text("Debug: OFF".into()), TextColor(BLACK.into()),)],
Button,
@ -146,7 +146,7 @@ fn init_debug_ui(mut commands: Commands) {
..default()
},
BorderRadius::all(Val::Px(5.0)),
BorderColor(BLACK.into()),
BorderColor::all(BLACK),
BackgroundColor(Color::WHITE),
))
.with_children(|parent| {
@ -197,7 +197,7 @@ fn init_debug_ui(mut commands: Commands) {
Pickable::IGNORE,
GlobalZIndex(i32::MAX),
BorderRadius::all(Val::Px(5.0)),
BorderColor(BLACK.into()),
BorderColor::all(BLACK),
BackgroundColor(Color::WHITE),
Node {
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(
mut next: ResMut<NextState<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
fn add_tooltip_text(trigger: Trigger<OnAdd, ToolTip>, mut commands: Commands) {
info!("Adding text2d to {:?}", trigger.target());
commands.entity(trigger.target()).with_children(|parent| {
fn add_tooltip_text(event: On<Add, ToolTip>, mut commands: Commands) {
info!("Adding text2d to {:?}", event.entity);
commands.entity(event.entity).with_children(|parent| {
parent.spawn((
TextColor(BLACK.into()),
Text2d("Placeholder".into()),
Transform::from_xyz(0.5, 0.0, 1.0).with_scale(Vec3::splat(0.01)),
Anchor::CenterLeft,
Anchor::CENTER_LEFT,
DebuggingState::On,
));
});
}
fn populate_tooltip_info(
trigger: Trigger<OnAdd, ToolTip>,
event: On<Add, ToolTip>,
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("Name", n.into());
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
fn remove_tooltip_text(
trigger: Trigger<OnRemove, ToolTip>,
event: On<Remove, ToolTip>,
mut commands: Commands,
parents: Query<&Children>,
text_2d: Query<Entity, With<Text2d>>,
) {
// 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
if let Some(child) = children.iter().find_map(|child| text_2d.get(child).ok()) {
// Remove it from the world
@ -381,14 +381,14 @@ fn tooltip_draw(
/// When you hover over a mesh, update the tooltip with some info
fn hover_mesh(
mut over_events: EventReader<Pointer<Over>>,
mut out_events: EventReader<Pointer<Out>>,
mut over_events: MessageReader<Pointer<Over>>,
mut out_events: MessageReader<Pointer<Out>>,
mut tooltip: ResMut<ToolTip>,
meshes: Query<(&Transform, Option<&Name>), Or<(With<Mesh3d>, With<Mesh2d>)>>,
) {
out_events
.read()
.filter_map(|Pointer { target, .. }| meshes.contains(*target).then_some(*target))
.filter_map(|Pointer { entity, .. }| meshes.contains(*entity).then_some(*entity))
.for_each(|_| {
tooltip.remove("ID");
tooltip.remove("Pos");
@ -396,7 +396,7 @@ fn hover_mesh(
});
over_events
.read()
.filter_map(|Pointer { target, .. }| meshes.contains(*target).then_some(*target))
.filter_map(|Pointer { entity, .. }| meshes.contains(*entity).then_some(*entity))
.for_each(|e| {
if let Ok((t, n)) = meshes.get(e) {
let pos = (t.translation.x, t.translation.y, t.translation.z);
@ -414,21 +414,21 @@ fn hover_mesh(
}
fn hover_ui(
mut over_events: EventReader<Pointer<Over>>,
mut out_events: EventReader<Pointer<Out>>,
mut over_events: MessageReader<Pointer<Over>>,
mut out_events: MessageReader<Pointer<Out>>,
mut tooltip: ResMut<ToolTip>,
nodes: Query<Option<&Name>, With<Node>>,
) {
out_events
.read()
.filter_map(|Pointer { target, .. }| nodes.contains(*target).then_some(*target))
.filter_map(|Pointer { entity, .. }| nodes.contains(*entity).then_some(*entity))
.for_each(|_| {
tooltip.remove("ID");
tooltip.remove("Name");
});
over_events
.read()
.filter_map(|Pointer { target, .. }| nodes.contains(*target).then_some(*target))
.filter_map(|Pointer { entity, .. }| nodes.contains(*entity).then_some(*entity))
.for_each(|e| {
if let Ok(n) = nodes.get(e) {
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
fn toggle_debug(
_trigger: Trigger<Pointer<Click>>,
_event: On<Pointer<Click>>,
curr: Res<State<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>) {
if let Ok(mut v) = query.get_mut(trigger.target()) {
fn close_on_click(event: On<Pointer<Click>>, mut query: Query<&mut Visibility>) {
if let Ok(mut v) = query.get_mut(event.entity) {
*v = Visibility::Hidden;
}
}

3
src/lib.rs
Unescape Escape View File

@ -20,6 +20,7 @@ pub use std::fmt::Display;
// Community libraries
pub use bevy::{
asset::{AssetLoader, AssetMetaCheck, LoadContext, LoadState, LoadedFolder, io::Reader},
camera::primitives::*,
color::palettes::css::*,
gizmos::{aabb::AabbGizmoPlugin, light::LightGizmoPlugin},
input::{
@ -33,7 +34,7 @@ pub use bevy::{
platform::{collections::HashMap, hash::RandomState},
prelude::*,
reflect::TypePath,
sprite::AlphaMode2d,
sprite_render::*,
window::{WindowResized, WindowResolution},
};
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::*;
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 over(
trigger: Trigger<Pointer<Over>>,
event: On<Pointer<Over>>,
mut query: Query<&mut BorderColor>,
style: Res<Style>,
) {
if let Ok(mut bc) = query.get_mut(trigger.target()) {
debug!("pointer over {:?}", trigger.target());
bc.0 = style.accent;
if let Ok(mut bc) = query.get_mut(event.entity) {
debug!("pointer over {:?}", event.entity);
bc.set_all(style.accent);
}
}
fn out(trigger: Trigger<Pointer<Out>>, mut query: Query<&mut BorderColor>, style: Res<Style>) {
if let Ok(mut bc) = query.get_mut(trigger.target()) {
debug!("pointer out {:?}", trigger.target());
bc.0 = style.secondary;
fn out(event: On<Pointer<Out>>, mut query: Query<&mut BorderColor>, style: Res<Style>) {
if let Ok(mut bc) = query.get_mut(event.entity) {
debug!("pointer out {:?}", event.entity);
bc.set_all(style.secondary);
}
}
fn pressed(
trigger: Trigger<Pointer<Pressed>>,
event: On<Pointer<Press>>,
mut query: Query<&mut BackgroundColor>,
style: Res<Style>,
) {
if let Ok(mut bg) = query.get_mut(trigger.target()) {
debug!("pointer pressed {:?}", trigger.target());
if let Ok(mut bg) = query.get_mut(event.entity) {
debug!("pointer pressed {:?}", event.entity);
bg.0 = style.accent;
}
}
fn released(
trigger: Trigger<Pointer<Released>>,
event: On<Pointer<Release>>,
mut query: Query<&mut BackgroundColor>,
style: Res<Style>,
) {
if let Ok(mut bg) = query.get_mut(trigger.target()) {
debug!("pointer released {:?}", trigger.target());
if let Ok(mut bg) = query.get_mut(event.entity) {
debug!("pointer released {:?}", event.entity);
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 pressed(
trigger: Trigger<Pointer<Pressed>>,
event: On<Pointer<Press>>,
mut query: Query<(&mut TextColor, &ChildOf)>,
buttons: Query<Entity, With<Button>>,
style: Res<Style>,
) {
// 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)
{
debug!("pointer pressed {:?}", trigger.target());
debug!("pointer pressed {:?}", event.entity);
tc.0 = style.primary;
}
}
fn released(
trigger: Trigger<Pointer<Released>>,
event: On<Pointer<Release>>,
mut query: Query<(&mut TextColor, &ChildOf)>,
buttons: Query<Entity, With<Button>>,
style: Res<Style>,
) {
// 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)
{
debug!("pointer released {:?}", trigger.target());
debug!("pointer released {:?}", event.entity);
tc.0 = style.secondary;
}
}
@ -152,7 +152,7 @@ fn add_ui_node(
// Add extra stuff for non-text nodes
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)));
}
})
@ -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
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 {
event: Scroll { unit, x, y, .. },
..
} = trigger.event();
} = event.event();
let (dx, dy) = match unit {
MouseScrollUnit::Line => (x * 16.0, y * 16.0),
MouseScrollUnit::Pixel => (x * 1., y * 1.),
};
if let Ok(mut pos) = scrollers.get_mut(trigger.target()) {
pos.offset_x -= dx;
pos.offset_y -= dy;
if let Ok(mut pos) = scrollers.get_mut(event.entity) {
pos.x -= dx;
pos.y -= dy;
}
}

Write Preview
Loading…
Cancel
Save