Upload folder using huggingface_hub

.gitattributes

@@ -1,58 +1,5 @@
-*.7z filter=lfs diff=lfs merge=lfs -text
-*.arrow filter=lfs diff=lfs merge=lfs -text
-*.bin filter=lfs diff=lfs merge=lfs -text
-*.bz2 filter=lfs diff=lfs merge=lfs -text
-*.ckpt filter=lfs diff=lfs merge=lfs -text
-*.ftz filter=lfs diff=lfs merge=lfs -text
-*.gz filter=lfs diff=lfs merge=lfs -text
-*.h5 filter=lfs diff=lfs merge=lfs -text
-*.joblib filter=lfs diff=lfs merge=lfs -text
-*.lfs.* filter=lfs diff=lfs merge=lfs -text
-*.lz4 filter=lfs diff=lfs merge=lfs -text
-*.mlmodel filter=lfs diff=lfs merge=lfs -text
-*.model filter=lfs diff=lfs merge=lfs -text
-*.msgpack filter=lfs diff=lfs merge=lfs -text
-*.npy filter=lfs diff=lfs merge=lfs -text
-*.npz filter=lfs diff=lfs merge=lfs -text
-*.onnx filter=lfs diff=lfs merge=lfs -text
-*.ot filter=lfs diff=lfs merge=lfs -text
-*.parquet filter=lfs diff=lfs merge=lfs -text
-*.pb filter=lfs diff=lfs merge=lfs -text
-*.pickle filter=lfs diff=lfs merge=lfs -text
-*.pkl filter=lfs diff=lfs merge=lfs -text
-*.pt filter=lfs diff=lfs merge=lfs -text
-*.pth filter=lfs diff=lfs merge=lfs -text
-*.rar filter=lfs diff=lfs merge=lfs -text
-*.safetensors filter=lfs diff=lfs merge=lfs -text
-saved_model/**/* filter=lfs diff=lfs merge=lfs -text
-*.tar.* filter=lfs diff=lfs merge=lfs -text
-*.tar filter=lfs diff=lfs merge=lfs -text
-*.tflite filter=lfs diff=lfs merge=lfs -text
-*.tgz filter=lfs diff=lfs merge=lfs -text
-*.wasm filter=lfs diff=lfs merge=lfs -text
-*.xz filter=lfs diff=lfs merge=lfs -text
-*.zip filter=lfs diff=lfs merge=lfs -text
-*.zst filter=lfs diff=lfs merge=lfs -text
-*tfevents* filter=lfs diff=lfs merge=lfs -text
-# Audio files - uncompressed
-*.pcm filter=lfs diff=lfs merge=lfs -text
-*.sam filter=lfs diff=lfs merge=lfs -text
-*.raw filter=lfs diff=lfs merge=lfs -text
-# Audio files - compressed
-*.aac filter=lfs diff=lfs merge=lfs -text
-*.flac filter=lfs diff=lfs merge=lfs -text
-*.mp3 filter=lfs diff=lfs merge=lfs -text
-*.ogg filter=lfs diff=lfs merge=lfs -text
-*.wav filter=lfs diff=lfs merge=lfs -text
-# Image files - uncompressed
-*.bmp filter=lfs diff=lfs merge=lfs -text
-*.gif filter=lfs diff=lfs merge=lfs -text
-*.png filter=lfs diff=lfs merge=lfs -text
-*.tiff filter=lfs diff=lfs merge=lfs -text
-# Image files - compressed
-*.jpg filter=lfs diff=lfs merge=lfs -text
-*.jpeg filter=lfs diff=lfs merge=lfs -text
-*.webp filter=lfs diff=lfs merge=lfs -text
-# Video files - compressed
-*.mp4 filter=lfs diff=lfs merge=lfs -text
-*.webm filter=lfs diff=lfs merge=lfs -text
+# Normalize EOL for all files that Git considers text files.
+* text=auto eol=lf
+addons/godot_rl_agents/icon.png filter=lfs diff=lfs merge=lfs -text
+onnx/platform_onnx/model.onnx filter=lfs diff=lfs merge=lfs -text
+onnx/player_onnx/model.onnx filter=lfs diff=lfs merge=lfs -text

.gitignore

@@ -0,0 +1,3 @@
+# Godot 4+ specific ignores
+.godot/
+android/

MultiAgentTestEnv.csproj

@@ -0,0 +1,10 @@
+<Project Sdk="Godot.NET.Sdk/4.3.0-dev.5">
+  <PropertyGroup>
+    <TargetFramework>net6.0</TargetFramework>
+    <EnableDynamicLoading>true</EnableDynamicLoading>
+    <RootNamespace>GodotRLAgents</RootNamespace>
+  </PropertyGroup>
+  <ItemGroup>
+    <PackageReference Include="Microsoft.ML.OnnxRuntime" Version="1.16.3" />
+  </ItemGroup>
+</Project>

MultiAgentTestEnv.sln

@@ -0,0 +1,19 @@
+Microsoft Visual Studio Solution File, Format Version 12.00
+# Visual Studio 2012
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "RobotEnv", "RobotEnv.csproj", "{C8D3517D-AA7F-40D8-B8D8-6FD3D270B2B9}"
+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
+		{C8D3517D-AA7F-40D8-B8D8-6FD3D270B2B9}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{C8D3517D-AA7F-40D8-B8D8-6FD3D270B2B9}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{C8D3517D-AA7F-40D8-B8D8-6FD3D270B2B9}.ExportDebug|Any CPU.ActiveCfg = ExportDebug|Any CPU
+		{C8D3517D-AA7F-40D8-B8D8-6FD3D270B2B9}.ExportDebug|Any CPU.Build.0 = ExportDebug|Any CPU
+		{C8D3517D-AA7F-40D8-B8D8-6FD3D270B2B9}.ExportRelease|Any CPU.ActiveCfg = ExportRelease|Any CPU
+		{C8D3517D-AA7F-40D8-B8D8-6FD3D270B2B9}.ExportRelease|Any CPU.Build.0 = ExportRelease|Any CPU
+	EndGlobalSection
+EndGlobal

README.md

@@ -0,0 +1,25 @@
+---
+library_name: godot-rl
+tags:
+- deep-reinforcement-learning
+- reinforcement-learning
+- godot-rl
+- environments
+- video-games
+---
+
+A RL environment called MultiAgentSimple for the Godot Game Engine.
+
+This environment was created with: https://github.com/edbeeching/godot_rl_agents 
+
+
+## Downloading the environment 
+
+After installing Godot RL Agents, download the environment with: 
+
+```
+gdrl.env_from_hub -r jtatman/godot_rl_MultiAgentSimple
+```
+
+
+

addons/godot_rl_agents/controller/ai_controller_2d.gd

