Fixed bugs

main/ShootingGallery.csproj

@@ -0,0 +1,8 @@
+<Project Sdk="Godot.NET.Sdk/4.2.1">
+ <PropertyGroup>
+ <TargetFramework>net6.0</TargetFramework>
+ <TargetFramework Condition=" '$(GodotTargetPlatform)' == 'android' ">net7.0</TargetFramework>
+ <TargetFramework Condition=" '$(GodotTargetPlatform)' == 'ios' ">net8.0</TargetFramework>
+ <EnableDynamicLoading>true</EnableDynamicLoading>
+ </PropertyGroup>
+</Project>

main/ShootingGallery.sln

@@ -0,0 +1,19 @@
+Microsoft Visual Studio Solution File, Format Version 12.00
+# Visual Studio 2012
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "ShootingGallery", "ShootingGallery.csproj", "{CBAC2DA1-37AD-4D33-9024-10E691C21FC6}"
+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
+ {CBAC2DA1-37AD-4D33-9024-10E691C21FC6}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+ {CBAC2DA1-37AD-4D33-9024-10E691C21FC6}.Debug|Any CPU.Build.0 = Debug|Any CPU
+ {CBAC2DA1-37AD-4D33-9024-10E691C21FC6}.ExportDebug|Any CPU.ActiveCfg = ExportDebug|Any CPU
+ {CBAC2DA1-37AD-4D33-9024-10E691C21FC6}.ExportDebug|Any CPU.Build.0 = ExportDebug|Any CPU
+ {CBAC2DA1-37AD-4D33-9024-10E691C21FC6}.ExportRelease|Any CPU.ActiveCfg = ExportRelease|Any CPU
+ {CBAC2DA1-37AD-4D33-9024-10E691C21FC6}.ExportRelease|Any CPU.Build.0 = ExportRelease|Any CPU
+ EndGlobalSection
+EndGlobal

main/project.godot

@@ -11,9 +11,8 @@ config_version=5
 [application]
 
 config/name="Shooting Gallery"
-config/tags=PackedStringArray("desktop", "gdscript")
 run/main_scene="res:https://src/Main/Main.tscn"
-config/features=PackedStringArray("4.1", "Forward Plus")
+config/features=PackedStringArray("4.2", "4.2.1", "C#", "GL Compatibility")
 boot_splash/show_image=false
 boot_splash/fullsize=false
 boot_splash/use_filter=false
@@ -23,12 +22,9 @@ config/windows_native_icon="res:https://icon.ico"
 [autoload]
 
 Globals="*res:https://src/Global/Globals.gd"
-Composer="*res:https://src/Composer/Composer.gd"
 SaveData="*res:https://src/Global/SaveData.gd"
-
-[debug]
-
-settings/stdout/verbose_stdout=true
+Composer="*res:https://src/Composer/Composer.cs"
+ComposerGD="*res:https://src/Composer/ComposerGD.cs"
 
 [display]
 
@@ -41,18 +37,17 @@ window/size/window_width_override=1280
 window/size/window_height_override=720
 window/stretch/mode="canvas_items"
 
+[dotnet]
+
+project/assembly_name="ShootingGallery"
+
 [input]
 
 exit={
 "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":4194305,"key_label":0,"unicode":0,"echo":false,"script":null)
 ]
 }
-reset={
-"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":82,"key_label":0,"unicode":114,"echo":false,"script":null)
-]
-}
 pause={
 "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":80,"key_label":0,"unicode":112,"echo":false,"script":null)

main/src/Composer/Composer.cs

