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

118
crates/shared/src/abilities/arrow.rs
View File

@@ -1,118 +0,0 @@
use super::TriggerArrow;
use crate::{
GameState, billboards::Billboard, global_observer, heads_database::HeadsDatabase,
hitpoints::Hit, loading_assets::GameAssets, physics_layers::GameLayer, sounds::PlaySound,
utils::sprite_3d_animation::AnimationTimer,
};
use avian3d::prelude::*;
use bevy::{pbr::NotShadowCaster, prelude::*};
use bevy_sprite3d::{Sprite3dBuilder, Sprite3dParams};
use std::f32::consts::PI;
#[derive(Component)]
struct ArrowProjectile {
damage: u32,
}
#[derive(Resource)]
struct ShotAssets {
image: Handle<Image>,
layout: Handle<TextureAtlasLayout>,
}
pub fn plugin(app: &mut App) {
app.add_systems(OnEnter(GameState::Playing), setup);
app.add_systems(Update, update.run_if(in_state(GameState::Playing)));
global_observer!(app, on_trigger_arrow);
}
fn setup(mut commands: Commands, assets: Res<GameAssets>, mut sprite_params: Sprite3dParams) {
let layout = TextureAtlasLayout::from_grid(UVec2::splat(256), 7, 6, None, None);
let texture_atlas_layout = sprite_params.atlas_layouts.add(layout);
commands.insert_resource(ShotAssets {
image: assets.impact_atlas.clone(),
layout: texture_atlas_layout,
});
}
fn on_trigger_arrow(
trigger: Trigger<TriggerArrow>,
mut commands: Commands,
query_transform: Query<&Transform>,
heads_db: Res<HeadsDatabase>,
) {
let state = trigger.0;
commands.trigger(PlaySound::Crossbow);
let rotation = if let Some(target) = state.target {
let t = query_transform
.get(target)
.expect("target must have transform");
Transform::from_translation(state.pos)
.looking_at(t.translation, Vec3::Y)
.rotation
} else {
state.rot.mul_quat(Quat::from_rotation_y(PI))
};
let mut t = Transform::from_translation(state.pos).with_rotation(rotation);
t.translation += t.forward().as_vec3() * 2.;
let damage = heads_db.head_stats(state.head).damage;
commands.spawn((Name::new("projectile-arrow"), ArrowProjectile { damage }, t));
}
fn update(
mut cmds: Commands,
query: Query<(Entity, &Transform, &ArrowProjectile)>,
spatial_query: SpatialQuery,
assets: Res<ShotAssets>,
mut sprite_params: Sprite3dParams,
) {
for (e, t, arrow) in query.iter() {
let filter = SpatialQueryFilter::from_mask(LayerMask(
GameLayer::Level.to_bits() | GameLayer::Npc.to_bits(),
));
if let Some(first_hit) = spatial_query.cast_shape(
&Collider::sphere(0.5),
t.translation,
t.rotation,
t.forward(),
&ShapeCastConfig::from_max_distance(150.),
&filter,
) {
cmds.entity(first_hit.entity).trigger(Hit {
damage: arrow.damage,
});
cmds.spawn(
Sprite3dBuilder {
image: assets.image.clone(),
pixels_per_metre: 128.,
alpha_mode: AlphaMode::Blend,
unlit: true,
..default()
}
.bundle_with_atlas(
&mut sprite_params,
TextureAtlas {
layout: assets.layout.clone(),
index: 0,
},
),
)
.insert((
Billboard::All,
Transform::from_translation(first_hit.point1),
NotShadowCaster,
AnimationTimer::new(Timer::from_seconds(0.005, TimerMode::Repeating)),
));
}
cmds.entity(e).despawn();
}
}

204
crates/shared/src/abilities/curver.rs
View File

