wip sync

Directory.Build.props

@@ -15,6 +15,8 @@
     <Nullable>disable</Nullable>
     <Product>OpenRA</Product>
     <Copyright>Copyright (c) The OpenRA Developers and Contributors</Copyright>
+
+     <EmitCompilerGeneratedFiles>true</EmitCompilerGeneratedFiles>
   </PropertyGroup>
 
   <PropertyGroup>

OpenRA.Game/OpenRA.Game.csproj

@@ -17,4 +17,7 @@
     <PackageReference Include="System.Net.Http" Version="4.3.4" />
     <PackageReference Include="System.Threading.Channels" Version="6.0.0" />
   </ItemGroup>
+  <ItemGroup>
+    <ProjectReference Include="..\OpenRA.SourceGenerators\OpenRA.SourceGenerators.csproj" ReferenceOutputAssembly="false" OutputItemType="Analyzer"/>
+  </ItemGroup>
 </Project>

OpenRA.Game/Sync.cs

@@ -25,6 +25,11 @@ public sealed class SyncAttribute : Attribute { }
 	// Marker interface
 	public interface ISync { }
 
+	public interface ISync2
+	{
+		int GetSyncHash();
+	}
+
 	public static class Sync
 	{
 		static readonly ConcurrentCache<Type, Func<object, int>> HashFunctions =
@@ -134,6 +139,11 @@ public static int HashPlayer(Player p)
 			return 0;
 		}
 
+		public static int HashBool(bool b)
+		{
+			return b ? 0xaaa : 0x555;
+		}
+
 		public static int HashTarget(Target t)
 		{
 			switch (t.Type)

OpenRA.Game/SyncGenerationAttribute.cs

@@ -0,0 +1,10 @@
+using System;
+
+namespace OpenRA
+{
+	[AttributeUsage(AttributeTargets.Class)]
+	public class SyncGenerationAttribute : Attribute
+	{
+	}
+
+}

OpenRA.Game/Traits/Player/Shroud.cs

@@ -69,7 +69,8 @@ IEnumerable<LobbyOption> ILobbyOptions.LobbyOptions(MapPreview map)
 		public override object Create(ActorInitializer init) { return new Shroud(init.Self, this); }
 	}
 
-	public class Shroud : ISync, INotifyCreated, ITick
+	[SyncGeneration]
+	public partial class Shroud : ISync, INotifyCreated, ITick, ISync2
 	{
 		public enum SourceType : byte { PassiveVisibility, Shroud, Visibility }
 		public event Action<PPos> OnShroudChanged;

OpenRA.Mods.Common/OpenRA.Mods.Common.csproj

@@ -12,5 +12,8 @@
     <PackageReference Include="rix0rrr.BeaconLib" Version="1.0.2" />
     <PackageReference Include="Pfim" Version="0.11.2" />
     <PackageReference Include="System.Net.Http" Version="4.3.4" />
+  </ItemGroup>
+	<ItemGroup>
+    <ProjectReference Include="..\OpenRA.SourceGenerators\OpenRA.SourceGenerators.csproj" ReferenceOutputAssembly="false" OutputItemType="Analyzer"/>
   </ItemGroup>
 </Project>

OpenRA.Mods.Common/Projectiles/AreaBeam.cs

@@ -82,7 +82,8 @@ public IProjectile Create(ProjectileArgs args)
 		}
 	}
 
-	public class AreaBeam : IProjectile, ISync
+    [SyncGeneration]
+	public partial class AreaBeam : IProjectile, ISync
 	{
 		readonly AreaBeamInfo info;
 		readonly ProjectileArgs args;

OpenRA.Mods.Common/Traits/Mobile.cs

@@ -168,8 +168,9 @@ IEnumerable<EditorActorOption> IEditorActorOptions.ActorOptions(ActorInfo ai, Wo
 		}
 	}
 
