});
// Can't insert, unanchored and unpowered
- xformSystem.Unanchor(unitUid, entityManager.GetComponent<TransformComponent>(unitUid));
+ xformSystem.Unanchor((unitUid, entityManager.GetComponent<TransformComponent>(unitUid)));
UnitInsertContains(disposalUnit, unitComponent, false, disposalSystem, human, wrench, disposalUnit, disposalTrunk);
});
await server.WaitAssertion(() =>
{
// Anchor the disposal unit
- xformSystem.AnchorEntity(unitUid, entityManager.GetComponent<TransformComponent>(unitUid));
+ xformSystem.AnchorEntity((unitUid, entityManager.GetComponent<TransformComponent>(unitUid)));
// No power
Assert.That(unitComponent.Powered, Is.False);
{
var xform = Transform(args.Target);
var fixtures = Comp<FixturesComponent>(args.Target);
- xform.Anchored = false; // Just in case.
+ _transformSystem.Unanchor((args.Target, xform)); // Just in case.
_physics.SetBodyType(args.Target, BodyType.Dynamic, manager: fixtures, body: physics);
_physics.SetBodyStatus(args.Target, physics, BodyStatus.InAir);
_physics.WakeBody(args.Target, manager: fixtures, body: physics);
{
var xform = Transform(args.Target);
var fixtures = Comp<FixturesComponent>(args.Target);
- xform.Anchored = false; // Just in case.
+ _transformSystem.Unanchor((args.Target, xform));
_physics.SetBodyType(args.Target, BodyType.Dynamic, body: physics);
_physics.SetBodyStatus(args.Target, physics, BodyStatus.InAir);
if (HasComp<AnchorableComponent>(ent) && CheckOverlap(ent))
{
_popup.PopupEntity(Loc.GetString("pipe-restrict-overlap-popup-blocked", ("pipe", ent.Owner)), ent);
- _xform.Unanchor(ent, Transform(ent));
+ _xform.Unanchor((ent, Transform(ent)));
}
}
var item = Spawn(order.ProductId, spawn);
// Ensure the item doesn't start anchored
- _transformSystem.Unanchor(item, Transform(item));
+ _transformSystem.Unanchor((item, Transform(item)));
// Create a sheet of paper to write the order details on
var printed = EntityManager.SpawnEntity(paperProto, spawn);
public void PerformAction(EntityUid uid, EntityUid? userUid, IEntityManager entityManager)
{
- var transform = entityManager.GetComponent<TransformComponent>(uid);
- transform.Anchored = Value;
+ var transformSystem = entityManager.System<SharedTransformSystem>();
+ transformSystem.TrySetAnchor(uid, Value);
}
}
}
var newTransform = Transform(newUid);
TransformSystem.AttachToGridOrMap(newUid, newTransform); // in case in hands or a container
newTransform.LocalRotation = transform.LocalRotation;
- newTransform.Anchored = transform.Anchored;
+ TransformSystem.SetAnchor((newUid, newTransform), transform.Anchored);
// Container transferring.
if (containerManager != null)
var xform = Transform(uid);
if (!xform.Anchored)
- _transform.AnchorEntity(uid, xform);
+ _transform.AnchorEntity((uid, xform));
SetBolt(comp, true);
SetActivated(comp, true);
comp.Bolted = false;
if (xform.Anchored)
- _transform.Unanchor(uid, xform);
+ _transform.Unanchor((uid, xform));
_appearance.SetData(uid, DefusableVisuals.Active, comp.Activated);
}
if (xform.Anchored)
return;
- _transformSystem.AnchorEntity(uid, xform);
+ _transformSystem.AnchorEntity((uid, xform));
if (component.RemoveOnTrigger)
RemCompDeferred<AnchorOnTriggerComponent>(uid);
var holoUid = EntityManager.SpawnEntity(component.SignProto, args.ClickLocation.SnapToGrid(EntityManager));
var xform = Transform(holoUid);
if (!xform.Anchored)
- _transform.AnchorEntity(holoUid, xform); // anchor to prevent any tempering with (don't know what could even interact with it)
+ _transform.AnchorEntity((holoUid, xform)); // anchor to prevent any tempering with (don't know what could even interact with it)
args.Handled = true;
}
var xform = Transform(uid);
if (xform.Anchored)
{
- _transform.Unanchor(uid, xform);
+ _transform.Unanchor((uid, xform));
_itemSlots.SetLock(uid, component.DiskSlot, true);
}
else
}
_transform.SetCoordinates(uid, xform, xform.Coordinates.SnapToGrid());
- _transform.AnchorEntity(uid, xform);
+ _transform.AnchorEntity((uid, xform));
_itemSlots.SetLock(uid, component.DiskSlot, false);
}
if (!nukeXform.Anchored)
{
// Admin command shenanigans, just make sure.
- _transform.AnchorEntity(uid, nukeXform);
+ _transform.AnchorEntity((uid, nukeXform));
}
component.Status = NukeStatus.ARMED;
if (reservedTiles.Contains(node))
continue;
-
+
if (dunGen.TileMask is not null)
{
if (!dunGen.TileMask.Contains(((ContentTileDefinition) _tileDefManager[tileRef.Value.Tile.TypeId]).ID))
if (!xform.Comp.Anchored)
{
- _transform.AnchorEntity(ent, xform);
+ _transform.AnchorEntity((ent, xform));
}
// TODO: Engine bug with SpawnAtPosition
var xform = xformQuery.Get(ent);
if (!xform.Comp.Anchored)
- _transform.AnchorEntity(ent, xform);
+ _transform.AnchorEntity((ent, xform));
await SuspendDungeon();
if (!ValidateResume())
if (anchored && !childXform.Anchored)
_transform.AnchorEntity((ent, childXform), (gridUid, grid));
else if (!anchored && childXform.Anchored)
- _transform.Unanchor(ent, childXform);
+ _transform.Unanchor((ent, childXform));
}
// Load decals
[Dependency] private readonly PopupSystem _popup = default!;
[Dependency] private readonly ActionBlockerSystem _actionBlocker = default!;
[Dependency] private readonly SharedInteractionSystem _interaction = default!;
+ [Dependency] private readonly SharedTransformSystem _transform = default!;
public override void Initialize()
{
var entity = EntityManager.SpawnEntity(component.MirrorEntity, oldTransform.Coordinates);
var newTransform = EntityManager.GetComponent<TransformComponent>(entity);
newTransform.LocalRotation = oldTransform.LocalRotation;
- newTransform.Anchored = false;
+ _transform.Unanchor((entity, newTransform));
EntityManager.DeleteEntity(uid);
}
}
//Don't allow someone to block if they're somehow not anchored.
- _transformSystem.AnchorEntity(user, xform);
+ _transformSystem.AnchorEntity((user, xform));
if (!xform.Anchored)
{
CantBlockError(user);
&& TryComp<PhysicsComponent>(user, out var physicsComponent))
{
if (xform.Anchored)
- _transformSystem.Unanchor(user, xform);
+ _transformSystem.Unanchor((user, xform));
_actionsSystem.SetToggled(component.BlockingToggleActionEntity, false);
_fixtureSystem.DestroyFixture(user, BlockingComponent.BlockFixtureID, body: physicsComponent);
var xform = Transform(uid);
RaiseLocalEvent(uid, new BeforeUnanchoredEvent(args.User, used));
- _transformSystem.Unanchor(uid, xform);
+ _transformSystem.Unanchor((uid, xform));
RaiseLocalEvent(uid, new UserUnanchoredEvent(args.User, used));
_popup.PopupClient(Loc.GetString("anchorable-unanchored"), uid, args.User);
RaiseLocalEvent(uid, new BeforeAnchoredEvent(args.User, used));
if (!xform.Anchored)
- _transformSystem.AnchorEntity(uid, xform);
+ _transformSystem.AnchorEntity((uid, xform));
RaiseLocalEvent(uid, new UserAnchoredEvent(args.User, used));
{
public abstract class SharedConstructionSystem : EntitySystem
{
- [Dependency] private readonly IMapManager _mapManager = default!;
+ [Dependency] protected readonly IMapManager MapManager = default!;
[Dependency] protected readonly IPrototypeManager PrototypeManager = default!;
[Dependency] protected readonly SharedTransformSystem TransformSystem = default!;
if (!canBuildInImpassable)
return null;
- if (!_mapManager.TryFindGridAt(coords, out _, out var grid))
+ if (!MapManager.TryFindGridAt(coords, out _, out var grid))
return null;
var ignored = grid.GetAnchoredEntities(coords).ToHashSet();
var xform = Transform(ev.Target);
var fixture = fixtures.Fixtures.First();
- _transform.Unanchor(ev.Target);
+ _transform.Unanchor((ev.Target, xform));
_physics.SetCanCollide(ev.Target, true, true, false, fixtures, physics);
_physics.SetCollisionMask(ev.Target, fixture.Key, fixture.Value, (int)CollisionGroup.FlyingMobMask, fixtures, physics);
_physics.SetCollisionLayer(ev.Target, fixture.Key, fixture.Value, (int)CollisionGroup.FlyingMobLayer, fixtures, physics);
var xform = Transform(uid);
if (xform.Anchored)
- _xform.Unanchor(uid, xform);
+ _xform.Unanchor((uid, xform));
else
_xform.AnchorEntity((uid, xform));
var xform = Transform(ent);
xform.NoLocalRotation = false;
- _xform.Unanchor(ent, xform);
+ _xform.Unanchor((ent, xform));
Del(ent.Comp.Disguise);
RemComp<ChameleonDisguisedComponent>(ent);
if (isDeployed && transform.GridUid != null)
{
- _transform.AnchorEntity(uid, transform);
+ _transform.AnchorEntity((uid, transform));
if (fixture != null)
_physics.SetHard(uid, fixture, true);
}
else
{
- _transform.Unanchor(uid, transform);
+ _transform.Unanchor((uid, transform));
if (fixture != null)
_physics.SetHard(uid, fixture, false);
}
if (comp.UnanchorOnHit && HasComp<AnchorableComponent>(hit))
{
- _transform.Unanchor(hit, Transform(hit));
+ _transform.Unanchor((hit, Transform(hit)));
}
RemComp<MeleeThrownComponent>(hit);
_appearance.SetData(gunUid, ToggleableLightVisuals.Enabled, true, appearance);
// Target updates
- TransformSystem.Unanchor(target, targetXform);
+ TransformSystem.Unanchor((target, targetXform));
component.Tethered = target;
var tethered = EnsureComp<TetheredComponent>(target);
_physics.SetBodyStatus(target, targetPhysics, BodyStatus.InAir, false);
projects / space-station-14.git / commitdiff