godot/scenes/misc/teleport_grenade.tscn

@@ -15,8 +15,6 @@ size = Vector3(0.1, 0.1, 0.1)
 [node name="teleport_grenade" type="Telegrenade" unique_id=1670808846]
 collision_layer = 0
 collision_mask = 4
-contact_monitor = true
-max_contacts_reported = 1
 
 [node name="collision_shape_3d" type="CollisionShape3D" parent="." unique_id=1124839205]
 shape = SubResource("SphereShape3D_1cgct")

godot/scenes/player/local_player.tscn

@@ -23,7 +23,6 @@ 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,7 +49,6 @@ 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

@@ -14,21 +14,15 @@ use crate::{
     net::{
         network_manager::{
             BallSync, NetworkManager,
-            Package::{
-                self, Kill, SelfSync, SetTeam, SpawnPlayer, TakeDamage, TelegrenadeTeleport,
-            },
-            PeerKind, SyncPackage, TelegrenadeSync,
+            Package::{self, Kill, SelfSync, SetTeam, SpawnPlayer, TakeDamage},
+            PeerKind, SyncPackage,
         },
         util::NetVector3,
     },
     pickup::PickupKind,
     player::{
-        DamageSource, IPlayer, NetTransform,
-        ball::Ball,
-        local_player::LocalPlayer,
-        remote_player::RemotePlayer,
-        telegrenade::{self, Telegrenade},
-        weapon::WeaponType,
+        DamageSource, IPlayer, NetTransform, ball::Ball, local_player::LocalPlayer,
+        remote_player::RemotePlayer, telegrenade::Telegrenade, weapon::WeaponType,
     },
     replay::{ReplayEvent, ReplayPlayback, ReplayRecorder},
     team_resource::TeamResource,
@@ -298,24 +292,12 @@ 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,
                                     },
                                 );
                             }
@@ -995,20 +977,10 @@ 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);
@@ -1302,36 +1274,6 @@ impl Game {
             character.dyn_bind_mut().try_throw_telegrenade(to.into());
         }
     }
-
-    // Handle telegrenade activate from server to client
-    pub fn handle_telegrenade_teleport(&mut self, player_id: u16, to: NetVector3) {
-        if let Some(player) = self.find_player_mut(player_id)
-            && let Some(character) = &mut player.character
-        {
-            character.dyn_bind_mut().telegrenade_teleport(to.into());
-        }
-    }
-
-    // Handle telegrenade activation from client to server
-    pub fn handle_telegrenade_activate(&mut self, player_id: u16) {
-        if let Some(player) = self.find_player_mut(player_id)
-            && let Some(character) = &mut player.character
-        {
-            let pos = if let Some(telegrenade) = character.dyn_bind().get_telegrenade() {
-                telegrenade.get_global_position()
-            } else {
-                Vector3::ZERO
-            };
-            character.dyn_bind_mut().telegrenade_teleport(pos);
-            self.run_deferred(move |_| {
-                if let Some(peer) = &mut NetworkManager::singleton().bind_mut().peer
-                    && let PeerKind::Server(peer, _) = peer
-                {
-                    peer.broadcast_reliable(TelegrenadeTeleport(player_id, pos.into()));
-                }
-            });
-        }
-    }
 }
 
 #[derive(Clone, Debug)]
@@ -1387,7 +1329,6 @@ 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

@@ -316,8 +316,6 @@ pub enum Package {
     Announcement(u16, Announcement),
     Pickup(u8, u16),
     ThrowTelegrenade(u16, NetVector3),
-    TelegrenadeTeleport(u16, NetVector3),
-    TelegrenadeActivate,
 
     // End-of-Game packages
     FinishGame,
@@ -328,13 +326,6 @@ 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/net/protocol.rs

@@ -238,11 +238,6 @@ impl NetworkManager {
                                 }
                             }
                         }
-                        Package::TelegrenadeTeleport(player_id, to) => {
-                            if let Some(game) = &mut Game::singleton() {
-                                game.bind_mut().handle_telegrenade_teleport(player_id, to);
-                            }
-                        }
                         _ => {}
                     },
                 },
@@ -464,15 +459,6 @@ impl NetworkManager {
                                 }
                             }
                         }
-                        Package::TelegrenadeActivate => {
-                            if let Some(game) = &mut Game::singleton() {
-                                let player =
-                                    game.bind().find_player_by_addr(&conn.address).cloned();
-                                if let Some(player) = player {
-                                    game.bind_mut().handle_telegrenade_activate(player.id());
-                                }
-                            }
-                        }
                         _ => {}
                     },
                 },

rust/src/player/local_player.rs

@@ -88,10 +88,7 @@ pub struct LocalPlayer {
 
     punch_cd_remaining: f64,
 
-    #[export]
-    telegrenade_cd: f64,
     telegrenade: Option<Gd<Telegrenade>>,
-    telegrenade_cd_remaining: f64,
 
     base: Base<CharacterBody3D>,
 }