@@ -0,0 +1,318 @@
+using Godot;
+using System;
+
+namespace ComposerLib
+{
+ public partial class Composer : Node
+ {
+ [Signal]
+ public delegate void SceneBeganLoadedEventHandler(string sceneName);
+
+ [Signal]
+ public delegate void SceneLoadedEventHandler(string sceneName);
+
+ [Signal]
+ public delegate void SceneLoadingProcessUpdatedEventHandler(string sceneName, float progress);
+
+ [Signal]
+ public delegate void SceneCreatedEventHandler(string sceneName);
+
+ [Signal]
+ public delegate void SceneEnabledEventHandler(string sceneName);
+
+ [Signal]
+ public delegate void SceneDisabledEventHandler(string sceneName);
+
+ [Signal]
+ public delegate void SceneRemovedEventHandler(string sceneName);
+
+ [Signal]
+ public delegate void SceneDisposedEventHandler(string sceneName);
+
+
+ public Godot.Collections.Dictionary<string, Scene> Scenes = new();
+ internal ComposerGD ComposerGD {get; set;} = null;
+ private readonly CreateSettings DefaultCreateSettings = new(){SceneParent = ((SceneTree)Engine.GetMainLoop()).Root};
+ private readonly Loader Loader = new();
+
+ public override void _EnterTree()
+ {
+ AddChild(Loader,true);
+ Loader.LoaderStarted += OnSceneBeganLoading;
+ Loader.LoaderLoadingUpdated += OnLoadingUpdated;
+ }
+
+ public Scene GetScene(string name)
+ {
+ if (!Scenes.TryGetValue(name, out Scene scene))
+ {
+ GD.PrintErr($"GetScene error: Scene {name} doesn't exist in memory.");
+ return null;
+ }
+
+ return scene;
+ }
+
+ public void AddScene(string name, string path, AddSettings settings = null)
+ {
+ if (Scenes.ContainsKey(name))
+ {
+ GD.PrintErr($"AddScene error: Scene {name} already exists in memory.");
+ return;
+ }
+
+ var scene = new Scene(name, path);
+ scene.FinishedLoading += OnSceneLoaded;
+ scene.FinishedCreating += OnSceneCreated;
+
+ if (settings != null) VerifyPreAddSettings(name, settings);
+
+ Scenes.Add(name,scene);
+
+ if (settings != null) VerifyPostAddSettings(name, settings);
+ }
+
+ public void AddScene(string name, PackedScene resource, AddSettings settings = null, string path = "")
+ {
+ if (Scenes.ContainsKey(name))
+ {
+ GD.PrintErr($"AddScene error: Scene {name} already exists in memory.");
+ return;
+ }
+
+ var scene = new Scene(name, resource, path);
+ scene.FinishedLoading += OnSceneLoaded;
+ scene.FinishedCreating += OnSceneCreated;
+
+ if (settings != null) VerifyPreAddSettings(name, settings);
+
+ Scenes.Add(name,scene);
+
+ if (settings != null) VerifyPostAddSettings(name, settings);
+ }
+
+ public void AddScene(Scene scene, AddSettings settings = null)
+ {
+ if (Scenes.ContainsKey(scene.InternalName))
+ {
+ GD.PrintErr($"AddScene error: Scene {scene.InternalName} already exists in memory.");
+ return;
+ }
+
+ scene.FinishedLoading += OnSceneLoaded;
+ scene.FinishedCreating += OnSceneCreated;
+
+ if (settings != null) VerifyPreAddSettings(scene.InternalName, settings);
+
+ Scenes.Add(scene.InternalName,scene);
+
+ if (settings != null) VerifyPostAddSettings(scene.InternalName, settings);
+ }
+
+ public async void LoadScene(string name, LoadSettings settings = null)
+ {
+ var scene = GetScene(name);
+
+ if (scene == null)
+ {
+ GD.PrintErr($"LoadScene error: Scene {name} doesn't exist in memory.");
+ return;
+ }
+
+ if (settings != null) VerifyPreLoadSettings(name, settings);
+
+ if (settings != null)
+ scene.Load(settings.UseSubthreads, settings.CacheMode);
+ else
+ scene.Load();
+
+ await ToSignal(scene,Scene.SignalName.FinishedLoading);
+
+ if (settings != null) VerifyPostLoadSettings(name, settings);
+ }
+
+ public async void CreateScene(string name, CreateSettings settings = null)
+ {
+ settings ??= DefaultCreateSettings;
+ var scene = GetScene(name);
+
+ if (scene == null)
+ {
+ GD.PrintErr($"CreateScene error: Scene {name} doesn't exist in memory.");
+ return;
+ }
+
+ if (settings != null) VerifyPreCreateSettings(name, settings);
+
+ scene.Create(settings.SceneParent);
+
+ await ToSignal(scene, Scene.SignalName.FinishedCreating);
+
+ if (settings != null) VerifyPostCreateSettings(name, settings);
+ }
+
+ public void ReplaceScene(string sceneToRemove, string sceneToAdd, Node parent)
+ {
+ RemoveScene(sceneToRemove);
+ CreateScene(sceneToAdd, new CreateSettings{
+ SceneParent = parent
+ });
+ }
+
+ public void ReloadScene(string name)
+ {
+ var scene = GetScene(name);
+
+ if (scene.Instance == null)
+ {
+ GD.PrintErr($"ReloadScene error: Scene {name} doesn't have an instance.");
+ return;
+ }
+
+ var parent = scene.Instance.GetParent();
+ RemoveScene(name);
+ CreateScene(name, new(){
+ SceneParent = parent
+ });
+ }
+
+ public void EnableScene(string name)
+ {
+ var scene = GetScene(name);
+
+ if (scene == null)
+ {
+ GD.PrintErr($"EnableScene error: Scene {name} doesn't exist in memory.");
+ return;
+ }
+
+ scene.Enable();
+ EmitSignal(SignalName.SceneEnabled, name);
+ ComposerGD?.EmitSignal(ComposerGD.SignalName.SceneEnabled, name);
+ }
+
+ public void DisableScene(string name)
+ {
+ var scene = GetScene(name);
+
+ if (scene == null)
+ {
+ GD.PrintErr($"EnableScene error: Scene {name} doesn't exist in memory.");
+ return;
+ }
+
+ scene.Disable();
+ EmitSignal(SignalName.SceneDisabled, name);
+ ComposerGD?.EmitSignal(ComposerGD.SignalName.SceneDisabled, name);
+ }
+
+ public void RemoveScene(string name)
+ {
+ var scene = GetScene(name);
+
+ if (scene == null)
+ {
+ GD.PrintErr($"RemoveScene error: Scene {name} doesn't exist in memory.");
+ return;
+ }
+
+ scene.Remove();
+ EmitSignal(SignalName.SceneRemoved, name);
+ ComposerGD?.EmitSignal(ComposerGD.SignalName.SceneRemoved, name);
+ }
+
+ public void DisposeScene(string name)
+ {
+ var scene = GetScene(name);
+
+ if (scene == null)
+ {
+ GD.PrintErr($"DisposeScene error: Scene {name} doesn't exist in memory.");
+ return;
+ }
+
+ scene.FinishedLoading -= OnSceneLoaded;
+ scene.FinishedCreating -= OnSceneCreated;
+ scene.Dispose();
+ Scenes.Remove(name);
+
+ EmitSignal(SignalName.SceneDisposed, name);
+ ComposerGD?.EmitSignal(ComposerGD.SignalName.SceneDisposed, name);
+ }
+
+ private void VerifyPreAddSettings(string name, AddSettings settings)
+ {
+
+ }
+
+ private void VerifyPostAddSettings(string name, AddSettings settings)
+ {
+ if (settings.InstantLoad)
+ {
+ LoadScene(name,new LoadSettings{
+ SceneParent = settings.SceneParent,
+ InstantCreate = settings.InstantCreate
+ });
+ }
+ }
+
+ private void VerifyPreLoadSettings(string name, LoadSettings settings)
+ {
+
+ }
+
+ private void VerifyPostLoadSettings(string name, LoadSettings settings)
+ {
+ if (settings.SceneParent != null)
+ {
+ if (settings.InstantCreate)
+ {
+ CreateScene(name,new CreateSettings{
+ SceneParent = settings.SceneParent
+ });
+ }
+ }
+ }
+
+ private void VerifyPreCreateSettings(string name, CreateSettings settings)
+ {
+ if (!IsInstanceValid(settings.SceneParent))
+ {
+ throw new ArgumentException($"Invalid SceneParent argument for CreateScene, scene {name}");
+ }
+ }
+
+ private void VerifyPostCreateSettings(string name, CreateSettings settings)
+ {
+ if (settings.DisableProcessing)
+ {
+ GetScene(name).Disable();
+ }
+ }
+
+ private void OnSceneCreated(string sceneName)
+ {
+ EmitSignal(SignalName.SceneCreated, sceneName);
+ ComposerGD?.EmitSignal(ComposerGD.SignalName.SceneCreated, sceneName);
+ }
+
+ private void OnSceneBeganLoading(Scene scene)
+ {
+ EmitSignal(SignalName.SceneBeganLoaded, scene.InternalName);
+ ComposerGD?.EmitSignal(ComposerGD.SignalName.SceneBeganLoading, scene.InternalName);
+ }
+
+ private void OnLoadingUpdated(Scene scene, float progress)
+ {
+ EmitSignal(SignalName.SceneLoadingProcessUpdated, scene.InternalName, progress);
+ ComposerGD?.EmitSignal(ComposerGD.SignalName.SceneLoadingProcessUpdated, scene.InternalName, progress);
+ }
+
+ private void OnSceneLoaded(string sceneName)
+ {
+ EmitSignal(SignalName.SceneLoaded, sceneName);
+ ComposerGD?.EmitSignal(ComposerGD.SignalName.SceneLoaded, sceneName);
+ }
+ }
+}
+