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

Anchorable shared (#17422)

Browse Source 
Co-authored-by: BenOwnby <ownbyb@appstate.edu>
Co-authored-by: metalgearsloth <comedian_vs_clown@hotmail.com>
Co-authored-by: metalgearsloth <31366439+metalgearsloth@users.noreply.github.com>
This commit is contained in:
Ben
2023-06-29 08:35:54 -04:00
committed by GitHub
parent 67df47f553
commit c858c76341
21 changed files with 363 additions and 385 deletions
Download Patch File Download Diff File Expand all files Collapse all files

5
Content.Client/Construction/EntitySystems/AnchorableSystem.cs
View File

@@ -1,5 +0,0 @@
using Content.Shared.Construction.EntitySystems;
namespace Content.Client.Construction.EntitySystems;
public sealed class AnchorableSystem : SharedAnchorableSystem { }

2
Content.Server/Abilities/Mime/MimePowersSystem.cs
View File

@@ -1,7 +1,7 @@
using Content.Server.Popups;
using Content.Server.Coordinates.Helpers;
using Content.Shared.Actions;
using Content.Shared.Alert;
using Content.Shared.Coordinates.Helpers;
using Content.Shared.Physics;
using Content.Shared.Doors.Components;
using Content.Shared.Maps;

2
Content.Server/Botany/Systems/PlantHolderSystem.cs
View File

@@ -2,7 +2,6 @@ using Content.Server.Atmos;
using Content.Server.Atmos.EntitySystems;
using Content.Server.Botany.Components;
using Content.Server.Chemistry.EntitySystems;
using Content.Server.Coordinates.Helpers;
using Content.Server.Fluids.Components;
using Content.Server.Ghost.Roles.Components;
using Content.Server.Kitchen.Components;
@@ -10,6 +9,7 @@ using Content.Server.Popups;
using Content.Shared.Botany;
using Content.Shared.Chemistry.Components;
using Content.Shared.Chemistry.Reagent;
using Content.Shared.Coordinates.Helpers;
using Content.Shared.Examine;
using Content.Shared.FixedPoint;
using Content.Shared.Hands.Components;

2
Content.Server/Chemistry/ReactionEffects/AreaReactionEffect.cs
View File

@@ -1,9 +1,9 @@
using Content.Server.Chemistry.Components;
using Content.Server.Chemistry.EntitySystems;
using Content.Server.Coordinates.Helpers;
using Content.Server.Fluids.EntitySystems;
using Content.Shared.Audio;
using Content.Shared.Chemistry.Reagent;
using Content.Shared.Coordinates.Helpers;
using Content.Shared.Database;
using Content.Shared.FixedPoint;
using Content.Shared.Maps;

268
Content.Server/Construction/AnchorableSystem.cs
View File

@@ -1,268 +0,0 @@
using Content.Server.Administration.Logs;
using Content.Server.Construction.Components;
using Content.Server.Coordinates.Helpers;
using Content.Server.Popups;
using Content.Server.Pulling;
using Content.Shared.Construction.Components;
using Content.Shared.Construction.Conditions;
using Content.Shared.Construction.EntitySystems;
using Content.Shared.Database;
using Content.Shared.DoAfter;
using Content.Shared.Examine;
using Content.Shared.Pulling.Components;
using Content.Shared.Tag;
using Content.Shared.Tools;
using Content.Shared.Tools.Components;
using Robust.Shared.Map;
using Robust.Shared.Map.Components;
using Robust.Shared.Physics.Components;
namespace Content.Server.Construction
{
public sealed class AnchorableSystem : SharedAnchorableSystem
{
[Dependency] private readonly IAdminLogManager _adminLogger = default!;
[Dependency] private readonly IMapManager _mapManager = default!;
[Dependency] private readonly PopupSystem _popup = default!;
[Dependency] private readonly SharedToolSystem _tool = default!;
[Dependency] private readonly PullingSystem _pulling = default!;
[Dependency] private readonly SharedTransformSystem _transform = default!;
public override void Initialize()
{
base.Initialize();
SubscribeLocalEvent<AnchorableComponent, TryAnchorCompletedEvent>(OnAnchorComplete);
SubscribeLocalEvent<AnchorableComponent, TryUnanchorCompletedEvent>(OnUnanchorComplete);
SubscribeLocalEvent<AnchorableComponent, ExaminedEvent>(OnAnchoredExamine);
}
private void OnAnchoredExamine(EntityUid uid, AnchorableComponent component, ExaminedEvent args)
{
var isAnchored = Comp<TransformComponent>(uid).Anchored;
var messageId = isAnchored ? "examinable-anchored" : "examinable-unanchored";
args.PushMarkup(Loc.GetString(messageId, ("target", uid)));
}
private void OnUnanchorComplete(EntityUid uid, AnchorableComponent component, TryUnanchorCompletedEvent args)
{
if (args.Cancelled || args.Used is not { } used)
return;
var xform = Transform(uid);
RaiseLocalEvent(uid, new BeforeUnanchoredEvent(args.User, used));
_transform.Unanchor(uid, xform);
RaiseLocalEvent(uid, new UserUnanchoredEvent(args.User, used));
_popup.PopupEntity(Loc.GetString("anchorable-unanchored"), uid);
_adminLogger.Add(
LogType.Unanchor,
LogImpact.Low,
$"{EntityManager.ToPrettyString(args.User):user} unanchored {EntityManager.ToPrettyString(uid):anchored} using {EntityManager.ToPrettyString(used):using}"
);
}
private void OnAnchorComplete(EntityUid uid, AnchorableComponent component, TryAnchorCompletedEvent args)
{
if (args.Cancelled || args.Used is not { } used)
return;
var xform = Transform(uid);
if (TryComp<PhysicsComponent>(uid, out var anchorBody) &&
!TileFree(xform.Coordinates, anchorBody))
{
_popup.PopupEntity(Loc.GetString("anchorable-occupied"), uid, args.User);
return;
}
// Snap rotation to cardinal (multiple of 90)
var rot = xform.LocalRotation;
xform.LocalRotation = Math.Round(rot / (Math.PI / 2)) * (Math.PI / 2);
if (TryComp<SharedPullableComponent>(uid, out var pullable) && pullable.Puller != null)
{
_pulling.TryStopPull(pullable);
}
// TODO: Anchoring snaps rn anyway!
if (component.Snap)
{
var coordinates = xform.Coordinates.SnapToGrid(EntityManager, _mapManager);
if (AnyUnstackable(uid, coordinates))
{
_popup.PopupEntity(Loc.GetString("construction-step-condition-no-unstackable-in-tile"), uid, args.User);
return;
}
_transform.SetCoordinates(uid, coordinates);
}
RaiseLocalEvent(uid, new BeforeAnchoredEvent(args.User, used));
if (!xform.Anchored)
_transform.AnchorEntity(uid, xform);
RaiseLocalEvent(uid, new UserAnchoredEvent(args.User, used));
_popup.PopupEntity(Loc.GetString("anchorable-anchored"), uid);
_adminLogger.Add(
LogType.Anchor,
LogImpact.Low,
$"{EntityManager.ToPrettyString(args.User):user} anchored {EntityManager.ToPrettyString(uid):anchored} using {EntityManager.ToPrettyString(used):using}"
);
}
private bool TileFree(EntityCoordinates coordinates, PhysicsComponent anchorBody)
{
// Probably ignore CanCollide on the anchoring body?
var gridUid = coordinates.GetGridUid(EntityManager);
if (!_mapManager.TryGetGrid(gridUid, out var grid))
return false;
var tileIndices = grid.TileIndicesFor(coordinates);
return TileFree(grid, tileIndices, anchorBody.CollisionLayer, anchorBody.CollisionMask);
}
public bool TileFree(MapGridComponent grid, Vector2i gridIndices, int collisionLayer = 0, int collisionMask = 0)
{
var enumerator = grid.GetAnchoredEntitiesEnumerator(gridIndices);
var bodyQuery = GetEntityQuery<PhysicsComponent>();
while (enumerator.MoveNext(out var ent))
{
if (!bodyQuery.TryGetComponent(ent, out var body) ||
!body.CanCollide ||
!body.Hard)
{
continue;
}
if ((body.CollisionMask & collisionLayer) != 0x0 ||
(body.CollisionLayer & collisionMask) != 0x0)
{
return false;
}
}
return true;
}
/// <summary>
/// Checks if a tool can change the anchored status.
/// </summary>
/// <returns>true if it is valid, false otherwise</returns>
private bool Valid(EntityUid uid, EntityUid userUid, EntityUid usingUid, bool anchoring, AnchorableComponent? anchorable = null, ToolComponent? usingTool = null)
{
if (!Resolve(uid, ref anchorable))
return false;
if (!Resolve(usingUid, ref usingTool))
return false;
BaseAnchoredAttemptEvent attempt =
anchoring ? new AnchorAttemptEvent(userUid, usingUid) : new UnanchorAttemptEvent(userUid, usingUid);
// Need to cast the event or it will be raised as BaseAnchoredAttemptEvent.
if (anchoring)
RaiseLocalEvent(uid, (AnchorAttemptEvent) attempt);
else
RaiseLocalEvent(uid, (UnanchorAttemptEvent) attempt);
anchorable.Delay += attempt.Delay;
return !attempt.Cancelled;
}
/// <summary>
/// Tries to anchor the entity.
/// </summary>
/// <returns>true if anchored, false otherwise</returns>
private void TryAnchor(EntityUid uid, EntityUid userUid, EntityUid usingUid,
AnchorableComponent? anchorable = null,
TransformComponent? transform = null,
SharedPullableComponent? pullable = null,
ToolComponent? usingTool = null)
{
if (!Resolve(uid, ref anchorable, ref transform))
return;
// Optional resolves.
Resolve(uid, ref pullable, false);
if (!Resolve(usingUid, ref usingTool))
return;
if (!Valid(uid, userUid, usingUid, true, anchorable, usingTool))
return;
if (TryComp<PhysicsComponent>(uid, out var anchorBody) &&
!TileFree(transform.Coordinates, anchorBody))
{
_popup.PopupEntity(Loc.GetString("anchorable-occupied"), uid, userUid);
return;
}
if (AnyUnstackable(uid, transform.Coordinates))
{
_popup.PopupEntity(Loc.GetString("construction-step-condition-no-unstackable-in-tile"), uid, userUid);
return;
}
_tool.UseTool(usingUid, userUid, uid, anchorable.Delay, usingTool.Qualities, new TryAnchorCompletedEvent());
}
/// <summary>
/// Tries to unanchor the entity.
/// </summary>
/// <returns>true if unanchored, false otherwise</returns>
private void TryUnAnchor(EntityUid uid, EntityUid userUid, EntityUid usingUid,
AnchorableComponent? anchorable = null,
TransformComponent? transform = null,
ToolComponent? usingTool = null)
{
if (!Resolve(uid, ref anchorable, ref transform))
return;
if (!Resolve(usingUid, ref usingTool))
return;
if (!Valid(uid, userUid, usingUid, false))
return;
_tool.UseTool(usingUid, userUid, uid, anchorable.Delay, usingTool.Qualities, new TryUnanchorCompletedEvent());
}
/// <summary>
/// Tries to toggle the anchored status of this component's owner.
/// </summary>
/// <returns>true if toggled, false otherwise</returns>
public override void TryToggleAnchor(EntityUid uid, EntityUid userUid, EntityUid usingUid,
AnchorableComponent? anchorable = null,
TransformComponent? transform = null,
SharedPullableComponent? pullable = null,
ToolComponent? usingTool = null)
{
if (!Resolve(uid, ref transform))
return;
if (transform.Anchored)
{
TryUnAnchor(uid, userUid, usingUid, anchorable, transform, usingTool);
// Log unanchor attempt
_adminLogger.Add(LogType.Anchor, LogImpact.Low, $"{ToPrettyString(userUid):user} is trying to unanchor {ToPrettyString(uid):entity} from {transform.Coordinates:targetlocation}");
}
else
{
TryAnchor(uid, userUid, usingUid, anchorable, transform, pullable, usingTool);
// Log anchor attempt
_adminLogger.Add(LogType.Anchor, LogImpact.Low, $"{ToPrettyString(userUid):user} is trying to anchor {ToPrettyString(uid):entity} to {transform.Coordinates:targetlocation}");
}
}
}
}

2
Content.Server/Construction/Completions/SnapToGrid.cs
View File

@@ -1,4 +1,4 @@
using Content.Server.Coordinates.Helpers;
using Content.Shared.Coordinates.Helpers;
using Content.Shared.Construction;
using JetBrains.Annotations;

5
Content.Server/Construction/ConstructionSystem.Interactions.cs
View File

@@ -4,6 +4,7 @@ using Content.Server.Construction.Components;
using Content.Server.Temperature.Components;
using Content.Server.Temperature.Systems;
using Content.Shared.Construction;
using Content.Shared.Construction.EntitySystems;
using Content.Shared.Construction.Steps;
using Content.Shared.DoAfter;
using Content.Shared.Interaction;
@@ -34,7 +35,9 @@ namespace Content.Server.Construction
SubscribeLocalEvent<ConstructionComponent, ConstructionInteractDoAfterEvent>(EnqueueEvent);
// Event handling. Add your subscriptions here! Just make sure they're all handled by EnqueueEvent.
SubscribeLocalEvent<ConstructionComponent, InteractUsingEvent>(EnqueueEvent, new []{typeof(AnchorableSystem)}, new []{typeof(EncryptionKeySystem)});
SubscribeLocalEvent<ConstructionComponent, InteractUsingEvent>(EnqueueEvent,
new []{typeof(AnchorableSystem)},
new []{typeof(EncryptionKeySystem)});
SubscribeLocalEvent<ConstructionComponent, OnTemperatureChangeEvent>(EnqueueEvent);
}

