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

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
{
}
}