Merge branch 'godot-rust:master' into update-macos-image-runner

Author: Yarwin

.github/workflows/ci.yml

@@ -114,7 +114,7 @@ jobs:
 
           - name: linux
             os: ubuntu-22.04
-            rust-toolchain: "1.85"
+            rust-toolchain: "1.87"
             rust-special: -msrv
 
     steps:

dodge-the-creeps/godot/Main.tscn

@@ -48,6 +48,4 @@ stream = ExtResource("5")
 [node name="DeathSound" type="AudioStreamPlayer" parent="."]
 stream = ExtResource("6")
 
-[connection signal="timeout" from="MobTimer" to="." method="on_mob_timer_timeout"]
-[connection signal="timeout" from="ScoreTimer" to="." method="on_score_timer_timeout"]
 [connection signal="timeout" from="StartTimer" to="." method="on_start_timer_timeout"]

dodge-the-creeps/rust/src/main_scene.rs

@@ -1,6 +1,6 @@
 use crate::{hud, mob, player};
 
-use godot::classes::{Marker2D, PathFollow2D, RigidBody2D, Timer};
+use godot::classes::{AudioStreamPlayer, Marker2D, PathFollow2D, RigidBody2D, Timer};
 use godot::prelude::*;
 
 use rand::Rng as _;
