- Update example to keep it in line with the latest gdext changes

- Move all constants to their own file
- Add copyright information
- Fix paths for compiled libraries

Author: Yarwin

examples/multiplayer-bomber/godot/rust.gdextension

@@ -3,13 +3,13 @@ entry_symbol = "gdext_rust_init"
 compatibility_minimum = 4.1
 
 [libraries]
-linux.debug.x86_64 = "res://../../../target/debug/multiplayer_bomber.so"
-linux.release.x86_64 = "res://../../../target/release/multiplayer_bomber.so"
+linux.debug.x86_64 = "res://../../../target/debug/libmultiplayer_bomber.so"
+linux.release.x86_64 = "res://../../../target/release/libmultiplayer_bomber.so"
 windows.debug.x86_64 = "res://../../../target/debug/multiplayer_bomber.dll"
 windows.release.x86_64 = "res://../../../target/release/multiplayer_bomber.dll"
-macos.debug = "res://../../../target/debug/multiplayer_bomber.dylib"
-macos.release = "res://../../../target/release/multiplayer_bomber.dylib"
-macos.debug.arm64 = "res://../../../target/debug/multiplayer_bomber.dylib"
-macos.release.arm64 = "res://../../../target/release/multiplayer_bomber.dylib"
+macos.debug = "res://../../../target/debug/libmultiplayer_bomber.dylib"
+macos.release = "res://../../../target/release/libmultiplayer_bomber.dylib"
+macos.debug.arm64 = "res://../../../target/debug/libmultiplayer_bomber.dylib"
+macos.release.arm64 = "res://../../../target/release/libmultiplayer_bomber.dylib"
 web.debug.wasm32 = "res://../../../target/wasm32-unknown-emscripten/debug/multiplayer_bomber.wasm"
 web.release.wasm32 = "res://../../../target/wasm32-unknown-emscripten/release/multiplayer_bomber.wasm"

examples/multiplayer-bomber/rust/src/bomb.rs

@@ -1,3 +1,10 @@
+/*
+ * Copyright (c) godot-rust; Bromeon and contributors.
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/.
+ */
+
 use godot::classes::{Area2D, PhysicsRayQueryParameters2D, TileMap};
 use godot::prelude::*;
 
@@ -26,7 +33,7 @@ impl Bomb {
             panic!("couldn't access World2D from Bomb!")
         };
         for mut collider in self.base().get_overlapping_bodies().iter_shared() {
-            if !collider.has_method("exploded".into()) {
+            if !collider.has_method("exploded") {
                 continue;
             }
             // check if there is any solid wall between bomb and the object
@@ -37,7 +44,7 @@ impl Bomb {
                 panic!("couldn't create PhysicsRayQueryParameters!")
             };
             query.set_hit_from_inside(true);
-            let result = space_state.intersect_ray(query);
+            let result = space_state.intersect_ray(&query);
             let is_wall_between = result
                 .get("collider")
                 .map(|c| c.try_to::<Gd<TileMap>>().is_ok())
@@ -46,7 +53,7 @@ impl Bomb {
                 continue;
             }
 
-            collider.rpc("exploded".into(), &[self.from_player.to_variant()]);
+            collider.rpc("exploded", &[self.from_player.to_variant()]);
         }
     }
 

examples/multiplayer-bomber/rust/src/bomb_spawner.rs

@@ -1,4 +1,12 @@
+/*
+ * Copyright (c) godot-rust; Bromeon and contributors.
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/.
+ */
+
 use crate::bomb::Bomb;
+use crate::constants::SIGNAL_SPAWN_BOMB;
 use crate::game_state::{GameSingleton, GameState};
 use godot::classes::{IMultiplayerSpawner, MultiplayerSpawner};
 use godot::prelude::*;
