[Dependency] private readonly IEyeManager _eyeManager = default!;
[Dependency] private readonly IEntityManager _entityManager = default!;
[Dependency] protected readonly IConfigurationManager ConfigManager = default!;
+ private readonly SharedTransformSystem _transformSystem;
public enum SpeechType : byte
{
{
IoCManager.InjectDependencies(this);
_senderEntity = senderEntity;
+ _transformSystem = _entityManager.System<SharedTransformSystem>();
// Use text clipping so new messages don't overlap old ones being pushed up.
RectClipContent = true;
}
var offset = (-_eyeManager.CurrentEye.Rotation).ToWorldVec() * -EntityVerticalOffset;
- var worldPos = xform.WorldPosition + offset;
+ var worldPos = _transformSystem.GetWorldPosition(xform) + offset;
var lowerCenter = _eyeManager.WorldToScreen(worldPos) / UIScale;
var screenPos = lowerCenter - new Vector2(ContentSize.X / 2, ContentSize.Y + _verticalOffsetAchieved);
[Dependency] private readonly IRobustRandom _robustRandom = default!;
[Dependency] private readonly IEntityManager _entMan = default!;
[Dependency] private readonly IPrototypeManager _proto = default!;
+ private readonly SharedTransformSystem _transformSystem;
private SharedAppearanceSystem _appearance;
public override OverlaySpace Space => OverlaySpace.WorldSpaceBelowFOV;
{
IoCManager.InjectDependencies(this);
_shader = _proto.Index<ShaderPrototype>("unshaded").Instance();
+ _transformSystem = _entMan.System<SharedTransformSystem>();
_appearance = appearanceSystem;
}
continue;
var xform = xforms.GetComponent(gridId);
- var (_, _, worldMatrix, invWorldMatrix) = xform.GetWorldPositionRotationMatrixWithInv(xforms);
+ var (_, _, worldMatrix, invWorldMatrix) = _transformSystem.GetWorldPositionRotationMatrixWithInv(xform, xforms);
gridBounds = invWorldMatrix.TransformBox(worldBounds).Enlarged(grid.TileSize * 2);
drawHandle.SetTransform(worldMatrix);
[Dependency] private readonly IEntityManager _entityManager = default!;
[Dependency] private readonly IEntitySystemManager _entitySystemManager = default!;
private readonly PuddleDebugOverlaySystem _debugOverlaySystem;
+ private readonly SharedTransformSystem _transformSystem;
private readonly Color _heavyPuddle = new(0, 255, 255, 50);
private readonly Color _mediumPuddle = new(0, 150, 255, 50);
_debugOverlaySystem = _entitySystemManager.GetEntitySystem<PuddleDebugOverlaySystem>();
var cache = IoCManager.Resolve<IResourceCache>();
_font = new VectorFont(cache.GetResource<FontResource>("/Fonts/NotoSans/NotoSans-Regular.ttf"), 8);
+ _transformSystem = _entityManager.System<SharedTransformSystem>();
}
protected override void Draw(in OverlayDrawArgs args)
continue;
var gridXform = xformQuery.GetComponent(gridId);
- var (_, _, worldMatrix, invWorldMatrix) = gridXform.GetWorldPositionRotationMatrixWithInv(xformQuery);
+ var (_, _, worldMatrix, invWorldMatrix) = _transformSystem.GetWorldPositionRotationMatrixWithInv(gridXform, xformQuery);
gridBounds = invWorldMatrix.TransformBox(args.WorldBounds).Enlarged(mapGrid.TileSize * 2);
drawHandle.SetTransform(worldMatrix);
continue;
var gridXform = xformQuery.GetComponent(gridId);
- var (_, _, matrix, invMatrix) = gridXform.GetWorldPositionRotationMatrixWithInv(xformQuery);
+ var (_, _, matrix, invMatrix) = _transformSystem.GetWorldPositionRotationMatrixWithInv(gridXform, xformQuery);
var gridBounds = invMatrix.TransformBox(args.WorldBounds).Enlarged(mapGrid.TileSize * 2);
foreach (var debugOverlayData in _debugOverlaySystem.GetData(gridId))
[Dependency] private readonly ActionBlockerSystem _actionBlockerSystem = default!;
[Dependency] private readonly EntityLookupSystem _lookup = default!;
[Dependency] private readonly SharedPopupSystem _popup = default!;
+ [Dependency] private readonly SharedTransformSystem _transformSystem = default!;
// how often to recheck possible targets (prevents calling expensive
// check logic each update)
if (Exists(_dragShadow))
{
var mousePos = _eyeManager.PixelToMap(_inputManager.MouseScreenPosition);
- Transform(_dragShadow.Value).WorldPosition = mousePos.Position;
+ _transformSystem.SetWorldPosition(_dragShadow.Value, mousePos.Position);
}
}
}
[Dependency] private readonly IInputManager _inputManager = default!;
[Dependency] private readonly IMapManager _mapManager = default!;
[Dependency] private readonly InputSystem _inputSystem = default!;
+ [Dependency] private readonly SharedTransformSystem _transformSystem = default!;
public bool Enabled { get; set; }
if (_dragging == null) return;
if (_lastMousePosition != null && TryComp(_dragging.Value, out TransformComponent? xform) &&
- TryComp<PhysicsComponent>(_dragging.Value, out var body) &&
+ TryComp<PhysicsComponent>(_dragging.Value, out _) &&
xform.MapID == _lastMousePosition.Value.MapId)
{
var tickTime = _gameTiming.TickPeriod;
- var distance = _lastMousePosition.Value.Position - xform.WorldPosition;
+ var distance = _lastMousePosition.Value.Position - _transformSystem.GetWorldPosition(xform);
RaiseNetworkEvent(new GridDragVelocityRequest()
{
Grid = GetNetEntity(_dragging.Value),
{
private readonly IEntityManager _entManager = default!;
private readonly Font _font = default!;
+ private readonly SharedTransformSystem _transformSystem;
public override OverlaySpace Space => OverlaySpace.ScreenSpace;
{
_entManager = entManager;
_font = new VectorFont(resourceCache.GetResource<FontResource>("/Fonts/NotoSans/NotoSans-Regular.ttf"), 10);
+ _transformSystem = _entManager.System<SharedTransformSystem>();
}
protected override void Draw(in OverlayDrawArgs args)
if (string.IsNullOrEmpty(comp.DebugText) || xform.MapID != args.MapId)
continue;
- var worldPos = xform.WorldPosition;
+ var worldPos = _transformSystem.GetWorldPosition(xform);
if (!args.WorldAABB.Contains(worldPos))
continue;
public override OverlaySpace Space => OverlaySpace.WorldSpace;
private readonly IEntityManager _entManager;
+ private readonly SharedTransformSystem _transformSystem;
public NPCSteeringOverlay(IEntityManager entManager)
{
_entManager = entManager;
+ _transformSystem = _entManager.System<SharedTransformSystem>();
}
protected override void Draw(in OverlayDrawArgs args)
continue;
}
- var (worldPos, worldRot) = xform.GetWorldPositionRotation();
+ var (worldPos, worldRot) = _transformSystem.GetWorldPositionRotation(xform);
if (!args.WorldAABB.Contains(worldPos))
continue;
[Dependency] private readonly IEntityManager _entityManager = default!;
[Dependency] private readonly IRobustRandom _random = default!;
private readonly DeviceListSystem _deviceListSystem;
+ private readonly SharedTransformSystem _transformSystem;
public Dictionary<EntityUid, Color> Colors = new();
public EntityUid? Action;
IoCManager.InjectDependencies(this);
_deviceListSystem = _entityManager.System<DeviceListSystem>();
+ _transformSystem = _entityManager.System<SharedTransformSystem>();
}
protected override void Draw(in OverlayDrawArgs args)
continue;
}
- args.WorldHandle.DrawLine(sourceTransform.WorldPosition, linkTransform.WorldPosition, Colors[uid]);
+ args.WorldHandle.DrawLine(_transformSystem.GetWorldPosition(sourceTransform), _transformSystem.GetWorldPosition(linkTransform), Colors[uid]);
}
}
}
private readonly IMapManager _mapManager;
private readonly IInputManager _inputManager;
private readonly IEntityManager _entityManager;
+ private readonly SharedTransformSystem _transformSystem;
private readonly Dictionary<(int, int), NodeRenderData> _nodeIndex = new();
private readonly Dictionary<EntityUid, Dictionary<Vector2i, List<(GroupData, NodeDatum)>>> _gridIndex = new ();
_mapManager = mapManager;
_inputManager = inputManager;
_entityManager = entityManager;
+ _transformSystem = _entityManager.System<SharedTransformSystem>();
_font = cache.GetFont("/Fonts/NotoSans/NotoSans-Regular.ttf", 12);
}
foreach (var (gridId, gridDict) in _gridIndex)
{
var grid = _entityManager.GetComponent<MapGridComponent>(gridId);
- var (_, _, worldMatrix, invMatrix) = _entityManager.GetComponent<TransformComponent>(gridId).GetWorldPositionRotationMatrixWithInv();
+ var (_, _, worldMatrix, invMatrix) = _transformSystem.GetWorldPositionRotationMatrixWithInv(gridId);
var lCursorBox = invMatrix.TransformBox(cursorBox);
foreach (var (pos, list) in gridDict)
[Dependency] private readonly IPrototypeManager _prototypeManager = default!;
[Dependency] private readonly SharedInteractionSystem _interactionSystem = default!;
[Dependency] private readonly EntityWhitelistSystem _whitelistSystem = default!;
+ [Dependency] private readonly SharedTransformSystem _transformSystem = default!;
private bool _enabled = false;
valid = _interactionSystem.InRangeUnobstructed(player, entity, Range);
else if (Range >= 0)
{
- var origin = Transform(player).WorldPosition;
- var target = Transform(entity).WorldPosition;
+ var origin = _transformSystem.GetWorldPosition(player);
+ var target = _transformSystem.GetWorldPosition(entity);
valid = (origin - target).LengthSquared() <= Range;
}
public sealed class StealthSystem : SharedStealthSystem
{
[Dependency] private readonly IPrototypeManager _protoMan = default!;
+ [Dependency] private readonly SharedTransformSystem _transformSystem = default!;
private ShaderInstance _shader = default!;
if (!parent.IsValid())
return; // should never happen, but lets not kill the client.
var parentXform = Transform(parent);
- var reference = args.Viewport.WorldToLocal(parentXform.WorldPosition);
+ var reference = args.Viewport.WorldToLocal(_transformSystem.GetWorldPosition(parentXform));
reference.X = -reference.X;
var visibility = GetVisibility(uid, component);
[Dependency] private readonly IPlayerManager _playerManager = default!;
[Dependency] private readonly IGameTiming _gameTiming = default!;
[Dependency] private readonly AppearanceSystem _appearance = default!;
+ [Dependency] private readonly SharedTransformSystem _transformSystem = default!;
// Time in seconds to wait until sending the location of a dragged entity to the server again
private const float Delay = 1f / 10; // 10 Hz
if (clampedCoords.Equals(MapCoordinates.Nullspace)) return;
// Move the entity locally every update
- EntityManager.GetComponent<TransformComponent>(_draggedEntity.Value).WorldPosition = clampedCoords.Position;
+ _transformSystem.SetWorldPosition(_draggedEntity.Value, clampedCoords.Position);
// Increment total time passed
_timePassed += frameTime;
[Dependency] private readonly IPlayerManager _playerMan = default!;
[Dependency] private readonly IEntityManager _entMan = default!;
[Dependency] private readonly IConfigurationManager _configurationManager = default!;
-
public static readonly Vector2i ViewportSize = (EyeManager.PixelsPerMeter * 21, EyeManager.PixelsPerMeter * 15);
public const int ViewportHeight = 15;
private MainViewport? Viewport => UIManager.ActiveScreen?.GetWidget<MainViewport>();
private void UpdateEffects()
{
var query = EntityQueryEnumerator<TrackUserComponent, TransformComponent>();
- while (query.MoveNext(out var arcComponent, out var xform))
+ while (query.MoveNext(out var uid, out var arcComponent, out var xform))
{
if (arcComponent.User == null)
continue;
targetPos += entRotation.RotateVec(arcComponent.Offset);
}
- TransformSystem.SetWorldPosition(xform, targetPos);
+ TransformSystem.SetWorldPosition(uid, targetPos);
}
}
}
// 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, _transformSystem).Position - xform.WorldPosition).Normalized() + dirVec).Normalized();
+ var pos = ((_transformSystem.ToMapCoordinates(throwTarget).Position - _transformSystem.GetWorldPosition(xform)).Normalized() + dirVec).Normalized();
_physics.ApplyLinearImpulse(uid, pos * moveForce, body: physics);
}
else
[Dependency] private readonly SolutionContainerSystem _solutionContainerSystem = default!;
[Dependency] private readonly ThrowingSystem _throwing = default!;
[Dependency] private readonly ReactiveSystem _reactive = default!;
+ [Dependency] private readonly SharedTransformSystem _transformSystem = default!;
private const float ReactTime = 0.125f;
_throwing.TryThrow(vapor, dir, speed, user: user);
- var distance = (target.Position - vaporXform.WorldPosition).Length();
+ var distance = (target.Position - _transformSystem.GetWorldPosition(vaporXform)).Length();
var time = (distance / physics.LinearVelocity.Length());
despawn.Lifetime = MathF.Min(aliveTime, time);
}
-using System.Diagnostics.CodeAnalysis;
+using System.Diagnostics.CodeAnalysis;
using System.Globalization;
using Robust.Server.Player;
using Robust.Shared.Console;
{
var entMan = IoCManager.Resolve<IEntityManager>();
var transform = entMan.GetComponent<TransformComponent>(ent);
+ var transformSystem = entMan.System<SharedTransformSystem>();
+ var worldPosition = transformSystem.GetWorldPosition(transform);
// gross, is there a better way to do this?
ruleString = ruleString.Replace("$ID", ent.ToString());
ruleString = ruleString.Replace("$WX",
- transform.WorldPosition.X.ToString(CultureInfo.InvariantCulture));
+ worldPosition.X.ToString(CultureInfo.InvariantCulture));
ruleString = ruleString.Replace("$WY",
- transform.WorldPosition.Y.ToString(CultureInfo.InvariantCulture));
+ worldPosition.Y.ToString(CultureInfo.InvariantCulture));
ruleString = ruleString.Replace("$LX",
transform.LocalPosition.X.ToString(CultureInfo.InvariantCulture));
ruleString = ruleString.Replace("$LY",
if (player.AttachedEntity is {Valid: true} p)
{
var pTransform = entMan.GetComponent<TransformComponent>(p);
+ var pWorldPosition = transformSystem.GetWorldPosition(pTransform);
ruleString = ruleString.Replace("$PID", ent.ToString());
ruleString = ruleString.Replace("$PWX",
- pTransform.WorldPosition.X.ToString(CultureInfo.InvariantCulture));
+ pWorldPosition.X.ToString(CultureInfo.InvariantCulture));
ruleString = ruleString.Replace("$PWY",
- pTransform.WorldPosition.Y.ToString(CultureInfo.InvariantCulture));
+ pWorldPosition.Y.ToString(CultureInfo.InvariantCulture));
ruleString = ruleString.Replace("$PLX",
pTransform.LocalPosition.X.ToString(CultureInfo.InvariantCulture));
ruleString = ruleString.Replace("$PLY",
[UsedImplicitly]
public sealed class WirelessNetworkSystem : EntitySystem
{
+ [Dependency] private readonly SharedTransformSystem _transformSystem = default!;
+
public override void Initialize()
{
base.Initialize();
return;
if (xform.MapID != args.SenderTransform.MapID
- || (ownPosition - xform.WorldPosition).Length() > sendingComponent.Range)
+ || (ownPosition - _transformSystem.GetWorldPosition(xform)).Length() > sendingComponent.Range)
{
args.Cancel();
}
}
// cant put a rift on solars
- foreach (var tile in grid.GetTilesIntersecting(new Circle(xform.WorldPosition, RiftTileRadius), false))
+ foreach (var tile in grid.GetTilesIntersecting(new Circle(_transform.GetWorldPosition(xform), RiftTileRadius), false))
{
if (!tile.IsSpace(_tileDef))
continue;
var xforms = EntityManager.GetEntityQuery<TransformComponent>();
var xform = xforms.GetComponent(gridToTransform);
- var (_, gridWorldRotation, gridWorldMatrix, invGridWorldMatrid) = xform.GetWorldPositionRotationMatrixWithInv(xforms);
+ var (_, gridWorldRotation, gridWorldMatrix, invGridWorldMatrid) = _transformSystem.GetWorldPositionRotationMatrixWithInv(xform, xforms);
var localEpicentre = (Vector2i) Vector2.Transform(epicentre.Position, invGridWorldMatrid);
var matrix = offsetMatrix * gridWorldMatrix * targetMatrix;
if (player.AttachedEntity is not EntityUid uid)
continue;
- var playerPos = Transform(player.AttachedEntity!.Value).WorldPosition;
+ var playerPos = _transformSystem.GetWorldPosition(player.AttachedEntity!.Value);
var delta = epicenter.Position - playerPos;
if (delta.EqualsApprox(Vector2.Zero))
throwEnt = splitStack.Value;
}
- var direction = coordinates.ToMapPos(EntityManager, _transformSystem) - Transform(player).WorldPosition;
+ var direction = _transformSystem.ToMapCoordinates(coordinates).Position - _transformSystem.GetWorldPosition(player);
if (direction == Vector2.Zero)
return true;
{
[Dependency] private readonly IConGroupController _admin = default!;
[Dependency] private readonly SharedPhysicsSystem _physics = default!;
+ [Dependency] private readonly SharedTransformSystem _transformSystem = default!;
private readonly HashSet<ICommonSession> _draggers = new();
return;
}
- var gridXform = Transform(grid);
-
- gridXform.WorldPosition = msg.WorldPosition;
+ _transformSystem.SetWorldPosition(grid, msg.WorldPosition);
}
}
-using System.Linq;
+using System.Linq;
using Content.Server.Interaction;
using Content.Server.Mech.Equipment.Components;
using Content.Server.Mech.Systems;
var (mechPos, mechRot) = _transform.GetWorldPositionRotation(mechxform);
var offset = mechPos + mechRot.RotateVec(component.DepositOffset);
- _transform.SetWorldPositionRotation(xform, offset, Angle.Zero);
+ _transform.SetWorldPositionRotation(toRemove, offset, Angle.Zero);
_mech.UpdateUserInterface(mech);
}
var x = MathF.Sin(stressTest.Progress * MathHelper.TwoPi);
var y = MathF.Cos(stressTest.Progress * MathHelper.TwoPi);
- _transform.SetWorldPosition(transform, stressTest.Origin + new Vector2(x, y) * 5);
+ _transform.SetWorldPosition((uid, transform), stressTest.Origin + new Vector2(x, y) * 5);
}
}
}
[Dependency] private readonly IRobustRandom _random = default!;
[Dependency] private readonly ExplosionSystem _explosion = default!;
[Dependency] private readonly SharedAppearanceSystem _appearance = default!;
+ [Dependency] private readonly SharedTransformSystem _transformSystem = default!;
private EntityUid? RandomNearbyPlayer(EntityUid uid, RoguePointingArrowComponent? component = null, TransformComponent? transform = null)
{
}
component.TurningDelay -= frameTime;
+ var (transformPos, transformRot) = _transformSystem.GetWorldPositionRotation(transform);
if (component.TurningDelay > 0)
{
- var difference = Comp<TransformComponent>(chasing).WorldPosition - transform.WorldPosition;
+ var difference = _transformSystem.GetWorldPosition(chasing) - transformPos;
var angle = difference.ToAngle();
var adjusted = angle.Degrees + 90;
var newAngle = Angle.FromDegrees(adjusted);
- transform.WorldRotation = newAngle;
+ _transformSystem.SetWorldRotation(transform, newAngle);
UpdateAppearance(uid, component, transform);
continue;
}
- transform.WorldRotation += Angle.FromDegrees(20);
+ _transformSystem.SetWorldRotation(transform, transformRot + Angle.FromDegrees(20));
UpdateAppearance(uid, component, transform);
- var toChased = Comp<TransformComponent>(chasing).WorldPosition - transform.WorldPosition;
+ var toChased = _transformSystem.GetWorldPosition(chasing) - transformPos;
- transform.WorldPosition += toChased * frameTime * component.ChasingSpeed;
+ _transformSystem.SetWorldPosition((uid, transform), transformPos + (toChased * frameTime * component.ChasingSpeed));
component.ChasingTime -= frameTime;
-using Content.Server.Administration.Logs;
+using Content.Server.Administration.Logs;
using Content.Server.Atmos.EntitySystems;
using Content.Server.Chat.Managers;
using Content.Server.GameTicking;
var tile = tileRef.GridIndices;
var found = false;
- var (gridPos, _, gridMatrix) = xform.GetWorldPositionRotationMatrix();
+ var (gridPos, _, gridMatrix) = _transform.GetWorldPositionRotationMatrix(xform);
var gridBounds = gridMatrix.TransformBox(grid.LocalAABB);
//Obviously don't put anything ridiculous in here
[Dependency] private readonly GhostSystem _ghost = default!;
[Dependency] private readonly TileSystem _tile = default!;
[Dependency] private readonly EntityWhitelistSystem _whitelistSystem = default!;
+ [Dependency] private readonly SharedTransformSystem _transformSystem = default!;
private void InitializeAbilities()
{
var xform = Transform(uid);
if (!TryComp<MapGridComponent>(xform.GridUid, out var map))
return;
- var tiles = map.GetTilesIntersecting(Box2.CenteredAround(xform.WorldPosition,
+ var tiles = map.GetTilesIntersecting(Box2.CenteredAround(_transformSystem.GetWorldPosition(xform),
new Vector2(component.DefileRadius * 2, component.DefileRadius))).ToArray();
_random.Shuffle(tiles);
[Dependency] private readonly PhysicsSystem _physics = default!;
[Dependency] private readonly PopupSystem _popupSystem = default!;
[Dependency] private readonly SharedPointLightSystem _light = default!;
+ [Dependency] private readonly SharedTransformSystem _transformSystem = default!;
[Dependency] private readonly TagSystem _tags = default!;
public override void Initialize()
if (!gen1XForm.Anchored)
return false;
- var genWorldPosRot = gen1XForm.GetWorldPositionRotation();
+ var genWorldPosRot = _transformSystem.GetWorldPositionRotation(gen1XForm);
var dirRad = dir.ToAngle() + genWorldPosRot.WorldRotation; //needs to be like this for the raycast to work properly
var ray = new CollisionRay(genWorldPosRot.WorldPosition, dirRad.ToVec(), component.CollisionMask);
-using Content.Server.Popups;
+using Content.Server.Popups;
using Content.Server.Shuttles.Components;
using Content.Server.Singularity.Events;
using Content.Shared.Popups;
{
[Dependency] private readonly ThrowingSystem _throwing = default!;
[Dependency] private readonly PopupSystem _popupSystem = default!;
+ [Dependency] private readonly SharedTransformSystem _transformSystem = default!;
public override void Initialize()
{
if (TryComp<PhysicsComponent>(otherBody, out var physics) && physics.Mass <= component.MaxMass && physics.Hard)
{
- var fieldDir = Transform(uid).WorldPosition;
- var playerDir = Transform(otherBody).WorldPosition;
+ var fieldDir = _transformSystem.GetWorldPosition(uid);
+ var playerDir = _transformSystem.GetWorldPosition(otherBody);
_throwing.TryThrow(otherBody, playerDir-fieldDir, baseThrowSpeed: component.ThrowForce);
}
{
[Dependency] private readonly IRobustRandom _robustRandom = default!;
[Dependency] private readonly SharedPhysicsSystem _physicsSystem = default!;
+ [Dependency] private readonly SharedTransformSystem _transformSystem = default!;
/// <summary>
/// Maximum panel angular velocity range - used to stop people rotating panels fast enough that the lag prevention becomes noticable
while (query.MoveNext(out var uid, out var panel, out var xform))
{
TotalPanelPower += panel.MaxSupply * panel.Coverage;
- xform.WorldRotation = TargetPanelRotation;
+ _transformSystem.SetWorldRotation(xform, TargetPanelRotation);
_updateQueue.Enqueue((uid, panel));
}
}
// directly downwards (abs(theta) = pi) = coverage -1
// as TowardsSun + = CCW,
// panelRelativeToSun should - = CW
- var panelRelativeToSun = xform.WorldRotation - TowardsSun;
+ var panelRelativeToSun = _transformSystem.GetWorldRotation(xform) - TowardsSun;
// essentially, given cos = X & sin = Y & Y is 'downwards',
// then for the first 90 degrees of rotation in either direction,
// this plots the lower-right quadrant of a circle.
if (coverage > 0)
{
// Determine if the solar panel is occluded, and zero out coverage if so.
- var ray = new CollisionRay(xform.WorldPosition, TowardsSun.ToWorldVec(), (int) CollisionGroup.Opaque);
+ var ray = new CollisionRay(_transformSystem.GetWorldPosition(xform), TowardsSun.ToWorldVec(), (int) CollisionGroup.Opaque);
var rayCastResults = _physicsSystem.IntersectRayWithPredicate(
xform.MapID,
ray,
-using System.Numerics;
+using System.Numerics;
using Content.Server.Worldgen.Components;
using JetBrains.Annotations;
public abstract class BaseWorldSystem : EntitySystem
{
[Dependency] private readonly WorldControllerSystem _worldController = default!;
+ [Dependency] private readonly SharedTransformSystem _transformSystem = default!;
/// <summary>
/// Gets a chunk's coordinates in chunk space as an integer value.
if (!Resolve(ent, ref xform))
throw new Exception("Failed to resolve transform, somehow.");
- return WorldGen.WorldToChunkCoords(xform.WorldPosition).Floored();
+ return WorldGen.WorldToChunkCoords(_transformSystem.GetWorldPosition(xform)).Floored();
}
/// <summary>
if (!Resolve(ent, ref xform))
throw new Exception("Failed to resolve transform, somehow.");
- return WorldGen.WorldToChunkCoords(xform.WorldPosition);
+ return WorldGen.WorldToChunkCoords(_transformSystem.GetWorldPosition(xform));
}
/// <summary>
-using System.Numerics;
+using System.Numerics;
using Content.Server.Xenoarchaeology.XenoArtifacts.Effects.Components;
using Content.Server.Xenoarchaeology.XenoArtifacts.Events;
using Content.Shared.Maps;
if (TryComp<MapGridComponent>(xform.GridUid, out var grid))
{
var tiles = grid.GetTilesIntersecting(
- Box2.CenteredAround(xform.WorldPosition, new Vector2(component.Range * 2, component.Range)));
+ Box2.CenteredAround(_transform.GetWorldPosition(xform), new Vector2(component.Range * 2, component.Range)));
foreach (var tile in tiles)
{
// get blueprint and user position
var transformSystem = entManager.System<SharedTransformSystem>();
- var userWorldPosition = entManager.GetComponent<TransformComponent>(user).WorldPosition;
+ var userWorldPosition = transformSystem.GetWorldPosition(user);
var objWorldPosition = location.ToMap(entManager, transformSystem).Position;
// find direction from user to blueprint
var userToObject = (objWorldPosition - userWorldPosition);
// get direction of the grid being placed on as an offset.
- var gridRotation = entManager.GetComponent<TransformComponent>(location.EntityId).WorldRotation;
+ var gridRotation = transformSystem.GetWorldRotation(location.EntityId);
var directionWithOffset = gridRotation.RotateVec(direction.ToVec());
// dot product will be positive if user direction and blueprint are co-directed
var grid = _mapManager.CreateGridEntity(locationMap.MapId);
var gridXform = Transform(grid);
- _transform.SetWorldPosition(gridXform, locationMap.Position);
+ _transform.SetWorldPosition((grid, gridXform), locationMap.Position);
location = new EntityCoordinates(grid, Vector2.Zero);
PlaceAt(args.User, grid, grid.Comp, location, _tileDefinitionManager[component.OutputTiles[0]].TileId, component.PlaceTileSound, grid.Comp.TileSize / 2f);
return;
projects / space-station-14.git / commitdiff