@@ -170,16 +167,7 @@ impl IPlayer for LocalPlayer {
     fn apply_look_up(&mut self, _look: f32) {}
 
     fn try_throw_telegrenade(&mut self, to: Vector3) -> bool {
-        if self.telegrenade_cd_remaining > 0. {
-            return false;
-        }
-
-        if self.throw_telegrenade_common(to) {
-            self.telegrenade_cd_remaining = self.telegrenade_cd;
-            true
-        } else {
-            false
-        }
+        self.throw_telegrenade_common(to)
     }
 
     fn try_shoot(&mut self, to: Vector3, deal_damage: bool) -> bool {
@@ -337,14 +325,6 @@ impl IPlayer for LocalPlayer {
         self.telegrenade = grenade;
     }
 
-    fn get_telegrenade(&self) -> Option<Gd<Telegrenade>> {
-        self.telegrenade.clone()
-    }
-
-    fn telegrenade_teleport(&mut self, to: Vector3) -> bool {
-        self.telegrenade_teleport_common(to)
-    }
-
     fn as_gd(&self) -> DynGd<CharacterBody3D, dyn IPlayer> {
         self.to_gd().into_dyn().upcast()
     }
@@ -390,7 +370,6 @@ 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;
@@ -500,24 +479,6 @@ impl ICharacterBody3D for LocalPlayer {
     fn input(&mut self, event: Gd<InputEvent>) {
         if self.locked {
             if event.is_action_pressed("throw_telegrenade") {
-                if let Some(telegrenade) = &mut self.telegrenade {
-                    if let Some(peer) = &mut NetworkManager::singleton().bind_mut().peer {
-                        match peer {
-                            PeerKind::Client(peer, socket_addr) => {
-                                peer.send_reliable(socket_addr, Package::TelegrenadeActivate);
-                            }
-                            PeerKind::Server(peer, _) => {
-                                let position = telegrenade.get_global_position();
-                                self.telegrenade_teleport(position);
-                                peer.broadcast_reliable(Package::TelegrenadeTeleport(
-                                    self.player_id.unwrap_or(0),
-                                    position.into(),
-                                ));
-                            }
-                        }
-                    }
-                }
-
                 if let Some(pos) = self.raycast_from_camera() {
                     if let Some(peer) = &mut NetworkManager::singleton().bind_mut().peer {
                         match peer {

rust/src/player/mod.rs

@@ -69,8 +69,6 @@ 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 telegrenade_teleport(&mut self, to: Vector3) -> bool;
     fn as_gd(&self) -> DynGd<CharacterBody3D, dyn IPlayer>;
 }
 
@@ -83,7 +81,6 @@ pub trait PlayerCommon {
     fn try_shoot_common(&mut self, to: Vector3, deal_damage: bool) -> bool;
     fn try_punch_common(&mut self, to: Vector3, deal_damage: bool) -> bool;
     fn throw_telegrenade_common(&mut self, to: Vector3) -> bool;
-    fn telegrenade_teleport_common(&mut self, to: Vector3) -> bool;
 }
 
 impl<T: IPlayer + ICharacterBody3D + WithBaseField> PlayerCommon for T {
@@ -292,17 +289,6 @@ impl<T: IPlayer + ICharacterBody3D + WithBaseField> PlayerCommon for T {
 
         true
     }
-
-    fn telegrenade_teleport_common(&mut self, to: Vector3) -> bool {
-        if let Some(mut telegrenade) = self.get_telegrenade() {
-            telegrenade.queue_free();
-        } else {
-            return false;
-        }
-        self.set_telegrenade(None);
-        self.base_mut().set_global_position(to);
-        true
-    }
 }
 
 #[derive(Clone, Copy, Debug, Serialize, Deserialize)]

rust/src/player/remote_player.rs

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

rust/src/player/telegrenade.rs

@@ -4,10 +4,7 @@ use godot::{
 };
 
 use crate::{
-    net::{
-        network_manager::{NetworkManager, Package, PeerKind},
-        util::NetVector3,
-    },
+    net::util::NetVector3,
     player::{IPlayer, NetTransform},
 };
 
@@ -21,28 +18,11 @@ pub struct Telegrenade {
 
 #[godot_api]
 impl IRigidBody3D for Telegrenade {
-    fn ready(&mut self) {
-        self.base()
-            .signals()
-            .body_entered()
-            .connect_other(self, |s, _| s.on_collision());
-    }
+    fn ready(&mut self) {}
 }
 
 impl Telegrenade {
-    pub fn on_collision(&mut self) {
-        if let Some(peer) = &mut NetworkManager::singleton().bind_mut().peer
-            && let PeerKind::Server(peer, _) = peer
-            && let Some(mut player) = self.player.clone()
-        {
-            let pos = self.base().get_global_position();
-            player.dyn_bind_mut().telegrenade_teleport(pos);
-            peer.broadcast_reliable(Package::TelegrenadeTeleport(
-                player.dyn_bind().get_player_id().unwrap_or(0),
-                pos.into(),
-            ));
-        }
-    }
+    pub fn teleport(&mut self) {}
 
     pub fn get_transform(&self) -> NetTransform {
         NetTransform {