godot/maps/default_map.tres

@@ -1,6 +1,6 @@
-[gd_resource type="MapResource" format=3 uid="uid://c7n1tacc7a73t"]
+[gd_resource type="Map" format=3 uid="uid://b4rw48yjf7q3q"]
 
-[ext_resource type="PackedScene" uid="uid://7iooamjot1tg" path="res://scenes/map0.tscn" id="1_k5804"]
+[ext_resource type="PackedScene" uid="uid://lahirbqfppvw" path="res://scenes/main.tscn" id="1_k5804"]
 
 [resource]
 name = "Default Map"

godot/maps/default_map_2.tres

@@ -0,0 +1,7 @@
+[gd_resource type="Map" format=3 uid="uid://crti664evgfmj"]
+
+[ext_resource type="PackedScene" uid="uid://lahirbqfppvw" path="res://scenes/main.tscn" id="1_gr7ev"]
+
+[resource]
+name = "Default Map 2"
+scene = ExtResource("1_gr7ev")

godot/project.godot

@@ -23,7 +23,6 @@ GameManagerGlobal="*uid://bii6018k3ip3t"
 
 [display]
 
-window/size/mode=2
 window/stretch/mode="canvas_items"
 window/stretch/aspect="expand"
 
@@ -41,32 +40,6 @@ toggle_cli={
 "deadzone": 0.2,
 "events": [Object(InputEventKey,"resource_local_to_scene":false,"resource_name":"","device":-1,"window_id":0,"alt_pressed":false,"shift_pressed":false,"ctrl_pressed":false,"meta_pressed":false,"pressed":false,"keycode":0,"physical_keycode":167,"key_label":0,"unicode":167,"location":0,"echo":false,"script":null)
 , Object(InputEventKey,"resource_local_to_scene":false,"resource_name":"","device":-1,"window_id":0,"alt_pressed":false,"shift_pressed":false,"ctrl_pressed":false,"meta_pressed":false,"pressed":false,"keycode":0,"physical_keycode":4194332,"key_label":0,"unicode":0,"location":0,"echo":false,"script":null)
-, Object(InputEventKey,"resource_local_to_scene":false,"resource_name":"","device":-1,"window_id":0,"alt_pressed":false,"shift_pressed":false,"ctrl_pressed":false,"meta_pressed":false,"pressed":false,"keycode":0,"physical_keycode":4194343,"key_label":0,"unicode":0,"location":0,"echo":false,"script":null)
-]
-}
-left={
-"deadzone": 0.2,
-"events": [Object(InputEventKey,"resource_local_to_scene":false,"resource_name":"","device":-1,"window_id":0,"alt_pressed":false,"shift_pressed":false,"ctrl_pressed":false,"meta_pressed":false,"pressed":false,"keycode":0,"physical_keycode":65,"key_label":0,"unicode":97,"location":0,"echo":false,"script":null)
-]
-}
-right={
-"deadzone": 0.2,
-"events": [Object(InputEventKey,"resource_local_to_scene":false,"resource_name":"","device":-1,"window_id":0,"alt_pressed":false,"shift_pressed":false,"ctrl_pressed":false,"meta_pressed":false,"pressed":false,"keycode":0,"physical_keycode":68,"key_label":0,"unicode":100,"location":0,"echo":false,"script":null)
-]
-}
-forward={
-"deadzone": 0.2,
-"events": [Object(InputEventKey,"resource_local_to_scene":false,"resource_name":"","device":-1,"window_id":0,"alt_pressed":false,"shift_pressed":false,"ctrl_pressed":false,"meta_pressed":false,"pressed":false,"keycode":0,"physical_keycode":87,"key_label":0,"unicode":119,"location":0,"echo":false,"script":null)
-]
-}
-backward={
-"deadzone": 0.2,
-"events": [Object(InputEventKey,"resource_local_to_scene":false,"resource_name":"","device":-1,"window_id":0,"alt_pressed":false,"shift_pressed":false,"ctrl_pressed":false,"meta_pressed":false,"pressed":false,"keycode":0,"physical_keycode":83,"key_label":0,"unicode":115,"location":0,"echo":false,"script":null)
-]
-}
-jump={
-"deadzone": 0.2,
-"events": [Object(InputEventKey,"resource_local_to_scene":false,"resource_name":"","device":-1,"window_id":0,"alt_pressed":false,"shift_pressed":false,"ctrl_pressed":false,"meta_pressed":false,"pressed":false,"keycode":0,"physical_keycode":32,"key_label":0,"unicode":32,"location":0,"echo":false,"script":null)
 ]
 }
 

godot/scenes/game_manager.tscn

@@ -1,6 +1,7 @@
 [gd_scene format=3 uid="uid://bii6018k3ip3t"]
 
-[ext_resource type="MapResource" uid="uid://c7n1tacc7a73t" path="res://maps/default_map.tres" id="1_glms7"]
+[ext_resource type="Map" uid="uid://b4rw48yjf7q3q" path="res://maps/default_map.tres" id="1_glms7"]
+[ext_resource type="Map" uid="uid://crti664evgfmj" path="res://maps/default_map_2.tres" id="2_udu3i"]
 
 [node name="game_manager" type="GameManager" unique_id=1442044769]
