Fix issues brought up

ValorZard · ValorZard · commit a6a032373468 · 2025-10-09T14:19:17.000-07:00
diff --git a/net-pong/godot/project.godot b/net-pong/godot/project.godot
@@ -10,9 +10,9 @@ config_version=5
 
 [application]
 
-config/name="Rust Template"
+config/name="Multiplayer Pong"
 run/main_scene="uid://f85s2avde6r4"
-config/features=PackedStringArray("4.4", "GL Compatibility")
+config/features=PackedStringArray("4.5", "GL Compatibility")
 config/icon="uid://dcvpakna8i04d"
 
 [display]
diff --git a/net-pong/godot/rust.gdextension b/net-pong/godot/rust.gdextension
@@ -4,11 +4,11 @@ compatibility_minimum = 4.4
 reloadable = true
 
 [libraries]
-linux.debug.x86_64 =     "res://../rust/target/debug/librust.so"
-linux.release.x86_64 =   "res://../rust/target/release/librust.so"
-windows.debug.x86_64 =   "res://../rust/target/debug/rust.dll"
-windows.release.x86_64 = "res://../rust/target/release/rust.dll"
-macos.debug =            "res://../rust/target/debug/librust.dylib"
-macos.release =          "res://../rust/target/release/librust.dylib"
-macos.debug.arm64 =      "res://../rust/target/debug/librust.dylib"
-macos.release.arm64 =    "res://../rust/target/release/librust.dylib"
+linux.debug.x86_64 =     "res://../../target/debug/libnet_pong.so"
+linux.release.x86_64 =   "res://../../target/release/libnet_pong.so"
+windows.debug.x86_64 =   "res://../../target/debug/net_pong.dll"
+windows.release.x86_64 = "res://../../target/release/net_pong.dll"
+macos.debug =            "res://../../target/debug/libnet_pong.dylib"
+macos.release =          "res://../../target/release/libnet_pong.dylib"
+macos.debug.arm64 =      "res://../../target/debug/libnet_pong.dylib"
+macos.release.arm64 =    "res://../../target/release/libnet_pong.dylib"
diff --git a/net-pong/rust/Cargo.toml b/net-pong/rust/Cargo.toml
@@ -1,13 +1,13 @@
 [package]
-name = "rust"
+name = "net-pong"
 version = "1.0.0"
 edition = "2024"
 rust-version = "1.88"
 license = "MPL-2.0"
 publish = false
 
 [dependencies]
-godot = {git = "https://github.com/godot-rust/gdext.git", rev = "18d8a2200cb0bb85b587336ba853db3bb54c9ffa"}
+godot = {git = "https://github.com/godot-rust/gdext.git"}
 
 [lib]
 crate-type = ["cdylib"] # Compile this crate to a dynamic C library.
diff --git a/net-pong/rust/src/ball.rs b/net-pong/rust/src/ball.rs
@@ -1,5 +1,6 @@
-use godot::classes::Area2D;
 use godot::prelude::*;
+use godot::classes::{Area2D, IArea2D};
+use crate::pong::Pong;
 
 const DEFAULT_SPEED: f64 = 100.0;
 
@@ -12,14 +13,9 @@ pub struct Ball {
     base: Base<Area2D>,
 }
 
