tommy/tbd-station-14
2
1
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Refactors stacks to be fully ECS. (#4046)

Browse Source
This commit is contained in:
Vera Aguilera Puerto
2021-05-26 10:20:57 +02:00
committed by GitHub
parent 0f8e330a3d
commit 33fa208214
18 changed files with 494 additions and 249 deletions
Download Patch File Download Diff File Expand all files Collapse all files

36
Content.Client/GameObjects/Components/StackComponent.cs
View File

@@ -1,9 +1,6 @@
#nullable enable
using Content.Client.UserInterface.Stylesheets;
using Content.Client.Utility;
using Content.Shared.GameObjects.Components;
using Robust.Client.GameObjects;
using Robust.Client.UserInterface;
using Robust.Client.UserInterface.Controls;
using Robust.Shared.GameObjects;
@@ -17,39 +14,18 @@ namespace Content.Client.GameObjects.Components
[ComponentReference(typeof(SharedStackComponent))]
public class StackComponent : SharedStackComponent, IItemStatus
{
[ViewVariables(VVAccess.ReadWrite)] private bool _uiUpdateNeeded;
[ComponentDependency] private readonly AppearanceComponent? _appearanceComponent = default!;
[ViewVariables(VVAccess.ReadWrite)]
private bool _uiUpdateNeeded;
public Control MakeControl() => new StatusControl(this);
public override int Count
public Control MakeControl()
{
get => base.Count;
set
{
var valueChanged = value != Count;
base.Count = value;
if (valueChanged)
{
_appearanceComponent?.SetData(StackVisuals.Actual, Count);
return new StatusControl(this);
}
public void DirtyUI()
{
_uiUpdateNeeded = true;
}
}
public override void Initialize()
{
base.Initialize();
if (!Owner.Deleted)
{
_appearanceComponent?.SetData(StackVisuals.MaxCount, MaxCount);
_appearanceComponent?.SetData(StackVisuals.Hide, false);
}
}
private sealed class StatusControl : Control
{

25
Content.Client/GameObjects/EntitySystems/StackSystem.cs Normal file
View File

@@ -0,0 +1,25 @@
using Content.Client.GameObjects.Components;
using Content.Shared.GameObjects.Components;
using Content.Shared.GameObjects.EntitySystems;
using JetBrains.Annotations;
using Robust.Shared.GameObjects;
namespace Content.Client.GameObjects.EntitySystems
{
[UsedImplicitly]
public class StackSystem : SharedStackSystem
{
public override void Initialize()
{
base.Initialize();
SubscribeLocalEvent<StackComponent, StackCountChangedEvent>(OnStackCountChanged);
}
private void OnStackCountChanged(EntityUid uid, StackComponent component, StackCountChangedEvent args)
{
// Dirty the UI now that the stack count has changed.
component.DirtyUI();
}
}
}

33
Content.Server/Construction/StackHelpers.cs
View File

@@ -1,33 +0,0 @@
#nullable enable
using System;
using Content.Server.GameObjects.Components.Stack;
using Content.Shared.GameObjects.Components;
using Content.Shared.Stacks;
using Robust.Shared.GameObjects;
using Robust.Shared.IoC;
using Robust.Shared.Map;
namespace Content.Server.Construction
{
public static class StackHelpers
{
/// <summary>
/// Spawns a stack of a specified type given an amount.
/// </summary>
public static IEntity SpawnStack(StackPrototype stack, int amount, EntityCoordinates coordinates, IEntityManager? entityManager = null)
{
entityManager ??= IoCManager.Resolve<IEntityManager>();
// TODO: Add more.
string prototype = stack.Spawn ?? throw new ArgumentOutOfRangeException(nameof(stack),
"Stack type doesn't have a prototype specified yet!");
var ent = entityManager.SpawnEntity(prototype, coordinates);
var stackComponent = ent.GetComponent<StackComponent>();
stackComponent.Count = Math.Min(amount, stackComponent.MaxCount);
return ent;
}
}
}

13
Content.Server/GameObjects/Components/Construction/ConstructionComponent.cs
View File

@@ -6,6 +6,7 @@ using System.Linq;
using System.Threading.Tasks;
using Content.Server.GameObjects.Components.Interactable;
using Content.Server.GameObjects.Components.Stack;
using Content.Server.GameObjects.EntitySystems;
using Content.Server.GameObjects.EntitySystems.DoAfter;
using Content.Shared.Construction;
using Content.Shared.GameObjects.Components.Interactable;
@@ -264,11 +265,17 @@ namespace Content.Server.GameObjects.Components.Construction
break;
case MaterialConstructionGraphStep materialStep:
if (materialStep.EntityValid(eventArgs.Using, out var sharedStack)
if (materialStep.EntityValid(eventArgs.Using, out var stack)
&& await doAfterSystem.DoAfter(doAfterArgs) == DoAfterStatus.Finished)
{
var stack = (StackComponent) sharedStack;
valid = stack.Split(materialStep.Amount, eventArgs.User.Transform.Coordinates, out entityUsing);
var splitStack = new StackSplitEvent() {Amount = materialStep.Amount, SpawnPosition = eventArgs.User.Transform.Coordinates};
Owner.EntityManager.EventBus.RaiseLocalEvent(stack.Owner.Uid, splitStack);
if (splitStack.Result != null)
{
entityUsing = splitStack.Result;
valid = true;
}
}
break;

10
Content.Server/GameObjects/Components/Construction/MachineComponent.cs
View File

@@ -1,6 +1,7 @@
using System;
using System.Collections.Generic;
using Content.Server.Construction;
using Content.Server.GameObjects.EntitySystems;
using Content.Server.Interfaces.GameObjects;
using Robust.Shared.Containers;
using Robust.Shared.GameObjects;
@@ -87,7 +88,14 @@ namespace Content.Server.GameObjects.Components.Construction
foreach (var (stackType, amount) in machineBoard.MaterialRequirements)
{
var s = StackHelpers.SpawnStack(stackType, amount, Owner.Transform.Coordinates);
var stackSpawn = new StackTypeSpawnEvent()
{Amount = amount, StackType = stackType, SpawnPosition = Owner.Transform.Coordinates};
Owner.EntityManager.EventBus.RaiseEvent(EventSource.Local, stackSpawn);
var s = stackSpawn.Result;
if (s == null)
throw new Exception($"Couldn't spawn stack of type {stackType}!");
if (!partContainer.Insert(s))
throw new Exception($"Couldn't insert machine material of type {stackType} to machine with prototype {Owner.Prototype?.ID ?? "N/A"}");

9
Content.Server/GameObjects/Components/Construction/MachineFrameComponent.cs
View File

@@ -2,6 +2,7 @@
using System.Threading.Tasks;
using Content.Server.Construction;
using Content.Server.GameObjects.Components.Stack;
using Content.Server.GameObjects.EntitySystems;
using Content.Shared.GameObjects.Components.Construction;
using Content.Shared.GameObjects.Components.Tag;
using Content.Shared.Interfaces.GameObjects.Components;
@@ -314,10 +315,14 @@ namespace Content.Server.GameObjects.Components.Construction
return true;
}
if (!stack.Split(needed, Owner.Transform.Coordinates, out var newStack))
var splitStack = new StackSplitEvent()
{Amount = needed, SpawnPosition = Owner.Transform.Coordinates};
Owner.EntityManager.EventBus.RaiseLocalEvent(stack.Owner.Uid, splitStack);
if (splitStack.Result == null)
return false;
if(!_partContainer.Insert(newStack))
if(!_partContainer.Insert(splitStack.Result))
return false;
_materialProgress[type] += needed;

9
Content.Server/GameObjects/Components/Items/FloorTileItemComponent.cs
View File

@@ -1,6 +1,7 @@
using System.Collections.Generic;
using System.Threading.Tasks;
using Content.Server.GameObjects.Components.Stack;
using Content.Server.GameObjects.EntitySystems;
using Content.Shared.Audio;
using Content.Shared.Interfaces.GameObjects.Components;
using Content.Shared.Maps;
@@ -78,8 +79,14 @@ namespace Content.Server.GameObjects.Components.Items
var tile = mapGrid.GetTileRef(location);
var baseTurf = (ContentTileDefinition) _tileDefinitionManager[tile.Tile.TypeId];
if (HasBaseTurf(currentTileDefinition, baseTurf.Name) && stack.Use(1))
if (HasBaseTurf(currentTileDefinition, baseTurf.Name))
{
var stackUse = new StackUseEvent() {Amount = 1};
Owner.EntityManager.EventBus.RaiseLocalEvent(Owner.Uid, stackUse);
if (!stackUse.Result)
continue;
PlaceAt(mapGrid, location, currentTileDefinition.TileId);
break;
}

8
Content.Server/GameObjects/Components/Medical/HealingComponent.cs
View File

@@ -1,6 +1,7 @@
using System.Collections.Generic;
using System.Threading.Tasks;
using Content.Server.GameObjects.Components.Stack;
using Content.Server.GameObjects.EntitySystems;
using Content.Shared.Damage;
using Content.Shared.GameObjects.Components.Damage;
using Content.Shared.GameObjects.EntitySystems.ActionBlocker;
@@ -41,9 +42,12 @@ namespace Content.Server.GameObjects.Components.Medical
return true;
}
if (Owner.TryGetComponent(out StackComponent? stack) &&
!stack.Use(1))
if (Owner.HasComponent<StackComponent>())
{
var stackUse = new StackUseEvent() {Amount = 1};
Owner.EntityManager.EventBus.RaiseLocalEvent(Owner.Uid, stackUse);
if(!stackUse.Result)
return true;
}

11
Content.Server/GameObjects/Components/Power/WirePlacerComponent.cs
View File

@@ -8,6 +8,7 @@ using Robust.Shared.IoC;
using Robust.Shared.Serialization;
using Robust.Shared.ViewVariables;
using System.Threading.Tasks;
using Content.Server.GameObjects.EntitySystems;
using Robust.Shared.Prototypes;
using Robust.Shared.Serialization.Manager.Attributes;
using Robust.Shared.Map;
@@ -49,8 +50,16 @@ namespace Content.Server.GameObjects.Components.Power
return true;
}
}
if (Owner.TryGetComponent<StackComponent>(out var stack) && !stack.Use(1))
if (Owner.HasComponent<StackComponent>())
{
var stackUse = new StackUseEvent(){Amount = 1};
Owner.EntityManager.EventBus.RaiseLocalEvent(Owner.Uid, stackUse);
if(!stackUse.Result)
return true;
}
Owner.EntityManager.SpawnEntity(_wirePrototypeID, grid.GridTileToLocal(snapPos));
return true;
}

115
Content.Server/GameObjects/Components/Stack/StackComponent.cs
View File

@@ -1,14 +1,7 @@
#nullable enable
using System;
using System.Diagnostics.CodeAnalysis;
using System.Threading.Tasks;
using Content.Shared.GameObjects.Components;
using Content.Shared.GameObjects.EntitySystems;
using Content.Shared.Interfaces;
using Content.Shared.Interfaces.GameObjects.Components;
using Robust.Shared.GameObjects;
using Robust.Shared.Localization;
using Robust.Shared.Map;
using Robust.Shared.Utility;
using Robust.Shared.ViewVariables;
@@ -17,114 +10,10 @@ namespace Content.Server.GameObjects.Components.Stack
// TODO: Naming and presentation and such could use some improvement.
[RegisterComponent]
[ComponentReference(typeof(SharedStackComponent))]
public class StackComponent : SharedStackComponent, IInteractUsing, IExamine
public class StackComponent : SharedStackComponent, IExamine
{
private bool _throwIndividually = false;
[ViewVariables(VVAccess.ReadWrite)]
public bool ThrowIndividually
{
get => _throwIndividually;
private set
{
_throwIndividually = value;
Dirty();
}
}
public void Add(int amount)
{
Count += amount;
}
/// <summary>
/// Try to use an amount of items on this stack.
/// </summary>
/// <param name="amount"></param>
/// <returns>True if there were enough items to remove, false if not in which case nothing was changed.</returns>
public bool Use(int amount)
{
if (Count >= amount)
{
Count -= amount;
return true;
}
return false;
}
/// <summary>
/// Attempts to split this stack in two.
/// </summary>
/// <param name="amount">amount the new stack will have</param>
/// <param name="spawnPosition">the position the new stack will spawn at</param>
/// <param name="stack">the new stack</param>
/// <returns></returns>
public bool Split(int amount, EntityCoordinates spawnPosition, [NotNullWhen(true)] out IEntity? stack)
{
if (Count >= amount)
{
Count -= amount;
stack = Owner.EntityManager.SpawnEntity(Owner.Prototype?.ID, spawnPosition);
if (stack.TryGetComponent(out StackComponent? stackComp))
{
stackComp.Count = amount;
}
return true;
}
stack = null;
return false;
}
async Task<bool> IInteractUsing.InteractUsing(InteractUsingEventArgs eventArgs)
{
if (!eventArgs.Using.TryGetComponent<StackComponent>(out var stack))
return false;
if (!stack.StackTypeId.Equals(StackTypeId))
{
return false;
}
var toTransfer = Math.Min(Count, stack.AvailableSpace);
Count -= toTransfer;
stack.Add(toTransfer);
var popupPos = eventArgs.ClickLocation;
if (popupPos == EntityCoordinates.Invalid)
{
popupPos = eventArgs.User.Transform.Coordinates;
}
if (toTransfer > 0)
{
popupPos.PopupMessage(eventArgs.User, $"+{toTransfer}");
if (stack.AvailableSpace == 0)
{
eventArgs.Using.SpawnTimer(
300,
() => popupPos.PopupMessage(
eventArgs.User,
Loc.GetString("comp-stack-becomes-full")
)
);
}
}
else if (toTransfer == 0 && stack.AvailableSpace == 0)
{
popupPos.PopupMessage(
eventArgs.User,
Loc.GetString("comp-stack-already-full")
);
}
return true;
}
public bool ThrowIndividually { get; set; } = false;
void IExamine.Examine(FormattedMessage message, bool inDetailsRange)
{

14
Content.Server/GameObjects/EntitySystems/ConstructionSystem.cs
View File

@@ -163,20 +163,22 @@ namespace Content.Server.GameObjects.EntitySystems
case MaterialConstructionGraphStep materialStep:
foreach (var entity in EnumerateNearby(user))
{
if (!materialStep.EntityValid(entity, out var sharedStack))
if (!materialStep.EntityValid(entity, out var stack))
continue;
var stack = (StackComponent) sharedStack;
var splitStack = new StackSplitEvent()
{Amount = materialStep.Amount, SpawnPosition = user.ToCoordinates()};
RaiseLocalEvent(entity.Uid, splitStack);
if (!stack.Split(materialStep.Amount, user.ToCoordinates(), out var newStack))
if (splitStack.Result == null)
continue;
if (string.IsNullOrEmpty(materialStep.Store))
{
if (!container.Insert(newStack))
if (!container.Insert(splitStack.Result))
continue;
}
else if (!GetContainer(materialStep.Store).Insert(newStack))
else if (!GetContainer(materialStep.Store).Insert(splitStack.Result))
continue;
handled = true;
@@ -230,7 +232,7 @@ namespace Content.Server.GameObjects.EntitySystems
BreakOnStun = true,
BreakOnTargetMove = false,
BreakOnUserMove = true,
NeedHand = true,
NeedHand = false,
};
if (await doAfterSystem.DoAfter(doAfterArgs) == DoAfterStatus.Cancelled)

11
Content.Server/GameObjects/EntitySystems/HandsSystem.cs
View File

@@ -180,12 +180,13 @@ namespace Content.Server.GameObjects.EntitySystems
}
else
{
stackComp.Use(1);
throwEnt = throwEnt.EntityManager.SpawnEntity(throwEnt.Prototype?.ID, playerEnt.Transform.Coordinates);
var splitStack = new StackSplitEvent() {Amount = 1, SpawnPosition = playerEnt.Transform.Coordinates};
RaiseLocalEvent(throwEnt.Uid, splitStack);
// can only throw one item at a time, regardless of what the prototype stack size is.
if (throwEnt.TryGetComponent<StackComponent>(out var newStackComp))
newStackComp.Count = 1;
if (splitStack.Result == null)
return false;
throwEnt = splitStack.Result;
}
var direction = coords.ToMapPos(EntityManager) - playerEnt.Transform.WorldPosition;

13
Content.Server/GameObjects/EntitySystems/SpawnAfterInteractSystem.cs
View File

@@ -65,13 +65,20 @@ namespace Content.Server.GameObjects.EntitySystems
if (component.Deleted || component.Owner.Deleted)
return;
StackComponent? stack = null;
if (component.RemoveOnInteract && component.Owner.TryGetComponent(out stack) && !stack.Use(1))
var hasStack = component.Owner.HasComponent<StackComponent>();
if (hasStack && component.RemoveOnInteract)
{
var stackUse = new StackUseEvent() {Amount = 1};
RaiseLocalEvent(component.Owner.Uid, stackUse);
if (!stackUse.Result)
return;
}
EntityManager.SpawnEntity(component.Prototype, args.ClickLocation.SnapToGrid(grid));
if (component.RemoveOnInteract && stack == null && !component.Owner.Deleted)
if (component.RemoveOnInteract && !hasStack && !component.Owner.Deleted)
component.Owner.Delete();
}
}