2
Content.Server/Engineering/EntitySystems/SpawnAfterInteractSystem.cs
View File

@@ -1,4 +1,4 @@
using Content.Server.Coordinates.Helpers;
using Content.Shared.Coordinates.Helpers;
using Content.Server.Engineering.Components;
using Content.Server.Stack;
using Content.Shared.DoAfter;

2
Content.Server/Fluids/EntitySystems/SmokeSystem.cs
View File

@@ -5,12 +5,12 @@ using Content.Server.Body.Systems;
using Content.Server.Chemistry.Components;
using Content.Server.Chemistry.EntitySystems;
using Content.Server.Chemistry.ReactionEffects;
using Content.Server.Coordinates.Helpers;
using Content.Server.Spreader;
using Content.Shared.Chemistry;
using Content.Shared.Chemistry.Components;
using Content.Shared.Chemistry.Reaction;
using Content.Shared.Chemistry.Reagent;
using Content.Shared.Coordinates.Helpers;
using Content.Shared.Database;
using Content.Shared.FixedPoint;
using Content.Shared.Smoking;

2
Content.Server/Holosign/HolosignSystem.cs
View File

@@ -1,6 +1,6 @@
using Content.Shared.Interaction.Events;
using Content.Shared.Examine;
using Content.Server.Coordinates.Helpers;
using Content.Shared.Coordinates.Helpers;
using Content.Server.Power.Components;
using Content.Server.PowerCell;