-use godot::classes::IArea2D;
-
-use crate::pong::Pong;
-
 #[godot_api]
 impl IArea2D for Ball {
     fn init(base: Base<Area2D>) -> Self {
-        godot_print!("Hello, world!"); // Prints to the Godot console
 
         Self {
             direction: Vector2::LEFT,
@@ -29,8 +25,6 @@ impl IArea2D for Ball {
         }
     }
 
-    fn ready(&mut self) {}
-
     fn process(&mut self, delta: f64) {
         let screen_size = self.base().get_viewport_rect().size;
         self._speed += delta;
diff --git a/net-pong/rust/src/lobby.rs b/net-pong/rust/src/lobby.rs
@@ -1,68 +1,48 @@
-use godot::classes::Button;
-use godot::classes::ENetMultiplayerPeer;
-use godot::classes::Label;
-use godot::classes::LineEdit;
-use godot::classes::LinkButton;
-use godot::classes::Os;
-use godot::classes::Panel;
-use godot::classes::ProjectSettings;
-use godot::classes::enet_connection::CompressionMode;
-use godot::classes::object::ConnectFlags;
-use godot::global::Error;
+use godot::classes::enet_connection::CompressionMode;  
+use godot::classes::object::ConnectFlags;  
+use godot::classes::{  
+    Button, ENetMultiplayerPeer, Label, LineEdit, LinkButton, Os, Panel, ProjectSettings, IPanel 
+};  
+use godot::global::Error;  
 use godot::prelude::*;
 
+use crate::pong::Pong;
+
 const DEFAULT_PORT: i32 = 8910;
 
 #[derive(GodotClass)]
-#[class(base=Panel)]
+#[class(init, base=Panel)]
 pub struct Lobby {
     #[export]
-    address: Option<Gd<LineEdit>>,
+    address: OnEditor<Gd<LineEdit>>,
     #[export]
-    host_button: Option<Gd<Button>>,
+    host_button: OnEditor<Gd<Button>>,
     #[export]
-    join_button: Option<Gd<Button>>,
+    join_button: OnEditor<Gd<Button>>,
     #[export]
-    status_ok: Option<Gd<Label>>,
+    status_ok: OnEditor<Gd<Label>>,
     #[export]
-    status_fail: Option<Gd<Label>>,
+    status_fail: OnEditor<Gd<Label>>,
     #[export]
-    port_forward_label: Option<Gd<Label>>,
+    port_forward_label: OnEditor<Gd<Label>>,
     #[export]
-    find_public_ip_button: Option<Gd<LinkButton>>,
+    find_public_ip_button: OnEditor<Gd<LinkButton>>,
     peer: Option<Gd<ENetMultiplayerPeer>>,
     base: Base<Panel>,
 }
 
-use godot::classes::IPanel;
-
-use crate::pong::Pong;
-
 #[godot_api]
 impl IPanel for Lobby {
-    fn init(base: Base<Panel>) -> Self {
-        Self {
-            address: None,
-            host_button: None,
-            join_button: None,
-            status_ok: None,
-            status_fail: None,
-            port_forward_label: None,
-            find_public_ip_button: None,
-            peer: None,
-            base,
-        }
-    }
 
     fn ready(&mut self) {
         /*
-            # Connect all the callbacks related to networking.
+        # Connect all the callbacks related to networking.
         multiplayer.peer_connected.connect(_player_connected)
         multiplayer.peer_disconnected.connect(_player_disconnected)
         multiplayer.connected_to_server.connect(_connected_ok)
         multiplayer.connection_failed.connect(_connected_fail)
         multiplayer.server_disconnected.connect(_server_disconnected)
-             */
+        */
         let multiplayer = self.base().get_multiplayer().unwrap();
         let gd_ref = self.to_gd();
         multiplayer
@@ -72,17 +52,15 @@ impl IPanel for Lobby {
             .connect_other_gd(&gd_ref, |mut this: Gd<Self>, _id: i64| {
                 godot_print!("Someone connected, start the game!");
                 let pong: Gd<Pong> = load::<PackedScene>("res://pong.tscn")
-                    .instantiate()
-                    .unwrap()
-                    .cast();
+                    .instantiate_as::<Pong>();
                 // Connect deferred so we can safely erase it from the callback.
                 pong.signals()
                     .game_finished()
                     .builder()
                     .flags(ConnectFlags::DEFERRED)
                     .connect_other_gd(&this, |mut this: Gd<Self>| {
                         this.bind_mut()
-                            ._end_game("Client disconnected.".to_string());
+                            .end_game("Client disconnected.".to_string());
                     });
 
                 this.bind_mut()
@@ -92,17 +70,17 @@ impl IPanel for Lobby {
                     .get_root()
                     .unwrap()
                     .add_child(&pong);
-                this.bind_mut().base_mut().hide();
+                this.hide();
             });
         multiplayer
             .signals()
             .peer_disconnected()
             .builder()
             .connect_other_mut(&self.to_gd(), |this: &mut Self, _id: i64| {
                 if this.base().get_multiplayer().unwrap().is_server() {
-                    this._end_game("Client disconnected.".to_string());
+                    this.end_game("Client disconnected.".to_string());
                 } else {
-                    this._end_game("Server disconnected.".to_string());
+                    this.end_game("Server disconnected.".to_string());
                 }
             });
         multiplayer
@@ -117,81 +95,76 @@ impl IPanel for Lobby {
             .connection_failed()
             .builder()
             .connect_other_mut(&self.to_gd(), |this: &mut Self| {
-                this._set_status("Couldn't connect.".to_string(), false);
+                this.set_status("Couldn't connect.", false);
                 let mut multiplayer = this.base().get_multiplayer().unwrap();
                 multiplayer.set_multiplayer_peer(Gd::null_arg()); // Remove peer.
-                this.host_button.as_mut().unwrap().set_disabled(false);
-                this.join_button.as_mut().unwrap().set_disabled(false);
+                this.host_button.set_disabled(false);
+                this.join_button.set_disabled(false);
             });
         multiplayer
             .signals()
             .server_disconnected()
             .builder()
             .connect_other_mut(&self.to_gd(), |this: &mut Self| {
-                this._end_game("Server disconnected.".to_string());
+                this.end_game("Server disconnected.".to_string());
             });
 
-        let gd_ref = self.to_gd();
-
-        // Clone the Gd<Button> references to avoid borrowing self mutably and immutably at the same time
-        let host_button = self.host_button.as_ref().unwrap().clone();
-        host_button
+        self.host_button
             .signals()
             .pressed()
             .builder()
             .connect_other_mut(&gd_ref, |this: &mut Self| {
-                this._on_host_pressed();
+                this.on_host_pressed();
             });
 
-        let join_button = self.join_button.as_ref().unwrap().clone();
-        join_button
+        self.join_button
             .signals()
             .pressed()
             .builder()
             .connect_other_mut(&gd_ref, |this: &mut Self| {
-                this._on_join_pressed();
+                this.on_join_pressed();
             });
     }
 }
 
 #[godot_api]
 impl Lobby {
-    fn _set_status(&mut self, text: String, is_ok: bool) {
+    fn set_status(&mut self, text: &str, is_ok: bool) {
         // Simple way to show status.
         if is_ok {
-            self.status_ok.as_mut().unwrap().set_text(&text);
-            self.status_fail.as_mut().unwrap().set_text("");
+            self.status_ok.set_text(text);
+            self.status_fail.set_text("");
         } else {
-            self.status_ok.as_mut().unwrap().set_text("");
-            self.status_fail.as_mut().unwrap().set_text(&text);
+            self.status_ok.set_text("");
+            self.status_fail.set_text(text);
         }
     }
 
     #[func]
-    fn _end_game(&mut self, with_error: String) {
+    fn end_game(&mut self, with_error: String) {
         if self.base().has_node("/root/Pong") {
             // Erase immediately, otherwise network might show
             // errors (this is why we connected deferred above).
             self.base().get_node_as::<Node>("/root/Pong").free();
             self.base_mut().show();
         }
-
+    
         let mut multiplayer = self.base().get_multiplayer().unwrap();
         multiplayer.set_multiplayer_peer(Gd::null_arg()); // Remove peer.
-        self.host_button.as_mut().unwrap().set_disabled(false);
-        self.join_button.as_mut().unwrap().set_disabled(false);
+        self.host_button.set_disabled(false);
+        self.join_button.set_disabled(false);
 
-        self._set_status(with_error, false);
+        self.set_status(&with_error, false);
     }
 
-    fn _on_host_pressed(&mut self) {
+    fn on_host_pressed(&mut self) {
         let mut peer = ENetMultiplayerPeer::new_gd();
         self.peer = Some(peer.clone());
         // Set a maximum of 1 peer, since Pong is a 2-player game.
         let err = peer.create_server_ex(DEFAULT_PORT).max_clients(1).done();
         if err != Error::OK {
             // Is another server running?
-            self._set_status("Can't host, address in use.".to_string(), false);
+            self.set_status("Can't host, address in use.", false);
             return;
         }
         peer.get_host()
@@ -200,30 +173,25 @@ impl Lobby {
 
         let mut multiplayer = self.base().get_multiplayer().unwrap();
         multiplayer.set_multiplayer_peer(&peer);
-        self.host_button.as_mut().unwrap().set_disabled(true);
-        self.join_button.as_mut().unwrap().set_disabled(true);
-        self._set_status("Waiting for player...".to_string(), true);
-        let project_settings = ProjectSettings::singleton();
-        self.base_mut().get_window().unwrap().set_title(
-            (project_settings
-                .get_setting("application/config/name")
-                .to_string()
-                + ": Server")
-                .as_str(),
-        );
-
+        self.host_button.set_disabled(true);
+        self.join_button.set_disabled(true);
+        self.set_status("Waiting for player...", true);
+        let application_name = ProjectSettings::singleton()  
+            .get_setting("application/config/name")  
+            .to_string();  
+        self.base_mut()  
+            .get_window()  
+            .unwrap()  
+            .set_title(&format!("{application_name}: Server"));  
         // Only show hosting instructions when relevant.
-        self.port_forward_label.as_mut().unwrap().set_visible(true);
-        self.find_public_ip_button
-            .as_mut()
-            .unwrap()
-            .set_visible(true);
+        self.port_forward_label.set_visible(true);
+        self.find_public_ip_button.set_visible(true);
     }
 
-    fn _on_join_pressed(&mut self) {
-        let ip = self.address.as_mut().unwrap().get_text();
+    fn on_join_pressed(&mut self) {
+        let ip = self.address.get_text();
         if !ip.is_valid_ip_address() {
-            self._set_status("IP address is invalid.".to_string(), false);
+            self.set_status("IP address is invalid.", false);
             return;
         }
 
@@ -236,15 +204,14 @@ impl Lobby {
         let mut multiplayer = self.base().get_multiplayer().unwrap();
         multiplayer.set_multiplayer_peer(&peer);
 
-        self._set_status("Connecting...".to_string(), true);
-        let project_settings = ProjectSettings::singleton();
-        self.base_mut().get_window().unwrap().set_title(
-            (project_settings
-                .get_setting("application/config/name")
-                .to_string()
-                + ": Client")
-                .as_str(),
-        );
+        self.set_status("Connecting...", true);
+        let application_name = ProjectSettings::singleton()  
+            .get_setting("application/config/name")  
+            .to_string();  
+        self.base_mut()  
+            .get_window()  
+            .unwrap()  
+            .set_title(&format!("{application_name}: Client")); 
     }
 
     fn _on_find_public_ip_pressed(&mut self) {
diff --git a/net-pong/rust/src/paddle.rs b/net-pong/rust/src/paddle.rs
diff --git a/net-pong/rust/src/pong.rs b/net-pong/rust/src/pong.rs