@@ -46,25 +46,42 @@ impl INode for Main {
         self.player
             .signals()
             .hit()
-            .connect_obj(&main, Self::game_over);
+            .connect_other(&main, Self::game_over);
 
         // Connect Hud::start_game -> Main::new_game.
         self.hud
             .signals()
             .start_game()
-            .connect_obj(&main, Self::new_game);
+            .connect_other(&main, Self::new_game);
+
+        // Connect Main.ScoreTimer::timeout -> Main::on_score_timer_timeout.
+        self.score_timer()
+            .signals()
+            .timeout()
+            .connect_other(&main, Self::on_score_timer_timeout);
+
+        // Connect Main.MobTimer::timeout -> Main::on_mob_timer_timeout.
+        self.mob_timer()
+            .signals()
+            .timeout()
+            .connect_other(&main, Self::on_mob_timer_timeout);
+
+        // Main.StartTimer::timeout -> Main::on_start_timer_timeout is set up in the Editor's Inspector UI, but could be done here as well,
+        // as follows. Note that signal handlers connected via Rust do not need a #[func] annotation, they can remain entirely visible to Godot.
+        //
+        // self.start_timer()
+        //     .signals()
+        //     .timeout()
+        //     .connect_other(&main, Self::on_start_timer_timeout);
     }
 }
 
 #[godot_api]
 impl Main {
     // No #[func] here, this method is directly called from Rust (via type-safe signals).
     fn game_over(&mut self) {
-        let mut score_timer = self.base().get_node_as::<Timer>("ScoreTimer");
-        let mut mob_timer = self.base().get_node_as::<Timer>("MobTimer");
-
-        score_timer.stop();
-        mob_timer.stop();
+        self.score_timer().stop();
+        self.mob_timer().stop();
 
         self.hud.bind_mut().show_game_over();
 
@@ -75,12 +92,11 @@ impl Main {
     // No #[func].
     pub fn new_game(&mut self) {
         let start_position = self.base().get_node_as::<Marker2D>("StartPosition");
-        let mut start_timer = self.base().get_node_as::<Timer>("StartTimer");
 
         self.score = 0;
 
         self.player.bind_mut().start(start_position.get_position());
-        start_timer.start();
+        self.start_timer().start();
 
         let hud = self.hud.bind_mut();
         hud.update_score(self.score);
@@ -89,22 +105,20 @@ impl Main {
         self.music.play();
     }
 
-    #[func]
-    fn on_start_timer_timeout(&self) {
-        let mut mob_timer = self.base().get_node_as::<Timer>("MobTimer");
-        let mut score_timer = self.base().get_node_as::<Timer>("ScoreTimer");
-        mob_timer.start();
-        score_timer.start();
+    #[func] // needed because connected in Editor UI (see ready).
+    fn on_start_timer_timeout(&mut self) {
+        self.mob_timer().start();
+        self.score_timer().start();
     }
 
-    #[func]
+    // No #[func], connected in pure Rust.
     fn on_score_timer_timeout(&mut self) {
         self.score += 1;
 
         self.hud.bind_mut().update_score(self.score);
     }
 
-    #[func]
+    // No #[func], connected in pure Rust.
     fn on_mob_timer_timeout(&mut self) {
         let mut mob_spawn_location = self
             .base()
@@ -134,4 +148,17 @@ impl Main {
 
         mob.set_linear_velocity(Vector2::new(range, 0.0).rotated(real::from_f32(direction)));
     }
+
+    // These timers could also be stored as OnReady fields, but are now fetched via function for demonstration purposes.
+    fn start_timer(&self) -> Gd<Timer> {
+        self.base().get_node_as::<Timer>("StartTimer")
+    }
+
+    fn score_timer(&self) -> Gd<Timer> {
+        self.base().get_node_as::<Timer>("ScoreTimer")
+    }
+
+    fn mob_timer(&self) -> Gd<Timer> {
+        self.base().get_node_as::<Timer>("MobTimer")
+    }
 }

dodge-the-creeps/rust/src/player.rs

@@ -1,4 +1,4 @@
-use godot::classes::{AnimatedSprite2D, Area2D, CollisionShape2D, IArea2D, PhysicsBody2D};
+use godot::classes::{AnimatedSprite2D, Area2D, CollisionShape2D, IArea2D, Input};
 use godot::prelude::*;
 
 #[derive(GodotClass)]
@@ -17,7 +17,7 @@ impl Player {
     pub fn hit();
 
     #[func]
-    fn on_player_body_entered(&mut self, _body: Gd<PhysicsBody2D>) {
+    fn on_player_body_entered(&mut self, _body: Gd<Node2D>) {
         self.base_mut().hide();
         self.signals().hit().emit();
 
@@ -55,9 +55,15 @@ impl IArea2D for Player {
         let viewport = self.base().get_viewport_rect();
         self.screen_size = viewport.size;
         self.base_mut().hide();
+
+        // Signal setup
+        self.signals()
+            .body_entered()
+            .connect_self(Self::on_player_body_entered);
     }
 
-    fn process(&mut self, delta: f64) {
+    // `delta` can be f32 or f64; #[godot_api] macro converts transparently.
+    fn process(&mut self, delta: f32) {
         let mut animated_sprite = self
             .base()
             .get_node_as::<AnimatedSprite2D>("AnimatedSprite2D");
@@ -100,7 +106,7 @@ impl IArea2D for Player {
             animated_sprite.stop();
         }
 
-        let change = velocity * real::from_f64(delta);
+        let change = velocity * delta;
         let position = self.base().get_global_position() + change;
         let position = Vector2::new(
             position.x.clamp(0.0, self.screen_size.x),

hot-reload/rust/src/lib.rs

@@ -11,41 +11,31 @@ struct HotReload;
 
 #[gdextension]
 unsafe impl ExtensionLibrary for HotReload {
-    fn on_level_init(_level: InitLevel) {
-        println!("[Rust]      Init level {:?}", _level);
+    fn on_level_init(level: InitLevel) {
+        println!("[Rust]   Init level {level:?}");
     }
 
-    fn on_level_deinit(_level: InitLevel) {
-        println!("[Rust]      Deinit level {:?}", _level);
+    fn on_level_deinit(level: InitLevel) {
+        println!("[Rust]   Deinit level {level:?}");
     }
 }
 
 // ----------------------------------------------------------------------------------------------------------------------------------------------
 
 /// A RustDoc comment appearing under the editor help docs.
 #[derive(GodotClass)]
-#[class(base=Node)]
+#[class(init, base=Node)]
 struct Reloadable {
     /// A planet!
     #[export]
+    #[init(val = Planet::Earth)]
     favorite_planet: Planet,
     //
     // HOT-RELOAD: uncomment this to add a new exported field (also update init() below).
     // #[export]
     // some_string: GString,
 }
 
-#[godot_api]
-impl INode for Reloadable {
-    fn init(_base: Base<Self::Base>) -> Self {
-        // HOT-RELOAD: change values to initialize with different defaults.
-        Self {
-            favorite_planet: Planet::Earth,
-            //some_string: "Hello, world!".into(),
-        }
-    }
-}
-
 #[godot_api]
 impl Reloadable {
     /// A function to return a number.
@@ -55,19 +45,18 @@ impl Reloadable {
         100
     }
 
-    /// Constructor from a string.
+    // HOT-RELOAD: uncomment to make new function accessible.
+
     #[func]
-    fn from_string(s: GString) -> Gd<Self> {
-        Gd::from_object(Reloadable {
-            favorite_planet: Planet::from_godot(s),
-        })
+    fn get_planet(&self) -> Planet {
+        self.favorite_planet
     }
 }
 
 // ----------------------------------------------------------------------------------------------------------------------------------------------
 
 /// A planet enum.
-#[derive(GodotConvert, Var, Export)]
+#[derive(GodotConvert, Var, Export, Copy, Clone, Debug)]
 #[godot(via = GString)]
 enum Planet {
     Earth,