Upload folder using huggingface_hub

AIController3D.gd

@@ -0,0 +1,63 @@
+extends AIController3D
+
+
+func _physics_process(_delta):
+	n_steps += 1
+	if n_steps >= reset_after:
+		done = true
+		needs_reset = true
+
+	if needs_reset:
+		_player.game_over()
+
+
+func get_obs():
+	var goal_distance = 0.0
+	var goal_position = Vector3.ZERO
+	if _player.next == 0:
+		goal_distance = _player.position.distance_to(_player.first_jump_pad.position)
+		goal_position = _player.first_jump_pad.global_position
+
+	if _player.next == 1:
+		goal_distance = _player.position.distance_to(_player.second_jump_pad.position)
+		goal_position = _player.second_jump_pad.global_position
+
+
+	var goal_vector = _player.to_local(goal_position).normalized()
+
+	goal_distance = clamp(goal_distance, 0.0, 20.0)
+	var obs = []
+	obs.append_array(
+		[
+			_player.move_vec.x / _player.MOVE_SPEED,
+			_player.move_vec.y / _player.MAX_FALL_SPEED,
+			_player.move_vec.z / _player.MOVE_SPEED
+		]
+	)
+	obs.append_array([goal_distance / 20.0, goal_vector.x, goal_vector.y, goal_vector.z])
+	obs.append(_player.grounded)
+	obs.append_array(_player.raycast_sensor.get_observation())
+
+	return {
+		"obs": obs,
+	}
+
+
+func set_action(action):
+	_player.move_action = action["move"][0]
+	_player.turn_action = action["turn"][0]
+	_player.jump_action = action["jump"][0] > 0
+
+
+func get_action_space():
+	return {
+		"jump": {"size": 1, "action_type": "continuous"},
+		"move": {"size": 1, "action_type": "continuous"},
+		"turn": {"size": 1, "action_type": "continuous"}
+	}
+
+
+func get_reward():
+	var current_reward = reward
+	reward = 0  # reset the reward to zero checked every decision step
+	return current_reward

JumperHard.csproj

@@ -1,4 +1,4 @@
-<Project Sdk="Godot.NET.Sdk/4.1.1">
+<Project Sdk="Godot.NET.Sdk/4.2.1">
   <PropertyGroup>
     <TargetFramework>net6.0</TargetFramework>
     <EnableDynamicLoading>true</EnableDynamicLoading>

JumperHard.csproj.old

@@ -1,4 +1,4 @@
-<Project Sdk="Godot.NET.Sdk/4.0.2">
+<Project Sdk="Godot.NET.Sdk/4.1.3">
   <PropertyGroup>
     <TargetFramework>net6.0</TargetFramework>
     <EnableDynamicLoading>true</EnableDynamicLoading>

Player.gd

@@ -5,7 +5,6 @@ const JUMP_FORCE = 30
 const GRAVITY = 0.98
 const MAX_FALL_SPEED = 30
 const TURN_SENS = 2.0
-const MAX_STEPS = 20000
 
 @onready var cam = $Camera3D
 var move_vec = Vector3()
@@ -17,198 +16,130 @@ var needs_reset = false
 @onready var first_jump_pad = $"../Pads/FirstPad"
 @onready var second_jump_pad = $"../Pads/SecondPad"
 @onready var robot = $Robot
+@onready var ai_controller = $AIController3D
 
 var next = 1
-var done = false
 var just_reached_end = false
 var just_reached_next = false
 var just_fell_off = false
 var best_goal_distance := 10000.0
 var grounded := false
-var _heuristic := "player"
 var move_action := 0.0
 var turn_action := 0.0
 var jump_action := false
-var n_steps = 0
-var _goal_vec = null
-var reward = 0.0
+
 
 func _ready():
+	ai_controller.init(self)
 	raycast_sensor.activate()
-	reset()
+	game_over()
 
-#func _process(_delta):
-#	if _goal_vec != null:
-#		DebugDraw.draw_line_3d(position, position + (_goal_vec*10), Color(1, 1, 0))
 
 func _physics_process(_delta):
-	
-	#reward = 0.0
-	n_steps +=1    
-	if n_steps >= MAX_STEPS:
-		done = true
-		needs_reset = true
-
-	if needs_reset:
-		needs_reset = false
-		reset()
-		return
-	
-	
-	move_vec *= 0
 	move_vec = get_move_vec()