@@ -1,204 +0,0 @@
use crate::{
GameState,
abilities::TriggerCurver,
billboards::Billboard,
heads_database::HeadsDatabase,
hitpoints::Hit,
loading_assets::GameAssets,
physics_layers::GameLayer,
tb_entities::EnemySpawn,
utils::{auto_rotate::AutoRotation, global_observer, sprite_3d_animation::AnimationTimer},
};
use avian3d::prelude::*;
use bevy::{pbr::NotShadowCaster, prelude::*};
use bevy_sprite3d::{Sprite3dBuilder, Sprite3dParams};
use std::f32::consts::PI;
const MAX_SHOT_AGES: f32 = 15.;
#[derive(Component)]
struct CurverProjectile {
time: f32,
damage: u32,
}
#[derive(Resource)]
struct ShotAssets {
image: Handle<Image>,
layout: Handle<TextureAtlasLayout>,
}
pub fn plugin(app: &mut App) {
app.add_systems(OnEnter(GameState::Playing), setup);
app.add_systems(
Update,
(shot_collision, enemy_hit).run_if(in_state(GameState::Playing)),
);
app.add_systems(
FixedUpdate,
(update, timeout).run_if(in_state(GameState::Playing)),
);
global_observer!(app, on_trigger_missile);
}
fn setup(mut commands: Commands, assets: Res<GameAssets>, mut sprite_params: Sprite3dParams) {
let layout = TextureAtlasLayout::from_grid(UVec2::splat(256), 7, 6, None, None);
let texture_atlas_layout = sprite_params.atlas_layouts.add(layout);
commands.insert_resource(ShotAssets {
image: assets.impact_atlas.clone(),
layout: texture_atlas_layout,
});
}
fn on_trigger_missile(
trigger: Trigger<TriggerCurver>,
mut commands: Commands,
query_transform: Query<&Transform>,
time: Res<Time>,
heads_db: Res<HeadsDatabase>,
assets: Res<GameAssets>,
gltf_assets: Res<Assets<Gltf>>,
) {
let state = trigger.event().0;
let rotation = if let Some(target) = state.target {
let t = query_transform
.get(target)
.expect("target must have transform");
Transform::from_translation(state.pos)
.looking_at(t.translation, Vec3::Y)
.rotation
} else {
state.rot.mul_quat(Quat::from_rotation_y(PI))
};
let head = heads_db.head_stats(state.head);
let mut t = Transform::from_translation(state.pos).with_rotation(rotation);
t.translation += t.forward().as_vec3() * 2.0;
let mesh = assets.projectiles[format!("{}.glb", head.projectile).as_str()].clone();
let asset = gltf_assets.get(&mesh).unwrap();
commands.spawn((
Name::new("projectile-missile"),
CurverProjectile {
time: time.elapsed_secs(),
damage: head.damage,
},
Collider::capsule_endpoints(0.4, Vec3::new(0., 0., 2.), Vec3::new(0., 0., -2.)),
CollisionLayers::new(
LayerMask(GameLayer::Projectile.to_bits()),
LayerMask(state.target_layer.to_bits() | GameLayer::Level.to_bits()),
),
Sensor,
CollisionEventsEnabled,
Visibility::default(),
t,
children![(
Transform::from_rotation(Quat::from_rotation_x(PI / 2.).inverse()),
AutoRotation(Quat::from_rotation_x(0.4) * Quat::from_rotation_z(0.3)),
SceneRoot(asset.scenes[0].clone()),
),],
));
}
fn enemy_hit(
mut commands: Commands,
mut collision_event_reader: EventReader<CollisionStarted>,
query_shot: Query<&CurverProjectile>,
query_npc: Query<&EnemySpawn>,
) {
for CollisionStarted(e1, e2) in collision_event_reader.read() {
if !query_shot.contains(*e1) && !query_shot.contains(*e2) {
continue;
}
if !query_npc.contains(*e1) && !query_npc.contains(*e2) {
continue;
}
let (enemy_entity, projectile) = if query_npc.contains(*e1) {
(*e1, query_shot.get(*e2))
} else {
(*e2, query_shot.get(*e1))
};
if let Ok(projectile) = projectile {
let damage = projectile.damage;
commands.entity(enemy_entity).trigger(Hit { damage });
}
}
}
fn update(mut query: Query<&mut Transform, With<CurverProjectile>>) {
for mut transform in query.iter_mut() {
let forward = transform.forward();
transform.translation += forward * 0.5;
}
}
fn timeout(mut commands: Commands, query: Query<(Entity, &CurverProjectile)>, time: Res<Time>) {
let current_time = time.elapsed_secs();
for (e, CurverProjectile { time, .. }) in query.iter() {
if current_time > time + MAX_SHOT_AGES {
commands.entity(e).despawn();
}
}
}
fn shot_collision(
mut commands: Commands,
mut collision_event_reader: EventReader<CollisionStarted>,
query_shot: Query<&Transform, With<CurverProjectile>>,
sensors: Query<(), With<Sensor>>,
assets: Res<ShotAssets>,
mut sprite_params: Sprite3dParams,
) {
for CollisionStarted(e1, e2) in collision_event_reader.read() {
if !query_shot.contains(*e1) && !query_shot.contains(*e2) {
continue;
}
if sensors.contains(*e1) && sensors.contains(*e2) {
continue;
}
let shot_entity = if query_shot.contains(*e1) { *e1 } else { *e2 };
let Ok(shot_pos) = query_shot.get(shot_entity).map(|t| t.translation) else {
continue;
};
if let Ok(mut entity) = commands.get_entity(shot_entity) {
entity.try_despawn();
} else {
continue;
}
let texture_atlas = TextureAtlas {
layout: assets.layout.clone(),
index: 0,
};
commands
.spawn(
Sprite3dBuilder {
image: assets.image.clone(),
pixels_per_metre: 128.,
alpha_mode: AlphaMode::Blend,
unlit: true,
..default()
}
.bundle_with_atlas(&mut sprite_params, texture_atlas),
)
.insert((
Billboard::All,
Transform::from_translation(shot_pos),
NotShadowCaster,
AnimationTimer::new(Timer::from_seconds(0.01, TimerMode::Repeating)),
));
}
}