1
Content.Server/Kitchen/EntitySystems/MicrowaveSystem.cs
View File

@@ -10,6 +10,7 @@ using Content.Server.Temperature.Components;
using Content.Server.Temperature.Systems;
using Content.Shared.Body.Components;
using Content.Shared.Body.Part;
using Content.Shared.Construction.EntitySystems;
using Content.Shared.Destructible;
using Content.Shared.FixedPoint;
using Content.Shared.Interaction;

2
Content.Server/Magic/MagicSystem.cs
View File

@@ -1,7 +1,6 @@
using Content.Server.Body.Components;
using Content.Server.Body.Systems;
using Content.Server.Chat.Systems;
using Content.Server.Coordinates.Helpers;
using Content.Server.Doors.Systems;
using Content.Server.Magic.Components;
using Content.Server.Magic.Events;
@@ -9,6 +8,7 @@ using Content.Server.Weapons.Ranged.Systems;
using Content.Shared.Actions;
using Content.Shared.Actions.ActionTypes;
using Content.Shared.Body.Components;
using Content.Shared.Coordinates.Helpers;
using Content.Shared.DoAfter;
using Content.Shared.Doors.Components;
using Content.Shared.Doors.Systems;

4
Content.Server/Maps/TileSystem.cs
View File

@@ -1,5 +1,5 @@
using Content.Server.Coordinates.Helpers;
using Content.Server.Decals;
using Content.Server.Decals;
using Content.Shared.Coordinates.Helpers;
using Content.Shared.Decals;
using Content.Shared.Maps;
using Robust.Shared.Map;