-	#move_vec = move_vec.normalized()
 	move_vec = move_vec.rotated(Vector3(0, 1, 0), rotation.y)
 	move_vec *= MOVE_SPEED
 	move_vec.y = y_velo
 	set_velocity(move_vec)
 	set_up_direction(Vector3(0, 1, 0))
 	move_and_slide()
-	
+
 	# turning
-	
+
 	var turn_vec = get_turn_vec()
-	rotation.y += deg_to_rad(turn_vec*TURN_SENS)
- 
+	rotation.y += deg_to_rad(turn_vec * TURN_SENS)
+
 	grounded = is_on_floor()
 
 	y_velo -= GRAVITY
-	var just_jumped = false
 	if grounded and get_jump_action():
 		robot.set_animation("jump")
-		just_jumped = true
 		y_velo = JUMP_FORCE
 		grounded = false
 	if grounded and y_velo <= 0:
 		y_velo = -0.1
 	if y_velo < -MAX_FALL_SPEED:
 		y_velo = -MAX_FALL_SPEED
-	
-	if y_velo < 0 and !grounded :
+
+	if y_velo < 0 and !grounded:
 		robot.set_animation("falling")
-	
+
 	var horizontal_speed = Vector2(move_vec.x, move_vec.z)
 	if horizontal_speed.length() < 0.1 and grounded:
 		robot.set_animation("idle")
 	elif horizontal_speed.length() < 1.0 and grounded:
-		robot.set_animation("walk")    
+		robot.set_animation("walk")
 	elif horizontal_speed.length() >= 1.0 and grounded:
 		robot.set_animation("run")
-	
+
 	update_reward()
-	
+
 	if Input.is_action_just_pressed("r_key"):
-		reset()
-		
+		game_over()
+
 
 func get_move_vec() -> Vector3:
