target ui indicating health too (#17)

src/aim/mod.rs

@@ -0,0 +1,143 @@
+mod target_ui;
+
+use crate::{
+    billboards::Billboard,
+    player::{Player, PlayerRig},
+    tb_entities::EnemySpawn,
+};
+use bevy::prelude::*;
+use bevy_sprite3d::{Sprite3dBuilder, Sprite3dParams};
+use ops::sin;
+use std::f32::consts::PI;
+
+#[derive(Resource, Reflect)]
+#[reflect(Resource)]
+pub struct AimState {
+    pub target: Option<Entity>,
+    pub range: f32,
+    pub max_angle: f32,
+}
+
+impl Default for AimState {
+    fn default() -> Self {
+        Self {
+            target: None,
+            range: 40.,
+            max_angle: PI / 8.,
+        }
+    }
+}
+
+#[derive(Component, Reflect)]
+#[reflect(Component)]
+struct Marker;
+
+#[derive(Event)]
+enum MarkerEvent {
+    Spawn(Entity),
+    Despawn,
+}
+
+pub fn plugin(app: &mut App) {
+    app.init_resource::<AimState>();
+
+    app.add_plugins(target_ui::plugin);
+
+    app.add_systems(Update, (update, move_marker));
+    app.add_observer(marker_event);
+}
+
+fn marker_event(
+    trigger: Trigger<MarkerEvent>,
+    mut commands: Commands,
+    asset_server: Res<AssetServer>,
+    mut sprite_params: Sprite3dParams,
+    marker: Query<Entity, With<Marker>>,
+) {
+    for m in marker.iter() {
+        commands.entity(m).despawn_recursive();
+    }
+
+    let MarkerEvent::Spawn(target) = trigger.event() else {
+        return;
+    };
+
+    let selector = asset_server.load("ui/selector.png");
+
+    let id = commands
+        .spawn((
+            Name::new("aim-marker"),
+            Billboard,
+            Marker,
+            Transform::default(),
+            Sprite3dBuilder {
+                image: selector,
+                pixels_per_metre: 30.,
+                alpha_mode: AlphaMode::Blend,
+                unlit: true,
+                ..default()
+            }
+            .bundle(&mut sprite_params),
+        ))
+        .id();
+
+    commands.entity(*target).add_child(id);
+}
+
+fn update(
+    mut commands: Commands,
+    mut state: ResMut<AimState>,
+    query: Query<(Entity, &Transform), With<EnemySpawn>>,
+    player_pos: Query<&Transform, With<Player>>,
+    player_rot: Query<&Transform, With<PlayerRig>>,
+) {
+    let Some(player_pos) = player_pos.iter().next().map(|t| t.translation) else {
+        return;
+    };
+
+    let Some(player_forward) = player_rot.iter().next().map(|t| t.forward()) else {
+        return;
+    };
+
+    let mut new_target = None;
+    let mut target_distance = f32::MAX;
+
+    for (e, t) in query.iter() {
+        let delta = player_pos - t.translation;
+
+        let distance = delta.length();
+
+        if distance > state.range {
+            continue;
+        }
+
+        let angle = player_forward.angle_between(delta.normalize());
+
+        if angle < state.max_angle && distance < target_distance {
+            new_target = Some(e);
+            target_distance = distance;
+        }
+    }
+
+    if let Some(e) = state.target {
+        if commands.get_entity(e).is_none() {
+            state.target = None;
+            return;
+        }
+    }
+
+    if new_target != state.target {
+        if let Some(target) = new_target {
+            commands.trigger(MarkerEvent::Spawn(target));
+        } else {
+            commands.trigger(MarkerEvent::Despawn);
+        }
+        state.target = new_target;
+    }
+}
+
+fn move_marker(mut query: Query<&mut Transform, With<Marker>>, time: Res<Time>) {
+    for mut transform in query.iter_mut() {
+        transform.translation = Vec3::new(0., 3. + (sin(time.elapsed_secs() * 6.) * 0.2), 0.);
+    }
+}

src/aim/target_ui.rs

@@ -0,0 +1,160 @@
+use super::AimState;
+use crate::{
+    backpack::BackpackHead,
+    heads_ui::HeadsImages,
+    npc::{Hitpoints, NpcHead},
+};
+use bevy::prelude::*;
+
+#[derive(Component, Reflect, Default)]
+#[reflect(Component)]
+struct HeadImage;
+
+#[derive(Component, Reflect, Default)]
+#[reflect(Component)]
+struct HeadDamage;
+
+#[derive(Resource, Default, PartialEq)]
+struct TargetUi {
+    head: Option<BackpackHead>,
+}
+
+pub fn plugin(app: &mut App) {
+    app.add_systems(Startup, setup);
+    app.add_systems(Update, (sync, update));
+}
+
+fn setup(mut commands: Commands, asset_server: Res<AssetServer>) {
+    let bg = asset_server.load("ui/head_bg.png");
+    let regular = asset_server.load("ui/head_regular.png");
+    let damage = asset_server.load("ui/head_damage.png");
+
+    commands
+        .spawn((
+            Name::new("target-ui"),
+            Node {
+                position_type: PositionType::Absolute,
+                top: Val::Px(150.0),
+                left: Val::Px(20.0),
+                height: Val::Px(74.0),
+                ..default()
+            },
+        ))
+        .with_children(|parent| {
+            spawn_head_ui(parent, bg.clone(), regular.clone(), damage.clone());
+        });
+
+    commands.insert_resource(TargetUi::default());
+}
+
+fn spawn_head_ui(
+    parent: &mut ChildBuilder,
+    bg: Handle<Image>,
+    regular: Handle<Image>,
+    damage: Handle<Image>,
+) {
+    const SIZE: f32 = 90.0;
+    const DAMAGE_SIZE: f32 = 74.0;
+
+    parent
+        .spawn((Node {
+            position_type: PositionType::Relative,
+            justify_content: JustifyContent::Center,
+            align_items: AlignItems::Center,
+            width: Val::Px(SIZE),
+            ..default()
+        },))
+        .with_children(|parent| {
+            parent.spawn((
+                Node {
+                    position_type: PositionType::Absolute,
+                    ..default()
+                },
+                ImageNode::new(bg),
+            ));
+            parent.spawn((
+                Node {
+                    position_type: PositionType::Absolute,
+                    ..default()
+                },
+                ImageNode::default(),
+                Visibility::Hidden,
+                HeadImage,
+            ));
+            parent.spawn((
+                Node {
+                    position_type: PositionType::Absolute,
+                    ..default()
+                },
+                ImageNode::new(regular),
+            ));
+            parent
+                .spawn((Node {
+                    height: Val::Px(DAMAGE_SIZE),
+                    width: Val::Px(DAMAGE_SIZE),
+                    ..default()
+                },))
+                .with_children(|parent| {
+                    parent
+                        .spawn((
+                            HeadDamage,
+                            Node {
+                                position_type: PositionType::Absolute,
+                                display: Display::Block,
+                                overflow: Overflow::clip(),
+                                top: Val::Px(0.),
+                                left: Val::Px(0.),
+                                right: Val::Px(0.),
+                                height: Val::Percent(25.),
+                                ..default()
+                            },
+                        ))
+                        .with_child(ImageNode::new(damage));
+                });
+        });
+}
+
+fn update(
+    target: Res<TargetUi>,
+    heads_images: Res<HeadsImages>,
+    mut head_image: Query<
+        (&mut Visibility, &mut ImageNode),
+        (Without<HeadDamage>, With<HeadImage>),
+    >,
+    mut head_damage: Query<&mut Node, (With<HeadDamage>, Without<HeadImage>)>,
+) {
+    if target.is_changed() {
+        if let Ok((mut vis, mut image)) = head_image.get_single_mut() {
+            if let Some(head) = target.head {
+                *vis = Visibility::Visible;
+                image.image = heads_images.heads[head.head].clone();
+            } else {
+                *vis = Visibility::Hidden;
+            }
+        }
+
+        if let Ok(mut node) = head_damage.get_single_mut() {
+            node.height = Val::Percent(target.head.map(|head| head.damage()).unwrap_or(0.) * 100.);
+        }
+    }
+}
+
+fn sync(
+    mut target: ResMut<TargetUi>,
+    aim: Res<AimState>,
+    target_data: Query<(&Hitpoints, &NpcHead)>,
+) {
+    let mut new_state = None;
+    if let Some(e) = aim.target {
+        if let Ok((hp, head)) = target_data.get(e) {
+            new_state = Some(BackpackHead {
+                head: head.0,
+                health: hp.health(),
+            });
+        }
+    }
+
+    if new_state != target.head {
+        target.head = new_state;
+    }
+}