200
crates/shared/src/abilities/gun.rs
View File

@@ -1,200 +0,0 @@
use super::TriggerGun;
use crate::{
GameState, billboards::Billboard, global_observer, heads_database::HeadsDatabase,
hitpoints::Hit, loading_assets::GameAssets, physics_layers::GameLayer, sounds::PlaySound,
tb_entities::EnemySpawn, utils::sprite_3d_animation::AnimationTimer,
};
use avian3d::prelude::*;
use bevy::{pbr::NotShadowCaster, prelude::*};
use bevy_sprite3d::{Sprite3dBuilder, Sprite3dParams};
use std::f32::consts::PI;
#[derive(Component)]
struct GunProjectile {
time: f32,
owner_head: usize,
}
const MAX_SHOT_AGES: f32 = 1.;
#[derive(Resource)]
struct ShotAssets {
image: Handle<Image>,
layout: Handle<TextureAtlasLayout>,
}
pub fn plugin(app: &mut App) {
app.add_systems(OnEnter(GameState::Playing), setup);
app.add_systems(
Update,
(shot_collision, enemy_hit).run_if(in_state(GameState::Playing)),
);
app.add_systems(
FixedUpdate,
(update, timeout).run_if(in_state(GameState::Playing)),
);
global_observer!(app, on_trigger_gun);
}
fn setup(mut commands: Commands, assets: Res<GameAssets>, mut sprite_params: Sprite3dParams) {
let layout = TextureAtlasLayout::from_grid(UVec2::splat(256), 7, 6, None, None);
let texture_atlas_layout = sprite_params.atlas_layouts.add(layout);
commands.insert_resource(ShotAssets {
image: assets.impact_atlas.clone(),
layout: texture_atlas_layout,
});
}
fn enemy_hit(
mut commands: Commands,
mut collision_event_reader: EventReader<CollisionStarted>,
query_shot: Query<&GunProjectile>,
query_npc: Query<&EnemySpawn>,
heads_db: Res<HeadsDatabase>,
) {
for CollisionStarted(e1, e2) in collision_event_reader.read() {
if !query_shot.contains(*e1) && !query_shot.contains(*e2) {
continue;
}
if !query_npc.contains(*e1) && !query_npc.contains(*e2) {
continue;
}
let (enemy_entity, projectile) = if query_npc.contains(*e1) {
(*e1, query_shot.get(*e2))
} else {
(*e2, query_shot.get(*e1))
};
if let Ok(head) = projectile.map(|p| p.owner_head) {
let damage = heads_db.head_stats(head).damage;
commands.entity(enemy_entity).trigger(Hit { damage });
}
}
}
fn on_trigger_gun(
trigger: Trigger<TriggerGun>,
mut commands: Commands,
query_transform: Query<&Transform>,
time: Res<Time>,
mut gizmo_assets: ResMut<Assets<GizmoAsset>>,
) {
let state = trigger.0;
commands.trigger(PlaySound::Gun);
let rotation = if let Some(t) = state
.target
.and_then(|target| query_transform.get(target).ok())
{
Transform::from_translation(state.pos)
.looking_at(t.translation, Vec3::Y)
.rotation
} else {
state.rot.mul_quat(Quat::from_rotation_y(PI))
};
let mut t = Transform::from_translation(state.pos).with_rotation(rotation);
t.translation += t.forward().as_vec3() * 2.0;
commands.spawn((
Name::new("projectile-gun"),
GunProjectile {
time: time.elapsed_secs(),
owner_head: state.head,
},
Collider::capsule_endpoints(0.5, Vec3::new(0., 0., 0.), Vec3::new(0., 0., -3.)),
CollisionLayers::new(
LayerMask(GameLayer::Projectile.to_bits()),
LayerMask(state.target_layer.to_bits() | GameLayer::Level.to_bits()),
),
Sensor,
CollisionEventsEnabled,
Visibility::default(),
t,
Children::spawn(Spawn(Gizmo {
handle: gizmo_assets.add({
let mut g = GizmoAsset::default();
g.line(Vec3::Z * -2., Vec3::Z * 2., LinearRgba::rgb(0.9, 0.9, 0.));
g
}),
line_config: GizmoLineConfig {
width: 8.,
..default()
},
..default()
})),
));
}
fn update(mut query: Query<&mut Transform, With<GunProjectile>>) {
for mut transform in query.iter_mut() {
let forward = transform.forward();
transform.translation += forward * 2.;
}
}
fn timeout(mut commands: Commands, query: Query<(Entity, &GunProjectile)>, time: Res<Time>) {
let current_time = time.elapsed_secs();
for (e, GunProjectile { time, .. }) in query.iter() {
if current_time > time + MAX_SHOT_AGES {
commands.entity(e).despawn();
}
}
}
fn shot_collision(
mut commands: Commands,
mut collision_event_reader: EventReader<CollisionStarted>,
query_shot: Query<(&GunProjectile, &Transform)>,
sensors: Query<(), With<Sensor>>,
assets: Res<ShotAssets>,
mut sprite_params: Sprite3dParams,
) {
for CollisionStarted(e1, e2) in collision_event_reader.read() {
if !query_shot.contains(*e1) && !query_shot.contains(*e2) {
continue;
}
if sensors.contains(*e1) && sensors.contains(*e2) {
continue;
}
let shot_entity = if query_shot.contains(*e1) { *e1 } else { *e2 };
if let Ok(mut entity) = commands.get_entity(shot_entity) {
entity.try_despawn();
} else {
continue;
}
let shot_pos = query_shot.get(shot_entity).unwrap().1.translation;
let texture_atlas = TextureAtlas {
layout: assets.layout.clone(),
index: 0,
};
commands
.spawn(
Sprite3dBuilder {
image: assets.image.clone(),
pixels_per_metre: 128.,
alpha_mode: AlphaMode::Blend,
unlit: true,
..default()
}
.bundle_with_atlas(&mut sprite_params, texture_atlas),
)
.insert((
Billboard::All,
Transform::from_translation(shot_pos),
NotShadowCaster,
AnimationTimer::new(Timer::from_seconds(0.01, TimerMode::Repeating)),
));
}
}