-	if done:
-		move_vec = Vector3.ZERO
-		return move_vec
-	
-	if _heuristic == "model":
-		return Vector3(
-		0,
-		0,
-		clamp(move_action, -1.0, 0.5)
-	)
-		
-	var move_vec := Vector3(
+	if ai_controller.done:
+		return Vector3.ZERO
+
+	if ai_controller.heuristic == "model":
+		return Vector3(0, 0, clamp(move_action, -1.0, 0.5))
+
+	return Vector3(
 		0,
 		0,
-		clamp(Input.get_action_strength("move_backwards") - Input.get_action_strength("move_forwards"),-1.0, 0.5)
-		
+		clamp(
+			(
+				Input.get_action_strength("move_backwards")
+				- Input.get_action_strength("move_forwards")
+			),
+			-1.0,
+			0.5
+		)
 	)
-	return move_vec
+
 
 func get_turn_vec() -> float:
-	if _heuristic == "model":
+	if ai_controller.heuristic == "model":
 		return turn_action
-	var rotation_amount = Input.get_action_strength("turn_left") - Input.get_action_strength("turn_right")
+	var rotation_amount = (
+		Input.get_action_strength("turn_left") - Input.get_action_strength("turn_right")
+	)
 
 	return rotation_amount
-	
+
+
 func get_jump_action() -> bool:
-	if done:
+	if ai_controller.done:
 		jump_action = false
 		return jump_action
-		
-	if _heuristic == "model":
-		return jump_action  
-	
+
+	if ai_controller.heuristic == "model":
+		return jump_action
+
 	return Input.is_action_just_pressed("jump")
-  
-func reset():
-	needs_reset = false
+
+
+func game_over():
 	next = 1
-	n_steps = 0
 	first_jump_pad.position = Vector3.ZERO
-	second_jump_pad.position = Vector3(0,0,-12)
+	second_jump_pad.position = Vector3(0, 0, -12)
 	just_reached_end = false
 	just_fell_off = false
 	jump_action = false
 
-	set_position(Vector3(0,5,0))
-	rotation.y = deg_to_rad(randf_range(-180,180))
+	set_position(Vector3(0, 5, 0))
+	rotation.y = deg_to_rad(randf_range(-180, 180))
 	y_velo = 0.1
 	reset_best_goal_distance()
-	
-func set_action(action):
-	move_action = action["move"][0]
-	turn_action = action["turn"][0]
-	jump_action = action["jump"] == 1
-	
-func reset_if_done():
-	if done:
-		reset()
-
-func get_obs():
-	var goal_distance = 0.0
-	var goal_vector = Vector3.ZERO
-	if next == 0:
-		goal_distance = position.distance_to(first_jump_pad.position)
-		goal_vector = (first_jump_pad.position - position).normalized()
-		
-	if next == 1:
-		goal_distance = position.distance_to(second_jump_pad.position)
-		goal_vector = (second_jump_pad.position - position).normalized()
-	
-	goal_vector = goal_vector.rotated(Vector3.UP, -rotation.y)
-	
-	goal_distance = clamp(goal_distance, 0.0, 20.0)
-	var obs = []
-	obs.append_array([move_vec.x/MOVE_SPEED,
-					move_vec.y/MAX_FALL_SPEED,
-					move_vec.z/MOVE_SPEED])
-	obs.append_array([goal_distance/20.0,
-					goal_vector.x, 
-					goal_vector.y, 
-					goal_vector.z])
-	obs.append(grounded)
-	obs.append_array(raycast_sensor.get_observation())
-	
-	return {
-		"obs": obs,
-	}
-	
-func get_obs_space():
-	# typs of obs space: box, discrete, repeated
-	return {
-		"obs": {
-			"size": [len(get_obs()["obs"])],
-			"space": "box"
-			}
-		}
-	
+	ai_controller.reset()
+
+
 func update_reward():
-	reward -= 0.01 # step penalty
-	reward += shaping_reward()
-	
-func get_reward():
-	var current_reward = reward
-	reward = 0 # reset the reward to zero checked every decision step
-	return current_reward
-	
+	ai_controller.reward -= 0.01  # step penalty
+	ai_controller.reward += shaping_reward()
+
+
 func shaping_reward():
 	var s_reward = 0.0
 	var goal_distance = 0
@@ -220,75 +151,46 @@ func shaping_reward():
 	if goal_distance < best_goal_distance:
 		s_reward += best_goal_distance - goal_distance
 		best_goal_distance = goal_distance
-		
+
 	s_reward /= 1.0
-	return s_reward   
+	return s_reward
+
 
 func reset_best_goal_distance():
 	if next == 0:
 		best_goal_distance = position.distance_to(first_jump_pad.position)
 	if next == 1:
-		best_goal_distance = position.distance_to(second_jump_pad.position)    
-
-func set_heuristic(heuristic):
-	self._heuristic = heuristic
-
-func get_obs_size():
-	return len(get_obs())
-	
-func zero_reward():
-	reward = 0
-   
-func get_action_space():
-	return {
-		"move" : {
-			"size": 1,
-			"action_type": "continuous"
-		},        
-			"turn" : {
-			"size": 1,
-			"action_type": "continuous"
-		},
-		"jump": {
-			"size": 2,
-			"action_type": "discrete"
-			}
-		}
-
-func get_done():
-	return done
-	
-func set_done_false():
-	done = false
-
-func calculate_translation(other_pad_translation : Vector3) -> Vector3:
+		best_goal_distance = position.distance_to(second_jump_pad.position)
+
+
+func calculate_translation(other_pad_translation: Vector3) -> Vector3:
 	var new_translation := Vector3.ZERO
-	var distance = randf_range(12,16)
-	var angle = randf_range(-180,180)
-	new_translation.z = other_pad_translation.z + sin(deg_to_rad(angle))*distance 
-	new_translation.x = other_pad_translation.x + cos(deg_to_rad(angle))*distance
-	
+	var distance = randf_range(12, 16)
+	var angle = randf_range(-180, 180)
+	new_translation.z = other_pad_translation.z + sin(deg_to_rad(angle)) * distance
+	new_translation.x = other_pad_translation.x + cos(deg_to_rad(angle)) * distance
+
 	return new_translation
 
 
-func _on_First_Pad_Trigger_body_entered(body):
+func _on_First_Pad_Trigger_body_entered(_body):
 	if next != 0:
 		return
-	reward += 100.0
+	ai_controller.reward += 100.0
 	next = 1
 	reset_best_goal_distance()
 	second_jump_pad.position = calculate_translation(first_jump_pad.position)
 
-func _on_Second_Trigger_body_entered(body):
+
+func _on_Second_Trigger_body_entered(_body):
 	if next != 1:
 		return
-	reward += 100.0
+	ai_controller.reward += 100.0
 	next = 0
 	reset_best_goal_distance()
 	first_jump_pad.position = calculate_translation(second_jump_pad.position)
-		
 
 
-func _on_ResetTriggerBox_body_entered(body):
-	done = true
-	reset()
+func _on_ResetTriggerBox_body_entered(_body):
+	ai_controller.done = true
+	game_over()

Player.tscn

@@ -1,8 +1,9 @@
-[gd_scene load_steps=8 format=3 uid="uid://btjelqxpc6evr"]
+[gd_scene load_steps=9 format=3 uid="uid://btjelqxpc6evr"]
 
 [ext_resource type="Script" path="res://Player.gd" id="1"]
 [ext_resource type="Script" path="res://addons/godot_rl_agents/sensors/sensors_3d/RaycastSensor3D.gd" id="3"]
 [ext_resource type="PackedScene" uid="uid://dmvrtwu4ml51r" path="res://robot2.tscn" id="3_pt6ta"]
+[ext_resource type="Script" path="res://AIController3D.gd" id="4_grup7"]
 
 [sub_resource type="CapsuleShape3D" id="CapsuleShape3D_k5nui"]
 
@@ -20,7 +21,7 @@ ambient_light_energy = 0.79
 tonemap_mode = 3
 glow_intensity = 0.65
 
-[node name="Player" type="CharacterBody3D" groups=["AGENT"]]
+[node name="Player" type="CharacterBody3D"]
 transform = Transform3D(1, 0, 0, 0, 1, 0, 0, 0, 1, 0, 1, 0)
 script = ExtResource("1")
 
@@ -478,3 +479,7 @@ target_position = Vector3(6.14364, 6.92623, 11.8018)
 
 [node name="Robot" parent="." instance=ExtResource("3_pt6ta")]
 transform = Transform3D(-1.5, 0, -2.26494e-07, 0, 1.5, 0, 2.26494e-07, 0, -1.5, 0, -0.951698, 0)
+
+[node name="AIController3D" type="Node3D" parent="."]
+script = ExtResource("4_grup7")
+reset_after = 20000

Robot.gd

@@ -1,16 +1,8 @@
 extends Node3D
 
 
-# Declare member variables here. Examples:
-# var a = 2
-# var b = "text"
-
 @onready var player = $AnimationPlayer
 
-# Called when the node enters the scene tree for the first time.
-func _ready():
-	pass # Replace with function body.
-
 func set_animation(anim):
 	if player.current_animation == anim:
 		return

addons/godot_rl_agents/controller/ai_controller_2d.gd

@@ -1,8 +1,82 @@
-extends AIController
+extends Node2D
 class_name AIController2D
 
-# ------------------ Godot RL Agents Logic ------------------------------------#
+@export var reset_after := 1000
+
+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 get set_action method is not implemented when extending from ai_controller") 	
+# -----------------------------------------------------------------------------#
+	
+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

@@ -1,8 +1,80 @@
-extends AIController
+extends Node3D
 class_name AIController3D
 
-# ------------------ Godot RL Agents Logic ------------------------------------#
+@export var reset_after := 1000
+
+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 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 get set_action method is not implemented when extending from ai_controller") 	
+# -----------------------------------------------------------------------------#
+	
+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/icon.png.import

@@ -2,7 +2,7 @@
 
 importer="texture"
 type="CompressedTexture2D"
-uid="uid://bxj7outrsyldm"
+uid="uid://btyhe25nk3d13"
 path="res://.godot/imported/icon.png-45a871b53434e556222f5901d598ab34.ctex"
 metadata={
 "vram_texture": false

addons/godot_rl_agents/onnx/csharp/ONNXInference.cs

@@ -1,93 +1,103 @@
 using Godot;
-using System.Collections.Generic;
-using System.Linq;
 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 : Node
+namespace GodotONNX
 {
-		
-	private InferenceSession session;
-	/// <summary>
-	/// Path to the ONNX model. Use Initialize to change it. 
-	/// </summary>
-	private string modelPath;
-	private int batchSize;
+	/// <include file='docs/ONNXInference.xml' path='docs/members[@name="ONNXInference"]/ONNXInference/*'/>
+	public partial class ONNXInference : GodotObject
+	{
 
-	private SessionOptions SessionOpt;
+		private InferenceSession session;
+		/// <summary>
+		/// Path to the ONNX model. Use Initialize to change it. 
+		/// </summary>
+		private string modelPath;
+		private int batchSize;
 
-	//init function
-/// <include file='docs/ONNXInference.xml' path='docs/members[@name="ONNXInference"]/Initialize/*'/>
-	public void Initialize(string Path, int BatchSize)
-	{
-		modelPath = Path;
-		batchSize = BatchSize;
-		SessionConfigurator.SystemCheck();
-		SessionOpt = SessionConfigurator.GetSessionOptions();
-		session = LoadModel(modelPath);
+		private SessionOptions SessionOpt;
 
-	}
-/// <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++)
+		//init function
+		/// <include file='docs/ONNXInference.xml' path='docs/members[@name="ONNXInference"]/Initialize/*'/>
+		public void Initialize(string Path, int BatchSize)
 		{
-			span[i] = obs[i];
+			modelPath = Path;
+			batchSize = BatchSize;
+            SessionOpt = SessionConfigurator.MakeConfiguredSessionOptions();
+            session = LoadModel(modelPath);
+
 		}
-				
-		IReadOnlyCollection<NamedOnnxValue> inputs = new List<NamedOnnxValue> 
+		/// <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
+			};
+			IReadOnlyCollection<string> outputNames = new List<string> { "output", "state_outs" }; //ONNX is sensible to these names, as well as the input names
 
-			IDisposableReadOnlyCollection<DisposableNamedOnnxValue> results;
-		
-		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>();
+			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 output1.AsEnumerable<float>())
+			{
+				output1Array.Add(f);
+			}
 
-		foreach (float f in output2.AsEnumerable<float>()) {
-			output2Array.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, ...]}
-		return output;
-	}	
-/// <include file='docs/ONNXInference.xml' path='docs/members[@name="ONNXInference"]/Load/*'/>
-	public InferenceSession LoadModel(string Path) 
-	{
-		Godot.FileAccess file = FileAccess.Open(Path, Godot.FileAccess.ModeFlags.Read);
-		byte[] model = file.GetBuffer((int)file.GetLength());
-		file.Close();
-		return new InferenceSession(model, SessionOpt); //Load the model
-	}
+			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