@@ -0,0 +1,119 @@
+extends Node2D
+class_name AIController2D
+
+enum ControlModes { INHERIT_FROM_SYNC, HUMAN, TRAINING, ONNX_INFERENCE, RECORD_EXPERT_DEMOS }
+@export var control_mode: ControlModes = ControlModes.INHERIT_FROM_SYNC
+@export var onnx_model_path := ""
+@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
+
+
+#-- 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 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")
+
+
+#-----------------------------------------------------------------------------#
+
+
+#-- 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 []
+
+# -----------------------------------------------------------------------------#
+
+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

addons/godot_rl_agents/controller/ai_controller_3d.gd

@@ -0,0 +1,120 @@
+extends Node3D
+class_name AIController3D
+
+enum ControlModes { INHERIT_FROM_SYNC, HUMAN, TRAINING, ONNX_INFERENCE, RECORD_EXPERT_DEMOS }
+@export var control_mode: ControlModes = ControlModes.INHERIT_FROM_SYNC
+@export var onnx_model_path := ""
+@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
+
+
+#-- 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")
+
+
+#-----------------------------------------------------------------------------#
+
+
+#-- 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 []
+
+# -----------------------------------------------------------------------------#
+
+
+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

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")

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
+{
+	/// <include file='docs/ONNXInference.xml' path='docs/members[@name="ONNXInference"]/ONNXInference/*'/>
+	public partial class ONNXInference : GodotObject
+	{
+
+		private InferenceSession session;
+		/// <summary>
+		/// Path to the ONNX model. Use Initialize to change it. 
+		/// </summary>
+		private string modelPath;
+		private int batchSize;
+
+		private SessionOptions SessionOpt;
+
+        /// <summary>
+        /// init function
+        /// </summary>
+        /// <param name="Path"></param>
+        /// <param name="BatchSize"></param>
+        /// <returns>Returns the output size of the model</returns>
+        public int Initialize(string Path, int BatchSize)
+		{
+			modelPath = Path;
+			batchSize = BatchSize;
+            SessionOpt = SessionConfigurator.MakeConfiguredSessionOptions();
+            session = LoadModel(modelPath);
+            return session.OutputMetadata["output"].Dimensions[1];
+        }
+
+
+		/// <include file='docs/ONNXInference.xml' path='docs/members[@name="ONNXInference"]/Run/*'/>
+		public Godot.Collections.Dictionary<string, Godot.Collections.Array<float>> RunInference(Godot.Collections.Array<float> 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<NamedOnnxValue> inputs = new List<NamedOnnxValue>
+			{
+			NamedOnnxValue.CreateFromTensor("obs", new DenseTensor<float>(span, new int[] { batchSize, obs.Count })),
+			NamedOnnxValue.CreateFromTensor("state_ins", new DenseTensor<float>(new float[] { state_ins }, new int[] { batchSize }))
+			};
+			IReadOnlyCollection<string> outputNames = new List<string> { "output", "state_outs" }; //ONNX is sensible to these names, as well as the input names
+
+			IDisposableReadOnlyCollection<DisposableNamedOnnxValue> 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<float> to Variant, so we have to convert it to an array or something
+			Godot.Collections.Dictionary<string, Godot.Collections.Array<float>> output = new Godot.Collections.Dictionary<string, Godot.Collections.Array<float>>();
+			DisposableNamedOnnxValue output1 = results.First();
+			DisposableNamedOnnxValue output2 = results.Last();
+			Godot.Collections.Array<float> output1Array = new Godot.Collections.Array<float>();
+			Godot.Collections.Array<float> output2Array = new Godot.Collections.Array<float>();
+
+			foreach (float f in output1.AsEnumerable<float>())
+			{
+				output1Array.Add(f);
+			}
+
+			foreach (float f in output2.AsEnumerable<float>())
+			{
+				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;
+		}
+		/// <include file='docs/ONNXInference.xml' path='docs/members[@name="ONNXInference"]/Load/*'/>
+		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();
+		}
+	}
+}

addons/godot_rl_agents/onnx/csharp/SessionConfigurator.cs

@@ -0,0 +1,131 @@
+using Godot;
+using Microsoft.ML.OnnxRuntime;
+
+namespace GodotONNX
+{
+	/// <include file='docs/SessionConfigurator.xml' path='docs/members[@name="SessionConfigurator"]/SessionConfigurator/*'/>
+
+	public static class SessionConfigurator
+	{
+		public enum ComputeName
+		{
+			CUDA,
+			ROCm,
+			DirectML,
+			CoreML,
+			CPU
+		}
+
+        /// <include file='docs/SessionConfigurator.xml' path='docs/members[@name="SessionConfigurator"]/GetSessionOptions/*'/>
+        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);
+        }
+
+        /// <include file='docs/SessionConfigurator.xml' path='docs/members[@name="SessionConfigurator"]/SystemCheck/*'/>
+        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;
+            }
+            */
+        }
+
+
+        /// <include file='docs/SessionConfigurator.xml' path='docs/members[@name="SessionConfigurator"]/ComputeCheck/*'/>
+        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;
+		}
+	}
+}

addons/godot_rl_agents/onnx/csharp/docs/ONNXInference.xml

@@ -0,0 +1,31 @@
+<docs>
+	<members name="ONNXInference">
+		<ONNXInference>
+			<summary>
+       		The main <c>ONNXInference</c> Class that handles the inference process.
+        	</summary>
+		</ONNXInference>
+   		<Initialize>
+        	<summary>
+			Starts the inference process. 
+			</summary>
+			<param name="Path">Path to the ONNX model, expects a path inside resources.</param>
+			<param name="BatchSize">How many observations will the model recieve.</param>
+		</Initialize>
+		<Run>
+			<summary>
+			Runs the given input through the model and returns the output.
+			</summary>
+			<param name="obs">Dictionary containing all observations.</param>
+			<param name="state_ins">How many different agents are creating these observations.</param>
+			<returns>A Dictionary of arrays, containing instructions based on the observations.</returns>
+		</Run>
+		<Load>
+			<summary>
+			Loads the given model into the inference process, using the best Execution provider available.
+			</summary>
+			<param name="Path">Path to the ONNX model, expects a path inside resources.</param>
+			<returns>InferenceSession ready to run.</returns>
+		</Load>
+	</members>
+</docs>

addons/godot_rl_agents/onnx/csharp/docs/SessionConfigurator.xml

