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

16
Content.Shared/GameObjects/Components/Body/Part/BodyPartCompatibility.cs Normal file
View File

@@ -0,0 +1,16 @@
using System;
using Robust.Shared.Serialization;
namespace Content.Shared.GameObjects.Components.Body.Part
{
/// <summary>
/// Used to determine whether a BodyPart can connect to another BodyPart.
/// </summary>
[Serializable, NetSerializable]
public enum BodyPartCompatibility
{
Universal = 0,
Biological,
Mechanical
}
}

37
Content.Shared/GameObjects/Components/Body/Part/BodyPartExtensions.cs Normal file
View File

@@ -0,0 +1,37 @@
#nullable enable
using System;
using System.Diagnostics.CodeAnalysis;
using Content.Shared.GameObjects.Components.Body.Part.Property;
namespace Content.Shared.GameObjects.Components.Body.Part
{
public static class BodyPartExtensions
{
public static bool HasProperty(this IBodyPart part, Type type)
{
return part.Owner.HasComponent(type);
}
public static bool HasProperty<T>(this IBodyPart part) where T : class, IBodyPartProperty
{
return part.HasProperty(typeof(T));
}
public static bool TryGetProperty(this IBodyPart part, Type type,
[NotNullWhen(true)] out IBodyPartProperty? property)
{
if (!part.Owner.TryGetComponent(type, out var component))
{
property = null;
return false;
}
return (property = component as IBodyPartProperty) != null;
}
public static bool TryGetProperty<T>(this IBodyPart part, [NotNullWhen(true)] out T? property) where T : class, IBodyPartProperty
{
return part.Owner.TryGetComponent(out property);
}
}
}

13
Content.Shared/GameObjects/Components/Body/Part/BodyPartSymmetry.cs Normal file
View File

@@ -0,0 +1,13 @@
using System;
using Robust.Shared.Serialization;
namespace Content.Shared.GameObjects.Components.Body.Part
{
[Serializable, NetSerializable]
public enum BodyPartSymmetry
{
None = 0,
Left,
Right
}
}

21
Content.Shared/GameObjects/Components/Body/Part/BodyPartType.cs Normal file
View File

@@ -0,0 +1,21 @@
using System;
using Robust.Shared.Serialization;
namespace Content.Shared.GameObjects.Components.Body.Part
{
/// <summary>
/// Each BodyPart has a BodyPartType used to determine a variety of things.
/// For instance, what slots it can fit into.
/// </summary>
[Serializable, NetSerializable]
public enum BodyPartType
{
Other = 0,
Torso,
Head,
Arm,
Hand,
Leg,
Foot
}
}

110
Content.Shared/GameObjects/Components/Body/Part/IBodyPart.cs Normal file
View File

