Refactoring body system to use containers and general body cleanup (#20202)
Co-authored-by: metalgearsloth <comedian_vs_clown@hotmail.com>
This commit is contained in:
Jezithyr
GitHub
@@ -1,28 +1,141 @@
|
||||
using System.Diagnostics.CodeAnalysis;
|
||||
using System.Linq;
|
||||
using System.Linq;
|
||||
using System.Numerics;
|
||||
using Content.Shared.Body.Components;
|
||||
using Content.Shared.Body.Organ;
|
||||
using Content.Shared.Body.Part;
|
||||
using Content.Shared.Body.Prototypes;
|
||||
using Content.Shared.Coordinates;
|
||||
using Content.Shared.DragDrop;
|
||||
using Robust.Shared.Containers;
|
||||
using Robust.Shared.GameStates;
|
||||
using Robust.Shared.Network;
|
||||
using Robust.Shared.Map;
|
||||
using MapInitEvent = Robust.Shared.GameObjects.MapInitEvent;
|
||||
|
||||
namespace Content.Shared.Body.Systems;
|
||||
|
||||
public partial class SharedBodySystem
|
||||
{
|
||||
[Dependency] private readonly INetManager _netManager = default!;
|
||||
/*
|
||||
* tl;dr of how bobby works
|
||||
* - BodyComponent uses a BodyPrototype as a template.
|
||||
* - On MapInit we spawn the root entity in the prototype and spawn all connections outwards from here
|
||||
* - Each "connection" is a body part (e.g. arm, hand, etc.) and each part can also contain organs.
|
||||
*/
|
||||
|
||||
public void InitializeBody()
|
||||
private void InitializeBody()
|
||||
{
|
||||
SubscribeLocalEvent<BodyComponent, ComponentInit>(OnBodyInit);
|
||||
// Body here to handle root body parts.
|
||||
SubscribeLocalEvent<BodyComponent, EntInsertedIntoContainerMessage>(OnBodyInserted);
|
||||
SubscribeLocalEvent<BodyComponent, EntRemovedFromContainerMessage>(OnBodyRemoved);
|
||||
|
||||
SubscribeLocalEvent<BodyComponent, ComponentInit>(OnBodyInit);
|
||||
SubscribeLocalEvent<BodyComponent, MapInitEvent>(OnBodyMapInit);
|
||||
SubscribeLocalEvent<BodyComponent, CanDragEvent>(OnBodyCanDrag);
|
||||
SubscribeLocalEvent<BodyComponent, ComponentGetState>(OnBodyGetState);
|
||||
SubscribeLocalEvent<BodyComponent, ComponentHandleState>(OnBodyHandleState);
|
||||
SubscribeLocalEvent<BodyComponent, CanDragEvent>(OnBodyCanDrag);
|
||||
}
|
||||
|
||||
private void OnBodyInserted(EntityUid uid, BodyComponent component, EntInsertedIntoContainerMessage args)
|
||||
{
|
||||
// Root body part?
|
||||
var slotId = args.Container.ID;
|
||||
|
||||
if (slotId != BodyRootContainerId)
|
||||
return;
|
||||
|
||||
var entity = args.Entity;
|
||||
|
||||
if (TryComp(entity, out BodyPartComponent? childPart))
|
||||
{
|
||||
AddPart(uid, entity, slotId, childPart);
|
||||
RecursiveBodyUpdate(entity, uid, childPart);
|
||||
}
|
||||
|
||||
if (TryComp(entity, out OrganComponent? organ))
|
||||
{
|
||||
AddOrgan(entity, uid, uid, organ);
|
||||
}
|
||||
}
|
||||
|
||||
private void OnBodyRemoved(EntityUid uid, BodyComponent component, EntRemovedFromContainerMessage args)
|
||||
{
|
||||
// TODO: lifestage shenanigans
|
||||
if (LifeStage(uid) >= EntityLifeStage.Terminating)
|
||||
return;
|
||||
|
||||
// Root body part?
|
||||
var slotId = args.Container.ID;
|
||||
|
||||
if (slotId != BodyRootContainerId)
|
||||
return;
|
||||
|
||||
var entity = args.Entity;
|
||||
|
||||
if (TryComp(entity, out BodyPartComponent? childPart))
|
||||
{
|
||||
RemovePart(uid, entity, slotId, childPart);
|
||||
RecursiveBodyUpdate(entity, null, childPart);
|
||||
}
|
||||
|
||||
if (TryComp(entity, out OrganComponent? organ))
|
||||
{
|
||||
RemoveOrgan(entity, uid, uid, organ);
|
||||
}
|
||||
}
|
||||
|
||||
private void OnBodyHandleState(EntityUid uid, BodyComponent component, ref ComponentHandleState args)
|
||||
{
|
||||
if (args.Current is not BodyComponentState state)
|
||||
return;
|
||||
|
||||
component.Prototype = state.Prototype != null ? state.Prototype : null!;
|
||||
component.GibSound = state.GibSound;
|
||||
component.RequiredLegs = state.RequiredLegs;
|
||||
component.LegEntities = EntityManager.EnsureEntitySet<BodyComponent>(state.LegNetEntities, uid);
|
||||
}
|
||||
|
||||
private void OnBodyGetState(EntityUid uid, BodyComponent component, ref ComponentGetState args)
|
||||
{
|
||||
args.State = new BodyComponentState(
|
||||
component.Prototype,
|
||||
component.RootPartSlot,
|
||||
component.GibSound,
|
||||
component.RequiredLegs,
|
||||
EntityManager.GetNetEntitySet(component.LegEntities)
|
||||
);
|
||||
}
|
||||
|
||||
private void OnBodyInit(EntityUid bodyId, BodyComponent body, ComponentInit args)
|
||||
{
|
||||
// Setup the initial container.
|
||||
body.RootContainer = Containers.EnsureContainer<ContainerSlot>(bodyId, BodyRootContainerId);
|
||||
}
|
||||
|
||||
private void OnBodyMapInit(EntityUid bodyId, BodyComponent body, MapInitEvent args)
|
||||
{
|
||||
if (body.Prototype == null)
|
||||
return;
|
||||
|
||||
// One-time setup
|
||||
// Obviously can't run in Init to avoid double-spawns on save / load.
|
||||
var prototype = Prototypes.Index(body.Prototype.Value);
|
||||
MapInitBody(bodyId, prototype);
|
||||
}
|
||||
|
||||
private void MapInitBody(EntityUid bodyEntity, BodyPrototype prototype)
|
||||
{
|
||||
var protoRoot = prototype.Slots[prototype.Root];
|
||||
if (protoRoot.Part == null)
|
||||
return;
|
||||
|
||||
// This should already handle adding the entity to the root.
|
||||
var rootPartEntity = SpawnInContainerOrDrop(protoRoot.Part, bodyEntity, BodyRootContainerId);
|
||||
var rootPart = Comp<BodyPartComponent>(rootPartEntity);
|
||||
rootPart.Body = bodyEntity;
|
||||
Dirty(rootPartEntity, rootPart);
|
||||
|
||||
// Setup the rest of the body entities.
|
||||
SetupOrgans(rootPartEntity, rootPart, protoRoot.Organs);
|
||||
MapInitParts(rootPartEntity, prototype);
|
||||
}
|
||||
|
||||
private void OnBodyCanDrag(EntityUid uid, BodyComponent component, ref CanDragEvent args)
|
||||
@@ -30,148 +143,114 @@ public partial class SharedBodySystem
|
||||
args.Handled = true;
|
||||
}
|
||||
|
||||
private void OnBodyInit(EntityUid bodyId, BodyComponent body, ComponentInit args)
|
||||
/// <summary>
|
||||
/// Sets up all of the relevant body parts for a particular body entity and root part.
|
||||
/// </summary>
|
||||
private void MapInitParts(EntityUid rootPartId, BodyPrototype prototype)
|
||||
{
|
||||
// ReSharper disable once ConditionIsAlwaysTrueOrFalseAccordingToNullableAPIContract
|
||||
if (body.Prototype == null || body.Root != null)
|
||||
return;
|
||||
// Start at the root part and traverse the body graph, setting up parts as we go.
|
||||
// Basic BFS pathfind.
|
||||
var rootSlot = prototype.Root;
|
||||
var frontier = new Queue<string>();
|
||||
frontier.Enqueue(rootSlot);
|
||||
|
||||
var prototype = Prototypes.Index<BodyPrototype>(body.Prototype);
|
||||
// Child -> Parent connection.
|
||||
var cameFrom = new Dictionary<string, string>();
|
||||
// Maps slot to its relevant entity.
|
||||
var cameFromEntities = new Dictionary<string, EntityUid>();
|
||||
cameFromEntities[rootSlot] = rootPartId;
|
||||
|
||||
if (!_netManager.IsClient || IsClientSide(bodyId))
|
||||
InitBody(body, prototype);
|
||||
|
||||
Dirty(body); // Client doesn't actually spawn the body, need to sync it
|
||||
}
|
||||
|
||||
private void OnBodyGetState(EntityUid uid, BodyComponent body, ref ComponentGetState args)
|
||||
{
|
||||
args.State = new BodyComponentState(body.Root, body.GibSound);
|
||||
}
|
||||
|
||||
private void OnBodyHandleState(EntityUid uid, BodyComponent body, ref ComponentHandleState args)
|
||||
{
|
||||
if (args.Current is not BodyComponentState state)
|
||||
return;
|
||||
|
||||
body.Root = state.Root; // TODO use containers. This is broken and does not work.
|
||||
body.GibSound = state.GibSound;
|
||||
}
|
||||
|
||||
public bool TryCreateBodyRootSlot(
|
||||
EntityUid? bodyId,
|
||||
string slotId,
|
||||
[NotNullWhen(true)] out BodyPartSlot? slot,
|
||||
BodyComponent? body = null)
|
||||
{
|
||||
slot = null;
|
||||
|
||||
// ReSharper disable once ConditionIsAlwaysTrueOrFalseAccordingToNullableAPIContract
|
||||
if (bodyId == null ||
|
||||
!Resolve(bodyId.Value, ref body, false) ||
|
||||
body.Root != null)
|
||||
return false;
|
||||
|
||||
slot = new BodyPartSlot
|
||||
while (frontier.TryDequeue(out var currentSlotId))
|
||||
{
|
||||
Id = slotId,
|
||||
Parent = bodyId.Value,
|
||||
NetParent = GetNetEntity(bodyId.Value),
|
||||
};
|
||||
body.Root = slot;
|
||||
var currentSlot = prototype.Slots[currentSlotId];
|
||||
|
||||
return true;
|
||||
foreach (var connection in currentSlot.Connections)
|
||||
{
|
||||
// Already been handled
|
||||
if (!cameFrom.TryAdd(connection, currentSlotId))
|
||||
continue;
|
||||
|
||||
// Setup part
|
||||
var connectionSlot = prototype.Slots[connection];
|
||||
var parentEntity = cameFromEntities[currentSlotId];
|
||||
var parentPartComponent = Comp<BodyPartComponent>(parentEntity);
|
||||
|
||||
// Spawn the entity on the target
|
||||
// then get the body part type, create the slot, and finally
|
||||
// we can insert it into the container.
|
||||
var childPart = Spawn(connectionSlot.Part, new EntityCoordinates(parentEntity, Vector2.Zero));
|
||||
cameFromEntities[connection] = childPart;
|
||||
|
||||
var childPartComponent = Comp<BodyPartComponent>(childPart);
|
||||
var partSlot = CreatePartSlot(parentEntity, connection, childPartComponent.PartType, parentPartComponent);
|
||||
var cont = Containers.GetContainer(parentEntity, GetPartSlotContainerId(connection));
|
||||
|
||||
if (partSlot == null || !cont.Insert(childPart))
|
||||
{
|
||||
Log.Error($"Could not create slot for connection {connection} in body {prototype.ID}");
|
||||
QueueDel(childPart);
|
||||
continue;
|
||||
}
|
||||
|
||||
// Add organs
|
||||
SetupOrgans(childPart, childPartComponent, connectionSlot.Organs);
|
||||
|
||||
// Enqueue it so we can also get its neighbors.
|
||||
frontier.Enqueue(connection);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
protected void InitBody(BodyComponent body, BodyPrototype prototype)
|
||||
private void SetupOrgans(EntityUid partId, BodyPartComponent partComponent, Dictionary<string, string> organs)
|
||||
{
|
||||
var root = prototype.Slots[prototype.Root];
|
||||
Containers.EnsureContainer<Container>(body.Owner, BodyContainerId);
|
||||
if (root.Part == null)
|
||||
return;
|
||||
var bodyId = Spawn(root.Part, body.Owner.ToCoordinates());
|
||||
var partComponent = Comp<BodyPartComponent>(bodyId);
|
||||
var slot = new BodyPartSlot
|
||||
foreach (var (organSlotId, organProto) in organs)
|
||||
{
|
||||
Id = root.Part,
|
||||
Type = partComponent.PartType,
|
||||
Parent = body.Owner,
|
||||
NetParent = GetNetEntity(body.Owner),
|
||||
};
|
||||
body.Root = slot;
|
||||
partComponent.Body = bodyId;
|
||||
var slot = CreateOrganSlot(organSlotId, partId, partComponent);
|
||||
SpawnInContainerOrDrop(organProto, partId, GetOrganContainerId(organSlotId));
|
||||
|
||||
AttachPart(bodyId, slot, partComponent);
|
||||
InitPart(partComponent, prototype, prototype.Root);
|
||||
}
|
||||
|
||||
protected void InitPart(BodyPartComponent parent, BodyPrototype prototype, string slotId, HashSet<string>? initialized = null)
|
||||
{
|
||||
initialized ??= new HashSet<string>();
|
||||
|
||||
if (initialized.Contains(slotId))
|
||||
return;
|
||||
|
||||
initialized.Add(slotId);
|
||||
|
||||
var (_, connections, organs) = prototype.Slots[slotId];
|
||||
connections = new HashSet<string>(connections);
|
||||
connections.ExceptWith(initialized);
|
||||
|
||||
var coordinates = parent.Owner.ToCoordinates();
|
||||
var subConnections = new List<(BodyPartComponent child, string slotId)>();
|
||||
|
||||
Containers.EnsureContainer<Container>(parent.Owner, BodyContainerId);
|
||||
|
||||
foreach (var connection in connections)
|
||||
{
|
||||
var childSlot = prototype.Slots[connection];
|
||||
if (childSlot.Part == null)
|
||||
continue;
|
||||
|
||||
var childPart = Spawn(childSlot.Part, coordinates);
|
||||
var childPartComponent = Comp<BodyPartComponent>(childPart);
|
||||
var slot = CreatePartSlot(connection, parent.Owner, childPartComponent.PartType, parent);
|
||||
if (slot == null)
|
||||
{
|
||||
Logger.Error($"Could not create slot for connection {connection} in body {prototype.ID}");
|
||||
continue;
|
||||
Log.Error($"Could not create organ for slot {organSlotId} in {ToPrettyString(partId)}");
|
||||
}
|
||||
|
||||
AttachPart(childPart, slot, childPartComponent);
|
||||
subConnections.Add((childPartComponent, connection));
|
||||
}
|
||||
|
||||
foreach (var (organSlotId, organId) in organs)
|
||||
{
|
||||
var organ = Spawn(organId, coordinates);
|
||||
var organComponent = Comp<OrganComponent>(organ);
|
||||
|
||||
var slot = CreateOrganSlot(organSlotId, parent.Owner, parent);
|
||||
if (slot == null)
|
||||
{
|
||||
Logger.Error($"Could not create slot for connection {organSlotId} in body {prototype.ID}");
|
||||
continue;
|
||||
}
|
||||
|
||||
InsertOrgan(organ, slot, organComponent);
|
||||
}
|
||||
|
||||
foreach (var connection in subConnections)
|
||||
{
|
||||
InitPart(connection.child, prototype, connection.slotId, initialized);
|
||||
}
|
||||
}
|
||||
public IEnumerable<(EntityUid Id, BodyPartComponent Component)> GetBodyChildren(EntityUid? id, BodyComponent? body = null)
|
||||
|
||||
/// <summary>
|
||||
/// Gets all body containers on this entity including the root one.
|
||||
/// </summary>
|
||||
public IEnumerable<BaseContainer> GetBodyContainers(EntityUid id, BodyComponent? body = null,
|
||||
BodyPartComponent? rootPart = null)
|
||||
{
|
||||
if (!Resolve(id, ref body, false) ||
|
||||
body.RootContainer.ContainedEntity == null ||
|
||||
!Resolve(body.RootContainer.ContainedEntity.Value, ref rootPart))
|
||||
{
|
||||
yield break;
|
||||
}
|
||||
|
||||
yield return body.RootContainer;
|
||||
|
||||
foreach (var childContainer in GetPartContainers(body.RootContainer.ContainedEntity.Value, rootPart))
|
||||
{
|
||||
yield return childContainer;
|
||||
}
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Gets all child body parts of this entity, including the root entity.
|
||||
/// </summary>
|
||||
public IEnumerable<(EntityUid Id, BodyPartComponent Component)> GetBodyChildren(EntityUid? id, BodyComponent? body = null,
|
||||
BodyPartComponent? rootPart = null)
|
||||
{
|
||||
if (id == null ||
|
||||
!Resolve(id.Value, ref body, false) ||
|
||||
!TryComp(body.Root?.Child, out BodyPartComponent? part))
|
||||
body.RootContainer.ContainedEntity == null ||
|
||||
!Resolve(body.RootContainer.ContainedEntity.Value, ref rootPart))
|
||||
{
|
||||
yield break;
|
||||
}
|
||||
|
||||
yield return (body.Root.Child.Value, part);
|
||||
|
||||
foreach (var child in GetPartChildren(body.Root.Child))
|
||||
foreach (var child in GetBodyPartChildren(body.RootContainer.ContainedEntity.Value, rootPart))
|
||||
{
|
||||
yield return child;
|
||||
}
|
||||
@@ -191,55 +270,37 @@ public partial class SharedBodySystem
|
||||
}
|
||||
}
|
||||
|
||||
public IEnumerable<BodyPartSlot> GetBodyAllSlots(EntityUid? bodyId, BodyComponent? body = null)
|
||||
{
|
||||
if (bodyId == null || !Resolve(bodyId.Value, ref body, false))
|
||||
yield break;
|
||||
|
||||
foreach (var slot in GetPartAllSlots(body.Root?.Child))
|
||||
{
|
||||
yield return slot;
|
||||
}
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Returns all body part slots in the graph, including ones connected by
|
||||
/// body parts which are null.
|
||||
/// Returns all body part slots for this entity.
|
||||
/// </summary>
|
||||
/// <param name="partId"></param>
|
||||
/// <param name="part"></param>
|
||||
/// <param name="bodyId"></param>
|
||||
/// <param name="body"></param>
|
||||
/// <returns></returns>
|
||||
public IEnumerable<BodyPartSlot> GetAllBodyPartSlots(EntityUid partId, BodyPartComponent? part = null)
|
||||
public IEnumerable<BodyPartSlot> GetBodyAllSlots(EntityUid bodyId, BodyComponent? body = null)
|
||||
{
|
||||
if (!Resolve(partId, ref part, false))
|
||||
if (!Resolve(bodyId, ref body, false) || body.RootContainer.ContainedEntity == null)
|
||||
yield break;
|
||||
|
||||
foreach (var slot in part.Children.Values)
|
||||
foreach (var slot in GetAllBodyPartSlots(body.RootContainer.ContainedEntity.Value))
|
||||
{
|
||||
if (!TryComp<BodyPartComponent>(slot.Child, out var childPart))
|
||||
continue;
|
||||
|
||||
yield return slot;
|
||||
|
||||
foreach (var child in GetAllBodyPartSlots(slot.Child.Value, childPart))
|
||||
{
|
||||
yield return child;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
public virtual HashSet<EntityUid> GibBody(EntityUid? partId, bool gibOrgans = false,
|
||||
public virtual HashSet<EntityUid> GibBody(EntityUid bodyId, bool gibOrgans = false,
|
||||
BodyComponent? body = null, bool deleteItems = false)
|
||||
{
|
||||
if (partId == null || !Resolve(partId.Value, ref body, false))
|
||||
return new HashSet<EntityUid>();
|
||||
var gibs = new HashSet<EntityUid>();
|
||||
|
||||
var parts = GetBodyChildren(partId, body).ToArray();
|
||||
var gibs = new HashSet<EntityUid>(parts.Length);
|
||||
if (!Resolve(bodyId, ref body, false))
|
||||
return gibs;
|
||||
|
||||
var parts = GetBodyChildren(bodyId, body).ToArray();
|
||||
gibs.EnsureCapacity(parts.Length);
|
||||
|
||||
foreach (var part in parts)
|
||||
{
|
||||
DropPart(part.Id, part.Component);
|
||||
SharedTransform.AttachToGridOrMap(part.Id);
|
||||
gibs.Add(part.Id);
|
||||
|
||||
if (!gibOrgans)
|
||||
@@ -247,7 +308,7 @@ public partial class SharedBodySystem
|
||||
|
||||
foreach (var organ in GetPartOrgans(part.Id, part.Component))
|
||||
{
|
||||
DropOrgan(organ.Id, organ.Component);
|
||||
SharedTransform.AttachToGridOrMap(organ.Id);
|
||||
gibs.Add(organ.Id);
|
||||
}
|
||||
}
|
||||
|
||||
@@ -3,194 +3,142 @@ using Content.Shared.Body.Components;
|
||||
using Content.Shared.Body.Events;
|
||||
using Content.Shared.Body.Organ;
|
||||
using Content.Shared.Body.Part;
|
||||
using Content.Shared.Random.Helpers;
|
||||
using Robust.Shared.Containers;
|
||||
using Robust.Shared.GameStates;
|
||||
using Robust.Shared.Map;
|
||||
|
||||
namespace Content.Shared.Body.Systems;
|
||||
|
||||
public partial class SharedBodySystem
|
||||
{
|
||||
[Dependency] private readonly SharedContainerSystem _container = default!;
|
||||
|
||||
private void InitializeOrgans()
|
||||
private void AddOrgan(EntityUid uid, EntityUid bodyUid, EntityUid parentPartUid, OrganComponent component)
|
||||
{
|
||||
SubscribeLocalEvent<OrganComponent, ComponentGetState>(OnOrganGetState);
|
||||
SubscribeLocalEvent<OrganComponent, ComponentHandleState>(OnOrganHandleState);
|
||||
component.Body = bodyUid;
|
||||
RaiseLocalEvent(uid, new AddedToPartEvent(bodyUid));
|
||||
|
||||
if (component.Body != null)
|
||||
RaiseLocalEvent(uid, new AddedToPartInBodyEvent(component.Body.Value, parentPartUid));
|
||||
|
||||
Dirty(uid, component);
|
||||
}
|
||||
|
||||
private void RemoveOrgan(EntityUid uid, EntityUid bodyUid, EntityUid parentPartUid, OrganComponent component)
|
||||
{
|
||||
RaiseLocalEvent(uid, new RemovedFromPartEvent(bodyUid));
|
||||
|
||||
if (component.Body != null)
|
||||
RaiseLocalEvent(uid, new RemovedFromPartInBodyEvent(component.Body.Value, parentPartUid));
|
||||
|
||||
component.Body = null;
|
||||
Dirty(uid, component);
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Creates the specified organ slot on the parent entity.
|
||||
/// </summary>
|
||||
private OrganSlot? CreateOrganSlot(string slotId, EntityUid parent, BodyPartComponent? part = null)
|
||||
{
|
||||
if (!Resolve(parent, ref part, false))
|
||||
return null;
|
||||
|
||||
var slot = new OrganSlot()
|
||||
{
|
||||
Id = slotId,
|
||||
Parent = parent,
|
||||
NetParent = GetNetEntity(parent),
|
||||
};
|
||||
Containers.EnsureContainer<ContainerSlot>(parent, GetOrganContainerId(slotId));
|
||||
var slot = new OrganSlot(slotId);
|
||||
part.Organs.Add(slotId, slot);
|
||||
|
||||
return slot;
|
||||
}
|
||||
|
||||
private bool CanInsertOrgan(EntityUid? organId, OrganSlot slot, OrganComponent? organ = null)
|
||||
/// <summary>
|
||||
/// Attempts to create the specified organ slot on the specified parent if it exists.
|
||||
/// </summary>
|
||||
public bool TryCreateOrganSlot(
|
||||
EntityUid? parent,
|
||||
string slotId,
|
||||
[NotNullWhen(true)] out OrganSlot? slot,
|
||||
BodyPartComponent? part = null)
|
||||
{
|
||||
return organId != null &&
|
||||
slot.Child == null &&
|
||||
Resolve(organId.Value, ref organ, false) &&
|
||||
Containers.TryGetContainer(slot.Parent, BodyContainerId, out var container) &&
|
||||
_container.CanInsert(organId.Value, container);
|
||||
}
|
||||
slot = null;
|
||||
|
||||
private void OnOrganGetState(EntityUid uid, OrganComponent organ, ref ComponentGetState args)
|
||||
{
|
||||
args.State = new OrganComponentState(GetNetEntity(organ.Body), organ.ParentSlot);
|
||||
}
|
||||
|
||||
private void OnOrganHandleState(EntityUid uid, OrganComponent organ, ref ComponentHandleState args)
|
||||
{
|
||||
if (args.Current is not OrganComponentState state)
|
||||
return;
|
||||
|
||||
organ.Body = EnsureEntity<OrganComponent>(state.Body, uid);
|
||||
organ.ParentSlot = state.Parent;
|
||||
}
|
||||
|
||||
public bool InsertOrgan(EntityUid? organId, OrganSlot slot, OrganComponent? organ = null)
|
||||
{
|
||||
if (organId == null ||
|
||||
!Resolve(organId.Value, ref organ, false) ||
|
||||
!CanInsertOrgan(organId, slot, organ))
|
||||
return false;
|
||||
|
||||
DropOrgan(slot.Child);
|
||||
DropOrgan(organId, organ);
|
||||
|
||||
var container = Containers.EnsureContainer<Container>(slot.Parent, BodyContainerId);
|
||||
if (!container.Insert(organId.Value))
|
||||
return false;
|
||||
|
||||
slot.Child = organId;
|
||||
organ.ParentSlot = slot;
|
||||
organ.Body = CompOrNull<BodyPartComponent>(slot.Parent)?.Body;
|
||||
|
||||
DirtyAllComponents(slot.Parent);
|
||||
Dirty(organId.Value, organ);
|
||||
|
||||
if (organ.Body == null)
|
||||
if (parent == null || !Resolve(parent.Value, ref part, false))
|
||||
{
|
||||
RaiseLocalEvent(organId.Value, new AddedToPartEvent(slot.Parent));
|
||||
}
|
||||
else
|
||||
{
|
||||
RaiseLocalEvent(organId.Value, new AddedToPartInBodyEvent(organ.Body.Value, slot.Parent));
|
||||
return false;
|
||||
}
|
||||
|
||||
return true;
|
||||
Containers.EnsureContainer<ContainerSlot>(parent.Value, GetOrganContainerId(slotId));
|
||||
slot = new OrganSlot(slotId);
|
||||
return part.Organs.TryAdd(slotId,slot.Value);
|
||||
}
|
||||
|
||||
public void DirtyAllComponents(EntityUid uid)
|
||||
/// <summary>
|
||||
/// Returns whether the slotId exists on the partId.
|
||||
/// </summary>
|
||||
public bool CanInsertOrgan(EntityUid partId, string slotId, BodyPartComponent? part = null)
|
||||
{
|
||||
// TODO just use containers. Please
|
||||
if (TryComp(uid, out BodyPartComponent? part))
|
||||
Dirty(uid, part);
|
||||
|
||||
if (TryComp(uid, out OrganComponent? organ))
|
||||
Dirty(uid, organ);
|
||||
|
||||
if (TryComp(uid, out BodyComponent? body))
|
||||
Dirty(uid, body);
|
||||
return Resolve(partId, ref part) && part.Organs.ContainsKey(slotId);
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Returns whether the specified organ slot exists on the partId.
|
||||
/// </summary>
|
||||
public bool CanInsertOrgan(EntityUid partId, OrganSlot slot, BodyPartComponent? part = null)
|
||||
{
|
||||
return CanInsertOrgan(partId, slot.Id, part);
|
||||
}
|
||||
|
||||
public bool InsertOrgan(EntityUid partId, EntityUid organId, string slotId, BodyPartComponent? part = null, OrganComponent? organ = null)
|
||||
{
|
||||
if (!Resolve(organId, ref organ, false) ||
|
||||
!Resolve(partId, ref part, false) ||
|
||||
!CanInsertOrgan(partId, slotId, part))
|
||||
{
|
||||
return false;
|
||||
}
|
||||
|
||||
var containerId = GetOrganContainerId(slotId);
|
||||
|
||||
if (!Containers.TryGetContainer(partId, containerId, out var container))
|
||||
return false;
|
||||
|
||||
return container.Insert(organId);
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Removes the organ if it is inside of a body part.
|
||||
/// </summary>
|
||||
public bool RemoveOrgan(EntityUid organId, OrganComponent? organ = null)
|
||||
{
|
||||
if (!Containers.TryGetContainingContainer(organId, out var container))
|
||||
return false;
|
||||
|
||||
var parent = container.Owner;
|
||||
|
||||
if (!HasComp<BodyPartComponent>(parent))
|
||||
return false;
|
||||
|
||||
return container.Remove(organId);
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Tries to add this organ to any matching slot on this body part.
|
||||
/// </summary>
|
||||
public bool AddOrganToFirstValidSlot(
|
||||
EntityUid? childId,
|
||||
EntityUid? parentId,
|
||||
OrganComponent? child = null,
|
||||
BodyPartComponent? parent = null)
|
||||
EntityUid partId,
|
||||
EntityUid organId,
|
||||
BodyPartComponent? part = null,
|
||||
OrganComponent? organ = null)
|
||||
{
|
||||
if (childId == null ||
|
||||
!Resolve(childId.Value, ref child, false) ||
|
||||
parentId == null ||
|
||||
!Resolve(parentId.Value, ref parent, false))
|
||||
return false;
|
||||
|
||||
foreach (var slot in parent.Organs.Values)
|
||||
if (!Resolve(partId, ref part, false) ||
|
||||
!Resolve(organId, ref organ, false))
|
||||
{
|
||||
if (slot.Child == null)
|
||||
continue;
|
||||
return false;
|
||||
}
|
||||
|
||||
InsertOrgan(childId, slot, child);
|
||||
foreach (var slotId in part.Organs.Keys)
|
||||
{
|
||||
InsertOrgan(partId, organId, slotId, part, organ);
|
||||
return true;
|
||||
}
|
||||
|
||||
return false;
|
||||
}
|
||||
|
||||
public bool DropOrgan(EntityUid? organId, OrganComponent? organ = null)
|
||||
{
|
||||
if (organId == null ||
|
||||
!Resolve(organId.Value, ref organ, false) ||
|
||||
organ.ParentSlot is not { } slot)
|
||||
return false;
|
||||
|
||||
var oldParent = CompOrNull<BodyPartComponent>(organ.ParentSlot.Parent);
|
||||
|
||||
slot.Child = null;
|
||||
organ.ParentSlot = null;
|
||||
organ.Body = null;
|
||||
|
||||
if (Containers.TryGetContainer(slot.Parent, BodyContainerId, out var container))
|
||||
container.Remove(organId.Value);
|
||||
|
||||
if (TryComp(organId, out TransformComponent? transform))
|
||||
transform.AttachToGridOrMap();
|
||||
|
||||
organ.Owner.RandomOffset(0.25f);
|
||||
|
||||
if (oldParent == null)
|
||||
return true;
|
||||
|
||||
if (oldParent.Body != null)
|
||||
{
|
||||
RaiseLocalEvent(organId.Value, new RemovedFromPartInBodyEvent(oldParent.Body.Value, oldParent.Owner));
|
||||
}
|
||||
else
|
||||
{
|
||||
RaiseLocalEvent(organId.Value, new RemovedFromPartEvent(oldParent.Owner));
|
||||
}
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
public bool DropOrganAt(EntityUid? organId, EntityCoordinates dropAt, OrganComponent? organ = null)
|
||||
{
|
||||
if (organId == null || !DropOrgan(organId, organ))
|
||||
return false;
|
||||
|
||||
if (TryComp(organId.Value, out TransformComponent? transform))
|
||||
transform.Coordinates = dropAt;
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
public bool DeleteOrgan(EntityUid? id, OrganComponent? part = null)
|
||||
{
|
||||
if (id == null || !Resolve(id.Value, ref part, false))
|
||||
return false;
|
||||
|
||||
DropOrgan(id, part);
|
||||
|
||||
if (Deleted(id.Value))
|
||||
return false;
|
||||
|
||||
Del(id.Value);
|
||||
return true;
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Returns a list of ValueTuples of <see cref="T"/> and OrganComponent on each organ
|
||||
/// in the given body.
|
||||
|
||||
File diff suppressed because it is too large
Load Diff
@@ -8,14 +8,31 @@ namespace Content.Shared.Body.Systems;
|
||||
|
||||
public abstract partial class SharedBodySystem : EntitySystem
|
||||
{
|
||||
protected const string BodyContainerId = "BodyContainer";
|
||||
/*
|
||||
* See the body partial for how this works.
|
||||
*/
|
||||
|
||||
/// <summary>
|
||||
/// Container ID prefix for any body parts.
|
||||
/// </summary>
|
||||
protected const string PartSlotContainerIdPrefix = "body_part_slot_";
|
||||
|
||||
/// <summary>
|
||||
/// Container ID for the ContainerSlot on the body entity itself.
|
||||
/// </summary>
|
||||
protected const string BodyRootContainerId = "body_root_part";
|
||||
|
||||
/// <summary>
|
||||
/// Container ID prefix for any body organs.
|
||||
/// </summary>
|
||||
protected const string OrganSlotContainerIdPrefix = "body_organ_slot_";
|
||||
|
||||
[Dependency] protected readonly IPrototypeManager Prototypes = default!;
|
||||
|
||||
[Dependency] protected readonly SharedContainerSystem Containers = default!;
|
||||
[Dependency] protected readonly DamageableSystem Damageable = default!;
|
||||
[Dependency] protected readonly StandingStateSystem Standing = default!;
|
||||
[Dependency] protected readonly MovementSpeedModifierSystem Movement = default!;
|
||||
[Dependency] protected readonly SharedContainerSystem Containers = default!;
|
||||
[Dependency] protected readonly SharedTransformSystem SharedTransform = default!;
|
||||
[Dependency] protected readonly StandingStateSystem Standing = default!;
|
||||
|
||||
public override void Initialize()
|
||||
{
|
||||
@@ -23,6 +40,36 @@ public abstract partial class SharedBodySystem : EntitySystem
|
||||
|
||||
InitializeBody();
|
||||
InitializeParts();
|
||||
InitializeOrgans();
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Inverse of <see cref="GetPartSlotContainerId"/>
|
||||
/// </summary>
|
||||
protected static string? GetPartSlotContainerIdFromContainer(string containerSlotId)
|
||||
{
|
||||
// This is blursed
|
||||
var slotIndex = containerSlotId.IndexOf(PartSlotContainerIdPrefix, StringComparison.Ordinal);
|
||||
|
||||
if (slotIndex < -1)
|
||||
return null;
|
||||
|
||||
var slotId = containerSlotId.Remove(slotIndex, PartSlotContainerIdPrefix.Length);
|
||||
return slotId;
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Gets the container Id for the specified slotId.
|
||||
/// </summary>
|
||||
public static string GetPartSlotContainerId(string slotId)
|
||||
{
|
||||
return PartSlotContainerIdPrefix + slotId;
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Gets the container Id for the specified slotId.
|
||||
/// </summary>
|
||||
public static string GetOrganContainerId(string slotId)
|
||||
{
|
||||
return OrganSlotContainerIdPrefix + slotId;
|
||||
}
|
||||
}
|
||||
|
||||
Reference in New Issue
Block a user