@@ -1,106 +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 {
-
-		private static SessionOptions options = new SessionOptions();
-		
-/// <include file='docs/SessionConfigurator.xml' path='docs/members[@name="SessionConfigurator"]/GetSessionOptions/*'/>
-		public static SessionOptions GetSessionOptions() {
-			options = new SessionOptions();
-			options.LogSeverityLevel = OrtLoggingLevel.ORT_LOGGING_LEVEL_WARNING; 
-			// see warnings
-			SystemCheck();
-			return options;
-		}
-/// <include file='docs/SessionConfigurator.xml' path='docs/members[@name="SessionConfigurator"]/SystemCheck/*'/>
+namespace GodotONNX
+{
+	/// <include file='docs/SessionConfigurator.xml' path='docs/members[@name="SessionConfigurator"]/SessionConfigurator/*'/>
 
-static public void SystemCheck()  
+	public static class SessionConfigurator
 	{
-		//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
-		int ComputeAPIID = 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
-		
-		string [] ComputeNames = {"CUDA", "DirectML/ROCm", "DirectML", "CoreML", "CPU"};
-		//match OS and Compute API
-		options.AppendExecutionProvider_CPU(0); // Always use CPU
-		GD.Print("OS: " + OSName, " | Compute API: " + ComputeNames[ComputeAPIID]);
-
-		switch (OSName) 
+		public enum ComputeName
 		{
-		case "Windows": //Can use CUDA, DirectML
-			if (ComputeAPIID == 0) 
-				{
-				//CUDA 
-				//options.AppendExecutionProvider_CUDA(0);
-				options.AppendExecutionProvider_DML(0);
-					}
-			else if (ComputeAPIID == 1) 
-				{ 
-				//DirectML
-				options.AppendExecutionProvider_DML(0);
-				}
-			break;
-		case "X11": //Can use CUDA, ROCm
-			if (ComputeAPIID == 0) 
-				{ 
-				//CUDA
-				//options.AppendExecutionProvider_CUDA(0);
-				}
-			if (ComputeAPIID == 1) 
-				{
-				//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.");
-				options.AppendExecutionProvider_CPU(0);
-				}
-			
-			break;
-		case "OSX": //Can use CoreML
-			if (ComputeAPIID == 0) { //CoreML
-			//TODO: Needs testing
-				options.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;
+			CUDA,
+			ROCm,
+			DirectML,
+			CoreML,
+			CPU
 		}
-	}
-/// <include file='docs/SessionConfigurator.xml' path='docs/members[@name="SessionConfigurator"]/ComputeCheck/*'/>
 
-	public static int 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 2, should use DirectML only
-		return 2;}
-	if (adapterName.Contains("AMD")) {
-		//Return 1, should use DirectML, check later for ROCm
-		return 1;}
-	if (adapterName.Contains("NVIDIA")){
-		//Return 0, should use CUDA
-		return 0;}
-	
-	GD.Print("Graphics Card not recognized."); //Return -1, should use CPU
-	return -1;
+        /// <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/wrapper/ONNX_wrapper.gd

@@ -1,4 +1,4 @@
-extends Node
+extends Resource
 class_name ONNXModel
 var inferencer_script = load("res://addons/godot_rl_agents/onnx/csharp/ONNXInference.cs")
 
@@ -17,3 +17,8 @@ func run_inference(obs : Array, state_ins : int) -> Dictionary:
 		printerr("Inferencer not initialized")
 		return {}
 	return inferencer.RunInference(obs, state_ins)
+
+func _notification(what):
+	if what == NOTIFICATION_PREDELETE:
+		inferencer.FreeDisposables()
+		inferencer.free()

addons/godot_rl_agents/sensors/sensors_2d/ExampleRaycastSensor2D.tscn

@@ -1,6 +1,6 @@
 [gd_scene load_steps=5 format=3 uid="uid://ddeq7mn1ealyc"]
 
-[ext_resource type="Script" path="res://sensors/sensors_2d/RaycastSensor2D.gd" id="1"]
+[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

addons/godot_rl_agents/sensors/sensors_3d/RaycastSensor3D.gd

@@ -61,11 +61,15 @@ var geo = null
 
 func _update():
 	if Engine.is_editor_hint():
-		_spawn_nodes()	
-
+		if is_node_ready():
+			_spawn_nodes()	
 
 func _ready() -> void:
-	_spawn_nodes()
+	if Engine.is_editor_hint():	
+		if get_child_count() == 0:
+			_spawn_nodes()
+	else:
+		_spawn_nodes()
 
 func _spawn_nodes():
 	print("spawning nodes")

addons/godot_rl_agents/sync.gd

@@ -1,7 +1,7 @@
 extends Node
 # --fixed-fps 2000 --disable-render-loop
-@export var action_repeat := 8
-@export var speed_up = 1
+@export_range(1, 10, 1, "or_greater") var action_repeat := 8
+@export_range(1, 10, 1, "or_greater") var speed_up = 1
 @export var onnx_model_path := ""
 
 @onready var start_time = Time.get_ticks_msec()
@@ -10,7 +10,6 @@ const MAJOR_VERSION := "0"
 const MINOR_VERSION := "3" 
 const DEFAULT_PORT := "11008"
 const DEFAULT_SEED := "1"
-const DEFAULT_ACTION_REPEAT := "8"
 var stream : StreamPeerTCP = null
 var connected = false
 var message_center
@@ -44,17 +43,20 @@ func _initialize():
 	Engine.time_scale = _get_speedup() * 1.0
 	prints("physics ticks", Engine.physics_ticks_per_second, Engine.time_scale, _get_speedup(), speed_up)
 	
-
-	connected = connect_to_server()
-	if connected:
-		_set_heuristic("model")
-		_handshake()
-		_send_env_info()
-	elif onnx_model_path != "":
+	# Run inference if onnx model path is set, otherwise wait for server connection
+	var run_onnx_model_inference : bool = onnx_model_path != ""
+	if run_onnx_model_inference:
+		assert(FileAccess.file_exists(onnx_model_path), "Onnx Model Path set on Sync node does not exist: " + onnx_model_path)
 		onnx_model = ONNXModel.new(onnx_model_path, 1)
 		_set_heuristic("model")
-	else:
-		_set_heuristic("human")  
+	else:		
+		connected = connect_to_server()
+		if connected:
+			_set_heuristic("model")
+			_handshake()
+			_send_env_info()
+		else:
+			_set_heuristic("human")  
 		
 	_set_seed()
 	_set_action_repeat()
@@ -232,7 +234,7 @@ func _set_seed():
 	seed(_seed)
 
 func _set_action_repeat():
-	action_repeat = args.get("action_repeat", DEFAULT_ACTION_REPEAT).to_int()
+	action_repeat = args.get("action_repeat", str(action_repeat)).to_int()
 	
 func disconnect_from_server():
 	stream.disconnect_from_host()

bin/JumperHard.exe

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:2de407f42a3db0dece9ff075b69219a30493b90c67f0a14bc450b414fba39125
-size 71425536
+oid sha256:910d1661cf406eb788be65369b4784b8bde02dd16e327fac690b501d08e9e886
+size 69051392

bin/JumperHard.x86_64

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:843a1e5f8df1e6b2fe57ff86ca637436c7e1216f8409f2b079090c373548e86f
-size 72784744
+oid sha256:fb6fa01639dd98489aac3e0dd5f9ecf0691b25b37a717f7380b1350d91ed23a4
+size 61637496

export_presets.cfg

@@ -8,18 +8,17 @@ custom_features=""
 export_filter="all_resources"
 include_filter=""
 exclude_filter=""
-export_path=""
+export_path="../../../godot_rl_agents/examples/jh/JumperHard.x86_64"
 encryption_include_filters=""
 encryption_exclude_filters=""
 encrypt_pck=false
 encrypt_directory=false
-script_encryption_key=""
 
 [preset.0.options]
 
 custom_template/debug=""
 custom_template/release=""
-debug/export_console_script=1
+debug/export_console_wrapper=1
 binary_format/embed_pck=false
 texture_format/bptc=true
 texture_format/s3tc=true
@@ -38,6 +37,10 @@ unzip -o -q \"{temp_dir}/{archive_name}\" -d \"{temp_dir}\"
 ssh_remote_deploy/cleanup_script="#!/usr/bin/env bash
 kill $(pgrep -x -f \"{temp_dir}/{exe_name} {cmd_args}\")
 rm -rf \"{temp_dir}\""
+dotnet/include_scripts_content=false
+dotnet/include_debug_symbols=true
+dotnet/embed_build_outputs=false
+debug/export_console_script=1
 
 [preset.1]
 
@@ -54,13 +57,12 @@ encryption_include_filters=""
 encryption_exclude_filters=""
 encrypt_pck=false
 encrypt_directory=false
-script_encryption_key=""
 
 [preset.1.options]
 
 custom_template/debug=""
 custom_template/release=""
-debug/export_console_script=1
+debug/export_console_wrapper=1
 binary_format/embed_pck=false
 texture_format/bptc=true
 texture_format/s3tc=true
@@ -68,9 +70,6 @@ texture_format/etc=false
 texture_format/etc2=false
 binary_format/architecture="x86_64"
 codesign/enable=false
-codesign/identity_type=0
-codesign/identity=""
-codesign/password=""
 codesign/timestamp=true
 codesign/timestamp_server_url=""
 codesign/digest_algorithm=1
@@ -87,6 +86,7 @@ application/product_name=""
 application/file_description=""
 application/copyright=""
 application/trademarks=""
+application/export_angle=0
 ssh_remote_deploy/enabled=false
 ssh_remote_deploy/host="user@host_ip"
 ssh_remote_deploy/port="22"
@@ -104,3 +104,7 @@ Unregister-ScheduledTask -TaskName godot_remote_debug -Confirm:$false -ErrorActi
 ssh_remote_deploy/cleanup_script="Stop-ScheduledTask -TaskName godot_remote_debug -ErrorAction:SilentlyContinue
 Unregister-ScheduledTask -TaskName godot_remote_debug -Confirm:$false -ErrorAction:SilentlyContinue
 Remove-Item -Recurse -Force '{temp_dir}'"
+dotnet/include_scripts_content=false
+dotnet/include_debug_symbols=true
+dotnet/embed_build_outputs=false
+debug/export_console_script=1

project.godot

@@ -12,7 +12,7 @@ config_version=5
 
 config/name="JumperHard"
 run/main_scene="res://BatchEnvs.tscn"
-config/features=PackedStringArray("4.0", "C#")
+config/features=PackedStringArray("4.1", "C#")
 config/icon="res://icon.png"
 
 [dotnet]
@@ -21,7 +21,7 @@ project/assembly_name="JumperHard"
 
 [editor_plugins]
 
-enabled=PackedStringArray()
+enabled=PackedStringArray("res://addons/godot_rl_agents/plugin.cfg")
 
 [input]