@@ -0,0 +1,29 @@
+<docs>
+	<members name="SessionConfigurator">
+		<SessionConfigurator>
+			<summary>
+       		The main <c>SessionConfigurator</c> Class that handles the execution options and providers for the inference process.
+        	</summary>
+		</SessionConfigurator>
+  		<GetSessionOptions>
+    	    <summary>
+    	    Creates a SessionOptions with all available execution providers.
+    	    </summary>
+			<returns>SessionOptions with all available execution providers.</returns>
+    	</GetSessionOptions>
+    	<SystemCheck>
+        	<summary>
+        	Appends any execution provider available in the current system.  
+        	</summary>
+			<remarks>
+				This function is mainly verbose for tracking implementation progress of different compute APIs. 
+			</remarks>
+    	</SystemCheck>
+    	<ComputeCheck>
+        	<summary>
+        		Checks for available GPUs.
+        	</summary>
+			<returns>An integer identifier for each compute platform.</returns>
+    	</ComputeCheck>
+	</members>
+</docs>

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

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"

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")

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_x * _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_x * _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)

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

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

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

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)

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, 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_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_x * _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_x * _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)

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

addons/godot_rl_agents/sensors/sensors_3d/RGBCameraSensor3D.gd

@@ -0,0 +1,21 @@
+extends Node3D
+class_name RGBCameraSensor3D
+var camera_pixels = null
+
+@onready var camera_texture := $Control/TextureRect/CameraTexture as Sprite2D
+@onready var sub_viewport := $SubViewport as SubViewport
+
+
+func get_camera_pixel_encoding():
+	return camera_texture.get_texture().get_image().get_data().hex_encode()
+
+
+func get_camera_shape() -> Array:
+	assert(
+		sub_viewport.size.x >= 36 and sub_viewport.size.y >= 36,
+		"SubViewport size must be 36x36 or larger."
+	)
+	if sub_viewport.transparent_bg:
+		return [4, sub_viewport.size.y, sub_viewport.size.x]
+	else:
+		return [3, sub_viewport.size.y, sub_viewport.size.x]

addons/godot_rl_agents/sensors/sensors_3d/RGBCameraSensor3D.tscn

@@ -0,0 +1,41 @@
+[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="1"]
+viewport_path = NodePath("SubViewport")
+
+[node name="RGBCameraSensor3D" type="Node3D"]
+script = ExtResource("1")
+
+[node name="RemoteTransform3D" type="RemoteTransform3D" parent="."]
+remote_path = NodePath("../SubViewport/Camera3D")
+
+[node name="SubViewport" type="SubViewport" parent="."]
+size = Vector2i(32, 32)
+render_target_update_mode = 3
+
+[node name="Camera3D" 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
+
+[node name="TextureRect" type="ColorRect" parent="Control"]
+layout_mode = 0
+offset_left = 1096.0
+offset_top = 534.0
+offset_right = 1114.0
+offset_bottom = 552.0
+scale = Vector2(10, 10)
+color = Color(0.00784314, 0.00784314, 0.00784314, 1)
+
+[node name="CameraTexture" type="Sprite2D" parent="Control/TextureRect"]
+texture = SubResource("1")
+offset = Vector2(9, 9)
+flip_v = true

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

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)

addons/godot_rl_agents/sync.gd

@@ -0,0 +1,579 @@
+extends Node
+
+# --fixed-fps 2000 --disable-render-loop
+
+enum ControlModes { HUMAN, TRAINING, ONNX_INFERENCE }
+@export var control_mode: ControlModes = ControlModes.TRAINING
+@export_range(1, 10, 1, "or_greater") var action_repeat := 8
+@export_range(0, 10, 0.1, "or_greater") var speed_up := 1.0
+@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_tree().root.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)
+
+		if just_reset:
+			just_reset = false
+			var obs = _get_obs_from_agents(agents_training)
+
+			var reply = {"type": "reset", "obs": obs}
+			_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 obs = _get_obs_from_agents(agents_training)
+
+			var reply = {"type": "step", "obs": obs, "reward": reward, "done": done}
+			_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_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)

license.md