2
Content.Server/Nuke/NukeSystem.cs
View File

@@ -1,13 +1,13 @@
using Content.Server.AlertLevel;
using Content.Server.Audio;
using Content.Server.Chat.Systems;
using Content.Server.Coordinates.Helpers;
using Content.Server.Explosion.EntitySystems;
using Content.Server.Popups;
using Content.Server.Station.Systems;
using Content.Shared.Audio;
using Content.Shared.Construction.Components;
using Content.Shared.Containers.ItemSlots;
using Content.Shared.Coordinates.Helpers;
using Content.Shared.DoAfter;
using Content.Shared.Nuke;
using Content.Shared.Popups;

1
Content.Server/Procedural/DungeonJob.cs
View File

@@ -3,6 +3,7 @@ using System.Threading.Tasks;
using Content.Server.Construction;
using Robust.Shared.CPUJob.JobQueues;
using Content.Server.Decals;
using Content.Shared.Construction.EntitySystems;
using Content.Shared.Procedural;
using Content.Shared.Procedural.DungeonGenerators;
using Content.Shared.Procedural.PostGeneration;

1
Content.Server/Procedural/DungeonSystem.cs
View File

@@ -5,6 +5,7 @@ using Robust.Shared.CPUJob.JobQueues.Queues;
using Content.Server.Decals;
using Content.Server.GameTicking.Events;
using Content.Shared.CCVar;
using Content.Shared.Construction.EntitySystems;
using Content.Shared.Procedural;
using Robust.Server.GameObjects;
using Robust.Shared.Configuration;