75
crates/shared/src/abilities/healing.rs
View File

@@ -1,75 +0,0 @@
use crate::{
GameState, global_observer, heads::ActiveHeads, heads_database::HeadsDatabase,
hitpoints::Hitpoints, loading_assets::AudioAssets,
};
use bevy::prelude::*;
#[derive(Component)]
pub struct Healing(pub Entity);
#[derive(Event, Debug)]
pub enum HealingStateChanged {
Started,
Stopped,
}
pub fn plugin(app: &mut App) {
app.add_systems(Update, update.run_if(in_state(GameState::Playing)));
global_observer!(app, on_heal_start_stop);
}
fn on_heal_start_stop(
trigger: Trigger<HealingStateChanged>,
mut cmds: Commands,
assets: Res<AudioAssets>,
query: Query<&Healing>,
) {
if matches!(trigger.event(), HealingStateChanged::Started) {
let e = cmds
.spawn((
Name::new("sfx-heal"),
AudioPlayer::new(assets.healing.clone()),
PlaybackSettings {
mode: bevy::audio::PlaybackMode::Loop,
..Default::default()
},
))
.id();
cmds.entity(trigger.target())
.add_child(e)
.insert(Healing(e));
} else {
if let Ok(healing) = query.single() {
cmds.entity(healing.0).despawn();
}
cmds.entity(trigger.target()).remove::<Healing>();
}
}
fn update(
mut query: Query<(&mut ActiveHeads, &mut Hitpoints), With<Healing>>,
time: Res<Time>,
heads_db: Res<HeadsDatabase>,
) {
for (mut heads, mut hitpoints) in query.iter_mut() {
let Some(current) = heads.current() else {
continue;
};
let head = heads_db.head_stats(current.head);
if current.last_use + (1. / head.aps) > time.elapsed_secs() {
continue;
}
let medic_hp = hitpoints.get().0;
if medic_hp > 0 {
if let Some(health) = heads.medic_heal(2, time.elapsed_secs()) {
hitpoints.set_health(health);
} else {
continue;
}
}
}
}