@@ -0,0 +1,110 @@
#nullable enable
using System.Collections.Generic;
using Content.Shared.GameObjects.Components.Body.Mechanism;
using Content.Shared.GameObjects.Components.Body.Surgery;
using Robust.Shared.Interfaces.GameObjects;
using Robust.Shared.Map;
namespace Content.Shared.GameObjects.Components.Body.Part
{
public interface IBodyPart : IHasBody, IBodyPartContainer
{
new IBody? Body { get; set; }
/// <summary>
/// <see cref="BodyPartType"/> that this <see cref="IBodyPart"/> is considered
/// to be.
/// For example, <see cref="BodyPartType.Arm"/>.
/// </summary>
BodyPartType PartType { get; }
/// <summary>
/// Plural version of this <see cref="IBodyPart"/> name.
/// </summary>
public string Plural { get; }
/// <summary>
/// Determines many things: how many mechanisms can be fit inside this
/// <see cref="IBodyPart"/>, whether a body can fit through tiny crevices,
/// etc.
/// </summary>
int Size { get; }
// TODO BODY Mechanisms occupying different parts at the body level
/// <summary>
/// Collection of all <see cref="IMechanism"/>s currently inside this
/// <see cref="IBodyPart"/>.
/// To add and remove from this list see <see cref="AddMechanism"/> and
/// <see cref="RemoveMechanism"/>
/// </summary>
IReadOnlyCollection<IMechanism> Mechanisms { get; }
/// <summary>
/// If body part is vital
/// </summary>
public bool IsVital { get; }
public BodyPartSymmetry Symmetry { get; }
bool Drop();
/// <summary>
/// Checks if the given <see cref="SurgeryType"/> can be used on
/// the current state of this <see cref="IBodyPart"/>.
/// </summary>
/// <returns>True if it can be used, false otherwise.</returns>
bool SurgeryCheck(SurgeryType surgery);
/// <summary>
/// Attempts to perform surgery on this <see cref="IBodyPart"/> with the given
/// tool.
/// </summary>
/// <returns>True if successful, false if there was an error.</returns>
public bool AttemptSurgery(SurgeryType toolType, IBodyPartContainer target, ISurgeon surgeon,
IEntity performer);
/// <summary>
/// Checks if another <see cref="IBodyPart"/> can be connected to this one.
/// </summary>
/// <param name="part">The part to connect.</param>
/// <returns>True if it can be connected, false otherwise.</returns>
bool CanAttachPart(IBodyPart part);
/// <summary>
/// Checks if a <see cref="IMechanism"/> can be added on this
/// <see cref="IBodyPart"/>.
/// </summary>
/// <returns>True if it can be added, false otherwise.</returns>
bool CanAddMechanism(IMechanism mechanism);
bool TryAddMechanism(IMechanism mechanism, bool force = false);
/// <summary>
/// Tries to remove the given <see cref="mechanism"/> from this
/// <see cref="IBodyPart"/>.
/// </summary>
/// <param name="mechanism">The mechanism to remove.</param>
/// <returns>True if it was removed, false otherwise.</returns>
bool RemoveMechanism(IMechanism mechanism);
/// <summary>
/// Tries to remove the given <see cref="mechanism"/> from this
/// <see cref="IBodyPart"/> and drops it at the specified coordinates.
/// </summary>
/// <param name="mechanism">The mechanism to remove.</param>
/// <param name="dropAt">The coordinates to drop it at.</param>
/// <returns>True if it was removed, false otherwise.</returns>
bool RemoveMechanism(IMechanism mechanism, EntityCoordinates dropAt);
/// <summary>
/// Tries to destroy the given <see cref="IMechanism"/> from
/// this <see cref="IBodyPart"/>.
/// The mechanism won't be deleted if it is not in this body part.
/// </summary>
/// <returns>
/// True if the mechanism was in this body part and destroyed,
/// false otherwise.
/// </returns>
bool DeleteMechanism(IMechanism mechanism);
}
}

26
Content.Shared/GameObjects/Components/Body/Part/IBodyPartAdded.cs Normal file
View File

@@ -0,0 +1,26 @@
using System;
namespace Content.Shared.GameObjects.Components.Body.Part
{
/// <summary>
/// This interface gives components behavior when a body part
/// is added to their owning entity.
/// </summary>
public interface IBodyPartAdded
{
void BodyPartAdded(BodyPartAddedEventArgs args);
}
public class BodyPartAddedEventArgs : EventArgs
{
public BodyPartAddedEventArgs(IBodyPart part, string slot)
{
Part = part;
Slot = slot;
}
public IBodyPart Part { get; }
public string Slot { get; }
}
}

17
Content.Shared/GameObjects/Components/Body/Part/IBodyPartContainer.cs Normal file
View File

@@ -0,0 +1,17 @@
namespace Content.Shared.GameObjects.Components.Body.Part
{
/// <summary>
/// Making a class inherit from this interface allows you to do many
/// things with it in the <see cref="SurgeryData"/> class.
/// This includes passing it as an argument to a
/// <see cref="SurgeryData.SurgeryAction"/> delegate, as to later typecast
/// it back to the original class type.
/// Every BodyPart also needs an <see cref="IBodyPartContainer"/> to be
/// its parent (i.e. the <see cref="IBody"/> holds many
/// <see cref="IBodyPart"/>s, each of which have an upward reference to it).
/// </summary>
// TODO BODY Remove
public interface IBodyPartContainer
{
}
}

26
Content.Shared/GameObjects/Components/Body/Part/IBodyPartRemoved.cs Normal file
View File