-maps = Array[MapResource]([ExtResource("1_glms7")])
+maps = Array[Map]([ExtResource("1_glms7"), ExtResource("2_udu3i")])

godot/scenes/lobby.tscn

@@ -68,28 +68,19 @@ grow_vertical = 0
 vertical_alignment = 2
 
 [node name="ready_button" type="Button" parent="." unique_id=311553419]
-layout_mode = 1
-anchors_preset = 2
-anchor_top = 1.0
-anchor_bottom = 1.0
+layout_mode = 0
 offset_left = 129.0
-offset_top = -177.0
+offset_top = 504.0
 offset_right = 278.0
-offset_bottom = -126.0
-grow_vertical = 0
+offset_bottom = 555.0
 text = "Not Ready"
 
 [node name="v_box_container2" type="VBoxContainer" parent="." unique_id=653902328]
-layout_mode = 1
-anchors_preset = 1
-anchor_left = 1.0
-anchor_right = 1.0
-offset_left = -329.0
+layout_mode = 0
+offset_left = 716.0
 offset_top = 146.0
-offset_right = -221.0
+offset_right = 824.0
 offset_bottom = 204.0
-grow_horizontal = 0
 
 [node name="option_button" type="OptionButton" parent="v_box_container2" unique_id=426342653]
 layout_mode = 2
-metadata/_edit_lock_ = true

godot/scenes/local_player.tscn

@@ -1,21 +0,0 @@
-[gd_scene format=3 uid="uid://ct70bpbca8one"]
-
-[sub_resource type="CapsuleMesh" id="CapsuleMesh_1cgct"]
-
-[sub_resource type="CapsuleShape3D" id="CapsuleShape3D_1cgct"]
-
-[node name="player" type="LocalPlayer" unique_id=863055906 node_paths=PackedStringArray("camera")]
-look_sensitivity = 1.5
-camera = NodePath("camera_3d")
-move_speed = 5.0
-collision_mask = 2
-
-[node name="mesh_instance_3d" type="MeshInstance3D" parent="." unique_id=700336478]
-mesh = SubResource("CapsuleMesh_1cgct")
-
-[node name="collision_shape_3d" type="CollisionShape3D" parent="." unique_id=1110995513]
-shape = SubResource("CapsuleShape3D_1cgct")
-
-[node name="camera_3d" type="Camera3D" parent="." unique_id=1773137418]
-transform = Transform3D(1, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0.5391109, 0)
-current = true

godot/scenes/map0.tscn

@@ -1,46 +0,0 @@
-[gd_scene format=3 uid="uid://7iooamjot1tg"]
-
-[ext_resource type="PackedScene" uid="uid://ct70bpbca8one" path="res://scenes/local_player.tscn" id="1_yjvui"]
-[ext_resource type="PackedScene" uid="uid://kfxc0migw80o" path="res://scenes/remote_player.tscn" id="2_kcncr"]
-
-[sub_resource type="ImageTexture" id="ImageTexture_3vyb7"]
-
-[sub_resource type="StandardMaterial3D" id="StandardMaterial3D_u8vuu"]
-albedo_texture = SubResource("ImageTexture_3vyb7")
-
-[sub_resource type="PlaneMesh" id="PlaneMesh_1cgct"]
-size = Vector2(100, 100)
-
-[sub_resource type="BoxShape3D" id="BoxShape3D_1cgct"]
-size = Vector3(100, 0.01, 100)
-
-[node name="map_0" type="Map" unique_id=914577955 node_paths=PackedStringArray("spawner")]
-spawner = NodePath("spawner")
-local_player = ExtResource("1_yjvui")
-remote_player = ExtResource("2_kcncr")
-
-[node name="net_stats_label" type="NetStatsLabel" parent="." unique_id=1821474986]
-anchors_preset = 2
-anchor_top = 1.0
-anchor_bottom = 1.0
-offset_top = -152.0
-offset_right = 369.0
-grow_vertical = 0
-vertical_alignment = 2
-
-[node name="terrain" type="MeshInstance3D" parent="." unique_id=1474127252]
-material_override = SubResource("StandardMaterial3D_u8vuu")
-mesh = SubResource("PlaneMesh_1cgct")
-
-[node name="static_body_3d" type="StaticBody3D" parent="terrain" unique_id=203785193]
-collision_layer = 3
-collision_mask = 3
-
-[node name="collision_shape_3d" type="CollisionShape3D" parent="terrain/static_body_3d" unique_id=1466526153]
-shape = SubResource("BoxShape3D_1cgct")
-
-[node name="directional_light_3d" type="DirectionalLight3D" parent="." unique_id=793524416]
-transform = Transform3D(1, 0, 0, 0, 0.7274598, 0.6861503, 0, -0.6861503, 0.7274598, -5.1267624, 3.3997262, 3.715582)
-
-[node name="spawner" type="Node3D" parent="." unique_id=1364438299]
-transform = Transform3D(1, 0, 0, 0, 1, 0, 0, 0, 1, -0.028572083, 3.9666176, 0.031027317)