201
crates/shared/src/abilities/missile.rs
View File

@@ -1,201 +0,0 @@
use super::TriggerMissile;
use crate::{
GameState,
billboards::Billboard,
heads_database::HeadsDatabase,
loading_assets::GameAssets,
physics_layers::GameLayer,
sounds::PlaySound,
utils::{
explosions::Explosion, global_observer, sprite_3d_animation::AnimationTimer, trail::Trail,
},
};
use avian3d::prelude::*;
use bevy::{pbr::NotShadowCaster, prelude::*};
use bevy_sprite3d::{Sprite3dBuilder, Sprite3dParams};
use std::f32::consts::PI;
const MAX_SHOT_AGES: f32 = 15.;
#[derive(Component)]
struct MissileProjectile {
time: f32,
damage: u32,
}
#[derive(Resource)]
struct ShotAssets {
image: Handle<Image>,
layout: Handle<TextureAtlasLayout>,
}
pub fn plugin(app: &mut App) {
app.add_systems(OnEnter(GameState::Playing), setup);
app.add_systems(Update, shot_collision.run_if(in_state(GameState::Playing)));
app.add_systems(
FixedUpdate,
(update, timeout).run_if(in_state(GameState::Playing)),
);
global_observer!(app, on_trigger_missile);
}
fn setup(mut commands: Commands, assets: Res<GameAssets>, mut sprite_params: Sprite3dParams) {
let layout = TextureAtlasLayout::from_grid(UVec2::splat(256), 7, 6, None, None);
let texture_atlas_layout = sprite_params.atlas_layouts.add(layout);
commands.insert_resource(ShotAssets {
image: assets.impact_atlas.clone(),
layout: texture_atlas_layout,
});
}
fn on_trigger_missile(
trigger: Trigger<TriggerMissile>,
mut commands: Commands,
query_transform: Query<&Transform>,
time: Res<Time>,
heads_db: Res<HeadsDatabase>,
assets: Res<GameAssets>,
gltf_assets: Res<Assets<Gltf>>,
mut gizmo_assets: ResMut<Assets<GizmoAsset>>,
) {
let state = trigger.event().0;
let rotation = if let Some(target) = state.target {
let t = query_transform
.get(target)
.expect("target must have transform");
Transform::from_translation(state.pos)
.looking_at(t.translation, Vec3::Y)
.rotation
} else {
state.rot.mul_quat(Quat::from_rotation_y(PI))
};
let head = heads_db.head_stats(state.head);
let mut t = Transform::from_translation(state.pos).with_rotation(rotation);
t.translation += t.forward().as_vec3() * 2.0;
let mesh = assets.projectiles["missile.glb"].clone();
let asset = gltf_assets.get(&mesh).unwrap();
commands.spawn((
Name::new("projectile-missile"),
MissileProjectile {
time: time.elapsed_secs(),
damage: head.damage,
},
Collider::capsule_endpoints(0.4, Vec3::new(0., 0., 2.), Vec3::new(0., 0., -2.)),
CollisionLayers::new(
LayerMask(GameLayer::Projectile.to_bits()),
LayerMask(state.target_layer.to_bits() | GameLayer::Level.to_bits()),
),
Sensor,
CollisionEventsEnabled,
Visibility::default(),
t,
children![
(
Transform::from_rotation(Quat::from_rotation_x(PI / 2.).inverse())
.with_scale(Vec3::splat(0.04)),
SceneRoot(asset.scenes[0].clone()),
),
(
Trail::new(
12,
LinearRgba::rgb(1., 0.0, 0.),
LinearRgba::rgb(0.9, 0.9, 0.)
)
.with_pos(t.translation),
Gizmo {
handle: gizmo_assets.add(GizmoAsset::default()),
line_config: GizmoLineConfig {
width: 10.,
..default()
},
..default()
},
)
],
));
}
fn update(mut query: Query<&mut Transform, With<MissileProjectile>>) {
for mut transform in query.iter_mut() {
let forward = transform.forward();
transform.translation += forward * 3.;
}
}
fn timeout(mut commands: Commands, query: Query<(Entity, &MissileProjectile)>, time: Res<Time>) {
let current_time = time.elapsed_secs();
for (e, MissileProjectile { time, .. }) in query.iter() {
if current_time > time + MAX_SHOT_AGES {
commands.entity(e).despawn();
}
}
}
fn shot_collision(
mut commands: Commands,
mut collision_event_reader: EventReader<CollisionStarted>,
query_shot: Query<(&MissileProjectile, &Transform)>,
sensors: Query<(), With<Sensor>>,
assets: Res<ShotAssets>,
mut sprite_params: Sprite3dParams,
) {
for CollisionStarted(e1, e2) in collision_event_reader.read() {
if !query_shot.contains(*e1) && !query_shot.contains(*e2) {
continue;
}
if sensors.contains(*e1) && sensors.contains(*e2) {
continue;
}
let shot_entity = if query_shot.contains(*e1) { *e1 } else { *e2 };
let Ok((shot_pos, damage)) = query_shot
.get(shot_entity)
.map(|(projectile, t)| (t.translation, projectile.damage))
else {
continue;
};
commands.trigger(PlaySound::MissileExplosion);
commands.entity(shot_entity).despawn();
commands.trigger(Explosion {
damage,
position: shot_pos,
radius: 6.,
});
let texture_atlas = TextureAtlas {
layout: assets.layout.clone(),
index: 0,
};
commands
.spawn(
Sprite3dBuilder {
image: assets.image.clone(),
pixels_per_metre: 16.,
alpha_mode: AlphaMode::Blend,
unlit: true,
..default()
}
.bundle_with_atlas(&mut sprite_params, texture_atlas),
)
.insert((
Billboard::All,
Transform::from_translation(shot_pos),
NotShadowCaster,
AnimationTimer::new(Timer::from_seconds(0.01, TimerMode::Repeating)),
));
}
}