-	public class Mobile : PausableConditionalTrait<MobileInfo>, IIssueOrder, IResolveOrder, IOrderVoice, IPositionable, IMove, ITick, ICreationActivity,
-		IFacing, IDeathActorInitModifier, INotifyAddedToWorld, INotifyRemovedFromWorld, INotifyBlockingMove, IActorPreviewInitModifier, INotifyBecomingIdle
+    [SyncGeneration]
+	public partial class Mobile : PausableConditionalTrait<MobileInfo>, IIssueOrder, IResolveOrder, IOrderVoice, IPositionable, IMove, ITick, ICreationActivity,
+		IFacing, IDeathActorInitModifier, INotifyAddedToWorld, INotifyRemovedFromWorld, INotifyBlockingMove, IActorPreviewInitModifier, INotifyBecomingIdle, ISync2
 	{
 		readonly Actor self;
 		readonly Lazy<IEnumerable<int>> speedModifiers;

OpenRA.SourceGenerators/Sync/SyncClassInfo.cs

@@ -0,0 +1,86 @@
+using System;
+using System.Collections.Generic;
+using System.Diagnostics;
+using System.Linq;
+using Microsoft.CodeAnalysis;
+
+namespace OpenRA.SourceGenerators.Sync
+{
+	public sealed class SyncClassInfo : IEquatable<SyncClassInfo>
+	{
+		public string? Namespace { get; }
+		public string Name { get; }
+		public IReadOnlyList<SyncMember> SyncMembers { get; }
+
+		public SyncClassInfo(ITypeSymbol type)
+		{
+			Namespace = type.ContainingNamespace.IsGlobalNamespace ? null : type.ContainingNamespace.ToString();
+			Name = type.Name;
+			//Debugger.Launch();
+
+			var result = new List<SyncMember>();
+			var members = type.GetMembers().Where(m => m.GetAttributes().Any(a => a.AttributeClass.Name == "SyncAttribute"))
+				.ToList();
+
+			foreach (var member in members)
+			{
+				if (member is IFieldSymbol field)
+				{
+					result.Add(new SyncMember
+					{
+						Name = field.Name,
+						Type = field.Type.Name
+					});
+				}
+
+				if (member is IPropertySymbol property)
+				{
+					result.Add(new SyncMember
+					{
+						Name = property.Name,
+						Type = property.Type.Name
+					});
+				}
+			}
+			//HasNameProperty = type.GetMembers().Any(m => m.Name == "Name"
+			//                                             && m is IPropertySymbol property
+			//                                             && property.Type.SpecialType == SpecialType.System_String);
+
+			SyncMembers = result;
+		}
+
+		public override bool Equals(object? obj)
+		{
+			return obj is SyncClassInfo other && Equals(other);
+		}
+
+		public bool Equals(SyncClassInfo? other)
+		{
+			if (ReferenceEquals(null, other))
+				return false;
+			if (ReferenceEquals(this, other))
+				return true;
+
+			return Namespace == other.Namespace
+			       && Name == other.Name;
+		}
+
+		public override int GetHashCode()
+		{
+			unchecked
+			{
+				var hashCode = (Namespace != null ? Namespace.GetHashCode() : 0);
+				hashCode = (hashCode * 397) ^ Name.GetHashCode();
+
+				return hashCode;
+			}
+		}
+	}
+
+	public class SyncMember
+	{
+		public string Name { get; set; }
+		public string Type { get; set; }
+
+	}
+}

OpenRA.SourceGenerators/Sync/SyncCodeGenerator.cs

@@ -0,0 +1,76 @@
+using System.Collections.Generic;
+using System.Diagnostics;
+using System.Linq;
+using System.Text;
+using Microsoft.CodeAnalysis.CSharp.Syntax;
+
+namespace OpenRA.SourceGenerators.Sync
+{
+	public static class SyncCodeGenerator
+	{
+		public static string Generate(SyncClassInfo syncClassInfo)
+		{
+			var ns = syncClassInfo.Namespace;
+			var name = syncClassInfo.Name;
+
+			var sb = new StringBuilder(@"// <auto-generated />
+#nullable enable");
+
+
+			sb.Append($@"
+
+using OpenRA;
+
+
+{(ns is null ? null : $@"namespace {ns}
+{{")}
+   partial class {name}
+   {{
+      public int GetSyncHash()
+      {{
+			return ");
+
+          GenerateHashCode(sb, syncClassInfo.SyncMembers);
+
+		 sb.Append($@"
+      }}
+   }}
+{(ns is null ? null : @"}
+")}");
+
+			return sb.ToString();
+		}
+
+		private static void GenerateHashCode(StringBuilder sb, IReadOnlyList<SyncMember> itemNames)
+		{
+			var delimiter = "";
+
+			//Debugger.Launch();
+
+			foreach (var item in itemNames)
+			{
+				sb.Append(delimiter);
+				if (item.Type == "Boolean")
+				{
+					sb.Append($"Sync.HashBool({item.Name})");
+				}
+				else if(item.Type == "WPos")
+				{
+					sb.Append($"{item.Name}.GetHashCode()");
+				}
+				else if (item.Type == "CPos")
+				{
+                    sb.Append($"{item.Name}.Bits");
+				}
+				else if (item.Type == "WAngle")
+				{
+                    sb.Append($"{item.Name}.GetHashCode()");
+				}
+
+				delimiter = " ^ ";
+			}
+
+			sb.Append(";");
+		}
+	}
+}

OpenRA.SourceGenerators/Sync/SyncGenerator.cs

@@ -0,0 +1,65 @@
+using System;
+using System.Collections.Generic;
+using System.Collections.Immutable;
+using System.Diagnostics;
+using System.Linq;
+using System.Text;
+using System.Threading;
+using Microsoft.CodeAnalysis;
+using Microsoft.CodeAnalysis.CSharp;
+using Microsoft.CodeAnalysis.CSharp.Syntax;
+
+namespace OpenRA.SourceGenerators.Sync
+{
+	[Generator]
+	public class SyncGenerator : IIncrementalGenerator
+	{
+		const string SyncGenerationAttribute = "OpenRA.SyncGenerationAttribute";
+		public void Initialize(IncrementalGeneratorInitializationContext context)
+		{
+
+			var enumTypes = context.SyntaxProvider
+								   .ForAttributeWithMetadataName(SyncGenerationAttribute,
+																 CouldBeEnumerationAsync,
+																 GetSyncClassInfo)
+								   .Collect()
+								   .SelectMany((classInfos, _) => classInfos.Distinct());
+
+			context.RegisterSourceOutput(enumTypes, GenerateCode);
+		}
+
+
+		private static bool CouldBeEnumerationAsync(SyntaxNode syntaxNode, CancellationToken cancellationToken)
+		{
+			return syntaxNode is ClassDeclarationSyntax classDeclaration && IsPartial(classDeclaration);
+		}
+
+		private SyncClassInfo GetSyncClassInfo(GeneratorAttributeSyntaxContext context, CancellationToken cancellationToken)
+		{
+			var type = (INamedTypeSymbol)context.TargetSymbol;
+			var enumInfo = new SyncClassInfo(type);
+
+
+
+			return enumInfo;
+		}
+
+		public static bool IsPartial(ClassDeclarationSyntax classDeclaration)
+		{
+			return classDeclaration.Modifiers.Any(m => m.IsKind(SyntaxKind.PartialKeyword));
+		}
+
+		private static void GenerateCode(SourceProductionContext context, SyncClassInfo classInfo)
+		{
+
+			var ns = classInfo.Namespace is null ? null : $"{classInfo.Namespace}.";
+			var code = SyncCodeGenerator.Generate(classInfo);
+
+			if (!String.IsNullOrWhiteSpace(code))
+				context.AddSource($"{ns}{classInfo.Name}.g.cs", code);
+
+		}
+
+	}
+
+}