godot/scenes/remote_player.tscn

@@ -1,15 +0,0 @@
-[gd_scene format=3 uid="uid://kfxc0migw80o"]
-
-[sub_resource type="CapsuleMesh" id="CapsuleMesh_1cgct"]
-
-[sub_resource type="CapsuleShape3D" id="CapsuleShape3D_1cgct"]
-
-[node name="player" type="RemotePlayer" unique_id=845968872]
-move_speed = 5.0
-collision_mask = 2
-
-[node name="mesh_instance_3d" type="MeshInstance3D" parent="." unique_id=700336478]
-mesh = SubResource("CapsuleMesh_1cgct")
-
-[node name="collision_shape_3d" type="CollisionShape3D" parent="." unique_id=1110995513]
-shape = SubResource("CapsuleShape3D_1cgct")

rust/src/game_manager.rs

@@ -1,20 +1,11 @@
-use std::{collections::HashMap, net::SocketAddr};
+use std::net::SocketAddr;
 
-use godot::{classes::CharacterBody3D, prelude::*, tools::get_autoload_by_name};
+use godot::{prelude::*, tools::get_autoload_by_name};
 use serde::{Deserialize, Serialize};
 
 use crate::{
-    map::Map,
-    map_resource::MapResource,
-    net::{
-        network_manager::{
-            NetworkManager,
-            Package::{self, SelfSync},
-            PeerKind,
-        },
-        util::NetVector3,
-    },
-    player::{IPlayer, NetPlayerTransform},
+    map_resource::Map,
+    net::network_manager::{NetworkManager, Package, PeerKind},
 };
 
 pub const GAME_MANAGER_GLOBAL: &str = "GameManagerGlobal";
@@ -26,7 +17,7 @@ pub struct GameManager {
     base: Base<Node>,
 
     #[export]
-    pub maps: Array<Gd<MapResource>>,
+    pub maps: Array<Gd<Map>>,
 }
 
 #[godot_api]