224
crates/shared/src/abilities/mod.rs
View File

@@ -1,224 +0,0 @@
mod arrow;
mod curver;
mod gun;
mod healing;
mod missile;
mod thrown;
use crate::{
GameState,
aim::AimTarget,
character::CharacterHierarchy,
global_observer,
head::ActiveHead,
heads::ActiveHeads,
heads_database::HeadsDatabase,
physics_layers::GameLayer,
player::{Player, PlayerBodyMesh},
sounds::PlaySound,
};
use bevy::prelude::*;
pub use healing::Healing;
use healing::HealingStateChanged;
use serde::{Deserialize, Serialize};
#[derive(Event, Reflect)]
pub enum TriggerState {
Active,
Inactive,
}
#[derive(Event, Reflect)]
pub struct TriggerCashHeal;
#[derive(Debug, Copy, Clone, PartialEq, Reflect, Default, Serialize, Deserialize)]
pub enum HeadAbility {
#[default]
None,
Arrow,
Thrown,
Gun,
Missile,
Medic,
Curver,
Boat,
Turbo,
Spray,
}
#[derive(Debug, Reflect, Clone, Copy)]
pub struct TriggerData {
target: Option<Entity>,
dir: Dir3,
rot: Quat,
pos: Vec3,
target_layer: GameLayer,
head: usize,
}
impl TriggerData {
pub fn new(
target: Option<Entity>,
dir: Dir3,
rot: Quat,
pos: Vec3,
target_layer: GameLayer,
head: usize,
) -> Self {
Self {
target,
dir,
rot,
pos,
target_layer,
head,
}
}
}
#[derive(Event, Reflect)]
pub struct TriggerGun(pub TriggerData);
#[derive(Event, Reflect)]
pub struct TriggerArrow(pub TriggerData);
#[derive(Event, Reflect)]
pub struct TriggerThrow(pub TriggerData);
#[derive(Event, Reflect)]
pub struct TriggerMissile(pub TriggerData);
#[derive(Event, Reflect)]
pub struct TriggerCurver(pub TriggerData);
#[derive(Resource, Default)]
pub struct TriggerStateRes {
next_trigger_timestamp: f32,
active: bool,
}
impl TriggerStateRes {
pub fn is_active(&self) -> bool {
self.active
}
}
pub fn plugin(app: &mut App) {
app.init_resource::<TriggerStateRes>();
app.add_plugins(gun::plugin);
app.add_plugins(thrown::plugin);
app.add_plugins(arrow::plugin);
app.add_plugins(missile::plugin);
app.add_plugins(healing::plugin);
app.add_plugins(curver::plugin);
app.add_systems(
Update,
(update, update_heal_ability).run_if(in_state(GameState::Playing)),
);
global_observer!(app, on_trigger_state);
}
fn on_trigger_state(
trigger: Trigger<TriggerState>,
mut res: ResMut<TriggerStateRes>,
player_head: Single<&ActiveHead, With<Player>>,
headdb: Res<HeadsDatabase>,
time: Res<Time>,
) {
res.active = matches!(trigger.event(), TriggerState::Active);
if res.active {
let head_stats = headdb.head_stats(player_head.0);
res.next_trigger_timestamp = time.elapsed_secs() + head_stats.shoot_offset;
}
}
fn update(
mut res: ResMut<TriggerStateRes>,
mut commands: Commands,
player_rot: Query<&Transform, With<PlayerBodyMesh>>,
player_query: Query<(Entity, &AimTarget), With<Player>>,
mut active_heads: Single<&mut ActiveHeads, With<Player>>,
heads_db: Res<HeadsDatabase>,
time: Res<Time>,
character: CharacterHierarchy,
) {
if res.active && res.next_trigger_timestamp < time.elapsed_secs() {
let Some(state) = active_heads.current() else {
return;
};
if !state.has_ammo() {
commands.trigger(PlaySound::Invalid);
return;
}
let Some((player, target)) = player_query.iter().next() else {
return;
};
let Some(projectile_origin) = character
.projectile_origin(player)
.map(|origin| origin.translation())
else {
return;
};
let Some((rot, dir)) = player_rot.iter().next().map(|t| (t.rotation, t.forward())) else {
return;
};
let head = heads_db.head_stats(state.head);
if matches!(head.ability, HeadAbility::None | HeadAbility::Medic) {
return;
}
active_heads.use_ammo(time.elapsed_secs());
res.next_trigger_timestamp = time.elapsed_secs() + (1. / head.aps);
let trigger_state = TriggerData {
dir,
rot,
pos: projectile_origin,
target: target.0,
target_layer: GameLayer::Npc,
head: state.head,
};
match head.ability {
HeadAbility::Thrown => commands.trigger(TriggerThrow(trigger_state)),
HeadAbility::Gun => commands.trigger(TriggerGun(trigger_state)),
HeadAbility::Missile => commands.trigger(TriggerMissile(trigger_state)),
HeadAbility::Arrow => commands.trigger(TriggerArrow(trigger_state)),
HeadAbility::Curver => commands.trigger(TriggerCurver(trigger_state)),
_ => panic!("Unhandled head ability"),
};
}
}
fn update_heal_ability(
res: Res<TriggerStateRes>,
mut commands: Commands,
active_heads: Single<(Entity, &ActiveHeads), With<Player>>,
heads_db: Res<HeadsDatabase>,
) {
if res.is_changed() {
let Some(state) = active_heads.1.current() else {
return;
};
let player = active_heads.0;
let head = heads_db.head_stats(state.head);
if !matches!(head.ability, HeadAbility::Medic) {
return;
}
if res.active {
commands.trigger_targets(HealingStateChanged::Started, player);
} else {
commands.trigger_targets(HealingStateChanged::Stopped, player);
}
}
}

