Cinka/OldThink
1
0
Fork 0
Code Issues Pull Requests Actions 1 Packages Projects Releases Wiki Activity

FIXED: Chemistry JSON dump tool and companion GitHub Action (#6222)

Browse Source 
Co-authored-by: ShadowCommander <10494922+ShadowCommander@users.noreply.github.com>
Co-authored-by: moonheart08 <moonheart08@users.noreply.github.com>
This commit is contained in:
Sam Weaver
2022-01-18 16:44:22 -05:00
committed by GitHub
parent 9d73ff1e26
commit adddd2fac6
27 changed files with 602 additions and 43 deletions
Download Patch File Download Diff File Expand all files Collapse all files

28
Content.Server/Chemistry/ReactionEffects/ExplosionReactionEffect.cs
View File

@@ -1,4 +1,5 @@
using System;
using System.Text.Json.Serialization;
using Content.Server.Chemistry.Components.SolutionManager;
using Content.Server.Explosion.EntitySystems;
using Content.Shared.Administration.Logs;
@@ -12,21 +13,36 @@ namespace Content.Server.Chemistry.ReactionEffects
[DataDefinition]
public class ExplosionReactionEffect : ReagentEffect
{
[DataField("devastationRange")] private float _devastationRange = 1;
[DataField("heavyImpactRange")] private float _heavyImpactRange = 2;
[DataField("lightImpactRange")] private float _lightImpactRange = 3;
[DataField("flashRange")] private float _flashRange;
[DataField("devastationRange")]
[JsonIgnore]
private float _devastationRange = 1;
[DataField("heavyImpactRange")]
[JsonIgnore]
private float _heavyImpactRange = 2;
[DataField("lightImpactRange")]
[JsonIgnore]
private float _lightImpactRange = 3;
[DataField("flashRange")]
[JsonIgnore]
private float _flashRange;
/// <summary>
/// If true, then scale ranges by intensity. If not, the ranges are the same regardless of reactant amount.
/// </summary>
[DataField("scaled")] private bool _scaled;
[DataField("scaled")]
[JsonIgnore]
private bool _scaled;
/// <summary>
/// Maximum scaling on ranges. For example, if it equals 5, then it won't scaled anywhere past
/// 5 times the minimum reactant amount.
/// </summary>
[DataField("maxScale")] private float _maxScale = 1;
[DataField("maxScale")]
[JsonIgnore]
private float _maxScale = 1;
public override bool ShouldLog => true;
public override LogImpact LogImpact => LogImpact.High;

4
Content.Server/Chemistry/ReagentEffects/HealthChange.cs
View File

@@ -1,3 +1,4 @@
using System.Text.Json.Serialization;
using Content.Shared.Chemistry.Reagent;
using Robust.Shared.GameObjects;
using Robust.Shared.Serialization.Manager.Attributes;
@@ -16,6 +17,7 @@ namespace Content.Server.Chemistry.ReagentEffects
/// <summary>
/// Damage to apply every metabolism cycle. Damage Ignores resistances.
/// </summary>
[JsonPropertyName("damage")]
[DataField("damage", required: true)]
public DamageSpecifier Damage = default!;
@@ -23,10 +25,12 @@ namespace Content.Server.Chemistry.ReagentEffects
/// Should this effect scale the damage by the amount of chemical in the solution?
/// Useful for touch reactions, like styptic powder or acid.
/// </summary>
[JsonPropertyName("scaleByQuantity")]
[DataField("scaleByQuantity")]
public bool ScaleByQuantity = false;
[DataField("ignoreResistances")]
[JsonPropertyName("ignoreResistances")]
public bool IgnoreResistances = true;
public override void Effect(ReagentEffectArgs args)

83
Content.Server/Entry/EntryPoint.cs
View File

@@ -1,3 +1,4 @@
using System.IO;
using Content.Server.Administration.Managers;
using Content.Server.Afk;
using Content.Server.AI.Utility;
@@ -8,6 +9,7 @@ using Content.Server.Connection;
using Content.Server.Database;
using Content.Server.EUI;
using Content.Server.GameTicking;
using Content.Server.GuideGenerator;
using Content.Server.Info;
using Content.Server.IoC;
using Content.Server.Maps;
@@ -18,15 +20,19 @@ using Content.Server.Voting.Managers;
using Content.Shared.Actions;
using Content.Shared.Administration;
using Content.Shared.Alert;
using Content.Shared.CCVar;
using Content.Shared.Kitchen;
using Robust.Server;
using Robust.Server.Bql;
using Robust.Server.Player;
using Robust.Shared.Configuration;
using Robust.Server.ServerStatus;
using Robust.Shared.ContentPack;
using Robust.Shared.GameObjects;
using Robust.Shared.IoC;
using Robust.Shared.Log;
using Robust.Shared.Timing;
using Robust.Shared.Utility;
namespace Content.Server.Entry
{
@@ -62,45 +68,66 @@ namespace Content.Server.Entry
IoCManager.BuildGraph();
factory.GenerateNetIds();
var configManager = IoCManager.Resolve<IConfigurationManager>();
var dest = configManager.GetCVar(CCVars.DestinationFile);
if (string.IsNullOrEmpty(dest)) //hacky but it keeps load times for the generator down.
{
_euiManager = IoCManager.Resolve<EuiManager>();
_voteManager = IoCManager.Resolve<IVoteManager>();
_euiManager = IoCManager.Resolve<EuiManager>();
_voteManager = IoCManager.Resolve<IVoteManager>();
IoCManager.Resolve<IChatSanitizationManager>().Initialize();
IoCManager.Resolve<IChatManager>().Initialize();
IoCManager.Resolve<IChatSanitizationManager>().Initialize();
IoCManager.Resolve<IChatManager>().Initialize();
var playerManager = IoCManager.Resolve<IPlayerManager>();
var playerManager = IoCManager.Resolve<IPlayerManager>();
var logManager = IoCManager.Resolve<ILogManager>();
logManager.GetSawmill("Storage").Level = LogLevel.Info;
logManager.GetSawmill("db.ef").Level = LogLevel.Info;
var logManager = IoCManager.Resolve<ILogManager>();
logManager.GetSawmill("Storage").Level = LogLevel.Info;
logManager.GetSawmill("db.ef").Level = LogLevel.Info;
IoCManager.Resolve<IConnectionManager>().Initialize();
IoCManager.Resolve<IServerDbManager>().Init();
IoCManager.Resolve<IServerPreferencesManager>().Init();
IoCManager.Resolve<INodeGroupFactory>().Initialize();
IoCManager.Resolve<IGamePrototypeLoadManager>().Initialize();
_voteManager.Initialize();
IoCManager.Resolve<IConnectionManager>().Initialize();
IoCManager.Resolve<IServerDbManager>().Init();
IoCManager.Resolve<IServerPreferencesManager>().Init();
IoCManager.Resolve<INodeGroupFactory>().Initialize();
IoCManager.Resolve<IGamePrototypeLoadManager>().Initialize();
_voteManager.Initialize();
}
}
public override void PostInit()
{
base.PostInit();
IoCManager.Resolve<ISandboxManager>().Initialize();
IoCManager.Resolve<RecipeManager>().Initialize();
IoCManager.Resolve<ActionManager>().Initialize();
IoCManager.Resolve<BlackboardManager>().Initialize();
IoCManager.Resolve<ConsiderationsManager>().Initialize();
IoCManager.Resolve<IAdminManager>().Initialize();
IoCManager.Resolve<INpcBehaviorManager>().Initialize();
IoCManager.Resolve<IAfkManager>().Initialize();
IoCManager.Resolve<RulesManager>().Initialize();
_euiManager.Initialize();
var configManager = IoCManager.Resolve<IConfigurationManager>();
var resourceManager = IoCManager.Resolve<IResourceManager>();
var dest = configManager.GetCVar(CCVars.DestinationFile);
if (!string.IsNullOrEmpty(dest))
{
var resPath = new ResourcePath(dest).ToRootedPath();
var file = resourceManager.UserData.OpenWriteText(resPath.WithName("chem_" + dest));
ChemistryJsonGenerator.PublishJson(file);
file.Flush();
file = resourceManager.UserData.OpenWriteText(resPath.WithName("react_" + dest));
ReactionJsonGenerator.PublishJson(file);
file.Flush();
IoCManager.Resolve<IBaseServer>().Shutdown("Data generation done");
}
else
{
IoCManager.Resolve<ISandboxManager>().Initialize();
IoCManager.Resolve<RecipeManager>().Initialize();
IoCManager.Resolve<ActionManager>().Initialize();
IoCManager.Resolve<BlackboardManager>().Initialize();
IoCManager.Resolve<ConsiderationsManager>().Initialize();
IoCManager.Resolve<IAdminManager>().Initialize();
IoCManager.Resolve<INpcBehaviorManager>().Initialize();
IoCManager.Resolve<IAfkManager>().Initialize();
IoCManager.Resolve<RulesManager>().Initialize();
_euiManager.Initialize();
IoCManager.Resolve<IGameMapManager>().Initialize();
IoCManager.Resolve<IEntitySystemManager>().GetEntitySystem<GameTicker>().PostInitialize();
IoCManager.Resolve<IBqlQueryManager>().DoAutoRegistrations();
IoCManager.Resolve<IGameMapManager>().Initialize();
IoCManager.Resolve<IEntitySystemManager>().GetEntitySystem<GameTicker>().PostInitialize();
IoCManager.Resolve<IBqlQueryManager>().DoAutoRegistrations();
}
}
public override void Update(ModUpdateLevel level, FrameEventArgs frameEventArgs)

70
Content.Server/GuideGenerator/ChemistryJsonGenerator.cs Normal file
View File

@@ -0,0 +1,70 @@
using System;
using System.IO;
using System.Linq;
using System.Text.Json;
using System.Text.Json.Serialization;
using Content.Shared.Chemistry.Reaction;
using Content.Shared.Chemistry.Reagent;
using Content.Shared.Damage;
using Content.Shared.FixedPoint;
using Robust.Shared.IoC;
using Robust.Shared.Prototypes;
namespace Content.Server.GuideGenerator;
public class ChemistryJsonGenerator
{
public static void PublishJson(StreamWriter file)
{
var prototype = IoCManager.Resolve<IPrototypeManager>();
var prototypes =
prototype
.EnumeratePrototypes<ReagentPrototype>()
.Where(x => !x.Abstract)
.Select(x => new ReagentEntry(x))
.ToDictionary(x => x.Id, x => x);
var reactions =
prototype
.EnumeratePrototypes<ReactionPrototype>()
.Where(x => x.Products.Count != 0);
foreach (var reaction in reactions)
{
foreach (var product in reaction.Products.Keys)
{
prototypes[product].Recipes.Add(reaction.ID);
}
}
var serializeOptions = new JsonSerializerOptions
{
WriteIndented = true,
Converters =
{
new UniversalJsonConverter<ReagentEffect>(),
new UniversalJsonConverter<ReagentEffectCondition>(),
new UniversalJsonConverter<ReagentEffectsEntry>(),
new UniversalJsonConverter<DamageSpecifier>(),
new FixedPointJsonConverter()
}
};
file.Write(JsonSerializer.Serialize(prototypes, serializeOptions));
}
public class FixedPointJsonConverter : JsonConverter<FixedPoint2>
{
public override void Write(Utf8JsonWriter writer, FixedPoint2 value, JsonSerializerOptions options)
{
writer.WriteNumberValue(value.Float());
}
public override FixedPoint2 Read(ref Utf8JsonReader reader, Type objectType, JsonSerializerOptions options)
{
// Throwing a NotSupportedException here allows the error
// message to provide path information.
throw new NotSupportedException();
}
}
}

36
Content.Server/GuideGenerator/ReactionJsonGenerator.cs Normal file
View File

@@ -0,0 +1,36 @@
using System.IO;
using System.Linq;
using System.Text.Json;
using Content.Shared.Chemistry.Reaction;
using Content.Shared.Chemistry.Reagent;
using Content.Shared.FixedPoint;
using Robust.Shared.IoC;
using Robust.Shared.Prototypes;
namespace Content.Server.GuideGenerator;
public class ReactionJsonGenerator
{
public static void PublishJson(StreamWriter file)
{
var prototype = IoCManager.Resolve<IPrototypeManager>();
var reactions =
prototype
.EnumeratePrototypes<ReactionPrototype>()
.Select(x => new ReactionEntry(x))
.ToDictionary(x => x.Id, x => x);
var serializeOptions = new JsonSerializerOptions
{
WriteIndented = true,
Converters =
{
new UniversalJsonConverter<ReagentEffect>(),
}
};
file.Write(JsonSerializer.Serialize(reactions, serializeOptions));
}
}

96
Content.Server/GuideGenerator/ReagentEntry.cs Normal file
View File

@@ -0,0 +1,96 @@
using System.Collections.Generic;
using System.Linq;
using System.Text.Json.Serialization;
using Content.Server.Body.Components;
using Content.Shared.Chemistry.Reaction;
using Content.Shared.Chemistry.Reagent;
using Robust.Shared.Maths;
using Robust.Shared.Serialization.Manager.Attributes;
namespace Content.Server.GuideGenerator;
public class ReagentEntry
{
[JsonPropertyName("id")]
public string Id { get; }
[JsonPropertyName("name")]
public string Name { get; }
[JsonPropertyName("group")]
public string Group { get; }
[JsonPropertyName("desc")]
public string Description { get; }
[JsonPropertyName("physicalDesc")]
public string PhysicalDescription { get; }
[JsonPropertyName("color")]
public string SubstanceColor { get; }
[JsonPropertyName("recipes")]
public List<string> Recipes { get; } = new();
[JsonPropertyName("metabolisms")]
public Dictionary<string, ReagentEffectsEntry>? Metabolisms { get; }
public ReagentEntry(ReagentPrototype proto)
{
Id = proto.ID;
Name = proto.Name;
Group = proto.Group;
Description = proto.Description;
PhysicalDescription = proto.PhysicalDescription;
SubstanceColor = proto.SubstanceColor.ToHex();
Metabolisms = proto.Metabolisms;
}
}
public class ReactionEntry
{
[JsonPropertyName("id")]
public string Id { get; }
[JsonPropertyName("name")]
public string Name { get; }
[JsonPropertyName("reactants")]
public Dictionary<string, ReactantEntry> Reactants { get; }
[JsonPropertyName("products")]
public Dictionary<string, float> Products { get; }
[JsonPropertyName("effects")]
public List<ReagentEffect> Effects { get; }
public ReactionEntry(ReactionPrototype proto)
{
Id = proto.ID;
Name = proto.Name;
Reactants =
proto.Reactants
.Select(x => KeyValuePair.Create(x.Key, new ReactantEntry(x.Value.Amount.Float(), x.Value.Catalyst)))
.ToDictionary(x => x.Key, x => x.Value);
Products =
proto.Products
.Select(x => KeyValuePair.Create(x.Key, x.Value.Float()))
.ToDictionary(x => x.Key, x => x.Value);
Effects = proto.Effects;
}
}
public class ReactantEntry
{
[JsonPropertyName("amount")]
public float Amount { get; }
[JsonPropertyName("catalyst")]
public bool Catalyst { get; }
public ReactantEntry(float amnt, bool cata)
{
Amount = amnt;
Catalyst = cata;
}
}

102
Content.Server/GuideGenerator/UniversalJsonConverter.cs Normal file
View File

@@ -0,0 +1,102 @@
using System;
using System.Collections.Generic;
using System.Reflection;
using System.Text.Json;
using System.Text.Json.Serialization;
namespace Content.Server.GuideGenerator
{
// This class is used as a shim to help do polymorphic serialization of objects into JSON
// (serializing objects that inherit abstract base classes or interfaces) since
// System.Text.Json (our new JSON solution) doesn't support that while Newtonsoft.Json (our old
// solution) does.
public class UniversalJsonConverter<T> : JsonConverter<T>
{
// This converter can only convert types that are T or descend from T.
public override bool CanConvert(Type typeToConvert)
{
return typeof(T).IsAssignableFrom(typeToConvert);
}
// We don't support deserialization right now. In order to do so, we'd need to bundle a
// field like "$type" with our objects so they'd be reserialized into the correct base class
// but that presents a security hazard.
public override T Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
{
// Throwing a NotImplementedException here allows the Utf8JsonReader to provide
// an error message that provides the specific JSON path of the problematic object
// rather than a generic error message. At least in theory. Haven't tested that.
throw new NotImplementedException();
}
// The bread and butter. Deserialize an object of parameter type T.
// This method is automatically called when the JSON writer finds an object of a type
// where we've registered this class as its converter using the [JsonConverter(...)] attribute
public override void Write(Utf8JsonWriter writer, T obj, JsonSerializerOptions options)
{
// If the object is null, don't include it.
if (obj is null)
{
writer.WriteNullValue();
return;
}
// Use reflection to get a list of fields and properties on the object we're serializing.
// Using obj.GetType() here instead of typeof(T) allows us to get the true base class rather
// than the abstract ancestor, even if we're parameterized with that abstract class.
FieldInfo[] fields = obj.GetType().GetFields(BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance);
PropertyInfo[] properties = obj.GetType().GetProperties(BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance);
// Since the JSON writer will have already written the field name, we need to write the object itself.
// Since we only use this class to serialize complex objects, we know we'll be writing a JSON object, so open one.
writer.WriteStartObject();
// For each field, try to write it into the object.
foreach (FieldInfo field in fields)
{
// If the field has a [JsonIgnore] attribute, skip it
if (Attribute.GetCustomAttribute(field, typeof(JsonIgnoreAttribute), true) != null) continue;
// exclude fields that are compiler autogenerated like "__BackingField" fields
if (Attribute.GetCustomAttribute(field, typeof(System.Runtime.CompilerServices.CompilerGeneratedAttribute), true) != null) continue;
// If the field has a [JsonPropertyName] attribute, get the property name. Otherwise, use the field name.
JsonPropertyNameAttribute? attr = (JsonPropertyNameAttribute?) Attribute.GetCustomAttribute(field, typeof(JsonPropertyNameAttribute), true);
string name = attr == null ? field.Name : attr.Name;
// Write a new key/value pair into the JSON object itself.
WriteKV(writer, name, field.GetValue(obj), options);
}
// Repeat the same process for each property.
foreach (PropertyInfo prop in properties)
{
// If the field has a [JsonIgnore] attribute, skip it
if (Attribute.GetCustomAttribute(prop, typeof(JsonIgnoreAttribute), true) != null) continue;
// If the property has a [JsonPropertyName] attribute, get the property name. Otherwise, use the property name.
JsonPropertyNameAttribute? attr = (JsonPropertyNameAttribute?) Attribute.GetCustomAttribute(prop, typeof(JsonPropertyNameAttribute), true);
string name = attr == null ? prop.Name : attr.Name;
// Write a new key/value pair into the JSON object itself.
WriteKV(writer, name, prop.GetValue(obj), options);
}
// Close the object, we're done!
writer.WriteEndObject();
}
// This is a little utility method to write a key/value pair inside a JSON object.
// It's used for all the actual writing.
public void WriteKV(Utf8JsonWriter writer, string key, object? obj, JsonSerializerOptions options)
{
// First, write the property name
writer.WritePropertyName(key);
// Then, recurse. This ensures that primitive values will be written directly, while
// more complex values can use any custom converters we've registered (like this one.)
JsonSerializer.Serialize(writer, obj, options);
}
}
}