@@ -0,0 +1,26 @@
using System;
namespace Content.Shared.GameObjects.Components.Body.Part
{
/// <summary>
/// This interface gives components behavior when a body part
/// is removed from their owning entity.
/// </summary>
public interface IBodyPartRemoved
{
void BodyPartRemoved(BodyPartRemovedEventArgs args);
}
public class BodyPartRemovedEventArgs : EventArgs
{
public BodyPartRemovedEventArgs(IBodyPart part, string slot)
{
Part = part;
Slot = slot;
}
public IBodyPart Part { get; }
public string Slot { get; }
}
}

25
Content.Shared/GameObjects/Components/Body/Part/Property/BodyPartPropertyComponent.cs Normal file
View File

@@ -0,0 +1,25 @@
using Robust.Shared.GameObjects;
using Robust.Shared.Serialization;
namespace Content.Shared.GameObjects.Components.Body.Part.Property
{
/// <summary>
/// Property attachable to a <see cref="IBodyPart"/>.
/// 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 BodyPartPropertyComponent : Component, IBodyPartProperty
{
/// <summary>
/// Whether this property is currently active.
/// </summary>
public bool Active { get; set; }
public override void ExposeData(ObjectSerializer serializer)
{
base.ExposeData(serializer);
serializer.DataField(this, b => b.Active, "active", true);
}
}
}

23
Content.Shared/GameObjects/Components/Body/Part/Property/ExtensionComponent.cs Normal file
View File

@@ -0,0 +1,23 @@
using Robust.Shared.GameObjects;
using Robust.Shared.Serialization;
namespace Content.Shared.GameObjects.Components.Body.Part.Property
{
[RegisterComponent]
public class ExtensionComponent : BodyPartPropertyComponent
{
public override string Name => "Extension";
/// <summary>
/// Current distance (in tiles).
/// </summary>
public float Distance { get; set; }
public override void ExposeData(ObjectSerializer serializer)
{
base.ExposeData(serializer);
serializer.DataField(this, e => e.Distance, "distance", 3f);
}
}
}

14
Content.Shared/GameObjects/Components/Body/Part/Property/GraspComponent.cs Normal file
View File

@@ -0,0 +1,14 @@
using Robust.Shared.GameObjects;
namespace Content.Shared.GameObjects.Components.Body.Part.Property
{
/// <summary>
/// Defines an entity as being able to pick up items
/// </summary>
// TODO BODY Implement
[RegisterComponent]
public class GraspComponent : BodyPartPropertyComponent
{
public override string Name => "Grasp";
}
}

9
Content.Shared/GameObjects/Components/Body/Part/Property/IBodyPartProperty.cs Normal file
View File

@@ -0,0 +1,9 @@
using Robust.Shared.Interfaces.GameObjects;
namespace Content.Shared.GameObjects.Components.Body.Part.Property
{
public interface IBodyPartProperty : IComponent
{
bool Active { get; set; }
}
}

23
Content.Shared/GameObjects/Components/Body/Part/Property/LegComponent.cs Normal file
View File

@@ -0,0 +1,23 @@
using Robust.Shared.GameObjects;
using Robust.Shared.Serialization;
namespace Content.Shared.GameObjects.Components.Body.Part.Property
{
[RegisterComponent]
public class LegComponent : BodyPartPropertyComponent
{
public override string Name => "Leg";
/// <summary>
/// Speed (in tiles per second).
/// </summary>
public float Speed { get; set; }
public override void ExposeData(ObjectSerializer serializer)
{
base.ExposeData(serializer);
serializer.DataField(this, l => l.Speed, "speed", 2.6f);
}
}
}

346
Content.Shared/GameObjects/Components/Body/Part/SharedBodyPartComponent.cs Normal file
View File

