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

EntityStorage ECS (#9291)

Browse Source
This commit is contained in:
Nemanja
2022-07-13 19:11:59 -04:00
committed by GitHub
parent a655891a8d
commit 5edf2ccad5
46 changed files with 1057 additions and 1126 deletions
Download Patch File Download Diff File Expand all files Collapse all files

9
Content.Server/Storage/Components/ArtifactStorageComponent.cs
View File

@@ -1,14 +1,7 @@
using Content.Server.Xenoarchaeology.XenoArtifacts;
namespace Content.Server.Storage.Components;
[RegisterComponent]
public sealed class ArtifactStorageComponent : EntityStorageComponent
public sealed class ArtifactStorageComponent : Component
{
[Dependency] private readonly IEntityManager _entMan = default!;
public override bool CanFit(EntityUid entity)
{
return _entMan.HasComponent<ArtifactComponent>(entity);
}
}

54
Content.Server/Storage/Components/CursedEntityStorageComponent.cs
View File

@@ -1,54 +1,12 @@
using Content.Shared.Audio;
using Content.Shared.Interaction;
using Content.Shared.Sound;
using Robust.Shared.Audio;
using Robust.Shared.Player;
using Robust.Shared.Random;
using System.Linq;
namespace Content.Server.Storage.Components
namespace Content.Server.Storage.Components;
[RegisterComponent]
public sealed class CursedEntityStorageComponent : Component
{
[ComponentReference(typeof(EntityStorageComponent))]
[ComponentReference(typeof(IActivate))]
[ComponentReference(typeof(IStorageComponent))]
[RegisterComponent]
public sealed class CursedEntityStorageComponent : EntityStorageComponent
{
[Dependency] private readonly IEntityManager _entMan = default!;
[Dependency] private readonly IRobustRandom _robustRandom = default!;
[DataField("cursedSound")] private SoundSpecifier _cursedSound = new SoundPathSpecifier("/Audio/Effects/teleport_departure.ogg");
[DataField("cursedLockerSound")] private SoundSpecifier _cursedLockerSound = new SoundPathSpecifier("/Audio/Effects/teleport_arrival.ogg");
protected override void CloseStorage()
{
base.CloseStorage();
// No contents, we do nothing
if (Contents.ContainedEntities.Count == 0) return;
var lockers = _entMan.EntityQuery<EntityStorageComponent>().Select(c => c.Owner).ToList();
if (lockers.Contains(Owner))
lockers.Remove(Owner);
if (lockers.Count == 0) return;
var lockerEnt = _robustRandom.Pick(lockers);
var locker = _entMan.GetComponent<EntityStorageComponent>(lockerEnt);
if (locker.Open)
locker.TryCloseStorage(Owner);
foreach (var entity in Contents.ContainedEntities.ToArray())
{
Contents.ForceRemove(entity);
locker.Insert(entity);
}
SoundSystem.Play(_cursedSound.GetSound(), Filter.Pvs(Owner), Owner, AudioHelpers.WithVariation(0.125f));
SoundSystem.Play(_cursedLockerSound.GetSound(), Filter.Pvs(lockerEnt), lockerEnt, AudioHelpers.WithVariation(0.125f));
}
}
[DataField("cursedSound")]
public SoundSpecifier CursedSound = new SoundPathSpecifier("/Audio/Effects/teleport_departure.ogg");
}

477
Content.Server/Storage/Components/EntityStorageComponent.cs
View File

@@ -1,389 +1,104 @@
using System.Linq;
using Content.Server.Buckle.Components;
using Content.Server.Construction;
using Content.Server.Construction.Completions;
using Content.Server.Construction.Components;
using Content.Server.Ghost.Components;
using Content.Server.Storage.EntitySystems;
using Content.Shared.Body.Components;
using Content.Shared.Foldable;
using Content.Shared.Interaction;
using Content.Shared.Item;
using Content.Shared.Physics;
using Content.Shared.Placeable;
using Content.Shared.Popups;
using Content.Shared.Sound;
using Content.Shared.Storage;
using Robust.Shared.Audio;
using Robust.Shared.Containers;
using Robust.Shared.Physics;
using Robust.Shared.Player;
namespace Content.Server.Storage.Components
namespace Content.Server.Storage.Components;
[RegisterComponent]
public sealed class EntityStorageComponent : Component
{
[RegisterComponent]
[Virtual]
[ComponentReference(typeof(IActivate))]
[ComponentReference(typeof(IStorageComponent))]
public class EntityStorageComponent : Component, IActivate, IStorageComponent
public readonly float MaxSize = 1.0f; // maximum width or height of an entity allowed inside the storage.
public static readonly TimeSpan InternalOpenAttemptDelay = TimeSpan.FromSeconds(0.5);
public TimeSpan LastInternalOpenAttempt;
/// <summary>
/// Collision masks that get removed when the storage gets opened.
/// </summary>
public readonly int MasksToRemove = (int) (
CollisionGroup.MidImpassable |
CollisionGroup.HighImpassable |
CollisionGroup.LowImpassable);
/// <summary>
/// Collision masks that were removed from ANY layer when the storage was opened;
/// </summary>
[DataField("removedMasks")]
public int RemovedMasks;
[ViewVariables]
[DataField("Capacity")]
public int StorageCapacityMax = 30;
[ViewVariables]
[DataField("IsCollidableWhenOpen")]
public bool IsCollidableWhenOpen;
//The offset for where items are emptied/vacuumed for the EntityStorage.
[DataField("enteringOffset")]
public Vector2 EnteringOffset = new(0, 0);
//The collision groups checked, so that items are depositied or grabbed from inside walls.
[DataField("enteringOffsetCollisionFlags")]
public readonly CollisionGroup EnteringOffsetCollisionFlags = CollisionGroup.Impassable | CollisionGroup.MidImpassable;
[ViewVariables]
[DataField("EnteringRange")]
public float EnteringRange = -0.18f;
[DataField("showContents")]
public bool ShowContents;
[DataField("occludesLight")]
public bool OccludesLight = true;
[DataField("deleteContentsOnDestruction")]
public bool DeleteContentsOnDestruction = false;
[DataField("open")]
public bool Open;
[DataField("closeSound")]
public SoundSpecifier CloseSound = new SoundPathSpecifier("/Audio/Effects/closetclose.ogg");
[DataField("openSound")]
public SoundSpecifier OpenSound = new SoundPathSpecifier("/Audio/Effects/closetopen.ogg");
[ViewVariables]
public Container Contents = default!;
[ViewVariables(VVAccess.ReadWrite)]
public bool IsWeldedShut;
}
public sealed class InsertIntoEntityStorageAttemptEvent : CancellableEntityEventArgs { }
public sealed class StoreMobInItemContainerAttemptEvent : CancellableEntityEventArgs
{
public bool Handled = false;
}
public sealed class StorageOpenAttemptEvent : CancellableEntityEventArgs
{
public bool Silent = false;
public StorageOpenAttemptEvent (bool silent = false)
{
[Dependency] private readonly IEntityManager _entMan = default!;
private const float MaxSize = 1.0f; // maximum width or height of an entity allowed inside the storage.
public static readonly TimeSpan InternalOpenAttemptDelay = TimeSpan.FromSeconds(0.5);
public TimeSpan LastInternalOpenAttempt;
/// <summary>
/// Collision masks that get removed when the storage gets opened.
/// </summary>
private const int MasksToRemove = (int) (
CollisionGroup.MidImpassable |
CollisionGroup.HighImpassable |
CollisionGroup.LowImpassable);
/// <summary>
/// Collision masks that were removed from ANY layer when the storage was opened;
/// </summary>
[DataField("removedMasks")] public int RemovedMasks;
[ViewVariables]
[DataField("Capacity")]
private int _storageCapacityMax = 30;
[ViewVariables]
[DataField("IsCollidableWhenOpen")]
private bool _isCollidableWhenOpen;
[ViewVariables]
[DataField("EnteringRange")]
private float _enteringRange = -0.18f;
[DataField("showContents")]
private bool _showContents;
[DataField("occludesLight")]
private bool _occludesLight = true;
[DataField("open")]
public bool Open;
[DataField("closeSound")]
private SoundSpecifier _closeSound = new SoundPathSpecifier("/Audio/Effects/closetclose.ogg");
[DataField("openSound")]
private SoundSpecifier _openSound = new SoundPathSpecifier("/Audio/Effects/closetopen.ogg");
[ViewVariables]
public Container Contents = default!;
/// <summary>
/// Determines if the container contents should be drawn when the container is closed.
/// </summary>
[ViewVariables(VVAccess.ReadWrite)]
public bool ShowContents
{
get => _showContents;
set
{
_showContents = value;
Contents.ShowContents = _showContents;
}
}
[ViewVariables(VVAccess.ReadWrite)]
public bool OccludesLight
{
get => _occludesLight;
set
{
_occludesLight = value;
Contents.OccludesLight = _occludesLight;
}
}
[ViewVariables(VVAccess.ReadWrite)]
public bool IsWeldedShut;
[ViewVariables(VVAccess.ReadWrite)]
public float EnteringRange
{
get => _enteringRange;
set => _enteringRange = value;
}
/// <inheritdoc />
protected override void Initialize()
{
base.Initialize();
Contents = Owner.EnsureContainer<Container>(EntityStorageSystem.ContainerName);
Contents.ShowContents = _showContents;
Contents.OccludesLight = _occludesLight;
if(_entMan.TryGetComponent(Owner, out ConstructionComponent? construction))
EntitySystem.Get<ConstructionSystem>().AddContainer(Owner, nameof(EntityStorageComponent), construction);
if (_entMan.TryGetComponent<PlaceableSurfaceComponent?>(Owner, out var surface))
{
EntitySystem.Get<PlaceableSurfaceSystem>().SetPlaceable(Owner, Open, surface);
}
}
public virtual void Activate(ActivateEventArgs eventArgs)
{
ToggleOpen(eventArgs.User);
}
public virtual bool CanOpen(EntityUid user, bool silent = false)
{
if (IsWeldedShut)
{
if (!silent && !Contents.Contains(user))
Owner.PopupMessage(user, Loc.GetString("entity-storage-component-welded-shut-message"));
return false;
}
if (_entMan.TryGetComponent<LockComponent?>(Owner, out var @lock) && @lock.Locked)
{
if (!silent) Owner.PopupMessage(user, Loc.GetString("entity-storage-component-locked-message"));
return false;
}
var @event = new StorageOpenAttemptEvent();
IoCManager.Resolve<IEntityManager>().EventBus.RaiseLocalEvent(Owner, @event, true);
return !@event.Cancelled;
}
public virtual bool CanClose(EntityUid user, bool silent = false)
{
var @event = new StorageCloseAttemptEvent();
IoCManager.Resolve<IEntityManager>().EventBus.RaiseLocalEvent(Owner, @event, true);
return !@event.Cancelled;
}
public void ToggleOpen(EntityUid user)
{
if (Open)
{
TryCloseStorage(user);
}
else
{
TryOpenStorage(user);
}
}
protected virtual void CloseStorage()
{
Open = false;
var count = 0;
foreach (var entity in DetermineCollidingEntities())
{
// prevents taking items out of inventories, out of containers, and orphaning child entities
if (entity.IsInContainer())
continue;
if (!CanFit(entity))
continue;
// finally, AddToContents
if (!AddToContents(entity))
continue;
count++;
if (count >= _storageCapacityMax)
{
break;
}
}
ModifyComponents();
SoundSystem.Play(_closeSound.GetSound(), Filter.Pvs(Owner), Owner);
LastInternalOpenAttempt = default;
}
public virtual bool CanFit(EntityUid entity)
{
// conditions are complicated because of pizzabox-related issues, so follow this guide
// 0. Accomplish your goals at all costs.
// 1. AddToContents can block anything
// 2. maximum item count can block anything
// 3. ghosts can NEVER be eaten
// 4. items can always be eaten unless a previous law prevents it
// 5. if this is NOT AN ITEM, then mobs can always be eaten unless unless a previous law prevents it
// 6. if this is an item, then mobs must only be eaten if some other component prevents pick-up interactions while a mob is inside (e.g. foldable)
var attemptEvent = new InsertIntoEntityStorageAttemptEvent();
_entMan.EventBus.RaiseLocalEvent(entity, attemptEvent);
if (attemptEvent.Cancelled)
return false;
// checks
// TODO: Make the others sub to it.
var targetIsItem = _entMan.HasComponent<SharedItemComponent>(entity);
var targetIsMob = _entMan.HasComponent<SharedBodyComponent>(entity);
var storageIsItem = _entMan.HasComponent<SharedItemComponent>(Owner);
var allowedToEat = targetIsItem;
// BEFORE REPLACING THIS WITH, I.E. A PROPERTY:
// Make absolutely 100% sure you have worked out how to stop people ending up in backpacks.
// Seriously, it is insanely hacky and weird to get someone out of a backpack once they end up in there.
// And to be clear, they should NOT be in there.
// For the record, what you need to do is empty the backpack onto a PlacableSurface (table, rack)
if (targetIsMob)
{
if (!storageIsItem)
allowedToEat = true;
else
{
var storeEv = new StoreThisAttemptEvent();
_entMan.EventBus.RaiseLocalEvent(Owner, storeEv);
allowedToEat = !storeEv.Cancelled;
}
}
return allowedToEat;
}
protected virtual void OpenStorage()
{
Open = true;
EntitySystem.Get<EntityStorageSystem>().EmptyContents(Owner, this);
ModifyComponents();
SoundSystem.Play(_openSound.GetSound(), Filter.Pvs(Owner), Owner);
}
private void ModifyComponents()
{
if (!_isCollidableWhenOpen && _entMan.TryGetComponent<FixturesComponent?>(Owner, out var manager)
&& manager.Fixtures.Count > 0)
{
// currently only works for single-fixture entities. If they have more than one fixture, then
// RemovedMasks needs to be tracked separately for each fixture, using a fixture Id Dictionary. Also the
// fixture IDs probably cant be automatically generated without causing issues, unless there is some
// guarantee that they will get deserialized with the same auto-generated ID when saving+loading the map.
var fixture = manager.Fixtures.Values.First();
if (Open)
{
RemovedMasks = fixture.CollisionLayer & MasksToRemove;
fixture.CollisionLayer &= ~MasksToRemove;
}
else
{
fixture.CollisionLayer |= RemovedMasks;
RemovedMasks = 0;
}
}
if (_entMan.TryGetComponent<PlaceableSurfaceComponent?>(Owner, out var surface))
{
EntitySystem.Get<PlaceableSurfaceSystem>().SetPlaceable(Owner, Open, surface);
}
if (_entMan.TryGetComponent(Owner, out AppearanceComponent? appearance))
{
appearance.SetData(StorageVisuals.Open, Open);
}
}
protected virtual bool AddToContents(EntityUid entity)
{
if (entity == Owner) return false;
if (_entMan.TryGetComponent(entity, out IPhysBody? entityPhysicsComponent))
{
if (MaxSize < entityPhysicsComponent.GetWorldAABB().Size.X
|| MaxSize < entityPhysicsComponent.GetWorldAABB().Size.Y)
{
return false;
}
}
return Contents.CanInsert(entity) && Insert(entity);
}
public virtual Vector2 ContentsDumpPosition()
{
return _entMan.GetComponent<TransformComponent>(Owner).WorldPosition;
}
public virtual bool TryOpenStorage(EntityUid user)
{
if (!CanOpen(user)) return false;
OpenStorage();
return true;
}
public virtual bool TryCloseStorage(EntityUid user)
{
if (!CanClose(user)) return false;
CloseStorage();
return true;
}
/// <inheritdoc />
public bool Remove(EntityUid entity)
{
return Contents.CanRemove(entity);
}
/// <inheritdoc />
public bool Insert(EntityUid entity)
{
// Trying to add while open just dumps it on the ground below us.
if (Open)
{
var entMan = _entMan;
entMan.GetComponent<TransformComponent>(entity).WorldPosition = entMan.GetComponent<TransformComponent>(Owner).WorldPosition;
return true;
}
return Contents.Insert(entity);
}
/// <inheritdoc />
public bool CanInsert(EntityUid entity)
{
if (Open)
{
return true;
}
if (Contents.ContainedEntities.Count >= _storageCapacityMax)
{
return false;
}
return Contents.CanInsert(entity);
}
protected virtual IEnumerable<EntityUid> DetermineCollidingEntities()
{
var entityLookup = EntitySystem.Get<EntityLookupSystem>();
return entityLookup.GetEntitiesInRange(Owner, _enteringRange, LookupFlags.Approximate);
}
}
public sealed class InsertIntoEntityStorageAttemptEvent : CancellableEntityEventArgs
{
}
public sealed class StoreThisAttemptEvent : CancellableEntityEventArgs
{
}
public sealed class StorageOpenAttemptEvent : CancellableEntityEventArgs
{
}
public sealed class StorageCloseAttemptEvent : CancellableEntityEventArgs
{
Silent = silent;
}
}
public sealed class StorageAfterOpenEvent : EventArgs { }
public sealed class StorageCloseAttemptEvent : CancellableEntityEventArgs { }
public sealed class StorageBeforeCloseEvent : EventArgs
{
public EntityUid Container;
public HashSet<EntityUid> Contents;
public HashSet<EntityUid> ContentsWhitelist = new();
public StorageBeforeCloseEvent(EntityUid container, HashSet<EntityUid> contents)
{
Container = container;
Contents = contents;
}
}
public sealed class StorageAfterCloseEvent : EventArgs { }

9
Content.Server/Storage/Components/IStorageComponent.cs
View File

@@ -1,9 +0,0 @@
namespace Content.Server.Storage.Components
{
public interface IStorageComponent : IComponent
{
bool Remove(EntityUid entity);
bool Insert(EntityUid entity);
bool CanInsert(EntityUid entity);
}
}

23
Content.Server/Storage/EntitySystems/ArtifactStorageSystem.cs Normal file
View File

@@ -0,0 +1,23 @@
using Content.Server.Storage.Components;
using Content.Server.Xenoarchaeology.XenoArtifacts;
namespace Content.Server.Storage.EntitySystems;
public sealed class ArtifactStorageSystem : EntitySystem
{
public override void Initialize()
{
base.Initialize();
SubscribeLocalEvent<ArtifactStorageComponent, StorageBeforeCloseEvent>(OnBeforeClose);
}
private void OnBeforeClose(EntityUid uid, ArtifactStorageComponent component, StorageBeforeCloseEvent args)
{
foreach (var ent in args.Contents)
{
if (HasComp<ArtifactComponent>(ent))
args.ContentsWhitelist.Add(ent);
}
}
}

47
Content.Server/Storage/EntitySystems/CursedEntityStorageSystem.cs Normal file
View File

@@ -0,0 +1,47 @@
using Content.Server.Storage.Components;
using Content.Shared.Audio;
using Content.Shared.Interaction;
using Robust.Server.Containers;
using Robust.Shared.Audio;
using Robust.Shared.Player;
using Robust.Shared.Random;
using System.Linq;
namespace Content.Server.Storage.EntitySystems;
public sealed class CursedEntityStorageSystem : EntitySystem
{
[Dependency] private readonly IRobustRandom _random = default!;
[Dependency] private readonly EntityStorageSystem _entityStorage = default!;
public override void Initialize()
{
base.Initialize();
SubscribeLocalEvent<CursedEntityStorageComponent, StorageAfterCloseEvent>(OnClose);
}
private void OnClose(EntityUid uid, CursedEntityStorageComponent component, StorageAfterCloseEvent args)
{
if (!TryComp<EntityStorageComponent>(uid, out var storage))
return;
if (storage.Open || storage.Contents.ContainedEntities.Count <= 0)
return;
var lockerQuery = EntityQuery<EntityStorageComponent>().ToList();
lockerQuery.Remove(storage);
if (lockerQuery.Count == 0)
return;
var lockerEnt = _random.Pick(lockerQuery).Owner;
foreach (var entity in storage.Contents.ContainedEntities.ToArray())
{
storage.Contents.Remove(entity);
_entityStorage.AddToContents(entity, lockerEnt);
}
SoundSystem.Play(component.CursedSound.GetSound(), Filter.Pvs(uid), uid, AudioHelpers.WithVariation(0.125f, _random));
}
}

306
Content.Server/Storage/EntitySystems/EntityStorageSystem.cs
View File

@@ -1,8 +1,19 @@
using System.Linq;
using System.Linq;
using Content.Server.Construction;
using Content.Server.Construction.Components;
using Content.Server.Popups;
using Content.Server.Storage.Components;
using Content.Server.Tools.Systems;
using Content.Shared.Body.Components;
using Content.Shared.Destructible;
using Content.Shared.Interaction;
using Content.Shared.Item;
using Content.Shared.Placeable;
using Content.Shared.Storage;
using Robust.Server.Containers;
using Robust.Shared.Audio;
using Robust.Shared.Containers;
using Robust.Shared.Map;
using Robust.Shared.Physics;
using Robust.Shared.Player;
@@ -10,6 +21,11 @@ namespace Content.Server.Storage.EntitySystems;
public sealed class EntityStorageSystem : EntitySystem
{
[Dependency] private readonly ConstructionSystem _construction = default!;
[Dependency] private readonly ContainerSystem _container = default!;
[Dependency] private readonly EntityLookupSystem _lookup = default!;
[Dependency] private readonly SharedInteractionSystem _interactionSystem = default!;
[Dependency] private readonly PlaceableSurfaceSystem _placeableSurface = default!;
[Dependency] private readonly PopupSystem _popupSystem = default!;
public const string ContainerName = "entity_storage";
@@ -17,11 +33,36 @@ public sealed class EntityStorageSystem : EntitySystem
public override void Initialize()
{
base.Initialize();
SubscribeLocalEvent<EntityStorageComponent, ComponentInit>(OnInit);
SubscribeLocalEvent<EntityStorageComponent, ActivateInWorldEvent>(OnInteract);
SubscribeLocalEvent<EntityStorageComponent, WeldableAttemptEvent>(OnWeldableAttempt);
SubscribeLocalEvent<EntityStorageComponent, WeldableChangedEvent>(OnWelded);
SubscribeLocalEvent<EntityStorageComponent, DestructionEventArgs>(OnDestroy);
}
private void OnInit(EntityUid uid, EntityStorageComponent component, ComponentInit args)
{
component.Contents = _container.EnsureContainer<Container>(uid, ContainerName);
component.Contents.ShowContents = component.ShowContents;
component.Contents.OccludesLight = component.OccludesLight;
if (TryComp<ConstructionComponent>(uid, out var construction))
_construction.AddContainer(uid, nameof(EntityStorageComponent), construction);
if (TryComp<PlaceableSurfaceComponent>(uid, out var placeable))
_placeableSurface.SetPlaceable(uid, component.Open, placeable);
}
private void OnInteract(EntityUid uid, EntityStorageComponent component, ActivateInWorldEvent args)
{
if (args.Handled)
return;
args.Handled = true;
ToggleOpen(args.User, uid, component);
}
private void OnWeldableAttempt(EntityUid uid, EntityStorageComponent component, WeldableAttemptEvent args)
{
if (component.Open)
@@ -46,7 +87,23 @@ public sealed class EntityStorageSystem : EntitySystem
private void OnDestroy(EntityUid uid, EntityStorageComponent component, DestructionEventArgs args)
{
component.Open = true;
EmptyContents(uid, component);
if (!component.DeleteContentsOnDestruction)
EmptyContents(uid, component);
}
public void ToggleOpen(EntityUid user, EntityUid target, EntityStorageComponent? component = null)
{
if (!Resolve(target, ref component))
return;
if (component.Open)
{
TryCloseStorage(target);
}
else
{
TryOpenStorage(user, target);
}
}
public void EmptyContents(EntityUid uid, EntityStorageComponent? component = null)
@@ -54,17 +111,252 @@ public sealed class EntityStorageSystem : EntitySystem
if (!Resolve(uid, ref component))
return;
var uidXform = Transform(uid);
var containedArr = component.Contents.ContainedEntities.ToArray();
foreach (var contained in containedArr)
{
if (component.Contents.Remove(contained))
{
Transform(contained).WorldPosition = component.ContentsDumpPosition();
if (TryComp(contained, out IPhysBody? physics))
{
physics.CanCollide = true;
}
Transform(contained).WorldPosition =
uidXform.WorldPosition + uidXform.WorldRotation.RotateVec(component.EnteringOffset);
}
}
}
public void OpenStorage(EntityUid uid, EntityStorageComponent? component = null)
{
if (!Resolve(uid, ref component))
return;
component.Open = true;
EmptyContents(uid, component);
ModifyComponents(uid, component);
SoundSystem.Play(component.OpenSound.GetSound(), Filter.Pvs(component.Owner), component.Owner);
RaiseLocalEvent(uid, new StorageAfterOpenEvent());
}
public void CloseStorage(EntityUid uid, EntityStorageComponent? component = null)
{
if (!Resolve(uid, ref component))
return;
component.Open = false;
var targetCoordinates = new EntityCoordinates(uid, component.EnteringOffset);
var ev = new StorageBeforeCloseEvent(uid, _lookup.GetEntitiesInRange(targetCoordinates, component.EnteringRange, LookupFlags.Approximate));
RaiseLocalEvent(uid, ev, true);
var count = 0;
foreach (var entity in ev.Contents)
{
if (!ev.ContentsWhitelist.Contains(entity))
if (!CanFit(entity, uid))
continue;
if (!AddToContents(entity, uid, component))
continue;
count++;
if (count >= component.StorageCapacityMax)
break;
}
ModifyComponents(uid, component);
SoundSystem.Play(component.CloseSound.GetSound(), Filter.Pvs(uid), uid);
component.LastInternalOpenAttempt = default;
RaiseLocalEvent(uid, new StorageAfterCloseEvent());
}
public bool Insert(EntityUid toInsert, EntityUid container, EntityStorageComponent? component = null)
{
if (!Resolve(container, ref component))
return false;
if (component.Open)
{
Transform(toInsert).WorldPosition = Transform(container).WorldPosition;
return true;
}
return component.Contents.Insert(toInsert, EntityManager);
}
public bool Remove(EntityUid toRemove, EntityUid container, EntityStorageComponent? component = null)
{
if (!Resolve(container, ref component))
return false;
return component.Contents.Remove(toRemove, EntityManager);
}
public bool CanInsert(EntityUid container, EntityStorageComponent? component = null)
{
if (!Resolve(container, ref component))
return false;
if (component.Open)
return true;
if (component.Contents.ContainedEntities.Count >= component.StorageCapacityMax)
return false;
return true;
}
public bool TryOpenStorage(EntityUid user, EntityUid target)
{
if (!CanOpen(user, target))
return false;
OpenStorage(target);
return true;
}
public bool TryCloseStorage(EntityUid target)
{
if (!CanClose(target))
{
return false;
}
CloseStorage(target);
return true;
}
public bool CanOpen(EntityUid user, EntityUid target, bool silent = false, EntityStorageComponent? component = null)
{
if (!Resolve(target, ref component))
return false;
if (component.IsWeldedShut)
{
if (!silent && !component.Contents.Contains(user))
_popupSystem.PopupEntity(Loc.GetString("entity-storage-component-welded-shut-message"), target, Filter.Pvs(target));
return false;
}
//Checks to see if the opening position, if offset, is inside of a wall.
if (component.EnteringOffset != (0, 0)) //if the entering position is offset
{
var targetXform = Transform(target);
var newCoords = new EntityCoordinates(target, component.EnteringOffset);
if (!_interactionSystem.InRangeUnobstructed(target, newCoords, collisionMask: component.EnteringOffsetCollisionFlags))
{
if (!silent)
_popupSystem.PopupEntity(Loc.GetString("entity-storage-component-cannot-open-no-space"), target, Filter.Pvs(target));
return false;
}
}
var ev = new StorageOpenAttemptEvent(silent);
RaiseLocalEvent(target, ev, true);
return !ev.Cancelled;
}
public bool CanClose(EntityUid target, bool silent = false)
{
var ev = new StorageCloseAttemptEvent();
RaiseLocalEvent(target, ev, silent);
return !ev.Cancelled;
}
public bool AddToContents(EntityUid toAdd, EntityUid container, EntityStorageComponent? component = null)
{
if (!Resolve(container, ref component))
return false;
if (toAdd == container)
return false;
if (TryComp<IPhysBody>(toAdd, out var phys))
if (component.MaxSize < phys.GetWorldAABB().Size.X || component.MaxSize < phys.GetWorldAABB().Size.Y)
return false;
return Insert(toAdd, container, component);
}
public bool CanFit(EntityUid toInsert, EntityUid container)
{
// conditions are complicated because of pizzabox-related issues, so follow this guide
// 0. Accomplish your goals at all costs.
// 1. AddToContents can block anything
// 2. maximum item count can block anything
// 3. ghosts can NEVER be eaten
// 4. items can always be eaten unless a previous law prevents it
// 5. if this is NOT AN ITEM, then mobs can always be eaten unless a previous
// law prevents it
// 6. if this is an item, then mobs must only be eaten if some other component prevents
// pick-up interactions while a mob is inside (e.g. foldable)
var attemptEvent = new InsertIntoEntityStorageAttemptEvent();
RaiseLocalEvent(toInsert, attemptEvent);
if (attemptEvent.Cancelled)
return false;
// checks
// TODO: Make the others sub to it.
var targetIsItem = HasComp<SharedItemComponent>(toInsert);
var targetIsMob = HasComp<SharedBodyComponent>(toInsert);
var storageIsItem = HasComp<SharedItemComponent>(container);
var allowedToEat = targetIsItem;
// BEFORE REPLACING THIS WITH, I.E. A PROPERTY:
// Make absolutely 100% sure you have worked out how to stop people ending up in backpacks.
// Seriously, it is insanely hacky and weird to get someone out of a backpack once they end up in there.
// And to be clear, they should NOT be in there.
// For the record, what you need to do is empty the backpack onto a PlacableSurface (table, rack)
if (targetIsMob)
{
if (!storageIsItem)
allowedToEat = true;
else
{
var storeEv = new StoreMobInItemContainerAttemptEvent();
RaiseLocalEvent(container, storeEv);
allowedToEat = storeEv.Handled && !storeEv.Cancelled;
}
}
return allowedToEat;
}
public void ModifyComponents(EntityUid uid, EntityStorageComponent? component = null)
{
if (!Resolve(uid, ref component))
return;
if (!component.IsCollidableWhenOpen && TryComp<FixturesComponent>(uid, out var fixtures) && fixtures.Fixtures.Count > 0)
{
// currently only works for single-fixture entities. If they have more than one fixture, then
// RemovedMasks needs to be tracked separately for each fixture, using a fixture Id Dictionary. Also the
// fixture IDs probably cant be automatically generated without causing issues, unless there is some
// guarantee that they will get deserialized with the same auto-generated ID when saving+loading the map.
var fixture = fixtures.Fixtures.Values.First();
if (component.Open)
{
component.RemovedMasks = fixture.CollisionLayer & component.MasksToRemove;
fixture.CollisionLayer &= ~component.MasksToRemove;
}
else
{
fixture.CollisionLayer |= component.RemovedMasks;
component.RemovedMasks = 0;
}
}
if (TryComp<PlaceableSurfaceComponent>(uid, out var surface))
_placeableSurface.SetPlaceable(uid, true, surface);
if (TryComp<AppearanceComponent>(uid, out var appearance))
{
appearance.SetData(StorageVisuals.Open, component.Open);
appearance.SetData(StorageVisuals.HasContents, component.Contents.ContainedEntities.Count() > 0);
}
}
}

10
Content.Server/Storage/EntitySystems/StorageSystem.Fill.cs
View File

@@ -8,10 +8,12 @@ public sealed partial class StorageSystem
private void OnStorageFillMapInit(EntityUid uid, StorageFillComponent component, MapInitEvent args)
{
if (component.Contents.Count == 0) return;
// ServerStorageComponent needs to rejoin IStorageComponent when other storage components are ECS'd
TryComp<IStorageComponent>(uid, out var storage);
if (!EntityManager.EntitySysManager.TryGetEntitySystem<EntityStorageSystem>(out var entityStorage)) return;
TryComp<ServerStorageComponent>(uid, out var serverStorageComp);
if (storage == null && serverStorageComp == null)
TryComp<EntityStorageComponent>(uid, out var entityStorageComp);
if (entityStorageComp == null && serverStorageComp == null)
{
Logger.Error($"StorageFillComponent couldn't find any StorageComponent ({uid})");
return;
@@ -25,7 +27,7 @@ public sealed partial class StorageSystem
var ent = EntityManager.SpawnEntity(item, coordinates);
// handle depending on storage component, again this should be unified after ECS
if (storage != null && storage.Insert(ent))
if (entityStorageComp != null && entityStorage.Insert(ent, uid))
continue;
if (serverStorageComp != null && Insert(uid, ent, serverStorageComp))

10
Content.Server/Storage/EntitySystems/StorageSystem.cs
View File

@@ -40,6 +40,7 @@ namespace Content.Server.Storage.EntitySystems
[Dependency] private readonly ContainerSystem _containerSystem = default!;
[Dependency] private readonly DoAfterSystem _doAfterSystem = default!;
[Dependency] private readonly EntityLookupSystem _entityLookupSystem = default!;
[Dependency] private readonly EntityStorageSystem _entityStorage = default!;
[Dependency] private readonly InteractionSystem _interactionSystem = default!;
[Dependency] private readonly PopupSystem _popupSystem = default!;
[Dependency] private readonly SharedHandsSystem _sharedHandsSystem = default!;
@@ -88,12 +89,11 @@ namespace Content.Server.Storage.EntitySystems
if (!EntityManager.HasComponent<HandsComponent>(args.Entity))
return;
if (_gameTiming.CurTime <
component.LastInternalOpenAttempt + EntityStorageComponent.InternalOpenAttemptDelay)
if (_gameTiming.CurTime < component.LastInternalOpenAttempt + EntityStorageComponent.InternalOpenAttemptDelay)
return;
component.LastInternalOpenAttempt = _gameTiming.CurTime;
component.TryOpenStorage(args.Entity);
_entityStorage.TryOpenStorage(args.Entity, component.Owner);
}
@@ -102,7 +102,7 @@ namespace Content.Server.Storage.EntitySystems
if (!args.CanAccess || !args.CanInteract)
return;
if (!component.CanOpen(args.User, silent: true))
if (!_entityStorage.CanOpen(args.User, args.Target, silent: true, component))
return;
InteractionVerb verb = new();
@@ -116,7 +116,7 @@ namespace Content.Server.Storage.EntitySystems
verb.Text = Loc.GetString("verb-common-open");
verb.IconTexture = "/Textures/Interface/VerbIcons/open.svg.192dpi.png";
}
verb.Act = () => component.ToggleOpen(args.User);
verb.Act = () => _entityStorage.ToggleOpen(args.User, args.Target, component);
args.Verbs.Add(verb);
}