[Dependency] private readonly IPlayerManager _playerManager = default!;
[Dependency] private readonly IPrototypeManager _prototypeManager = default!;
[Dependency] private readonly SharedInteractionSystem _interactionSystem = default!;
+ [Dependency] private readonly SharedTransformSystem _transformSystem = default!;
[Dependency] private readonly PopupSystem _popupSystem = default!;
private readonly Dictionary<int, EntityUid> _ghosts = new();
return false;
// This InRangeUnobstructed should probably be replaced with "is there something blocking us in that tile?"
- var predicate = GetPredicate(prototype.CanBuildInImpassable, loc.ToMap(EntityManager));
+ var predicate = GetPredicate(prototype.CanBuildInImpassable, loc.ToMap(EntityManager, _transformSystem));
if (!_interactionSystem.InRangeUnobstructed(user, loc, 20f, predicate: predicate))
return false;
if (_combatMode.IsInCombatMode(args.Session?.AttachedEntity))
return false;
- var coords = args.Coordinates.ToMap(_entityManager);
+ var coords = args.Coordinates.ToMap(_entityManager, _xform);
if (_verbSystem.TryGetEntityMenuEntities(coords, out var entities))
OpenRootMenu(entities);
public IEnumerable<EntityUid> GetClickableEntities(EntityCoordinates coordinates)
{
- return GetClickableEntities(coordinates.ToMap(_entityManager));
+ return GetClickableEntities(coordinates.ToMap(_entityManager, _entitySystemManager.GetEntitySystem<SharedTransformSystem>()));
}
public IEnumerable<EntityUid> GetClickableEntities(MapCoordinates coordinates)
[Dependency] private readonly IResourceCache _cache = default!;
[Dependency] private readonly NPCSteeringSystem _steering = default!;
[Dependency] private readonly MapSystem _mapSystem = default!;
+ [Dependency] private readonly SharedTransformSystem _transformSystem = default!;
public PathfindingDebugMode Modes
{
}
else if (!overlayManager.HasOverlay<PathfindingOverlay>())
{
- overlayManager.AddOverlay(new PathfindingOverlay(EntityManager, _eyeManager, _inputManager, _mapManager, _cache, this, _mapSystem));
+ overlayManager.AddOverlay(new PathfindingOverlay(EntityManager, _eyeManager, _inputManager, _mapManager, _cache, this, _mapSystem, _transformSystem));
}
if ((value & PathfindingDebugMode.Steering) != 0x0)
private readonly IMapManager _mapManager;
private readonly PathfindingSystem _system;
private readonly MapSystem _mapSystem;
+ private readonly SharedTransformSystem _transformSystem;
public override OverlaySpace Space => OverlaySpace.ScreenSpace | OverlaySpace.WorldSpace;
IMapManager mapManager,
IResourceCache cache,
PathfindingSystem system,
- MapSystem mapSystem)
+ MapSystem mapSystem,
+ SharedTransformSystem transformSystem)
{
_entManager = entManager;
_eyeManager = eyeManager;
_mapManager = mapManager;
_system = system;
_mapSystem = mapSystem;
+ _transformSystem = transformSystem;
_font = new VectorFont(cache.GetResource<FontResource>("/Fonts/NotoSans/NotoSans-Regular.ttf"), 10);
}
if (neighborPoly.NetEntity != poly.GraphUid)
{
color = Color.Green;
- var neighborMap = _entManager.GetCoordinates(neighborPoly).ToMap(_entManager);
+ var neighborMap = _entManager.GetCoordinates(neighborPoly).ToMap(_entManager, _transformSystem);
if (neighborMap.MapId != args.MapId)
continue;
private readonly PopupSystem _popup;
private readonly PopupUIController _controller;
private readonly ExamineSystemShared _examine;
-
+ private readonly SharedTransformSystem _transform;
private readonly ShaderInstance _shader;
public override OverlaySpace Space => OverlaySpace.ScreenSpace;
IUserInterfaceManager uiManager,
PopupUIController controller,
ExamineSystemShared examine,
+ SharedTransformSystem transform,
PopupSystem popup)
{
_configManager = configManager;
_playerMgr = playerMgr;
_uiManager = uiManager;
_examine = examine;
+ _transform = transform;
_popup = popup;
_controller = controller;
foreach (var popup in _popup.WorldLabels)
{
- var mapPos = popup.InitialPos.ToMap(_entManager);
+ var mapPos = popup.InitialPos.ToMap(_entManager, _transform);
if (mapPos.MapId != args.MapId)
continue;
[Dependency] private readonly IUserInterfaceManager _uiManager = default!;
[Dependency] private readonly IReplayRecordingManager _replayRecording = default!;
[Dependency] private readonly ExamineSystemShared _examine = default!;
+ [Dependency] private readonly SharedTransformSystem _transform = default!;
public IReadOnlyList<WorldPopupLabel> WorldLabels => _aliveWorldLabels;
public IReadOnlyList<CursorPopupLabel> CursorLabels => _aliveCursorLabels;
_uiManager,
_uiManager.GetUIController<PopupUIController>(),
_examine,
+ _transform,
this));
}
private bool PulseQualifies(EntityUid pulseEntity, MapCoordinates currentEyeLoc)
{
- return _entityManager.GetComponent<TransformComponent>(pulseEntity).MapID == currentEyeLoc.MapId && _entityManager.GetComponent<TransformComponent>(pulseEntity).Coordinates.InRange(_entityManager, EntityCoordinates.FromMap(_entityManager, _entityManager.GetComponent<TransformComponent>(pulseEntity).ParentUid, currentEyeLoc), MaxDist);
+ var transformComponent = _entityManager.GetComponent<TransformComponent>(pulseEntity);
+ var transformSystem = _entityManager.System<SharedTransformSystem>();
+ return transformComponent.MapID == currentEyeLoc.MapId
+ && transformComponent.Coordinates.InRange(_entityManager, transformSystem, EntityCoordinates.FromMap(transformComponent.ParentUid, currentEyeLoc, transformSystem, _entityManager), MaxDist);
}
private sealed record RadiationShaderInstance(MapCoordinates CurrentMapCoords, float Range, TimeSpan Start, float Duration)
[Dependency] private readonly IMapManager _map = default!;
[Dependency] private readonly IPlacementManager _placement = default!;
[Dependency] private readonly ContentEyeSystem _contentEye = default!;
+ [Dependency] private readonly SharedTransformSystem _transform = default!;
private bool _sandboxEnabled;
public bool SandboxAllowed { get; private set; }
}
// Try copy tile.
- if (!_map.TryFindGridAt(coords.ToMap(EntityManager), out _, out var grid) || !grid.TryGetTileRef(coords, out var tileRef))
+ if (!_map.TryFindGridAt(coords.ToMap(EntityManager, _transform), out _, out var grid) || !grid.TryGetTileRef(coords, out var tileRef))
return false;
if (_placement.Eraser)
// TODO: Technically these directions won't be correct but uhh I'm just here for optimisations buddy not to fix my old bugs.
if (throwTarget != EntityCoordinates.Invalid)
{
- var pos = ((throwTarget.ToMap(EntityManager).Position - xform.WorldPosition).Normalized() + dirVec).Normalized();
+ var pos = ((throwTarget.ToMap(EntityManager, _transformSystem).Position - xform.WorldPosition).Normalized() + dirVec).Normalized();
_physics.ApplyLinearImpulse(uid, pos * moveForce, body: physics);
}
else
[UsedImplicitly]
internal sealed class VaporSystem : EntitySystem
{
- [Dependency] private readonly IMapManager _mapManager = default!;
[Dependency] private readonly IPrototypeManager _protoManager = default!;
+ [Dependency] private readonly SharedMapSystem _map = default!;
[Dependency] private readonly SharedPhysicsSystem _physics = default!;
[Dependency] private readonly SolutionContainerSystem _solutionContainerSystem = default!;
[Dependency] private readonly ThrowingSystem _throwing = default!;
{
vapor.ReactTimer = 0;
- var tile = gridComp.GetTileRef(xform.Coordinates.ToVector2i(EntityManager, _mapManager));
+ var tile = _map.GetTileRef(xform.GridUid.Value, gridComp, xform.Coordinates);
foreach (var reagentQuantity in contents.Contents.ToArray())
{
if (reagentQuantity.Quantity == FixedPoint2.Zero) continue;
if (transform.GridUid == null)
return false;
- var indices = transform.Coordinates.ToVector2i(entityManager, IoCManager.Resolve<IMapManager>());
+ var transformSys = entityManager.System<SharedTransformSystem>();
+ var indices = transform.Coordinates.ToVector2i(entityManager, IoCManager.Resolve<IMapManager>(), transformSys);
var lookup = entityManager.EntitySysManager.GetEntitySystem<EntityLookupSystem>();
var entities = indices.GetEntitiesInTile(transform.GridUid.Value, LookupFlags.Approximate | LookupFlags.Static, lookup);
using System.Linq;
using System.Threading.Tasks;
using Content.Server.Construction.Components;
-using Content.Server.Storage.EntitySystems;
using Content.Shared.ActionBlocker;
using Content.Shared.Construction;
using Content.Shared.Construction.Prototypes;
using Content.Shared.Interaction;
using Content.Shared.Inventory;
using Content.Shared.Storage;
-using Content.Shared.Tag;
using Robust.Shared.Containers;
using Robust.Shared.Player;
using Robust.Shared.Timing;
[Dependency] private readonly ActionBlockerSystem _actionBlocker = default!;
[Dependency] private readonly SharedHandsSystem _handsSystem = default!;
[Dependency] private readonly EntityLookupSystem _lookupSystem = default!;
- [Dependency] private readonly StorageSystem _storageSystem = default!;
- [Dependency] private readonly TagSystem _tagSystem = default!;
+ [Dependency] private readonly SharedTransformSystem _transformSystem = default!;
// --- WARNING! LEGACY CODE AHEAD! ---
// This entire file contains the legacy code for initial construction.
return;
}
- var mapPos = location.ToMap(EntityManager);
+ var mapPos = location.ToMap(EntityManager, _transformSystem);
var predicate = GetPredicate(constructionPrototype.CanBuildInImpassable, mapPos);
if (!_interactionSystem.InRangeUnobstructed(user, mapPos, predicate: predicate))
[Dependency] private readonly RoleSystem _role = default!;
[Dependency] private readonly SharedActionsSystem _actions = default!;
[Dependency] private readonly SharedAudioSystem _audio = default!;
+ [Dependency] private readonly SharedTransformSystem _transform = default!;
private EntityQuery<CarpRiftsConditionComponent> _objQuery;
// cant stack rifts near eachother
foreach (var (_, riftXform) in EntityQuery<DragonRiftComponent, TransformComponent>(true))
{
- if (riftXform.Coordinates.InRange(EntityManager, xform.Coordinates, RiftRange))
+ if (riftXform.Coordinates.InRange(EntityManager, _transform, xform.Coordinates, RiftRange))
{
_popup.PopupEntity(Loc.GetString("carp-rift-proximity", ("proximity", RiftRange)), uid, uid);
return;
CameraShake(iterationIntensity.Count * 4f, epicenter, totalIntensity);
//For whatever bloody reason, sound system requires ENTITY coordinates.
- var mapEntityCoords = EntityCoordinates.FromMap(EntityManager, _mapManager.GetMapEntityId(epicenter.MapId), epicenter);
+ var mapEntityCoords = EntityCoordinates.FromMap(_mapManager.GetMapEntityId(epicenter.MapId), epicenter, _transformSystem, EntityManager);
// play sound.
// for the normal audio, we want everyone in pvs range
// Ideally engine would just spawn them on grid directly I guess? Right now grid traversal is handling it during
// update which means we need to add a hack somewhere around it.
var spawn = _robustRandom.Pick(_possiblePositions);
- var toMap = spawn.ToMap(EntityManager);
+ var toMap = spawn.ToMap(EntityManager, _transform);
if (_mapManager.TryFindGridAt(toMap, out var gridUid, out _))
{
[Dependency] private readonly SharedAudioSystem _audio = default!;
[Dependency] private readonly BodySystem _bodySystem = default!;
[Dependency] private readonly SharedContainerSystem _container = default!;
+ [Dependency] private readonly SharedTransformSystem _transform = default!;
public override void Initialize()
{
if (!guardianComponent.GuardianLoose)
return;
- if (!guardianXform.Coordinates.InRange(EntityManager, hostXform.Coordinates, guardianComponent.DistanceAllowed))
+ if (!guardianXform.Coordinates.InRange(EntityManager, _transform, hostXform.Coordinates, guardianComponent.DistanceAllowed))
RetractGuardian(hostUid, hostComponent, guardianUid, guardianComponent);
}
[Dependency] private readonly VirtualItemSystem _virtualItemSystem = default!;
[Dependency] private readonly ActionBlockerSystem _actionBlockerSystem = default!;
[Dependency] private readonly SharedHandsSystem _handsSystem = default!;
+ [Dependency] private readonly SharedTransformSystem _transformSystem = default!;
[Dependency] private readonly PullingSystem _pullingSystem = default!;
[Dependency] private readonly ThrowingSystem _throwingSystem = default!;
throwEnt = splitStack.Value;
}
- var direction = coordinates.ToMapPos(EntityManager) - Transform(player).WorldPosition;
+ var direction = coordinates.ToMapPos(EntityManager, _transformSystem) - Transform(player).WorldPosition;
if (direction == Vector2.Zero)
return true;
return;
var xform = Transform(ent);
- var entityCoords = xform.Coordinates.ToMap(EntityManager);
+ var entityCoords = xform.Coordinates.ToMap(EntityManager, _xform);
// try to find a valid position to teleport to, teleport to whatever works if we can't
var targetCoords = new MapCoordinates();
foreach (var pos in GetSpawnPositions(xform, ev.Pos))
{
// If applicable, this ensures the projectile is parented to grid on spawn, instead of the map.
- var mapPos = pos.ToMap(EntityManager);
+ var mapPos = pos.ToMap(EntityManager, _transformSystem);
var spawnCoords = _mapManager.TryFindGridAt(mapPos, out var gridUid, out _)
? pos.WithEntityId(gridUid, EntityManager)
: new(_mapManager.GetMapEntityId(mapPos.MapId), mapPos.Position);
if (!blackboard.TryGetValue<EntityCoordinates>(TargetKey, out var target, _entManager))
return false;
- return coordinates.InRange(_entManager, target, blackboard.GetValueOrDefault<float>(RangeKey, _entManager));
+ return coordinates.InRange(_entManager, _entManager.System<SharedTransformSystem>(), target, blackboard.GetValueOrDefault<float>(RangeKey, _entManager));
}
}
if (!blackboard.TryGetValue<EntityCoordinates>(TargetKey, out var target, _entManager))
return false;
- return !coordinates.InRange(_entManager, target, blackboard.GetValueOrDefault<float>(RangeKey, _entManager));
+ return !coordinates.InRange(_entManager, _entManager.System<SharedTransformSystem>(), target, blackboard.GetValueOrDefault<float>(RangeKey, _entManager));
}
}
!_entManager.TryGetComponent<TransformComponent>(target, out var targetXform))
return false;
- return coordinates.InRange(_entManager, targetXform.Coordinates, blackboard.GetValueOrDefault<float>(RangeKey, _entManager));
+ return coordinates.InRange(_entManager, _entManager.System<SharedTransformSystem>(), targetXform.Coordinates, blackboard.GetValueOrDefault<float>(RangeKey, _entManager));
}
}
return null;
}
- var localPos = xform.InvWorldMatrix.Transform(coordinates.ToMapPos(EntityManager));
+ var localPos = xform.InvWorldMatrix.Transform(coordinates.ToMapPos(EntityManager, _transform));
var origin = GetOrigin(localPos);
if (!TryGetChunk(origin, comp, out var chunk))
[Dependency] private readonly SharedPopupSystem _popup = default!;
[Dependency] private readonly VisibilitySystem _visibilitySystem = default!;
[Dependency] private readonly SharedMindSystem _minds = default!;
+ [Dependency] private readonly SharedTransformSystem _transform = default!;
[Dependency] private readonly IAdminLogManager _adminLogger = default!;
[Dependency] private readonly ExamineSystemShared _examine = default!;
{
if (HasComp<GhostComponent>(pointer))
{
- return Transform(pointer).Coordinates.InRange(EntityManager, coordinates, 15);
+ return Transform(pointer).Coordinates.InRange(EntityManager, _transform, coordinates, 15);
}
else
{
return false;
}
- var mapCoordsPointed = coordsPointed.ToMap(EntityManager);
+ var mapCoordsPointed = coordsPointed.ToMap(EntityManager, _transform);
_rotateToFaceSystem.TryFaceCoordinates(player, mapCoordsPointed.Position);
var arrow = EntityManager.SpawnEntity("PointingArrow", coordsPointed);
if (TryComp<PointingArrowComponent>(arrow, out var pointing))
{
if (TryComp(player, out TransformComponent? xformPlayer))
- pointing.StartPosition = EntityCoordinates.FromMap(arrow, xformPlayer.Coordinates.ToMap(EntityManager)).Position;
+ pointing.StartPosition = EntityCoordinates.FromMap(arrow, xformPlayer.Coordinates.ToMap(EntityManager, _transform), _transform).Position;
pointing.EndTime = _gameTiming.CurTime + PointDuration;
[Dependency] private readonly ITileDefinitionManager _tileDefinitionManager = default!;
[Dependency] private readonly AtmosphereSystem _atmosphere = default!;
[Dependency] private readonly IRobustRandom _random = default!;
+ [Dependency] private readonly SharedTransformSystem _transform = default!;
[Dependency] private readonly TurfSystem _turf = default!;
[Dependency] private readonly IChatManager _chat = default!;
private void Respawn(EntityUid oldEntity, string prototype, EntityCoordinates coords)
{
var entity = Spawn(prototype, coords);
- _adminLog.Add(LogType.Respawn, LogImpact.High, $"{ToPrettyString(oldEntity)} was deleted and was respawned at {coords.ToMap(EntityManager)} as {ToPrettyString(entity)}");
+ _adminLog.Add(LogType.Respawn, LogImpact.High, $"{ToPrettyString(oldEntity)} was deleted and was respawned at {coords.ToMap(EntityManager, _transform)} as {ToPrettyString(entity)}");
_chat.SendAdminAlert($"{MetaData(oldEntity).EntityName} was deleted and was respawned as {ToPrettyString(entity)}");
}
- /// <summary>
+ /// <summary>
/// Try to find a random safe tile on the supplied grid
/// </summary>
/// <param name="targetGrid">The grid that you're looking for a safe tile on</param>
/// </summary>
public sealed class GravityWellSystem : SharedGravityWellSystem
{
-#region Dependencies
+ #region Dependencies
[Dependency] private readonly IGameTiming _timing = default!;
[Dependency] private readonly IViewVariablesManager _vvManager = default!;
[Dependency] private readonly EntityLookupSystem _lookup = default!;
[Dependency] private readonly SharedPhysicsSystem _physics = default!;
[Dependency] private readonly SharedTransformSystem _transform = default!;
-#endregion Dependencies
+ #endregion Dependencies
/// <summary>
/// The minimum range at which gravpulses will act.
/// <param name="minRange">The minimum distance at which entities can be affected by the gravity pulse.</param>
/// <param name="baseMatrixDeltaV">The base velocity added to any entities within affected by the gravity pulse scaled by the displacement of those entities from the epicenter.</param>
public void GravPulse(EntityCoordinates entityPos, float maxRange, float minRange, in Matrix3 baseMatrixDeltaV)
- => GravPulse(entityPos.ToMap(EntityManager), maxRange, minRange, in baseMatrixDeltaV);
+ => GravPulse(entityPos.ToMap(EntityManager, _transform), maxRange, minRange, in baseMatrixDeltaV);
/// <summary>
/// Greates a gravitational pulse, shoving around all entities within some distance of an epicenter.
/// <param name="baseRadialDeltaV">The base radial velocity that will be added to entities within range towards the center of the gravitational pulse.</param>
/// <param name="baseTangentialDeltaV">The base tangential velocity that will be added to entities within countrclockwise around the center of the gravitational pulse.</param>
public void GravPulse(EntityCoordinates entityPos, float maxRange, float minRange, float baseRadialDeltaV = 0.0f, float baseTangentialDeltaV = 0.0f)
- => GravPulse(entityPos.ToMap(EntityManager), maxRange, minRange, baseRadialDeltaV, baseTangentialDeltaV);
+ => GravPulse(entityPos.ToMap(EntityManager, _transform), maxRange, minRange, baseRadialDeltaV, baseTangentialDeltaV);
/// <summary>
/// Causes a gravitational pulse, shoving around all entities within some distance of an epicenter.
using Content.Server.Power.EntitySystems;
using Content.Server.Singularity.Components;
using Content.Shared.Singularity.Components;
-using Content.Shared.Singularity.EntitySystems;
using Robust.Shared.Map;
-using Robust.Shared.Map.Components;
-using Robust.Shared.Physics;
-using Robust.Shared.Physics.Components;
-using Robust.Shared.Physics.Systems;
using Robust.Shared.Timing;
using System.Numerics;
/// </summary>
public sealed class SingularityAttractorSystem : EntitySystem
{
- [Dependency] private readonly EntityLookupSystem _lookup = default!;
[Dependency] private readonly IGameTiming _timing = default!;
+ [Dependency] private readonly SharedTransformSystem _transform = default!;
/// <summary>
/// The minimum range at which the attraction will act.
attractor.LastPulseTime = _timing.CurTime;
- var mapPos = xform.Coordinates.ToMap(EntityManager);
+ var mapPos = xform.Coordinates.ToMap(EntityManager, _transform);
if (mapPos == MapCoordinates.Nullspace)
return;
var query = EntityQuery<SingularityComponent, RandomWalkComponent, TransformComponent>();
foreach (var (singulo, walk, singuloXform) in query)
{
- var singuloMapPos = singuloXform.Coordinates.ToMap(EntityManager);
+ var singuloMapPos = singuloXform.Coordinates.ToMap(EntityManager, _transform);
if (singuloMapPos.MapId != mapPos.MapId)
continue;
[Dependency] private readonly WeldableSystem _weldableSystem = default!;
[Dependency] private readonly LockSystem _lockSystem = default!;
[Dependency] private readonly SharedDoAfterSystem _doAfterSystem = default!;
+ [Dependency] private readonly SharedTransformSystem _transformSystem = default!;
[Dependency] private readonly ExplosionSystem _explosionSystem = default!;
public override void Initialize()
switch (component.BehaviorProperties.DestroyType)
{
case BluespaceLockerDestroyType.Explode:
- _explosionSystem.QueueExplosion(uid.ToCoordinates().ToMap(EntityManager),
+ _explosionSystem.QueueExplosion(uid.ToCoordinates().ToMap(EntityManager, _transformSystem),
ExplosionSystem.DefaultExplosionPrototypeId, 4, 1, 2, maxTileBreak: 0);
goto case BluespaceLockerDestroyType.Delete;
case BluespaceLockerDestroyType.Delete:
public sealed class NoiseRangeCarverSystem : EntitySystem
{
[Dependency] private readonly NoiseIndexSystem _index = default!;
+ [Dependency] private readonly SharedTransformSystem _transform = default!;
/// <inheritdoc />
public override void Initialize()
private void OnPrePlaceDebris(EntityUid uid, NoiseRangeCarverComponent component,
ref PrePlaceDebrisFeatureEvent args)
{
- var coords = WorldGen.WorldToChunkCoords(args.Coords.ToMapPos(EntityManager));
+ var coords = WorldGen.WorldToChunkCoords(args.Coords.ToMapPos(EntityManager, _transform));
var val = _index.Evaluate(uid, component.NoiseChannel, coords);
foreach (var (low, high) in component.Ranges)
var entManager = IoCManager.Resolve<IEntityManager>();
// get blueprint and user position
+ var transformSystem = entManager.System<SharedTransformSystem>();
var userWorldPosition = entManager.GetComponent<TransformComponent>(user).WorldPosition;
- var objWorldPosition = location.ToMap(entManager).Position;
+ var objWorldPosition = location.ToMap(entManager, transformSystem).Position;
// find direction from user to blueprint
var userToObject = (objWorldPosition - userWorldPosition);
{
var entMan = IoCManager.Resolve<IEntityManager>();
var originPos = entMan.GetComponent<TransformComponent>(origin).MapPosition;
- var otherPos = other.ToMap(entMan);
+ var otherPos = other.ToMap(entMan, _transform);
return InRangeUnOccluded(originPos, otherPos, range, predicate, ignoreInsideBlocker);
}
&& (itemPos.Position - xform.MapPosition.Position).Length() <= MaxAnimationRange
&& MetaData(entity).VisibilityMask == MetaData(uid).VisibilityMask) // Don't animate aghost pickups.
{
- var initialPosition = EntityCoordinates.FromMap(coordinateEntity, itemPos, EntityManager);
+ var initialPosition = EntityCoordinates.FromMap(coordinateEntity, itemPos, TransformSystem, EntityManager);
_storage.PlayPickupAnimation(entity, initialPosition, xform.Coordinates, itemXform.LocalRotation, uid);
}
}
return false;
if (!HasComp<NoRotateOnInteractComponent>(user))
- _rotateToFaceSystem.TryFaceCoordinates(user, coordinates.ToMapPos(EntityManager));
+ _rotateToFaceSystem.TryFaceCoordinates(user, coordinates.ToMapPos(EntityManager, _transform));
return true;
}
Ignored combinedPredicate = e => e == origin || (predicate?.Invoke(e) ?? false);
var inRange = true;
MapCoordinates originPos = default;
- var targetPos = otherCoordinates.ToMap(EntityManager);
+ var targetPos = otherCoordinates.ToMap(EntityManager, _transform);
Angle targetRot = default;
// So essentially:
Ignored? predicate = null,
bool popup = false)
{
- return InRangeUnobstructed(origin, other.ToMap(EntityManager), range, collisionMask, predicate, popup);
+ return InRangeUnobstructed(origin, other.ToMap(EntityManager, _transform), range, collisionMask, predicate, popup);
}
/// <summary>
SharedPhysicsSystem? physicsManager = null)
{
physicsManager ??= entityManager.System<SharedPhysicsSystem>();
- var mapCoordinates = coordinates.ToMap(entityManager);
+ var mapCoordinates = coordinates.ToMap(entityManager, entityManager.System<SharedTransformSystem>());
return entityManager.SpawnIfUnobstructed(prototypeName, mapCoordinates, collisionLayer, box, physicsManager);
}
projects / space-station-14.git / commitdiff