@@ -0,0 +1,346 @@
#nullable enable
using System;
using System.Collections.Generic;
using System.Linq;
using Content.Shared.GameObjects.Components.Body.Mechanism;
using Content.Shared.GameObjects.Components.Body.Surgery;
using Robust.Shared.GameObjects;
using Robust.Shared.Interfaces.GameObjects;
using Robust.Shared.IoC;
using Robust.Shared.Map;
using Robust.Shared.Serialization;
using Robust.Shared.Utility;
using Robust.Shared.ViewVariables;
namespace Content.Shared.GameObjects.Components.Body.Part
{
public abstract class SharedBodyPartComponent : Component, IBodyPart
{
public override string Name => "BodyPart";
public override uint? NetID => ContentNetIDs.BODY_PART;
private IBody? _body;
// TODO BODY Remove
private List<string> _mechanismIds = new List<string>();
public IReadOnlyList<string> MechanismIds => _mechanismIds;
[ViewVariables]
private HashSet<IMechanism> _mechanisms = new HashSet<IMechanism>();
[ViewVariables]
public IBody? Body
{
get => _body;
set
{
if (_body == value)
{
return;
}
var old = _body;
_body = value;
if (value != null)
{
foreach (var mechanism in _mechanisms)
{
mechanism.OnBodyAdd(old, value);
}
}
else if (old != null)
{
foreach (var mechanism in _mechanisms)
{
mechanism.OnBodyRemove(old);
}
}
}
}
[ViewVariables] public BodyPartType PartType { get; private set; }
[ViewVariables] public string Plural { get; private set; } = string.Empty;
[ViewVariables] public int Size { get; private set; }
[ViewVariables] public int SizeUsed { get; private set; }
// TODO BODY size used
// TODO BODY surgerydata
/// <summary>
/// What types of BodyParts this <see cref="IBodyPart"/> can easily attach to.
/// For the most part, most limbs aren't universal and require extra work to
/// attach between types.
/// </summary>
[ViewVariables]
public BodyPartCompatibility Compatibility { get; private set; }
/// <summary>
/// Set of all <see cref="IMechanism"/> currently inside this
/// <see cref="IBodyPart"/>.
/// </summary>
[ViewVariables]
public IReadOnlyCollection<IMechanism> Mechanisms => _mechanisms;
// TODO BODY Replace with a simulation of organs
/// <summary>
/// Represents if body part is vital for creature.
/// If the last vital body part is removed creature dies
/// </summary>
[ViewVariables]
public bool IsVital { get; private set; }
[ViewVariables]
public BodyPartSymmetry Symmetry { get; private set; }
// TODO BODY
[ViewVariables]
public SurgeryDataComponent? SurgeryDataComponent => Owner.GetComponentOrNull<SurgeryDataComponent>();
protected virtual void OnAddMechanism(IMechanism mechanism)
{
var prototypeId = mechanism.Owner.Prototype!.ID;
if (!_mechanismIds.Contains(prototypeId))
{
_mechanismIds.Add(prototypeId);
}
mechanism.Part = this;
SizeUsed += mechanism.Size;
Dirty();
}
protected virtual void OnRemoveMechanism(IMechanism mechanism)
{
_mechanismIds.Remove(mechanism.Owner.Prototype!.ID);
mechanism.Part = null;
SizeUsed -= mechanism.Size;
Dirty();
}
public override void ExposeData(ObjectSerializer serializer)
{
base.ExposeData(serializer);
// TODO BODY serialize any changed properties?
serializer.DataField(this, b => b.PartType, "partType", BodyPartType.Other);
serializer.DataField(this, b => b.Plural, "plural", string.Empty);
serializer.DataField(this, b => b.Size, "size", 1);
serializer.DataField(this, b => b.Compatibility, "compatibility", BodyPartCompatibility.Universal);
serializer.DataField(this, b => b.IsVital, "vital", false);
serializer.DataField(this, b => b.Symmetry, "symmetry", BodyPartSymmetry.None);
serializer.DataField(ref _mechanismIds, "mechanisms", new List<string>());
}
public override ComponentState GetComponentState()
{
var mechanismIds = new EntityUid[_mechanisms.Count];
var i = 0;
foreach (var mechanism in _mechanisms)
{
mechanismIds[i] = mechanism.Owner.Uid;
i++;
}
return new BodyPartComponentState(mechanismIds);
}
public override void HandleComponentState(ComponentState? curState, ComponentState? nextState)
{
base.HandleComponentState(curState, nextState);
if (!(curState is BodyPartComponentState state))
{
return;
}
var newMechanisms = state.Mechanisms();
foreach (var mechanism in _mechanisms.ToArray())
{
if (!newMechanisms.Contains(mechanism))
{
RemoveMechanism(mechanism);
}
}
foreach (var mechanism in newMechanisms)
{
if (!_mechanisms.Contains(mechanism))
{
TryAddMechanism(mechanism, true);
}
}
}
public bool Drop()
{
Body = null;
Owner.Transform.AttachToGridOrMap();
return true;
}
public bool SurgeryCheck(SurgeryType surgery)
{
return SurgeryDataComponent?.CheckSurgery(surgery) ?? false;
}
/// <summary>
/// Attempts to perform surgery on this <see cref="IBodyPart"/> with the given
/// tool.
/// </summary>
/// <returns>True if successful, false if there was an error.</returns>
public bool AttemptSurgery(SurgeryType toolType, IBodyPartContainer target, ISurgeon surgeon, IEntity performer)
{
DebugTools.AssertNotNull(toolType);
DebugTools.AssertNotNull(target);
DebugTools.AssertNotNull(surgeon);
DebugTools.AssertNotNull(performer);
return SurgeryDataComponent?.PerformSurgery(toolType, target, surgeon, performer) ?? false;
}
public bool CanAttachPart(IBodyPart part)
{
DebugTools.AssertNotNull(part);
return SurgeryDataComponent?.CanAttachBodyPart(part) ?? false;
}
public bool CanAddMechanism(IMechanism mechanism)
{
DebugTools.AssertNotNull(mechanism);
return SurgeryDataComponent != null &&
SizeUsed + mechanism.Size <= Size &&
SurgeryDataComponent.CanAddMechanism(mechanism);
}
/// <summary>
/// Tries to add a mechanism onto this body part.
/// </summary>
/// <param name="mechanism">The mechanism to try to add.</param>
/// <param name="force">
/// Whether or not to check if the mechanism can be added.
/// </param>
/// <returns>
/// True if successful, false if there was an error
/// (e.g. not enough room in <see cref="IBodyPart"/>).
/// Will return false even when forced if the mechanism is already
/// added in this <see cref="IBodyPart"/>.
/// </returns>
public bool TryAddMechanism(IMechanism mechanism, bool force = false)
{
DebugTools.AssertNotNull(mechanism);
if (!force && !CanAddMechanism(mechanism))
{
return false;
}
if (!_mechanisms.Add(mechanism))
{
return false;
}
OnAddMechanism(mechanism);
return true;
}
public bool RemoveMechanism(IMechanism mechanism)
{
DebugTools.AssertNotNull(mechanism);
if (!_mechanisms.Remove(mechanism))
{
return false;
}
OnRemoveMechanism(mechanism);
return true;
}
public bool RemoveMechanism(IMechanism mechanism, EntityCoordinates coordinates)
{
if (RemoveMechanism(mechanism))
{
mechanism.Owner.Transform.Coordinates = coordinates;
return true;
}
return false;
}
public bool DeleteMechanism(IMechanism mechanism)
{
DebugTools.AssertNotNull(mechanism);
if (!RemoveMechanism(mechanism))
{
return false;
}
mechanism.Owner.Delete();
return true;
}
}
[Serializable, NetSerializable]
public class BodyPartComponentState : ComponentState
{
private List<IMechanism>? _mechanisms;
public readonly EntityUid[] MechanismIds;
public BodyPartComponentState(EntityUid[] mechanismIds) : base(ContentNetIDs.BODY_PART)
{
MechanismIds = mechanismIds;
}
public List<IMechanism> Mechanisms(IEntityManager? entityManager = null)
{
if (_mechanisms != null)
{
return _mechanisms;
}
entityManager ??= IoCManager.Resolve<IEntityManager>();
var mechanisms = new List<IMechanism>(MechanismIds.Length);
foreach (var id in MechanismIds)
{
if (!entityManager.TryGetEntity(id, out var entity))
{
continue;
}
if (!entity.TryGetComponent(out IMechanism? mechanism))
{
continue;
}
mechanisms.Add(mechanism);
}
return _mechanisms = mechanisms;
}
}
}