Add sourcegenned field deltas (#5155)

* Remove full "delta" states

* Update MapGridComponentState

* abstract ComponentState

* Release notes

* Fix tests

* Fix nullable errors

* A

* Sourcegen component deltas

* Audio deltas + methids

* Also eye

* Optimise out the dictionary

* Minor fixes

* Physics deltas

* Also this

* Fix field deltas

* remove old release notes

* Make IComponentDelta implement IComponent

* add sourcegen launch settings

* make silent error loud

* Review

* UI deltas

* Slimmer

* Sourcegen bandaid

---------

Co-authored-by: ElectroJr <leonsfriedrich@gmail.com>
This commit is contained in:
metalgearsloth
2024-12-21 15:48:33 +11:00
committed by GitHub
parent ac30ad1820
commit 9837c33de7
28 changed files with 1057 additions and 327 deletions

View File

@@ -36,7 +36,9 @@ namespace Robust.Shared.CompNetworkGenerator
private static readonly SymbolDisplayFormat FullNullableFormat =
FullyQualifiedFormat.WithMiscellaneousOptions(IncludeNullableReferenceTypeModifier);
private static string? GenerateSource(in GeneratorExecutionContext context, INamedTypeSymbol classSymbol, CSharpCompilation comp, bool raiseAfterAutoHandle)
private static string? GenerateSource(in GeneratorExecutionContext context, INamedTypeSymbol classSymbol, CSharpCompilation comp,
bool raiseAfterAutoHandle,
bool fieldDeltas)
{
var nameSpace = classSymbol.ContainingNamespace.ToDisplayString();
var componentName = classSymbol.Name;
@@ -134,54 +136,154 @@ namespace Robust.Shared.CompNetworkGenerator
// component.Count = state.Count;
var handleStateSetters = new StringBuilder();
// Builds the string for copying delta fields in IComponentDelta to a new full state.
var deltaCreate = new StringBuilder();
// Delta field states
var deltaGetFields = new StringBuilder();
var deltaHandleFields = new StringBuilder();
// Apply the delta field to the full state.
var deltaApply = new List<string>();
var index = -1;
var fieldsStr = new StringBuilder();
var fieldStates = new StringBuilder();
var networkedTypes = new List<string>();
foreach (var (type, name) in fields)
{
index++;
if (index == 0)
{
fieldsStr.Append(@$"""{name}""");
}
else
{
fieldsStr.Append(@$", ""{name}""");
}
var typeDisplayStr = type.ToDisplayString(FullNullableFormat);
var nullable = type.NullableAnnotation == NullableAnnotation.Annotated;
var nullableAnnotation = nullable ? "?" : string.Empty;
string deltaStateName = $"{name}_FieldComponentState";
// The type used for networking, e.g. EntityUid -> NetEntity
string networkedType;
string getField;
string? cast;
// TODO: Uhh I just need casts or something.
var castString = typeDisplayStr.Substring(8);
deltaGetFields.Append(@$"
case {Math.Pow(2, index)}:
args.State = new {deltaStateName}()
{{
");
deltaHandleFields.Append(@$"
case {deltaStateName} {deltaStateName}_State:
{{
");
var fieldHandleValue = $"{deltaStateName}_State.{name}!";
switch (typeDisplayStr)
{
case GlobalEntityUidName:
case GlobalNullableEntityUidName:
stateFields.Append($@"
public NetEntity{nullableAnnotation} {name} = default!;");
networkedType = $"NetEntity{nullableAnnotation}";
stateFields.Append($@"
public {networkedType} {name} = default!;");
getField = $"GetNetEntity(component.{name})";
cast = $"(NetEntity{nullableAnnotation})";
getStateInit.Append($@"
{name} = GetNetEntity(component.{name}),");
handleStateSetters.Append($@"
component.{name} = EnsureEntity<{componentName}>(state.{name}, uid);");
component.{name} = EnsureEntity<{componentName}>(state.{name}, uid);");
deltaHandleFields.Append($@"
component.{name} = EnsureEntity<{componentName}>({cast} {fieldHandleValue}, uid);");
deltaCreate.Append($@"
{name} = fullState.{name},");
deltaApply.Add($@"
fullState.{name} = {name};");
break;
case GlobalEntityCoordinatesName:
case GlobalNullableEntityCoordinatesName:
stateFields.Append($@"
public NetCoordinates{nullableAnnotation} {name} = default!;");
networkedType = $"NetCoordinates{nullableAnnotation}";
stateFields.Append($@"
public {networkedType} {name} = default!;");
getField = $"GetNetCoordinates(component.{name})";
cast = $"(NetCoordinates{nullableAnnotation})";
getStateInit.Append($@"
{name} = GetNetCoordinates(component.{name}),");
handleStateSetters.Append($@"
component.{name} = EnsureCoordinates<{componentName}>(state.{name}, uid);");
component.{name} = EnsureCoordinates<{componentName}>(state.{name}, uid);");
deltaHandleFields.Append($@"
component.{name} = EnsureCoordinates<{componentName}>({cast} {fieldHandleValue}, uid);");
deltaCreate.Append($@"
{name} = fullState.{name},");
deltaApply.Add($@"
fullState.{name} = {name};");
break;
case GlobalEntityUidSetName:
stateFields.Append($@"
public {GlobalNetEntityUidSetName} {name} = default!;");
networkedType = $"{GlobalNetEntityUidSetName}";
stateFields.Append($@"
public {networkedType} {name} = default!;");
getField = $"GetNetEntitySet(component.{name})";
cast = $"({GlobalNetEntityUidSetName})";
getStateInit.Append($@"
{name} = GetNetEntitySet(component.{name}),");
handleStateSetters.Append($@"
EnsureEntitySet<{componentName}>(state.{name}, uid, component.{name});");
EnsureEntitySet<{componentName}>(state.{name}, uid, component.{name});");
deltaHandleFields.Append($@"
EnsureEntitySet<{componentName}>({cast} {fieldHandleValue}, uid, component.{name});");
deltaCreate.Append($@"
{name} = new(fullState.{name}),");
deltaApply.Add($@"
fullState.{name} = {name};");
break;
case GlobalEntityUidListName:
stateFields.Append($@"
public {GlobalNetEntityUidListName} {name} = default!;");
networkedType = $"{GlobalNetEntityUidListName}";
stateFields.Append($@"
public {networkedType} {name} = default!;");
getField = $"GetNetEntityList(component.{name})";
cast = $"({GlobalNetEntityUidListName})";
getStateInit.Append($@"
{name} = GetNetEntityList(component.{name}),");
handleStateSetters.Append($@"
EnsureEntityList<{componentName}>(state.{name}, uid, component.{name});");
EnsureEntityList<{componentName}>(state.{name}, uid, component.{name});");
deltaHandleFields.Append($@"
EnsureEntityList<{componentName}>({cast} {fieldHandleValue}, uid, component.{name});");
deltaCreate.Append($@"
{name} = new(fullState.{name}),");
deltaApply.Add($@"
fullState.{name} = {name};");
break;
default:
@@ -205,69 +307,150 @@ namespace Robust.Shared.CompNetworkGenerator
ensureGeneric = componentName;
}
stateFields.Append($@"
public Dictionary<{key}, {value}> {name} = default!;");
networkedType = $"Dictionary<{key}, {value}>";
getStateInit.Append($@"
{name} = GetNetEntityDictionary(component.{name}),");
stateFields.Append($@"
public {networkedType} {name} = default!;");
getField = $"GetNetEntityDictionary(component.{name})";
if (valueNullable && value is not GlobalNetEntityName and not GlobalNetEntityNullableName)
{
cast = $"(Dictionary<{key}, {value}>)";
handleStateSetters.Append($@"
EnsureEntityDictionaryNullableValue<{componentName}, {value}>(state.{name}, uid, component.{name});");
EnsureEntityDictionaryNullableValue<{componentName}, {value}>(state.{name}, uid, component.{name});");
deltaHandleFields.Append($@"
EnsureEntityDictionaryNullableValue<{componentName}, {value}>({cast} {fieldHandleValue}, uid, component.{name});");
}
else
{
cast = $"({castString})";
handleStateSetters.Append($@"
EnsureEntityDictionary<{ensureGeneric}>(state.{name}, uid, component.{name});");
EnsureEntityDictionary<{ensureGeneric}>(state.{name}, uid, component.{name})");
deltaHandleFields.Append($@"
EnsureEntityDictionary<{ensureGeneric}>({cast} {fieldHandleValue}, uid, component.{name});");
}
deltaCreate.Append($@"
{name} = new(fullState.{name}),");
deltaApply.Add($@"
fullState.{name} = {name};");
break;
}
if (value is GlobalEntityUidName or GlobalNullableEntityUidName)
{
networkedType = $"Dictionary<{key}, {value}>";
value = valueNullable ? GlobalNetEntityNullableName : GlobalNetEntityName;
stateFields.Append($@"
public Dictionary<{key}, {value}> {name} = default!;");
public {networkedType} {name} = default!;");
getField = $"GetNetEntityDictionary(component.{name})";
cast = $"(Dictionary<{key}, {value}>)";
getStateInit.Append($@"
{name} = GetNetEntityDictionary(component.{name}),");
handleStateSetters.Append($@"
EnsureEntityDictionary<{componentName}, {key}>(state.{name}, uid, component.{name});");
EnsureEntityDictionary<{componentName}, {key}>(state.{name}, uid, component.{name});");
deltaHandleFields.Append($@"
EnsureEntityDictionary<{componentName}, {key}>({cast} {fieldHandleValue}, uid, component.{name});");
deltaCreate.Append($@"
{name} = new(fullState.{name}),");
deltaApply.Add($@"
fullState.{name} = {name};");
break;
}
}
networkedType = $"{typeDisplayStr}";
stateFields.Append($@"
public {typeDisplayStr} {name} = default!;");
public {networkedType} {name} = default!;");
if (IsCloneType(type))
{
// get first ctor arg of the field attribute, which determines whether the field should be cloned
// (like if its a dict or list)
getStateInit.Append($@"
{name} = component.{name},");
getField = $"component.{name}";
cast = $"({castString})";
var nullCast = nullable ? castString.Substring(0, castString.Length - 1) : castString;
handleStateSetters.Append($@"
if (state.{name} == null)
component.{name} = null!;
else
component.{name} = new(state.{name});");
deltaHandleFields.Append($@"
var {name}Value = {cast} {fieldHandleValue};
if ({name}Value == null)
component.{name} = null!;
else
component.{name} = new {nullCast}({name}Value);");
if (nullable)
{
deltaCreate.Append($@"
{name} = fullState.{name} == null ? null : new(fullState.{name}),");
}
else
{
deltaCreate.Append($@"
{name} = new(fullState.{name}),");
}
deltaApply.Add($@"
if ({name} == null)
fullState.{name} = null!;
else
fullState.{name} = new({name});");
}
else
{
getStateInit.Append($@"
{name} = component.{name},");
getField = $"component.{name}";
cast = $"({castString})";
handleStateSetters.Append($@"
component.{name} = state.{name};");
deltaHandleFields.Append($@"
component.{name} = {cast} {fieldHandleValue};");
deltaCreate.Append($@"
{name} = fullState.{name},");
deltaApply.Add($@"
fullState.{name} = {name};");
}
break;
}
/*
* End loop stuff
*/
networkedTypes.Add(networkedType);
getStateInit.Append($@"
{name} = {getField},");
deltaGetFields.Append(@$" {name} = {getField}
}};
return;");
deltaHandleFields.Append($@"
}}
break;");
}
var eventRaise = "";
@@ -278,19 +461,94 @@ namespace Robust.Shared.CompNetworkGenerator
EntityManager.EventBus.RaiseComponentEvent(uid, component, ref ev);";
}
var deltaGetState = "";
var deltaHandleState = "";
var deltaInterface = "";
var deltaCompFields = "";
var deltaNetRegister = "";
if (fieldDeltas)
{
for (var i = 0; i < fields.Count; i++)
{
var name = fields[i].FieldName;
string deltaStateName = $"{name}_FieldComponentState";
var networkedType = networkedTypes[i];
var apply = deltaApply[i];
// Creates a state per field
fieldStates.Append($@"
[Serializable, NetSerializable]
public sealed class {deltaStateName} : IComponentDeltaState<{stateName}>
{{
public {networkedType} {name} = default!;
public void ApplyToFullState({stateName} fullState)
{{{apply}
}}
public {stateName} CreateNewFullState({stateName} fullState)
{{
var newState = new {stateName}
{{{deltaCreate}
}};
{apply}
return newState;
}}
}}
");
}
deltaNetRegister = $@"EntityManager.ComponentFactory.RegisterNetworkedFields<{classSymbol}>({fieldsStr});";
deltaGetState = @$"// Delta state
if (component is IComponentDelta delta && args.FromTick > component.CreationTick && delta.LastFieldUpdate >= args.FromTick)
{{
var fields = EntityManager.GetModifiedFields(component, args.FromTick);
// Try and get a matching delta state for the relevant dirty fields, otherwise fall back to full state.
switch (fields)
{{{deltaGetFields}
default:
break;
}}
}}";
deltaHandleState = $@"switch(args.Current)
{{{deltaHandleFields}
default:
break;
}}";
deltaInterface = " : IComponentDelta";
deltaCompFields = @$"/// <inheritdoc />
public GameTick LastFieldUpdate {{ get; set; }} = GameTick.Zero;
/// <inheritdoc />
public GameTick[] LastModifiedFields {{ get; set; }} = Array.Empty<GameTick>();";
}
return $@"// <auto-generated />
#nullable enable
using System;
using Robust.Shared.GameStates;
using Robust.Shared.GameObjects;
using Robust.Shared.Analyzers;
using Robust.Shared.Collections;
using Robust.Shared.Serialization;
using Robust.Shared.Map;
using Robust.Shared.Timing;
using Robust.Shared.Utility;
using System.Collections.Generic;
namespace {nameSpace};
public partial class {componentName}
public partial class {componentName}{deltaInterface}
{{
{deltaCompFields}
[System.Serializable, NetSerializable]
public sealed class {stateName} : IComponentState
{{{stateFields}
@@ -301,12 +559,16 @@ public partial class {componentName}
{{
public override void Initialize()
{{
{deltaNetRegister}
SubscribeLocalEvent<{componentName}, ComponentGetState>(OnGetState);
SubscribeLocalEvent<{componentName}, ComponentHandleState>(OnHandleState);
}}
private void OnGetState(EntityUid uid, {componentName} component, ref ComponentGetState args)
{{
{deltaGetState}
// Get full state
args.State = new {stateName}
{{{getStateInit}
}};
@@ -314,11 +576,15 @@ public partial class {componentName}
private void OnHandleState(EntityUid uid, {componentName} component, ref ComponentHandleState args)
{{
{deltaHandleState}
if (args.Current is not {stateName} state)
return;
{handleStateSetters}{eventRaise}
}}
}}
{fieldStates}
}}
";
}
@@ -341,13 +607,15 @@ public partial class {componentName}
{
var attr = type.Attribute;
var raiseEv = false;
if (attr.ConstructorArguments is [{Value: bool raise}])
var fieldDeltas = false;
if (attr.ConstructorArguments is [{Value: bool raise}, {Value: bool fields}])
{
// Get the afterautohandle bool, which is first constructor arg
raiseEv = raise;
fieldDeltas = fields;
}
var source = GenerateSource(context, type.Type, comp, raiseEv);
var source = GenerateSource(context, type.Type, comp, raiseEv, fieldDeltas);
// can be null if no members marked with network field, which already has a diagnostic, so
// just continue
if (source == null)

View File

@@ -0,0 +1,9 @@
{
"$schema": "http://json.schemastore.org/launchsettings.json",
"profiles": {
"Comp State Generator": {
"commandName": "DebugRoslynComponent",
"targetProject": "../../Content.Shared/Content.Shared.csproj"
}
}
}