@@ -79,8 +70,8 @@ impl GameManager {
 #[class(base=Node, init)]
 pub struct Game {
     pub selected_map_idx: u8,
-    pub selected_map: Option<Gd<MapResource>>,
-    pub maps: Array<Gd<MapResource>>,
+    pub selected_map: Option<Gd<Map>>,
+    pub maps: Array<Gd<Map>>,
 
     is_host: bool,
     player_counter: u16,
@@ -88,53 +79,9 @@ pub struct Game {
     pub players: Vec<Player>,
     game_started: bool,
 
-    pub current_map: Option<Gd<Map>>,
-    since_last_sync: f64,
-
     base: Base<Node>,
 }
 
-#[godot_api]
-impl INode for Game {
-    fn process(&mut self, delta: f64) {
-        self.since_last_sync += delta;
-        if self.since_last_sync > (1. / 60.) {
-            self.since_last_sync = 0.;
-            if let Some(_) = self.current_map {
-                if let Some(peer) = &mut NetworkManager::singleton().bind_mut().peer {
-                    match peer {
-                        PeerKind::Client(peer, socket_addr) => {
-                            if let Some(player) = self
-                                .players
-                                .iter()
-                                .find(|p| p.id == self.self_id.unwrap_or(0))
-                            {
-                                if let Some((dir, rot)) = &player.get_self_sync() {
-                                    peer.send_unreliable(
-                                        socket_addr,
-                                        SelfSync(dir.clone(), rot.clone()),
-                                    );
-                                }
-                            }
-                        }
-                        PeerKind::Server(peer, _) => {
-                            let mut sync_data = HashMap::new();
-                            for player in &self.players {
-                                if let (Some(dir), Some(transform)) =
-                                    (player.get_move_dir(), player.get_transform())
-                                {
-                                    sync_data.insert(player.id, (dir, transform));
-                                }
-                            }
-                            peer.broadcast_unreliable(Package::Sync(sync_data));
-                        }
-                    }
-                }
-            }
-        }
-    }
-}
-
 #[godot_api]
 impl Game {
     #[signal]
@@ -198,7 +145,6 @@ impl Game {
             name,
             ping: 0,
             ready: false,
-            character: None,
         });
         self.run_deferred(move |s| s.signals().on_new_player().emit(id));
         id
@@ -215,18 +161,10 @@ impl Game {
         self.players.iter().find(|p| p.connection_addr == *addr)
     }
 
-    pub fn find_player_by_addr_mut(&mut self, addr: &SocketAddr) -> Option<&mut Player> {
-        self.players.iter_mut().find(|p| p.connection_addr == *addr)
-    }
-
     pub fn find_player(&self, player_id: u16) -> Option<&Player> {
         self.players.iter().find(|p| p.id == player_id)
     }
 
-    pub fn find_player_mut(&mut self, player_id: u16) -> Option<&mut Player> {
-        self.players.iter_mut().find(|p| p.id == player_id)
-    }
-
     pub fn remove_player(&mut self, id: u16) {
         self.players.retain(|p| p.id != id);
         self.run_deferred(move |s| s.signals().on_player_disconnected().emit(id));
@@ -252,162 +190,13 @@ impl Game {
         }
         self.run_deferred(|s| s.signals().on_players_updated().emit());
     }
-
-    pub fn on_map_loaded(&mut self, map: Gd<Map>) {
-        self.current_map = Some(map);
-        if let Some(peer) = &mut NetworkManager::singleton().bind_mut().peer {
-            if let PeerKind::Client(peer, to) = peer {
-                peer.send_reliable(to, Package::MapLoaded);
-            } else {
-                self.run_deferred(|s| {
-                    for player in &mut s.players {
-                        if let Some(map) = &mut s.current_map {
-                            let character = map.bind_mut().spawn_player(
-                                player,
-                                player.id == s.self_id.unwrap_or(0),
-                                None,
-                            );
-                            player.character = character;
-                        }
-                    }
-                });
-            }
-        }
-    }
-
-    pub fn spawn_player(&mut self, id: u16, transform: NetPlayerTransform) {
-        if let Some(map) = &mut self.current_map {
-            if let Some(player) = self.players.iter_mut().find(|p| p.id == id) {
-                let character = map.bind_mut().spawn_player(
-                    player,
-                    player.id == self.self_id.unwrap_or(0),
-                    Some(transform),
-                );
-                player.character = character;
-            }
-        }
-    }
-
-    pub fn handle_sync(&mut self, sync_data: HashMap<u16, (NetVector3, NetPlayerTransform)>) {
-        for (player_id, (dir, transform)) in sync_data {
-            if let Some(player) = self.players.iter_mut().find(|p| p.id == player_id) {
-                if player.id != self.self_id.unwrap_or(0) {
-                    // Sync remote players always
-                    player.set_transform(transform);
-                    player.set_move_dir(dir);
-                } else {
-                    // Sync local player only if it's far enough
-                    if let Some(local_net_transform) = player.get_transform() {
-                        let local_location: Vector3 = local_net_transform.location.into();
-                        let remote_location: Vector3 = transform.location.into();
-                        if local_location.distance_squared_to(remote_location) > 2. {
-                            player.set_transform(transform);
-                        }
-                    }
-                }
-            }
-        }
-    }
-
-    pub fn handle_jump(&mut self, player_id: u16) {
-        if player_id != self.self_id.unwrap_or(0) {
-            if let Some(player) = self.find_player_mut(player_id) {
-                player.apply_jump();
-            }
-        }
-    }
 }
 
-#[derive(Clone, Debug)]
+#[derive(Clone, Deserialize, Serialize, Debug)]
 pub struct Player {
     pub id: u16,
     pub connection_addr: SocketAddr,
     pub name: String,
     pub ping: u128,
     pub ready: bool,
-    pub character: Option<DynGd<CharacterBody3D, dyn IPlayer + 'static>>,
-}
-
-impl Player {
-    pub fn get_transform(&self) -> Option<NetPlayerTransform> {
-        if let Some(character) = &self.character {
-            Some(character.dyn_bind().get_transform())
-        } else {
-            None
-        }
-    }
-
-    pub fn set_transform(&mut self, transform: NetPlayerTransform) {
-        if let Some(character) = &mut self.character {
-            character.dyn_bind_mut().apply_transform(transform);
-        }
-    }
-
-    pub fn get_move_dir(&self) -> Option<NetVector3> {
-        if let Some(character) = &self.character {
-            Some(character.dyn_bind().get_movement_dir().into())
-        } else {
-            None
-        }
-    }
-
-    pub fn set_move_dir(&mut self, dir: NetVector3) {
-        if let Some(character) = &mut self.character {
-            character.dyn_bind_mut().set_movement_dir(dir.into());
-        }
-    }
-
-    pub fn get_self_sync(&self) -> Option<(NetVector3, NetVector3)> {
-        if let Some(character) = &self.character {
-            Some((
-                character.dyn_bind().get_movement_dir().into(),
-                character.dyn_bind().get_transform().rotation,
-            ))
-        } else {
-            None
-        }
-    }
-
-    pub fn apply_self_sync(&mut self, dir: NetVector3, rot: NetVector3) {
-        if let Some(character) = &mut self.character {
-            character.dyn_bind_mut().set_movement_dir(dir.into());
-            character.dyn_bind_mut().apply_rotation(rot.into());
-        }
-    }
-
-    pub fn apply_jump(&mut self) {
-        if let Some(character) = &mut self.character {
-            character.dyn_bind_mut().jump();
-        }
-    }
-}
-
-#[derive(Debug, Serialize, Deserialize, Clone)]
-pub struct NetPlayer {
-    pub id: u16,
-    pub name: String,
-    pub ping: u128,
-}
-
-impl From<NetPlayer> for Player {
-    fn from(value: NetPlayer) -> Self {
-        Player {
-            id: value.id,
-            connection_addr: SocketAddr::from(([0, 0, 0, 0], 0)),
-            name: value.name,
-            ping: value.ping,
-            ready: false,
-            character: None,
-        }
-    }
-}
-
-impl From<Player> for NetPlayer {
-    fn from(value: Player) -> Self {
-        NetPlayer {
-            id: value.id,
-            name: value.name,
-            ping: value.ping,
-        }
-    }
 }

rust/src/lib.rs

@@ -3,10 +3,8 @@ use std::net::SocketAddr;
 use godot::prelude::*;
 
 pub mod game_manager;
-pub mod map;
 pub mod map_resource;
 pub mod net;
-pub mod player;
 pub mod ui;
 
 struct MyExtension;

rust/src/map.rs

@@ -1,87 +0,0 @@
-use godot::{classes::CharacterBody3D, prelude::*};
-
-use crate::{
-    game_manager::{Game, Player},
-    player::{IPlayer, LocalPlayer, NetPlayerTransform, RemotePlayer},
-};
-
-#[derive(GodotClass)]
-#[class(base=Node3D, init)]
-pub struct Map {
-    #[export]
-    pub spawner: Option<Gd<Node3D>>,
-    #[export]
-    pub local_player: Option<Gd<PackedScene>>,
-    #[export]
-    pub remote_player: Option<Gd<PackedScene>>,
-
-    base: Base<Node3D>,
-}
-
-#[godot_api]
-impl INode3D for Map {
-    fn ready(&mut self) {
-        if let Some(game) = &mut Game::singleton() {
-            game.bind_mut().on_map_loaded(self.to_gd());
-        }
-    }
-}
-
-#[godot_api]
-impl Map {
-    #[signal]
-    pub fn on_loaded();
-
-    pub fn spawn_player(
-        &mut self,
-        player: &Player,
-        is_local: bool,
-        transform: Option<NetPlayerTransform>,
-    ) -> Option<DynGd<CharacterBody3D, dyn IPlayer + 'static>> {
-        if is_local {
-            if let Some(local_player) = &self.local_player {
-                let mut node = local_player.instantiate_as::<LocalPlayer>();
-                node.bind_mut().player_id = Some(player.id);
-                self.base_mut().add_child(&node);
-                if let Some(transform) = transform {
-                    node.bind_mut()
-                        .base_mut()
-                        .set_global_position(transform.location.into());
-                    node.bind_mut()
-                        .base_mut()
-                        .set_global_rotation(transform.rotation.into());
-                } else {
-                    if let Some(spawner) = &self.spawner {
-                        node.bind_mut()
-                            .base_mut()
-                            .set_global_position(spawner.get_global_position());
-                    }
-                }
-                Some(node.into_dyn::<dyn IPlayer>().upcast())
-            } else {
-                None
-            }
-        } else if let Some(remote_player) = &self.remote_player {
-            let mut node = remote_player.instantiate_as::<RemotePlayer>();
-            node.bind_mut().player_id = Some(player.id);
-            self.base_mut().add_child(&node);
-            if let Some(transform) = transform {
-                node.bind_mut()
-                    .base_mut()
-                    .set_global_position(transform.location.into());
-                node.bind_mut()
-                    .base_mut()
-                    .set_global_rotation(transform.rotation.into());
-            } else {
-                if let Some(spawner) = &self.spawner {
-                    node.bind_mut()
-                        .base_mut()
-                        .set_global_position(spawner.get_global_position());
-                }
-            }
-            Some(node.into_dyn::<dyn IPlayer>().upcast())
-        } else {
-            None
-        }
-    }
-}