256
Content.Server/GameObjects/EntitySystems/StackSystem.cs Normal file
View File

@@ -0,0 +1,256 @@
using System;
using Content.Server.GameObjects.Components.Stack;
using Content.Shared.GameObjects.EntitySystems;
using Content.Shared.Interfaces;
using Content.Shared.Interfaces.GameObjects.Components;
using Content.Shared.Stacks;
using JetBrains.Annotations;
using Robust.Shared.GameObjects;
using Robust.Shared.IoC;
using Robust.Shared.Localization;
using Robust.Shared.Map;
using Robust.Shared.Prototypes;
namespace Content.Server.GameObjects.EntitySystems
{
/// <summary>
/// Entity system that handles everything relating to stacks.
/// This is a good example for learning how to code in an ECS manner.
/// </summary>
[UsedImplicitly]
public class StackSystem : SharedStackSystem
{
[Dependency] private readonly IPrototypeManager _prototypeManager = default!;
public override void Initialize()
{
base.Initialize();
SubscribeLocalEvent<StackComponent, InteractUsingEvent>(OnStackInteractUsing);
// The following subscriptions are basically the "method calls" of this entity system.
SubscribeLocalEvent<StackComponent, StackUseEvent>(OnStackUse);
SubscribeLocalEvent<StackComponent, StackSplitEvent>(OnStackSplit);
SubscribeLocalEvent<StackTypeSpawnEvent>(OnStackTypeSpawn);
}
/// <summary>
/// Try to use an amount of items on this stack.
/// See <see cref="StackUseEvent"/>
/// </summary>
private void OnStackUse(EntityUid uid, StackComponent stack, StackUseEvent args)
{
// Check if we have enough things in the stack for this...
if (stack.Count < args.Amount)
{
// Not enough things in the stack, so we set the output result to false.
args.Result = false;
}
else
{
// We do have enough things in the stack, so remove them and set the output result to true.
RaiseLocalEvent(uid, new StackChangeCountEvent(stack.Count - args.Amount));
args.Result = true;
}
}
/// <summary>
/// Try to split this stack into two.
/// See <see cref="StackSplitEvent"/>
/// </summary>
private void OnStackSplit(EntityUid uid, StackComponent stack, StackSplitEvent args)
{
// If the stack doesn't have enough things as specified in the parameters, we do nothing.
if (stack.Count < args.Amount)
return;
// Get a prototype ID to spawn the new entity. Null is also valid, although it should rarely be picked...
var prototype = _prototypeManager.TryIndex<StackPrototype>(stack.StackTypeId, out var stackType)
? stackType.Spawn
: stack.Owner.Prototype?.ID ?? null;
// Remove the amount of things we want to split from the original stack...
RaiseLocalEvent(uid, new StackChangeCountEvent(stack.Count - args.Amount));
// Set the output parameter in the event instance to the newly split stack.
args.Result = EntityManager.SpawnEntity(prototype, args.SpawnPosition);
if (args.Result.TryGetComponent(out StackComponent? stackComp))
{
// Set the split stack's count.
RaiseLocalEvent(args.Result.Uid, new StackChangeCountEvent(args.Amount));
}
}
/// <summary>
/// Tries to spawn a stack of a certain type.
/// See <see cref="StackTypeSpawnEvent"/>
/// </summary>
private void OnStackTypeSpawn(StackTypeSpawnEvent args)
{
// Can't spawn a stack for an invalid type.
if (args.StackType == null)
return;
// Set the output result parameter to the new stack entity...
args.Result = EntityManager.SpawnEntity(args.StackType.Spawn, args.SpawnPosition);
var stack = args.Result.GetComponent<StackComponent>();
// And finally, set the correct amount!
RaiseLocalEvent(args.Result.Uid, new StackChangeCountEvent(args.Amount));
}
private void OnStackInteractUsing(EntityUid uid, StackComponent stack, InteractUsingEvent args)
{
if (!args.Used.TryGetComponent<StackComponent>(out var otherStack))
return;
if (!otherStack.StackTypeId.Equals(stack.StackTypeId))
return;
var toTransfer = Math.Min(stack.Count, otherStack.AvailableSpace);
RaiseLocalEvent(uid, new StackChangeCountEvent(stack.Count - toTransfer));
RaiseLocalEvent(args.Used.Uid, new StackChangeCountEvent(otherStack.Count + toTransfer));
var popupPos = args.ClickLocation;
if (!popupPos.IsValid(EntityManager))
{
popupPos = args.User.Transform.Coordinates;
}
switch (toTransfer)
{
case > 0:
popupPos.PopupMessage(args.User, $"+{toTransfer}");
if (otherStack.AvailableSpace == 0)
{
args.Used.SpawnTimer(
300,
() => popupPos.PopupMessage(
args.User,
Loc.GetString("comp-stack-becomes-full")
)
);
}
break;
case 0 when otherStack.AvailableSpace == 0:
popupPos.PopupMessage(
args.User,
Loc.GetString("comp-stack-already-full")
);
break;
}
args.Handled = true;
}
}
/*
* The following events are actually funny ECS method calls!
*
* Instead of coupling systems together into a ball of spaghetti,
* we raise events that act as method calls.
*
* So for example, instead of having an Use() method in the
* stack component or stack system, we have a StackUseEvent.
* Before raising the event, you would set the Amount property,
* which acts as a parameter or argument, and afterwards the
* entity system in charge of handling this would perform the logic
* and then set the Result on the event instance.
* Then you can access this property to see whether your Use attempt succeeded.
*
* This is very powerful, as it completely removes the coupling
* between entity systems and allows for greater flexibility.
* If you want to intercept this event with another entity system, you can.
* And you don't have to write any bad, hacky code for this!
* You could even use handled events, or cancellable events...
* The possibilities are endless.
*
* Of course, not everything needs to be directed events!
* Broadcast events also work in the same way.
* For example, we use a broadcast event to spawn a stack of a certain type.
*
* Wrapping your head around this may be difficult at first,
* but soon you'll get it, coder. Soon you'll grasp the wisdom.
* Go forth and write some beautiful and robust code!
*/
/// <summary>
/// Uses an amount of things from a stack.
/// Whether this succeeded is stored in <see cref="Result"/>.
/// </summary>
public class StackUseEvent : EntityEventArgs
{
/// <summary>
/// The amount of things to use on the stack.
/// Consider this the equivalent of a parameter for a method call.
/// </summary>
public int Amount { get; init; }
/// <summary>
/// Whether the action succeeded or not.
/// Set by the <see cref="StackSystem"/> after handling this event.
/// Consider this the equivalent of a return value for a method call.
/// </summary>
public bool Result { get; set; } = false;
}
/// <summary>
/// Tries to split a stack into two.
/// If this succeeds, <see cref="Result"/> will be the new stack.
/// </summary>
public class StackSplitEvent : EntityEventArgs
{
/// <summary>
/// The amount of things to take from the original stack.
/// Input parameter.
/// </summary>
public int Amount { get; init; }
/// <summary>
/// The position where to spawn the new stack.
/// Input parameter.
/// </summary>
public EntityCoordinates SpawnPosition { get; init; }
/// <summary>
/// The newly split stack. May be null if the split failed.
/// Output parameter.
/// </summary>
public IEntity? Result { get; set; } = null;
}
/// <summary>
/// Tries to spawn a stack of a certain type.
/// If this succeeds, <see cref="Result"/> will be the new stack.
/// </summary>
public class StackTypeSpawnEvent : EntityEventArgs
{
/// <summary>
/// The amount of things the spawned stack will have.
/// Input parameter.
/// </summary>
public int Amount { get; init; }
/// <summary>
/// The stack type to be spawned.
/// Input parameter.
/// </summary>
public StackPrototype? StackType { get; init; }
/// <summary>
/// The position where the new stack will be spawned.
/// Input parameter.
/// </summary>
public EntityCoordinates SpawnPosition { get; init; }
/// <summary>
/// The newly spawned stack, or null if this failed.
/// Output parameter.
/// </summary>
public IEntity? Result { get; set; } = null;
}
}

