396 lines
9.8 KiB
Rust
396 lines
9.8 KiB
Rust
use std::{collections::HashMap, f32::consts::PI};
|
|
|
|
use godot::{
|
|
classes::{AudioStreamPlayer3D, GpuParticles3D, RandomNumberGenerator},
|
|
prelude::*,
|
|
};
|
|
use serde::{Deserialize, Serialize};
|
|
|
|
use crate::{
|
|
game::Game,
|
|
player::{DamageSource, shootable::Shootable},
|
|
replay::StandaloneReplayManager,
|
|
util::{RaycastResult, cast_ray, shotgun_ray},
|
|
};
|
|
|
|
pub trait Weapon {
|
|
fn shoot(
|
|
&mut self,
|
|
player_rid: Rid,
|
|
player_id: u16,
|
|
from: Vector3,
|
|
to: Vector3,
|
|
up: Vector3,
|
|
deal_damage: bool,
|
|
play_fx: bool,
|
|
) -> bool;
|
|
fn get_type(&self) -> WeaponType;
|
|
fn get_max_cd(&self) -> f64;
|
|
fn get_remaining_cd(&self) -> f64;
|
|
fn set_remaining_cd(&mut self, cd: f64);
|
|
}
|
|
|
|
#[derive(Debug, Clone, Copy, Deserialize, Serialize, PartialEq, PartialOrd)]
|
|
pub enum WeaponType {
|
|
Raygun,
|
|
Shotgun,
|
|
Ball,
|
|
}
|
|
|
|
#[derive(GodotClass)]
|
|
#[class(base=Node3D, init)]
|
|
pub struct Raygun {
|
|
#[export]
|
|
sound_emitter: Option<Gd<AudioStreamPlayer3D>>,
|
|
#[export]
|
|
bullet_prefab: Option<Gd<PackedScene>>,
|
|
#[export]
|
|
bullet_source: Option<Gd<Node3D>>,
|
|
#[export]
|
|
decal: Option<Gd<PackedScene>>,
|
|
|
|
#[export]
|
|
cooldown: f64,
|
|
|
|
cooldown_remaining: f64,
|
|
|
|
base: Base<Node3D>,
|
|
}
|
|
|
|
#[godot_api]
|
|
impl INode3D for Raygun {
|
|
fn process(&mut self, delta: f64) {
|
|
self.cooldown_remaining -= delta;
|
|
}
|
|
}
|
|
|
|
#[godot_dyn]
|
|
impl Weapon for Raygun {
|
|
fn shoot(
|
|
&mut self,
|
|
player: Rid,
|
|
player_id: u16,
|
|
from: Vector3,
|
|
to: Vector3,
|
|
_: Vector3,
|
|
deal_damage: bool,
|
|
play_fx: bool,
|
|
) -> bool {
|
|
if self.cooldown_remaining > 0. {
|
|
return false;
|
|
}
|
|
|
|
if let Some(emitter) = &mut self.sound_emitter
|
|
&& play_fx
|
|
{
|
|
emitter.play();
|
|
}
|
|
|
|
if let Some(source) = self.bullet_source.clone() {
|
|
let target = cast_ray(
|
|
from,
|
|
to,
|
|
&self.base().get_world_3d(),
|
|
&Array::from_iter(vec![player]),
|
|
None,
|
|
);
|
|
|
|
if play_fx {
|
|
let target_clone = target.clone();
|
|
self.run_deferred(|s| {
|
|
if let Some(target) = target_clone {
|
|
add_decal(&target, s.decal.clone());
|
|
}
|
|
});
|
|
}
|
|
|
|
let beam_dir = (to - source.get_global_position()).normalized();
|
|
let beam_end = target
|
|
.as_ref()
|
|
.map(|r| r.position)
|
|
.unwrap_or(source.get_global_position() + beam_dir * 100.);
|
|
let delta = beam_end - source.get_global_position();
|
|
godot_print!("{}", delta);
|
|
|
|
if let Some(prefab) = &self.bullet_prefab
|
|
&& play_fx
|
|
{
|
|
let mut bullet = prefab.instantiate_as::<Beam>();
|
|
|
|
bullet.bind_mut().source = Some(source.get_global_position());
|
|
bullet.bind_mut().target = Some(beam_end);
|
|
|
|
self.run_deferred(move |_| {
|
|
if let Some(mut game) = Game::singleton()
|
|
&& let Some(map) = &mut game.bind_mut().current_map
|
|
{
|
|
map.add_child(&bullet);
|
|
} else if let Some(playback) =
|
|
&mut StandaloneReplayManager::singleton().bind_mut().playback
|
|
&& let Some(map) = &mut playback.bind_mut().current_map
|
|
{
|
|
map.add_child(&bullet);
|
|
}
|
|
});
|
|
}
|
|
|
|
if deal_damage && let Some(target) = target {
|
|
if let Ok(mut shootable) = target.collider.clone().try_dynify::<dyn Shootable>() {
|
|
self.run_deferred(move |_| {
|
|
shootable.dyn_bind_mut().on_shoot(
|
|
DamageSource::Player(player_id),
|
|
100,
|
|
delta,
|
|
);
|
|
});
|
|
}
|
|
}
|
|
}
|
|
|
|
self.cooldown_remaining = self.cooldown;
|
|
|
|
true
|
|
}
|
|
|
|
fn get_type(&self) -> WeaponType {
|
|
WeaponType::Raygun
|
|
}
|
|
|
|
fn get_max_cd(&self) -> f64 {
|
|
self.cooldown
|
|
}
|
|
|
|
fn get_remaining_cd(&self) -> f64 {
|
|
self.cooldown_remaining
|
|
}
|
|
|
|
fn set_remaining_cd(&mut self, cd: f64) {
|
|
self.cooldown_remaining = cd;
|
|
}
|
|
}
|
|
|
|
#[derive(GodotClass)]
|
|
#[class(base=Node3D, init)]
|
|
pub struct Shotgun {
|
|
#[export]
|
|
sound_emitter: Option<Gd<AudioStreamPlayer3D>>,
|
|
#[export]
|
|
vfx: Option<Gd<GpuParticles3D>>,
|
|
|
|
#[export]
|
|
cooldown: f64,
|
|
|
|
#[export]
|
|
decal: Option<Gd<PackedScene>>,
|
|
|
|
cooldown_remaining: f64,
|
|
|
|
rng: Gd<RandomNumberGenerator>,
|
|
|
|
base: Base<Node3D>,
|
|
}
|
|
|
|
#[godot_api]
|
|
impl INode3D for Shotgun {
|
|
fn process(&mut self, delta: f64) {
|
|
self.cooldown_remaining -= delta;
|
|
}
|
|
}
|
|
|
|
#[godot_dyn]
|
|
impl Weapon for Shotgun {
|
|
fn shoot(
|
|
&mut self,
|
|
player: Rid,
|
|
player_id: u16,
|
|
from: Vector3,
|
|
to: Vector3,
|
|
up: Vector3,
|
|
deal_damage: bool,
|
|
play_fx: bool,
|
|
) -> bool {
|
|
if self.cooldown_remaining > 0. {
|
|
return false;
|
|
}
|
|
|
|
if let Some(audio) = &mut self.sound_emitter
|
|
&& play_fx
|
|
{
|
|
audio.play();
|
|
}
|
|
if let Some(vfx) = &mut self.vfx
|
|
&& play_fx
|
|
{
|
|
vfx.set_emitting(true);
|
|
}
|
|
|
|
let mut colliders: HashMap<Gd<Object>, Vec<Vector3>> = HashMap::new();
|
|
let results = shotgun_ray(
|
|
from,
|
|
to,
|
|
up,
|
|
&self.base().get_world_3d(),
|
|
&Array::from_iter(vec![player]),
|
|
10,
|
|
PI / 2.,
|
|
10.,
|
|
None,
|
|
);
|
|
if play_fx {
|
|
let mut bullet_decal_results = Vec::new();
|
|
for _ in 0..10 {
|
|
if let Some(result) = results
|
|
.get(self.rng.randi_range(0, results.len() as i32 - 1) as usize)
|
|
.cloned()
|
|
{
|
|
bullet_decal_results.push(result);
|
|
}
|
|
}
|
|
|
|
for result in bullet_decal_results {
|
|
self.run_deferred(move |s| {
|
|
add_decal(&result, s.decal.clone());
|
|
});
|
|
}
|
|
}
|
|
|
|
for result in &results {
|
|
if let Some(positions) = colliders.get_mut(&result.collider) {
|
|
positions.push(result.position)
|
|
} else {
|
|
colliders.insert(result.collider.clone(), vec![result.position]);
|
|
}
|
|
}
|
|
|
|
if deal_damage {
|
|
for (collider, positions) in colliders {
|
|
let position = positions.iter().sum::<Vector3>() / positions.len() as f32;
|
|
let delta = position - from;
|
|
|
|
if let Ok(mut shootable) = collider.clone().try_dynify::<dyn Shootable>() {
|
|
self.run_deferred(move |_| {
|
|
shootable.dyn_bind_mut().on_shoot(
|
|
DamageSource::Player(player_id),
|
|
(500. / delta.length()) as i32,
|
|
delta.normalized(),
|
|
);
|
|
});
|
|
}
|
|
}
|
|
}
|
|
|
|
self.cooldown_remaining = self.cooldown;
|
|
|
|
true
|
|
}
|
|
|
|
fn get_type(&self) -> WeaponType {
|
|
WeaponType::Shotgun
|
|
}
|
|
|
|
fn get_max_cd(&self) -> f64 {
|
|
self.cooldown
|
|
}
|
|
|
|
fn get_remaining_cd(&self) -> f64 {
|
|
self.cooldown_remaining
|
|
}
|
|
|
|
fn set_remaining_cd(&mut self, cd: f64) {
|
|
self.cooldown_remaining = cd;
|
|
}
|
|
}
|
|
|
|
#[derive(GodotClass)]
|
|
#[class(base=Node3D, init)]
|
|
pub struct Beam {
|
|
pub source: Option<Vector3>,
|
|
pub target: Option<Vector3>,
|
|
|
|
distance: f32,
|
|
girth: f32,
|
|
|
|
base: Base<Node3D>,
|
|
}
|
|
|
|
#[godot_api]
|
|
impl INode3D for Beam {
|
|
fn ready(&mut self) {
|
|
if let (Some(target), Some(source)) = (self.target, self.source) {
|
|
let midway_point = (target + source) / 2.;
|
|
self.distance = source.distance_to(target);
|
|
self.girth = 1.;
|
|
|
|
self.scale();
|
|
self.base_mut().look_at_from_position(source, target);
|
|
self.base_mut().set_global_position(midway_point);
|
|
}
|
|
}
|
|
|
|
fn process(&mut self, _delta: f32) {
|
|
self.girth = self.girth.lerp(0., 0.07);
|
|
self.scale();
|
|
}
|
|
}
|
|
|
|
impl Beam {
|
|
fn scale(&mut self) {
|
|
let length = Vector3::BACK * self.distance;
|
|
let girth_scale = (Vector3::UP + Vector3::RIGHT) * self.girth;
|
|
self.base_mut().set_scale(length + girth_scale);
|
|
|
|
if self.girth < 0.01 {
|
|
self.base_mut().queue_free();
|
|
}
|
|
}
|
|
}
|
|
|
|
#[derive(GodotClass)]
|
|
#[class(base=Node3D, init)]
|
|
pub struct BallWeapon {
|
|
base: Base<Node3D>,
|
|
}
|
|
|
|
#[godot_dyn]
|
|
impl Weapon for BallWeapon {
|
|
fn shoot(
|
|
&mut self,
|
|
_: Rid,
|
|
_: u16,
|
|
_: Vector3,
|
|
_: Vector3,
|
|
_: Vector3,
|
|
_: bool,
|
|
_: bool,
|
|
) -> bool {
|
|
true
|
|
}
|
|
|
|
fn get_type(&self) -> WeaponType {
|
|
WeaponType::Ball
|
|
}
|
|
|
|
fn get_max_cd(&self) -> f64 {
|
|
0.
|
|
}
|
|
|
|
fn get_remaining_cd(&self) -> f64 {
|
|
0.
|
|
}
|
|
|
|
fn set_remaining_cd(&mut self, _: f64) {}
|
|
}
|
|
|
|
fn add_decal(result: &RaycastResult, prefab: Option<Gd<PackedScene>>) {
|
|
if let Some(mut game) = Game::singleton()
|
|
&& let Some(map) = &mut game.bind_mut().current_map
|
|
&& let Some(prefab) = prefab
|
|
{
|
|
let mut decal = prefab.instantiate_as::<Node3D>();
|
|
map.add_child(&decal);
|
|
decal.set_global_position(result.position);
|
|
let quat = Quaternion::from_rotation_arc(Vector3::UP, result.normal);
|
|
decal.set_global_rotation(quat.get_euler());
|
|
}
|
|
}
|