rust/src/map_resource.rs

@@ -2,7 +2,7 @@ use godot::prelude::*;
 
 #[derive(GodotClass)]
 #[class(base=Resource, init, tool)]
-pub struct MapResource {
+pub struct Map {
     #[export]
     pub name: GString,
     #[export]
@@ -12,7 +12,7 @@ pub struct MapResource {
 }
 
 #[godot_api]
-impl IResource for MapResource {
+impl IResource for Map {
     fn on_notification(&mut self, what: godot::classes::notify::ObjectNotification) {}
 
     fn to_string(&self) -> GString {

rust/src/net/mod.rs

@@ -1,3 +1,2 @@
 pub mod net_stats;
 pub mod network_manager;
-pub mod util;

rust/src/net/network_manager.rs

@@ -9,9 +9,8 @@ use serde::{Deserialize, Serialize};
 use teanet::{Peer, PeerConfig, PeerMessage, connections::Connection};
 
 use crate::{
-    game_manager::{Game, GameManager, NetPlayer, Player},
-    net::{net_stats::Stats, util::NetVector3},
-    player::NetPlayerTransform,
+    game_manager::{Game, GameManager, Player},
+    net::net_stats::Stats,
     ui::cli::{CliColor, CommandLinePanel},
 };
 
@@ -153,12 +152,7 @@ impl INode for NetworkManager {
                                             CliColor::Info,
                                         );
                                         if let Some(game) = &mut Game::singleton() {
-                                            game.bind_mut().set_players(
-                                                players
-                                                    .into_iter()
-                                                    .map(|p| p.clone().into())
-                                                    .collect(),
-                                            );
+                                            game.bind_mut().set_players(players);
                                             game.bind_mut().set_self(self_id);
                                         }
                                     }
@@ -212,21 +206,6 @@ impl INode for NetworkManager {
                                             game.bind_mut().start_game();
                                         }
                                     }
-                                    Package::SpawnPlayer(id, transform) => {
-                                        if let Some(game) = &mut Game::singleton() {
-                                            game.bind_mut().spawn_player(id, transform);
-                                        }
-                                    }
-                                    Package::Sync(sync_data) => {
-                                        if let Some(game) = &mut Game::singleton() {
-                                            game.bind_mut().handle_sync(sync_data);
-                                        }
-                                    }
-                                    Package::Jump(player_id) => {
-                                        if let Some(game) = &mut Game::singleton() {
-                                            game.bind_mut().handle_jump(player_id);
-                                        }
-                                    }
                                     _ => {}
                                 },
                             }
@@ -253,25 +232,20 @@ impl INode for NetworkManager {
                                             String::new(),
                                             None,
                                         );
+                                        let mut sent_players = game.bind().players.clone();
+                                        for player in &mut sent_players {
+                                            player.connection_addr =
+                                                SocketAddr::from(([0, 0, 0, 0], 0))
+                                        }
                                         peer.send_reliable(
                                             &connection.address,
-                                            Package::Players(
-                                                game.bind()
-                                                    .players
-                                                    .clone()
-                                                    .into_iter()
-                                                    .map(|p| p.into())
-                                                    .collect(),
-                                                self_id,
-                                            ),
+                                            Package::Players(sent_players, self_id),
                                         );
-                                        peer.broadcast_reliable(Package::NewPlayer(
-                                            game.bind()
-                                                .find_player(self_id)
-                                                .unwrap()
-                                                .clone()
-                                                .into(),
-                                        ));
+                                        let mut sent_player =
+                                            game.bind().find_player(self_id).unwrap().clone();
+                                        sent_player.connection_addr =
+                                            SocketAddr::from(([0, 0, 0, 0], 0));
+                                        peer.broadcast_reliable(Package::NewPlayer(sent_player));
 
                                         peer.send_reliable(
                                             &connection.address,
@@ -297,11 +271,7 @@ impl INode for NetworkManager {
                                             .map(|p| p.id);
                                         if let Some(player_id) = player_id {
                                             peer.broadcast_reliable(Package::PlayerLeft(
-                                                game.bind()
-                                                    .find_player(player_id)
-                                                    .unwrap()
-                                                    .clone()
-                                                    .into(),
+                                                game.bind().find_player(player_id).unwrap().clone(),
                                             ));
                                             game.bind_mut().remove_player(player_id);
                                         }
@@ -344,40 +314,6 @@ impl INode for NetworkManager {
                                             }
                                         }
                                     }
-                                    Package::MapLoaded => {
-                                        if let Some(game) = Game::singleton() {
-                                            for player in &game.bind().players {
-                                                if let Some(transform) = player.get_transform() {
-                                                    peer.send_reliable(
-                                                        &conn.address,
-                                                        Package::SpawnPlayer(player.id, transform),
-                                                    );
-                                                }
-                                            }
-                                        }
-                                    }
-                                    Package::SelfSync(dir, rot) => {
-                                        if let Some(game) = &mut Game::singleton() {
-                                            if let Some(player) = &mut game
-                                                .bind_mut()
-                                                .find_player_by_addr_mut(&conn.address)
-                                            {
-                                                player.apply_self_sync(dir, rot);
-                                            }
-                                        }
-                                    }
-                                    Package::Jump(_) => {
-                                        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_jump(player.id);
-                                                peer.broadcast_reliable(Package::Jump(player.id));
-                                            }
-                                        }
-                                    }
                                     _ => {}
                                 },
                             }