@@ -0,0 +1,5 @@
+MultiAgent Simple environment made by https://github.com/Ivan-267.
+
+The following license is only for the graphical assets in the folder "assets", including .glb format files:
+Author: Ivan Dodic (https://github.com/Ivan-267), 
+License: https://creativecommons.org/licenses/by/4.0/

onnx/platform_onnx/model.onnx

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:6dd705240611b375bf5de8ffbe43adb56ee600685b87120be350513a01bfbb2f
+size 22676

onnx/player_onnx/model.onnx

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:cf3db421d81e88303f449ef57f04408cf652d2cef2b191ea10a25d3d33ad3857
+size 32412

project.godot

@@ -0,0 +1,61 @@
+; Engine configuration file.
+; It's best edited using the editor UI and not directly,
+; since the parameters that go here are not all obvious.
+;
+; Format:
+;   [section] ; section goes between []
+;   param=value ; assign values to parameters
+
+config_version=5
+
+[application]
+
+config/name="MultiAgentSimple"
+run/main_scene="res://scenes/training_scene/training_scene.tscn"
+config/features=PackedStringArray("4.3", "C#", "Forward Plus")
+config/icon="res://icon.svg"
+
+[dotnet]
+
+project/assembly_name="MultiAgentTestEnv"
+
+[editor_plugins]
+
+enabled=PackedStringArray("res://addons/godot_rl_agents/plugin.cfg")
+
+[global_group]
+
+resetable=""
+
+[input]
+
+platform_left={
+"deadzone": 0.5,
+"events": [Object(InputEventKey,"resource_local_to_scene":false,"resource_name":"","device":-1,"window_id":0,"alt_pressed":false,"shift_pressed":false,"ctrl_pressed":false,"meta_pressed":false,"pressed":false,"keycode":0,"physical_keycode":4194319,"key_label":0,"unicode":0,"location":0,"echo":false,"script":null)
+]
+}
+platform_right={
+"deadzone": 0.5,
+"events": [Object(InputEventKey,"resource_local_to_scene":false,"resource_name":"","device":-1,"window_id":0,"alt_pressed":false,"shift_pressed":false,"ctrl_pressed":false,"meta_pressed":false,"pressed":false,"keycode":0,"physical_keycode":4194321,"key_label":0,"unicode":0,"location":0,"echo":false,"script":null)
+]
+}
+robot_left={
+"deadzone": 0.5,
+"events": [Object(InputEventKey,"resource_local_to_scene":false,"resource_name":"","device":-1,"window_id":0,"alt_pressed":false,"shift_pressed":false,"ctrl_pressed":false,"meta_pressed":false,"pressed":false,"keycode":0,"physical_keycode":65,"key_label":0,"unicode":97,"location":0,"echo":false,"script":null)
+]
+}
+robot_right={
+"deadzone": 0.5,
+"events": [Object(InputEventKey,"resource_local_to_scene":false,"resource_name":"","device":-1,"window_id":0,"alt_pressed":false,"shift_pressed":false,"ctrl_pressed":false,"meta_pressed":false,"pressed":false,"keycode":0,"physical_keycode":68,"key_label":0,"unicode":100,"location":0,"echo":false,"script":null)
+]
+}
+robot_forward={
+"deadzone": 0.5,
+"events": [Object(InputEventKey,"resource_local_to_scene":false,"resource_name":"","device":-1,"window_id":0,"alt_pressed":false,"shift_pressed":false,"ctrl_pressed":false,"meta_pressed":false,"pressed":false,"keycode":0,"physical_keycode":87,"key_label":0,"unicode":119,"location":0,"echo":false,"script":null)
+]
+}
+robot_back={
+"deadzone": 0.5,
+"events": [Object(InputEventKey,"resource_local_to_scene":false,"resource_name":"","device":-1,"window_id":0,"alt_pressed":false,"shift_pressed":false,"ctrl_pressed":false,"meta_pressed":false,"pressed":false,"keycode":0,"physical_keycode":83,"key_label":0,"unicode":115,"location":0,"echo":false,"script":null)
+]
+}

readme.md

@@ -0,0 +1,78 @@
+# MultiAgent Simple Environment
+
+https://github.com/edbeeching/godot_rl_agents_examples/assets/61947090/0ce8e667-124d-4c99-8136-e139b4a5aaca
+
+## Goal:
+
+The robot agent needs to reach the goal (marked by a transparent green square) as many times as possible during the episode. It needs to work together with the platform agent to be able to reach static platforms. Goal position switches to the other static platform after being reached. 
+
+### Rewards:
+
+All agents (AIController pairs for each batch) receive the same rewards, including:
+
+- A negative reward for the robot falling,
+- A positive reward for reaching the goal position,
+- A reward every step based on the change in distance between the robot and the goal (positive for approaching, negative for moving away from).
+
+## Episode end condition:
+
+Episodes have a fixed length and end at the same time for all agents.
+
+## Agents:
+
+### Robot:
+
+![robot](https://github.com/edbeeching/godot_rl_agents_examples/assets/61947090/a046de7d-3714-4593-9fc4-9d9dd8e3054e)
+
+
+Policy name: `player`
+
+### Actions:
+
+Robot has continuous actions for movement in 2 axes.
+
+```python
+func get_action_space() -> Dictionary:
+	return {
+		"movement": {"size": 2, "action_type": "continuous"},
+	}
+```
+
+### Observations:
+
+Robot has a Raycast sensor for observations, and has additional observations including the relative positions of the goal and platform agent, as well as its own and the platform agent’s velocities.
+
+### Platform:
+
+![Platform](https://github.com/edbeeching/godot_rl_agents_examples/assets/61947090/238aacd4-dcec-4c27-9f0c-f8f409289704)
+
+Policy name: `platform`
+
+### Actions:
+
+Platform has a single continuous action for movement.
+
+```python
+func get_action_space() -> Dictionary:
+	return {
+		"movement": {"size": 1, "action_type": "continuous"},
+	}
+```
+
+### Observations:
+
+Platform’s observations include the relative positions of the goal and robot agent, as well as its own and the robot agent’s velocities.
+
+### Onnx inference:
+
+To run the included trained model, open `res://scenes/testing_scene/testing_scene.tscn` in Godot Editor and press F6. 
+
+If you want to change the paths to run your own onnx file in a different folder, you can adjust them in `res://scenes/game_scene/game_scene_onnx_inference.tscn` > `PlayerAIController` and `PlatformAIController` inspector properties.
+
+### Training:
+
+Training this scene is currently only supported using the [Rllib example](https://github.com/edbeeching/godot_rl_agents/blob/main/examples/rllib_example.py) (`env_is_multiagent` should be set to `true` in the config file, and you can adjust the stopping criteria and other settings as needed).
+
+Here are some stats from the session that was used to get the trained onnx model (for testing a single worker / env instance was used and the training time was likely longer than required). Steps are env steps, since there are multiple agents using each policy in the env, there are many more total agent steps than env steps:
+
+![Training stats](https://github.com/edbeeching/godot_rl_agents_examples/assets/61947090/6b7005aa-ddc4-4f7e-bc7e-4a0d0d1b4c28)

scenes/game_scene/game_scene.tscn

@@ -0,0 +1,61 @@
+[gd_scene load_steps=8 format=3 uid="uid://tpt7yljsu6ei"]
+
+[ext_resource type="Script" path="res://scenes/game_scene/game_scene_manager.gd" id="1_7f2j4"]
+[ext_resource type="PackedScene" uid="uid://byg2il8fbav13" path="res://assets/platform.glb" id="2_1mict"]
+[ext_resource type="PackedScene" uid="uid://bpgscnt6a3c2" path="res://scenes/player/player.tscn" id="3_hmuow"]
+[ext_resource type="PackedScene" uid="uid://u16gxctwsq88" path="res://scenes/platform/platform.tscn" id="4_imy8y"]
+[ext_resource type="PackedScene" uid="uid://duqqne2b1we3x" path="res://scenes/goal/goal.tscn" id="5_j8srg"]
+
+[sub_resource type="BoxShape3D" id="BoxShape3D_ajlrv"]
+size = Vector3(4, 1, 4)
+
+[sub_resource type="BoxShape3D" id="BoxShape3D_3o3mb"]
+size = Vector3(4, 1, 4)
+
+[node name="GameScene" type="Node3D" node_paths=PackedStringArray("AIControllers", "player_goal_spawn_positions")]
+script = ExtResource("1_7f2j4")
+AIControllers = [NodePath("PlayerAIController"), NodePath("PlatformAIController")]
+player_goal_spawn_positions = [NodePath("platform"), NodePath("platform2")]
+
+[node name="platform" type="StaticBody3D" parent="."]
+
+[node name="platform" parent="platform" instance=ExtResource("2_1mict")]
+transform = Transform3D(2, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0)
+
+[node name="CollisionShape3D" type="CollisionShape3D" parent="platform"]
+shape = SubResource("BoxShape3D_ajlrv")
+
+[node name="platform2" type="StaticBody3D" parent="."]
+transform = Transform3D(1, 0, 0, 0, 1, 0, 0, 0, 1, 18, 0, 0)
+
+[node name="platform" parent="platform2" instance=ExtResource("2_1mict")]
+transform = Transform3D(2, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0)
+
+[node name="CollisionShape3D" type="CollisionShape3D" parent="platform2"]
+shape = SubResource("BoxShape3D_3o3mb")
+
+[node name="Goal" parent="." node_paths=PackedStringArray("game_manager", "player_ai_controller") instance=ExtResource("5_j8srg")]
+collision_mask = 2
+monitorable = false
+game_manager = NodePath("..")
+player_ai_controller = NodePath("../PlayerAIController")
+
+[node name="PlayerAIController" parent="." node_paths=PackedStringArray("game_manager", "platform_ai_controller", "goal") instance=ExtResource("3_hmuow")]
+transform = Transform3D(1, 0, 0, 0, 1, 0, 0, 0, 1, 0, 1.6, 0)
+game_manager = NodePath("..")
+platform_ai_controller = NodePath("../PlatformAIController")
+goal = NodePath("../Goal")
+onnx_model_path = ""
+
+[node name="PlatformAIController" parent="." node_paths=PackedStringArray("game_manager", "goal", "player_ai_controller") instance=ExtResource("4_imy8y")]
+transform = Transform3D(1, 0, 0, 0, 1, 0, 0, 0, 1, 8.3, 0.362, 0)
+game_manager = NodePath("..")
+goal = NodePath("../Goal")
+player_ai_controller = NodePath("../PlayerAIController")
+onnx_model_path = ""
+
+[node name="Camera3D" type="Camera3D" parent="."]
+transform = Transform3D(0.999701, -0.00611733, 0.023654, 0, 0.968148, 0.25038, -0.0244322, -0.250305, 0.967859, 9.475, 6.297, 10.476)
+fov = 64.9
+
+[connection signal="body_entered" from="Goal" to="PlayerAIController" method="_on_goal_body_entered"]

scenes/game_scene/game_scene_manager.gd

@@ -0,0 +1,36 @@
+extends Node3D
+class_name GameSceneManager
+
+@export var AIControllers: Array[Node]
+
+## Used by the player and goal to calculate new positions
+@export var player_goal_spawn_positions: Array[Node3D]
+
+var resetables: Array
+var steps := 0
+var max_steps := 100
+
+## Value set by training manager
+var training_manager: TrainingManager
+
+
+func _ready():
+	for node in find_children("*"):
+		if node.is_in_group("resetable"):
+			resetables.append(node)
+
+
+func reset_game(reward = 0, done = false):
+	for agent in AIControllers:
+		agent.reward += reward
+		if done:
+			agent.done = true
+		agent.reset()
+
+	for resetable in resetables:
+		resetable.reset()
+
+
+func set_agents_rewards(reward = 0):
+	for agent in AIControllers:
+		agent.reward += reward

scenes/game_scene/game_scene_onnx_inference.tscn

@@ -0,0 +1,25 @@
+[gd_scene load_steps=2 format=3 uid="uid://xomproo2eyut"]
+
+[ext_resource type="PackedScene" uid="uid://tpt7yljsu6ei" path="res://scenes/game_scene/game_scene.tscn" id="1_eys64"]
+
+[node name="GameScene" node_paths=PackedStringArray("AIControllers", "player_goal_spawn_positions") instance=ExtResource("1_eys64")]
+AIControllers = [NodePath("PlayerAIController"), NodePath("PlatformAIController")]
+player_goal_spawn_positions = [NodePath("platform"), NodePath("platform2")]
+
+[node name="Goal" parent="." index="2" node_paths=PackedStringArray("game_manager", "player_ai_controller")]
+game_manager = NodePath("..")
+player_ai_controller = NodePath("../PlayerAIController")
+
+[node name="PlayerAIController" parent="." index="3" node_paths=PackedStringArray("game_manager", "platform_ai_controller", "goal")]
+game_manager = NodePath("..")
+platform_ai_controller = NodePath("../PlatformAIController")
+goal = NodePath("../Goal")
+control_mode = 3
+onnx_model_path = "onnx\\player_onnx\\model.onnx"
+
+[node name="PlatformAIController" parent="." index="4" node_paths=PackedStringArray("game_manager", "goal", "player_ai_controller")]
+game_manager = NodePath("..")
+goal = NodePath("../Goal")
+player_ai_controller = NodePath("../PlayerAIController")
+control_mode = 3
+onnx_model_path = "onnx\\platform_onnx\\model.onnx"

scenes/goal/goal.gd

@@ -0,0 +1,23 @@
+extends Area3D
+class_name Goal
+
+@onready var initial_position = global_position
+@export var game_manager: GameSceneManager
+@export var player_ai_controller: PlayerAIController
+
+## Nodes that this goal will spawn on (it will reset to the platform that has the largest distance from the player)
+@onready var spawn_positions := game_manager.player_goal_spawn_positions
+
+
+func reset():
+	await get_tree().physics_frame  # Wait a physics frame before moving to avoid detecting player on reset
+	var farthest_distance: float = 0.0
+	var farthest_node: Node3D
+	for node in spawn_positions:
+		var distance = node.global_position.distance_squared_to(
+			player_ai_controller.player.global_position
+		)
+		if distance > farthest_distance:
+			farthest_distance = distance
+			farthest_node = node
+	global_position = farthest_node.global_position + Vector3.UP * 1.5

scenes/goal/goal.tscn

@@ -0,0 +1,28 @@
+[gd_scene load_steps=5 format=3 uid="uid://duqqne2b1we3x"]
+
+[ext_resource type="Script" path="res://scenes/goal/goal.gd" id="1_k3tuu"]
+
+[sub_resource type="BoxShape3D" id="BoxShape3D_n45yr"]
+size = Vector3(1, 2, 1)
+
+[sub_resource type="StandardMaterial3D" id="StandardMaterial3D_hko7p"]
+transparency = 1
+albedo_color = Color(0, 1, 0, 0.282353)
+
+[sub_resource type="BoxMesh" id="BoxMesh_myqp0"]
+material = SubResource("StandardMaterial3D_hko7p")
+size = Vector3(1, 2, 1)
+
+[node name="Goal" type="Area3D" node_paths=PackedStringArray("game_manager", "player") groups=["resetable"]]
+transform = Transform3D(1, 0, 0, 0, 1, 0, 0, 0, 1, 18, 1.5, 0)
+collision_layer = 0
+script = ExtResource("1_k3tuu")
+game_manager = NodePath("")
+player = NodePath("")
+
+[node name="CollisionShape3D" type="CollisionShape3D" parent="."]
+shape = SubResource("BoxShape3D_n45yr")
+
+[node name="MeshInstance3D" type="MeshInstance3D" parent="."]
+mesh = SubResource("BoxMesh_myqp0")
+skeleton = NodePath("../..")

scenes/platform/platform.gd

@@ -0,0 +1,16 @@
+extends CharacterBody3D
+class_name Platform
+
+@export var speed := 8.0
+# Visual rotation speed of the propeller
+@export var propeller_rotation_speed := 1.0
+
+@onready var propeller = $flying_platform/flying_platform/Torus/propeller
+
+var requested_movement: float
+
+
+func _physics_process(delta: float) -> void:
+	velocity = Vector3.RIGHT * requested_movement * speed
+	move_and_slide()
+	propeller.rotate_object_local(Vector3.UP, propeller_rotation_speed * speed)

scenes/platform/platform.tscn

@@ -0,0 +1,25 @@
+[gd_scene load_steps=5 format=3 uid="uid://u16gxctwsq88"]
+
+[ext_resource type="Script" path="res://scenes/platform/platform_ai_controller.gd" id="1_u84vt"]
+[ext_resource type="Script" path="res://scenes/platform/platform.gd" id="2_6qscy"]
+[ext_resource type="PackedScene" uid="uid://b8k5wlite2uag" path="res://assets/flying_platform.glb" id="3_pn8gp"]
+
+[sub_resource type="BoxShape3D" id="BoxShape3D_xu28c"]
+size = Vector3(3.8, 0.5, 3)
+
+[node name="PlatformAIController" type="Node3D"]
+script = ExtResource("1_u84vt")
+policy_name = "platform"
+
+[node name="Platform" type="CharacterBody3D" parent="."]
+collision_mask = 3
+axis_lock_linear_y = true
+motion_mode = 1
+wall_min_slide_angle = 0.0523599
+script = ExtResource("2_6qscy")
+
+[node name="flying_platform" parent="Platform" instance=ExtResource("3_pn8gp")]
+
+[node name="CollisionShape3D" type="CollisionShape3D" parent="Platform"]
+transform = Transform3D(1, 0, 0, 0, 1, 0, 0, 0, 1, 0, -0.110486, 0)
+shape = SubResource("BoxShape3D_xu28c")

scenes/platform/platform_ai_controller.gd

@@ -0,0 +1,71 @@
+extends AIController3D
+class_name PlatformAIController
+
+@export var game_manager: GameSceneManager
+@export var goal: Goal
+@export var player_ai_controller: PlayerAIController
+
+@onready var platform: Platform = $Platform
+@onready var initial_position = position
+
+
+func get_obs() -> Dictionary:
+	var obs: Array
+	var goal_relative = (platform.to_local(goal.global_position) / 20.0).limit_length(1.0)
+	var player_relative = (
+		(platform.to_local(player_ai_controller.player.global_position) / 10.0).limit_length(1.0)
+	)
+
+	var platform_velocity = platform.velocity.limit_length(platform.speed) / platform.speed
+	var player_speed = player_ai_controller.player.speed
+	var player_velocity = player_ai_controller.player.velocity.limit_length(player_speed) / player_speed
+	obs.append_array(
+		[
+			goal_relative.x,
+			goal_relative.y,
+			goal_relative.z,
+			player_relative.x,
+			player_relative.y,
+			player_relative.z,
+			platform_velocity.x,
+			platform_velocity.y,
+			platform_velocity.z,
+			player_velocity.x,
+			player_velocity.y,
+			player_velocity.z
+		]
+	)
+	return {"obs": obs}
+
+
+func get_reward() -> float:
+	return reward
+
+
+func get_action_space() -> Dictionary:
+	return {
+		"movement": {"size": 1, "action_type": "continuous"},
+	}
+
+
+func _physics_process(delta: float) -> void:
+	super._physics_process(delta)
+	if heuristic == "human":
+		set_action()
+
+
+func set_action(action = null) -> void:
+	if action == null:
+		platform.requested_movement = (
+			Input.get_action_strength("platform_right") - Input.get_action_strength("platform_left")
+		)
+		return
+
+	platform.requested_movement = clamp(action.movement[0], -1.0, 1.0)
+
+
+func reset():
+	super.reset()
+	position = position
+	platform.position = Vector3.ZERO
+	platform.velocity = Vector3.ZERO

scenes/player/player.gd

@@ -0,0 +1,50 @@
+extends CharacterBody3D
+class_name Player
+
+@export var speed = 3.0
+@export var gravity_strength = 10.0
+@export var visual_rotation_update_speed = 8.0
+@export var wheels: Array[Node3D]
+
+var requested_movement: Vector2
+var requested_jump: bool
+
+@onready var robot_visual = $robot
+
+## Value set by AIController
+var game_manager: GameSceneManager
+var last_movement_direction: Vector3
+
+
+func _physics_process(delta: float) -> void:
+	if global_position.y < -5:
+		game_manager.reset_game(-5, false)
+
+	if not is_on_floor():
+		velocity += Vector3.DOWN * gravity_strength * delta
+
+	velocity.x = requested_movement.x * speed
+	velocity.z = requested_movement.y * speed
+
+	if velocity:
+		last_movement_direction = Vector3(requested_movement.x, 0, requested_movement.y)
+
+	_update_visual_rotation(delta)
+	_update_wheels_rotation(delta)
+	move_and_slide()
+
+
+func _update_visual_rotation(delta):
+	var direction: Vector3 = last_movement_direction
+
+	if direction:
+		var target_basis := Basis.looking_at(direction)
+		robot_visual.global_basis = robot_visual.global_basis.orthonormalized().slerp(
+			target_basis, delta * visual_rotation_update_speed
+		)
+
+
+func _update_wheels_rotation(delta):
+	var movement := Vector2(requested_movement.x, requested_movement.y).length()
+	for wheel in wheels:
+		wheel.rotate_object_local(Vector3.LEFT, movement * speed * delta * 2.0)

scenes/player/player.tscn

@@ -0,0 +1,145 @@
+[gd_scene load_steps=6 format=3 uid="uid://bpgscnt6a3c2"]
+
+[ext_resource type="Script" path="res://scenes/player/player_ai_controller.gd" id="1_chk3m"]
+[ext_resource type="Script" path="res://scenes/player/player.gd" id="2_fh5nj"]
+[ext_resource type="PackedScene" uid="uid://doqudr33pr7we" path="res://assets/robot.glb" id="3_lvsyl"]
+[ext_resource type="Script" path="res://addons/godot_rl_agents/sensors/sensors_3d/RaycastSensor3D.gd" id="4_bgl3b"]
+
+[sub_resource type="CapsuleShape3D" id="CapsuleShape3D_uiics"]
+radius = 0.67
+height = 1.981
+
+[node name="PlayerAIController" type="Node3D"]
+script = ExtResource("1_chk3m")
+policy_name = "player"
+
+[node name="Player" type="CharacterBody3D" parent="." node_paths=PackedStringArray("wheels")]
+collision_layer = 2
+collision_mask = 3
+script = ExtResource("2_fh5nj")
+speed = 5.0
+visual_rotation_update_speed = 5.0
+wheels = [NodePath("robot/Wheel_001"), NodePath("robot/Wheel")]
+
+[node name="robot" parent="Player" instance=ExtResource("3_lvsyl")]
+transform = Transform3D(-4.37114e-08, 0, -1, 0, 1, 0, 1, 0, -4.37114e-08, 0, -0.608908, 0)
+
+[node name="CollisionShape3D" type="CollisionShape3D" parent="Player"]
+shape = SubResource("CapsuleShape3D_uiics")
+
+[node name="RayCastSensor3D" type="Node3D" parent="Player"]
+transform = Transform3D(1, 0, 0, 0, -4.37114e-08, -1, 0, 1, -4.37114e-08, 0, 1, 0)
+script = ExtResource("4_bgl3b")
+ray_length = 8.0
+cone_width = 160.0
+cone_height = 160.0
+
+[node name="@RayCast3D@69341" type="RayCast3D" parent="Player/RayCastSensor3D"]
+target_position = Vector3(-2.90949, -7.34573, 1.25503)
+
+[node name="@RayCast3D@69342" type="RayCast3D" parent="Player/RayCastSensor3D"]
+target_position = Vector3(-5.62715, -5.1423, 2.42732)
+
+[node name="@RayCast3D@69343" type="RayCast3D" parent="Player/RayCastSensor3D"]
+target_position = Vector3(-7.14772, -1.84493, 3.08323)
+
+[node name="@RayCast3D@69344" type="RayCast3D" parent="Player/RayCastSensor3D"]
+target_position = Vector3(-7.14772, 1.84493, 3.08323)
+
+[node name="@RayCast3D@69345" type="RayCast3D" parent="Player/RayCastSensor3D"]
+target_position = Vector3(-5.62715, 5.1423, 2.42732)
+
+[node name="@RayCast3D@69346" type="RayCast3D" parent="Player/RayCastSensor3D"]
+target_position = Vector3(-2.90949, 7.34573, 1.25503)
+
+[node name="@RayCast3D@69347" type="RayCast3D" parent="Player/RayCastSensor3D"]
+target_position = Vector3(-2.03676, -7.34573, 2.42732)
+
+[node name="@RayCast3D@69348" type="RayCast3D" parent="Player/RayCastSensor3D"]
+target_position = Vector3(-3.93923, -5.1423, 4.69459)
+
+[node name="@RayCast3D@69349" type="RayCast3D" parent="Player/RayCastSensor3D"]
+target_position = Vector3(-5.00369, -1.84493, 5.96316)
+
+[node name="@RayCast3D@69350" type="RayCast3D" parent="Player/RayCastSensor3D"]
+target_position = Vector3(-5.00369, 1.84493, 5.96316)
+
+[node name="@RayCast3D@69351" type="RayCast3D" parent="Player/RayCastSensor3D"]
+target_position = Vector3(-3.93923, 5.1423, 4.69459)
+
+[node name="@RayCast3D@69352" type="RayCast3D" parent="Player/RayCastSensor3D"]
+target_position = Vector3(-2.03676, 7.34573, 2.42732)
+
+[node name="@RayCast3D@69353" type="RayCast3D" parent="Player/RayCastSensor3D"]
+target_position = Vector3(-0.730738, -7.34573, 3.08323)
+
+[node name="@RayCast3D@69354" type="RayCast3D" parent="Player/RayCastSensor3D"]
+target_position = Vector3(-1.4133, -5.1423, 5.96316)
+
+[node name="@RayCast3D@69355" type="RayCast3D" parent="Player/RayCastSensor3D"]
+target_position = Vector3(-1.7952, -1.84493, 7.57453)
+
+[node name="@RayCast3D@69356" type="RayCast3D" parent="Player/RayCastSensor3D"]
+target_position = Vector3(-1.7952, 1.84493, 7.57453)
+
+[node name="@RayCast3D@69357" type="RayCast3D" parent="Player/RayCastSensor3D"]
+target_position = Vector3(-1.4133, 5.1423, 5.96316)
+
+[node name="@RayCast3D@69358" type="RayCast3D" parent="Player/RayCastSensor3D"]
+target_position = Vector3(-0.730738, 7.34573, 3.08323)
+
+[node name="node_3 0" type="RayCast3D" parent="Player/RayCastSensor3D"]
+target_position = Vector3(0.730738, -7.34573, 3.08323)
+
+[node name="node_3 1" type="RayCast3D" parent="Player/RayCastSensor3D"]
+target_position = Vector3(1.4133, -5.1423, 5.96316)
+
+[node name="node_3 2" type="RayCast3D" parent="Player/RayCastSensor3D"]
+target_position = Vector3(1.7952, -1.84493, 7.57453)
+
+[node name="@RayCast3D@69359" type="RayCast3D" parent="Player/RayCastSensor3D"]
+target_position = Vector3(1.7952, 1.84493, 7.57453)
+
+[node name="@RayCast3D@69360" type="RayCast3D" parent="Player/RayCastSensor3D"]
+target_position = Vector3(1.4133, 5.1423, 5.96316)
+
+[node name="@RayCast3D@69361" type="RayCast3D" parent="Player/RayCastSensor3D"]
+target_position = Vector3(0.730738, 7.34573, 3.08323)
+
+[node name="node_4 0" type="RayCast3D" parent="Player/RayCastSensor3D"]
+target_position = Vector3(2.03676, -7.34573, 2.42732)
+
+[node name="node_4 1" type="RayCast3D" parent="Player/RayCastSensor3D"]
+target_position = Vector3(3.93923, -5.1423, 4.69459)
+
+[node name="node_4 2" type="RayCast3D" parent="Player/RayCastSensor3D"]
+target_position = Vector3(5.00369, -1.84493, 5.96316)
+
+[node name="@RayCast3D@69362" type="RayCast3D" parent="Player/RayCastSensor3D"]
+target_position = Vector3(5.00369, 1.84493, 5.96316)
+
+[node name="@RayCast3D@69363" type="RayCast3D" parent="Player/RayCastSensor3D"]
+target_position = Vector3(3.93923, 5.1423, 4.69459)
+
+[node name="@RayCast3D@69364" type="RayCast3D" parent="Player/RayCastSensor3D"]
+target_position = Vector3(2.03676, 7.34573, 2.42732)
+
+[node name="node_5 0" type="RayCast3D" parent="Player/RayCastSensor3D"]
+target_position = Vector3(2.90949, -7.34573, 1.25503)
+
+[node name="node_5 1" type="RayCast3D" parent="Player/RayCastSensor3D"]
+target_position = Vector3(5.62715, -5.1423, 2.42732)
+
+[node name="node_5 2" type="RayCast3D" parent="Player/RayCastSensor3D"]
+target_position = Vector3(7.14772, -1.84493, 3.08323)
+
+[node name="@RayCast3D@69365" type="RayCast3D" parent="Player/RayCastSensor3D"]
+target_position = Vector3(7.14772, 1.84493, 3.08323)
+
+[node name="@RayCast3D@69366" type="RayCast3D" parent="Player/RayCastSensor3D"]
+target_position = Vector3(5.62715, 5.1423, 2.42732)
+
+[node name="@RayCast3D@69367" type="RayCast3D" parent="Player/RayCastSensor3D"]
+target_position = Vector3(2.90949, 7.34573, 1.25503)
+
+[editable path="Player/robot"]

scenes/player/player_ai_controller.gd

@@ -0,0 +1,100 @@
+extends AIController3D
+class_name PlayerAIController
+
+@export var game_manager: GameSceneManager
+@export var platform_ai_controller: PlatformAIController
+@export var goal: Goal
+
+@onready var player: Player = $Player
+@onready var raycast_sensor = $Player/RayCastSensor3D
+@onready var spawn_positions = game_manager.player_goal_spawn_positions
+
+var previous_distance_to_goal
+
+
+func _ready():
+	super._ready()
+	player.game_manager = game_manager
+
+
+func get_obs() -> Dictionary:
+	var obs: Array
+	obs.append_array(raycast_sensor.get_observation())
+	var platform: Platform = platform_ai_controller.platform
+	var platform_relative = (player.to_local(platform.global_position) / 10.0).limit_length(1.0)
+	var goal_relative = (player.to_local(goal.global_position) / 20.0).limit_length(1.0)
+
+	var player_velocity = player.velocity.limit_length(player.speed) / player.speed
+	var platform_velocity = platform.velocity.limit_length(platform.speed) / platform.speed
+
+	obs.append_array(
+		[
+			goal_relative.x,
+			goal_relative.y,
+			goal_relative.z,
+			platform_relative.x,
+			platform_relative.y,
+			platform_relative.z,
+			player_velocity.x,
+			player_velocity.y,
+			player_velocity.z,
+			platform_velocity.x,
+			platform_velocity.y,
+			platform_velocity.z
+		]
+	)
+
+	return {"obs": obs}
+
+
+func get_reward() -> float:
+	var distance_to_goal = player.global_position.distance_to(goal.global_position)
+
+	if not previous_distance_to_goal:
+		previous_distance_to_goal = distance_to_goal
+
+	#if distance_to_goal < previous_distance_to_goal:
+	game_manager.set_agents_rewards(previous_distance_to_goal - distance_to_goal)
+	previous_distance_to_goal = distance_to_goal
+
+	return reward
+
+
+func reset():
+	super.reset()
+	previous_distance_to_goal = null
+
+	global_position = spawn_positions.pick_random().global_position + Vector3.UP * 1.5
+	player.position = Vector3.ZERO
+	player.velocity = Vector3.ZERO
+
+
+func get_action_space() -> Dictionary:
+	return {
+		"movement": {"size": 2, "action_type": "continuous"},
+	}
+
+
+func _physics_process(delta: float) -> void:
+	super._physics_process(delta)
+	if heuristic == "human":
+		set_action()
+
+
+func set_action(action = null) -> void:
+	if action == null:
+		player.requested_movement = Input.get_vector(
+			"robot_left", "robot_right", "robot_forward", "robot_back"
+		)
+		return
+
+	player.requested_movement = Vector2(
+		clamp(action.movement[0], -1.0, 1.0), clamp(action.movement[1], -1.0, 1.0)
+	)
+
+
+func _on_goal_body_entered(body: Node3D) -> void:
+	if body is Player:
+		goal.reset()
+		game_manager.set_agents_rewards(5)
+		previous_distance_to_goal = null

scenes/testing_scene/testing_scene.tscn

@@ -0,0 +1,35 @@
+[gd_scene load_steps=7 format=3 uid="uid://n5fft12lumgd"]
+
+[ext_resource type="Script" path="res://scenes/training_scene/training_manager.gd" id="1_1k23j"]
+[ext_resource type="PackedScene" uid="uid://xomproo2eyut" path="res://scenes/game_scene/game_scene_onnx_inference.tscn" id="2_u86wc"]
+[ext_resource type="Script" path="res://addons/godot_rl_agents/sync.gd" id="3_p180x"]
+
+[sub_resource type="ProceduralSkyMaterial" id="ProceduralSkyMaterial_riw1h"]
+sky_horizon_color = Color(0.64625, 0.65575, 0.67075, 1)
+ground_horizon_color = Color(0.64625, 0.65575, 0.67075, 1)
+
+[sub_resource type="Sky" id="Sky_qx0n5"]
+sky_material = SubResource("ProceduralSkyMaterial_riw1h")
+
+[sub_resource type="Environment" id="Environment_b3cgd"]
+background_mode = 2
+sky = SubResource("Sky_qx0n5")
+tonemap_mode = 2
+glow_enabled = true
+
+[node name="TestingScene" type="Node3D"]
+script = ExtResource("1_1k23j")
+reset_after_steps = 1800
+game_scene_to_instantiate = ExtResource("2_u86wc")
+scene_count = 3
+offset_between_scenes = Vector3(0, 0, -20)
+
+[node name="Sync" type="Node" parent="."]
+script = ExtResource("3_p180x")
+
+[node name="DirectionalLight3D" type="DirectionalLight3D" parent="."]
+transform = Transform3D(-0.866023, -0.433016, 0.250001, 0, 0.499998, 0.866027, -0.500003, 0.749999, -0.43301, 0, 0, 0)
+shadow_enabled = true
+
+[node name="WorldEnvironment" type="WorldEnvironment" parent="."]
+environment = SubResource("Environment_b3cgd")

scenes/training_scene/training_manager.gd

@@ -0,0 +1,36 @@
+extends Node3D
+class_name TrainingManager
+
+## Manages multiple GameScenes.
+
+## Resets all game scenes at this many steps and ends episode
+@export var reset_after_steps := 300
+
+@export var game_scene_to_instantiate: PackedScene
+@export var scene_count: int = 8
+@export var offset_between_scenes: Vector3
+
+# Physics steps since game started
+var _steps := 0
+
+var _game_scenes: Array[GameSceneManager]
+
+
+func _ready():
+	var current_position = offset_between_scenes
+	for i in range(0, scene_count):
+		var new_instance = game_scene_to_instantiate.instantiate() as GameSceneManager
+		add_child(new_instance, true)
+		new_instance.training_manager = self
+		new_instance.global_position += current_position
+		current_position += offset_between_scenes
+		new_instance.reset_game(0, false)  # Reset game initially to randomize positions
+		_game_scenes.append(new_instance)
+
+
+func _physics_process(delta: float) -> void:
+	_steps += 1
+	if _steps > reset_after_steps:
+		for game_scene in _game_scenes:
+			game_scene.reset_game(0, true)
+			_steps = 0