update light indicator

Author: raybbian

src/game/lyra/beam.rs

@@ -18,7 +18,10 @@ use crate::{
             LightBeamSource, LightColor,
         },
         lighting::LineLight2d,
-        lyra::Lyra,
+        lyra::{
+            indicator::{LYRA_SHARD_HOLD_X, LYRA_SHARD_HOLD_Y},
+            Lyra,
+        },
         Layers, LevelSystems,
     },
     save::SaveParam,
@@ -284,20 +287,22 @@ pub fn handle_shoot_inputs(
 pub fn process_beam_actions(
     mut commands: Commands,
     mut beam_actions: MessageReader<BeamAction>,
-    lyra: Single<(&Transform, &mut PlayerLightInventory), With<Lyra>>,
+    lyra: Single<(&Transform, &mut PlayerLightInventory, &Sprite), With<Lyra>>,
     cursor: Single<&CursorWorldCoords>,
     // beam_assets: Res<BeamSourceAssets>,
 ) {
-    let (player_transform, player_inventory) = lyra.into_inner();
+    let (player_transform, player_inventory, lyra_sprite) = lyra.into_inner();
     let player_inventory = player_inventory.into_inner();
     for action in beam_actions.read() {
         match action {
             BeamAction::Shoot => {
                 if !player_inventory.can_shoot() {
                     continue;
                 }
+                let mult = if lyra_sprite.flip_x { -1. } else { 1. };
+                let desired_shard_pos = Vec3::new(mult * LYRA_SHARD_HOLD_X, LYRA_SHARD_HOLD_Y, 0.);
 
-                let ray_pos = player_transform.translation.truncate();
+                let ray_pos = (player_transform.translation + desired_shard_pos).truncate();
                 let mut ray_dir = (cursor.pos - ray_pos).normalize_or_zero();
                 if player_inventory.snapping {
                     ray_dir = snap_ray(ray_dir);
@@ -348,6 +353,11 @@ pub fn process_beam_actions(
                 player_inventory.snapping = *val;
             }
             BeamAction::Preview => {
+                if player_inventory.current_color == None
+                    || !player_inventory.can_shoot_color(player_inventory.current_color.unwrap())
+                {
+                    continue;
+                }
                 player_inventory.previewing = true;
                 player_inventory.should_shoot = true;
             }
@@ -377,21 +387,25 @@ pub struct LightPreviewGizmos;
 
 pub fn preview_light_path(
     spatial_query: SpatialQuery,
-    lyra: Single<(&Transform, &PlayerLightInventory), With<Lyra>>,
+    lyra: Single<(&Transform, &PlayerLightInventory, &Sprite), With<Lyra>>,
     cursor: Single<&CursorWorldCoords>,
     mut gizmos: Gizmos,
     q_mirror: Query<&Mirror>,
     // q_black_ray: Query<(Entity, &BlackRayComponent)>,
 ) {
-    let (transform, inventory) = lyra.into_inner();
+    let (transform, inventory, lyra_sprite) = lyra.into_inner();
     if !inventory.can_shoot() || !inventory.previewing {
         return;
     }
 
     let shoot_color = inventory.current_color.unwrap();
 
-    let ray_pos = transform.translation.truncate();
+    let mult = if lyra_sprite.flip_x { -1. } else { 1. };
+    let desired_shard_pos = Vec3::new(mult * LYRA_SHARD_HOLD_X, LYRA_SHARD_HOLD_Y, 0.);
+
+    let ray_pos = (transform.translation + desired_shard_pos).truncate();
     let mut ray_dir = (cursor.pos - ray_pos).normalize_or_zero();
+
     if inventory.snapping {
         ray_dir = snap_ray(ray_dir);
     }

src/game/lyra/indicator.rs

@@ -7,6 +7,7 @@ use enum_map::EnumMap;
 
 use crate::asset::LoadResource;
 use crate::camera::TERRAIN_LAYER;
+use crate::game::light::LightBeamSource;
 use crate::game::lighting::LineLight2d;
 use crate::game::lyra::spawn_lyra;
 use crate::ldtk::LdtkParam;
@@ -25,6 +26,8 @@ pub const LYRA_SHARD_HEIGHT_DELTA: f32 = 4.;
 pub const LYRA_SHARD_Y_OFFSET: f32 = -4.;
 pub const LYRA_SHARD_PEAK_SHIFT_RATE: f32 = 1.2;
 pub const LYRA_SHARD_MOVING_DELAY_MILLIS: u64 = 250;
+pub const LYRA_SHARD_HOLD_X: f32 = 4.;
+pub const LYRA_SHARD_HOLD_Y: f32 = -2.;
 
 pub struct LightIndicatorPlugin;
 
@@ -190,14 +193,28 @@ impl Default for ShardMovingState {
     }
 }
 
+#[derive(Component)]
+pub struct WasChilded;
+
 pub fn update_light_indicator(
-    lyra: Single<(&PlayerLightInventory, &Transform, &LinearVelocity), With<Lyra>>,
+    lyra: Single<
+        (
+            Entity,
+            &PlayerLightInventory,
+            &Transform,
+            &LinearVelocity,
+            &Sprite,
+        ),
+        With<Lyra>,
+    >,
+    q_transforms: Query<(&Transform, Has<WasChilded>), (Without<Lyra>, Without<LightBeamSource>)>,
+    q_beam_sources: Query<(&Transform, &LightBeamSource)>,
     mut commands: Commands,
     mut light_indicators: ResMut<LightIndicators>,
     time: Res<Time>,
     mut shard_moving_state: Local<ShardMovingState>,
 ) {
-    let (inventory, base_transform, linear_velocity) = lyra.into_inner();
+    let (lyra_entity, inventory, base_transform, linear_velocity, lyra_sprite) = lyra.into_inner();
     light_indicators.angle_offset += time.delta_secs();
 
     for (color, entity) in light_indicators.indicators {
@@ -212,29 +229,85 @@ pub fn update_light_indicator(
     let indicators: Vec<_> = light_indicators
         .indicators
         .iter()
-        .filter_map(|(c, entity)| {
-            if !inventory.can_shoot_color(c) {
-                return None;
-            }
-            entity.map(|e| (c, e))
-        })
+        .filter_map(|(c, e)| e.and_then(|e| Some((c, e))))
         .collect();
 
     let handle_shooting = |commands: &mut Commands, c: LightColor, entity: Entity| -> bool {
-        let is_shooting =
-            inventory.current_color.is_some_and(|color| color == c) && inventory.can_shoot();
-
+        let is_selected = inventory.current_color.is_some_and(|color| color == c);
+        let is_shooting = is_selected && inventory.can_shoot();
+        let Ok((indicator_transform, was_childed)) = q_transforms.get(entity) else {
+            return false;
+        };
+        // TODO: fixme use inverse transforms instead
         if is_shooting {
+            if !was_childed {
+                commands
+                    .entity(entity)
+                    .insert(Transform::from_translation(
+                        (indicator_transform.translation - base_transform.translation).with_z(1.),
+                    ))
+                    .insert(WasChilded)
+                    .insert(ChildOf(lyra_entity));
+            }
+            let mult = if lyra_sprite.flip_x { -1. } else { 1. };
+            commands.entity(entity).insert(LerpTranslation {
+                to: LerpTranslationTarget::Position(Vec3::new(
+                    mult * LYRA_SHARD_HOLD_X,
+                    LYRA_SHARD_HOLD_Y,
+                    0.,
+                )),
+                lerp: 0.2,
+            });
+            return true;
+        } else if !inventory.can_shoot_color(c) {
+            if was_childed {
+                commands
+                    .entity(entity)
+                    .remove::<ChildOf>()
+                    .remove::<WasChilded>()
+                    .insert(Transform::from_translation(
+                        base_transform.translation + indicator_transform.translation,
+                    ));
+            }
+            let Some((source_transform, _)) =
+                q_beam_sources.iter().find(|(_, source)| source.color == c)
+            else {
+                return true;
+            };
             commands.entity(entity).insert(LerpTranslation {
                 to: LerpTranslationTarget::Position(
-                    base_transform
+                    source_transform
                         .translation
-                        .with_z(base_transform.translation.z - 0.1),
+                        .with_z(source_transform.translation.z + 1.),
                 ),
-                lerp: 1.0,
+                lerp: 0.2,
+            });
+            return true;
+        } else if is_selected {
+            if !was_childed {
+                commands
+                    .entity(entity)
+                    .insert(Transform::from_translation(
+                        (indicator_transform.translation - base_transform.translation).with_z(1.),
+                    ))
+                    .insert(WasChilded)
+                    .insert(ChildOf(lyra_entity));
+            }
+            commands.entity(entity).insert(LerpTranslation {
+                to: LerpTranslationTarget::Position(Vec3::new(0., 13., 0.)),
+                lerp: 0.2,
             });
             return true;
         }
+        if was_childed {
+            commands
+                .entity(entity)
+                .remove::<ChildOf>()
+                .remove::<WasChilded>()
+                .insert(Transform::from_translation(
+                    base_transform.translation + indicator_transform.translation,
+                ));
+        }
         false
     };