C#: Switch games to MSBuild Sdks and .NET Standard

Godot.NET.Sdk
-------------

Godot uses its own custom MSBuild Sdk for game
projects. This new Sdk adds its own functionality
on top of 'Microsoft.NET.Sdk'.

The new Sdk is resolved from the NuGet package.

All the default boilerplate was moved from game
projects to the Sdk. The default csproj for
game project can now be as simple as:

```
<Project Sdk="Godot.NET.Sdk/4.0.0-dev2">
  <PropertyGroup>
    <TargetFramework>netstandard2.1</TargetFramework>
  </PropertyGroup>
</Project>
```

Source files are included by automatically so
Godot no longer needs to keep the csproj in sync
when creating new source files.

Define constants
----------------

Godot defines a list of constants for conditional
compilation. When exporting games, this list also
included engine 'features' and platform 'bits'.
There were a few problems with that:

- The 'features' constants were only defined when
  exporting games. Not when building the game for
  running in the editor player.
- If the project was built externally by an IDE,
  the constants wouldn't be defined at all.

The new Sdk assigns default values to these
constants when not built from the Godot editor,
i.e.: when built from an IDE or from the command
line. The default define constants are determined
from the system MSBuild is running on.

However, it's not possible for MSBuild to
determine the set of supported engine features.
It's also not possible to determine if a project
is being built to run on a 32-bit or 64-bit
Godot executable.

As such the 'features' and 'bits' constants had
to be removed.
The benefit of checking those at compile time
was questionable, and they can still be checked
at runtime.

The new list of define constants includes:

- GODOT
- GODOT_<PLATFORM>
  Defaults to the platform MSBuild is running on.
- GODOT_<PC/MOBILE/WEB>
- TOOLS
  When building with the 'Debug' configuration
  (editor and editor player).
- GODOT_REAL_T_IS_DOUBLE
  Not defined by default unless $(GodotRealTIsDouble)
  is overriden to be 'true'.

.NET Standard
-------------

The target framework of game projects was changed
to 'netstandard2.1'.

1 files changed, 22 insertions, 147 deletions

diff --git a/modules/mono/editor/GodotTools/GodotTools.ProjectEditor/ProjectGenerator.cs b/modules/mono/editor/GodotTools/GodotTools.ProjectEditor/ProjectGenerator.cs
index 679d5bb444..5541876f9e 100644
--- a/modules/mono/editor/GodotTools/GodotTools.ProjectEditor/ProjectGenerator.cs
+++ b/modules/mono/editor/GodotTools/GodotTools.ProjectEditor/ProjectGenerator.cs
@@ -1,174 +1,49 @@
-using GodotTools.Core;
 using System;
-using System.Collections.Generic;
 using System.IO;
-using System.Reflection;
 using Microsoft.Build.Construction;
