Sync telegrenades

godot/scenes/player/local_player.tscn

@@ -23,6 +23,7 @@ hud = NodePath("hud")
 hit_sound = NodePath("hit_sound")
 health = 100
 punch_cooldown = 1.0
+telegrenade_cd = 10.0
 collision_mask = 4
 slide_on_ceiling = false
 floor_constant_speed = true

godot/scenes/player/remote_player.tscn

@@ -49,6 +49,7 @@ health_bar = NodePath("health_bar_sprite/health_bar_viewport/health_bar")
 double_health_bar = NodePath("double_health_bar_sprite/health_bar_viewport/double_health_bar")
 health_bar_sprite = NodePath("health_bar_sprite")
 double_health_bar_sprite = NodePath("double_health_bar_sprite")
+telegrenade_cd = 10.0
 collision_layer = 2
 collision_mask = 4
 slide_on_ceiling = false

rust/src/game_manager.rs

@@ -15,14 +15,18 @@ use crate::{
         network_manager::{
             BallSync, NetworkManager,
             Package::{self, Kill, SelfSync, SetTeam, SpawnPlayer, TakeDamage},
-            PeerKind, SyncPackage,
+            PeerKind, SyncPackage, TelegrenadeSync,
         },
         util::NetVector3,
     },
     pickup::PickupKind,
     player::{
-        DamageSource, IPlayer, NetTransform, ball::Ball, local_player::LocalPlayer,
+        DamageSource, IPlayer, NetTransform,
-        remote_player::RemotePlayer, telegrenade::Telegrenade, weapon::WeaponType,
+        ball::Ball,
+        local_player::LocalPlayer,
+        remote_player::RemotePlayer,
+        telegrenade::{self, Telegrenade},
+        weapon::WeaponType,
     },
     replay::{ReplayEvent, ReplayPlayback, ReplayRecorder},
     team_resource::TeamResource,
@@ -292,12 +296,24 @@ impl INode for Game {
                                 player.get_look_up(),
                                 player.get_transform(),
                             ) {
+                                let telegrenade_sync = if let Some(character) = &player.character
+                                    && let Some(telegrenade) =
+                                        character.dyn_bind().get_telegrenade()
+                                {
+                                    Some(TelegrenadeSync {
+                                        transform: telegrenade.bind().get_transform(),
+                                        velocity: telegrenade.bind().get_velocity(),
+                                    })
+                                } else {
+                                    None
+                                };
                                 sync_data.insert(
                                     player.id(),
                                     SyncPackage {
                                         movement_direction: dir,
                                         look_up,
                                         transform,
+                                        telegrenade: telegrenade_sync,
                                     },
                                 );
                             }