184
crates/shared/src/abilities/thrown.rs
View File

@@ -1,184 +0,0 @@
use super::TriggerThrow;
use crate::{
GameState,
billboards::Billboard,
heads_database::HeadsDatabase,
loading_assets::GameAssets,
physics_layers::GameLayer,
sounds::PlaySound,
utils::{
auto_rotate::AutoRotation, explosions::Explosion, global_observer,
sprite_3d_animation::AnimationTimer,
},
};
use avian3d::prelude::*;
use bevy::{pbr::NotShadowCaster, prelude::*};
use bevy_ballistic::launch_velocity;
use bevy_sprite3d::{Sprite3dBuilder, Sprite3dParams};
use std::f32::consts::PI;
#[derive(Component)]
struct ThrownProjectile {
impact_animation: bool,
damage: u32,
}
#[derive(Resource)]
struct ShotAssets {
image: Handle<Image>,
layout: Handle<TextureAtlasLayout>,
}
pub fn plugin(app: &mut App) {
app.add_systems(OnEnter(GameState::Playing), setup);
app.add_systems(Update, shot_collision.run_if(in_state(GameState::Playing)));
global_observer!(app, on_trigger_thrown);
}
fn setup(mut commands: Commands, assets: Res<GameAssets>, mut sprite_params: Sprite3dParams) {
let layout = TextureAtlasLayout::from_grid(UVec2::splat(256), 7, 6, None, None);
let texture_atlas_layout = sprite_params.atlas_layouts.add(layout);
commands.insert_resource(ShotAssets {
image: assets.impact_atlas.clone(),
layout: texture_atlas_layout,
});
}
fn on_trigger_thrown(
trigger: Trigger<TriggerThrow>,
mut commands: Commands,
query_transform: Query<&Transform>,
assets: Res<GameAssets>,
gltf_assets: Res<Assets<Gltf>>,
heads_db: Res<HeadsDatabase>,
) {
let state = trigger.event().0;
commands.trigger(PlaySound::Throw);
const SPEED: f32 = 35.;
let pos = state.pos;
let vel = if let Some(target) = state.target {
let t = query_transform
.get(target)
.expect("target must have transform");
launch_velocity(pos, t.translation, SPEED, 9.81)
.map(|(low, _)| low)
.unwrap()
} else {
state.rot.mul_quat(Quat::from_rotation_y(-PI / 2.))
* (Vec3::new(2., 1., 0.).normalize() * SPEED)
};
let head = heads_db.head_stats(state.head);
let mesh = assets.projectiles[format!("{}.glb", head.projectile).as_str()].clone();
let asset = gltf_assets.get(&mesh).unwrap();
//TODO: projectile db?
let explosion_animation = !matches!(state.head, 8 | 16);
commands
.spawn((
Transform::from_translation(pos),
Name::new("projectile-thrown"),
ThrownProjectile {
impact_animation: explosion_animation,
damage: head.damage,
},
Collider::sphere(0.4),
CollisionLayers::new(
LayerMask(GameLayer::Projectile.to_bits()),
LayerMask(state.target_layer.to_bits() | GameLayer::Level.to_bits()),
),
RigidBody::Dynamic,
CollisionEventsEnabled,
Mass(0.01),
LinearVelocity(vel),
Visibility::default(),
Sensor,
))
.with_child((
AutoRotation(Quat::from_rotation_x(0.4) * Quat::from_rotation_z(0.3)),
SceneRoot(asset.scenes[0].clone()),
));
}
fn shot_collision(
mut commands: Commands,
mut collision_event_reader: EventReader<CollisionStarted>,
query_shot: Query<(&ThrownProjectile, &Transform)>,
sensors: Query<(), With<Sensor>>,
assets: Res<ShotAssets>,
mut sprite_params: Sprite3dParams,
) {
for CollisionStarted(e1, e2) in collision_event_reader.read() {
if !query_shot.contains(*e1) && !query_shot.contains(*e2) {
continue;
}
if sensors.contains(*e1) && sensors.contains(*e2) {
continue;
}
let shot_entity = if query_shot.contains(*e1) { *e1 } else { *e2 };
let Ok((shot_pos, animation, damage)) =
query_shot.get(shot_entity).map(|(projectile, t)| {
(
t.translation,
projectile.impact_animation,
projectile.damage,
)
})
else {
continue;
};
if let Ok(mut entity) = commands.get_entity(shot_entity) {
entity.try_despawn();
} else {
continue;
}
commands.trigger(PlaySound::ThrowHit);
commands.trigger(Explosion {
damage,
position: shot_pos,
//TODO: should be around 1 grid in distance
radius: 5.,
});
//TODO: support different impact animations
if animation {
commands
.spawn(
Sprite3dBuilder {
image: assets.image.clone(),
pixels_per_metre: 32.,
alpha_mode: AlphaMode::Blend,
unlit: true,
..default()
}
.bundle_with_atlas(
&mut sprite_params,
TextureAtlas {
layout: assets.layout.clone(),
index: 0,
},
),
)
.insert((
Billboard::All,
Transform::from_translation(shot_pos),
NotShadowCaster,
AnimationTimer::new(Timer::from_seconds(0.02, TimerMode::Repeating)),
));
}
}
}