@@ -488,26 +424,15 @@ impl NetworkManager {
 #[derive(Debug, Clone, Serialize, Deserialize)]
 pub enum Package {
     Hello,
-
-    // Meta values
-    Players(Vec<NetPlayer>, u16),
-    UpdatePings(HashMap<u16, u128>),
+    Players(Vec<Player>, u16),
     SetNick(u16, String),
     SetSelfNick(String),
-    NewPlayer(NetPlayer),
-    PlayerLeft(NetPlayer),
-
-    // Lobby packages
+    UpdatePings(HashMap<u16, u128>),
+    NewPlayer(Player),
+    PlayerLeft(Player),
     SetReady(u16, bool),
     SelectMap(u8),
     GameStarted,
-    MapLoaded,
-
-    // Game packages
-    SpawnPlayer(u16, NetPlayerTransform),
-    Sync(HashMap<u16, (NetVector3, NetPlayerTransform)>),
-    SelfSync(NetVector3, NetVector3),
-    Jump(u16),
 }
 
 pub enum PeerKind {

rust/src/net/util.rs

@@ -1,25 +0,0 @@
-use godot::prelude::*;
-use serde::{Deserialize, Serialize};
-
-#[derive(Debug, Clone, Copy, Serialize, Deserialize)]
-pub struct NetVector3 {
-    pub x: f32,
-    pub y: f32,
-    pub z: f32,
-}
-
-impl From<Vector3> for NetVector3 {
-    fn from(value: Vector3) -> Self {
-        NetVector3 {
-            x: value.x,
-            y: value.y,
-            z: value.z,
-        }
-    }
-}
-
-impl From<NetVector3> for Vector3 {
-    fn from(value: NetVector3) -> Self {
-        Vector3::new(value.x, value.y, value.z)
-    }
-}

rust/src/player.rs

@@ -1,275 +0,0 @@
-use std::f32::consts::PI;
-
-use godot::{
-    classes::{
-        Camera3D, CharacterBody3D, ICharacterBody3D, Input, InputEvent, InputEventMouseMotion,
-        input::MouseMode,
-    },
-    obj::WithBaseField,
-    prelude::*,
-};
-use serde::{Deserialize, Serialize};
-
-use crate::{
-    net::{
-        network_manager::{NetworkManager, Package::Jump, PeerKind},
-        util::NetVector3,
-    },
-    ui::cli::CommandLinePanel,
-};
-
-#[derive(Debug, Clone, Copy, Serialize, Deserialize)]
-pub struct NetPlayerTransform {
-    pub location: NetVector3,
-    pub rotation: NetVector3,
-}
-
-pub trait IPlayer {
-    fn get_player_id(&self) -> Option<u16>;
-    fn get_y_speed(&self) -> f32;
-    fn set_y_speed(&mut self, speed: f32);
-    fn get_movement_dir(&self) -> Vector3;
-    fn set_movement_dir(&mut self, dir: Vector3);
-    fn get_move_speed(&self) -> f32;
-    fn apply_transform(&mut self, transform: NetPlayerTransform);
-    fn apply_rotation(&mut self, rot: Vector3);
-    fn get_transform(&self) -> NetPlayerTransform;
-    fn jump(&mut self);
-}
-
-pub trait PlayerMovement {
-    fn player_update(&mut self, delta: f64);
-}
-
-impl<T: IPlayer + ICharacterBody3D + WithBaseField> PlayerMovement for T {
-    fn player_update(&mut self, delta: f64) {
-        self.set_y_speed(self.get_y_speed() - 9.8 * delta as f32);
-        if self.base().is_on_floor() && self.get_y_speed() < 0. {
-            self.set_y_speed(0.);
-        }
-
-        let speed = Vector3::UP * self.get_y_speed()
-            + self
-                .get_movement_dir()
-                .try_normalized()
-                .unwrap_or_default()
-                .rotated(Vector3::UP, self.base().get_rotation().y)
-                * self.get_move_speed();
-
-        self.base_mut().set_velocity(speed);
-        self.base_mut().move_and_slide();
-    }
-}
-
-#[derive(GodotClass)]
-#[class(base=CharacterBody3D, init)]
-pub struct LocalPlayer {
-    #[export]
-    look_sensitivity: f32,
-    #[export]
-    camera: Option<Gd<Camera3D>>,
-    #[export]
-    move_speed: f32,
-
-    pub player_id: Option<u16>,
-
-    movement_dir: Vector3,
-    y_speed: f32,
-
-    locked: bool,
-
-    base: Base<CharacterBody3D>,
-}
-
-#[godot_dyn]
-impl IPlayer for LocalPlayer {
-    fn get_player_id(&self) -> Option<u16> {
-        self.player_id
-    }
-
-    fn get_y_speed(&self) -> f32 {
-        self.y_speed
-    }
-
-    fn set_y_speed(&mut self, speed: f32) {
-        self.y_speed = speed;
-    }
-
-    fn get_movement_dir(&self) -> Vector3 {
-        self.movement_dir
-    }
-
-    fn set_movement_dir(&mut self, _dir: Vector3) {}
-
-    fn get_move_speed(&self) -> f32 {
-        self.move_speed
-    }
-
-    fn apply_transform(&mut self, transform: NetPlayerTransform) {
-        self.base_mut()
-            .set_global_position(transform.location.into());
-        self.base_mut()
-            .set_global_rotation(transform.rotation.into());
-    }
-
-    fn apply_rotation(&mut self, _rot: Vector3) {}
-
-    fn get_transform(&self) -> NetPlayerTransform {
-        NetPlayerTransform {
-            location: self.base().get_global_position().into(),
-            rotation: self.base().get_global_rotation().into(),
-        }
-    }
-
-    fn jump(&mut self) {
-        self.set_y_speed(5.);
-        if let Some(peer) = &mut NetworkManager::singleton().bind_mut().peer {
-            match peer {
-                PeerKind::Client(peer, addr) => peer.send_reliable(&addr, Jump(0)),
-                PeerKind::Server(peer, _) => {
-                    peer.broadcast_reliable(Jump(self.player_id.unwrap_or(0)))
-                }
-            }
-        }
-    }
-}
-
-#[godot_api]
-impl ICharacterBody3D for LocalPlayer {
-    fn ready(&mut self) {
-        if !CommandLinePanel::singleton().bind().opened {
-            self.set_lock(true);
-        }
-
-        CommandLinePanel::singleton()
-            .signals()
-            .on_open()
-            .connect_other(self, |s| s.set_lock(false));
-        CommandLinePanel::singleton()
-            .signals()
-            .on_close()
-            .connect_other(self, |s| {
-                s.set_lock(true);
-            });
-    }
-
-    fn process(&mut self, delta: f64) {
-        let input_direction = if self.locked {
-            let input = Input::singleton();
-
-            if self.base().is_on_floor() && input.is_action_just_pressed("jump") {
-                self.jump();
-            }
-
-            Vector3::RIGHT * input.is_action_pressed("right") as u32 as f32
-                - Vector3::RIGHT * input.is_action_pressed("left") as u32 as f32
-                + Vector3::FORWARD * input.is_action_pressed("forward") as u32 as f32
-                - Vector3::FORWARD * input.is_action_pressed("backward") as u32 as f32
-        } else {
-            Vector3::ZERO
-        };
-        self.movement_dir = input_direction;
-
-        self.player_update(delta);
-    }
-
-    fn input(&mut self, event: Gd<InputEvent>) {
-        if self.locked {
-            if let Ok(event) = event.try_cast::<InputEventMouseMotion>() {
-                let x = event.get_relative().x * 0.001 * self.look_sensitivity;
-                let y = event.get_relative().y * 0.001 * self.look_sensitivity;
-
-                if let Some(camera) = self.camera.as_mut() {
-                    let curr_rotation = camera.get_rotation();
-                    let x_rot =
-                        (curr_rotation.x - y * self.look_sensitivity).clamp(-PI / 2., PI / 2.);
-                    camera.set_rotation(Vector3::RIGHT * x_rot);
-                }
-
-                let y_rot = -x * self.look_sensitivity;
-                self.base_mut().rotate_y(y_rot);
-            }
-        }
-    }
-}
-
-impl LocalPlayer {
-    fn set_lock(&mut self, locked: bool) {
-        self.locked = locked;
-        if self.locked {
-            Input::singleton().set_mouse_mode(MouseMode::CAPTURED);
-        } else {
-            Input::singleton().set_mouse_mode(MouseMode::VISIBLE);
-        }
-    }
-}
-
-#[derive(GodotClass)]
-#[class(base=CharacterBody3D, init)]
-pub struct RemotePlayer {
-    #[export]
-    move_speed: f32,
-
-    pub player_id: Option<u16>,
-
-    movement_dir: Vector3,
-    y_speed: f32,
-
-    base: Base<CharacterBody3D>,
-}
-
-#[godot_dyn]
-impl IPlayer for RemotePlayer {
-    fn get_y_speed(&self) -> f32 {
-        self.y_speed
-    }
-
-    fn set_y_speed(&mut self, speed: f32) {
-        self.y_speed = speed;
-    }
-
-    fn get_movement_dir(&self) -> Vector3 {
-        self.movement_dir
-    }
-
-    fn set_movement_dir(&mut self, dir: Vector3) {
-        self.movement_dir = dir.into();
-    }
-
-    fn get_move_speed(&self) -> f32 {
-        self.move_speed
-    }
-
-    fn get_player_id(&self) -> Option<u16> {
-        self.player_id
-    }
-
-    fn apply_transform(&mut self, transform: NetPlayerTransform) {
-        self.base_mut()
-            .set_global_position(transform.location.into());
-        self.base_mut()
-            .set_global_rotation(transform.rotation.into());
-    }
-
-    fn apply_rotation(&mut self, rot: Vector3) {
-        self.base_mut().set_global_rotation(rot);
-    }
-
-    fn get_transform(&self) -> NetPlayerTransform {
-        NetPlayerTransform {
-            location: self.base().get_global_position().into(),
-            rotation: self.base().get_global_rotation().into(),
-        }
-    }
-
-    fn jump(&mut self) {
-        self.set_y_speed(5.);
-    }
-}
-
-#[godot_api]
-impl ICharacterBody3D for RemotePlayer {
-    fn process(&mut self, delta: f64) {
-        self.player_update(delta);
-    }
-}

rust/src/ui/cli.rs

@@ -109,11 +109,6 @@ impl IPanel for CommandLinePanel {
     fn input(&mut self, event: Gd<InputEvent>) {
         if event.is_action_pressed("toggle_cli") {
             self.opened = !self.opened;
-            if self.opened {
-                self.signals().on_open().emit();
-            } else {
-                self.signals().on_close().emit();
-            }
             if let Some(input_field) = &mut self.input_field {
                 if self.opened {
                     input_field.grab_focus();
@@ -136,10 +131,6 @@ impl CommandLinePanel {
     pub fn on_join(port: String);
     #[signal]
     pub fn on_disconnect();
-    #[signal]
-    pub fn on_open();
-    #[signal]
-    pub fn on_close();
 
     pub fn singleton() -> Gd<CommandLinePanel> {
         get_autoload_by_name::<CanvasLayer>(CLI_GLOBAL_NAME)

rust/src/ui/lobby.rs

@@ -5,7 +5,7 @@ use godot::{
 
 use crate::{
     game_manager::{Game, GameManager},
-    map_resource::MapResource,
+    map_resource::Map,
     net::network_manager::{NetworkManager, Package, PeerKind},
     ui::player_listing::PlayerListing,
 };