146 lines
4.0 KiB
Rust
146 lines
4.0 KiB
Rust
use super::TriggerThrow;
|
|
use crate::{
|
|
GameState,
|
|
abilities::BuildExplosionSprite,
|
|
heads_database::HeadsDatabase,
|
|
physics_layers::GameLayer,
|
|
protocol::GltfSceneRoot,
|
|
sounds::PlaySound,
|
|
utils::{
|
|
auto_rotate::AutoRotation,
|
|
commands::{CommandExt, EntityCommandExt},
|
|
explosions::Explosion,
|
|
global_observer,
|
|
},
|
|
};
|
|
use avian3d::prelude::*;
|
|
use bevy::prelude::*;
|
|
use bevy_ballistic::launch_velocity;
|
|
use lightyear::prelude::{NetworkTarget, Replicate};
|
|
use serde::{Deserialize, Serialize};
|
|
use std::f32::consts::PI;
|
|
|
|
#[derive(Component, Serialize, Deserialize, PartialEq)]
|
|
pub struct ThrownProjectile {
|
|
impact_animation: bool,
|
|
damage: u32,
|
|
}
|
|
|
|
pub fn plugin(app: &mut App) {
|
|
app.add_systems(Update, shot_collision.run_if(in_state(GameState::Playing)));
|
|
|
|
global_observer!(app, on_trigger_thrown);
|
|
}
|
|
|
|
fn on_trigger_thrown(
|
|
trigger: Trigger<TriggerThrow>,
|
|
mut commands: Commands,
|
|
query_transform: Query<&Transform>,
|
|
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 Ok(t) = query_transform.get(target)
|
|
{
|
|
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);
|
|
|
|
//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,
|
|
))
|
|
.insert_server(Replicate::to_clients(NetworkTarget::All))
|
|
.with_child((
|
|
AutoRotation(Quat::from_rotation_x(0.4) * Quat::from_rotation_z(0.3)),
|
|
GltfSceneRoot::Projectile(head.projectile.clone()),
|
|
));
|
|
}
|
|
|
|
fn shot_collision(
|
|
mut commands: Commands,
|
|
mut collision_event_reader: EventReader<CollisionStarted>,
|
|
query_shot: Query<(&ThrownProjectile, &Transform)>,
|
|
sensors: Query<(), With<Sensor>>,
|
|
) {
|
|
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.trigger_server(BuildExplosionSprite {
|
|
pos: shot_pos,
|
|
pixels_per_meter: 32.,
|
|
time: 0.02,
|
|
});
|
|
}
|
|
}
|
|
}
|