Crate unification (#88)

* move client/server/config into shared

* move platforms into shared

* move head drops into shared

* move tb_entities to shared

* reduce server to just a call into shared

* get solo play working

* fix server opening window

* fix fmt

* extracted a few more modules from client

* near completely migrated client

* fixed duplicate CharacterInputEnabled definition

* simplify a few things related to builds

* more simplifications

* fix warnings/check

* ci update

* address comments

* try fixing macos steam build

* address comments

* address comments

* CI tweaks with default client feature

---------

Co-authored-by: PROMETHIA-27 <electriccobras@gmail.com>

crates/hedz_reloaded/src/aim/mod.rs

@@ -0,0 +1,199 @@
+mod marker;
+mod target_ui;
+
+use crate::{
+    GameState, control::Inputs, head::ActiveHead, heads_database::HeadsDatabase,
+    hitpoints::Hitpoints, physics_layers::GameLayer, player::Player, tb_entities::EnemySpawn,
+};
+use avian3d::prelude::*;
+use bevy::prelude::*;
+use marker::MarkerEvent;
+use serde::{Deserialize, Serialize};
+use std::f32::consts::PI;
+
+#[derive(Component, Reflect, Default, Deref, PartialEq, Serialize, Deserialize)]
+#[reflect(Component)]
+pub struct AimTarget(pub Option<Entity>);
+
+#[derive(Component, Reflect, PartialEq, Serialize, Deserialize)]
+#[reflect(Component)]
+#[require(AimTarget)]
+pub struct AimState {
+    pub range: f32,
+    pub max_angle: f32,
+    pub spawn_marker: bool,
+}
+
+impl Default for AimState {
+    fn default() -> Self {
+        Self {
+            range: 80.,
+            max_angle: PI / 8.,
+            spawn_marker: true,
+        }
+    }
+}
+
+pub fn plugin(app: &mut App) {
+    app.register_type::<AimState>();
+    app.register_type::<AimTarget>();
+
+    app.add_plugins(target_ui::plugin);
+    app.add_plugins(marker::plugin);
+
+    app.add_systems(
+        Update,
+        (update_player_aim, update_npc_aim, head_change).run_if(in_state(GameState::Playing)),
+    );
+    app.add_systems(Update, add_aim);
+}
+
+fn add_aim(mut commands: Commands, query: Query<Entity, Added<ActiveHead>>) {
+    for e in query.iter() {
+        commands.entity(e).insert(AimState::default());
+    }
+}
+
+fn head_change(
+    mut query: Query<(&ActiveHead, &mut AimState), Changed<ActiveHead>>,
+    heads_db: Res<HeadsDatabase>,
+) {
+    for (head, mut state) in query.iter_mut() {
+        // info!("head changed: {}", head.0);
+        // state.max_angle = if head.0 == 0 { PI / 8. } else { PI / 2. }
+        let stats = heads_db.head_stats(head.0);
+        state.range = stats.range;
+    }
+}
+
+fn update_player_aim(
+    mut commands: Commands,
+    potential_targets: Query<(Entity, &Transform), With<Hitpoints>>,
+    mut player_aim: Query<
+        (Entity, &AimState, &mut AimTarget, &GlobalTransform, &Inputs),
+        With<Player>,
+    >,
+    spatial_query: SpatialQuery,
+) {
+    for (player, state, mut aim_target, global_tf, inputs) in player_aim.iter_mut() {
+        let (player_pos, player_forward) = (global_tf.translation(), inputs.look_dir);
+
+        let mut new_target = None;
+        let mut target_distance = f32::MAX;
+
+        for (e, t) in potential_targets.iter() {
+            if e == player {
+                continue;
+            }
+
+            let delta = t.translation - player_pos;
+
+            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 {
+                if !line_of_sight(&spatial_query, player_pos, delta, distance) {
+                    continue;
+                }
+
+                new_target = Some(e);
+                target_distance = distance;
+            }
+        }
+
+        if let Some(e) = &aim_target.0
+            && commands.get_entity(*e).is_err()
+        {
+            aim_target.0 = None;
+            return;
+        }
+
+        if new_target != aim_target.0 {
+            if state.spawn_marker {
+                if let Some(target) = new_target {
+                    commands.trigger(MarkerEvent::Spawn(target));
+                } else {
+                    commands.trigger(MarkerEvent::Despawn);
+                }
+            }
+            aim_target.0 = new_target;
+        }
+    }
+}
+
+fn update_npc_aim(
+    mut commands: Commands,
+    mut subject: Query<(&AimState, &Transform, &mut AimTarget), With<EnemySpawn>>,
+    potential_targets: Query<(Entity, &Transform), With<Player>>,
+    spatial_query: SpatialQuery,
+) {
+    for (state, t, mut aim_target) in subject.iter_mut() {
+        let (pos, forward) = (t.translation, t.forward());
+
+        let mut new_target = None;
+        let mut target_distance = f32::MAX;
+
+        for (e, t) in potential_targets.iter() {
+            let delta = t.translation - pos;
+
+            let distance = delta.length();
+
+            if distance > state.range {
+                continue;
+            }
+
+            let angle = forward.angle_between(delta.normalize());
+
+            if angle < state.max_angle && distance < target_distance {
+                if !line_of_sight(&spatial_query, pos, delta, distance) {
+                    continue;
+                }
+
+                new_target = Some(e);
+                target_distance = distance;
+            }
+        }
+
+        if let Some(e) = &aim_target.0
+            && commands.get_entity(*e).is_err()
+        {
+            aim_target.0 = None;
+            return;
+        }
+
+        if new_target != aim_target.0 {
+            aim_target.0 = new_target;
+        }
+    }
+}
+
+fn line_of_sight(
+    spatial_query: &SpatialQuery<'_, '_>,
+    player_pos: Vec3,
+    delta: Vec3,
+    distance: f32,
+) -> bool {
+    if let Some(_hit) = spatial_query.cast_shape(
+        &Collider::sphere(0.1),
+        player_pos + delta.normalize() + (Vec3::Y * 2.),
+        Quat::default(),
+        Dir3::new(delta).unwrap(),
+        &ShapeCastConfig {
+            max_distance: distance * 0.98,
+            compute_contact_on_penetration: false,
+            ignore_origin_penetration: true,
+            ..Default::default()
+        },
+        &SpatialQueryFilter::default().with_mask(LayerMask(GameLayer::Level.to_bits())),
+    ) {
+        // info!("no line of sight");
+        return false;
+    };
+
+    true
+}