2
Content.Shared/Construction/Components/AnchorableComponent.cs
View File

@@ -4,7 +4,7 @@ using Robust.Shared.Serialization.TypeSerializers.Implementations.Custom.Prototy
namespace Content.Shared.Construction.Components
{
[RegisterComponent, Access(typeof(SharedAnchorableSystem))]
[RegisterComponent, Access(typeof(AnchorableSystem))]
public sealed class AnchorableComponent : Component
{
[DataField("tool", customTypeSerializer: typeof(PrototypeIdSerializer<ToolQualityPrototype>))]

2
Content.Shared/Construction/Conditions/NoUnstackableInTile.cs
View File

@@ -16,7 +16,7 @@ public sealed class NoUnstackableInTile : IConstructionCondition
public bool Condition(EntityUid user, EntityCoordinates location, Direction direction)
{
var sysMan = IoCManager.Resolve<IEntitySystemManager>();
var anchorable = sysMan.GetEntitySystem<SharedAnchorableSystem>();
var anchorable = sysMan.GetEntitySystem<AnchorableSystem>();
return !anchorable.AnyUnstackablesAnchoredAt(location);
}

342
Content.Shared/Construction/EntitySystems/AnchorableSystem.cs Normal file
View File

@@ -0,0 +1,342 @@
using Content.Shared.Administration.Logs;
using Content.Shared.Examine;
using Content.Shared.Construction.Components;
using Content.Shared.Containers.ItemSlots;
using Content.Shared.Coordinates.Helpers;
using Content.Shared.Database;
using Content.Shared.DoAfter;
using Content.Shared.Interaction;
using Content.Shared.Popups;
using Content.Shared.Pulling;
using Content.Shared.Pulling.Components;
using Content.Shared.Tools;
using Content.Shared.Tools.Components;
using Robust.Shared.Map;
using Robust.Shared.Map.Components;
using Robust.Shared.Physics.Components;
using Content.Shared.Tag;
using Robust.Shared.Player;
using Robust.Shared.Serialization;
using Robust.Shared.Utility;
namespace Content.Shared.Construction.EntitySystems;
public sealed class AnchorableSystem : EntitySystem
{
[Dependency] private readonly IMapManager _mapManager = default!;
[Dependency] private readonly ISharedAdminLogManager _adminLogger = default!;
[Dependency] private readonly SharedPopupSystem _popup = default!;
[Dependency] private readonly SharedPullingSystem _pulling = default!;
[Dependency] private readonly SharedToolSystem _tool = default!;
[Dependency] private readonly SharedTransformSystem _transformSystem = default!;
[Dependency] private readonly TagSystem _tagSystem = default!;
private EntityQuery<PhysicsComponent> _physicsQuery;
private EntityQuery<TagComponent> _tagQuery;
public const string Unstackable = "Unstackable";
public override void Initialize()
{
base.Initialize();
_physicsQuery = GetEntityQuery<PhysicsComponent>();
_tagQuery = GetEntityQuery<TagComponent>();
SubscribeLocalEvent<AnchorableComponent, InteractUsingEvent>(OnInteractUsing,
before: new[] { typeof(ItemSlotsSystem) }, after: new[] { typeof(SharedConstructionSystem) });
SubscribeLocalEvent<AnchorableComponent, TryAnchorCompletedEvent>(OnAnchorComplete);
SubscribeLocalEvent<AnchorableComponent, TryUnanchorCompletedEvent>(OnUnanchorComplete);
SubscribeLocalEvent<AnchorableComponent, ExaminedEvent>(OnAnchoredExamine);
}
/// <summary>
/// Tries to unanchor the entity.
/// </summary>
/// <returns>true if unanchored, false otherwise</returns>
private void TryUnAnchor(EntityUid uid, EntityUid userUid, EntityUid usingUid,
AnchorableComponent? anchorable = null,
TransformComponent? transform = null,
ToolComponent? usingTool = null)
{
if (!Resolve(uid, ref anchorable, ref transform))
return;
if (!Resolve(usingUid, ref usingTool))
return;
if (!Valid(uid, userUid, usingUid, false))
return;
_tool.UseTool(usingUid, userUid, uid, anchorable.Delay, usingTool.Qualities, new TryUnanchorCompletedEvent());
}
private void OnInteractUsing(EntityUid uid, AnchorableComponent anchorable, InteractUsingEvent args)
{
if (args.Handled)
return;
// If the used entity doesn't have a tool, return early.
if (!TryComp(args.Used, out ToolComponent? usedTool) || !usedTool.Qualities.Contains(anchorable.Tool))
return;
args.Handled = true;
TryToggleAnchor(uid, args.User, args.Used, anchorable, usingTool: usedTool);
}
private void OnAnchoredExamine(EntityUid uid, AnchorableComponent component, ExaminedEvent args)
{
var isAnchored = Comp<TransformComponent>(uid).Anchored;
var messageId = isAnchored ? "examinable-anchored" : "examinable-unanchored";
args.PushMarkup(Loc.GetString(messageId, ("target", uid)));
}
private void OnUnanchorComplete(EntityUid uid, AnchorableComponent component, TryUnanchorCompletedEvent args)
{
if (args.Cancelled || args.Used is not { } used)
return;
var xform = Transform(uid);
RaiseLocalEvent(uid, new BeforeUnanchoredEvent(args.User, used));
_transformSystem.Unanchor(uid, xform);
RaiseLocalEvent(uid, new UserUnanchoredEvent(args.User, used));
_popup.PopupClient(Loc.GetString("anchorable-unanchored"), uid, args.User);
_adminLogger.Add(
LogType.Unanchor,
LogImpact.Low,
$"{EntityManager.ToPrettyString(args.User):user} unanchored {EntityManager.ToPrettyString(uid):anchored} using {EntityManager.ToPrettyString(used):using}"
);
}
private void OnAnchorComplete(EntityUid uid, AnchorableComponent component, TryAnchorCompletedEvent args)
{
if (args.Cancelled || args.Used is not { } used)
return;
var xform = Transform(uid);
if (TryComp<PhysicsComponent>(uid, out var anchorBody) &&
!TileFree(xform.Coordinates, anchorBody))
{
_popup.PopupClient(Loc.GetString("anchorable-occupied"), uid, args.User);
return;
}
// Snap rotation to cardinal (multiple of 90)
var rot = xform.LocalRotation;
xform.LocalRotation = Math.Round(rot / (Math.PI / 2)) * (Math.PI / 2);
if (TryComp<SharedPullableComponent>(uid, out var pullable) && pullable.Puller != null)
{
_pulling.TryStopPull(pullable);
}
// TODO: Anchoring snaps rn anyway!
if (component.Snap)
{
var coordinates = xform.Coordinates.SnapToGrid(EntityManager, _mapManager);
if (AnyUnstackable(uid, coordinates))
{
_popup.PopupClient(Loc.GetString("construction-step-condition-no-unstackable-in-tile"), uid, args.User);
return;
}
_transformSystem.SetCoordinates(uid, coordinates);
}
RaiseLocalEvent(uid, new BeforeAnchoredEvent(args.User, used));
if (!xform.Anchored)
_transformSystem.AnchorEntity(uid, xform);
RaiseLocalEvent(uid, new UserAnchoredEvent(args.User, used));
_popup.PopupClient(Loc.GetString("anchorable-anchored"), uid, args.User);
_adminLogger.Add(
LogType.Anchor,
LogImpact.Low,
$"{EntityManager.ToPrettyString(args.User):user} anchored {EntityManager.ToPrettyString(uid):anchored} using {EntityManager.ToPrettyString(used):using}"
);
}
/// <summary>
/// Tries to toggle the anchored status of this component's owner.
/// override is used due to popup and adminlog being server side systems in this case.
/// </summary>
/// <returns>true if toggled, false otherwise</returns>
public void TryToggleAnchor(EntityUid uid, EntityUid userUid, EntityUid usingUid,
AnchorableComponent? anchorable = null,
TransformComponent? transform = null,
SharedPullableComponent? pullable = null,
ToolComponent? usingTool = null)
{
if (!Resolve(uid, ref transform))
return;
if (transform.Anchored)
{
TryUnAnchor(uid, userUid, usingUid, anchorable, transform, usingTool);
// Log unanchor attempt (server only)
_adminLogger.Add(LogType.Anchor, LogImpact.Low, $"{ToPrettyString(userUid):user} is trying to unanchor {ToPrettyString(uid):entity} from {transform.Coordinates:targetlocation}");
}
else
{
TryAnchor(uid, userUid, usingUid, anchorable, transform, pullable, usingTool);
// Log anchor attempt (server only)
_adminLogger.Add(LogType.Anchor, LogImpact.Low, $"{ToPrettyString(userUid):user} is trying to anchor {ToPrettyString(uid):entity} to {transform.Coordinates:targetlocation}");
}
}
/// <summary>
/// Tries to anchor the entity.
/// </summary>
/// <returns>true if anchored, false otherwise</returns>
private void TryAnchor(EntityUid uid, EntityUid userUid, EntityUid usingUid,
AnchorableComponent? anchorable = null,
TransformComponent? transform = null,
SharedPullableComponent? pullable = null,
ToolComponent? usingTool = null)
{
if (!Resolve(uid, ref anchorable, ref transform))
return;
// Optional resolves.
Resolve(uid, ref pullable, false);
if (!Resolve(usingUid, ref usingTool))
return;
if (!Valid(uid, userUid, usingUid, true, anchorable, usingTool))
return;
if (TryComp<PhysicsComponent>(uid, out var anchorBody) &&
!TileFree(transform.Coordinates, anchorBody))
{
_popup.PopupClient(Loc.GetString("anchorable-occupied"), uid, userUid);
return;
}
if (AnyUnstackable(uid, transform.Coordinates))
{
_popup.PopupClient(Loc.GetString("construction-step-condition-no-unstackable-in-tile"), uid, userUid);
return;
}
_tool.UseTool(usingUid, userUid, uid, anchorable.Delay, usingTool.Qualities, new TryAnchorCompletedEvent());
}
private bool Valid(
EntityUid uid,
EntityUid userUid,
EntityUid usingUid,
bool anchoring,
AnchorableComponent? anchorable = null,
ToolComponent? usingTool = null)
{
if (!Resolve(uid, ref anchorable))
return false;
if (!Resolve(usingUid, ref usingTool))
return false;
BaseAnchoredAttemptEvent attempt =
anchoring ? new AnchorAttemptEvent(userUid, usingUid) : new UnanchorAttemptEvent(userUid, usingUid);
// Need to cast the event or it will be raised as BaseAnchoredAttemptEvent.
if (anchoring)
RaiseLocalEvent(uid, (AnchorAttemptEvent) attempt);
else
RaiseLocalEvent(uid, (UnanchorAttemptEvent) attempt);
anchorable.Delay += attempt.Delay;
return !attempt.Cancelled;
}
private bool TileFree(EntityCoordinates coordinates, PhysicsComponent anchorBody)
{
// Probably ignore CanCollide on the anchoring body?
var gridUid = coordinates.GetGridUid(EntityManager);
if (!_mapManager.TryGetGrid(gridUid, out var grid))
return false;
var tileIndices = grid.TileIndicesFor(coordinates);
return TileFree(grid, tileIndices, anchorBody.CollisionLayer, anchorBody.CollisionMask);
}
/// <summary>
/// Returns true if no hard anchored entities match the collision layer or mask specified.
/// </summary>
/// <param name="grid"></param>
public bool TileFree(MapGridComponent grid, Vector2i gridIndices, int collisionLayer = 0, int collisionMask = 0)
{
var enumerator = grid.GetAnchoredEntitiesEnumerator(gridIndices);
while (enumerator.MoveNext(out var ent))
{
if (!_physicsQuery.TryGetComponent(ent, out var body) ||
!body.CanCollide ||
!body.Hard)
{
continue;
}
if ((body.CollisionMask & collisionLayer) != 0x0 ||
(body.CollisionLayer & collisionMask) != 0x0)
{
return false;
}
}
return true;
}
/// <summary>
/// Returns true if any unstackables are also on the corresponding tile.
/// </summary>
public bool AnyUnstackable(EntityUid uid, EntityCoordinates location)
{
DebugTools.Assert(!Transform(uid).Anchored);
// If we are unstackable, iterate through any other entities anchored on the current square
return _tagSystem.HasTag(uid, Unstackable, _tagQuery) && AnyUnstackablesAnchoredAt(location);
}
public bool AnyUnstackablesAnchoredAt(EntityCoordinates location)
{
var gridUid = location.GetGridUid(EntityManager);
if (!TryComp<MapGridComponent>(gridUid, out var grid))
return false;
var enumerator = grid.GetAnchoredEntitiesEnumerator(grid.LocalToTile(location));
while (enumerator.MoveNext(out var entity))
{
// If we find another unstackable here, return true.
if (_tagSystem.HasTag(entity.Value, Unstackable, _tagQuery))
{
return true;
}
}
return false;
}
[Serializable, NetSerializable]
private sealed class TryUnanchorCompletedEvent : SimpleDoAfterEvent
{
}
[Serializable, NetSerializable]
private sealed class TryAnchorCompletedEvent : SimpleDoAfterEvent
{
}
}

97
Content.Shared/Construction/EntitySystems/SharedAnchorableSystem.cs
View File

@@ -1,97 +0,0 @@
using Content.Shared.Construction.Components;
using Content.Shared.Containers.ItemSlots;
using Content.Shared.DoAfter;
using Content.Shared.Interaction;
using Content.Shared.Pulling.Components;
using Content.Shared.Tag;
using Content.Shared.Tools.Components;
using Robust.Shared.Map;
using Robust.Shared.Map.Components;
using Robust.Shared.Serialization;
namespace Content.Shared.Construction.EntitySystems;
public abstract class SharedAnchorableSystem : EntitySystem
{
[Dependency] private readonly TagSystem _tagSystem = default!;
protected EntityQuery<TagComponent> TagQuery;
public const string Unstackable = "Unstackable";
public override void Initialize()
{
base.Initialize();
TagQuery = GetEntityQuery<TagComponent>();
SubscribeLocalEvent<AnchorableComponent, InteractUsingEvent>(OnInteractUsing,
before: new[] { typeof(ItemSlotsSystem) }, after: new[] { typeof(SharedConstructionSystem) });
}
private void OnInteractUsing(EntityUid uid, AnchorableComponent anchorable, InteractUsingEvent args)
{
if (args.Handled)
return;
// If the used entity doesn't have a tool, return early.
if (!TryComp(args.Used, out ToolComponent? usedTool) || !usedTool.Qualities.Contains(anchorable.Tool))
return;
args.Handled = true;
TryToggleAnchor(uid, args.User, args.Used, anchorable, usingTool: usedTool);
}
public virtual void TryToggleAnchor(EntityUid uid, EntityUid userUid, EntityUid usingUid,
AnchorableComponent? anchorable = null,
TransformComponent? transform = null,
SharedPullableComponent? pullable = null,
ToolComponent? usingTool = null)
{
// Thanks tool system.
// TODO tool system is fixed now, make this actually shared.
}
public bool AnyUnstackablesAnchoredAt(EntityCoordinates location)
{
var gridUid = location.GetGridUid(EntityManager);
if (!TryComp<MapGridComponent>(gridUid, out var grid))
return false;
var enumerator = grid.GetAnchoredEntitiesEnumerator(grid.LocalToTile(location));
while (enumerator.MoveNext(out var entity))
{
// If we find another unstackable here, return true.
if (_tagSystem.HasTag(entity.Value, Unstackable, TagQuery))
{
return true;
}
}
return false;
}
public bool AnyUnstackable(EntityUid uid, EntityCoordinates location)
{
// If we are unstackable, iterate through any other entities anchored on the current square
if (_tagSystem.HasTag(uid, Unstackable, TagQuery))
{
return AnyUnstackablesAnchoredAt(location);
}
return false;
}
[Serializable, NetSerializable]
protected sealed class TryUnanchorCompletedEvent : SimpleDoAfterEvent
{
}
[Serializable, NetSerializable]
protected sealed class TryAnchorCompletedEvent : SimpleDoAfterEvent
{
}
}

2
Content.Server/Coordinates/Helpers/SnapgridHelper.cs → Content.Shared/Coordinates/Helpers/SnapgridHelper.cs
View File

@@ -1,7 +1,7 @@
using Robust.Shared.Map;
using Robust.Shared.Map.Components;
namespace Content.Server.Coordinates.Helpers
namespace Content.Shared.Coordinates.Helpers
{
public static class SnapgridHelper
{