rustunit/HEDZReloaded
1
0
Fork 0
Code Issues 2 Pull Requests 1 Actions 2 Packages Projects 1 Releases Wiki Activity

Revert "clippy fixes"

Browse Source 
This reverts commit f6e94cfd32.
This commit is contained in:
extrawurst
2025-06-29 10:54:59 +02:00
parent f6e94cfd32
commit 5d4c7630ef
65 changed files with 85 additions and 495 deletions
Download Patch File Download Diff File Expand all files Collapse all files

60
crates/shared/src/aim/marker.rs
View File

@@ -1,60 +0,0 @@
use crate::{GameState, global_observer, loading_assets::UIAssets, utils::billboards::Billboard};
use bevy::prelude::*;
use bevy_sprite3d::{Sprite3dBuilder, Sprite3dParams};
use ops::sin;
#[derive(Component, Reflect)]
#[reflect(Component)]
struct TargetMarker;
#[derive(Event)]
pub enum MarkerEvent {
Spawn(Entity),
Despawn,
}
pub fn plugin(app: &mut App) {
app.add_systems(Update, move_marker.run_if(in_state(GameState::Playing)));
global_observer!(app, marker_event);
}
fn move_marker(mut query: Query<&mut Transform, With<TargetMarker>>, time: Res<Time>) {
for mut transform in query.iter_mut() {
transform.translation = Vec3::new(0., 3. + (sin(time.elapsed_secs() * 6.) * 0.2), 0.);
}
}
fn marker_event(
trigger: Trigger<MarkerEvent>,
mut commands: Commands,
assets: Res<UIAssets>,
mut sprite_params: Sprite3dParams,
marker: Query<Entity, With<TargetMarker>>,
) {
for m in marker.iter() {
commands.entity(m).despawn();
}
let MarkerEvent::Spawn(target) = trigger.event() else {
return;
};
let id = commands
.spawn((
Name::new("aim-marker"),
Billboard::All,
TargetMarker,
Transform::default(),
Sprite3dBuilder {
image: assets.head_selector.clone(),
pixels_per_metre: 30.,
alpha_mode: AlphaMode::Blend,
unlit: true,
..default()
}
.bundle(&mut sprite_params),
))
.id();
commands.entity(*target).add_child(id);
}

206
crates/shared/src/aim/mod.rs
View File

@@ -1,206 +0,0 @@
mod marker;
mod target_ui;
use crate::{
GameState,
head::ActiveHead,
heads_database::HeadsDatabase,
hitpoints::Hitpoints,
physics_layers::GameLayer,
player::{Player, PlayerBodyMesh},
tb_entities::EnemySpawn,
};
use avian3d::prelude::*;
use bevy::prelude::*;
use marker::MarkerEvent;
use std::f32::consts::PI;
#[derive(Component, Reflect, Default, Deref)]
#[reflect(Component)]
pub struct AimTarget(pub Option<Entity>);
#[derive(Component, Reflect)]
#[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.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>>,
player_rot: Query<(&Transform, &GlobalTransform), With<PlayerBodyMesh>>,
mut player_aim: Query<(Entity, &AimState, &mut AimTarget), With<Player>>,
spatial_query: SpatialQuery,
) {
let Some((player, state, mut aim_target)) = player_aim.iter_mut().next() else {
return;
};
let Some((player_pos, player_forward)) = player_rot
.iter()
.next()
.map(|(t, global)| (global.translation(), t.forward()))
else {
return;
};
let mut new_target = None;
let mut target_distance = f32::MAX;
for (e, t) in potential_targets.iter() {
if e == player {
continue;
}
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 {
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 {
if 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 = pos - t.translation;
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 {
if 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
}

158
crates/shared/src/aim/target_ui.rs
View File

@@ -1,158 +0,0 @@
use super::AimTarget;
use crate::{
GameState,
backpack::UiHeadState,
heads::{ActiveHeads, HeadsImages},
hitpoints::Hitpoints,
loading_assets::UIAssets,
npc::Npc,
player::Player,
};
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<UiHeadState>,
}
pub fn plugin(app: &mut App) {
app.add_systems(OnEnter(GameState::Playing), setup);
app.add_systems(Update, (sync, update).run_if(in_state(GameState::Playing)));
}
fn setup(mut commands: Commands, assets: Res<UIAssets>) {
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()
},
children![spawn_head_ui(
assets.head_bg.clone(),
assets.head_regular.clone(),
assets.head_damage.clone(),
)],
));
commands.insert_resource(TargetUi::default());
}
fn spawn_head_ui(bg: Handle<Image>, regular: Handle<Image>, damage: Handle<Image>) -> impl Bundle {
const SIZE: f32 = 90.0;
const DAMAGE_SIZE: f32 = 74.0;
(
Node {
position_type: PositionType::Relative,
justify_content: JustifyContent::Center,
align_items: AlignItems::Center,
width: Val::Px(SIZE),
..default()
},
children![
(
Node {
position_type: PositionType::Absolute,
..default()
},
ImageNode::new(bg),
),
(
Node {
position_type: PositionType::Absolute,
..default()
},
ImageNode::default(),
Visibility::Hidden,
HeadImage,
),
(
Node {
position_type: PositionType::Absolute,
..default()
},
ImageNode::new(regular),
),
(
Node {
height: Val::Px(DAMAGE_SIZE),
width: Val::Px(DAMAGE_SIZE),
..default()
},
children![(
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()
},
children![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.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.single_mut() {
node.height = Val::Percent(target.head.map(|head| head.damage()).unwrap_or(0.) * 100.);
}
}
}
fn sync(
mut target: ResMut<TargetUi>,
player_target: Query<&AimTarget, With<Player>>,
target_data: Query<(&Hitpoints, &ActiveHeads), With<Npc>>,
) {
let mut new_state = None;
if let Some(e) = player_target.iter().next().and_then(|target| target.0) {
if let Ok((hp, heads)) = target_data.get(e) {
let head = heads.current().expect("target must have a head on");
new_state = Some(UiHeadState {
head: head.head,
health: hp.health(),
ammo: 1.,
reloading: None,
});
}
}
if new_state != target.head {
target.head = new_state;
}
}