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

Change all of body system to use entities and components (#2074)

Browse Source 
* Early commit

* Early commit 2

* merging master broke my git

* does anyone even read these

* life is fleeting

* it just works

* this time passing integration tests

* Remove hashset yaml serialization for now

* You got a license for those nullables?

* No examine, no context menu, part and mechanism parenting and visibility

* Fix wrong brain sprite state

* Removing layers was a mistake

* just tear body system a new one and see if it still breathes

* Remove redundant code

* Add that comment back

* Separate damage and body, component states, stomach rework

* Add containers for body parts

* Bring layers back pls

* Fix parts magically changing color

* Reimplement sprite layer visibility

* Fix tests

* Add leg test

* Active legs is gone

Crab rave

* Merge fixes, rename DamageState to CurrentState

* Remove IShowContextMenu and ICanExamine
This commit is contained in:
DrSmugleaf
2020-10-10 15:25:13 +02:00
committed by GitHub
parent 73c730d06c
commit dd385a0511
165 changed files with 4232 additions and 4650 deletions
Download Patch File Download Diff File Expand all files Collapse all files

73
Content.Shared/Body/Mechanism/MechanismPrototype.cs
View File

@@ -1,73 +0,0 @@
using System;
using System.Collections.Generic;
using Content.Shared.GameObjects.Components.Body;
using Robust.Shared.Prototypes;
using Robust.Shared.Serialization;
using Robust.Shared.ViewVariables;
using YamlDotNet.RepresentationModel;
namespace Content.Shared.Body.Mechanism
{
/// <summary>
/// Prototype for the Mechanism class.
/// </summary>
[Prototype("mechanism")]
[Serializable, NetSerializable]
public class MechanismPrototype : IPrototype, IIndexedPrototype
{
private List<string> _behaviorClasses;
private BodyPartCompatibility _compatibility;
private string _description;
private int _destroyThreshold;
private int _durability;
private string _examineMessage;
private string _id;
private string _name;
private int _resistance;
private string _rsiPath;
private string _rsiState;
private int _size;
[ViewVariables] public string Name => _name;
[ViewVariables] public string Description => _description;
[ViewVariables] public string ExamineMessage => _examineMessage;
[ViewVariables] public string RSIPath => _rsiPath;
[ViewVariables] public string RSIState => _rsiState;
[ViewVariables] public int Durability => _durability;
[ViewVariables] public int DestroyThreshold => _destroyThreshold;
[ViewVariables] public int Resistance => _resistance;
[ViewVariables] public int Size => _size;
[ViewVariables] public BodyPartCompatibility Compatibility => _compatibility;
[ViewVariables] public List<string> BehaviorClasses => _behaviorClasses;
[ViewVariables] public string ID => _id;
public virtual void LoadFrom(YamlMappingNode mapping)
{
var serializer = YamlObjectSerializer.NewReader(mapping);
serializer.DataField(ref _id, "id", string.Empty);
serializer.DataField(ref _name, "name", string.Empty);
serializer.DataField(ref _description, "description", string.Empty);
serializer.DataField(ref _examineMessage, "examineMessage", string.Empty);
serializer.DataField(ref _rsiPath, "rsiPath", string.Empty);
serializer.DataField(ref _rsiState, "rsiState", string.Empty);
serializer.DataField(ref _durability, "durability", 0);
serializer.DataField(ref _destroyThreshold, "destroyThreshold", 0);
serializer.DataField(ref _resistance, "resistance", 0);
serializer.DataField(ref _size, "size", 2);
serializer.DataField(ref _compatibility, "compatibility", BodyPartCompatibility.Universal);
serializer.DataField(ref _behaviorClasses, "behaviors", new List<string>());
}
}
}

105
Content.Shared/Body/Part/BodyPartPrototype.cs
View File

@@ -1,105 +0,0 @@
using System;
using System.Collections.Generic;
using System.Linq;
using Content.Shared.GameObjects.Components.Body;
using Robust.Shared.Interfaces.Serialization;
using Robust.Shared.Prototypes;
using Robust.Shared.Serialization;
using Robust.Shared.ViewVariables;
using YamlDotNet.RepresentationModel;
namespace Content.Shared.Body.Part
{
/// <summary>
/// Prototype for the BodyPart class.
/// </summary>
[Prototype("bodyPart")]
[Serializable, NetSerializable]
public class BodyPartPrototype : IPrototype, IIndexedPrototype
{
private BodyPartCompatibility _compatibility;
private string _damageContainerPresetId;
private int _destroyThreshold;
private int _durability;
private string _id;
private List<string> _mechanisms;
private string _name;
private BodyPartType _partType;
private string _plural;
private List<IExposeData> _properties;
private float _resistance;
private string _resistanceSetId;
private string _rsiPath;
private string _rsiState;
private int _size;
private string _surgeryDataName;
private bool _isVital;
[ViewVariables] public string Name => _name;
[ViewVariables] public string Plural => _plural;
[ViewVariables] public string RSIPath => _rsiPath;
[ViewVariables] public string RSIState => _rsiState;
[ViewVariables] public BodyPartType PartType => _partType;
[ViewVariables] public int Durability => _durability;
[ViewVariables] public int DestroyThreshold => _destroyThreshold;
[ViewVariables] public float Resistance => _resistance;
[ViewVariables] public int Size => _size;
[ViewVariables] public BodyPartCompatibility Compatibility => _compatibility;
[ViewVariables] public string DamageContainerPresetId => _damageContainerPresetId;
[ViewVariables] public string ResistanceSetId => _resistanceSetId;
[ViewVariables] public string SurgeryDataName => _surgeryDataName;
[ViewVariables] public List<IExposeData> Properties => _properties;
[ViewVariables] public List<string> Mechanisms => _mechanisms;
[ViewVariables] public string ID => _id;
[ViewVariables] public bool IsVital => _isVital;
public virtual void LoadFrom(YamlMappingNode mapping)
{
var serializer = YamlObjectSerializer.NewReader(mapping);
serializer.DataField(ref _name, "name", string.Empty);
serializer.DataField(ref _id, "id", string.Empty);
serializer.DataField(ref _plural, "plural", string.Empty);
serializer.DataField(ref _rsiPath, "rsiPath", string.Empty);
serializer.DataField(ref _rsiState, "rsiState", string.Empty);
serializer.DataField(ref _partType, "partType", BodyPartType.Other);
serializer.DataField(ref _surgeryDataName, "surgeryDataType", "BiologicalSurgeryData");
serializer.DataField(ref _durability, "durability", 50);
serializer.DataField(ref _destroyThreshold, "destroyThreshold", -50);
serializer.DataField(ref _resistance, "resistance", 0f);
serializer.DataField(ref _size, "size", 0);
serializer.DataField(ref _compatibility, "compatibility", BodyPartCompatibility.Universal);
serializer.DataField(ref _damageContainerPresetId, "damageContainer", string.Empty);
serializer.DataField(ref _resistanceSetId, "resistances", string.Empty);
serializer.DataField(ref _properties, "properties", new List<IExposeData>());
serializer.DataField(ref _mechanisms, "mechanisms", new List<string>());
serializer.DataField(ref _isVital, "isVital", false);
foreach (var property in _properties)
{
if (_properties.Count(x => x.GetType() == property.GetType()) > 1)
{
throw new InvalidOperationException(
$"Multiple {nameof(BodyPartPrototype)} of the same type were defined in prototype {ID}");
}
}
}
}
}

23
Content.Shared/Body/Part/Properties/BodyPartProperty.cs
View File

@@ -1,23 +0,0 @@
using Robust.Shared.Interfaces.Serialization;
using Robust.Shared.Serialization;
namespace Content.Shared.Body.Part.Properties
{
/// <summary>
/// Property attachable to a <see cref="BodyPart"/>.
/// For example, this is used to define the speed capabilities of a
/// leg. The movement system will look for a LegProperty on all BodyParts.
/// </summary>
public abstract class BodyPartProperty : IExposeData
{
/// <summary>
/// Whether this property is currently active.
/// </summary>
public bool Active;
public virtual void ExposeData(ObjectSerializer serializer)
{
serializer.DataField(ref Active, "active", true);
}
}
}

11
Content.Shared/Body/Part/Properties/Movement/FootProperty.cs
View File

@@ -1,11 +0,0 @@
namespace Content.Shared.Body.Part.Properties.Movement
{
/// <summary>
/// Defines the leg-based locomotion ability of a BodyPart. Required for humanoid-like movement. Must be connected to a
/// <see cref="BodyPart" /> with
/// <see cref="LegProperty" /> and <see cref="ExtensionProperty" /> to work.
/// </summary>
public class FootProperty : BodyPartProperty
{
}
}

23
Content.Shared/Body/Part/Properties/Movement/LegProperty.cs
View File

@@ -1,23 +0,0 @@
using Robust.Shared.Serialization;
namespace Content.Shared.Body.Part.Properties.Movement
{
/// <summary>
/// Defines the speed of humanoid-like movement. Must be connected to a
/// <see cref="BodyPart" /> with <see cref="FootProperty" /> and have
/// <see cref="ExtensionProperty" /> on the same organ and down to the foot to work.
/// </summary>
public class LegProperty : BodyPartProperty
{
/// <summary>
/// Speed (in tiles per second).
/// </summary>
public float Speed;
public override void ExposeData(ObjectSerializer serializer)
{
base.ExposeData(serializer);
serializer.DataField(ref Speed, "speed", 1f);
}
}
}

21
Content.Shared/Body/Part/Properties/Other/ExtensionProperty.cs
View File

@@ -1,21 +0,0 @@
using Robust.Shared.Serialization;
namespace Content.Shared.Body.Part.Properties.Other
{
/// <summary>
/// Defines the extension ability of a BodyPart. Used to determine things like reach distance and running speed.
/// </summary>
public class ExtensionProperty : BodyPartProperty
{
/// <summary>
/// Current reach distance (in tiles).
/// </summary>
public float ReachDistance;
public override void ExposeData(ObjectSerializer serializer)
{
base.ExposeData(serializer);
serializer.DataField(ref ReachDistance, "reachDistance", 2f);
}
}
}

10
Content.Shared/Body/Part/Properties/Other/GraspProperty.cs
View File

@@ -1,10 +0,0 @@
namespace Content.Shared.Body.Part.Properties.Other
{
/// <summary>
/// Defines the item grasping ability of a BodyPart. Distance is determined by the
/// <see cref="ExtensionProperty">ExtensionProperties</see> of the current BodyPart or attached BodyParts.
/// </summary>
public class GraspProperty : BodyPartProperty
{
}
}

35
Content.Shared/Body/Preset/BodyPresetPrototype.cs
View File

@@ -1,35 +0,0 @@
using System;
using System.Collections.Generic;
using Robust.Shared.Prototypes;
using Robust.Shared.Serialization;
using Robust.Shared.ViewVariables;
using YamlDotNet.RepresentationModel;
namespace Content.Shared.Body.Preset
{
/// <summary>
/// Prototype for the BodyPreset class.
/// </summary>
[Prototype("bodyPreset")]
[Serializable, NetSerializable]
public class BodyPresetPrototype : IPrototype, IIndexedPrototype
{
private string _id;
private string _name;
private Dictionary<string, string> _partIDs;
[ViewVariables] public string ID => _id;
[ViewVariables] public string Name => _name;
[ViewVariables] public Dictionary<string, string> PartIDs => _partIDs;
public virtual void LoadFrom(YamlMappingNode mapping)
{
var serializer = YamlObjectSerializer.NewReader(mapping);
serializer.DataField(ref _id, "id", string.Empty);
serializer.DataField(ref _name, "name", string.Empty);
serializer.DataField(ref _partIDs, "partIDs", new Dictionary<string, string>());
}
}
}

85
Content.Shared/Body/Scanner/BodyScannerSharedValues.cs
View File

@@ -1,85 +0,0 @@
using System;
using System.Collections.Generic;
using Content.Shared.GameObjects.Components.Body;
using Robust.Shared.GameObjects.Components.UserInterface;
using Robust.Shared.Serialization;
namespace Content.Shared.Body.Scanner
{
[Serializable, NetSerializable]
public enum BodyScannerUiKey
{
Key
}
[Serializable, NetSerializable]
public class BodyScannerInterfaceState : BoundUserInterfaceState
{
public readonly Dictionary<string, BodyScannerBodyPartData> Parts;
public readonly BodyScannerTemplateData Template;
public BodyScannerInterfaceState(Dictionary<string, BodyScannerBodyPartData> parts,
BodyScannerTemplateData template)
{
Template = template;
Parts = parts;
}
}
[Serializable, NetSerializable]
public class BodyScannerBodyPartData
{
public readonly int CurrentDurability;
public readonly int MaxDurability;
public readonly List<BodyScannerMechanismData> Mechanisms;
public readonly string Name;
public readonly string RSIPath;
public readonly string RSIState;
public BodyScannerBodyPartData(string name, string rsiPath, string rsiState, int maxDurability,
int currentDurability, List<BodyScannerMechanismData> mechanisms)
{
Name = name;
RSIPath = rsiPath;
RSIState = rsiState;
MaxDurability = maxDurability;
CurrentDurability = currentDurability;
Mechanisms = mechanisms;
}
}
[Serializable, NetSerializable]
public class BodyScannerMechanismData
{
public readonly int CurrentDurability;
public readonly string Description;
public readonly int MaxDurability;
public readonly string Name;
public readonly string RSIPath;
public readonly string RSIState;
public BodyScannerMechanismData(string name, string description, string rsiPath, string rsiState,
int maxDurability, int currentDurability)
{
Name = name;
Description = description;
RSIPath = rsiPath;
RSIState = rsiState;
MaxDurability = maxDurability;
CurrentDurability = currentDurability;
}
}
[Serializable, NetSerializable]
public class BodyScannerTemplateData
{
public readonly string Name;
public readonly Dictionary<string, BodyPartType> Slots;
public BodyScannerTemplateData(string name, Dictionary<string, BodyPartType> slots)
{
Name = name;
Slots = slots;
}
}
}

88
Content.Shared/Body/Surgery/GenericSurgeryUIMessages.cs
View File

@@ -1,88 +0,0 @@
using System;
using System.Collections.Generic;
using Robust.Shared.GameObjects.Components.UserInterface;
using Robust.Shared.Serialization;
namespace Content.Shared.Body.Surgery
{
[Serializable]
[NetSerializable]
public class RequestBodyPartSurgeryUIMessage : BoundUserInterfaceMessage
{
public Dictionary<string, int> Targets;
public RequestBodyPartSurgeryUIMessage(Dictionary<string, int> targets)
{
Targets = targets;
}
}
[Serializable]
[NetSerializable]
public class RequestMechanismSurgeryUIMessage : BoundUserInterfaceMessage
{
public Dictionary<string, int> Targets;
public RequestMechanismSurgeryUIMessage(Dictionary<string, int> targets)
{
Targets = targets;
}
}
[Serializable]
[NetSerializable]
public class RequestBodyPartSlotSurgeryUIMessage : BoundUserInterfaceMessage
{
public Dictionary<string, int> Targets;
public RequestBodyPartSlotSurgeryUIMessage(Dictionary<string, int> targets)
{
Targets = targets;
}
}
[Serializable]
[NetSerializable]
public class ReceiveBodyPartSurgeryUIMessage : BoundUserInterfaceMessage
{
public int SelectedOptionId;
public ReceiveBodyPartSurgeryUIMessage(int selectedOptionId)
{
SelectedOptionId = selectedOptionId;
}
}
[Serializable]
[NetSerializable]
public class ReceiveMechanismSurgeryUIMessage : BoundUserInterfaceMessage
{
public int SelectedOptionId;
public ReceiveMechanismSurgeryUIMessage(int selectedOptionId)
{
SelectedOptionId = selectedOptionId;
}
}
[Serializable]
[NetSerializable]
public class ReceiveBodyPartSlotSurgeryUIMessage : BoundUserInterfaceMessage
{
public int SelectedOptionId;
public ReceiveBodyPartSlotSurgeryUIMessage(int selectedOptionId)
{
SelectedOptionId = selectedOptionId;
}
}
[NetSerializable]
[Serializable]
public enum GenericSurgeryUiKey
{
Key
}
}

87
Content.Shared/Body/Template/BodyTemplatePrototype.cs
View File

@@ -1,87 +0,0 @@
using System;
using System.Collections.Generic;
using System.Linq;
using Content.Shared.GameObjects.Components.Body;
using Robust.Shared.Prototypes;
using Robust.Shared.Serialization;
using Robust.Shared.ViewVariables;
using YamlDotNet.RepresentationModel;
namespace Content.Shared.Body.Template
{
/// <summary>
/// Prototype for the BodyTemplate class.
/// </summary>
[Prototype("bodyTemplate")]
[Serializable, NetSerializable]
public class BodyTemplatePrototype : IPrototype, IIndexedPrototype
{
private string _id;
private string _name;
private string _centerSlot;
private Dictionary<string, BodyPartType> _slots;
private Dictionary<string, List<string>> _connections;
private Dictionary<string, string> _layers;
private Dictionary<string, string> _mechanismLayers;
[ViewVariables] public string ID => _id;
[ViewVariables] public string Name => _name;
[ViewVariables] public string CenterSlot => _centerSlot;
[ViewVariables] public Dictionary<string, BodyPartType> Slots => new Dictionary<string, BodyPartType>(_slots);
[ViewVariables]
public Dictionary<string, List<string>> Connections =>
_connections.ToDictionary(x => x.Key, x => x.Value.ToList());
[ViewVariables] public Dictionary<string, string> Layers => new Dictionary<string, string>(_layers);
[ViewVariables] public Dictionary<string, string> MechanismLayers => new Dictionary<string, string>(_mechanismLayers);
public virtual void LoadFrom(YamlMappingNode mapping)
{
var serializer = YamlObjectSerializer.NewReader(mapping);
serializer.DataField(ref _id, "id", string.Empty);
serializer.DataField(ref _name, "name", string.Empty);
serializer.DataField(ref _centerSlot, "centerSlot", string.Empty);
serializer.DataField(ref _slots, "slots", new Dictionary<string, BodyPartType>());
serializer.DataField(ref _connections, "connections", new Dictionary<string, List<string>>());
serializer.DataField(ref _layers, "layers", new Dictionary<string, string>());
serializer.DataField(ref _mechanismLayers, "mechanismLayers", new Dictionary<string, string>());
//Our prototypes don't force the user to define a BodyPart connection twice. E.g. Head: Torso v.s. Torso: Head.
//The user only has to do one. We want it to be that way in the code, though, so this cleans that up.
var cleanedConnections = new Dictionary<string, List<string>>();
foreach (var targetSlotName in _slots.Keys)
{
var tempConnections = new List<string>();
foreach (var (slotName, slotConnections) in _connections)
{
if (slotName == targetSlotName)
{
foreach (var connection in slotConnections)
{
if (!tempConnections.Contains(connection))
{
tempConnections.Add(connection);
}
}
}
else if (slotConnections.Contains(targetSlotName))
{
tempConnections.Add(slotName);
}
}
if (tempConnections.Count > 0)
{
cleanedConnections.Add(targetSlotName, tempConnections);
}
}
_connections = cleanedConnections;
}
}
}