+using Microsoft.Build.Evaluation;
 
 namespace GodotTools.ProjectEditor
 {
     public static class ProjectGenerator
     {
-        private const string CoreApiProjectName = "GodotSharp";
-        private const string EditorApiProjectName = "GodotSharpEditor";
+        public const string GodotSdkVersionToUse = "4.0.0-dev2";
 
-        public const string CSharpProjectTypeGuid = "{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}";
-        public const string GodotProjectTypeGuid = "{8F3E2DF0-C35C-4265-82FC-BEA011F4A7ED}";
+        public static string GodotSdkAttrValue => $"Godot.NET.Sdk/{GodotSdkVersionToUse}";
 
-        public static readonly string GodotDefaultProjectTypeGuids = $"{GodotProjectTypeGuid};{CSharpProjectTypeGuid}";
-
-        public static string GenGameProject(string dir, string name, IEnumerable<string> compileItems)
-        {
-            string path = Path.Combine(dir, name + ".csproj");
-
-            ProjectPropertyGroupElement mainGroup;
-            var root = CreateLibraryProject(name, "Debug", out mainGroup);
-
-            mainGroup.SetProperty("ProjectTypeGuids", GodotDefaultProjectTypeGuids);
-            mainGroup.SetProperty("OutputPath", Path.Combine(".mono", "temp", "bin", "$(Configuration)"));
-            mainGroup.SetProperty("BaseIntermediateOutputPath", Path.Combine(".mono", "temp", "obj"));
-            mainGroup.SetProperty("IntermediateOutputPath", Path.Combine("$(BaseIntermediateOutputPath)", "$(Configuration)"));
-            mainGroup.SetProperty("ApiConfiguration", "Debug").Condition = " '$(Configuration)' != 'ExportRelease' ";
-            mainGroup.SetProperty("ApiConfiguration", "Release").Condition = " '$(Configuration)' == 'ExportRelease' ";
-
-            var debugGroup = root.AddPropertyGroup();
-            debugGroup.Condition = " '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ";
-            debugGroup.AddProperty("DebugSymbols", "true");
-            debugGroup.AddProperty("DebugType", "portable");
-            debugGroup.AddProperty("Optimize", "false");
-            debugGroup.AddProperty("DefineConstants", "$(GodotDefineConstants);GODOT;DEBUG;TOOLS;");
-            debugGroup.AddProperty("ErrorReport", "prompt");
-            debugGroup.AddProperty("WarningLevel", "4");
-            debugGroup.AddProperty("ConsolePause", "false");
-
-            var coreApiRef = root.AddItem("Reference", CoreApiProjectName);
-            coreApiRef.AddMetadata("HintPath", Path.Combine("$(ProjectDir)", ".mono", "assemblies", "$(ApiConfiguration)", CoreApiProjectName + ".dll"));
-            coreApiRef.AddMetadata("Private", "False");
-
-            var editorApiRef = root.AddItem("Reference", EditorApiProjectName);
-            editorApiRef.Condition = " '$(Configuration)' == 'Debug' ";
-            editorApiRef.AddMetadata("HintPath", Path.Combine("$(ProjectDir)", ".mono", "assemblies", "$(ApiConfiguration)", EditorApiProjectName + ".dll"));
-            editorApiRef.AddMetadata("Private", "False");
-
-            GenAssemblyInfoFile(root, dir, name);
-
-            foreach (var item in compileItems)
-            {
-                root.AddItem("Compile", item.RelativeToPath(dir).Replace("/", "\\"));
-            }
-
-            root.Save(path);
-
-            return root.GetGuid().ToString().ToUpper();
-        }
-
-        private static void GenAssemblyInfoFile(ProjectRootElement root, string dir, string name, string[] assemblyLines = null, string[] usingDirectives = null)
+        public static ProjectRootElement GenGameProject(string name)
         {
-            string propertiesDir = Path.Combine(dir, "Properties");
-            if (!Directory.Exists(propertiesDir))
-                Directory.CreateDirectory(propertiesDir);
-
-            string usingDirectivesText = string.Empty;
+            if (name.Length == 0)
+                throw new ArgumentException("Project name is empty", nameof(name));
 
-            if (usingDirectives != null)
-            {
-                foreach (var usingDirective in usingDirectives)
-                    usingDirectivesText += "\nusing " + usingDirective + ";";
-            }
+            var root = ProjectRootElement.Create(NewProjectFileOptions.None);
 
-            string assemblyLinesText = string.Empty;
+            root.Sdk = GodotSdkAttrValue;
 
-            if (assemblyLines != null)
-                assemblyLinesText += string.Join("\n", assemblyLines) + "\n";
+            var mainGroup = root.AddPropertyGroup();
+            mainGroup.AddProperty("TargetFramework", "netstandard2.1");
 
-            string content = string.Format(AssemblyInfoTemplate, usingDirectivesText, name, assemblyLinesText);
+            string sanitizedName = IdentifierUtils.SanitizeQualifiedIdentifier(name, allowEmptyIdentifiers: true);
 
-            string assemblyInfoFile = Path.Combine(propertiesDir, "AssemblyInfo.cs");
+            // If the name is not a valid namespace, manually set RootNamespace to a sanitized one.
+            if (sanitizedName != name)
+                mainGroup.AddProperty("RootNamespace", sanitizedName);
 
-            File.WriteAllText(assemblyInfoFile, content);
-
-            root.AddItem("Compile", assemblyInfoFile.RelativeToPath(dir).Replace("/", "\\"));
+            return root;
         }
 
-        public static ProjectRootElement CreateLibraryProject(string name, string defaultConfig, out ProjectPropertyGroupElement mainGroup)
+        public static string GenAndSaveGameProject(string dir, string name)
         {
-            if (string.IsNullOrEmpty(name))
-                throw new ArgumentException($"{nameof(name)} cannot be empty", nameof(name));
-
-            var root = ProjectRootElement.Create();
-            root.DefaultTargets = "Build";
-
-            mainGroup = root.AddPropertyGroup();
-            mainGroup.AddProperty("Configuration", defaultConfig).Condition = " '$(Configuration)' == '' ";
-            mainGroup.AddProperty("Platform", "AnyCPU").Condition = " '$(Platform)' == '' ";
-            mainGroup.AddProperty("ProjectGuid", "{" + Guid.NewGuid().ToString().ToUpper() + "}");
-            mainGroup.AddProperty("OutputType", "Library");
-            mainGroup.AddProperty("OutputPath", Path.Combine("bin", "$(Configuration)"));
-            mainGroup.AddProperty("RootNamespace", IdentifierUtils.SanitizeQualifiedIdentifier(name, allowEmptyIdentifiers: true));
-            mainGroup.AddProperty("AssemblyName", name);
-            mainGroup.AddProperty("TargetFrameworkVersion", "v4.7");
-            mainGroup.AddProperty("GodotProjectGeneratorVersion", Assembly.GetExecutingAssembly().GetName().Version.ToString());
+            if (name.Length == 0)
+                throw new ArgumentException("Project name is empty", nameof(name));
 
-            var exportDebugGroup = root.AddPropertyGroup();
-            exportDebugGroup.Condition = " '$(Configuration)|$(Platform)' == 'ExportDebug|AnyCPU' ";
-            exportDebugGroup.AddProperty("DebugSymbols", "true");
-            exportDebugGroup.AddProperty("DebugType", "portable");
-            exportDebugGroup.AddProperty("Optimize", "false");
-            exportDebugGroup.AddProperty("DefineConstants", "$(GodotDefineConstants);GODOT;DEBUG;");
-            exportDebugGroup.AddProperty("ErrorReport", "prompt");
-            exportDebugGroup.AddProperty("WarningLevel", "4");
-            exportDebugGroup.AddProperty("ConsolePause", "false");
-
-            var exportReleaseGroup = root.AddPropertyGroup();
-            exportReleaseGroup.Condition = " '$(Configuration)|$(Platform)' == 'ExportRelease|AnyCPU' ";
-            exportReleaseGroup.AddProperty("DebugType", "portable");
-            exportReleaseGroup.AddProperty("Optimize", "true");
-            exportReleaseGroup.AddProperty("DefineConstants", "$(GodotDefineConstants);GODOT;");
-            exportReleaseGroup.AddProperty("ErrorReport", "prompt");
-            exportReleaseGroup.AddProperty("WarningLevel", "4");
-            exportReleaseGroup.AddProperty("ConsolePause", "false");
-
-            // References
-            var referenceGroup = root.AddItemGroup();
-            referenceGroup.AddItem("Reference", "System");
-            var frameworkRefAssembliesItem = referenceGroup.AddItem("PackageReference", "Microsoft.NETFramework.ReferenceAssemblies");
+            string path = Path.Combine(dir, name + ".csproj");
 
-            // Use metadata (child nodes) instead of attributes for the PackageReference.
-            // This is for compatibility with 3.2, where GodotTools uses an old Microsoft.Build.
-            frameworkRefAssembliesItem.AddMetadata("Version", "1.0.0");
-            frameworkRefAssembliesItem.AddMetadata("PrivateAssets", "All");
+            var root = GenGameProject(name);
 
-            root.AddImport(Path.Combine("$(MSBuildBinPath)", "Microsoft.CSharp.targets").Replace("/", "\\"));
+            root.Save(path);
 
-            return root;
+            return Guid.NewGuid().ToString().ToUpper();
         }
-
-        private const string AssemblyInfoTemplate =
-            @"using System.Reflection;{0}
-
-// Information about this assembly is defined by the following attributes.
-// Change them to the values specific to your project.
-
-[assembly: AssemblyTitle(""{1}"")]
-[assembly: AssemblyDescription("""")]
-[assembly: AssemblyConfiguration("""")]
-[assembly: AssemblyCompany("""")]
-[assembly: AssemblyProduct("""")]
-[assembly: AssemblyCopyright("""")]
-[assembly: AssemblyTrademark("""")]
-[assembly: AssemblyCulture("""")]
-
-// The assembly version has the format ""{{Major}}.{{Minor}}.{{Build}}.{{Revision}}"".
-// The form ""{{Major}}.{{Minor}}.*"" will automatically update the build and revision,
-// and ""{{Major}}.{{Minor}}.{{Build}}.*"" will update just the revision.
-
-[assembly: AssemblyVersion(""1.0.*"")]
-
-// The following attributes are used to specify the signing key for the assembly,
-// if desired. See the Mono documentation for more information about signing.
-
-//[assembly: AssemblyDelaySign(false)]
-//[assembly: AssemblyKeyFile("""")]
-{2}";
     }
 }