1
Content.Shared/Content.Shared.csproj
View File

@@ -30,7 +30,6 @@
<ItemGroup>
<Folder Include="GameObjects\Components\Trigger\" />
<EmbeddedResource Include="Text\Names\*.txt" />
<Folder Include="GameObjects\Components\Visualizers" />
</ItemGroup>
<Import Project="..\RobustToolbox\MSBuild\Robust.Analyzers.targets" />

59
Content.Shared/GameObjects/Components/SharedStackComponent.cs
View File

@@ -1,46 +1,34 @@
using System;
using Content.Shared.GameObjects.EntitySystems;
using Content.Shared.Stacks;
using Robust.Shared.GameObjects;
using Robust.Shared.IoC;
using Robust.Shared.Log;
using Robust.Shared.Players;
using Robust.Shared.Prototypes;
using Robust.Shared.Serialization;
using Robust.Shared.Serialization.Manager.Attributes;
using Robust.Shared.Serialization.TypeSerializers.Implementations.Custom.Prototype;
using Robust.Shared.ViewVariables;
namespace Content.Shared.GameObjects.Components
{
public abstract class SharedStackComponent : Component, ISerializationHooks
{
[Dependency] private readonly IPrototypeManager _prototypeManager = default!;
private const string SerializationCache = "stack";
public sealed override string Name => "Stack";
public sealed override uint? NetID => ContentNetIDs.STACK;
[DataField("count")]
private int _count = 30;
[DataField("max")]
private int _maxCount = 30;
[ViewVariables(VVAccess.ReadWrite)]
public virtual int Count
{
get => _count;
set
{
_count = value;
if (_count <= 0)
{
Owner.Delete();
}
[DataField("stackType", required:true, customTypeSerializer:typeof(PrototypeIdSerializer<StackPrototype>))]
public string StackTypeId { get; private set; } = string.Empty;
Dirty();
}
}
/// <summary>
/// Current stack count.
/// Do NOT set this directly, raise the <see cref="StackChangeCountEvent"/> event instead.
/// </summary>
[ViewVariables(VVAccess.ReadWrite)]
[DataField("count")]
public int Count { get; set; } = 30;
[ViewVariables]
public int MaxCount
@@ -48,28 +36,16 @@ namespace Content.Shared.GameObjects.Components
get => _maxCount;
private set
{
if (_maxCount == value)
return;
_maxCount = value;
Dirty();
}
}
[ViewVariables] public int AvailableSpace => MaxCount - Count;
[ViewVariables]
[DataField("stackType")]
public string StackTypeId { get; } = string.Empty;
public StackPrototype StackType => _prototypeManager.Index<StackPrototype>(StackTypeId);
protected override void Startup()
{
base.Startup();
if (StackTypeId != string.Empty && !_prototypeManager.HasIndex<StackPrototype>(StackTypeId))
{
Logger.Error($"No {nameof(StackPrototype)} found with id {StackTypeId} for {Owner.Prototype?.ID ?? Owner.Name}");
}
}
public int AvailableSpace => MaxCount - Count;
public override ComponentState GetComponentState(ICommonSession player)
{
@@ -79,11 +55,10 @@ namespace Content.Shared.GameObjects.Components
public override void HandleComponentState(ComponentState? curState, ComponentState? nextState)
{
if (curState is not StackComponentState cast)
{
return;
}
Count = cast.Count;
// This will change the count and call events.
Owner.EntityManager.EventBus.RaiseLocalEvent(Owner.Uid, new StackChangeCountEvent(cast.Count));
MaxCount = cast.MaxCount;
}

108
Content.Shared/GameObjects/EntitySystems/SharedStackSystem.cs Normal file
View File

@@ -0,0 +1,108 @@
using Content.Shared.GameObjects.Components;
using JetBrains.Annotations;
using Robust.Shared.GameObjects;
namespace Content.Shared.GameObjects.EntitySystems
{
[UsedImplicitly]
public abstract class SharedStackSystem : EntitySystem
{
public override void Initialize()
{
base.Initialize();
SubscribeLocalEvent<SharedStackComponent, ComponentStartup>(OnStackStarted);
SubscribeLocalEvent<SharedStackComponent, StackChangeCountEvent>(OnStackCountChange);
}
private void OnStackStarted(EntityUid uid, SharedStackComponent component, ComponentStartup args)
{
if (!ComponentManager.TryGetComponent(uid, out SharedAppearanceComponent? appearance))
return;
appearance.SetData(StackVisuals.MaxCount, component.MaxCount);
appearance.SetData(StackVisuals.Hide, false);
}
protected void OnStackCountChange(EntityUid uid, SharedStackComponent component, StackChangeCountEvent args)
{
if (args.Amount == component.Count)
return;
var old = component.Count;
if (args.Amount > component.MaxCount)
{
args.Amount = component.MaxCount;
args.Clamped = true;
}
if (args.Amount < 0)
{
args.Amount = 0;
args.Clamped = true;
}
component.Count = args.Amount;
component.Dirty();
// Queue delete stack if count reaches zero.
if(component.Count <= 0)
EntityManager.QueueDeleteEntity(uid);
// Change appearance data.
if (ComponentManager.TryGetComponent(uid, out SharedAppearanceComponent? appearance))
appearance.SetData(StackVisuals.Actual, component.Count);
RaiseLocalEvent(uid, new StackCountChangedEvent(old, component.Count));
}
}
/// <summary>
/// Attempts to change the amount of things in a stack to a specific number.
/// If the amount had to be clamped to zero or the max amount, <see cref="Clamped"/> will be true
/// and the amount will be changed to match the value set.
/// Does nothing if the amount is the same as the stack count already.
/// </summary>
public class StackChangeCountEvent : EntityEventArgs
{
/// <summary>
/// Amount to set the stack to.
/// Input/Output parameter.
/// </summary>
public int Amount { get; set; }
/// <summary>
/// Whether the <see cref="Amount"/> had to be clamped.
/// Output parameter.
/// </summary>
public bool Clamped { get; set; }
public StackChangeCountEvent(int amount)
{
Amount = amount;
}
}
/// <summary>
/// Event raised when a stack's count has changed.
/// </summary>
public class StackCountChangedEvent : EntityEventArgs
{
/// <summary>
/// The old stack count.
/// </summary>
public int OldCount { get; }
/// <summary>
/// The new stack count.
/// </summary>
public int NewCount { get; }
public StackCountChangedEvent(int oldCount, int newCount)
{
OldCount = oldCount;
NewCount = newCount;
}
}
}

6
Content.Shared/Stacks/StackPrototype.cs
View File

@@ -17,12 +17,12 @@ namespace Content.Shared.Stacks
public string Name { get; } = string.Empty;
[DataField("icon")]
public SpriteSpecifier? Icon { get; }
public SpriteSpecifier? Icon { get; } = null;
/// <summary>
/// The entity id that will be spawned by default from this stack.
/// </summary>
[DataField("spawn")]
public string? Spawn { get; }
[DataField("spawn", required: true)]
public string Spawn { get; } = string.Empty;
}
}