using Content.Server.Administration.UI;
using Content.Server.Chemistry.Components.SolutionManager;
using Content.Server.Chemistry.EntitySystems;
-using Content.Server.Configurable;
+using Content.Server.Disposal.Tube;
using Content.Server.Disposal.Tube.Components;
using Content.Server.EUI;
using Content.Server.Ghost.Roles;
[Dependency] private readonly IGameTiming _gameTiming = default!;
[Dependency] private readonly IMapManager _mapManager = default!;
[Dependency] private readonly IPrototypeManager _prototypeManager = default!;
+ [Dependency] private readonly DisposalTubeSystem _disposalTubes = default!;
[Dependency] private readonly EuiManager _euiManager = default!;
[Dependency] private readonly GhostRoleSystem _ghostRoleSystem = default!;
[Dependency] private readonly ArtifactSystem _artifactSystem = default!;
// Get Disposal tube direction verb
if (_groupController.CanCommand(player, "tubeconnections") &&
- EntityManager.TryGetComponent<IDisposalTubeComponent?>(args.Target, out var tube))
+ EntityManager.TryGetComponent<DisposalTubeComponent?>(args.Target, out var tube))
{
Verb verb = new()
{
Text = Loc.GetString("tube-direction-verb-get-data-text"),
Category = VerbCategory.Debug,
Icon = new SpriteSpecifier.Texture(new ResourcePath("/Textures/Interface/VerbIcons/information.svg.192dpi.png")),
- Act = () => tube.PopupDirections(args.User)
+ Act = () => _disposalTubes.PopupDirections(args.Target, tube, args.User)
};
args.Verbs.Add(verb);
}
-using Content.Server.Disposal.Unit.Components;
+namespace Content.Server.Disposal.Tube.Components;
-namespace Content.Server.Disposal.Tube.Components
+[RegisterComponent]
+[Access(typeof(DisposalTubeSystem))]
+public sealed class DisposalBendComponent : Component
{
- [RegisterComponent]
- [ComponentReference(typeof(IDisposalTubeComponent))]
- [ComponentReference(typeof(DisposalTubeComponent))]
- public sealed class DisposalBendComponent : DisposalTubeComponent
- {
- public override string ContainerId => "DisposalBend";
-
- [DataField("sideDegrees")]
- private int _sideDegrees = -90;
-
- protected override Direction[] ConnectableDirections()
- {
- var direction = IoCManager.Resolve<IEntityManager>().GetComponent<TransformComponent>(Owner).LocalRotation;
- var side = new Angle(MathHelper.DegreesToRadians(direction.Degrees + _sideDegrees));
-
- return new[] {direction.GetDir(), side.GetDir()};
- }
-
- public override Direction NextDirection(DisposalHolderComponent holder)
- {
- var directions = ConnectableDirections();
- var previousDF = holder.PreviousDirectionFrom;
-
- if (previousDF == Direction.Invalid)
- {
- return directions[0];
- }
-
- return previousDF == directions[0] ? directions[1] : directions[0];
- }
- }
}
namespace Content.Server.Disposal.Tube.Components
{
[RegisterComponent]
- [ComponentReference(typeof(IDisposalTubeComponent))]
- [ComponentReference(typeof(DisposalTubeComponent))]
- public sealed class DisposalEntryComponent : DisposalTubeComponent
+ [Access(typeof(DisposalTubeSystem), typeof(DisposalUnitSystem))]
+ public sealed class DisposalEntryComponent : Component
{
[Dependency] private readonly IEntityManager _entMan = default!;
private const string HolderPrototypeId = "DisposalHolder";
- public override string ContainerId => "DisposalEntry";
public bool TryInsert(DisposalUnitComponent from, IEnumerable<string>? tags = default)
{
if (tags != default)
holderComponent.Tags.UnionWith(tags);
- return EntitySystem.Get<DisposableSystem>().EnterTube((holderComponent).Owner, Owner, holderComponent, null, this);
- }
-
- protected override Direction[] ConnectableDirections()
- {
- return new[] {_entMan.GetComponent<TransformComponent>(Owner).LocalRotation.GetDir()};
- }
-
- /// <summary>
- /// Ejects contents when they come from the same direction the entry is facing.
- /// </summary>
- public override Direction NextDirection(DisposalHolderComponent holder)
- {
- if (holder.PreviousDirectionFrom != Direction.Invalid)
- {
- return Direction.Invalid;
- }
-
- return ConnectableDirections()[0];
+ return EntitySystem.Get<DisposableSystem>().EnterTube((holderComponent).Owner, Owner, holderComponent);
}
}
}
-using System.Linq;
-using Content.Server.Disposal.Unit.Components;
-using Robust.Shared.Random;
+namespace Content.Server.Disposal.Tube.Components;
-namespace Content.Server.Disposal.Tube.Components
+[RegisterComponent]
+[Access(typeof(DisposalTubeSystem))]
+[Virtual]
+public class DisposalJunctionComponent : Component
{
- [Virtual]
- [RegisterComponent]
- [ComponentReference(typeof(IDisposalTubeComponent))]
- [ComponentReference(typeof(DisposalTubeComponent))]
- public class DisposalJunctionComponent : DisposalTubeComponent
- {
- public override string ContainerId => "DisposalJunction";
-
- [Dependency] private readonly IEntityManager _entMan = default!;
- [Dependency] private readonly IRobustRandom _random = default!;
-
- /// <summary>
- /// The angles to connect to.
- /// </summary>
- [DataField("degrees")]
- private List<Angle> _degrees = new();
-
- protected override Direction[] ConnectableDirections()
- {
- var direction = _entMan.GetComponent<TransformComponent>(Owner).LocalRotation;
-
- return _degrees.Select(degree => new Angle(degree.Theta + direction.Theta).GetDir()).ToArray();
- }
-
- public override Direction NextDirection(DisposalHolderComponent holder)
- {
- var next = _entMan.GetComponent<TransformComponent>(Owner).LocalRotation.GetDir();
- var directions = ConnectableDirections().Skip(1).ToArray();
-
- if (holder.PreviousDirectionFrom == Direction.Invalid ||
- holder.PreviousDirectionFrom == next)
- {
- return _random.Pick(directions);
- }
-
- return next;
- }
- }
+ /// <summary>
+ /// The angles to connect to.
+ /// </summary>
+ [DataField("degrees")] public List<Angle> Degrees = new();
}
-using Content.Server.Disposal.Unit.Components;
using Content.Server.UserInterface;
using Robust.Server.GameObjects;
using Robust.Shared.Audio;
namespace Content.Server.Disposal.Tube.Components
{
[RegisterComponent]
- [ComponentReference(typeof(IDisposalTubeComponent))]
- [ComponentReference(typeof(DisposalTubeComponent))]
+ [Access(typeof(DisposalTubeSystem))]
public sealed class DisposalRouterComponent : DisposalJunctionComponent
{
- public override string ContainerId => "DisposalRouter";
-
[Dependency] private readonly IEntityManager _entMan = default!;
[DataField("tags")]
[DataField("clickSound")] private SoundSpecifier _clickSound = new SoundPathSpecifier("/Audio/Machines/machine_switch.ogg");
- public override Direction NextDirection(DisposalHolderComponent holder)
- {
- var directions = ConnectableDirections();
-
- if (holder.Tags.Overlaps(Tags))
- {
- return directions[1];
- }
-
- return _entMan.GetComponent<TransformComponent>(Owner).LocalRotation.GetDir();
- }
-
protected override void Initialize()
{
base.Initialize();
namespace Content.Server.Disposal.Tube.Components
{
[RegisterComponent]
- [ComponentReference(typeof(IDisposalTubeComponent))]
- [ComponentReference(typeof(DisposalTubeComponent))]
public sealed class DisposalTaggerComponent : DisposalTransitComponent
{
[Dependency] private readonly IEntityManager _entMan = default!;
- public override string ContainerId => "DisposalTagger";
-
[ViewVariables(VVAccess.ReadWrite)]
[DataField("tag")]
public string Tag = "";
[DataField("clickSound")] private SoundSpecifier _clickSound = new SoundPathSpecifier("/Audio/Machines/machine_switch.ogg");
- public override Direction NextDirection(DisposalHolderComponent holder)
- {
- holder.Tags.Add(Tag);
- return base.NextDirection(holder);
- }
-
protected override void Initialize()
{
base.Initialize();
-using Content.Server.Disposal.Unit.Components;
-
namespace Content.Server.Disposal.Tube.Components
{
// TODO: Different types of tubes eject in random direction with no exit point
[RegisterComponent]
- [ComponentReference(typeof(IDisposalTubeComponent))]
+ [Access(typeof(DisposalTubeSystem))]
[Virtual]
- [ComponentReference(typeof(DisposalTubeComponent))]
- public class DisposalTransitComponent : DisposalTubeComponent
+ public class DisposalTransitComponent : Component
{
- public override string ContainerId => "DisposalTransit";
-
- protected override Direction[] ConnectableDirections()
- {
- var rotation = IoCManager.Resolve<IEntityManager>().GetComponent<TransformComponent>(Owner).LocalRotation;
- var opposite = new Angle(rotation.Theta + Math.PI);
-
- return new[] {rotation.GetDir(), opposite.GetDir()};
- }
-
- public override Direction NextDirection(DisposalHolderComponent holder)
- {
- var directions = ConnectableDirections();
- var previousDF = holder.PreviousDirectionFrom;
- var forward = directions[0];
-
- if (previousDF == Direction.Invalid)
- {
- return forward;
- }
-
- var backward = directions[1];
- return previousDF == forward ? backward : forward;
- }
}
}
using Content.Server.Disposal.Unit.Components;
using Content.Server.Disposal.Unit.EntitySystems;
using Content.Shared.Construction.Components;
-using Content.Shared.Disposal.Components;
using Content.Shared.Popups;
using Robust.Shared.Audio;
using Robust.Shared.Containers;
-using Robust.Shared.Physics;
namespace Content.Server.Disposal.Tube.Components
{
- public abstract class DisposalTubeComponent : Component, IDisposalTubeComponent
+ [RegisterComponent]
+ [Access(typeof(DisposalTubeSystem), typeof(DisposableSystem))]
+ public sealed class DisposalTubeComponent : Component
{
- public virtual string ContainerId => "DisposalTube";
+ [DataField("containerId")] public string ContainerId { get; set; } = "DisposalTube";
[Dependency] private readonly IEntityManager _entMan = default!;
public static readonly TimeSpan ClangDelay = TimeSpan.FromSeconds(0.5);
public TimeSpan LastClang;
- private bool _connected;
+ public bool Connected;
[DataField("clangSound")] public SoundSpecifier ClangSound = new SoundPathSpecifier("/Audio/Effects/clang.ogg");
/// <summary>
[ViewVariables]
public Container Contents { get; private set; } = default!;
- /// <summary>
- /// The directions that this tube can connect to others from
- /// </summary>
- /// <returns>a new array of the directions</returns>
- protected abstract Direction[] ConnectableDirections();
-
- public abstract Direction NextDirection(DisposalHolderComponent holder);
-
// TODO: Make disposal pipes extend the grid
// ???
public void Connect()
{
- if (_connected)
+ if (Connected)
{
return;
}
- _connected = true;
- }
-
- public bool CanConnect(Direction direction, IDisposalTubeComponent with)
- {
- if (!_connected)
- {
- return false;
- }
-
- if (!ConnectableDirections().Contains(direction))
- {
- return false;
- }
-
- return true;
+ Connected = true;
}
public void Disconnect()
{
- if (!_connected)
+ if (!Connected)
{
return;
}
- _connected = false;
+ Connected = false;
foreach (var entity in Contents.ContainedEntities.ToArray())
{
}
}
- public void PopupDirections(EntityUid entity)
- {
- var directions = string.Join(", ", ConnectableDirections());
-
- Owner.PopupMessage(entity, Loc.GetString("disposal-tube-component-popup-directions-text", ("directions", directions)));
- }
-
protected override void Initialize()
{
base.Initialize();
+++ /dev/null
-using Content.Server.Disposal.Unit.Components;
-using Robust.Shared.Containers;
-
-namespace Content.Server.Disposal.Tube.Components
-{
- public interface IDisposalTubeComponent : IComponent
- {
- Container Contents { get; }
-
- Direction NextDirection(DisposalHolderComponent holder);
- bool CanConnect(Direction direction, IDisposalTubeComponent with);
- void PopupDirections(EntityUid entity);
- }
-}
+using System.Linq;
+using System.Text;
using Content.Server.Construction.Completions;
using Content.Server.Disposal.Tube.Components;
using Content.Server.Hands.Components;
+using Content.Server.Popups;
using Content.Server.UserInterface;
using Content.Shared.Destructible;
using Content.Shared.Disposal.Components;
using Robust.Shared.Audio;
using Robust.Shared.Map;
using Robust.Shared.Player;
+using Robust.Shared.Random;
using Robust.Shared.Timing;
-using System.Text;
namespace Content.Server.Disposal.Tube
{
{
[Dependency] private readonly IGameTiming _gameTiming = default!;
[Dependency] private readonly IMapManager _mapManager = default!;
+ [Dependency] private readonly IRobustRandom _random = default!;
[Dependency] private readonly SharedAppearanceSystem _appearanceSystem = default!;
+ [Dependency] private readonly PopupSystem _popups = default!;
public override void Initialize()
{
SubscribeLocalEvent<DisposalTubeComponent, AnchorStateChangedEvent>(OnAnchorChange);
SubscribeLocalEvent<DisposalTubeComponent, ContainerRelayMovementEntityEvent>(OnRelayMovement);
SubscribeLocalEvent<DisposalTubeComponent, BreakageEventArgs>(OnBreak);
- SubscribeLocalEvent<DisposalRouterComponent, ActivatableUIOpenAttemptEvent>(OnOpenRouterUIAttempt);
- SubscribeLocalEvent<DisposalTaggerComponent, ActivatableUIOpenAttemptEvent>(OnOpenTaggerUIAttempt);
SubscribeLocalEvent<DisposalTubeComponent, ComponentStartup>(OnStartup);
SubscribeLocalEvent<DisposalTubeComponent, ConstructionBeforeDeleteEvent>(OnDeconstruct);
+
+ SubscribeLocalEvent<DisposalBendComponent, GetDisposalsConnectableDirectionsEvent>(OnGetBendConnectableDirections);
+ SubscribeLocalEvent<DisposalBendComponent, GetDisposalsNextDirectionEvent>(OnGetBendNextDirection);
+
+ SubscribeLocalEvent<DisposalEntryComponent, GetDisposalsConnectableDirectionsEvent>(OnGetEntryConnectableDirections);
+ SubscribeLocalEvent<DisposalEntryComponent, GetDisposalsNextDirectionEvent>(OnGetEntryNextDirection);
+
+ SubscribeLocalEvent<DisposalJunctionComponent, GetDisposalsConnectableDirectionsEvent>(OnGetJunctionConnectableDirections);
+ SubscribeLocalEvent<DisposalJunctionComponent, GetDisposalsNextDirectionEvent>(OnGetJunctionNextDirection);
+
+ SubscribeLocalEvent<DisposalRouterComponent, GetDisposalsConnectableDirectionsEvent>(OnGetRouterConnectableDirections);
+ SubscribeLocalEvent<DisposalRouterComponent, GetDisposalsNextDirectionEvent>(OnGetRouterNextDirection);
+
+ SubscribeLocalEvent<DisposalTransitComponent, GetDisposalsConnectableDirectionsEvent>(OnGetTransitConnectableDirections);
+ SubscribeLocalEvent<DisposalTransitComponent, GetDisposalsNextDirectionEvent>(OnGetTransitNextDirection);
+
+ SubscribeLocalEvent<DisposalTaggerComponent, GetDisposalsConnectableDirectionsEvent>(OnGetTaggerConnectableDirections);
+ SubscribeLocalEvent<DisposalTaggerComponent, GetDisposalsNextDirectionEvent>(OnGetTaggerNextDirection);
+
+ SubscribeLocalEvent<DisposalRouterComponent, ActivatableUIOpenAttemptEvent>(OnOpenRouterUIAttempt);
+ SubscribeLocalEvent<DisposalTaggerComponent, ActivatableUIOpenAttemptEvent>(OnOpenTaggerUIAttempt);
+ }
+
+ private void OnGetBendConnectableDirections(EntityUid uid, DisposalBendComponent component, ref GetDisposalsConnectableDirectionsEvent args)
+ {
+ var direction = Transform(uid).LocalRotation;
+ var side = new Angle(MathHelper.DegreesToRadians(direction.Degrees - 90));
+
+ args.Connectable = new[] {direction.GetDir(), side.GetDir()};
+ }
+
+ private void OnGetBendNextDirection(EntityUid uid, DisposalBendComponent component, ref GetDisposalsNextDirectionEvent args)
+ {
+ var ev = new GetDisposalsConnectableDirectionsEvent();
+ RaiseLocalEvent(uid, ref ev);
+
+ var previousDF = args.Holder.PreviousDirectionFrom;
+
+ if (previousDF == Direction.Invalid)
+ {
+ args.Next = ev.Connectable[0];
+ return;
+ }
+
+ args.Next = previousDF == ev.Connectable[0] ? ev.Connectable[1] : ev.Connectable[0];
+ }
+
+ private void OnGetEntryConnectableDirections(EntityUid uid, DisposalEntryComponent component, ref GetDisposalsConnectableDirectionsEvent args)
+ {
+ args.Connectable = new[] {Transform(uid).LocalRotation.GetDir()};
+ }
+
+ private void OnGetEntryNextDirection(EntityUid uid, DisposalEntryComponent component, ref GetDisposalsNextDirectionEvent args)
+ {
+ // Ejects contents when they come from the same direction the entry is facing.
+ if (args.Holder.PreviousDirectionFrom != Direction.Invalid)
+ {
+ args.Next = Direction.Invalid;
+ return;
+ }
+
+ var ev = new GetDisposalsConnectableDirectionsEvent();
+ RaiseLocalEvent(uid, ref ev);
+ args.Next = ev.Connectable[0];
+ }
+
+ private void OnGetJunctionConnectableDirections(EntityUid uid, DisposalJunctionComponent component, ref GetDisposalsConnectableDirectionsEvent args)
+ {
+ var direction = Transform(uid).LocalRotation;
+
+ args.Connectable = component.Degrees
+ .Select(degree => new Angle(degree.Theta + direction.Theta).GetDir())
+ .ToArray();
+ }
+
+ private void OnGetJunctionNextDirection(EntityUid uid, DisposalJunctionComponent component, ref GetDisposalsNextDirectionEvent args)
+ {
+ var next = Transform(uid).LocalRotation.GetDir();
+ var ev = new GetDisposalsConnectableDirectionsEvent();
+ RaiseLocalEvent(uid, ref ev);
+ var directions = ev.Connectable.Skip(1).ToArray();
+
+ if (args.Holder.PreviousDirectionFrom == Direction.Invalid ||
+ args.Holder.PreviousDirectionFrom == next)
+ {
+ args.Next = _random.Pick(directions);
+ return;
+ }
+
+ args.Next = next;
+ }
+
+ private void OnGetRouterConnectableDirections(EntityUid uid, DisposalRouterComponent component, ref GetDisposalsConnectableDirectionsEvent args)
+ {
+ OnGetJunctionConnectableDirections(uid, component, ref args);
+ }
+
+ private void OnGetRouterNextDirection(EntityUid uid, DisposalRouterComponent component, ref GetDisposalsNextDirectionEvent args)
+ {
+ var ev = new GetDisposalsConnectableDirectionsEvent();
+ RaiseLocalEvent(uid, ref ev);
+
+ if (args.Holder.Tags.Overlaps(component.Tags))
+ {
+ args.Next = ev.Connectable[1];
+ return;
+ }
+
+ args.Next = Transform(uid).LocalRotation.GetDir();
+ }
+
+ private void OnGetTransitConnectableDirections(EntityUid uid, DisposalTransitComponent component, ref GetDisposalsConnectableDirectionsEvent args)
+ {
+ var rotation = Transform(uid).LocalRotation;
+ var opposite = new Angle(rotation.Theta + Math.PI);
+
+ args.Connectable = new[] {rotation.GetDir(), opposite.GetDir()};
+ }
+
+ private void OnGetTransitNextDirection(EntityUid uid, DisposalTransitComponent component, ref GetDisposalsNextDirectionEvent args)
+ {
+ var ev = new GetDisposalsConnectableDirectionsEvent();
+ RaiseLocalEvent(uid, ref ev);
+ var previousDF = args.Holder.PreviousDirectionFrom;
+ var forward = ev.Connectable[0];
+
+ if (previousDF == Direction.Invalid)
+ {
+ args.Next = forward;
+ return;
+ }
+
+ var backward = ev.Connectable[1];
+ args.Next = previousDF == forward ? backward : forward;
+ }
+
+ private void OnGetTaggerConnectableDirections(EntityUid uid, DisposalTaggerComponent component, ref GetDisposalsConnectableDirectionsEvent args)
+ {
+ OnGetTransitConnectableDirections(uid, component, ref args);
+ }
+
+ private void OnGetTaggerNextDirection(EntityUid uid, DisposalTaggerComponent component, ref GetDisposalsNextDirectionEvent args)
+ {
+ args.Holder.Tags.Add(component.Tag);
+ OnGetTransitNextDirection(uid, component, ref args);
}
private void OnDeconstruct(EntityUid uid, DisposalTubeComponent component, ConstructionBeforeDeleteEvent args)
}
}
- public IDisposalTubeComponent? NextTubeFor(EntityUid target, Direction nextDirection, IDisposalTubeComponent? targetTube = null)
+ public DisposalTubeComponent? NextTubeFor(EntityUid target, Direction nextDirection, DisposalTubeComponent? targetTube = null)
{
if (!Resolve(target, ref targetTube))
return null;
var position = xform.Coordinates;
foreach (var entity in grid.GetInDir(position, nextDirection))
{
- if (!EntityManager.TryGetComponent(entity, out IDisposalTubeComponent? tube))
+ if (!TryComp(entity, out DisposalTubeComponent? tube))
{
continue;
}
- if (!tube.CanConnect(oppositeDirection, targetTube))
+ if (!CanConnect(entity, tube, oppositeDirection))
{
continue;
}
- if (!targetTube.CanConnect(nextDirection, tube))
+ if (!CanConnect(target, targetTube, nextDirection))
{
continue;
}
return null;
}
+
+
+ public bool CanConnect(EntityUid tubeId, DisposalTubeComponent tube, Direction direction)
+ {
+ if (!tube.Connected)
+ {
+ return false;
+ }
+
+ var ev = new GetDisposalsConnectableDirectionsEvent();
+ RaiseLocalEvent(tubeId, ref ev);
+ return ev.Connectable.Contains(direction);
+ }
+
+ public void PopupDirections(EntityUid tubeId, DisposalTubeComponent tube, EntityUid recipient)
+ {
+ var ev = new GetDisposalsConnectableDirectionsEvent();
+ RaiseLocalEvent(tubeId, ref ev);
+ var directions = string.Join(", ", ev.Connectable);
+
+ _popups.PopupEntity(Loc.GetString("disposal-tube-component-popup-directions-text", ("directions", directions)), tubeId, recipient);
+ }
}
}
--- /dev/null
+using Content.Server.Disposal.Unit.Components;
+
+namespace Content.Server.Disposal.Tube;
+
+[ByRefEvent]
+public record struct GetDisposalsConnectableDirectionsEvent
+{
+ public Direction[] Connectable;
+}
--- /dev/null
+using Content.Server.Disposal.Unit.Components;
+
+namespace Content.Server.Disposal.Tube;
+
+[ByRefEvent]
+public record struct GetDisposalsNextDirectionEvent(DisposalHolderComponent Holder)
+{
+ public Direction Next;
+}
using Content.Server.Administration;
+using Content.Server.Disposal.Tube;
using Content.Server.Disposal.Tube.Components;
using Content.Shared.Administration;
using Robust.Server.Player;
[AdminCommand(AdminFlags.Debug)]
public sealed class TubeConnectionsCommand : IConsoleCommand
{
+ [Dependency] private readonly IEntityManager _entities = default!;
+
public string Command => "tubeconnections";
public string Description => Loc.GetString("tube-connections-command-description");
public string Help => Loc.GetString("tube-connections-command-help-text", ("command", Command));
return;
}
- var entityManager = IoCManager.Resolve<IEntityManager>();
- if (!entityManager.EntityExists(id))
+ if (!_entities.EntityExists(id))
{
shell.WriteLine(Loc.GetString("shell-could-not-find-entity-with-uid",("uid", id)));
return;
}
- if (!entityManager.TryGetComponent(id, out IDisposalTubeComponent? tube))
+ if (!_entities.TryGetComponent(id, out DisposalTubeComponent? tube))
{
shell.WriteLine(Loc.GetString("shell-entity-with-uid-lacks-component",
("uid", id),
- ("componentName", nameof(IDisposalTubeComponent))));
+ ("componentName", nameof(DisposalTubeComponent))));
return;
}
- tube.PopupDirections(player.AttachedEntity.Value);
+ _entities.System<DisposalTubeSystem>().PopupDirections(id, tube, player.AttachedEntity.Value);
}
}
}
using Content.Shared.Body.Components;
using Content.Shared.Item;
using Robust.Shared.Containers;
-using Robust.Shared.Physics;
using Robust.Shared.Physics.Components;
using Robust.Shared.Physics.Systems;
namespace Content.Server.Disposal.Unit.Components
{
- // TODO: Add gas
[RegisterComponent]
public sealed class DisposalHolderComponent : Component, IGasMixtureHolder
{
public float TimeLeft { get; set; }
[ViewVariables]
- public IDisposalTubeComponent? PreviousTube { get; set; }
+ public DisposalTubeComponent? PreviousTube { get; set; }
[ViewVariables]
public Direction PreviousDirection { get; set; } = Direction.Invalid;
public Direction PreviousDirectionFrom => (PreviousDirection == Direction.Invalid) ? Direction.Invalid : PreviousDirection.GetOpposite();
[ViewVariables]
- public IDisposalTubeComponent? CurrentTube { get; set; }
+ public DisposalTubeComponent? CurrentTube { get; set; }
// CurrentDirection is not null when CurrentTube isn't null.
[ViewVariables]
using System.Linq;
using Content.Server.Atmos.EntitySystems;
-using Content.Server.Disposal.Tube.Components;
using Content.Server.Disposal.Tube;
+using Content.Server.Disposal.Tube.Components;
using Content.Server.Disposal.Unit.Components;
using JetBrains.Annotations;
-using Robust.Shared.Containers;
using Robust.Shared.Map;
-using Robust.Shared.Physics;
-using Robust.Shared.Physics.Systems;
using Robust.Shared.Physics.Components;
+using Robust.Shared.Physics.Systems;
namespace Content.Server.Disposal.Unit.EntitySystems
{
}
// Note: This function will cause an ExitDisposals on any failure that does not make an ExitDisposals impossible.
- public bool EnterTube(EntityUid holderUid, EntityUid toUid, DisposalHolderComponent? holder = null, TransformComponent? holderTransform = null, IDisposalTubeComponent? to = null, TransformComponent? toTransform = null)
+ public bool EnterTube(EntityUid holderUid, EntityUid toUid, DisposalHolderComponent? holder = null, TransformComponent? holderTransform = null, DisposalTubeComponent? to = null, TransformComponent? toTransform = null)
{
if (!Resolve(holderUid, ref holder, ref holderTransform))
return false;
holder.PreviousDirection = holder.CurrentDirection;
}
holder.CurrentTube = to;
- holder.CurrentDirection = to.NextDirection(holder);
+ var ev = new GetDisposalsNextDirectionEvent(holder);
+ RaiseLocalEvent(toUid, ref ev);
+ holder.CurrentDirection = ev.Next;
holder.StartingTime = 0.1f;
holder.TimeLeft = 0.1f;
// Logger.InfoS("c.s.disposal.holder", $"Disposals dir {holder.CurrentDirection}");
}
// Perform remainder of entry process
- if (!EnterTube((holder).Owner, nextTube.Owner, holder, null, nextTube, null))
+ if (!EnterTube((holder).Owner, nextTube.Owner, holder))
{
break;
}
layers:
- map: [ "pipe" ]
state: conpipe-s
+ - type: DisposalTube
+ containerId: DisposalTransit
- type: DisposalTransit
- type: ContainerContainer
containers:
layers:
- map: [ "pipe" ]
state: conpipe-tagger
+ - type: DisposalTube
+ containerId: DisposalTagger
- type: DisposalTagger
- type: ContainerContainer
containers:
layers:
- map: [ "pipe" ]
state: conpipe-t
+ - type: DisposalTube
+ containerId: DisposalEntry
- type: DisposalEntry
- type: ContainerContainer
containers:
layers:
- map: [ "pipe" ]
state: conpipe-j1s
+ - type: DisposalTube
+ containerId: DisposalRouter
- type: DisposalRouter
degrees:
- 0
layers:
- map: [ "pipe" ]
state: conpipe-j2s
+ - type: DisposalTube
+ containerId: DisposalRouter
- type: DisposalRouter
degrees:
- 0
- map: [ "pipe" ]
state: conpipe-j1
visible: true
+ - type: DisposalTube
+ containerId: DisposalJunction
- type: DisposalJunction
degrees:
- 0
layers:
- map: [ "pipe" ]
state: conpipe-j2
+ - type: DisposalTube
+ containerId: DisposalJunction
- type: DisposalJunction
degrees:
- 0
layers:
- map: [ "pipe" ]
state: conpipe-y
+ - type: DisposalTube
+ containerId: DisposalJunction
- type: DisposalJunction
degrees:
- 0
layers:
- map: [ "pipe" ]
state: conpipe-c
+ - type: DisposalTube
+ containerId: DisposalBend
- type: DisposalBend
- type: ContainerContainer
containers:
projects / space-station-14.git / commitdiff