@@ -977,10 +993,20 @@ impl Game {
                 movement_direction,
                 look_up,
                 transform,
+                telegrenade,
             },
         ) in sync_data
         {
             if let Some(player) = self.players.iter_mut().find(|p| p.id() == player_id) {
+                if let Some(telegrenade_sync) = telegrenade
+                    && let Some(character) = &mut player.character
+                    && let Some(mut telegrenade) = character.dyn_bind().get_telegrenade()
+                {
+                    telegrenade.set_global_position(telegrenade_sync.transform.location.into());
+                    telegrenade.set_global_rotation(telegrenade_sync.transform.rotation.into());
+                    telegrenade.set_linear_velocity(telegrenade_sync.velocity.into());
+                }
+
                 if player.id() != self.self_id.unwrap_or(0) {
                     // Sync remote players always
                     player.set_transform(transform);
@@ -1329,6 +1355,7 @@ impl Player {
                 movement_direction: character.dyn_bind().get_movement_dir().into(),
                 look_up: character.dyn_bind().get_look_up(),
                 transform: character.dyn_bind().get_transform(),
+                telegrenade: None,
             })
         } else {
             None

rust/src/net/network_manager.rs

@@ -326,6 +326,13 @@ pub struct SyncPackage {
     pub movement_direction: NetVector3,
     pub look_up: f32,
     pub transform: NetTransform,
+    pub telegrenade: Option<TelegrenadeSync>,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct TelegrenadeSync {
+    pub transform: NetTransform,
+    pub velocity: NetVector3,
 }
 
 #[derive(Debug, Clone, Serialize, Deserialize)]

rust/src/player/local_player.rs

@@ -88,7 +88,10 @@ pub struct LocalPlayer {
 
     punch_cd_remaining: f64,
 
+    #[export]
+    telegrenade_cd: f64,
     telegrenade: Option<Gd<Telegrenade>>,
+    telegrenade_cd_remaining: f64,
 
     base: Base<CharacterBody3D>,
 }
@@ -167,7 +170,16 @@ impl IPlayer for LocalPlayer {
     fn apply_look_up(&mut self, _look: f32) {}
 
     fn try_throw_telegrenade(&mut self, to: Vector3) -> bool {
-        self.throw_telegrenade_common(to)
+        if self.telegrenade_cd_remaining > 0. {
+            return false;
+        }
+
+        if self.throw_telegrenade_common(to) {
+            self.telegrenade_cd_remaining = self.telegrenade_cd;
+            true
+        } else {
+            false
+        }
     }
 
     fn try_shoot(&mut self, to: Vector3, deal_damage: bool) -> bool {
@@ -325,6 +337,10 @@ impl IPlayer for LocalPlayer {
         self.telegrenade = grenade;
     }
 
+    fn get_telegrenade(&self) -> Option<Gd<Telegrenade>> {
+        self.telegrenade.clone()
+    }
+
     fn as_gd(&self) -> DynGd<CharacterBody3D, dyn IPlayer> {
         self.to_gd().into_dyn().upcast()
     }
@@ -370,6 +386,7 @@ impl ICharacterBody3D for LocalPlayer {
     fn process(&mut self, delta: f64) {
         self.time_passed += delta;
         self.punch_cd_remaining -= delta;
+        self.telegrenade_cd_remaining -= delta;
 
         if self.is_dead {
             self.dead_for += delta;

rust/src/player/mod.rs

@@ -69,6 +69,7 @@ pub trait IPlayer {
     fn on_pickup(&mut self, kind: PickupKind);
     fn try_throw_telegrenade(&mut self, to: Vector3) -> bool;
     fn set_telegrenade(&mut self, telegrenade: Option<Gd<Telegrenade>>);
+    fn get_telegrenade(&self) -> Option<Gd<Telegrenade>>;
     fn as_gd(&self) -> DynGd<CharacterBody3D, dyn IPlayer>;
 }
 

rust/src/player/remote_player.rs

@@ -64,7 +64,10 @@ pub struct RemotePlayer {
 
     punch_cd_remaining: f64,
 
-    pub telegrenade: Option<Gd<Telegrenade>>,
+    #[export]
+    telegrenade_cd: f64,
+    telegrenade: Option<Gd<Telegrenade>>,
+    telegrenade_cd_remaining: f64,
 
     base: Base<CharacterBody3D>,
 }
@@ -138,7 +141,16 @@ impl IPlayer for RemotePlayer {
     }
 
     fn try_throw_telegrenade(&mut self, to: Vector3) -> bool {
-        self.throw_telegrenade_common(to)
+        if self.telegrenade_cd_remaining > 0. {
+            return false;
+        }
+
+        if self.throw_telegrenade_common(to) {
+            self.telegrenade_cd_remaining = self.telegrenade_cd;
+            true
+        } else {
+            false
+        }
     }
 
     fn try_punch(&mut self, to: Vector3, deal_damage: bool) -> bool {
@@ -265,6 +277,10 @@ impl IPlayer for RemotePlayer {
         self.telegrenade = grenade;
     }
 
+    fn get_telegrenade(&self) -> Option<Gd<Telegrenade>> {
+        self.telegrenade.clone()
+    }
+
     fn as_gd(&self) -> DynGd<CharacterBody3D, dyn IPlayer> {
         self.to_gd().into_dyn().upcast()
     }
@@ -286,6 +302,7 @@ impl ICharacterBody3D for RemotePlayer {
 
     fn process(&mut self, delta: f64) {
         self.punch_cd_remaining -= delta;
+        self.telegrenade_cd_remaining -= delta;
 
         if self.is_dead {
             self.dead_for += delta;