@@ -40,7 +48,10 @@ impl FromGodot for BombArgs {
 }
 
 impl ToGodot for BombArgs {
-    type ToVia<'v> = VariantArray where Self: 'v;
+    type ToVia<'v>
+        = VariantArray
+    where
+        Self: 'v;
 
     fn to_godot(&self) -> Self::ToVia<'_> {
         varray![self.position.to_variant(), self.player_id.to_variant()]
@@ -59,9 +70,9 @@ pub struct BombSpawner {
 impl IMultiplayerSpawner for BombSpawner {
     fn ready(&mut self) {
         let spawn_bomb = self.base().callable("spawn_bomb");
-        self.base_mut().set_spawn_function(spawn_bomb);
+        self.base_mut().set_spawn_function(&spawn_bomb);
         let spawn = self.base().callable("spawn");
-        GameState::singleton().connect("spawn_bomb".into(), spawn);
+        GameState::singleton().connect(SIGNAL_SPAWN_BOMB, &spawn);
     }
 }
 

examples/multiplayer-bomber/rust/src/constants.rs

@@ -0,0 +1,38 @@
+/*
+ * Copyright (c) godot-rust; Bromeon and contributors.
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/.
+ */
+
+pub const FLAG_CONNECT_DEFERRED: u32 = 1;
+
+pub const SIGNAL_CHILD_EXITING_TREE: &str = "child_exiting_tree";
+pub const SIGNAL_SCORE_INCREASED: &str = "score_increased";
+pub const SIGNAL_CONNECTION_SUCCEEDED: &str = "connection_succeeded";
+pub const SIGNAL_CONNECTION_FAILED: &str = "connection_failed";
+pub const SIGNAL_PLAYER_LIST_CHANGED: &str = "player_list_changed";
+pub const SIGNAL_GAME_ENDED: &str = "game_ended";
+pub const SIGNAL_GAME_ERROR: &str = "game_error";
+pub const SIGNAL_GAME_STARTED: &str = "game_started";
+pub const SIGNAL_PEER_CONNECTED: &str = "peer_connected";
+pub const SIGNAL_PEER_DISCONNECTED: &str = "peer_disconnected";
+pub const SIGNAL_CONNECTED_TO_SERVER: &str = "connected_to_server";
+pub const SIGNAL_SERVER_DISCONNECTED: &str = "server_disconnected";
+
+pub const SIGNAL_SPAWN_BOMB: &str = "spawn_bomb";
+
+pub const ANIMATION_EXPLODE: &str = "explode";
+pub const ANIMATION_STUNNED: &str = "stunned";
+
+pub const ANIMATION_WALK_DOWN: &str = "walk_down";
+pub const ANIMATION_WALK_UP: &str = "walk_up";
+pub const ANIMATION_WALK_RIGHT: &str = "walk_right";
+pub const ANIMATION_WALK_LEFT: &str = "walk_left";
+pub const ANIMATION_STANDING: &str = "standing";
+
+pub const ACTION_MOVE_LEFT: &str = "move_left";
+pub const ACTION_MOVE_RIGHT: &str = "move_right";
+pub const ACTION_MOVE_UP: &str = "move_up";
+pub const ACTION_MOVE_DOWN: &str = "move_down";
+pub const ACTION_SET_BOMB: &str = "set_bomb";

examples/multiplayer-bomber/rust/src/game_state.rs

@@ -1,16 +1,28 @@
+/*
+ * Copyright (c) godot-rust; Bromeon and contributors.
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/.
+ */
+
 use crate::bomb_spawner::BombArgs;
+use crate::constants::{
+    SIGNAL_CONNECTED_TO_SERVER, SIGNAL_CONNECTION_FAILED, SIGNAL_CONNECTION_SUCCEEDED,
+    SIGNAL_GAME_ENDED, SIGNAL_GAME_ERROR, SIGNAL_GAME_STARTED, SIGNAL_PEER_CONNECTED,
+    SIGNAL_PEER_DISCONNECTED, SIGNAL_PLAYER_LIST_CHANGED, SIGNAL_SERVER_DISCONNECTED,
+};
 use crate::player::Player;
 use crate::world::World;
 use godot::classes::{ENetMultiplayerPeer, Engine, Marker2D, MultiplayerApi};
 use godot::obj::{bounds, Bounds};
 use godot::prelude::*;
 use std::collections::HashMap;
 
-/// In our example the GameState is being registered both as an Autoload and Engine Singleton
-/// Autoloads and Engine Singletons works similar to each other.
+/// In our example the GameState is being registered both as an [Autoload](https://docs.godotengine.org/en/stable/tutorials/scripting/singletons_autoload.html) and Engine Singleton
+/// Autoloads and Engine Singletons works similarly to each other.
 /// Engine singleton is anything that inherits an object and is accessible anywhere inside godot's runtime via Engine::singleton().get_singleton(…)
-/// Autoload is anything that lives in scene tree and is registered as Variant via ScriptServer
-/// In real-world usage you might want to declare your singleton as an Object and register it inside your MainLoop
+/// Autoload is anything that lives in a scene tree and is registered as a Variant via ScriptServer
+/// In real-world usage you might want to declare your singleton as an Object and register it in your [MainLoop](https://docs.godotengine.org/en/stable/classes/class_mainloop.html) or [during initialization of your gdext library](https://godot-rust.github.io/book/recipes/engine-singleton.html).
 #[derive(GodotClass)]
 #[class(init, base=Node)]
 pub struct GameState {
@@ -47,23 +59,23 @@ impl INode for GameState {
 
         let player_connected = self.base().callable("player_connected");
         self.multiplayer
-            .connect("peer_connected".into(), player_connected);
+            .connect(SIGNAL_PEER_CONNECTED, &player_connected);
 
         let player_disconnected = self.base().callable("player_disconnected");
         self.multiplayer
-            .connect("peer_disconnected".into(), player_disconnected);
+            .connect(SIGNAL_PEER_DISCONNECTED, &player_disconnected);
 
         let connected_ok = self.base().callable("connected_ok");
         self.multiplayer
-            .connect("connected_to_server".into(), connected_ok);
+            .connect(SIGNAL_CONNECTED_TO_SERVER, &connected_ok);
 
         let connected_fail = self.base().callable("connected_fail");
         self.multiplayer
-            .connect("connection_failed".into(), connected_fail);
+            .connect(SIGNAL_CONNECTION_FAILED, &connected_fail);
 
         let server_disconnected = self.base().callable("server_disconnected");
         self.multiplayer
-            .connect("server_disconnected".into(), server_disconnected);
+            .connect(SIGNAL_SERVER_DISCONNECTED, &server_disconnected);
     }
 }
 
@@ -106,19 +118,16 @@ impl GameState {
     #[func]
     fn player_connected(&mut self, player_id: i32) {
         let player_name_arg = self.player_name.clone().to_variant();
-        self.base_mut().rpc_id(
-            player_id as i64,
-            "register_player".into(),
-            &[player_name_arg],
-        );
+        self.base_mut()
+            .rpc_id(player_id as i64, "register_player", &[player_name_arg]);
     }
 
     #[func]
     fn player_disconnected(&mut self, player_id: i32) {
         if self.game_board.is_some() && self.multiplayer.is_server() {
             let message = GString::from(format!("Player {player_id} Disconnected"));
             self.base_mut()
-                .emit_signal("game_error".into(), &[message.to_variant()]);
+                .emit_signal(SIGNAL_GAME_ERROR, &[message.to_variant()]);
             self.end_game();
             return;
         }
@@ -128,28 +137,26 @@ impl GameState {
     #[func]
     fn connected_ok(&mut self) {
         self.base_mut()
-            .emit_signal("connection_succeeded".into(), &[]);
+            .emit_signal(SIGNAL_CONNECTION_SUCCEEDED, &[]);
     }
 
     #[func]
     fn server_disconnected(&mut self) {
         self.base_mut()
-            .emit_signal("game_error".into(), &["server disconnected".to_variant()]);
+            .emit_signal(SIGNAL_GAME_ERROR, &["server disconnected".to_variant()]);
     }
 
     #[rpc(any_peer)]
     fn register_player(&mut self, new_player_name: GString) {
         let id = self.multiplayer.get_remote_sender_id();
         self.players.entry(id).or_insert(new_player_name);
-        self.base_mut()
-            .emit_signal("player_list_changed".into(), &[]);
+        self.base_mut().emit_signal(SIGNAL_PLAYER_LIST_CHANGED, &[]);
     }
 
     #[func]
     fn unregister_player(&mut self, player_id: i32) {
         self.players.remove(&player_id);
-        self.base_mut()
-            .emit_signal("player_list_changed".into(), &[]);
+        self.base_mut().emit_signal(SIGNAL_PLAYER_LIST_CHANGED, &[]);
     }
 
     #[func]
@@ -170,7 +177,7 @@ impl GameState {
     pub fn join_game(&mut self, address: GString, new_player_name: GString) {
         self.player_name = new_player_name;
         let mut peer = ENetMultiplayerPeer::new_gd();
-        peer.create_client(address, Self::DEFAULT_PORT);
+        peer.create_client(&address, Self::DEFAULT_PORT);
         self.multiplayer.set_multiplayer_peer(&peer);
         self.peer = Some(peer);
         self.players
@@ -183,7 +190,7 @@ impl GameState {
         if !self.multiplayer.is_server() {
             panic!("Only server can start a game!")
         }
-        self.base_mut().rpc("load_world".into(), &[]);
+        self.base_mut().rpc("load_world", &[]);
         let Some(world) = self.game_board.as_mut() else {
             panic!("no game board!")
         };
@@ -203,11 +210,11 @@ impl GameState {
             };
             player.bind_mut().synced_position = spawn_marker.get_position();
             player.bind_mut().player_id = *player_id;
-            player.set_name(GString::from(player_id.to_string()));
+            player.set_name(&player_id.to_string());
             world.bind_mut().players.add_child(&player);
-            player.bind_mut().label.set_text(player_name.clone());
+            player.bind_mut().label.set_text(player_name);
         }
-        self.base_mut().emit_signal("game_started".into(), &[]);
+        self.base_mut().emit_signal(SIGNAL_GAME_STARTED, &[]);
     }
 
     #[rpc(call_local)]
@@ -242,7 +249,7 @@ impl GameState {
         if let Some(mut game_board) = self.game_board.take() {
             game_board.queue_free();
         }
-        self.base_mut().emit_signal("game_ended".into(), &[]);
+        self.base_mut().emit_signal(SIGNAL_GAME_ENDED, &[]);
         self.players.clear();
         if let Some(peer) = self.peer.as_mut() {
             peer.close();
@@ -274,23 +281,19 @@ pub trait GameSingleton:
 
     fn singleton() -> Gd<Self> {
         Engine::singleton()
-            .get_singleton(Self::singleton_name())
+            .get_singleton(Self::NAME)
             .unwrap()
             .cast::<Self>()
     }
 
-    fn singleton_name() -> StringName {
-        StringName::from(Self::NAME)
-    }
-
     fn register(game_system: Gd<Object>) {
         // in real world usage you might want to use this method to create your autoload.
         // In such case add trait bound 'NewAlloc'
         // and create your game system with `let game_system = Self::new_alloc();`
-        Engine::singleton().register_singleton(Self::singleton_name(), game_system);
+        Engine::singleton().register_singleton(Self::NAME, &game_system);
     }
 
     fn exit(&mut self) {
-        Engine::singleton().unregister_singleton(Self::singleton_name());
+        Engine::singleton().unregister_singleton(Self::NAME);
     }
 }

examples/multiplayer-bomber/rust/src/inputs.rs

@@ -1,3 +1,13 @@
+/*
+ * Copyright (c) godot-rust; Bromeon and contributors.
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/.
+ */
+
+use crate::constants::{
+    ACTION_MOVE_DOWN, ACTION_MOVE_LEFT, ACTION_MOVE_RIGHT, ACTION_MOVE_UP, ACTION_SET_BOMB,
+};
 use godot::prelude::*;
 
 #[derive(GodotClass)]
@@ -12,11 +22,11 @@ pub struct PlayerInputs {
 impl PlayerInputs {
     pub fn update(&mut self) {
         self.motion = Input::singleton().get_vector(
-            "move_left".into(),
-            "move_right".into(),
-            "move_up".into(),
-            "move_down".into(),
+            ACTION_MOVE_LEFT,
+            ACTION_MOVE_RIGHT,
+            ACTION_MOVE_UP,
+            ACTION_MOVE_DOWN,
         );
-        self.bombing = Input::singleton().is_action_pressed("set_bomb".into());
+        self.bombing = Input::singleton().is_action_pressed(ACTION_SET_BOMB);
     }
 }

examples/multiplayer-bomber/rust/src/lib.rs

@@ -1,5 +1,13 @@
+/*
+ * Copyright (c) godot-rust; Bromeon and contributors.
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/.
+ */
+
 mod bomb;
 mod bomb_spawner;
+mod constants;
 mod game_state;
 mod inputs;
 mod lobby;