From 51dddf3abfacee90b86584a4d5ca14b066f4c0ce Mon Sep 17 00:00:00 2001
From: Ivan-267 <61947090+Ivan-267@users.noreply.github.com>
Date: Sat, 7 Dec 2024 15:52:47 +0100
Subject: [PATCH 1/5] Adds Platform2D
---
examples/Platform2D/.gitattributes | 2 +
examples/Platform2D/.gitignore | 3 +
examples/Platform2D/Platform2D.csproj | 11 +
examples/Platform2D/Platform2D.sln | 19 +
.../controller/ai_controller_2d.gd | 136 ++++
.../controller/ai_controller_3d.gd | 136 ++++
.../addons/godot_rl_agents/godot_rl_agents.gd | 16 +
.../addons/godot_rl_agents/icon.png | Bin 0 -> 198 bytes
.../onnx/csharp/ONNXInference.cs | 109 ++++
.../onnx/csharp/SessionConfigurator.cs | 131 ++++
.../onnx/csharp/docs/ONNXInference.xml | 31 +
.../onnx/csharp/docs/SessionConfigurator.xml | 29 +
.../onnx/wrapper/ONNX_wrapper.gd | 51 ++
.../addons/godot_rl_agents/plugin.cfg | 7 +
.../sensors_2d/ExampleRaycastSensor2D.tscn | 48 ++
.../sensors/sensors_2d/GridSensor2D.gd | 235 +++++++
.../sensors/sensors_2d/ISensor2D.gd | 25 +
.../sensors/sensors_2d/RaycastSensor2D.gd | 118 ++++
.../sensors/sensors_2d/RaycastSensor2D.tscn | 7 +
.../sensors_3d/ExampleRaycastSensor3D.tscn | 6 +
.../sensors/sensors_3d/GridSensor3D.gd | 258 ++++++++
.../sensors/sensors_3d/ISensor3D.gd | 25 +
.../sensors/sensors_3d/RGBCameraSensor3D.gd | 63 ++
.../sensors/sensors_3d/RGBCameraSensor3D.tscn | 35 +
.../sensors/sensors_3d/RaycastSensor3D.gd | 185 ++++++
.../sensors/sensors_3d/RaycastSensor3D.tscn | 27 +
.../Platform2D/addons/godot_rl_agents/sync.gd | 598 ++++++++++++++++++
.../assets/player/jump/Player1Jump1.png | Bin 0 -> 3474 bytes
.../assets/player/jump/Player1Jump2.png | Bin 0 -> 3232 bytes
.../assets/player/jump/Player1Jump3.png | Bin 0 -> 3811 bytes
.../assets/player/move/Player-1.png | Bin 0 -> 3729 bytes
.../assets/player/move/Player-2.png | Bin 0 -> 3727 bytes
.../assets/player/move/Player-3.png | Bin 0 -> 3763 bytes
examples/Platform2D/assets/tilesheet.png | Bin 0 -> 35040 bytes
examples/Platform2D/icon.svg | 1 +
examples/Platform2D/license.md | 5 +
examples/Platform2D/model.onnx | Bin 0 -> 42972 bytes
examples/Platform2D/project.godot | 54 ++
examples/Platform2D/readme.md | 22 +
.../scenes/game_scene/game_scene.tscn | 21 +
.../scenes/player/extended_grid_sensor_2d.gd | 42 ++
examples/Platform2D/scenes/player/player.gd | 90 +++
examples/Platform2D/scenes/player/player.tscn | 126 ++++
.../scenes/player/player_ai_controller.gd | 82 +++
.../scenes/tilemap/tile_map_layer.gd | 145 +++++
.../Platform2D/scenes/tileset/tileset.tres | 31 +
.../training_scene/inference_scene.tscn | 14 +
.../scenes/training_scene/training_scene.tscn | 34 +
48 files changed, 2978 insertions(+)
create mode 100644 examples/Platform2D/.gitattributes
create mode 100644 examples/Platform2D/.gitignore
create mode 100644 examples/Platform2D/Platform2D.csproj
create mode 100644 examples/Platform2D/Platform2D.sln
create mode 100644 examples/Platform2D/addons/godot_rl_agents/controller/ai_controller_2d.gd
create mode 100644 examples/Platform2D/addons/godot_rl_agents/controller/ai_controller_3d.gd
create mode 100644 examples/Platform2D/addons/godot_rl_agents/godot_rl_agents.gd
create mode 100644 examples/Platform2D/addons/godot_rl_agents/icon.png
create mode 100644 examples/Platform2D/addons/godot_rl_agents/onnx/csharp/ONNXInference.cs
create mode 100644 examples/Platform2D/addons/godot_rl_agents/onnx/csharp/SessionConfigurator.cs
create mode 100644 examples/Platform2D/addons/godot_rl_agents/onnx/csharp/docs/ONNXInference.xml
create mode 100644 examples/Platform2D/addons/godot_rl_agents/onnx/csharp/docs/SessionConfigurator.xml
create mode 100644 examples/Platform2D/addons/godot_rl_agents/onnx/wrapper/ONNX_wrapper.gd
create mode 100644 examples/Platform2D/addons/godot_rl_agents/plugin.cfg
create mode 100644 examples/Platform2D/addons/godot_rl_agents/sensors/sensors_2d/ExampleRaycastSensor2D.tscn
create mode 100644 examples/Platform2D/addons/godot_rl_agents/sensors/sensors_2d/GridSensor2D.gd
create mode 100644 examples/Platform2D/addons/godot_rl_agents/sensors/sensors_2d/ISensor2D.gd
create mode 100644 examples/Platform2D/addons/godot_rl_agents/sensors/sensors_2d/RaycastSensor2D.gd
create mode 100644 examples/Platform2D/addons/godot_rl_agents/sensors/sensors_2d/RaycastSensor2D.tscn
create mode 100644 examples/Platform2D/addons/godot_rl_agents/sensors/sensors_3d/ExampleRaycastSensor3D.tscn
create mode 100644 examples/Platform2D/addons/godot_rl_agents/sensors/sensors_3d/GridSensor3D.gd
create mode 100644 examples/Platform2D/addons/godot_rl_agents/sensors/sensors_3d/ISensor3D.gd
create mode 100644 examples/Platform2D/addons/godot_rl_agents/sensors/sensors_3d/RGBCameraSensor3D.gd
create mode 100644 examples/Platform2D/addons/godot_rl_agents/sensors/sensors_3d/RGBCameraSensor3D.tscn
create mode 100644 examples/Platform2D/addons/godot_rl_agents/sensors/sensors_3d/RaycastSensor3D.gd
create mode 100644 examples/Platform2D/addons/godot_rl_agents/sensors/sensors_3d/RaycastSensor3D.tscn
create mode 100644 examples/Platform2D/addons/godot_rl_agents/sync.gd
create mode 100644 examples/Platform2D/assets/player/jump/Player1Jump1.png
create mode 100644 examples/Platform2D/assets/player/jump/Player1Jump2.png
create mode 100644 examples/Platform2D/assets/player/jump/Player1Jump3.png
create mode 100644 examples/Platform2D/assets/player/move/Player-1.png
create mode 100644 examples/Platform2D/assets/player/move/Player-2.png
create mode 100644 examples/Platform2D/assets/player/move/Player-3.png
create mode 100644 examples/Platform2D/assets/tilesheet.png
create mode 100644 examples/Platform2D/icon.svg
create mode 100644 examples/Platform2D/license.md
create mode 100644 examples/Platform2D/model.onnx
create mode 100644 examples/Platform2D/project.godot
create mode 100644 examples/Platform2D/readme.md
create mode 100644 examples/Platform2D/scenes/game_scene/game_scene.tscn
create mode 100644 examples/Platform2D/scenes/player/extended_grid_sensor_2d.gd
create mode 100644 examples/Platform2D/scenes/player/player.gd
create mode 100644 examples/Platform2D/scenes/player/player.tscn
create mode 100644 examples/Platform2D/scenes/player/player_ai_controller.gd
create mode 100644 examples/Platform2D/scenes/tilemap/tile_map_layer.gd
create mode 100644 examples/Platform2D/scenes/tileset/tileset.tres
create mode 100644 examples/Platform2D/scenes/training_scene/inference_scene.tscn
create mode 100644 examples/Platform2D/scenes/training_scene/training_scene.tscn
diff --git a/examples/Platform2D/.gitattributes b/examples/Platform2D/.gitattributes
new file mode 100644
index 0000000..8ad74f7
--- /dev/null
+++ b/examples/Platform2D/.gitattributes
@@ -0,0 +1,2 @@
+# Normalize EOL for all files that Git considers text files.
+* text=auto eol=lf
diff --git a/examples/Platform2D/.gitignore b/examples/Platform2D/.gitignore
new file mode 100644
index 0000000..7de8ea5
--- /dev/null
+++ b/examples/Platform2D/.gitignore
@@ -0,0 +1,3 @@
+# Godot 4+ specific ignores
+.godot/
+android/
diff --git a/examples/Platform2D/Platform2D.csproj b/examples/Platform2D/Platform2D.csproj
new file mode 100644
index 0000000..6fa3be0
--- /dev/null
+++ b/examples/Platform2D/Platform2D.csproj
@@ -0,0 +1,11 @@
+
+
+ net6.0
+ net7.0
+ net8.0
+ true
+
+
+
+
+
\ No newline at end of file
diff --git a/examples/Platform2D/Platform2D.sln b/examples/Platform2D/Platform2D.sln
new file mode 100644
index 0000000..5427097
--- /dev/null
+++ b/examples/Platform2D/Platform2D.sln
@@ -0,0 +1,19 @@
+Microsoft Visual Studio Solution File, Format Version 12.00
+# Visual Studio 2012
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Platform2D", "Platform2D.csproj", "{8552EC7B-EF81-42D4-828B-B6CD9D17C897}"
+EndProject
+Global
+ GlobalSection(SolutionConfigurationPlatforms) = preSolution
+ Debug|Any CPU = Debug|Any CPU
+ ExportDebug|Any CPU = ExportDebug|Any CPU
+ ExportRelease|Any CPU = ExportRelease|Any CPU
+ EndGlobalSection
+ GlobalSection(ProjectConfigurationPlatforms) = postSolution
+ {8552EC7B-EF81-42D4-828B-B6CD9D17C897}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+ {8552EC7B-EF81-42D4-828B-B6CD9D17C897}.Debug|Any CPU.Build.0 = Debug|Any CPU
+ {8552EC7B-EF81-42D4-828B-B6CD9D17C897}.ExportDebug|Any CPU.ActiveCfg = ExportDebug|Any CPU
+ {8552EC7B-EF81-42D4-828B-B6CD9D17C897}.ExportDebug|Any CPU.Build.0 = ExportDebug|Any CPU
+ {8552EC7B-EF81-42D4-828B-B6CD9D17C897}.ExportRelease|Any CPU.ActiveCfg = ExportRelease|Any CPU
+ {8552EC7B-EF81-42D4-828B-B6CD9D17C897}.ExportRelease|Any CPU.Build.0 = ExportRelease|Any CPU
+ EndGlobalSection
+EndGlobal
diff --git a/examples/Platform2D/addons/godot_rl_agents/controller/ai_controller_2d.gd b/examples/Platform2D/addons/godot_rl_agents/controller/ai_controller_2d.gd
new file mode 100644
index 0000000..06d928b
--- /dev/null
+++ b/examples/Platform2D/addons/godot_rl_agents/controller/ai_controller_2d.gd
@@ -0,0 +1,136 @@
+extends Node2D
+class_name AIController2D
+
+enum ControlModes {
+ INHERIT_FROM_SYNC, ## Inherit setting from sync node
+ HUMAN, ## Test the environment manually
+ TRAINING, ## Train a model
+ ONNX_INFERENCE, ## Load a pretrained model using an .onnx file
+ RECORD_EXPERT_DEMOS ## Record observations and actions for expert demonstrations
+}
+@export var control_mode: ControlModes = ControlModes.INHERIT_FROM_SYNC
+## The path to a trained .onnx model file to use for inference (overrides the path set in sync node).
+@export var onnx_model_path := ""
+## Once the number of steps has passed, the flag 'needs_reset' will be set to 'true' for this instance.
+@export var reset_after := 1000
+
+@export_group("Record expert demos mode options")
+## Path where the demos will be saved. The file can later be used for imitation learning.
+@export var expert_demo_save_path: String
+## The action that erases the last recorded episode from the currently recorded data.
+@export var remove_last_episode_key: InputEvent
+## Action will be repeated for n frames. Will introduce control lag if larger than 1.
+## Can be used to ensure that action_repeat on inference and training matches
+## the recorded demonstrations.
+@export var action_repeat: int = 1
+
+@export_group("Multi-policy mode options")
+## Allows you to set certain agents to use different policies.
+## Changing has no effect with default SB3 training. Works with Rllib example.
+## Tutorial: https://github.com/edbeeching/godot_rl_agents/blob/main/docs/TRAINING_MULTIPLE_POLICIES.md
+@export var policy_name: String = "shared_policy"
+
+var onnx_model: ONNXModel
+
+var heuristic := "human"
+var done := false
+var reward := 0.0
+var n_steps := 0
+var needs_reset := false
+
+var _player: Node2D
+
+
+func _ready():
+ add_to_group("AGENT")
+
+
+func init(player: Node2D):
+ _player = player
+
+
+#region Methods that need implementing using the "extend script" option in Godot
+func get_obs() -> Dictionary:
+ assert(false, "the get_obs method is not implemented when extending from ai_controller")
+ return {"obs": []}
+
+
+func get_reward() -> float:
+ assert(false, "the get_reward method is not implemented when extending from ai_controller")
+ return 0.0
+
+
+func get_action_space() -> Dictionary:
+ assert(
+ false, "the get_action_space method is not implemented when extending from ai_controller"
+ )
+ return {
+ "example_actions_continous": {"size": 2, "action_type": "continuous"},
+ "example_actions_discrete": {"size": 2, "action_type": "discrete"},
+ }
+
+
+func set_action(action) -> void:
+ assert(false, "the set_action method is not implemented when extending from ai_controller")
+
+
+#endregion
+
+
+#region Methods that sometimes need implementing using the "extend script" option in Godot
+# Only needed if you are recording expert demos with this AIController
+func get_action() -> Array:
+ assert(
+ false,
+ "the get_action method is not implemented in extended AIController but demo_recorder is used"
+ )
+ return []
+
+
+# For providing additional info (e.g. `is_success` for SB3 training)
+func get_info() -> Dictionary:
+ return {}
+
+
+#endregion
+
+
+func _physics_process(delta):
+ n_steps += 1
+ if n_steps > reset_after:
+ needs_reset = true
+
+
+func get_obs_space():
+ # may need overriding if the obs space is complex
+ var obs = get_obs()
+ return {
+ "obs": {"size": [len(obs["obs"])], "space": "box"},
+ }
+
+
+func reset():
+ n_steps = 0
+ needs_reset = false
+
+
+func reset_if_done():
+ if done:
+ reset()
+
+
+func set_heuristic(h):
+ # sets the heuristic from "human" or "model" nothing to change here
+ heuristic = h
+
+
+func get_done():
+ return done
+
+
+func set_done_false():
+ done = false
+
+
+func zero_reward():
+ reward = 0.0
diff --git a/examples/Platform2D/addons/godot_rl_agents/controller/ai_controller_3d.gd b/examples/Platform2D/addons/godot_rl_agents/controller/ai_controller_3d.gd
new file mode 100644
index 0000000..61a0529
--- /dev/null
+++ b/examples/Platform2D/addons/godot_rl_agents/controller/ai_controller_3d.gd
@@ -0,0 +1,136 @@
+extends Node3D
+class_name AIController3D
+
+enum ControlModes {
+ INHERIT_FROM_SYNC, ## Inherit setting from sync node
+ HUMAN, ## Test the environment manually
+ TRAINING, ## Train a model
+ ONNX_INFERENCE, ## Load a pretrained model using an .onnx file
+ RECORD_EXPERT_DEMOS ## Record observations and actions for expert demonstrations
+}
+@export var control_mode: ControlModes = ControlModes.INHERIT_FROM_SYNC
+## The path to a trained .onnx model file to use for inference (overrides the path set in sync node).
+@export var onnx_model_path := ""
+## Once the number of steps has passed, the flag 'needs_reset' will be set to 'true' for this instance.
+@export var reset_after := 1000
+
+@export_group("Record expert demos mode options")
+## Path where the demos will be saved. The file can later be used for imitation learning.
+@export var expert_demo_save_path: String
+## The action that erases the last recorded episode from the currently recorded data.
+@export var remove_last_episode_key: InputEvent
+## Action will be repeated for n frames. Will introduce control lag if larger than 1.
+## Can be used to ensure that action_repeat on inference and training matches
+## the recorded demonstrations.
+@export var action_repeat: int = 1
+
+@export_group("Multi-policy mode options")
+## Allows you to set certain agents to use different policies.
+## Changing has no effect with default SB3 training. Works with Rllib example.
+## Tutorial: https://github.com/edbeeching/godot_rl_agents/blob/main/docs/TRAINING_MULTIPLE_POLICIES.md
+@export var policy_name: String = "shared_policy"
+
+var onnx_model: ONNXModel
+
+var heuristic := "human"
+var done := false
+var reward := 0.0
+var n_steps := 0
+var needs_reset := false
+
+var _player: Node3D
+
+
+func _ready():
+ add_to_group("AGENT")
+
+
+func init(player: Node3D):
+ _player = player
+
+
+#region Methods that need implementing using the "extend script" option in Godot
+func get_obs() -> Dictionary:
+ assert(false, "the get_obs method is not implemented when extending from ai_controller")
+ return {"obs": []}
+
+
+func get_reward() -> float:
+ assert(false, "the get_reward method is not implemented when extending from ai_controller")
+ return 0.0
+
+
+func get_action_space() -> Dictionary:
+ assert(
+ false, "the get_action_space method is not implemented when extending from ai_controller"
+ )
+ return {
+ "example_actions_continous": {"size": 2, "action_type": "continuous"},
+ "example_actions_discrete": {"size": 2, "action_type": "discrete"},
+ }
+
+
+func set_action(action) -> void:
+ assert(false, "the set_action method is not implemented when extending from ai_controller")
+
+
+#endregion
+
+
+#region Methods that sometimes need implementing using the "extend script" option in Godot
+# Only needed if you are recording expert demos with this AIController
+func get_action() -> Array:
+ assert(
+ false,
+ "the get_action method is not implemented in extended AIController but demo_recorder is used"
+ )
+ return []
+
+
+# For providing additional info (e.g. `is_success` for SB3 training)
+func get_info() -> Dictionary:
+ return {}
+
+
+#endregion
+
+
+func _physics_process(delta):
+ n_steps += 1
+ if n_steps > reset_after:
+ needs_reset = true
+
+
+func get_obs_space():
+ # may need overriding if the obs space is complex
+ var obs = get_obs()
+ return {
+ "obs": {"size": [len(obs["obs"])], "space": "box"},
+ }
+
+
+func reset():
+ n_steps = 0
+ needs_reset = false
+
+
+func reset_if_done():
+ if done:
+ reset()
+
+
+func set_heuristic(h):
+ # sets the heuristic from "human" or "model" nothing to change here
+ heuristic = h
+
+
+func get_done():
+ return done
+
+
+func set_done_false():
+ done = false
+
+
+func zero_reward():
+ reward = 0.0
diff --git a/examples/Platform2D/addons/godot_rl_agents/godot_rl_agents.gd b/examples/Platform2D/addons/godot_rl_agents/godot_rl_agents.gd
new file mode 100644
index 0000000..e4fe136
--- /dev/null
+++ b/examples/Platform2D/addons/godot_rl_agents/godot_rl_agents.gd
@@ -0,0 +1,16 @@
+@tool
+extends EditorPlugin
+
+
+func _enter_tree():
+ # Initialization of the plugin goes here.
+ # Add the new type with a name, a parent type, a script and an icon.
+ add_custom_type("Sync", "Node", preload("sync.gd"), preload("icon.png"))
+ #add_custom_type("RaycastSensor2D2", "Node", preload("raycast_sensor_2d.gd"), preload("icon.png"))
+
+
+func _exit_tree():
+ # Clean-up of the plugin goes here.
+ # Always remember to remove it from the engine when deactivated.
+ remove_custom_type("Sync")
+ #remove_custom_type("RaycastSensor2D2")
diff --git a/examples/Platform2D/addons/godot_rl_agents/icon.png b/examples/Platform2D/addons/godot_rl_agents/icon.png
new file mode 100644
index 0000000000000000000000000000000000000000..fd8190e710eafcd44b723917e69f8a028e697f4b
GIT binary patch
literal 198
zcmeAS@N?(olHy`uVBq!ia0vp^0wB!73?$#)eFPHF3h)VW1=92H&!72h^YV{tmc3iE
z?8EA%@76ATw`S>kbo66k0w+*4Z%L3}Farmdxo=y?%=15f{`ngim75Ecu=8|r45_%4
zoZ!H;NBn|B&bH~o2YBx9-M+p-GO7B#h~pETS&{_}Yj&4UZ<5S@e{U~m+MT`C-}QRf
eHb3AgVPI&!A~QdCx-=WmBnD4cKbLh*2~7Y1GgDds
literal 0
HcmV?d00001
diff --git a/examples/Platform2D/addons/godot_rl_agents/onnx/csharp/ONNXInference.cs b/examples/Platform2D/addons/godot_rl_agents/onnx/csharp/ONNXInference.cs
new file mode 100644
index 0000000..6dcfa18
--- /dev/null
+++ b/examples/Platform2D/addons/godot_rl_agents/onnx/csharp/ONNXInference.cs
@@ -0,0 +1,109 @@
+using Godot;
+using Microsoft.ML.OnnxRuntime;
+using Microsoft.ML.OnnxRuntime.Tensors;
+using System.Collections.Generic;
+using System.Linq;
+
+namespace GodotONNX
+{
+ ///
+ public partial class ONNXInference : GodotObject
+ {
+
+ private InferenceSession session;
+ ///
+ /// Path to the ONNX model. Use Initialize to change it.
+ ///
+ private string modelPath;
+ private int batchSize;
+
+ private SessionOptions SessionOpt;
+
+ ///
+ /// init function
+ ///
+ ///
+ ///
+ /// Returns the output size of the model
+ public int Initialize(string Path, int BatchSize)
+ {
+ modelPath = Path;
+ batchSize = BatchSize;
+ SessionOpt = SessionConfigurator.MakeConfiguredSessionOptions();
+ session = LoadModel(modelPath);
+ return session.OutputMetadata["output"].Dimensions[1];
+ }
+
+
+ ///
+ public Godot.Collections.Dictionary> RunInference(Godot.Collections.Array obs, int state_ins)
+ {
+ //Current model: Any (Godot Rl Agents)
+ //Expects a tensor of shape [batch_size, input_size] type float named obs and a tensor of shape [batch_size] type float named state_ins
+
+ //Fill the input tensors
+ // create span from inputSize
+ var span = new float[obs.Count]; //There's probably a better way to do this
+ for (int i = 0; i < obs.Count; i++)
+ {
+ span[i] = obs[i];
+ }
+
+ IReadOnlyCollection inputs = new List
+ {
+ NamedOnnxValue.CreateFromTensor("obs", new DenseTensor(span, new int[] { batchSize, obs.Count })),
+ NamedOnnxValue.CreateFromTensor("state_ins", new DenseTensor(new float[] { state_ins }, new int[] { batchSize }))
+ };
+ IReadOnlyCollection outputNames = new List { "output", "state_outs" }; //ONNX is sensible to these names, as well as the input names
+
+ IDisposableReadOnlyCollection results;
+ //We do not use "using" here so we get a better exception explaination later
+ try
+ {
+ results = session.Run(inputs, outputNames);
+ }
+ catch (OnnxRuntimeException e)
+ {
+ //This error usually means that the model is not compatible with the input, beacause of the input shape (size)
+ GD.Print("Error at inference: ", e);
+ return null;
+ }
+ //Can't convert IEnumerable to Variant, so we have to convert it to an array or something
+ Godot.Collections.Dictionary> output = new Godot.Collections.Dictionary>();
+ DisposableNamedOnnxValue output1 = results.First();
+ DisposableNamedOnnxValue output2 = results.Last();
+ Godot.Collections.Array output1Array = new Godot.Collections.Array();
+ Godot.Collections.Array output2Array = new Godot.Collections.Array();
+
+ foreach (float f in output1.AsEnumerable())
+ {
+ output1Array.Add(f);
+ }
+
+ foreach (float f in output2.AsEnumerable())
+ {
+ output2Array.Add(f);
+ }
+
+ output.Add(output1.Name, output1Array);
+ output.Add(output2.Name, output2Array);
+
+ //Output is a dictionary of arrays, ex: { "output" : [0.1, 0.2, 0.3, 0.4, ...], "state_outs" : [0.5, ...]}
+ results.Dispose();
+ return output;
+ }
+ ///
+ public InferenceSession LoadModel(string Path)
+ {
+ using Godot.FileAccess file = FileAccess.Open(Path, Godot.FileAccess.ModeFlags.Read);
+ byte[] model = file.GetBuffer((int)file.GetLength());
+ //file.Close(); file.Dispose(); //Close the file, then dispose the reference.
+ return new InferenceSession(model, SessionOpt); //Load the model
+ }
+ public void FreeDisposables()
+ {
+ session.Dispose();
+ SessionOpt.Dispose();
+ }
+ }
+}
diff --git a/examples/Platform2D/addons/godot_rl_agents/onnx/csharp/SessionConfigurator.cs b/examples/Platform2D/addons/godot_rl_agents/onnx/csharp/SessionConfigurator.cs
new file mode 100644
index 0000000..ad7a41c
--- /dev/null
+++ b/examples/Platform2D/addons/godot_rl_agents/onnx/csharp/SessionConfigurator.cs
@@ -0,0 +1,131 @@
+using Godot;
+using Microsoft.ML.OnnxRuntime;
+
+namespace GodotONNX
+{
+ ///
+
+ public static class SessionConfigurator
+ {
+ public enum ComputeName
+ {
+ CUDA,
+ ROCm,
+ DirectML,
+ CoreML,
+ CPU
+ }
+
+ ///
+ public static SessionOptions MakeConfiguredSessionOptions()
+ {
+ SessionOptions sessionOptions = new();
+ SetOptions(sessionOptions);
+ return sessionOptions;
+ }
+
+ private static void SetOptions(SessionOptions sessionOptions)
+ {
+ sessionOptions.LogSeverityLevel = OrtLoggingLevel.ORT_LOGGING_LEVEL_WARNING;
+ ApplySystemSpecificOptions(sessionOptions);
+ }
+
+ ///
+ static public void ApplySystemSpecificOptions(SessionOptions sessionOptions)
+ {
+ //Most code for this function is verbose only, the only reason it exists is to track
+ //implementation progress of the different compute APIs.
+
+ //December 2022: CUDA is not working.
+
+ string OSName = OS.GetName(); //Get OS Name
+
+ //ComputeName ComputeAPI = ComputeCheck(); //Get Compute API
+ // //TODO: Get CPU architecture
+
+ //Linux can use OpenVINO (C#) on x64 and ROCm on x86 (GDNative/C++)
+ //Windows can use OpenVINO (C#) on x64
+ //TODO: try TensorRT instead of CUDA
+ //TODO: Use OpenVINO for Intel Graphics
+
+ // Temporarily using CPU on all platforms to avoid errors detected with DML
+ ComputeName ComputeAPI = ComputeName.CPU;
+
+ //match OS and Compute API
+ GD.Print($"OS: {OSName} Compute API: {ComputeAPI}");
+
+ // CPU is set by default without appending necessary
+ // sessionOptions.AppendExecutionProvider_CPU(0);
+
+ /*
+ switch (OSName)
+ {
+ case "Windows": //Can use CUDA, DirectML
+ if (ComputeAPI is ComputeName.CUDA)
+ {
+ //CUDA
+ //sessionOptions.AppendExecutionProvider_CUDA(0);
+ //sessionOptions.AppendExecutionProvider_DML(0);
+ }
+ else if (ComputeAPI is ComputeName.DirectML)
+ {
+ //DirectML
+ //sessionOptions.AppendExecutionProvider_DML(0);
+ }
+ break;
+ case "X11": //Can use CUDA, ROCm
+ if (ComputeAPI is ComputeName.CUDA)
+ {
+ //CUDA
+ //sessionOptions.AppendExecutionProvider_CUDA(0);
+ }
+ if (ComputeAPI is ComputeName.ROCm)
+ {
+ //ROCm, only works on x86
+ //Research indicates that this has to be compiled as a GDNative plugin
+ //GD.Print("ROCm not supported yet, using CPU.");
+ //sessionOptions.AppendExecutionProvider_CPU(0);
+ }
+ break;
+ case "macOS": //Can use CoreML
+ if (ComputeAPI is ComputeName.CoreML)
+ { //CoreML
+ //TODO: Needs testing
+ //sessionOptions.AppendExecutionProvider_CoreML(0);
+ //CoreML on ARM64, out of the box, on x64 needs .tar file from GitHub
+ }
+ break;
+ default:
+ GD.Print("OS not Supported.");
+ break;
+ }
+ */
+ }
+
+
+ ///
+ public static ComputeName ComputeCheck()
+ {
+ string adapterName = Godot.RenderingServer.GetVideoAdapterName();
+ //string adapterVendor = Godot.RenderingServer.GetVideoAdapterVendor();
+ adapterName = adapterName.ToUpper(new System.Globalization.CultureInfo(""));
+ //TODO: GPU vendors for MacOS, what do they even use these days?
+
+ if (adapterName.Contains("INTEL"))
+ {
+ return ComputeName.DirectML;
+ }
+ if (adapterName.Contains("AMD") || adapterName.Contains("RADEON"))
+ {
+ return ComputeName.DirectML;
+ }
+ if (adapterName.Contains("NVIDIA"))
+ {
+ return ComputeName.CUDA;
+ }
+
+ GD.Print("Graphics Card not recognized."); //Should use CPU
+ return ComputeName.CPU;
+ }
+ }
+}
diff --git a/examples/Platform2D/addons/godot_rl_agents/onnx/csharp/docs/ONNXInference.xml b/examples/Platform2D/addons/godot_rl_agents/onnx/csharp/docs/ONNXInference.xml
new file mode 100644
index 0000000..91b07d6
--- /dev/null
+++ b/examples/Platform2D/addons/godot_rl_agents/onnx/csharp/docs/ONNXInference.xml
@@ -0,0 +1,31 @@
+
+
+
+
+ The main ONNXInference Class that handles the inference process.
+
+
+
+
+ Starts the inference process.
+
+ Path to the ONNX model, expects a path inside resources.
+ How many observations will the model recieve.
+
+
+
+ Runs the given input through the model and returns the output.
+
+ Dictionary containing all observations.
+ How many different agents are creating these observations.
+ A Dictionary of arrays, containing instructions based on the observations.
+
+
+
+ Loads the given model into the inference process, using the best Execution provider available.
+
+ Path to the ONNX model, expects a path inside resources.
+ InferenceSession ready to run.
+
+
+
\ No newline at end of file
diff --git a/examples/Platform2D/addons/godot_rl_agents/onnx/csharp/docs/SessionConfigurator.xml b/examples/Platform2D/addons/godot_rl_agents/onnx/csharp/docs/SessionConfigurator.xml
new file mode 100644
index 0000000..f160c02
--- /dev/null
+++ b/examples/Platform2D/addons/godot_rl_agents/onnx/csharp/docs/SessionConfigurator.xml
@@ -0,0 +1,29 @@
+
+
+
+
+ The main SessionConfigurator Class that handles the execution options and providers for the inference process.
+
+
+
+
+ Creates a SessionOptions with all available execution providers.
+
+ SessionOptions with all available execution providers.
+
+
+
+ Appends any execution provider available in the current system.
+
+
+ This function is mainly verbose for tracking implementation progress of different compute APIs.
+
+
+
+
+ Checks for available GPUs.
+
+ An integer identifier for each compute platform.
+
+
+
\ No newline at end of file
diff --git a/examples/Platform2D/addons/godot_rl_agents/onnx/wrapper/ONNX_wrapper.gd b/examples/Platform2D/addons/godot_rl_agents/onnx/wrapper/ONNX_wrapper.gd
new file mode 100644
index 0000000..e27f2c3
--- /dev/null
+++ b/examples/Platform2D/addons/godot_rl_agents/onnx/wrapper/ONNX_wrapper.gd
@@ -0,0 +1,51 @@
+extends Resource
+class_name ONNXModel
+var inferencer_script = load("res://addons/godot_rl_agents/onnx/csharp/ONNXInference.cs")
+
+var inferencer = null
+
+## How many action values the model outputs
+var action_output_size: int
+
+## Used to differentiate models
+## that only output continuous action mean (e.g. sb3, cleanrl export)
+## versus models that output mean and logstd (e.g. rllib export)
+var action_means_only: bool
+
+## Whether action_means_value has been set already for this model
+var action_means_only_set: bool
+
+# Must provide the path to the model and the batch size
+func _init(model_path, batch_size):
+ inferencer = inferencer_script.new()
+ action_output_size = inferencer.Initialize(model_path, batch_size)
+
+# This function is the one that will be called from the game,
+# requires the observation as an array and the state_ins as an int
+# returns an Array containing the action the model takes.
+func run_inference(obs: Array, state_ins: int) -> Dictionary:
+ if inferencer == null:
+ printerr("Inferencer not initialized")
+ return {}
+ return inferencer.RunInference(obs, state_ins)
+
+
+func _notification(what):
+ if what == NOTIFICATION_PREDELETE:
+ inferencer.FreeDisposables()
+ inferencer.free()
+
+# Check whether agent uses a continuous actions model with only action means or not
+func set_action_means_only(agent_action_space):
+ action_means_only_set = true
+ var continuous_only: bool = true
+ var continuous_actions: int
+ for action in agent_action_space:
+ if not agent_action_space[action]["action_type"] == "continuous":
+ continuous_only = false
+ break
+ else:
+ continuous_actions += agent_action_space[action]["size"]
+ if continuous_only:
+ if continuous_actions == action_output_size:
+ action_means_only = true
diff --git a/examples/Platform2D/addons/godot_rl_agents/plugin.cfg b/examples/Platform2D/addons/godot_rl_agents/plugin.cfg
new file mode 100644
index 0000000..b1bc988
--- /dev/null
+++ b/examples/Platform2D/addons/godot_rl_agents/plugin.cfg
@@ -0,0 +1,7 @@
+[plugin]
+
+name="GodotRLAgents"
+description="Custom nodes for the godot rl agents toolkit "
+author="Edward Beeching"
+version="0.1"
+script="godot_rl_agents.gd"
diff --git a/examples/Platform2D/addons/godot_rl_agents/sensors/sensors_2d/ExampleRaycastSensor2D.tscn b/examples/Platform2D/addons/godot_rl_agents/sensors/sensors_2d/ExampleRaycastSensor2D.tscn
new file mode 100644
index 0000000..5edb6c7
--- /dev/null
+++ b/examples/Platform2D/addons/godot_rl_agents/sensors/sensors_2d/ExampleRaycastSensor2D.tscn
@@ -0,0 +1,48 @@
+[gd_scene load_steps=5 format=3 uid="uid://ddeq7mn1ealyc"]
+
+[ext_resource type="Script" path="res://addons/godot_rl_agents/sensors/sensors_2d/RaycastSensor2D.gd" id="1"]
+
+[sub_resource type="GDScript" id="2"]
+script/source = "extends Node2D
+
+
+
+func _physics_process(delta: float) -> void:
+ print(\"step start\")
+
+"
+
+[sub_resource type="GDScript" id="1"]
+script/source = "extends RayCast2D
+
+var steps = 1
+
+func _physics_process(delta: float) -> void:
+ print(\"processing raycast\")
+ steps += 1
+ if steps % 2:
+ force_raycast_update()
+
+ print(is_colliding())
+"
+
+[sub_resource type="CircleShape2D" id="3"]
+
+[node name="ExampleRaycastSensor2D" type="Node2D"]
+script = SubResource("2")
+
+[node name="ExampleAgent" type="Node2D" parent="."]
+position = Vector2(573, 314)
+rotation = 0.286234
+
+[node name="RaycastSensor2D" type="Node2D" parent="ExampleAgent"]
+script = ExtResource("1")
+
+[node name="TestRayCast2D" type="RayCast2D" parent="."]
+script = SubResource("1")
+
+[node name="StaticBody2D" type="StaticBody2D" parent="."]
+position = Vector2(1, 52)
+
+[node name="CollisionShape2D" type="CollisionShape2D" parent="StaticBody2D"]
+shape = SubResource("3")
diff --git a/examples/Platform2D/addons/godot_rl_agents/sensors/sensors_2d/GridSensor2D.gd b/examples/Platform2D/addons/godot_rl_agents/sensors/sensors_2d/GridSensor2D.gd
new file mode 100644
index 0000000..48b132e
--- /dev/null
+++ b/examples/Platform2D/addons/godot_rl_agents/sensors/sensors_2d/GridSensor2D.gd
@@ -0,0 +1,235 @@
+@tool
+extends ISensor2D
+class_name GridSensor2D
+
+@export var debug_view := false:
+ get:
+ return debug_view
+ set(value):
+ debug_view = value
+ _update()
+
+@export_flags_2d_physics var detection_mask := 0:
+ get:
+ return detection_mask
+ set(value):
+ detection_mask = value
+ _update()
+
+@export var collide_with_areas := false:
+ get:
+ return collide_with_areas
+ set(value):
+ collide_with_areas = value
+ _update()
+
+@export var collide_with_bodies := true:
+ get:
+ return collide_with_bodies
+ set(value):
+ collide_with_bodies = value
+ _update()
+
+@export_range(1, 200, 0.1) var cell_width := 20.0:
+ get:
+ return cell_width
+ set(value):
+ cell_width = value
+ _update()
+
+@export_range(1, 200, 0.1) var cell_height := 20.0:
+ get:
+ return cell_height
+ set(value):
+ cell_height = value
+ _update()
+
+@export_range(1, 21, 2, "or_greater") var grid_size_x := 3:
+ get:
+ return grid_size_x
+ set(value):
+ grid_size_x = value
+ _update()
+
+@export_range(1, 21, 2, "or_greater") var grid_size_y := 3:
+ get:
+ return grid_size_y
+ set(value):
+ grid_size_y = value
+ _update()
+
+var _obs_buffer: PackedFloat64Array
+var _rectangle_shape: RectangleShape2D
+var _collision_mapping: Dictionary
+var _n_layers_per_cell: int
+
+var _highlighted_cell_color: Color
+var _standard_cell_color: Color
+
+
+func get_observation():
+ return _obs_buffer
+
+
+func _update():
+ if Engine.is_editor_hint():
+ if is_node_ready():
+ _spawn_nodes()
+
+
+func _ready() -> void:
+ _set_colors()
+
+ if Engine.is_editor_hint():
+ if get_child_count() == 0:
+ _spawn_nodes()
+ else:
+ _spawn_nodes()
+
+
+func _set_colors() -> void:
+ _standard_cell_color = Color(100.0 / 255.0, 100.0 / 255.0, 100.0 / 255.0, 100.0 / 255.0)
+ _highlighted_cell_color = Color(255.0 / 255.0, 100.0 / 255.0, 100.0 / 255.0, 100.0 / 255.0)
+
+
+func _get_collision_mapping() -> Dictionary:
+ # defines which layer is mapped to which cell obs index
+ var total_bits = 0
+ var collision_mapping = {}
+ for i in 32:
+ var bit_mask = 2 ** i
+ if (detection_mask & bit_mask) > 0:
+ collision_mapping[i] = total_bits
+ total_bits += 1
+
+ return collision_mapping
+
+
+func _spawn_nodes():
+ for cell in get_children():
+ cell.name = "_%s" % cell.name # Otherwise naming below will fail
+ cell.queue_free()
+
+ _collision_mapping = _get_collision_mapping()
+ #prints("collision_mapping", _collision_mapping, len(_collision_mapping))
+ # allocate memory for the observations
+ _n_layers_per_cell = len(_collision_mapping)
+ _obs_buffer = PackedFloat64Array()
+ _obs_buffer.resize(grid_size_x * grid_size_y * _n_layers_per_cell)
+ _obs_buffer.fill(0)
+ #prints(len(_obs_buffer), _obs_buffer )
+
+ _rectangle_shape = RectangleShape2D.new()
+ _rectangle_shape.set_size(Vector2(cell_width, cell_height))
+
+ var shift := Vector2(
+ -(grid_size_x / 2) * cell_width,
+ -(grid_size_y / 2) * cell_height,
+ )
+
+ for i in grid_size_x:
+ for j in grid_size_y:
+ var cell_position = Vector2(i * cell_width, j * cell_height) + shift
+ _create_cell(i, j, cell_position)
+
+
+func _create_cell(i: int, j: int, position: Vector2):
+ var cell := Area2D.new()
+ cell.position = position
+ cell.name = "GridCell %s %s" % [i, j]
+ cell.modulate = _standard_cell_color
+
+ if collide_with_areas:
+ cell.area_entered.connect(_on_cell_area_entered.bind(i, j))
+ cell.area_exited.connect(_on_cell_area_exited.bind(i, j))
+
+ if collide_with_bodies:
+ cell.body_entered.connect(_on_cell_body_entered.bind(i, j))
+ cell.body_exited.connect(_on_cell_body_exited.bind(i, j))
+
+ cell.collision_layer = 0
+ cell.collision_mask = detection_mask
+ cell.monitorable = true
+ add_child(cell)
+ cell.set_owner(get_tree().edited_scene_root)
+
+ var col_shape := CollisionShape2D.new()
+ col_shape.shape = _rectangle_shape
+ col_shape.name = "CollisionShape2D"
+ cell.add_child(col_shape)
+ col_shape.set_owner(get_tree().edited_scene_root)
+
+ if debug_view:
+ var quad = MeshInstance2D.new()
+ quad.name = "MeshInstance2D"
+ var quad_mesh = QuadMesh.new()
+
+ quad_mesh.set_size(Vector2(cell_width, cell_height))
+
+ quad.mesh = quad_mesh
+ cell.add_child(quad)
+ quad.set_owner(get_tree().edited_scene_root)
+
+
+func _update_obs(cell_i: int, cell_j: int, collision_layer: int, entered: bool):
+ for key in _collision_mapping:
+ var bit_mask = 2 ** key
+ if (collision_layer & bit_mask) > 0:
+ var collison_map_index = _collision_mapping[key]
+
+ var obs_index = (
+ (cell_i * grid_size_y * _n_layers_per_cell)
+ + (cell_j * _n_layers_per_cell)
+ + collison_map_index
+ )
+ #prints(obs_index, cell_i, cell_j)
+ if entered:
+ _obs_buffer[obs_index] += 1
+ else:
+ _obs_buffer[obs_index] -= 1
+
+
+func _toggle_cell(cell_i: int, cell_j: int):
+ var cell = get_node_or_null("GridCell %s %s" % [cell_i, cell_j])
+
+ if cell == null:
+ print("cell not found, returning")
+
+ var n_hits = 0
+ var start_index = (cell_i * grid_size_y * _n_layers_per_cell) + (cell_j * _n_layers_per_cell)
+ for i in _n_layers_per_cell:
+ n_hits += _obs_buffer[start_index + i]
+
+ if n_hits > 0:
+ cell.modulate = _highlighted_cell_color
+ else:
+ cell.modulate = _standard_cell_color
+
+
+func _on_cell_area_entered(area: Area2D, cell_i: int, cell_j: int):
+ #prints("_on_cell_area_entered", cell_i, cell_j)
+ _update_obs(cell_i, cell_j, area.collision_layer, true)
+ if debug_view:
+ _toggle_cell(cell_i, cell_j)
+ #print(_obs_buffer)
+
+
+func _on_cell_area_exited(area: Area2D, cell_i: int, cell_j: int):
+ #prints("_on_cell_area_exited", cell_i, cell_j)
+ _update_obs(cell_i, cell_j, area.collision_layer, false)
+ if debug_view:
+ _toggle_cell(cell_i, cell_j)
+
+
+func _on_cell_body_entered(body: Node2D, cell_i: int, cell_j: int):
+ #prints("_on_cell_body_entered", cell_i, cell_j)
+ _update_obs(cell_i, cell_j, body.collision_layer, true)
+ if debug_view:
+ _toggle_cell(cell_i, cell_j)
+
+
+func _on_cell_body_exited(body: Node2D, cell_i: int, cell_j: int):
+ #prints("_on_cell_body_exited", cell_i, cell_j)
+ _update_obs(cell_i, cell_j, body.collision_layer, false)
+ if debug_view:
+ _toggle_cell(cell_i, cell_j)
diff --git a/examples/Platform2D/addons/godot_rl_agents/sensors/sensors_2d/ISensor2D.gd b/examples/Platform2D/addons/godot_rl_agents/sensors/sensors_2d/ISensor2D.gd
new file mode 100644
index 0000000..67669a1
--- /dev/null
+++ b/examples/Platform2D/addons/godot_rl_agents/sensors/sensors_2d/ISensor2D.gd
@@ -0,0 +1,25 @@
+extends Node2D
+class_name ISensor2D
+
+var _obs: Array = []
+var _active := false
+
+
+func get_observation():
+ pass
+
+
+func activate():
+ _active = true
+
+
+func deactivate():
+ _active = false
+
+
+func _update_observation():
+ pass
+
+
+func reset():
+ pass
diff --git a/examples/Platform2D/addons/godot_rl_agents/sensors/sensors_2d/RaycastSensor2D.gd b/examples/Platform2D/addons/godot_rl_agents/sensors/sensors_2d/RaycastSensor2D.gd
new file mode 100644
index 0000000..9bb54ed
--- /dev/null
+++ b/examples/Platform2D/addons/godot_rl_agents/sensors/sensors_2d/RaycastSensor2D.gd
@@ -0,0 +1,118 @@
+@tool
+extends ISensor2D
+class_name RaycastSensor2D
+
+@export_flags_2d_physics var collision_mask := 1:
+ get:
+ return collision_mask
+ set(value):
+ collision_mask = value
+ _update()
+
+@export var collide_with_areas := false:
+ get:
+ return collide_with_areas
+ set(value):
+ collide_with_areas = value
+ _update()
+
+@export var collide_with_bodies := true:
+ get:
+ return collide_with_bodies
+ set(value):
+ collide_with_bodies = value
+ _update()
+
+@export var n_rays := 16.0:
+ get:
+ return n_rays
+ set(value):
+ n_rays = value
+ _update()
+
+@export_range(5, 3000, 5.0) var ray_length := 200:
+ get:
+ return ray_length
+ set(value):
+ ray_length = value
+ _update()
+@export_range(5, 360, 5.0) var cone_width := 360.0:
+ get:
+ return cone_width
+ set(value):
+ cone_width = value
+ _update()
+
+@export var debug_draw := true:
+ get:
+ return debug_draw
+ set(value):
+ debug_draw = value
+ _update()
+
+var _angles = []
+var rays := []
+
+
+func _update():
+ if Engine.is_editor_hint():
+ if debug_draw:
+ _spawn_nodes()
+ else:
+ for ray in get_children():
+ if ray is RayCast2D:
+ remove_child(ray)
+
+
+func _ready() -> void:
+ _spawn_nodes()
+
+
+func _spawn_nodes():
+ for ray in rays:
+ ray.queue_free()
+ rays = []
+
+ _angles = []
+ var step = cone_width / (n_rays)
+ var start = step / 2 - cone_width / 2
+
+ for i in n_rays:
+ var angle = start + i * step
+ var ray = RayCast2D.new()
+ ray.set_target_position(
+ Vector2(ray_length * cos(deg_to_rad(angle)), ray_length * sin(deg_to_rad(angle)))
+ )
+ ray.set_name("node_" + str(i))
+ ray.enabled = false
+ ray.collide_with_areas = collide_with_areas
+ ray.collide_with_bodies = collide_with_bodies
+ ray.collision_mask = collision_mask
+ add_child(ray)
+ rays.append(ray)
+
+ _angles.append(start + i * step)
+
+
+func get_observation() -> Array:
+ return self.calculate_raycasts()
+
+
+func calculate_raycasts() -> Array:
+ var result = []
+ for ray in rays:
+ ray.enabled = true
+ ray.force_raycast_update()
+ var distance = _get_raycast_distance(ray)
+ result.append(distance)
+ ray.enabled = false
+ return result
+
+
+func _get_raycast_distance(ray: RayCast2D) -> float:
+ if !ray.is_colliding():
+ return 0.0
+
+ var distance = (global_position - ray.get_collision_point()).length()
+ distance = clamp(distance, 0.0, ray_length)
+ return (ray_length - distance) / ray_length
diff --git a/examples/Platform2D/addons/godot_rl_agents/sensors/sensors_2d/RaycastSensor2D.tscn b/examples/Platform2D/addons/godot_rl_agents/sensors/sensors_2d/RaycastSensor2D.tscn
new file mode 100644
index 0000000..5ca402c
--- /dev/null
+++ b/examples/Platform2D/addons/godot_rl_agents/sensors/sensors_2d/RaycastSensor2D.tscn
@@ -0,0 +1,7 @@
+[gd_scene load_steps=2 format=3 uid="uid://drvfihk5esgmv"]
+
+[ext_resource type="Script" path="res://addons/godot_rl_agents/sensors/sensors_2d/RaycastSensor2D.gd" id="1"]
+
+[node name="RaycastSensor2D" type="Node2D"]
+script = ExtResource("1")
+n_rays = 17.0
diff --git a/examples/Platform2D/addons/godot_rl_agents/sensors/sensors_3d/ExampleRaycastSensor3D.tscn b/examples/Platform2D/addons/godot_rl_agents/sensors/sensors_3d/ExampleRaycastSensor3D.tscn
new file mode 100644
index 0000000..a8057c7
--- /dev/null
+++ b/examples/Platform2D/addons/godot_rl_agents/sensors/sensors_3d/ExampleRaycastSensor3D.tscn
@@ -0,0 +1,6 @@
+[gd_scene format=3 uid="uid://biu787qh4woik"]
+
+[node name="ExampleRaycastSensor3D" type="Node3D"]
+
+[node name="Camera3D" type="Camera3D" parent="."]
+transform = Transform3D(1, 0, 0, 0, 1, 0, 0, 0, 1, 0.804183, 0, 2.70146)
diff --git a/examples/Platform2D/addons/godot_rl_agents/sensors/sensors_3d/GridSensor3D.gd b/examples/Platform2D/addons/godot_rl_agents/sensors/sensors_3d/GridSensor3D.gd
new file mode 100644
index 0000000..24de9a4
--- /dev/null
+++ b/examples/Platform2D/addons/godot_rl_agents/sensors/sensors_3d/GridSensor3D.gd
@@ -0,0 +1,258 @@
+@tool
+extends ISensor3D
+class_name GridSensor3D
+
+@export var debug_view := false:
+ get:
+ return debug_view
+ set(value):
+ debug_view = value
+ _update()
+
+@export_flags_3d_physics var detection_mask := 0:
+ get:
+ return detection_mask
+ set(value):
+ detection_mask = value
+ _update()
+
+@export var collide_with_areas := false:
+ get:
+ return collide_with_areas
+ set(value):
+ collide_with_areas = value
+ _update()
+
+@export var collide_with_bodies := false:
+ # NOTE! The sensor will not detect StaticBody3D, add an area to static bodies to detect them
+ get:
+ return collide_with_bodies
+ set(value):
+ collide_with_bodies = value
+ _update()
+
+@export_range(0.1, 2, 0.1) var cell_width := 1.0:
+ get:
+ return cell_width
+ set(value):
+ cell_width = value
+ _update()
+
+@export_range(0.1, 2, 0.1) var cell_height := 1.0:
+ get:
+ return cell_height
+ set(value):
+ cell_height = value
+ _update()
+
+@export_range(1, 21, 1, "or_greater") var grid_size_x := 3:
+ get:
+ return grid_size_x
+ set(value):
+ grid_size_x = value
+ _update()
+
+@export_range(1, 21, 1, "or_greater") var grid_size_z := 3:
+ get:
+ return grid_size_z
+ set(value):
+ grid_size_z = value
+ _update()
+
+var _obs_buffer: PackedFloat64Array
+var _box_shape: BoxShape3D
+var _collision_mapping: Dictionary
+var _n_layers_per_cell: int
+
+var _highlighted_box_material: StandardMaterial3D
+var _standard_box_material: StandardMaterial3D
+
+
+func get_observation():
+ return _obs_buffer
+
+
+func reset():
+ _obs_buffer.fill(0)
+
+
+func _update():
+ if Engine.is_editor_hint():
+ if is_node_ready():
+ _spawn_nodes()
+
+
+func _ready() -> void:
+ _make_materials()
+
+ if Engine.is_editor_hint():
+ if get_child_count() == 0:
+ _spawn_nodes()
+ else:
+ _spawn_nodes()
+
+
+func _make_materials() -> void:
+ if _highlighted_box_material != null and _standard_box_material != null:
+ return
+
+ _standard_box_material = StandardMaterial3D.new()
+ _standard_box_material.set_transparency(1) # ALPHA
+ _standard_box_material.albedo_color = Color(
+ 100.0 / 255.0, 100.0 / 255.0, 100.0 / 255.0, 100.0 / 255.0
+ )
+
+ _highlighted_box_material = StandardMaterial3D.new()
+ _highlighted_box_material.set_transparency(1) # ALPHA
+ _highlighted_box_material.albedo_color = Color(
+ 255.0 / 255.0, 100.0 / 255.0, 100.0 / 255.0, 100.0 / 255.0
+ )
+
+
+func _get_collision_mapping() -> Dictionary:
+ # defines which layer is mapped to which cell obs index
+ var total_bits = 0
+ var collision_mapping = {}
+ for i in 32:
+ var bit_mask = 2 ** i
+ if (detection_mask & bit_mask) > 0:
+ collision_mapping[i] = total_bits
+ total_bits += 1
+
+ return collision_mapping
+
+
+func _spawn_nodes():
+ for cell in get_children():
+ cell.name = "_%s" % cell.name # Otherwise naming below will fail
+ cell.queue_free()
+
+ _collision_mapping = _get_collision_mapping()
+ #prints("collision_mapping", _collision_mapping, len(_collision_mapping))
+ # allocate memory for the observations
+ _n_layers_per_cell = len(_collision_mapping)
+ _obs_buffer = PackedFloat64Array()
+ _obs_buffer.resize(grid_size_x * grid_size_z * _n_layers_per_cell)
+ _obs_buffer.fill(0)
+ #prints(len(_obs_buffer), _obs_buffer )
+
+ _box_shape = BoxShape3D.new()
+ _box_shape.set_size(Vector3(cell_width, cell_height, cell_width))
+
+ var shift := Vector3(
+ -(grid_size_x / 2) * cell_width,
+ 0,
+ -(grid_size_z / 2) * cell_width,
+ )
+
+ for i in grid_size_x:
+ for j in grid_size_z:
+ var cell_position = Vector3(i * cell_width, 0.0, j * cell_width) + shift
+ _create_cell(i, j, cell_position)
+
+
+func _create_cell(i: int, j: int, position: Vector3):
+ var cell := Area3D.new()
+ cell.position = position
+ cell.name = "GridCell %s %s" % [i, j]
+
+ if collide_with_areas:
+ cell.area_entered.connect(_on_cell_area_entered.bind(i, j))
+ cell.area_exited.connect(_on_cell_area_exited.bind(i, j))
+
+ if collide_with_bodies:
+ cell.body_entered.connect(_on_cell_body_entered.bind(i, j))
+ cell.body_exited.connect(_on_cell_body_exited.bind(i, j))
+
+# cell.body_shape_entered.connect(_on_cell_body_shape_entered.bind(i, j))
+# cell.body_shape_exited.connect(_on_cell_body_shape_exited.bind(i, j))
+
+ cell.collision_layer = 0
+ cell.collision_mask = detection_mask
+ cell.monitorable = true
+ cell.input_ray_pickable = false
+ add_child(cell)
+ cell.set_owner(get_tree().edited_scene_root)
+
+ var col_shape := CollisionShape3D.new()
+ col_shape.shape = _box_shape
+ col_shape.name = "CollisionShape3D"
+ cell.add_child(col_shape)
+ col_shape.set_owner(get_tree().edited_scene_root)
+
+ if debug_view:
+ var box = MeshInstance3D.new()
+ box.name = "MeshInstance3D"
+ var box_mesh = BoxMesh.new()
+
+ box_mesh.set_size(Vector3(cell_width, cell_height, cell_width))
+ box_mesh.material = _standard_box_material
+
+ box.mesh = box_mesh
+ cell.add_child(box)
+ box.set_owner(get_tree().edited_scene_root)
+
+
+func _update_obs(cell_i: int, cell_j: int, collision_layer: int, entered: bool):
+ for key in _collision_mapping:
+ var bit_mask = 2 ** key
+ if (collision_layer & bit_mask) > 0:
+ var collison_map_index = _collision_mapping[key]
+
+ var obs_index = (
+ (cell_i * grid_size_z * _n_layers_per_cell)
+ + (cell_j * _n_layers_per_cell)
+ + collison_map_index
+ )
+ #prints(obs_index, cell_i, cell_j)
+ if entered:
+ _obs_buffer[obs_index] += 1
+ else:
+ _obs_buffer[obs_index] -= 1
+
+
+func _toggle_cell(cell_i: int, cell_j: int):
+ var cell = get_node_or_null("GridCell %s %s" % [cell_i, cell_j])
+
+ if cell == null:
+ print("cell not found, returning")
+
+ var n_hits = 0
+ var start_index = (cell_i * grid_size_z * _n_layers_per_cell) + (cell_j * _n_layers_per_cell)
+ for i in _n_layers_per_cell:
+ n_hits += _obs_buffer[start_index + i]
+
+ var cell_mesh = cell.get_node_or_null("MeshInstance3D")
+ if n_hits > 0:
+ cell_mesh.mesh.material = _highlighted_box_material
+ else:
+ cell_mesh.mesh.material = _standard_box_material
+
+
+func _on_cell_area_entered(area: Area3D, cell_i: int, cell_j: int):
+ #prints("_on_cell_area_entered", cell_i, cell_j)
+ _update_obs(cell_i, cell_j, area.collision_layer, true)
+ if debug_view:
+ _toggle_cell(cell_i, cell_j)
+ #print(_obs_buffer)
+
+
+func _on_cell_area_exited(area: Area3D, cell_i: int, cell_j: int):
+ #prints("_on_cell_area_exited", cell_i, cell_j)
+ _update_obs(cell_i, cell_j, area.collision_layer, false)
+ if debug_view:
+ _toggle_cell(cell_i, cell_j)
+
+
+func _on_cell_body_entered(body: Node3D, cell_i: int, cell_j: int):
+ #prints("_on_cell_body_entered", cell_i, cell_j)
+ _update_obs(cell_i, cell_j, body.collision_layer, true)
+ if debug_view:
+ _toggle_cell(cell_i, cell_j)
+
+
+func _on_cell_body_exited(body: Node3D, cell_i: int, cell_j: int):
+ #prints("_on_cell_body_exited", cell_i, cell_j)
+ _update_obs(cell_i, cell_j, body.collision_layer, false)
+ if debug_view:
+ _toggle_cell(cell_i, cell_j)
diff --git a/examples/Platform2D/addons/godot_rl_agents/sensors/sensors_3d/ISensor3D.gd b/examples/Platform2D/addons/godot_rl_agents/sensors/sensors_3d/ISensor3D.gd
new file mode 100644
index 0000000..aca3c2d
--- /dev/null
+++ b/examples/Platform2D/addons/godot_rl_agents/sensors/sensors_3d/ISensor3D.gd
@@ -0,0 +1,25 @@
+extends Node3D
+class_name ISensor3D
+
+var _obs: Array = []
+var _active := false
+
+
+func get_observation():
+ pass
+
+
+func activate():
+ _active = true
+
+
+func deactivate():
+ _active = false
+
+
+func _update_observation():
+ pass
+
+
+func reset():
+ pass
diff --git a/examples/Platform2D/addons/godot_rl_agents/sensors/sensors_3d/RGBCameraSensor3D.gd b/examples/Platform2D/addons/godot_rl_agents/sensors/sensors_3d/RGBCameraSensor3D.gd
new file mode 100644
index 0000000..96dfb6a
--- /dev/null
+++ b/examples/Platform2D/addons/godot_rl_agents/sensors/sensors_3d/RGBCameraSensor3D.gd
@@ -0,0 +1,63 @@
+extends Node3D
+class_name RGBCameraSensor3D
+var camera_pixels = null
+
+@onready var camera_texture := $Control/CameraTexture as Sprite2D
+@onready var processed_texture := $Control/ProcessedTexture as Sprite2D
+@onready var sub_viewport := $SubViewport as SubViewport
+@onready var displayed_image: ImageTexture
+
+@export var render_image_resolution := Vector2(36, 36)
+## Display size does not affect rendered or sent image resolution.
+## Scale is relative to either render image or downscale image resolution
+## depending on which mode is set.
+@export var displayed_image_scale_factor := Vector2(8, 8)
+
+@export_group("Downscale image options")
+## Enable to downscale the rendered image before sending the obs.
+@export var downscale_image: bool = false
+## If downscale_image is true, will display the downscaled image instead of rendered image.
+@export var display_downscaled_image: bool = true
+## This is the resolution of the image that will be sent after downscaling
+@export var resized_image_resolution := Vector2(36, 36)
+
+
+func _ready():
+ sub_viewport.size = render_image_resolution
+ camera_texture.scale = displayed_image_scale_factor
+
+ if downscale_image and display_downscaled_image:
+ camera_texture.visible = false
+ processed_texture.scale = displayed_image_scale_factor
+ else:
+ processed_texture.visible = false
+
+
+func get_camera_pixel_encoding():
+ var image := camera_texture.get_texture().get_image() as Image
+
+ if downscale_image:
+ image.resize(
+ resized_image_resolution.x, resized_image_resolution.y, Image.INTERPOLATE_NEAREST
+ )
+ if display_downscaled_image:
+ if not processed_texture.texture:
+ displayed_image = ImageTexture.create_from_image(image)
+ processed_texture.texture = displayed_image
+ else:
+ displayed_image.update(image)
+
+ return image.get_data().hex_encode()
+
+
+func get_camera_shape() -> Array:
+ var size = resized_image_resolution if downscale_image else render_image_resolution
+
+ assert(
+ size.x >= 36 and size.y >= 36,
+ "Camera sensor sent image resolution must be 36x36 or larger."
+ )
+ if sub_viewport.transparent_bg:
+ return [4, size.y, size.x]
+ else:
+ return [3, size.y, size.x]
diff --git a/examples/Platform2D/addons/godot_rl_agents/sensors/sensors_3d/RGBCameraSensor3D.tscn b/examples/Platform2D/addons/godot_rl_agents/sensors/sensors_3d/RGBCameraSensor3D.tscn
new file mode 100644
index 0000000..d58649c
--- /dev/null
+++ b/examples/Platform2D/addons/godot_rl_agents/sensors/sensors_3d/RGBCameraSensor3D.tscn
@@ -0,0 +1,35 @@
+[gd_scene load_steps=3 format=3 uid="uid://baaywi3arsl2m"]
+
+[ext_resource type="Script" path="res://addons/godot_rl_agents/sensors/sensors_3d/RGBCameraSensor3D.gd" id="1"]
+
+[sub_resource type="ViewportTexture" id="ViewportTexture_y72s3"]
+viewport_path = NodePath("SubViewport")
+
+[node name="RGBCameraSensor3D" type="Node3D"]
+script = ExtResource("1")
+
+[node name="RemoteTransform" type="RemoteTransform3D" parent="."]
+remote_path = NodePath("../SubViewport/Camera")
+
+[node name="SubViewport" type="SubViewport" parent="."]
+size = Vector2i(36, 36)
+render_target_update_mode = 3
+
+[node name="Camera" type="Camera3D" parent="SubViewport"]
+near = 0.5
+
+[node name="Control" type="Control" parent="."]
+layout_mode = 3
+anchors_preset = 15
+anchor_right = 1.0
+anchor_bottom = 1.0
+grow_horizontal = 2
+grow_vertical = 2
+metadata/_edit_use_anchors_ = true
+
+[node name="CameraTexture" type="Sprite2D" parent="Control"]
+texture = SubResource("ViewportTexture_y72s3")
+centered = false
+
+[node name="ProcessedTexture" type="Sprite2D" parent="Control"]
+centered = false
diff --git a/examples/Platform2D/addons/godot_rl_agents/sensors/sensors_3d/RaycastSensor3D.gd b/examples/Platform2D/addons/godot_rl_agents/sensors/sensors_3d/RaycastSensor3D.gd
new file mode 100644
index 0000000..1357529
--- /dev/null
+++ b/examples/Platform2D/addons/godot_rl_agents/sensors/sensors_3d/RaycastSensor3D.gd
@@ -0,0 +1,185 @@
+@tool
+extends ISensor3D
+class_name RayCastSensor3D
+@export_flags_3d_physics var collision_mask = 1:
+ get:
+ return collision_mask
+ set(value):
+ collision_mask = value
+ _update()
+@export_flags_3d_physics var boolean_class_mask = 1:
+ get:
+ return boolean_class_mask
+ set(value):
+ boolean_class_mask = value
+ _update()
+
+@export var n_rays_width := 6.0:
+ get:
+ return n_rays_width
+ set(value):
+ n_rays_width = value
+ _update()
+
+@export var n_rays_height := 6.0:
+ get:
+ return n_rays_height
+ set(value):
+ n_rays_height = value
+ _update()
+
+@export var ray_length := 10.0:
+ get:
+ return ray_length
+ set(value):
+ ray_length = value
+ _update()
+
+@export var cone_width := 60.0:
+ get:
+ return cone_width
+ set(value):
+ cone_width = value
+ _update()
+
+@export var cone_height := 60.0:
+ get:
+ return cone_height
+ set(value):
+ cone_height = value
+ _update()
+
+@export var collide_with_areas := false:
+ get:
+ return collide_with_areas
+ set(value):
+ collide_with_areas = value
+ _update()
+
+@export var collide_with_bodies := true:
+ get:
+ return collide_with_bodies
+ set(value):
+ collide_with_bodies = value
+ _update()
+
+@export var class_sensor := false
+
+var rays := []
+var geo = null
+
+
+func _update():
+ if Engine.is_editor_hint():
+ if is_node_ready():
+ _spawn_nodes()
+
+
+func _ready() -> void:
+ if Engine.is_editor_hint():
+ if get_child_count() == 0:
+ _spawn_nodes()
+ else:
+ _spawn_nodes()
+
+
+func _spawn_nodes():
+ print("spawning nodes")
+ for ray in get_children():
+ ray.queue_free()
+ if geo:
+ geo.clear()
+ #$Lines.remove_points()
+ rays = []
+
+ var horizontal_step = cone_width / (n_rays_width)
+ var vertical_step = cone_height / (n_rays_height)
+
+ var horizontal_start = horizontal_step / 2 - cone_width / 2
+ var vertical_start = vertical_step / 2 - cone_height / 2
+
+ var points = []
+
+ for i in n_rays_width:
+ for j in n_rays_height:
+ var angle_w = horizontal_start + i * horizontal_step
+ var angle_h = vertical_start + j * vertical_step
+ #angle_h = 0.0
+ var ray = RayCast3D.new()
+ var cast_to = to_spherical_coords(ray_length, angle_w, angle_h)
+ ray.set_target_position(cast_to)
+
+ points.append(cast_to)
+
+ ray.set_name("node_" + str(i) + " " + str(j))
+ ray.enabled = true
+ ray.collide_with_bodies = collide_with_bodies
+ ray.collide_with_areas = collide_with_areas
+ ray.collision_mask = collision_mask
+ add_child(ray)
+ ray.set_owner(get_tree().edited_scene_root)
+ rays.append(ray)
+ ray.force_raycast_update()
+
+
+# if Engine.editor_hint:
+# _create_debug_lines(points)
+
+
+func _create_debug_lines(points):
+ if not geo:
+ geo = ImmediateMesh.new()
+ add_child(geo)
+
+ geo.clear()
+ geo.begin(Mesh.PRIMITIVE_LINES)
+ for point in points:
+ geo.set_color(Color.AQUA)
+ geo.add_vertex(Vector3.ZERO)
+ geo.add_vertex(point)
+ geo.end()
+
+
+func display():
+ if geo:
+ geo.display()
+
+
+func to_spherical_coords(r, inc, azimuth) -> Vector3:
+ return Vector3(
+ r * sin(deg_to_rad(inc)) * cos(deg_to_rad(azimuth)),
+ r * sin(deg_to_rad(azimuth)),
+ r * cos(deg_to_rad(inc)) * cos(deg_to_rad(azimuth))
+ )
+
+
+func get_observation() -> Array:
+ return self.calculate_raycasts()
+
+
+func calculate_raycasts() -> Array:
+ var result = []
+ for ray in rays:
+ ray.set_enabled(true)
+ ray.force_raycast_update()
+ var distance = _get_raycast_distance(ray)
+
+ result.append(distance)
+ if class_sensor:
+ var hit_class: float = 0
+ if ray.get_collider():
+ var hit_collision_layer = ray.get_collider().collision_layer
+ hit_collision_layer = hit_collision_layer & collision_mask
+ hit_class = (hit_collision_layer & boolean_class_mask) > 0
+ result.append(float(hit_class))
+ ray.set_enabled(false)
+ return result
+
+
+func _get_raycast_distance(ray: RayCast3D) -> float:
+ if !ray.is_colliding():
+ return 0.0
+
+ var distance = (global_transform.origin - ray.get_collision_point()).length()
+ distance = clamp(distance, 0.0, ray_length)
+ return (ray_length - distance) / ray_length
diff --git a/examples/Platform2D/addons/godot_rl_agents/sensors/sensors_3d/RaycastSensor3D.tscn b/examples/Platform2D/addons/godot_rl_agents/sensors/sensors_3d/RaycastSensor3D.tscn
new file mode 100644
index 0000000..35f9796
--- /dev/null
+++ b/examples/Platform2D/addons/godot_rl_agents/sensors/sensors_3d/RaycastSensor3D.tscn
@@ -0,0 +1,27 @@
+[gd_scene load_steps=2 format=3 uid="uid://b803cbh1fmy66"]
+
+[ext_resource type="Script" path="res://addons/godot_rl_agents/sensors/sensors_3d/RaycastSensor3D.gd" id="1"]
+
+[node name="RaycastSensor3D" type="Node3D"]
+script = ExtResource("1")
+n_rays_width = 4.0
+n_rays_height = 2.0
+ray_length = 11.0
+
+[node name="node_1 0" type="RayCast3D" parent="."]
+target_position = Vector3(-1.38686, -2.84701, 10.5343)
+
+[node name="node_1 1" type="RayCast3D" parent="."]
+target_position = Vector3(-1.38686, 2.84701, 10.5343)
+
+[node name="node_2 0" type="RayCast3D" parent="."]
+target_position = Vector3(1.38686, -2.84701, 10.5343)
+
+[node name="node_2 1" type="RayCast3D" parent="."]
+target_position = Vector3(1.38686, 2.84701, 10.5343)
+
+[node name="node_3 0" type="RayCast3D" parent="."]
+target_position = Vector3(4.06608, -2.84701, 9.81639)
+
+[node name="node_3 1" type="RayCast3D" parent="."]
+target_position = Vector3(4.06608, 2.84701, 9.81639)
diff --git a/examples/Platform2D/addons/godot_rl_agents/sync.gd b/examples/Platform2D/addons/godot_rl_agents/sync.gd
new file mode 100644
index 0000000..f47decb
--- /dev/null
+++ b/examples/Platform2D/addons/godot_rl_agents/sync.gd
@@ -0,0 +1,598 @@
+extends Node
+class_name Sync
+
+# --fixed-fps 2000 --disable-render-loop
+
+enum ControlModes {
+ HUMAN, ## Test the environment manually
+ TRAINING, ## Train a model
+ ONNX_INFERENCE ## Load a pretrained model using an .onnx file
+}
+@export var control_mode: ControlModes = ControlModes.TRAINING
+## Action will be repeated for n frames (Godot physics steps).
+@export_range(1, 10, 1, "or_greater") var action_repeat := 8
+## Speeds up the physics in the environment to enable faster training.
+@export_range(0, 10, 0.1, "or_greater") var speed_up := 1.0
+## The path to a trained .onnx model file to use for inference (only needed for the 'Onnx Inference' control mode).
+@export var onnx_model_path := ""
+
+# Onnx model stored for each requested path
+var onnx_models: Dictionary
+
+@onready var start_time = Time.get_ticks_msec()
+
+const MAJOR_VERSION := "0"
+const MINOR_VERSION := "7"
+const DEFAULT_PORT := "11008"
+const DEFAULT_SEED := "1"
+var stream: StreamPeerTCP = null
+var connected = false
+var message_center
+var should_connect = true
+
+var all_agents: Array
+var agents_training: Array
+## Policy name of each agent, for use with multi-policy multi-agent RL cases
+var agents_training_policy_names: Array[String] = ["shared_policy"]
+var agents_inference: Array
+var agents_heuristic: Array
+
+## For recording expert demos
+var agent_demo_record: Node
+## File path for writing recorded trajectories
+var expert_demo_save_path: String
+## Stores recorded trajectories
+var demo_trajectories: Array
+## A trajectory includes obs: Array, acts: Array, terminal (set in Python env instead)
+var current_demo_trajectory: Array
+
+var need_to_send_obs = false
+var args = null
+var initialized = false
+var just_reset = false
+var onnx_model = null
+var n_action_steps = 0
+
+var _action_space_training: Array[Dictionary] = []
+var _action_space_inference: Array[Dictionary] = []
+var _obs_space_training: Array[Dictionary] = []
+
+
+# Called when the node enters the scene tree for the first time.
+func _ready():
+ await get_parent().ready
+ get_tree().set_pause(true)
+ _initialize()
+ await get_tree().create_timer(1.0).timeout
+ get_tree().set_pause(false)
+
+
+func _initialize():
+ _get_agents()
+ args = _get_args()
+ Engine.physics_ticks_per_second = _get_speedup() * 60 # Replace with function body.
+ Engine.time_scale = _get_speedup() * 1.0
+ prints(
+ "physics ticks",
+ Engine.physics_ticks_per_second,
+ Engine.time_scale,
+ _get_speedup(),
+ speed_up
+ )
+
+ _set_heuristic("human", all_agents)
+
+ _initialize_training_agents()
+ _initialize_inference_agents()
+ _initialize_demo_recording()
+
+ _set_seed()
+ _set_action_repeat()
+ initialized = true
+
+
+func _initialize_training_agents():
+ if agents_training.size() > 0:
+ _obs_space_training.resize(agents_training.size())
+ _action_space_training.resize(agents_training.size())
+ for agent_idx in range(0, agents_training.size()):
+ _obs_space_training[agent_idx] = agents_training[agent_idx].get_obs_space()
+ _action_space_training[agent_idx] = agents_training[agent_idx].get_action_space()
+ connected = connect_to_server()
+ if connected:
+ _set_heuristic("model", agents_training)
+ _handshake()
+ _send_env_info()
+ else:
+ push_warning(
+ "Couldn't connect to Python server, using human controls instead. ",
+ "Did you start the training server using e.g. `gdrl` from the console?"
+ )
+
+
+func _initialize_inference_agents():
+ if agents_inference.size() > 0:
+ if control_mode == ControlModes.ONNX_INFERENCE:
+ assert(
+ FileAccess.file_exists(onnx_model_path),
+ "Onnx Model Path set on Sync node does not exist: %s" % onnx_model_path
+ )
+ onnx_models[onnx_model_path] = ONNXModel.new(onnx_model_path, 1)
+
+ for agent in agents_inference:
+ var action_space = agent.get_action_space()
+ _action_space_inference.append(action_space)
+
+ var agent_onnx_model: ONNXModel
+ if agent.onnx_model_path.is_empty():
+ assert(
+ onnx_models.has(onnx_model_path),
+ (
+ "Node %s has no onnx model path set " % agent.get_path()
+ + "and sync node's control mode is not set to OnnxInference. "
+ + "Either add the path to the AIController, "
+ + "or if you want to use the path set on sync node instead, "
+ + "set control mode to OnnxInference."
+ )
+ )
+ prints(
+ "Info: AIController %s" % agent.get_path(),
+ "has no onnx model path set.",
+ "Using path set on the sync node instead."
+ )
+ agent_onnx_model = onnx_models[onnx_model_path]
+ else:
+ if not onnx_models.has(agent.onnx_model_path):
+ assert(
+ FileAccess.file_exists(agent.onnx_model_path),
+ (
+ "Onnx Model Path set on %s node does not exist: %s"
+ % [agent.get_path(), agent.onnx_model_path]
+ )
+ )
+ onnx_models[agent.onnx_model_path] = ONNXModel.new(agent.onnx_model_path, 1)
+ agent_onnx_model = onnx_models[agent.onnx_model_path]
+
+ agent.onnx_model = agent_onnx_model
+ if not agent_onnx_model.action_means_only_set:
+ agent_onnx_model.set_action_means_only(action_space)
+
+ _set_heuristic("model", agents_inference)
+
+
+func _initialize_demo_recording():
+ if agent_demo_record:
+ expert_demo_save_path = agent_demo_record.expert_demo_save_path
+ assert(
+ not expert_demo_save_path.is_empty(),
+ "Expert demo save path set in %s is empty." % agent_demo_record.get_path()
+ )
+
+ InputMap.add_action("RemoveLastDemoEpisode")
+ InputMap.action_add_event(
+ "RemoveLastDemoEpisode", agent_demo_record.remove_last_episode_key
+ )
+ current_demo_trajectory.resize(2)
+ current_demo_trajectory[0] = []
+ current_demo_trajectory[1] = []
+ agent_demo_record.heuristic = "demo_record"
+
+
+func _physics_process(_delta):
+ # two modes, human control, agent control
+ # pause tree, send obs, get actions, set actions, unpause tree
+
+ _demo_record_process()
+
+ if n_action_steps % action_repeat != 0:
+ n_action_steps += 1
+ return
+
+ n_action_steps += 1
+
+ _training_process()
+ _inference_process()
+ _heuristic_process()
+
+
+func _training_process():
+ if connected:
+ get_tree().set_pause(true)
+
+ var obs = _get_obs_from_agents(agents_training)
+ var info = _get_info_from_agents(agents_training)
+
+ if just_reset:
+ just_reset = false
+
+ var reply = {"type": "reset", "obs": obs, "info": info}
+ _send_dict_as_json_message(reply)
+ # this should go straight to getting the action and setting it checked the agent, no need to perform one phyics tick
+ get_tree().set_pause(false)
+ return
+
+ if need_to_send_obs:
+ need_to_send_obs = false
+ var reward = _get_reward_from_agents()
+ var done = _get_done_from_agents()
+ #_reset_agents_if_done() # this ensures the new observation is from the next env instance : NEEDS REFACTOR
+
+ var reply = {"type": "step", "obs": obs, "reward": reward, "done": done, "info": info}
+ _send_dict_as_json_message(reply)
+
+ var handled = handle_message()
+
+
+func _inference_process():
+ if agents_inference.size() > 0:
+ var obs: Array = _get_obs_from_agents(agents_inference)
+ var actions = []
+
+ for agent_id in range(0, agents_inference.size()):
+ var model: ONNXModel = agents_inference[agent_id].onnx_model
+ var action = model.run_inference(obs[agent_id]["obs"], 1.0)
+ var action_dict = _extract_action_dict(
+ action["output"], _action_space_inference[agent_id], model.action_means_only
+ )
+ actions.append(action_dict)
+
+ _set_agent_actions(actions, agents_inference)
+ _reset_agents_if_done(agents_inference)
+ get_tree().set_pause(false)
+
+
+func _demo_record_process():
+ if not agent_demo_record:
+ return
+
+ if Input.is_action_just_pressed("RemoveLastDemoEpisode"):
+ print("[Sync script][Demo recorder] Removing last recorded episode.")
+ demo_trajectories.remove_at(demo_trajectories.size() - 1)
+ print("Remaining episode count: %d" % demo_trajectories.size())
+
+ if n_action_steps % agent_demo_record.action_repeat != 0:
+ return
+
+ var obs_dict: Dictionary = agent_demo_record.get_obs()
+
+ # Get the current obs from the agent
+ assert(
+ obs_dict.has("obs"),
+ "Demo recorder needs an 'obs' key in get_obs() returned dictionary to record obs from."
+ )
+ current_demo_trajectory[0].append(obs_dict.obs)
+
+ # Get the action applied for the current obs from the agent
+ agent_demo_record.set_action()
+ var acts = agent_demo_record.get_action()
+
+ var terminal = agent_demo_record.get_done()
+ # Record actions only for non-terminal states
+ if terminal:
+ agent_demo_record.set_done_false()
+ else:
+ current_demo_trajectory[1].append(acts)
+
+ if terminal:
+ #current_demo_trajectory[2].append(true)
+ demo_trajectories.append(current_demo_trajectory.duplicate(true))
+ print("[Sync script][Demo recorder] Recorded episode count: %d" % demo_trajectories.size())
+ current_demo_trajectory[0].clear()
+ current_demo_trajectory[1].clear()
+
+
+func _heuristic_process():
+ for agent in agents_heuristic:
+ _reset_agents_if_done(agents_heuristic)
+
+
+func _extract_action_dict(action_array: Array, action_space: Dictionary, action_means_only: bool):
+ var index = 0
+ var result = {}
+ for key in action_space.keys():
+ var size = action_space[key]["size"]
+ var action_type = action_space[key]["action_type"]
+ if action_type == "discrete":
+ var largest_logit: float # Value of the largest logit for this action in the actions array
+ var largest_logit_idx: int # Index of the largest logit for this action in the actions array
+ for logit_idx in range(0, size):
+ var logit_value = action_array[index + logit_idx]
+ if logit_value > largest_logit:
+ largest_logit = logit_value
+ largest_logit_idx = logit_idx
+ result[key] = largest_logit_idx # Index of the largest logit is the discrete action value
+ index += size
+ elif action_type == "continuous":
+ # For continous actions, we only take the action mean values
+ result[key] = clamp_array(action_array.slice(index, index + size), -1.0, 1.0)
+ if action_means_only:
+ index += size # model only outputs action means, so we move index by size
+ else:
+ index += size * 2 # model outputs logstd after action mean, we skip the logstd part
+
+ else:
+ assert(
+ false,
+ (
+ 'Only "discrete" and "continuous" action types supported. Found: %s action type set.'
+ % action_type
+ )
+ )
+
+ return result
+
+
+## For AIControllers that inherit mode from sync, sets the correct mode.
+func _set_agent_mode(agent: Node):
+ var agent_inherits_mode: bool = agent.control_mode == agent.ControlModes.INHERIT_FROM_SYNC
+
+ if agent_inherits_mode:
+ match control_mode:
+ ControlModes.HUMAN:
+ agent.control_mode = agent.ControlModes.HUMAN
+ ControlModes.TRAINING:
+ agent.control_mode = agent.ControlModes.TRAINING
+ ControlModes.ONNX_INFERENCE:
+ agent.control_mode = agent.ControlModes.ONNX_INFERENCE
+
+
+func _get_agents():
+ all_agents = get_tree().get_nodes_in_group("AGENT")
+ for agent in all_agents:
+ _set_agent_mode(agent)
+
+ if agent.control_mode == agent.ControlModes.TRAINING:
+ agents_training.append(agent)
+ elif agent.control_mode == agent.ControlModes.ONNX_INFERENCE:
+ agents_inference.append(agent)
+ elif agent.control_mode == agent.ControlModes.HUMAN:
+ agents_heuristic.append(agent)
+ elif agent.control_mode == agent.ControlModes.RECORD_EXPERT_DEMOS:
+ assert(
+ not agent_demo_record,
+ "Currently only a single AIController can be used for recording expert demos."
+ )
+ agent_demo_record = agent
+
+ var training_agent_count = agents_training.size()
+ agents_training_policy_names.resize(training_agent_count)
+ for i in range(0, training_agent_count):
+ agents_training_policy_names[i] = agents_training[i].policy_name
+
+
+func _set_heuristic(heuristic, agents: Array):
+ for agent in agents:
+ agent.set_heuristic(heuristic)
+
+
+func _handshake():
+ print("performing handshake")
+
+ var json_dict = _get_dict_json_message()
+ assert(json_dict["type"] == "handshake")
+ var major_version = json_dict["major_version"]
+ var minor_version = json_dict["minor_version"]
+ if major_version != MAJOR_VERSION:
+ print("WARNING: major verison mismatch ", major_version, " ", MAJOR_VERSION)
+ if minor_version != MINOR_VERSION:
+ print("WARNING: minor verison mismatch ", minor_version, " ", MINOR_VERSION)
+
+ print("handshake complete")
+
+
+func _get_dict_json_message():
+ # returns a dictionary from of the most recent message
+ # this is not waiting
+ while stream.get_available_bytes() == 0:
+ stream.poll()
+ if stream.get_status() != 2:
+ print("server disconnected status, closing")
+ get_tree().quit()
+ return null
+
+ OS.delay_usec(10)
+
+ var message = stream.get_string()
+ var json_data = JSON.parse_string(message)
+
+ return json_data
+
+
+func _send_dict_as_json_message(dict):
+ stream.put_string(JSON.stringify(dict, "", false))
+
+
+func _send_env_info():
+ var json_dict = _get_dict_json_message()
+ assert(json_dict["type"] == "env_info")
+
+ var message = {
+ "type": "env_info",
+ "observation_space": _obs_space_training,
+ "action_space": _action_space_training,
+ "n_agents": len(agents_training),
+ "agent_policy_names": agents_training_policy_names
+ }
+ _send_dict_as_json_message(message)
+
+
+func connect_to_server():
+ print("Waiting for one second to allow server to start")
+ OS.delay_msec(1000)
+ print("trying to connect to server")
+ stream = StreamPeerTCP.new()
+
+ # "localhost" was not working on windows VM, had to use the IP
+ var ip = "127.0.0.1"
+ var port = _get_port()
+ var connect = stream.connect_to_host(ip, port)
+ stream.set_no_delay(true) # TODO check if this improves performance or not
+ stream.poll()
+ # Fetch the status until it is either connected (2) or failed to connect (3)
+ while stream.get_status() < 2:
+ stream.poll()
+ return stream.get_status() == 2
+
+
+func _get_args():
+ print("getting command line arguments")
+ var arguments = {}
+ for argument in OS.get_cmdline_args():
+ print(argument)
+ if argument.find("=") > -1:
+ var key_value = argument.split("=")
+ arguments[key_value[0].lstrip("--")] = key_value[1]
+ else:
+ # Options without an argument will be present in the dictionary,
+ # with the value set to an empty string.
+ arguments[argument.lstrip("--")] = ""
+
+ return arguments
+
+
+func _get_speedup():
+ print(args)
+ return args.get("speedup", str(speed_up)).to_float()
+
+
+func _get_port():
+ return args.get("port", DEFAULT_PORT).to_int()
+
+
+func _set_seed():
+ var _seed = args.get("env_seed", DEFAULT_SEED).to_int()
+ seed(_seed)
+
+
+func _set_action_repeat():
+ action_repeat = args.get("action_repeat", str(action_repeat)).to_int()
+
+
+func disconnect_from_server():
+ stream.disconnect_from_host()
+
+
+func handle_message() -> bool:
+ # get json message: reset, step, close
+ var message = _get_dict_json_message()
+ if message["type"] == "close":
+ print("received close message, closing game")
+ get_tree().quit()
+ get_tree().set_pause(false)
+ return true
+
+ if message["type"] == "reset":
+ print("resetting all agents")
+ _reset_agents()
+ just_reset = true
+ get_tree().set_pause(false)
+ #print("resetting forcing draw")
+# RenderingServer.force_draw()
+# var obs = _get_obs_from_agents()
+# print("obs ", obs)
+# var reply = {
+# "type": "reset",
+# "obs": obs
+# }
+# _send_dict_as_json_message(reply)
+ return true
+
+ if message["type"] == "call":
+ var method = message["method"]
+ var returns = _call_method_on_agents(method)
+ var reply = {"type": "call", "returns": returns}
+ print("calling method from Python")
+ _send_dict_as_json_message(reply)
+ return handle_message()
+
+ if message["type"] == "action":
+ var action = message["action"]
+ _set_agent_actions(action, agents_training)
+ need_to_send_obs = true
+ get_tree().set_pause(false)
+ return true
+
+ print("message was not handled")
+ return false
+
+
+func _call_method_on_agents(method):
+ var returns = []
+ for agent in all_agents:
+ returns.append(agent.call(method))
+
+ return returns
+
+
+func _reset_agents_if_done(agents = all_agents):
+ for agent in agents:
+ if agent.get_done():
+ agent.set_done_false()
+
+
+func _reset_agents(agents = all_agents):
+ for agent in agents:
+ agent.needs_reset = true
+ #agent.reset()
+
+
+func _get_obs_from_agents(agents: Array = all_agents):
+ var obs = []
+ for agent in agents:
+ obs.append(agent.get_obs())
+ return obs
+
+
+func _get_reward_from_agents(agents: Array = agents_training):
+ var rewards = []
+ for agent in agents:
+ rewards.append(agent.get_reward())
+ agent.zero_reward()
+ return rewards
+
+
+func _get_info_from_agents(agents: Array = all_agents):
+ var info = []
+ for agent in agents:
+ info.append(agent.get_info())
+ return info
+
+
+func _get_done_from_agents(agents: Array = agents_training):
+ var dones = []
+ for agent in agents:
+ var done = agent.get_done()
+ if done:
+ agent.set_done_false()
+ dones.append(done)
+ return dones
+
+
+func _set_agent_actions(actions, agents: Array = all_agents):
+ for i in range(len(actions)):
+ agents[i].set_action(actions[i])
+
+
+func clamp_array(arr: Array, min: float, max: float):
+ var output: Array = []
+ for a in arr:
+ output.append(clamp(a, min, max))
+ return output
+
+
+## Save recorded export demos on window exit (Close game window instead of "Stop" button in Godot Editor)
+func _notification(what):
+ if demo_trajectories.size() == 0 or expert_demo_save_path.is_empty():
+ return
+
+ if what == NOTIFICATION_PREDELETE:
+ var json_string = JSON.stringify(demo_trajectories, "", false)
+ var file = FileAccess.open(expert_demo_save_path, FileAccess.WRITE)
+
+ if not file:
+ var error: Error = FileAccess.get_open_error()
+ assert(not error, "There was an error opening the file: %d" % error)
+
+ file.store_line(json_string)
+ var error = file.get_error()
+ assert(not error, "There was an error after trying to write to the file: %d" % error)
diff --git a/examples/Platform2D/assets/player/jump/Player1Jump1.png b/examples/Platform2D/assets/player/jump/Player1Jump1.png
new file mode 100644
index 0000000000000000000000000000000000000000..9a1719b97398c805aadf5ca28975642b1c3b1a4e
GIT binary patch
literal 3474
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
pQtpzOcZl;QFdov#bU*5fyiSxoe^?vmrxm(
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
Cn=v5(
literal 0
HcmV?d00001
diff --git a/examples/Platform2D/assets/player/jump/Player1Jump3.png b/examples/Platform2D/assets/player/jump/Player1Jump3.png
new file mode 100644
index 0000000000000000000000000000000000000000..79cecf17fea04e2b2ce81979be9b78afd55bb73b
GIT binary patch
literal 3811
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
literal 0
HcmV?d00001
diff --git a/examples/Platform2D/assets/player/move/Player-2.png b/examples/Platform2D/assets/player/move/Player-2.png
new file mode 100644
index 0000000000000000000000000000000000000000..e750568ae37c15c16fd1b9af5bd03ba2a7fee326
GIT binary patch
literal 3727
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
V72qkczda@au(pv_sfKOX{{TNGE4csw
literal 0
HcmV?d00001
diff --git a/examples/Platform2D/assets/player/move/Player-3.png b/examples/Platform2D/assets/player/move/Player-3.png
new file mode 100644
index 0000000000000000000000000000000000000000..f9b894bb642937d92d02d61be5be1af200c00100
GIT binary patch
literal 3763
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
LG=NoU+C}~cS}P*Z
literal 0
HcmV?d00001
diff --git a/examples/Platform2D/assets/tilesheet.png b/examples/Platform2D/assets/tilesheet.png
new file mode 100644
index 0000000000000000000000000000000000000000..ee1352df4114dfd3eba1c5a0ed0836752cd8861c
GIT binary patch
literal 35040
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