Inline UID

Robust.Client/Animations/AnimationTrackComponentProperty.cs

@@ -20,7 +20,7 @@ namespace Robust.Client.Animations
             }
 
             var entity = (IEntity) context;
-            var component = IoCManager.Resolve<IEntityManager>().GetComponent(entity.Uid, ComponentType);
+            var component = IoCManager.Resolve<IEntityManager>().GetComponent(entity, ComponentType);
 
             if (component is IAnimationProperties properties)
             {

Robust.Client/Animations/AnimationTrackSpriteFlick.cs

@@ -40,7 +40,7 @@ namespace Robust.Client.Animations
             DebugTools.AssertNotNull(LayerKey);
 
             var entity = (IEntity) context;
-            var sprite = IoCManager.Resolve<IEntityManager>().GetComponent<ISpriteComponent>(entity.Uid);
+            var sprite = IoCManager.Resolve<IEntityManager>().GetComponent<ISpriteComponent>(entity);
 
             var playingTime = prevPlayingTime + frameTime;
             var keyFrameIndex = prevKeyFrameIndex;

Robust.Client/Audio/Midi/MidiManager.cs

@@ -299,7 +299,7 @@ namespace Robust.Client.Audio.Midi
                 }
                 else if (renderer.TrackingEntity != null)
                 {
-                    mapPos = IoCManager.Resolve<IEntityManager>().GetComponent<TransformComponent>(renderer.TrackingEntity.Uid).MapPosition;
+                    mapPos = IoCManager.Resolve<IEntityManager>().GetComponent<TransformComponent>(renderer.TrackingEntity).MapPosition;
                 }
 
                 if (mapPos != null)

Robust.Client/Console/Commands/ClientSpawnCommand.cs

@@ -23,7 +23,7 @@ namespace Robust.Client.Console.Commands
             }
 
             var entityManager = IoCManager.Resolve<IEntityManager>();
-            entityManager.SpawnEntity(args[0], IoCManager.Resolve<IEntityManager>().GetComponent<TransformComponent>(player.ControlledEntity.Uid).Coordinates);
+            entityManager.SpawnEntity(args[0], IoCManager.Resolve<IEntityManager>().GetComponent<TransformComponent>(player.ControlledEntity).Coordinates);
         }
     }
 }

Robust.Client/Console/Commands/Debug.cs

@@ -43,9 +43,9 @@ namespace Robust.Client.Console.Commands
         {
             var entityManager = IoCManager.Resolve<IEntityManager>();
 
-            foreach (var e in entityManager.GetEntities().OrderBy(e => e.Uid))
+            foreach (var e in entityManager.GetEntities().OrderBy(e => (EntityUid) e))
             {
-                shell.WriteLine($"entity {e.Uid}, {IoCManager.Resolve<IEntityManager>().GetComponent<MetaDataComponent>(e.Uid).EntityPrototype?.ID}, {IoCManager.Resolve<IEntityManager>().GetComponent<TransformComponent>(e.Uid).Coordinates}.");
+                shell.WriteLine($"entity {e}, {IoCManager.Resolve<IEntityManager>().GetComponent<MetaDataComponent>(e).EntityPrototype?.ID}, {IoCManager.Resolve<IEntityManager>().GetComponent<TransformComponent>(e).Coordinates}.");
             }
         }
     }
@@ -246,9 +246,9 @@ namespace Robust.Client.Console.Commands
                 return;
             }
 
-            shell.WriteLine($"{entity.Uid}: {IoCManager.Resolve<IEntityManager>().GetComponent<MetaDataComponent>(entity.Uid).EntityPrototype?.ID}/{IoCManager.Resolve<IEntityManager>().GetComponent<MetaDataComponent>(entity.Uid).EntityName}");
-            shell.WriteLine($"init/del/lmt: {(!IoCManager.Resolve<IEntityManager>().EntityExists(entity.Uid) ? EntityLifeStage.Deleted : IoCManager.Resolve<IEntityManager>().GetComponent<MetaDataComponent>(entity.Uid).EntityLifeStage) >= EntityLifeStage.Initialized}/{(!IoCManager.Resolve<IEntityManager>().EntityExists(entity.Uid) ? EntityLifeStage.Deleted : IoCManager.Resolve<IEntityManager>().GetComponent<MetaDataComponent>(entity.Uid).EntityLifeStage) >= EntityLifeStage.Deleted}/{IoCManager.Resolve<IEntityManager>().GetComponent<MetaDataComponent>(entity.Uid).EntityLastModifiedTick}");
-            foreach (var component in IoCManager.Resolve<IEntityManager>().GetComponents(entity.Uid))
+            shell.WriteLine($"{entity}: {IoCManager.Resolve<IEntityManager>().GetComponent<MetaDataComponent>(entity).EntityPrototype?.ID}/{IoCManager.Resolve<IEntityManager>().GetComponent<MetaDataComponent>(entity).EntityName}");
+            shell.WriteLine($"init/del/lmt: {(!IoCManager.Resolve<IEntityManager>().EntityExists(entity) ? EntityLifeStage.Deleted : IoCManager.Resolve<IEntityManager>().GetComponent<MetaDataComponent>(entity).EntityLifeStage) >= EntityLifeStage.Initialized}/{(!IoCManager.Resolve<IEntityManager>().EntityExists(entity) ? EntityLifeStage.Deleted : IoCManager.Resolve<IEntityManager>().GetComponent<MetaDataComponent>(entity).EntityLifeStage) >= EntityLifeStage.Deleted}/{IoCManager.Resolve<IEntityManager>().GetComponent<MetaDataComponent>(entity).EntityLastModifiedTick}");
+            foreach (var component in IoCManager.Resolve<IEntityManager>().GetComponents(entity))
             {
                 shell.WriteLine(component.ToString() ?? "");
                 if (component is IComponentDebug debug)

Robust.Client/Debugging/DebugAnchoringSystem.cs

@@ -85,7 +85,7 @@ namespace Robust.Client.Debugging
                 }
                 else
                 {
-                    text.AppendLine($"uid: {ent}, {IoCManager.Resolve<IEntityManager>().GetComponent<MetaDataComponent>(entity.Uid).EntityName}");
+                    text.AppendLine($"uid: {ent}, {IoCManager.Resolve<IEntityManager>().GetComponent<MetaDataComponent>(entity).EntityName}");
                 }
             }
 

Robust.Client/Debugging/DebugDrawing.cs

@@ -61,7 +61,7 @@ namespace Robust.Client.Debugging
 
                 foreach (var entity in _lookup.GetEntitiesIntersecting(_eyeManager.CurrentMap, viewport))
                 {
-                    var transform = IoCManager.Resolve<IEntityManager>().GetComponent<TransformComponent>(entity.Uid);
+                    var transform = IoCManager.Resolve<IEntityManager>().GetComponent<TransformComponent>(entity);
 
                     var center = transform.WorldPosition;
                     var worldRotation = transform.WorldRotation;

Robust.Client/Debugging/DebugPhysicsSystem.cs

@@ -201,7 +201,7 @@ namespace Robust.Client.Debugging
             {
                 foreach (var physBody in _physicsSystem.GetCollidingEntities(mapId, viewBounds))
                 {
-                    if (IoCManager.Resolve<IEntityManager>().HasComponent<MapGridComponent>(physBody.Owner.Uid)) continue;
+                    if (IoCManager.Resolve<IEntityManager>().HasComponent<MapGridComponent>(physBody.Owner)) continue;
 
                     var xform = physBody.GetTransform();
 
@@ -246,7 +246,7 @@ namespace Robust.Client.Debugging
                     const float Alpha = 0.25f;
                     float size;
 
-                    if (IoCManager.Resolve<IEntityManager>().HasComponent<MapGridComponent>(physBody.Owner.Uid))
+                    if (IoCManager.Resolve<IEntityManager>().HasComponent<MapGridComponent>(physBody.Owner))
                     {
                         color = Color.Orange.WithAlpha(Alpha);
                         size = 1f;
@@ -267,7 +267,7 @@ namespace Robust.Client.Debugging
             {
                 foreach (var physBody in _physicsSystem.GetCollidingEntities(mapId, viewBounds))
                 {
-                    if (IoCManager.Resolve<IEntityManager>().HasComponent<MapGridComponent>(physBody.Owner.Uid)) continue;
+                    if (IoCManager.Resolve<IEntityManager>().HasComponent<MapGridComponent>(physBody.Owner)) continue;
 
                     var xform = physBody.GetTransform();
 
@@ -296,7 +296,7 @@ namespace Robust.Client.Debugging
                 foreach (var jointComponent in _entityManager.EntityQuery<JointComponent>(true))
                 {
                     if (jointComponent.JointCount == 0 ||
-                        !_entityManager.TryGetComponent(jointComponent.Owner.Uid, out TransformComponent? xf1) ||
+                        !_entityManager.TryGetComponent(jointComponent.Owner, out TransformComponent? xf1) ||
                         !viewAABB.Contains(xf1.WorldPosition)) continue;
 
                     foreach (var (_, joint) in jointComponent.Joints)
@@ -350,7 +350,7 @@ namespace Robust.Client.Debugging
 
                 foreach (var physBody in _physicsSystem.GetCollidingEntities(mapId, bounds))
                 {
-                    if (IoCManager.Resolve<IEntityManager>().HasComponent<MapGridComponent>(physBody.Owner.Uid)) continue;
+                    if (IoCManager.Resolve<IEntityManager>().HasComponent<MapGridComponent>(physBody.Owner)) continue;
                     hoverBodies.Add(physBody);
                 }
 

Robust.Client/GameObjects/ClientEntityManager.cs

@@ -116,7 +116,7 @@ namespace Robust.Client.GameObjects
 
             var msg = _networkManager.CreateNetMessage<MsgEntity>();
             msg.Type = EntityMessageType.ComponentMessage;
-            msg.EntityUid = entity.Uid;
+            msg.EntityUid = entity;
             msg.NetId = netId.Value;
             msg.ComponentMessage = message;
             msg.SourceTick = _gameTiming.CurTick;

Robust.Client/GameObjects/Components/Eye/EyeComponent.cs

@@ -118,7 +118,7 @@ namespace Robust.Client.GameObjects
 
             _eye = new Eye
             {
-                Position = IoCManager.Resolve<IEntityManager>().GetComponent<TransformComponent>(Owner.Uid).MapPosition,
+                Position = IoCManager.Resolve<IEntityManager>().GetComponent<TransformComponent>(Owner).MapPosition,
                 Zoom = _setZoomOnInitialize,
                 DrawFov = _setDrawFovOnInitialize
             };
@@ -166,7 +166,7 @@ namespace Robust.Client.GameObjects
         public void UpdateEyePosition()
         {
             if (_eye == null) return;
-            var mapPos = IoCManager.Resolve<IEntityManager>().GetComponent<TransformComponent>(Owner.Uid).MapPosition;
+            var mapPos = IoCManager.Resolve<IEntityManager>().GetComponent<TransformComponent>(Owner).MapPosition;
             _eye.Position = new MapCoordinates(mapPos.Position, mapPos.MapId);
         }
     }

Robust.Client/GameObjects/Components/Light/ClientOccluderComponent.cs

@@ -32,7 +32,7 @@ namespace Robust.Client.GameObjects
         {
             base.Startup();
 
-            if (IoCManager.Resolve<IEntityManager>().GetComponent<TransformComponent>(Owner.Uid).Anchored)
+            if (IoCManager.Resolve<IEntityManager>().GetComponent<TransformComponent>(Owner).Anchored)
             {
                 AnchorStateChanged();
             }
@@ -42,11 +42,11 @@ namespace Robust.Client.GameObjects
         {
             SendDirty();
 
-            if(!IoCManager.Resolve<IEntityManager>().GetComponent<TransformComponent>(Owner.Uid).Anchored)
+            if(!IoCManager.Resolve<IEntityManager>().GetComponent<TransformComponent>(Owner).Anchored)
                 return;
 
-            var grid = _mapManager.GetGrid(IoCManager.Resolve<IEntityManager>().GetComponent<TransformComponent>(Owner.Uid).GridID);
-            _lastPosition = (IoCManager.Resolve<IEntityManager>().GetComponent<TransformComponent>(Owner.Uid).GridID, grid.TileIndicesFor(IoCManager.Resolve<IEntityManager>().GetComponent<TransformComponent>(Owner.Uid).Coordinates));
+            var grid = _mapManager.GetGrid(IoCManager.Resolve<IEntityManager>().GetComponent<TransformComponent>(Owner).GridID);
+            _lastPosition = (IoCManager.Resolve<IEntityManager>().GetComponent<TransformComponent>(Owner).GridID, grid.TileIndicesFor(IoCManager.Resolve<IEntityManager>().GetComponent<TransformComponent>(Owner).Coordinates));
         }
 
         protected override void Shutdown()
@@ -58,7 +58,7 @@ namespace Robust.Client.GameObjects
 
         private void SendDirty()
         {
-            if (IoCManager.Resolve<IEntityManager>().GetComponent<TransformComponent>(Owner.Uid).Anchored)
+            if (IoCManager.Resolve<IEntityManager>().GetComponent<TransformComponent>(Owner).Anchored)
             {
                 IoCManager.Resolve<IEntityManager>().EventBus.RaiseEvent(EventSource.Local,
                     new OccluderDirtyEvent(Owner, _lastPosition));
@@ -69,13 +69,13 @@ namespace Robust.Client.GameObjects
         {
             Occluding = OccluderDir.None;
 
-            if (Deleted || !IoCManager.Resolve<IEntityManager>().GetComponent<TransformComponent>(Owner.Uid).Anchored)
+            if (Deleted || !IoCManager.Resolve<IEntityManager>().GetComponent<TransformComponent>(Owner).Anchored)
             {
                 return;
             }
 
-            var grid = _mapManager.GetGrid(IoCManager.Resolve<IEntityManager>().GetComponent<TransformComponent>(Owner.Uid).GridID);
-            var position = IoCManager.Resolve<IEntityManager>().GetComponent<TransformComponent>(Owner.Uid).Coordinates;
+            var grid = _mapManager.GetGrid(IoCManager.Resolve<IEntityManager>().GetComponent<TransformComponent>(Owner).GridID);
+            var position = IoCManager.Resolve<IEntityManager>().GetComponent<TransformComponent>(Owner).Coordinates;
             void CheckDir(Direction dir, OccluderDir oclDir)
             {
                 foreach (var neighbor in grid.GetInDir(position, dir))
@@ -88,7 +88,7 @@ namespace Robust.Client.GameObjects
                 }
             }
 
-            var angle = IoCManager.Resolve<IEntityManager>().GetComponent<TransformComponent>(Owner.Uid).LocalRotation;
+            var angle = IoCManager.Resolve<IEntityManager>().GetComponent<TransformComponent>(Owner).LocalRotation;
             var dirRolling = angle.GetCardinalDir();
             // dirRolling starts at effective south
 

Robust.Client/GameObjects/Components/Light/PointLightComponent.cs

@@ -32,7 +32,7 @@ namespace Robust.Client.GameObjects
             {
                 if (_enabled == value) return;
                 base.Enabled = value;
-                IoCManager.Resolve<IEntityManager>().EventBus.RaiseLocalEvent(Owner.Uid, new PointLightUpdateEvent());
+                IoCManager.Resolve<IEntityManager>().EventBus.RaiseLocalEvent(Owner, new PointLightUpdateEvent());
             }
         }
 
@@ -45,7 +45,7 @@ namespace Robust.Client.GameObjects
                 if (_containerOccluded == value) return;
 
                 _containerOccluded = value;
-                IoCManager.Resolve<IEntityManager>().EventBus.RaiseLocalEvent(Owner.Uid, new PointLightUpdateEvent());
+                IoCManager.Resolve<IEntityManager>().EventBus.RaiseLocalEvent(Owner, new PointLightUpdateEvent());
             }
         }
 

Robust.Client/GameObjects/Components/Renderable/SpriteBoundsOverlay.cs

@@ -75,11 +75,11 @@ namespace Robust.Client.GameObjects
 
             foreach (var comp in _renderTree.GetRenderTrees(currentMap, viewport))
             {
-                var localAABB = IoCManager.Resolve<IEntityManager>().GetComponent<TransformComponent>(comp.Owner.Uid).InvWorldMatrix.TransformBox(viewport);
+                var localAABB = IoCManager.Resolve<IEntityManager>().GetComponent<TransformComponent>(comp.Owner).InvWorldMatrix.TransformBox(viewport);
 
                 foreach (var sprite in comp.SpriteTree.QueryAabb(localAABB))
                 {
-                    var worldPos = IoCManager.Resolve<IEntityManager>().GetComponent<TransformComponent>(sprite.Owner.Uid).WorldPosition;
+                    var worldPos = IoCManager.Resolve<IEntityManager>().GetComponent<TransformComponent>(sprite.Owner).WorldPosition;
                     var bounds = sprite.CalculateBoundingBox(worldPos);
                     handle.DrawRect(bounds, Color.Red.WithAlpha(0.2f));
                     handle.DrawRect(bounds.Scale(0.2f).Translated(-new Vector2(0f, bounds.Extents.Y)), Color.Blue.WithAlpha(0.5f));

Robust.Client/GameObjects/Components/Renderable/SpriteComponent.cs

@@ -1603,7 +1603,7 @@ namespace Robust.Client.GameObjects
             builder.AppendFormat(
                 "vis/depth/scl/rot/ofs/col/norot/override/dir: {0}/{1}/{2}/{3}/{4}/{5}/{6}/{8}/{7}\n",
                 Visible, DrawDepth, Scale, Rotation, Offset,
-                Color, NoRotation, GetDir(RSI.State.DirectionType.Dir8, IoCManager.Resolve<IEntityManager>().GetComponent<TransformComponent>(Owner.Uid).WorldRotation),
+                Color, NoRotation, GetDir(RSI.State.DirectionType.Dir8, IoCManager.Resolve<IEntityManager>().GetComponent<TransformComponent>(Owner).WorldRotation),
                 DirectionOverride
             );
 
@@ -2076,7 +2076,8 @@ namespace Robust.Client.GameObjects
             }
 
             var entityManager = IoCManager.Resolve<IEntityManager>();
-            var dummy = entityManager.SpawnEntity(prototype.ID, MapCoordinates.Nullspace).Uid;
+            IEntity tempQualifier = entityManager.SpawnEntity(prototype.ID, MapCoordinates.Nullspace);
+            var dummy = (EntityUid) tempQualifier;
             var spriteComponent = entityManager.EnsureComponent<SpriteComponent>(dummy);
 
             var anyTexture = false;
@@ -2115,7 +2116,8 @@ namespace Robust.Client.GameObjects
             }
 
             var entityManager = IoCManager.Resolve<IEntityManager>();
-            var dummy = entityManager.SpawnEntity(prototype.ID, MapCoordinates.Nullspace).Uid;
+            IEntity tempQualifier = entityManager.SpawnEntity(prototype.ID, MapCoordinates.Nullspace);
+            var dummy = (EntityUid) tempQualifier;
             var spriteComponent = entityManager.EnsureComponent<SpriteComponent>(dummy);
             var result = spriteComponent.Icon ?? GetFallbackState(resourceCache);
             entityManager.DeleteEntity(dummy);

Robust.Client/GameObjects/Components/RenderingTreeComponent.cs

@@ -15,34 +15,34 @@ namespace Robust.Client.GameObjects
 
         private static Box2 SpriteAabbFunc(in SpriteComponent value)
         {
-            var (worldPos, worldRot) = IoCManager.Resolve<IEntityManager>().GetComponent<TransformComponent>(value.Owner.Uid).GetWorldPositionRotation();
+            var (worldPos, worldRot) = IoCManager.Resolve<IEntityManager>().GetComponent<TransformComponent>(value.Owner).GetWorldPositionRotation();
             var bounds = new Box2Rotated(value.CalculateBoundingBox(worldPos), worldRot, worldPos);
             var tree = RenderingTreeSystem.GetRenderTree(value.Owner);
 
-            var localAABB = (tree != null ? IoCManager.Resolve<IEntityManager>().GetComponent<TransformComponent>(tree.Owner.Uid) : null).InvWorldMatrix.TransformBox(bounds) ?? bounds.CalcBoundingBox();
+            var localAABB = (tree != null ? IoCManager.Resolve<IEntityManager>().GetComponent<TransformComponent>(tree.Owner) : null).InvWorldMatrix.TransformBox(bounds) ?? bounds.CalcBoundingBox();
 
             return localAABB;
         }
 
         private static Box2 LightAabbFunc(in PointLightComponent value)
         {
-            var worldPos = IoCManager.Resolve<IEntityManager>().GetComponent<TransformComponent>(value.Owner.Uid).WorldPosition;
+            var worldPos = IoCManager.Resolve<IEntityManager>().GetComponent<TransformComponent>(value.Owner).WorldPosition;
             var tree = RenderingTreeSystem.GetRenderTree(value.Owner);
             var boxSize = value.Radius * 2;
 
-            var localPos = (tree != null ? IoCManager.Resolve<IEntityManager>().GetComponent<TransformComponent>(tree.Owner.Uid) : null).InvWorldMatrix.Transform(worldPos) ?? worldPos;
+            var localPos = (tree != null ? IoCManager.Resolve<IEntityManager>().GetComponent<TransformComponent>(tree.Owner) : null).InvWorldMatrix.Transform(worldPos) ?? worldPos;
 
             return Box2.CenteredAround(localPos, (boxSize, boxSize));
         }
 
         internal static Box2 SpriteAabbFunc(SpriteComponent value, Vector2? worldPos = null, Angle? worldRot = null)
         {
-            worldPos ??= IoCManager.Resolve<IEntityManager>().GetComponent<TransformComponent>(value.Owner.Uid).WorldPosition;
-            worldRot ??= IoCManager.Resolve<IEntityManager>().GetComponent<TransformComponent>(value.Owner.Uid).WorldRotation;
+            worldPos ??= IoCManager.Resolve<IEntityManager>().GetComponent<TransformComponent>(value.Owner).WorldPosition;
+            worldRot ??= IoCManager.Resolve<IEntityManager>().GetComponent<TransformComponent>(value.Owner).WorldRotation;
             var bounds = new Box2Rotated(value.CalculateBoundingBox(worldPos.Value), worldRot.Value, worldPos.Value);
             var tree = RenderingTreeSystem.GetRenderTree(value.Owner);
 
-            var localAABB = (tree != null ? IoCManager.Resolve<IEntityManager>().GetComponent<TransformComponent>(tree.Owner.Uid) : null).InvWorldMatrix.TransformBox(bounds) ?? bounds.CalcBoundingBox();
+            var localAABB = (tree != null ? IoCManager.Resolve<IEntityManager>().GetComponent<TransformComponent>(tree.Owner) : null).InvWorldMatrix.TransformBox(bounds) ?? bounds.CalcBoundingBox();
 
             return localAABB;
         }
@@ -50,11 +50,11 @@ namespace Robust.Client.GameObjects
         internal static Box2 LightAabbFunc(PointLightComponent value, Vector2? worldPos = null)
         {
             // Lights are circles so don't need entity's rotation
-            worldPos ??= IoCManager.Resolve<IEntityManager>().GetComponent<TransformComponent>(value.Owner.Uid).WorldPosition;
+            worldPos ??= IoCManager.Resolve<IEntityManager>().GetComponent<TransformComponent>(value.Owner).WorldPosition;
             var tree = RenderingTreeSystem.GetRenderTree(value.Owner);
             var boxSize = value.Radius * 2;
 
-            var localPos = (tree != null ? IoCManager.Resolve<IEntityManager>().GetComponent<TransformComponent>(tree.Owner.Uid) : null).InvWorldMatrix.Transform(worldPos.Value) ?? worldPos.Value;
+            var localPos = (tree != null ? IoCManager.Resolve<IEntityManager>().GetComponent<TransformComponent>(tree.Owner) : null).InvWorldMatrix.Transform(worldPos.Value) ?? worldPos.Value;
 
             return Box2.CenteredAround(localPos, (boxSize, boxSize));
         }

Robust.Client/GameObjects/Components/UserInterface/ClientUserInterfaceComponent.cs

@@ -89,13 +89,13 @@ namespace Robust.Client.GameObjects
 
             var playerSession = IoCManager.Resolve<IPlayerManager>().LocalPlayer?.Session;
             if(playerSession != null)
-                IoCManager.Resolve<IEntityManager>().EventBus.RaiseLocalEvent(Owner.Uid, new BoundUIClosedEvent(uiKey, Owner.Uid, playerSession));
+                IoCManager.Resolve<IEntityManager>().EventBus.RaiseLocalEvent(Owner, new BoundUIClosedEvent(uiKey, Owner, playerSession));
         }
 
         internal void SendMessage(BoundUserInterfaceMessage message, object uiKey)
         {
             EntitySystem.Get<UserInterfaceSystem>()
-                .Send(new BoundUIWrapMessage(Owner.Uid, message, uiKey));
+                .Send(new BoundUIWrapMessage(Owner, message, uiKey));
         }
     }
 

Robust.Client/GameObjects/EntitySystems/AnimationPlayerSystem.cs

@@ -46,7 +46,7 @@ namespace Robust.Client.GameObjects
             foreach (var key in remie)
             {
                 component.PlayingAnimations.Remove(key);
-                EntityManager.EventBus.RaiseLocalEvent(component.Owner.Uid, new AnimationCompletedEvent {Uid = component.Owner.Uid, Key = key});
+                EntityManager.EventBus.RaiseLocalEvent(component.Owner, new AnimationCompletedEvent {Uid = component.Owner, Key = key});
                 component.AnimationComplete(key);
             }
 

Robust.Client/GameObjects/EntitySystems/AudioSystem.cs

@@ -125,13 +125,13 @@ namespace Robust.Client.GameObjects
                     }
                     else if (stream.TrackingEntity != null)
                     {
-                        if ((!IoCManager.Resolve<IEntityManager>().EntityExists(stream.TrackingEntity.Uid) ? EntityLifeStage.Deleted : IoCManager.Resolve<IEntityManager>().GetComponent<MetaDataComponent>(stream.TrackingEntity.Uid).EntityLifeStage) >= EntityLifeStage.Deleted)
+                        if ((!IoCManager.Resolve<IEntityManager>().EntityExists(stream.TrackingEntity) ? EntityLifeStage.Deleted : IoCManager.Resolve<IEntityManager>().GetComponent<MetaDataComponent>(stream.TrackingEntity).EntityLifeStage) >= EntityLifeStage.Deleted)
                         {
                             StreamDone(stream);
                             continue;
                         }
 
-                        mapPos = IoCManager.Resolve<IEntityManager>().GetComponent<TransformComponent>(stream.TrackingEntity.Uid).MapPosition;
+                        mapPos = IoCManager.Resolve<IEntityManager>().GetComponent<TransformComponent>(stream.TrackingEntity).MapPosition;
                     }
 
                     // TODO Remove when coordinates can't be NaN
@@ -304,7 +304,7 @@ namespace Robust.Client.GameObjects
             AudioParams? audioParams = null)
         {
             var source = _clyde.CreateAudioSource(stream);
-            if (!source.SetPosition(IoCManager.Resolve<IEntityManager>().GetComponent<TransformComponent>(entity.Uid).WorldPosition))
+            if (!source.SetPosition(IoCManager.Resolve<IEntityManager>().GetComponent<TransformComponent>(entity).WorldPosition))
             {
                 return Play(stream, fallbackCoordinates, fallbackCoordinates, audioParams);
             }
@@ -452,13 +452,13 @@ namespace Robust.Client.GameObjects
         /// <inheritdoc />
         public IPlayingAudioStream? Play(Filter playerFilter, string filename, IEntity entity, AudioParams? audioParams = null)
         {
-            return Play(filename, entity, GetFallbackCoordinates(IoCManager.Resolve<IEntityManager>().GetComponent<TransformComponent>(entity.Uid).MapPosition), audioParams);
+            return Play(filename, entity, GetFallbackCoordinates(IoCManager.Resolve<IEntityManager>().GetComponent<TransformComponent>(entity).MapPosition), audioParams);
         }
 
         public IPlayingAudioStream? Play(Filter playerFilter, string filename, EntityUid uid, AudioParams? audioParams = null)
         {
             return EntityManager.TryGetEntity(uid, out var entity)
-                ? Play(filename, entity, GetFallbackCoordinates(IoCManager.Resolve<IEntityManager>().GetComponent<TransformComponent>(entity.Uid).MapPosition), audioParams) : null;
+                ? Play(filename, entity, GetFallbackCoordinates(IoCManager.Resolve<IEntityManager>().GetComponent<TransformComponent>(entity).MapPosition), audioParams) : null;
         }
 
         /// <inheritdoc />

Robust.Client/GameObjects/EntitySystems/ClientOccluderSystem.cs

@@ -70,14 +70,14 @@ namespace Robust.Client.GameObjects
         private void HandleDirtyEvent(OccluderDirtyEvent ev)
         {
             var sender = ev.Sender;
-            if (IoCManager.Resolve<IEntityManager>().EntityExists(sender.Uid) &&
-                IoCManager.Resolve<IEntityManager>().TryGetComponent(sender.Uid, out ClientOccluderComponent? iconSmooth)
+            if (IoCManager.Resolve<IEntityManager>().EntityExists(sender) &&
+                IoCManager.Resolve<IEntityManager>().TryGetComponent(sender, out ClientOccluderComponent? iconSmooth)
                 && iconSmooth.Running)
             {
-                var grid1 = _mapManager.GetGrid(IoCManager.Resolve<IEntityManager>().GetComponent<TransformComponent>(sender.Uid).GridID);
-                var coords = IoCManager.Resolve<IEntityManager>().GetComponent<TransformComponent>(sender.Uid).Coordinates;
+                var grid1 = _mapManager.GetGrid(IoCManager.Resolve<IEntityManager>().GetComponent<TransformComponent>(sender).GridID);
+                var coords = IoCManager.Resolve<IEntityManager>().GetComponent<TransformComponent>(sender).Coordinates;
 
-                _dirtyEntities.Enqueue(sender.Uid);
+                _dirtyEntities.Enqueue(sender);
                 AddValidEntities(grid1.GetInDir(coords, Direction.North));
                 AddValidEntities(grid1.GetInDir(coords, Direction.South));
                 AddValidEntities(grid1.GetInDir(coords, Direction.East));

Robust.Client/GameObjects/EntitySystems/ContainerSystem.cs

@@ -37,10 +37,10 @@ namespace Robust.Client.GameObjects
 
         private void HandleEntityInitialized(EntityInitializedMessage ev)
         {
-            if (!ExpectedEntities.TryGetValue(ev.Entity.Uid, out var container))
+            if (!ExpectedEntities.TryGetValue(ev.Entity, out var container))
                 return;
 
-            RemoveExpectedEntity(ev.Entity.Uid);
+            RemoveExpectedEntity(ev.Entity);
 
             if (container.Deleted)
                 return;
@@ -92,7 +92,7 @@ namespace Robust.Client.GameObjects
                 List<IEntity>? toRemove = null;
                 foreach (var entity in container.ContainedEntities)
                 {
-                    if (!entityUids.Contains(entity.Uid))
+                    if (!entityUids.Contains(entity))
                     {
                         toRemove ??= new List<IEntity>();
                         toRemove.Add(entity);
@@ -172,7 +172,7 @@ namespace Robust.Client.GameObjects
 
             foreach (var toUpdate in _updateQueue)
             {
-                if ((!IoCManager.Resolve<IEntityManager>().EntityExists(toUpdate.Uid) ? EntityLifeStage.Deleted : IoCManager.Resolve<IEntityManager>().GetComponent<MetaDataComponent>(toUpdate.Uid).EntityLifeStage) >= EntityLifeStage.Deleted)
+                if ((!IoCManager.Resolve<IEntityManager>().EntityExists(toUpdate) ? EntityLifeStage.Deleted : IoCManager.Resolve<IEntityManager>().GetComponent<MetaDataComponent>(toUpdate).EntityLifeStage) >= EntityLifeStage.Deleted)
                 {
                     continue;
                 }
@@ -190,7 +190,7 @@ namespace Robust.Client.GameObjects
             // Am lazy though.
             UpdateEntity(entity);
 
-            foreach (var child in IoCManager.Resolve<IEntityManager>().GetComponent<TransformComponent>(entity.Uid).Children)
+            foreach (var child in IoCManager.Resolve<IEntityManager>().GetComponent<TransformComponent>(entity).Children)
             {
                 UpdateEntityRecursively(child.Owner);
             }
@@ -198,7 +198,7 @@ namespace Robust.Client.GameObjects
 
         private static void UpdateEntity(IEntity entity)
         {
-            if (IoCManager.Resolve<IEntityManager>().TryGetComponent(entity.Uid, out SpriteComponent? sprite))
+            if (IoCManager.Resolve<IEntityManager>().TryGetComponent(entity, out SpriteComponent? sprite))
             {
                 sprite.ContainerOccluded = false;
 
@@ -216,7 +216,7 @@ namespace Robust.Client.GameObjects
                 }
             }
 
-            if (IoCManager.Resolve<IEntityManager>().TryGetComponent(entity.Uid, out PointLightComponent? light))
+            if (IoCManager.Resolve<IEntityManager>().TryGetComponent(entity, out PointLightComponent? light))
             {
                 light.ContainerOccluded = false;
 

Robust.Client/GameObjects/EntitySystems/DebugGridTileLookupSystem.cs

@@ -81,7 +81,7 @@ namespace Robust.Client.GameObjects
 
                 if (!EntityManager.TryGetEntity(uid, out var entity)) continue;
 
-                text.AppendLine((string) IoCManager.Resolve<IEntityManager>().ToPrettyString(entity.Uid));
+                text.AppendLine((string) IoCManager.Resolve<IEntityManager>().ToPrettyString(entity));
             }
 
             _label.Text = text.ToString();

Robust.Client/GameObjects/EntitySystems/EffectSystem.cs

@@ -358,7 +358,7 @@ namespace Robust.Client.GameObjects
                 foreach (var effect in _owner._Effects)
                 {
                     IEntity? tempQualifier = effect.AttachedEntity;
-                    if ((tempQualifier != null ? IoCManager.Resolve<IEntityManager>().GetComponent<TransformComponent>(tempQualifier.Uid) : null).MapID != (player != null ? IoCManager.Resolve<IEntityManager>().GetComponent<TransformComponent>(player.Uid) : null).MapID &&
+                    if ((tempQualifier != null ? IoCManager.Resolve<IEntityManager>().GetComponent<TransformComponent>(tempQualifier) : null).MapID != (player != null ? IoCManager.Resolve<IEntityManager>().GetComponent<TransformComponent>(player) : null).MapID &&
                         effect.Coordinates.GetMapId(_entityManager) != map)
                     {
                         continue;
@@ -377,7 +377,7 @@ namespace Robust.Client.GameObjects
 
                     IEntity? tempQualifier1 = effect.AttachedEntity;
                     var coordinates =
-                        ((tempQualifier1 != null ? IoCManager.Resolve<IEntityManager>().GetComponent<TransformComponent>(tempQualifier1.Uid) : null).Coordinates ?? effect.Coordinates)
+                        ((tempQualifier1 != null ? IoCManager.Resolve<IEntityManager>().GetComponent<TransformComponent>(tempQualifier1) : null).Coordinates ?? effect.Coordinates)
                         .Offset(effect.AttachedOffset);
 
                     var rotation = _entityManager.GetComponent<TransformComponent>(coordinates.EntityId).WorldRotation;

Robust.Client/GameObjects/EntitySystems/EyeUpdateSystem.cs

@@ -71,7 +71,7 @@ namespace Robust.Client.GameObjects
             // TODO: Content should have its own way of handling this. We should have a default behavior that they can overwrite.
 
             IEntity? tempQualifier = _playerManager.LocalPlayer?.ControlledEntity;
-            var playerTransform = (tempQualifier != null ? IoCManager.Resolve<IEntityManager>().GetComponent<TransformComponent>(tempQualifier.Uid) : null);
+            var playerTransform = (tempQualifier != null ? IoCManager.Resolve<IEntityManager>().GetComponent<TransformComponent>(tempQualifier) : null);
 
             if (playerTransform == null) return;
 
@@ -79,8 +79,8 @@ namespace Robust.Client.GameObjects
 
             IEntity tempQualifier1 = _mapManager.GetMapEntity(playerTransform.MapID);
             var parent = gridId != GridId.Invalid && EntityManager.TryGetEntity(_mapManager.GetGrid(gridId).GridEntityId, out var gridEnt) ?
-                IoCManager.Resolve<IEntityManager>().GetComponent<TransformComponent>(gridEnt.Uid)
-                : IoCManager.Resolve<IEntityManager>().GetComponent<TransformComponent>(tempQualifier1.Uid);
+                IoCManager.Resolve<IEntityManager>().GetComponent<TransformComponent>(gridEnt)
+                : IoCManager.Resolve<IEntityManager>().GetComponent<TransformComponent>(tempQualifier1);
 
             // Make sure that we don't fire the vomit carousel when we spawn in
             if (_lastParent is null)

Robust.Client/GameObjects/EntitySystems/GridChunkBoundsDebugSystem.cs

@@ -66,7 +66,7 @@ namespace Robust.Client.GameObjects
             {
                 var gridEnt = _entityManager.GetEntity(grid.GridEntityId);
 
-                if (!_entityManager.TryGetComponent<PhysicsComponent>(gridEnt.Uid, out var body)) continue;
+                if (!_entityManager.TryGetComponent<PhysicsComponent>(gridEnt, out var body)) continue;
 
                 var transform = body.GetTransform();
 

Robust.Client/GameObjects/EntitySystems/InputSystem.cs

@@ -120,12 +120,12 @@ namespace Robust.Client.GameObjects
 
         private static void SetEntityContextActive(IInputManager inputMan, IEntity entity)
         {
-            if(entity == null || !IoCManager.Resolve<IEntityManager>().EntityExists(entity.Uid))
+            if(entity == null || !IoCManager.Resolve<IEntityManager>().EntityExists(entity))
                 throw new ArgumentNullException(nameof(entity));
 
-            if (!IoCManager.Resolve<IEntityManager>().TryGetComponent(entity.Uid, out InputComponent? inputComp))
+            if (!IoCManager.Resolve<IEntityManager>().TryGetComponent(entity, out InputComponent? inputComp))
             {
-                Logger.DebugS("input.context", $"AttachedEnt has no InputComponent: entId={entity.Uid}, entProto={IoCManager.Resolve<IEntityManager>().GetComponent<MetaDataComponent>(entity.Uid).EntityPrototype}. Setting default \"{InputContextContainer.DefaultContextName}\" context...");
+                Logger.DebugS("input.context", $"AttachedEnt has no InputComponent: entId={entity}, entProto={IoCManager.Resolve<IEntityManager>().GetComponent<MetaDataComponent>(entity).EntityPrototype}. Setting default \"{InputContextContainer.DefaultContextName}\" context...");
                 inputMan.Contexts.SetActiveContext(InputContextContainer.DefaultContextName);
                 return;
             }
@@ -136,7 +136,7 @@ namespace Robust.Client.GameObjects
             }
             else
             {
-                Logger.ErrorS("input.context", $"Unknown context: entId={entity.Uid}, entProto={IoCManager.Resolve<IEntityManager>().GetComponent<MetaDataComponent>(entity.Uid).EntityPrototype}, context={inputComp.ContextName}. . Setting default \"{InputContextContainer.DefaultContextName}\" context...");
+                Logger.ErrorS("input.context", $"Unknown context: entId={entity}, entProto={IoCManager.Resolve<IEntityManager>().GetComponent<MetaDataComponent>(entity).EntityPrototype}, context={inputComp.ContextName}. . Setting default \"{InputContextContainer.DefaultContextName}\" context...");
                 inputMan.Contexts.SetActiveContext(InputContextContainer.DefaultContextName);
             }
         }

Robust.Client/GameObjects/EntitySystems/PointLightSystem.cs

@@ -24,7 +24,7 @@ namespace Robust.Client.GameObjects
         private void HandleRemove(EntityUid uid, PointLightComponent component, ComponentRemove args)
         {
             var ent = EntityManager.GetEntity(uid);
-            var map = IoCManager.Resolve<IEntityManager>().GetComponent<TransformComponent>(ent.Uid).MapID;
+            var map = IoCManager.Resolve<IEntityManager>().GetComponent<TransformComponent>(ent).MapID;
             // TODO: Just make this update the tree directly and not allocate
             if (map != MapId.Nullspace)
             {

Robust.Client/GameObjects/EntitySystems/RenderingTreeSystem.cs

@@ -44,11 +44,11 @@ namespace Robust.Client.GameObjects
             foreach (var grid in _mapManager.FindGridsIntersecting(mapId, worldBounds))
             {
                 IEntity tempQualifier = EntityManager.GetEntity(grid.GridEntityId);
-                yield return IoCManager.Resolve<IEntityManager>().GetComponent<RenderingTreeComponent>(tempQualifier.Uid);
+                yield return IoCManager.Resolve<IEntityManager>().GetComponent<RenderingTreeComponent>(tempQualifier);
             }
 
             IEntity tempQualifier1 = _mapManager.GetMapEntity(mapId);
-            yield return IoCManager.Resolve<IEntityManager>().GetComponent<RenderingTreeComponent>(tempQualifier1.Uid);
+            yield return IoCManager.Resolve<IEntityManager>().GetComponent<RenderingTreeComponent>(tempQualifier1);
         }
 
         internal IEnumerable<RenderingTreeComponent> GetRenderTrees(MapId mapId, Box2 worldAABB)
@@ -58,11 +58,11 @@ namespace Robust.Client.GameObjects
             foreach (var grid in _mapManager.FindGridsIntersecting(mapId, worldAABB))
             {
                 IEntity tempQualifier = EntityManager.GetEntity(grid.GridEntityId);
-                yield return IoCManager.Resolve<IEntityManager>().GetComponent<RenderingTreeComponent>(tempQualifier.Uid);
+                yield return IoCManager.Resolve<IEntityManager>().GetComponent<RenderingTreeComponent>(tempQualifier);
             }
 
             IEntity tempQualifier1 = _mapManager.GetMapEntity(mapId);
-            yield return IoCManager.Resolve<IEntityManager>().GetComponent<RenderingTreeComponent>(tempQualifier1.Uid);
+            yield return IoCManager.Resolve<IEntityManager>().GetComponent<RenderingTreeComponent>(tempQualifier1);
         }
 
         public override void Initialize()
@@ -110,23 +110,23 @@ namespace Robust.Client.GameObjects
 
         private void AnythingMoved(ref MoveEvent args)
         {
-            AnythingMovedSubHandler(IoCManager.Resolve<IEntityManager>().GetComponent<TransformComponent>(args.Sender.Uid));
+            AnythingMovedSubHandler(IoCManager.Resolve<IEntityManager>().GetComponent<TransformComponent>(args.Sender));
         }
 
         private void AnythingMovedSubHandler(TransformComponent sender)
         {
             // To avoid doing redundant updates (and we don't need to update a grid's children ever)
-            if (!_checkedChildren.Add(sender.Owner.Uid) ||
-                IoCManager.Resolve<IEntityManager>().HasComponent<RenderingTreeComponent>(sender.Owner.Uid)) return;
+            if (!_checkedChildren.Add(sender.Owner) ||
+                IoCManager.Resolve<IEntityManager>().HasComponent<RenderingTreeComponent>(sender.Owner)) return;
 
             // This recursive search is needed, as MoveEvent is defined to not care about indirect events like children.
             // WHATEVER YOU DO, DON'T REPLACE THIS WITH SPAMMING EVENTS UNLESS YOU HAVE A GUARANTEE IT WON'T LAG THE GC.
             // (Struct-based events ok though)
             // Ironically this was lagging the GC lolz
-            if (IoCManager.Resolve<IEntityManager>().TryGetComponent(sender.Owner.Uid, out SpriteComponent? sprite))
+            if (IoCManager.Resolve<IEntityManager>().TryGetComponent(sender.Owner, out SpriteComponent? sprite))
                 QueueSpriteUpdate(sprite);
 
-            if (IoCManager.Resolve<IEntityManager>().TryGetComponent(sender.Owner.Uid, out PointLightComponent? light))
+            if (IoCManager.Resolve<IEntityManager>().TryGetComponent(sender.Owner, out PointLightComponent? light))
                 QueueLightUpdate(light);
 
             foreach (TransformComponent child in sender.Children)
@@ -251,17 +251,17 @@ namespace Robust.Client.GameObjects
 
         internal static RenderingTreeComponent? GetRenderTree(IEntity entity)
         {
-            if ((!IoCManager.Resolve<IEntityManager>().EntityExists(entity.Uid) ? EntityLifeStage.Deleted : IoCManager.Resolve<IEntityManager>().GetComponent<MetaDataComponent>(entity.Uid).EntityLifeStage) >= EntityLifeStage.Deleted || IoCManager.Resolve<IEntityManager>().GetComponent<TransformComponent>(entity.Uid).MapID == MapId.Nullspace ||
-                IoCManager.Resolve<IEntityManager>().HasComponent<RenderingTreeComponent>(entity.Uid)) return null;
+            if ((!IoCManager.Resolve<IEntityManager>().EntityExists(entity) ? EntityLifeStage.Deleted : IoCManager.Resolve<IEntityManager>().GetComponent<MetaDataComponent>(entity).EntityLifeStage) >= EntityLifeStage.Deleted || IoCManager.Resolve<IEntityManager>().GetComponent<TransformComponent>(entity).MapID == MapId.Nullspace ||
+                IoCManager.Resolve<IEntityManager>().HasComponent<RenderingTreeComponent>(entity)) return null;
 
-            var parent = IoCManager.Resolve<IEntityManager>().GetComponent<TransformComponent>(entity.Uid).Parent?.Owner;
+            var parent = IoCManager.Resolve<IEntityManager>().GetComponent<TransformComponent>(entity).Parent?.Owner;
 
             while (true)
             {
                 if (parent == null) break;
 
-                if (IoCManager.Resolve<IEntityManager>().TryGetComponent(parent.Uid, out RenderingTreeComponent? comp)) return comp;
-                parent = IoCManager.Resolve<IEntityManager>().GetComponent<TransformComponent>(parent.Uid).Parent?.Owner;
+                if (IoCManager.Resolve<IEntityManager>().TryGetComponent(parent, out RenderingTreeComponent? comp)) return comp;
+                parent = IoCManager.Resolve<IEntityManager>().GetComponent<TransformComponent>(parent).Parent?.Owner;
             }
 
             return null;
@@ -288,7 +288,7 @@ namespace Robust.Client.GameObjects
                 var oldMapTree = sprite.RenderTree;
                 var newMapTree = GetRenderTree(sprite.Owner);
                 // TODO: Temp PVS guard
-                var worldPos = IoCManager.Resolve<IEntityManager>().GetComponent<TransformComponent>(sprite.Owner.Uid).WorldPosition;
+                var worldPos = IoCManager.Resolve<IEntityManager>().GetComponent<TransformComponent>(sprite.Owner).WorldPosition;
 
                 if (float.IsNaN(worldPos.X) || float.IsNaN(worldPos.Y))
                 {
@@ -325,7 +325,7 @@ namespace Robust.Client.GameObjects
                 var oldMapTree = light.RenderTree;
                 var newMapTree = GetRenderTree(light.Owner);
                 // TODO: Temp PVS guard
-                var worldPos = IoCManager.Resolve<IEntityManager>().GetComponent<TransformComponent>(light.Owner.Uid).WorldPosition;
+                var worldPos = IoCManager.Resolve<IEntityManager>().GetComponent<TransformComponent>(light.Owner).WorldPosition;
 
                 if (float.IsNaN(worldPos.X) || float.IsNaN(worldPos.Y))
                 {

Robust.Client/GameObjects/EntitySystems/SpriteSystem.cs

@@ -55,7 +55,7 @@ namespace Robust.Client.GameObjects
 
             foreach (var comp in _treeSystem.GetRenderTrees(currentMap, pvsBounds))
             {
-                var bounds = IoCManager.Resolve<IEntityManager>().GetComponent<TransformComponent>(comp.Owner.Uid).InvWorldMatrix.TransformBox(pvsBounds);
+                var bounds = IoCManager.Resolve<IEntityManager>().GetComponent<TransformComponent>(comp.Owner).InvWorldMatrix.TransformBox(pvsBounds);
 
                 comp.SpriteTree.QueryAabb(ref frameTime, (ref float state, in SpriteComponent value) =>
                 {

Robust.Client/GameObjects/EntitySystems/VelocityDebugSystem.cs

@@ -35,13 +35,13 @@ namespace Robust.Client.GameObjects
 
             var player = _playerManager.LocalPlayer?.ControlledEntity;
 
-            if (player == null || !IoCManager.Resolve<IEntityManager>().TryGetComponent(player.Uid, out PhysicsComponent? body))
+            if (player == null || !IoCManager.Resolve<IEntityManager>().TryGetComponent(player, out PhysicsComponent? body))
             {
                 _label.Visible = false;
                 return;
             }
 
-            var screenPos = _eyeManager.WorldToScreen(IoCManager.Resolve<IEntityManager>().GetComponent<TransformComponent>(player.Uid).WorldPosition);
+            var screenPos = _eyeManager.WorldToScreen(IoCManager.Resolve<IEntityManager>().GetComponent<TransformComponent>(player).WorldPosition);
             LayoutContainer.SetPosition(_label, screenPos + new Vector2(0, 50));
             _label.Visible = true;
 

Robust.Client/GameStates/ClientGameStateManager.cs

@@ -341,21 +341,21 @@ namespace Robust.Client.GameStates
             foreach (var entity in _entities.GetEntities())
             {
                 // TODO: 99% there's an off-by-one here.
-                if (entity.Uid.IsClientSide() || IoCManager.Resolve<IEntityManager>().GetComponent<MetaDataComponent>(entity.Uid).EntityLastModifiedTick < curTick)
+                if (entity.IsClientSide() || IoCManager.Resolve<IEntityManager>().GetComponent<MetaDataComponent>(entity).EntityLastModifiedTick < curTick)
                 {
                     continue;
                 }
 
-                Logger.DebugS(CVars.NetPredict.Name, $"Entity {entity.Uid} was made dirty.");
+                Logger.DebugS(CVars.NetPredict.Name, $"Entity {entity} was made dirty.");
 
-                if (!_processor.TryGetLastServerStates(entity.Uid, out var last))
+                if (!_processor.TryGetLastServerStates(entity, out var last))
                 {
                     // Entity was probably deleted on the server so do nothing.
                     continue;
                 }
 
                 // TODO: handle component deletions/creations.
-                foreach (var (netId, comp) in _entityManager.GetNetComponents(entity.Uid))
+                foreach (var (netId, comp) in _entityManager.GetNetComponents(entity))
                 {
                     DebugTools.AssertNotNull(netId);
 
@@ -456,8 +456,8 @@ namespace Robust.Client.GameStates
                     var newEntity = _entities.CreateEntity(metaState.PrototypeId, es.Uid);
                     toApply.Add(newEntity, (es, null));
                     toInitialize.Add(newEntity);
-                    created.Add(newEntity.Uid);
-                    uid = newEntity.Uid;
+                    created.Add(newEntity);
+                    uid = newEntity;
                 }
                 if(es.Hide)
                     toHide.Add(uid);
@@ -563,7 +563,7 @@ namespace Robust.Client.GameStates
             EntityState? nextState)
         {
             var compStateWork = new Dictionary<ushort, (ComponentState? curState, ComponentState? nextState)>();
-            var entityUid = entity.Uid;
+            var entityUid = (EntityUid) entity;
 
             if (curState != null)
             {

Robust.Client/GameStates/NetEntityOverlay.cs

@@ -111,7 +111,7 @@ namespace Robust.Client.GameStates
                 {
                     //TODO: Whoever is working on PVS remake, change the InPVS detection.
                     IEntity tempQualifier = _entityManager.GetEntity(netEnt.Id);
-                    var position = IoCManager.Resolve<IEntityManager>().GetComponent<TransformComponent>(tempQualifier.Uid).MapPosition;
+                    var position = IoCManager.Resolve<IEntityManager>().GetComponent<TransformComponent>(tempQualifier).MapPosition;
                     netEnt.InPVS =  !pvsEnabled || (pvsBox.Contains(position.Position) && position.MapId == pvsCenter.MapId);
                     _netEnts[i] = netEnt; // copy struct back
                     continue;
@@ -178,7 +178,7 @@ namespace Robust.Client.GameStates
 
                 var xPos = 100;
                 var yPos = 10 + _lineHeight * i;
-                var name = $"({netEnt.Id}) {IoCManager.Resolve<IEntityManager>().GetComponent<MetaDataComponent>(ent.Uid).EntityPrototype?.ID}";
+                var name = $"({netEnt.Id}) {IoCManager.Resolve<IEntityManager>().GetComponent<MetaDataComponent>(ent).EntityPrototype?.ID}";
                 var color = CalcTextColor(ref netEnt);
                 screenHandle.DrawString(_font, new Vector2(xPos + (TrafficHistorySize + 4), yPos), name, color);
                 DrawTrafficBox(screenHandle, ref netEnt, xPos, yPos);

Robust.Client/GameStates/NetInterpOverlay.cs

@@ -35,7 +35,7 @@ namespace Robust.Client.GameStates
             foreach (var boundingBox in _entityManager.EntityQuery<IPhysBody>(true))
             {
                 // all entities have a TransformComponent
-                var transform = IoCManager.Resolve<IEntityManager>().GetComponent<TransformComponent>(boundingBox.Owner.Uid);
+                var transform = IoCManager.Resolve<IEntityManager>().GetComponent<TransformComponent>(boundingBox.Owner);
 
                 // if not on the same map, continue
                 if (transform.MapID != _eyeManager.CurrentMap || boundingBox.Owner.IsInContainer())

Robust.Client/Graphics/Clyde/Clyde.HLR.cs

@@ -374,14 +374,14 @@ namespace Robust.Client.Graphics.Clyde
         {
             foreach (var comp in _entitySystemManager.GetEntitySystem<RenderingTreeSystem>().GetRenderTrees(map, worldBounds))
             {
-                var bounds = IoCManager.Resolve<IEntityManager>().GetComponent<TransformComponent>(comp.Owner.Uid).InvWorldMatrix.TransformBox(worldBounds);
+                var bounds = IoCManager.Resolve<IEntityManager>().GetComponent<TransformComponent>(comp.Owner).InvWorldMatrix.TransformBox(worldBounds);
 
                 comp.SpriteTree.QueryAabb(ref list, (
                     ref RefList<(SpriteComponent sprite, Matrix3 matrix, Angle worldRot, float yWorldPos)> state,
                     in SpriteComponent value) =>
                 {
                     var entity = value.Owner;
-                    var transform = IoCManager.Resolve<IEntityManager>().GetComponent<TransformComponent>(entity.Uid);
+                    var transform = IoCManager.Resolve<IEntityManager>().GetComponent<TransformComponent>(entity);
 
                     ref var entry = ref state.AllocAdd();
                     entry.sprite = value;

Robust.Client/Graphics/Clyde/Clyde.LightRendering.cs

@@ -331,7 +331,7 @@ namespace Robust.Client.Graphics.Clyde
 
             // If this map has lighting disabled, return
             IEntity tempQualifier = _mapManager.GetMapEntity(mapId);
-            if (!IoCManager.Resolve<IEntityManager>().GetComponent<IMapComponent>(tempQualifier.Uid).LightingEnabled)
+            if (!IoCManager.Resolve<IEntityManager>().GetComponent<IMapComponent>(tempQualifier).LightingEnabled)
             {
                 return;
             }
@@ -415,7 +415,7 @@ namespace Robust.Client.Graphics.Clyde
             {
                 var (component, lightPos, _) = lights[i];
 
-                var transform = IoCManager.Resolve<IEntityManager>().GetComponent<TransformComponent>(component.Owner.Uid);
+                var transform = IoCManager.Resolve<IEntityManager>().GetComponent<TransformComponent>(component.Owner);
 
                 Texture? mask = null;
                 var rotation = Angle.Zero;
@@ -518,7 +518,7 @@ namespace Robust.Client.Graphics.Clyde
 
             foreach (var comp in renderingTreeSystem.GetRenderTrees(map, enlargedBounds))
             {
-                var bounds = IoCManager.Resolve<IEntityManager>().GetComponent<TransformComponent>(comp.Owner.Uid).InvWorldMatrix.TransformBox(worldBounds);
+                var bounds = IoCManager.Resolve<IEntityManager>().GetComponent<TransformComponent>(comp.Owner).InvWorldMatrix.TransformBox(worldBounds);
 
                 comp.LightTree.QueryAabb(ref state, (ref (Clyde clyde, Box2 worldAABB, int count) state, in PointLightComponent light) =>
                 {
@@ -528,7 +528,7 @@ namespace Robust.Client.Graphics.Clyde
                         return false;
                     }
 
-                    var transform = IoCManager.Resolve<IEntityManager>().GetComponent<TransformComponent>(light.Owner.Uid);
+                    var transform = IoCManager.Resolve<IEntityManager>().GetComponent<TransformComponent>(light.Owner);
 
                     if (float.IsNaN(transform.LocalPosition.X) || float.IsNaN(transform.LocalPosition.Y)) return true;
 
@@ -873,12 +873,12 @@ namespace Robust.Client.Graphics.Clyde
 
                 foreach (var comp in occluderSystem.GetOccluderTrees(map, expandedBounds))
                 {
-                    var treeBounds = IoCManager.Resolve<IEntityManager>().GetComponent<TransformComponent>(comp.Owner.Uid).InvWorldMatrix.TransformBox(expandedBounds);
+                    var treeBounds = IoCManager.Resolve<IEntityManager>().GetComponent<TransformComponent>(comp.Owner).InvWorldMatrix.TransformBox(expandedBounds);
 
                     comp.Tree.QueryAabb((in OccluderComponent sOccluder) =>
                     {
                         var occluder = (ClientOccluderComponent)sOccluder;
-                        var transform = IoCManager.Resolve<IEntityManager>().GetComponent<TransformComponent>(occluder.Owner.Uid);
+                        var transform = IoCManager.Resolve<IEntityManager>().GetComponent<TransformComponent>(occluder.Owner);
                         if (!occluder.Enabled)
                         {
                             return true;

Robust.Client/Graphics/Clyde/Clyde.RenderHandle.cs

@@ -125,12 +125,12 @@ namespace Robust.Client.Graphics.Clyde
 
             public void DrawEntity(IEntity entity, Vector2 position, Vector2 scale, Direction? overrideDirection)
             {
-                if ((!IoCManager.Resolve<IEntityManager>().EntityExists(entity.Uid) ? EntityLifeStage.Deleted : IoCManager.Resolve<IEntityManager>().GetComponent<MetaDataComponent>(entity.Uid).EntityLifeStage) >= EntityLifeStage.Deleted)
+                if ((!IoCManager.Resolve<IEntityManager>().EntityExists(entity) ? EntityLifeStage.Deleted : IoCManager.Resolve<IEntityManager>().GetComponent<MetaDataComponent>(entity).EntityLifeStage) >= EntityLifeStage.Deleted)
                 {
                     throw new ArgumentException("Tried to draw an entity has been deleted.", nameof(entity));
                 }
 
-                var sprite = IoCManager.Resolve<IEntityManager>().GetComponent<SpriteComponent>(entity.Uid);
+                var sprite = IoCManager.Resolve<IEntityManager>().GetComponent<SpriteComponent>(entity);
 
                 var oldProj = _clyde._currentMatrixProj;
                 var oldView = _clyde._currentMatrixView;
@@ -163,7 +163,7 @@ namespace Robust.Client.Graphics.Clyde
                     DrawingHandleWorld,
                     Angle.Zero,
                     overrideDirection == null
-                        ? IoCManager.Resolve<IEntityManager>().GetComponent<TransformComponent>(entity.Uid).WorldRotation
+                        ? IoCManager.Resolve<IEntityManager>().GetComponent<TransformComponent>(entity).WorldRotation
                         : Angle.Zero,
                     overrideDirection);
 

Robust.Client/Graphics/Clyde/Clyde.Rendering.cs

@@ -6,6 +6,7 @@ using System.Runtime.InteropServices;
 using OpenToolkit.Graphics.OpenGL4;
 using Robust.Client.GameObjects;
 using Robust.Client.Utility;
+using Robust.Shared.GameObjects;
 using Robust.Shared.Maths;
 using Robust.Shared.Utility;
 using Color = Robust.Shared.Maths.Color;
@@ -1027,7 +1028,7 @@ namespace Robust.Client.Graphics.Clyde
                     return cmp;
                 }
 
-                return a.Owner.Uid.CompareTo(b.Owner.Uid);
+                return a.Owner.CompareTo(b.Owner);
             }
         }
 

Robust.Client/Placement/Modes/AlignSimilar.cs

@@ -32,8 +32,8 @@ namespace Robust.Client.Placement.Modes
             var mapId = MouseCoords.GetMapId(pManager.EntityManager);
 
             var snapToEntities = IoCManager.Resolve<IEntityLookup>().GetEntitiesInRange(MouseCoords, SnapToRange)
-                .Where(entity => IoCManager.Resolve<IEntityManager>().GetComponent<MetaDataComponent>(entity.Uid).EntityPrototype == pManager.CurrentPrototype && IoCManager.Resolve<IEntityManager>().GetComponent<TransformComponent>(entity.Uid).MapID == mapId)
-                .OrderBy(entity => (IoCManager.Resolve<IEntityManager>().GetComponent<TransformComponent>(entity.Uid).WorldPosition - MouseCoords.ToMapPos(pManager.EntityManager)).LengthSquared)
+                .Where(entity => IoCManager.Resolve<IEntityManager>().GetComponent<MetaDataComponent>(entity).EntityPrototype == pManager.CurrentPrototype && IoCManager.Resolve<IEntityManager>().GetComponent<TransformComponent>(entity).MapID == mapId)
+                .OrderBy(entity => (IoCManager.Resolve<IEntityManager>().GetComponent<TransformComponent>(entity).WorldPosition - MouseCoords.ToMapPos(pManager.EntityManager)).LengthSquared)
                 .ToList();
 
             if (snapToEntities.Count == 0)
@@ -42,7 +42,7 @@ namespace Robust.Client.Placement.Modes
             }
 
             var closestEntity = snapToEntities[0];
-            if (!IoCManager.Resolve<IEntityManager>().TryGetComponent<ISpriteComponent?>(closestEntity.Uid, out var component) || component.BaseRSI == null)
+            if (!IoCManager.Resolve<IEntityManager>().TryGetComponent<ISpriteComponent?>(closestEntity, out var component) || component.BaseRSI == null)
             {
                 return;
             }
@@ -51,8 +51,8 @@ namespace Robust.Client.Placement.Modes
 
             var closestRect =
                 Box2.FromDimensions(
-                    IoCManager.Resolve<IEntityManager>().GetComponent<TransformComponent>(closestEntity.Uid).WorldPosition.X - closestBounds.X / 2f,
-                    IoCManager.Resolve<IEntityManager>().GetComponent<TransformComponent>(closestEntity.Uid).WorldPosition.Y - closestBounds.Y / 2f,
+                    IoCManager.Resolve<IEntityManager>().GetComponent<TransformComponent>(closestEntity).WorldPosition.X - closestBounds.X / 2f,
+                    IoCManager.Resolve<IEntityManager>().GetComponent<TransformComponent>(closestEntity).WorldPosition.Y - closestBounds.Y / 2f,
                     closestBounds.X, closestBounds.Y);
 
             var sides = new[]

Robust.Client/Placement/PlacementManager.cs

@@ -421,7 +421,7 @@ namespace Robust.Client.Placement
 
             var msg = NetworkManager.CreateNetMessage<MsgPlacement>();
             msg.PlaceType = PlacementManagerMessage.RequestEntRemove;
-            msg.EntityUid = entity.Uid;
+            msg.EntityUid = entity;
             NetworkManager.ClientSendMessage(msg);
         }
 
@@ -496,7 +496,7 @@ namespace Robust.Client.Placement
             var ent = PlayerManager.LocalPlayer!.ControlledEntity;
             if (ent != null)
             {
-                map = IoCManager.Resolve<IEntityManager>().GetComponent<TransformComponent>(ent.Uid).MapID;
+                map = IoCManager.Resolve<IEntityManager>().GetComponent<TransformComponent>(ent).MapID;
             }
 
             if (map == MapId.Nullspace || CurrentPermission == null || CurrentMode == null)
@@ -519,7 +519,7 @@ namespace Robust.Client.Placement
             }
             else
             {
-                var map = IoCManager.Resolve<IEntityManager>().GetComponent<TransformComponent>(ent.Uid).MapID;
+                var map = IoCManager.Resolve<IEntityManager>().GetComponent<TransformComponent>(ent).MapID;
                 if (map == MapId.Nullspace || !Eraser)
                 {
                     coordinates = new EntityCoordinates();
@@ -638,7 +638,7 @@ namespace Robust.Client.Placement
                 || PlayerManager.LocalPlayer?.ControlledEntity == null)
                 return;
 
-            var worldPos = IoCManager.Resolve<IEntityManager>().GetComponent<TransformComponent>(PlayerManager.LocalPlayer.ControlledEntity.Uid).WorldPosition;
+            var worldPos = IoCManager.Resolve<IEntityManager>().GetComponent<TransformComponent>(PlayerManager.LocalPlayer.ControlledEntity).WorldPosition;
 
             handle.DrawCircle(worldPos, CurrentPermission.Range, new Color(1, 1, 1, 0.25f));
         }
@@ -661,8 +661,8 @@ namespace Robust.Client.Placement
         {
             if (CurrentPlacementOverlayEntity != null)
             {
-                if (!((!IoCManager.Resolve<IEntityManager>().EntityExists(CurrentPlacementOverlayEntity.Uid) ? EntityLifeStage.Deleted : IoCManager.Resolve<IEntityManager>().GetComponent<MetaDataComponent>(CurrentPlacementOverlayEntity.Uid).EntityLifeStage) >= EntityLifeStage.Deleted))
-                    IoCManager.Resolve<IEntityManager>().DeleteEntity(CurrentPlacementOverlayEntity.Uid);
+                if (!((!IoCManager.Resolve<IEntityManager>().EntityExists(CurrentPlacementOverlayEntity) ? EntityLifeStage.Deleted : IoCManager.Resolve<IEntityManager>().GetComponent<MetaDataComponent>(CurrentPlacementOverlayEntity).EntityLifeStage) >= EntityLifeStage.Deleted))
+                    IoCManager.Resolve<IEntityManager>().DeleteEntity((EntityUid) CurrentPlacementOverlayEntity);
                 CurrentPlacementOverlayEntity = null;
             }
         }

Robust.Client/Placement/PlacementMode.cs

@@ -88,9 +88,9 @@ namespace Robust.Client.Placement
         public virtual void Render(DrawingHandleWorld handle)
         {
             var sce = pManager.CurrentPlacementOverlayEntity;
-            if (sce == null || (!IoCManager.Resolve<IEntityManager>().EntityExists(sce.Uid) ? EntityLifeStage.Deleted : IoCManager.Resolve<IEntityManager>().GetComponent<MetaDataComponent>(sce.Uid).EntityLifeStage) >= EntityLifeStage.Deleted)
+            if (sce == null || (!IoCManager.Resolve<IEntityManager>().EntityExists(sce) ? EntityLifeStage.Deleted : IoCManager.Resolve<IEntityManager>().GetComponent<MetaDataComponent>(sce).EntityLifeStage) >= EntityLifeStage.Deleted)
                 return;
-            var sc = IoCManager.Resolve<IEntityManager>().GetComponent<SpriteComponent>(sce.Uid);
+            var sc = IoCManager.Resolve<IEntityManager>().GetComponent<SpriteComponent>(sce);
 
             IEnumerable<EntityCoordinates> locationcollection;
             switch (pManager.PlacementType)
@@ -116,7 +116,7 @@ namespace Robust.Client.Placement
                     return; // Just some paranoia just in case
                 var entity = coordinate.GetEntity(pManager.EntityManager);
                 var worldPos = coordinate.ToMapPos(pManager.EntityManager);
-                var worldRot = IoCManager.Resolve<IEntityManager>().GetComponent<TransformComponent>(entity.Uid).WorldRotation + dirAng;
+                var worldRot = IoCManager.Resolve<IEntityManager>().GetComponent<TransformComponent>(entity).WorldRotation + dirAng;
 
                 sc.Color = IsValidPosition(coordinate) ? ValidPlaceColor : InvalidPlaceColor;
                 sc.Render(handle, pManager.eyeManager.CurrentEye.Rotation, worldRot, worldPos);
@@ -206,7 +206,7 @@ namespace Robust.Client.Placement
             }
 
             var range = pManager.CurrentPermission!.Range;
-            if (range > 0 && !IoCManager.Resolve<IEntityManager>().GetComponent<TransformComponent>(pManager.PlayerManager.LocalPlayer.ControlledEntity.Uid).Coordinates.InRange(pManager.EntityManager, coordinates, range))
+            if (range > 0 && !IoCManager.Resolve<IEntityManager>().GetComponent<TransformComponent>(pManager.PlayerManager.LocalPlayer.ControlledEntity).Coordinates.InRange(pManager.EntityManager, coordinates, range))
                 return false;
             return true;
         }

Robust.Client/Player/LocalPlayer.cs

@@ -30,7 +30,7 @@ namespace Robust.Client.Player
         /// </summary>
         [ViewVariables] public IEntity? ControlledEntity { get; private set; }
 
-        [ViewVariables] public EntityUid? ControlledEntityUid => ControlledEntity?.Uid;
+        [ViewVariables] public EntityUid? ControlledEntityUid => ControlledEntity;
 
 
         [ViewVariables] public NetUserId UserId { get; set; }
@@ -66,7 +66,7 @@ namespace Robust.Client.Player
             ControlledEntity = entity;
             InternalSession.AttachedEntity = entity;
 
-            if (!IoCManager.Resolve<IEntityManager>().TryGetComponent<EyeComponent?>(ControlledEntity.Uid, out var eye))
+            if (!IoCManager.Resolve<IEntityManager>().TryGetComponent<EyeComponent?>(ControlledEntity, out var eye))
             {
                 eye = IoCManager.Resolve<IEntityManager>().AddComponent<EyeComponent>(ControlledEntity);
             }
@@ -76,7 +76,7 @@ namespace Robust.Client.Player
 
             // notify ECS Systems
             IoCManager.Resolve<IEntityManager>().EventBus.RaiseEvent(EventSource.Local, new PlayerAttachSysMessage(ControlledEntity));
-            IoCManager.Resolve<IEntityManager>().EventBus.RaiseLocalEvent(ControlledEntity.Uid, new PlayerAttachedEvent(ControlledEntity));
+            IoCManager.Resolve<IEntityManager>().EventBus.RaiseLocalEvent(ControlledEntity, new PlayerAttachedEvent(ControlledEntity));
         }
 
         /// <summary>
@@ -87,11 +87,11 @@ namespace Robust.Client.Player
             var previous = ControlledEntity;
             if (previous is {((!IoCManager.Resolve<IEntityManager>().EntityExists(Uid) ? EntityLifeStage.Deleted : IoCManager.Resolve<IEntityManager>().GetComponent<MetaDataComponent>(Uid).EntityLifeStage) >= EntityLifeStage.Initialized): true, ((!IoCManager.Resolve<IEntityManager>().EntityExists(Uid) ? EntityLifeStage.Deleted : IoCManager.Resolve<IEntityManager>().GetComponent<MetaDataComponent>(Uid).EntityLifeStage) >= EntityLifeStage.Deleted): false})
             {
-                IoCManager.Resolve<IEntityManager>().GetComponent<EyeComponent>(previous.Uid).Current = false;
+                IoCManager.Resolve<IEntityManager>().GetComponent<EyeComponent>(previous).Current = false;
 
                 // notify ECS Systems
                 IoCManager.Resolve<IEntityManager>().EventBus.RaiseEvent(EventSource.Local, new PlayerAttachSysMessage(null));
-                IoCManager.Resolve<IEntityManager>().EventBus.RaiseLocalEvent(previous.Uid, new PlayerDetachedEvent(previous));
+                IoCManager.Resolve<IEntityManager>().EventBus.RaiseLocalEvent(previous, new PlayerDetachedEvent(previous));
             }
 
             ControlledEntity = null;

Robust.Client/Player/PlayerManager.cs

@@ -140,7 +140,7 @@ namespace Robust.Client.Player
         /// <param name="entity">AttachedEntity in the server session.</param>
         private void UpdateAttachedEntity(EntityUid? entity)
         {
-            if (LocalPlayer!.ControlledEntity?.Uid == entity)
+            if (LocalPlayer!.ControlledEntity == entity)
             {
                 return;
             }

Robust.Client/Player/PlayerSession.cs

@@ -20,7 +20,7 @@ namespace Robust.Client.Player
         public IEntity? AttachedEntity { get; set; }
 
         /// <inheritdoc />
-        public EntityUid? AttachedEntityUid => AttachedEntity?.Uid;
+        public EntityUid? AttachedEntityUid => AttachedEntity;
 
         /// <inheritdoc />
         public NetUserId UserId { get; }

Robust.Client/UserInterface/CustomControls/DebugCoordsPanel.cs

@@ -96,17 +96,17 @@ Mouse Pos:
             }
             else
             {
-                var entityTransform = IoCManager.Resolve<IEntityManager>().GetComponent<TransformComponent>(_playerManager.LocalPlayer.ControlledEntity.Uid);
+                var entityTransform = IoCManager.Resolve<IEntityManager>().GetComponent<TransformComponent>(_playerManager.LocalPlayer.ControlledEntity);
                 var playerWorldOffset = entityTransform.MapPosition;
                 var playerScreen = _eyeManager.WorldToScreen(playerWorldOffset.Position);
 
-                var playerCoordinates = IoCManager.Resolve<IEntityManager>().GetComponent<TransformComponent>(_playerManager.LocalPlayer.ControlledEntity.Uid).Coordinates;
+                var playerCoordinates = IoCManager.Resolve<IEntityManager>().GetComponent<TransformComponent>(_playerManager.LocalPlayer.ControlledEntity).Coordinates;
 
                 stringBuilder.AppendFormat(@"    Screen: {0}
     {1}
     {2}
     EntId: {3}
-    GridID: {4}", playerScreen, playerWorldOffset, playerCoordinates, entityTransform.Owner.Uid,
+    GridID: {4}", playerScreen, playerWorldOffset, playerCoordinates, entityTransform.Owner,
                     entityTransform.GridID);
             }
 

Robust.Client/ViewVariables/Instances/ViewVariablesInstanceEntity.cs

@@ -108,7 +108,7 @@ namespace Robust.Client.ViewVariables.Instances
                     top = new Label {Text = stringified};
                 }
 
-                if (IoCManager.Resolve<IEntityManager>().TryGetComponent(_entity.Uid, out ISpriteComponent? sprite))
+                if (IoCManager.Resolve<IEntityManager>().TryGetComponent(_entity, out ISpriteComponent? sprite))
                 {
                     var hBox = new BoxContainer
                     {
@@ -161,7 +161,7 @@ namespace Robust.Client.ViewVariables.Instances
 
             PopulateClientComponents();
 
-            if (!_entity.Uid.IsClientSide())
+            if (!_entity.IsClientSide())
             {
                 _serverVariables = new BoxContainer
                 {
@@ -202,7 +202,7 @@ namespace Robust.Client.ViewVariables.Instances
             _clientComponentsAddButton.OnPressed += OnClientComponentsAddButtonPressed;
             _clientComponentsSearchBar.OnTextChanged += OnClientComponentsSearchBarChanged;
 
-            var componentList = IoCManager.Resolve<IEntityManager>().GetComponents(_entity.Uid).OrderBy(c => c.GetType().ToString());
+            var componentList = IoCManager.Resolve<IEntityManager>().GetComponents(_entity).OrderBy(c => c.GetType().ToString());
 
             foreach (var component in componentList)
             {
@@ -266,12 +266,12 @@ namespace Robust.Client.ViewVariables.Instances
                 button.OnPressed += _ =>
                 {
                     ViewVariablesManager.OpenVV(
-                        new ViewVariablesComponentSelector(_entity.Uid, componentType.FullName));
+                        new ViewVariablesComponentSelector(_entity, componentType.FullName));
                 };
                 removeButton.OnPressed += _ =>
                 {
                     // We send a command to remove the component.
-                    IoCManager.Resolve<IClientConsoleHost>().RemoteExecuteCommand(null, $"rmcomp {_entity.Uid} {componentType.ComponentName}");
+                    IoCManager.Resolve<IClientConsoleHost>().RemoteExecuteCommand(null, $"rmcomp {_entity} {componentType.ComponentName}");
                     PopulateServerComponents();
                 };
                 button.AddChild(removeButton);
@@ -392,7 +392,7 @@ namespace Robust.Client.ViewVariables.Instances
 
             foreach (var type in componentFactory.AllRegisteredTypes)
             {
-                if (IoCManager.Resolve<IEntityManager>().HasComponent(_entity.Uid, type))
+                if (IoCManager.Resolve<IEntityManager>().HasComponent(_entity, type))
                     continue;
 
                 yield return (componentFactory.GetRegistration(type).Name);
@@ -415,7 +415,7 @@ namespace Robust.Client.ViewVariables.Instances
             if (_addComponentServer)
             {
                 // Attempted to add a component to the server entity... We send a command.
-                IoCManager.Resolve<IClientConsoleHost>().RemoteExecuteCommand(null, $"addcomp {_entity.Uid} {eventArgs.Entry}");
+                IoCManager.Resolve<IClientConsoleHost>().RemoteExecuteCommand(null, $"addcomp {_entity} {eventArgs.Entry}");
                 PopulateServerComponents();
                 _addComponentWindow?.Populate(await GetValidServerComponentsForAdding());
                 return;
@@ -446,7 +446,7 @@ namespace Robust.Client.ViewVariables.Instances
         {
             try
             {
-                _entityManager.RemoveComponent(_entity.Uid, component);
+                _entityManager.RemoveComponent(_entity, component);
             }
             catch (Exception e)
             {
@@ -503,7 +503,7 @@ namespace Robust.Client.ViewVariables.Instances
                 try
                 {
                     _entitySession =
-                        await ViewVariablesManager.RequestSession(new ViewVariablesEntitySelector(_entity.Uid));
+                        await ViewVariablesManager.RequestSession(new ViewVariablesEntitySelector(_entity));
                 }
                 catch (SessionDenyException e)
                 {

Robust.Client/ViewVariables/ViewVariablesManager.cs

@@ -213,7 +213,7 @@ namespace Robust.Client.ViewVariables
         {
             // TODO: more flexibility in allowing custom instances here.
             ViewVariablesInstance instance;
-            if (obj is IEntity entity && !((!IoCManager.Resolve<IEntityManager>().EntityExists(entity.Uid) ? EntityLifeStage.Deleted : IoCManager.Resolve<IEntityManager>().GetComponent<MetaDataComponent>(entity.Uid).EntityLifeStage) >= EntityLifeStage.Deleted))
+            if (obj is IEntity entity && !((!IoCManager.Resolve<IEntityManager>().EntityExists(entity) ? EntityLifeStage.Deleted : IoCManager.Resolve<IEntityManager>().GetComponent<MetaDataComponent>(entity).EntityLifeStage) >= EntityLifeStage.Deleted))
             {
                 instance = new ViewVariablesInstanceEntity(this, _entityManager, _robustSerializer);
             }

Robust.Server/Bql/BqlQuerySelector.Builtin.cs

@@ -308,7 +308,7 @@ namespace Robust.Server.Bql
                 .SelectMany(e =>
                     entityLookup.GetEntitiesInRange(entityManager.GetComponent<TransformComponent>(e).Coordinates,
                         radius))
-                .Select(x => x.Uid) // Sloth's fault.
+                .Select(x => (EntityUid) x) // Sloth's fault.
                 .Distinct();
         }
     }

Robust.Server/Bql/ForAllCommand.cs

@@ -39,31 +39,31 @@ namespace Robust.Server.Bql
         private static string SubstituteEntityDetails(IConsoleShell shell, IEntity ent, string ruleString)
         {
             // gross, is there a better way to do this?
-            ruleString = ruleString.Replace("$ID", ent.Uid.ToString());
+            ruleString = ruleString.Replace("$ID", ent.ToString());
             ruleString = ruleString.Replace("$WX",
-                IoCManager.Resolve<IEntityManager>().GetComponent<TransformComponent>(ent.Uid).WorldPosition.X.ToString(CultureInfo.InvariantCulture));
+                IoCManager.Resolve<IEntityManager>().GetComponent<TransformComponent>(ent).WorldPosition.X.ToString(CultureInfo.InvariantCulture));
             ruleString = ruleString.Replace("$WY",
-                IoCManager.Resolve<IEntityManager>().GetComponent<TransformComponent>(ent.Uid).WorldPosition.Y.ToString(CultureInfo.InvariantCulture));
+                IoCManager.Resolve<IEntityManager>().GetComponent<TransformComponent>(ent).WorldPosition.Y.ToString(CultureInfo.InvariantCulture));
             ruleString = ruleString.Replace("$LX",
-                IoCManager.Resolve<IEntityManager>().GetComponent<TransformComponent>(ent.Uid).LocalPosition.X.ToString(CultureInfo.InvariantCulture));
+                IoCManager.Resolve<IEntityManager>().GetComponent<TransformComponent>(ent).LocalPosition.X.ToString(CultureInfo.InvariantCulture));
             ruleString = ruleString.Replace("$LY",
-                IoCManager.Resolve<IEntityManager>().GetComponent<TransformComponent>(ent.Uid).LocalPosition.Y.ToString(CultureInfo.InvariantCulture));
-            ruleString = ruleString.Replace("$NAME", IoCManager.Resolve<IEntityManager>().GetComponent<MetaDataComponent>(ent.Uid).EntityName);
+                IoCManager.Resolve<IEntityManager>().GetComponent<TransformComponent>(ent).LocalPosition.Y.ToString(CultureInfo.InvariantCulture));
+            ruleString = ruleString.Replace("$NAME", IoCManager.Resolve<IEntityManager>().GetComponent<MetaDataComponent>(ent).EntityName);
 
             if (shell.Player is IPlayerSession player)
             {
                 if (player.AttachedEntity != null)
                 {
                     var p = player.AttachedEntity;
-                    ruleString = ruleString.Replace("$PID", ent.Uid.ToString());
+                    ruleString = ruleString.Replace("$PID", ent.ToString());
                     ruleString = ruleString.Replace("$PWX",
-                        IoCManager.Resolve<IEntityManager>().GetComponent<TransformComponent>(p.Uid).WorldPosition.X.ToString(CultureInfo.InvariantCulture));
+                        IoCManager.Resolve<IEntityManager>().GetComponent<TransformComponent>(p).WorldPosition.X.ToString(CultureInfo.InvariantCulture));
                     ruleString = ruleString.Replace("$PWY",
-                        IoCManager.Resolve<IEntityManager>().GetComponent<TransformComponent>(p.Uid).WorldPosition.Y.ToString(CultureInfo.InvariantCulture));
+                        IoCManager.Resolve<IEntityManager>().GetComponent<TransformComponent>(p).WorldPosition.Y.ToString(CultureInfo.InvariantCulture));
                     ruleString = ruleString.Replace("$PLX",
-                        IoCManager.Resolve<IEntityManager>().GetComponent<TransformComponent>(p.Uid).LocalPosition.X.ToString(CultureInfo.InvariantCulture));
+                        IoCManager.Resolve<IEntityManager>().GetComponent<TransformComponent>(p).LocalPosition.X.ToString(CultureInfo.InvariantCulture));
                     ruleString = ruleString.Replace("$PLY",
-                        IoCManager.Resolve<IEntityManager>().GetComponent<TransformComponent>(p.Uid).LocalPosition.Y.ToString(CultureInfo.InvariantCulture));
+                        IoCManager.Resolve<IEntityManager>().GetComponent<TransformComponent>(p).LocalPosition.Y.ToString(CultureInfo.InvariantCulture));
                 }
             }
 

Robust.Server/Console/Commands/AddComponentCommand.cs

@@ -46,9 +46,9 @@ namespace Robust.Server.Console.Commands
                 return;
             }
 
-            if (IoCManager.Resolve<IEntityManager>().HasComponent(entity.Uid, registration.Type))
+            if (IoCManager.Resolve<IEntityManager>().HasComponent(entity, registration.Type))
             {
-                shell.WriteLine($"Entity {IoCManager.Resolve<IEntityManager>().GetComponent<MetaDataComponent>(entity.Uid).EntityName} already has a {componentName} component.");
+                shell.WriteLine($"Entity {IoCManager.Resolve<IEntityManager>().GetComponent<MetaDataComponent>(entity).EntityName} already has a {componentName} component.");
             }
 
             var component = (Component) compFactory.GetComponent(registration.Type);
@@ -56,7 +56,7 @@ namespace Robust.Server.Console.Commands
             component.Owner = entity;
             entManager.AddComponent(entity, component);
 
-            shell.WriteLine($"Added {componentName} component to entity {IoCManager.Resolve<IEntityManager>().GetComponent<MetaDataComponent>(entity.Uid).EntityName}.");
+            shell.WriteLine($"Added {componentName} component to entity {IoCManager.Resolve<IEntityManager>().GetComponent<MetaDataComponent>(entity).EntityName}.");
         }
     }
 }

Robust.Server/Console/Commands/DeleteCommand.cs

@@ -33,7 +33,7 @@ namespace Robust.Server.Console.Commands
                 return;
             }
 
-            IoCManager.Resolve<IEntityManager>().DeleteEntity(entity.Uid);
+            IoCManager.Resolve<IEntityManager>().DeleteEntity((EntityUid) entity);
         }
     }
 }

Robust.Server/Console/Commands/MapCommands.cs

@@ -235,7 +235,7 @@ namespace Robust.Server.Console.Commands
             if (player?.AttachedEntity == null)
                 return;
 
-            var pos = IoCManager.Resolve<IEntityManager>().GetComponent<TransformComponent>(player.AttachedEntity.Uid).Coordinates;
+            var pos = IoCManager.Resolve<IEntityManager>().GetComponent<TransformComponent>(player.AttachedEntity).Coordinates;
             var entityManager = IoCManager.Resolve<IEntityManager>();
 
             shell.WriteLine(

Robust.Server/Console/Commands/PlayerCommands.cs

@@ -34,7 +34,7 @@ namespace Robust.Server.Console.Commands
 
             var position = new Vector2(posX, posY);
             IEntity? tempQualifier = player.AttachedEntity;
-            var transform = (tempQualifier != null ? IoCManager.Resolve<IEntityManager>().GetComponent<TransformComponent>(tempQualifier.Uid) : null);
+            var transform = (tempQualifier != null ? IoCManager.Resolve<IEntityManager>().GetComponent<TransformComponent>(tempQualifier) : null);
 
             if(transform == null)
                 return;
@@ -104,7 +104,7 @@ namespace Robust.Server.Console.Commands
                     return;
                 }
 
-                IoCManager.Resolve<IEntityManager>().GetComponent<TransformComponent>(player.AttachedEntity.Uid).Coordinates = IoCManager.Resolve<IEntityManager>().GetComponent<TransformComponent>(playerSession.AttachedEntity.Uid).Coordinates;
+                IoCManager.Resolve<IEntityManager>().GetComponent<TransformComponent>(player.AttachedEntity).Coordinates = IoCManager.Resolve<IEntityManager>().GetComponent<TransformComponent>(playerSession.AttachedEntity).Coordinates;
             }
             else if (args.Length > 1)
             {
@@ -140,7 +140,7 @@ namespace Robust.Server.Console.Commands
                         continue;
                     }
 
-                    IoCManager.Resolve<IEntityManager>().GetComponent<TransformComponent>(playerSession.AttachedEntity.Uid).Coordinates = IoCManager.Resolve<IEntityManager>().GetComponent<TransformComponent>(targetSession.AttachedEntity.Uid).Coordinates;
+                    IoCManager.Resolve<IEntityManager>().GetComponent<TransformComponent>(playerSession.AttachedEntity).Coordinates = IoCManager.Resolve<IEntityManager>().GetComponent<TransformComponent>(targetSession.AttachedEntity).Coordinates;
                 }
             }
         }

Robust.Server/Console/Commands/RemoveComponentCommand.cs

@@ -46,15 +46,15 @@ namespace Robust.Server.Console.Commands
                 return;
             }
 
-            if (!IoCManager.Resolve<IEntityManager>().HasComponent(entity.Uid, registration.Type))
+            if (!IoCManager.Resolve<IEntityManager>().HasComponent(entity, registration.Type))
             {
-                shell.WriteLine($"No {componentName} component found on entity {IoCManager.Resolve<IEntityManager>().GetComponent<MetaDataComponent>(entity.Uid).EntityName}.");
+                shell.WriteLine($"No {componentName} component found on entity {IoCManager.Resolve<IEntityManager>().GetComponent<MetaDataComponent>(entity).EntityName}.");
                 return;
             }
 
             entManager.RemoveComponent(uid, registration.Type);
 
-            shell.WriteLine($"Removed {componentName} component from entity {IoCManager.Resolve<IEntityManager>().GetComponent<MetaDataComponent>(entity.Uid).EntityName}.");
+            shell.WriteLine($"Removed {componentName} component from entity {IoCManager.Resolve<IEntityManager>().GetComponent<MetaDataComponent>(entity).EntityName}.");
         }
     }
 }

Robust.Server/Console/Commands/SpawnCommand.cs

@@ -24,17 +24,17 @@ namespace Robust.Server.Console.Commands
 
             if (args.Length == 1 && player?.AttachedEntity != null)
             {
-                ent.SpawnEntity(args[0], IoCManager.Resolve<IEntityManager>().GetComponent<TransformComponent>(player.AttachedEntity.Uid).Coordinates);
+                ent.SpawnEntity(args[0], IoCManager.Resolve<IEntityManager>().GetComponent<TransformComponent>(player.AttachedEntity).Coordinates);
             }
             else if (args.Length == 2)
             {
                 IEntity tempQualifier = ent.GetEntity(EntityUid.Parse(args[1]));
-                ent.SpawnEntity(args[0], IoCManager.Resolve<IEntityManager>().GetComponent<TransformComponent>(tempQualifier.Uid).Coordinates);
+                ent.SpawnEntity(args[0], IoCManager.Resolve<IEntityManager>().GetComponent<TransformComponent>(tempQualifier).Coordinates);
             }
             else if (player?.AttachedEntity != null)
             {
                 var coords = new MapCoordinates(float.Parse(args[1]),
-                    float.Parse(args[2]), IoCManager.Resolve<IEntityManager>().GetComponent<TransformComponent>(player.AttachedEntity.Uid).MapID);
+                    float.Parse(args[2]), IoCManager.Resolve<IEntityManager>().GetComponent<TransformComponent>(player.AttachedEntity).MapID);
                 ent.SpawnEntity(args[0], coords);
             }
         }

Robust.Server/Console/Commands/TestbedCommand.cs

@@ -112,7 +112,7 @@ namespace Robust.Server.Console.Commands
             var pauseManager = IoCManager.Resolve<IPauseManager>();
             pauseManager.SetMapPaused(mapId, false);
             IEntity tempQualifier = IoCManager.Resolve<IMapManager>().GetMapEntity(mapId);
-            IoCManager.Resolve<IEntityManager>().GetComponent<SharedPhysicsMapComponent>(tempQualifier.Uid).Gravity = new Vector2(0, -9.8f);
+            IoCManager.Resolve<IEntityManager>().GetComponent<SharedPhysicsMapComponent>(tempQualifier).Gravity = new Vector2(0, -9.8f);
 
             return;
         }
@@ -286,7 +286,7 @@ namespace Robust.Server.Console.Commands
                     IEntity tempQualifier1 = entityManager.SpawnEntity(null, new MapCoordinates(0, 0, mapId));
                     var box = IoCManager.Resolve<IEntityManager>().AddComponent<PhysicsComponent>(tempQualifier1);
                     box.BodyType = BodyType.Dynamic;
-                    IoCManager.Resolve<IEntityManager>().GetComponent<TransformComponent>(box.Owner.Uid).WorldPosition = y;
+                    IoCManager.Resolve<IEntityManager>().GetComponent<TransformComponent>(box.Owner).WorldPosition = y;
                     broadphase.CreateFixture(box,
                         new Fixture(box, shape) {
                         CollisionLayer = 2,
@@ -306,10 +306,12 @@ namespace Robust.Server.Console.Commands
             var broadphaseSystem = EntitySystem.Get<FixtureSystem>();
             var entityManager = IoCManager.Resolve<IEntityManager>();
 
-            var groundUid = entityManager.SpawnEntity(null, new MapCoordinates(0f, 0f, mapId)).Uid;
+            IEntity tempQualifier = entityManager.SpawnEntity(null, new MapCoordinates(0f, 0f, mapId));
+            var groundUid = (EntityUid) tempQualifier;
             var ground = entityManager.AddComponent<PhysicsComponent>(groundUid);
 
-            var bodyUid = entityManager.SpawnEntity(null, new MapCoordinates(0f, 10f, mapId)).Uid;
+            IEntity tempQualifier1 = entityManager.SpawnEntity(null, new MapCoordinates(0f, 10f, mapId));
+            var bodyUid = (EntityUid) tempQualifier1;
             var body = entityManager.AddComponent<PhysicsComponent>(bodyUid);
 
             body.BodyType = BodyType.Dynamic;
@@ -357,7 +359,8 @@ namespace Robust.Server.Console.Commands
                 Timer.Spawn(i * 20, () =>
                 {
                     if (!mapManager.MapExists(mapId)) return;
-                    var ent = entityManager.SpawnEntity(null, new MapCoordinates(0f, 10f, mapId)).Uid;
+                    IEntity tempQualifier2 = entityManager.SpawnEntity(null, new MapCoordinates(0f, 10f, mapId));
+                    var ent = (EntityUid) tempQualifier2;
                     var box = entityManager.AddComponent<PhysicsComponent>(ent);
                     box.BodyType = BodyType.Dynamic;
                     box.FixedRotation = false;

Robust.Server/GameObjects/Components/UserInterface/ServerUserInterfaceComponent.cs

@@ -69,7 +69,7 @@ namespace Robust.Server.GameObjects
         internal void SendToSession(IPlayerSession session, BoundUserInterfaceMessage message, object uiKey)
         {
             EntitySystem.Get<UserInterfaceSystem>()
-                .SendTo(session, new BoundUIWrapMessage(Owner.Uid, message, uiKey));
+                .SendTo(session, new BoundUIWrapMessage(Owner, message, uiKey));
         }
 
         internal void ReceiveMessage(IPlayerSession session, BoundUIWrapMessage msg)
@@ -246,7 +246,7 @@ namespace Robust.Server.GameObjects
         private void CloseShared(IPlayerSession session)
         {
             var owner = Owner.Owner;
-            IoCManager.Resolve<IEntityManager>().EventBus.RaiseLocalEvent(owner.Uid, new BoundUIClosedEvent(UiKey, owner.Uid, session));
+            IoCManager.Resolve<IEntityManager>().EventBus.RaiseLocalEvent(owner, new BoundUIClosedEvent(UiKey, owner, session));
             OnClosed?.Invoke(session);
             _subscribedSessions.Remove(session);
             _playerStateOverrides.Remove(session);

Robust.Server/GameObjects/EntitySystems/ActorSystem.cs

@@ -204,7 +204,7 @@ namespace Robust.Server.GameObjects
         public PlayerAttachedEvent(IEntity entity, IPlayerSession player, IPlayerSession? kicked = null)
         {
             Entity = entity;
-            EntityUid = entity.Uid;
+            EntityUid = entity;
             Player = player;
             Kicked = kicked;
         }
@@ -222,7 +222,7 @@ namespace Robust.Server.GameObjects
         public PlayerDetachedEvent(IEntity entity, IPlayerSession player)
         {
             Entity = entity;
-            EntityUid = entity.Uid;
+            EntityUid = entity;
             Player = player;
         }
     }

Robust.Server/GameObjects/EntitySystems/AudioSystem.cs

@@ -86,7 +86,7 @@ namespace Robust.Server.GameObjects
         /// <inheritdoc />
         public IPlayingAudioStream? Play(Filter playerFilter, string filename, IEntity entity, AudioParams? audioParams = null)
         {
-            return Play(playerFilter, filename, entity.Uid, audioParams);
+            return Play(playerFilter, filename, (EntityUid) entity, audioParams);
         }
 
         public IPlayingAudioStream? Play(Filter playerFilter, string filename, EntityUid uid, AudioParams? audioParams = null)

Robust.Server/GameObjects/EntitySystems/MapSystem.cs

@@ -59,7 +59,7 @@ namespace Robust.Server.GameObjects
         {
             if (!_deleteEmptyGrids ||
                 !EntityManager.TryGetEntity(uid, out var gridEnt) ||
-                (!IoCManager.Resolve<IEntityManager>().EntityExists(gridEnt.Uid) ? EntityLifeStage.Deleted : IoCManager.Resolve<IEntityManager>().GetComponent<MetaDataComponent>(gridEnt.Uid).EntityLifeStage) >= EntityLifeStage.Terminating) return;
+                (!IoCManager.Resolve<IEntityManager>().EntityExists(gridEnt) ? EntityLifeStage.Deleted : IoCManager.Resolve<IEntityManager>().GetComponent<MetaDataComponent>(gridEnt).EntityLifeStage) >= EntityLifeStage.Terminating) return;
 
             MapManager.DeleteGrid(args.GridId);
         }

Robust.Server/GameObjects/EntitySystems/TileLookup/GridTileLookupNode.cs

@@ -18,12 +18,12 @@ namespace Robust.Server.GameObjects
             {
                 foreach (var entity in _entities)
                 {
-                    if (!((!IoCManager.Resolve<IEntityManager>().EntityExists(entity.Uid) ? EntityLifeStage.Deleted : IoCManager.Resolve<IEntityManager>().GetComponent<MetaDataComponent>(entity.Uid).EntityLifeStage) >= EntityLifeStage.Deleted))
+                    if (!((!IoCManager.Resolve<IEntityManager>().EntityExists(entity) ? EntityLifeStage.Deleted : IoCManager.Resolve<IEntityManager>().GetComponent<MetaDataComponent>(entity).EntityLifeStage) >= EntityLifeStage.Deleted))
                     {
                         yield return entity;
                     }
 
-                    if (!IoCManager.Resolve<IEntityManager>().TryGetComponent(entity.Uid, out ContainerManagerComponent? containerManager)) continue;
+                    if (!IoCManager.Resolve<IEntityManager>().TryGetComponent(entity, out ContainerManagerComponent? containerManager)) continue;
                     foreach (var container in containerManager.GetAllContainers())
                     {
                         foreach (var child in container.ContainedEntities)

Robust.Server/GameObjects/EntitySystems/TileLookup/GridTileLookupSystem.cs

@@ -120,9 +120,9 @@ namespace Robust.Server.GameObjects
 
         private HashSet<GridTileLookupNode> GetOrCreateNodes(IEntity entity)
         {
-            if ((!IoCManager.Resolve<IEntityManager>().EntityExists(entity.Uid) ? EntityLifeStage.Deleted : IoCManager.Resolve<IEntityManager>().GetComponent<MetaDataComponent>(entity.Uid).EntityLifeStage) >= EntityLifeStage.Deleted)
+            if ((!IoCManager.Resolve<IEntityManager>().EntityExists(entity) ? EntityLifeStage.Deleted : IoCManager.Resolve<IEntityManager>().GetComponent<MetaDataComponent>(entity).EntityLifeStage) >= EntityLifeStage.Deleted)
             {
-                throw new InvalidOperationException($"Can't get nodes for deleted entity {IoCManager.Resolve<IEntityManager>().GetComponent<MetaDataComponent>(entity.Uid).EntityName}!");
+                throw new InvalidOperationException($"Can't get nodes for deleted entity {IoCManager.Resolve<IEntityManager>().GetComponent<MetaDataComponent>(entity).EntityName}!");
             }
 
             if (_lastKnownNodes.TryGetValue(entity, out var nodes))
@@ -183,7 +183,7 @@ namespace Robust.Server.GameObjects
             var entityBounds = GetEntityBox(entity);
             var results = new Dictionary<GridId, List<Vector2i>>();
 
-            foreach (var grid in _mapManager.FindGridsIntersecting(IoCManager.Resolve<IEntityManager>().GetComponent<TransformComponent>(entity.Uid).MapID, GetEntityBox(entity)))
+            foreach (var grid in _mapManager.FindGridsIntersecting(IoCManager.Resolve<IEntityManager>().GetComponent<TransformComponent>(entity).MapID, GetEntityBox(entity)))
             {
                 var indices = new List<Vector2i>();
 
@@ -244,7 +244,7 @@ namespace Robust.Server.GameObjects
 #if DEBUG
         private void HandleRequest(RequestGridTileLookupMessage message, EntitySessionEventArgs args)
         {
-            var entities = GetEntitiesIntersecting(message.GridId, message.Indices).Select(e => e.Uid).ToList();
+            var entities = GetEntitiesIntersecting(message.GridId, message.Indices).Select(e => (EntityUid) e).ToList();
             RaiseNetworkEvent(new SendGridTileLookupMessage(message.GridId, message.Indices, entities), args.SenderSession.ConnectedClient);
         }
 #endif
@@ -280,7 +280,7 @@ namespace Robust.Server.GameObjects
 
             foreach (var (entity, _) in _lastKnownNodes)
             {
-                if ((!IoCManager.Resolve<IEntityManager>().EntityExists(entity.Uid) ? EntityLifeStage.Deleted : IoCManager.Resolve<IEntityManager>().GetComponent<MetaDataComponent>(entity.Uid).EntityLifeStage) >= EntityLifeStage.Deleted || IoCManager.Resolve<IEntityManager>().GetComponent<TransformComponent>(entity.Uid).GridID == gridId)
+                if ((!IoCManager.Resolve<IEntityManager>().EntityExists(entity) ? EntityLifeStage.Deleted : IoCManager.Resolve<IEntityManager>().GetComponent<MetaDataComponent>(entity).EntityLifeStage) >= EntityLifeStage.Deleted || IoCManager.Resolve<IEntityManager>().GetComponent<TransformComponent>(entity).GridID == gridId)
                     toRemove.Add(entity);
             }
 
@@ -299,7 +299,7 @@ namespace Robust.Server.GameObjects
         /// <param name="entity"></param>
         private void HandleEntityAdd(IEntity entity)
         {
-            if ((!IoCManager.Resolve<IEntityManager>().EntityExists(entity.Uid) ? EntityLifeStage.Deleted : IoCManager.Resolve<IEntityManager>().GetComponent<MetaDataComponent>(entity.Uid).EntityLifeStage) >= EntityLifeStage.Deleted || IoCManager.Resolve<IEntityManager>().GetComponent<TransformComponent>(entity.Uid).GridID == GridId.Invalid)
+            if ((!IoCManager.Resolve<IEntityManager>().EntityExists(entity) ? EntityLifeStage.Deleted : IoCManager.Resolve<IEntityManager>().GetComponent<MetaDataComponent>(entity).EntityLifeStage) >= EntityLifeStage.Deleted || IoCManager.Resolve<IEntityManager>().GetComponent<TransformComponent>(entity).GridID == GridId.Invalid)
             {
                 return;
             }
@@ -350,7 +350,7 @@ namespace Robust.Server.GameObjects
             // TODO: When Acruid does TileEntities we may actually be able to delete this system if tile lookups become fast enough
             var gridId = moveEvent.NewPosition.GetGridId(EntityManager);
 
-            if ((!IoCManager.Resolve<IEntityManager>().EntityExists(moveEvent.Sender.Uid) ? EntityLifeStage.Deleted : IoCManager.Resolve<IEntityManager>().GetComponent<MetaDataComponent>(moveEvent.Sender.Uid).EntityLifeStage) >= EntityLifeStage.Deleted ||
+            if ((!IoCManager.Resolve<IEntityManager>().EntityExists(moveEvent.Sender) ? EntityLifeStage.Deleted : IoCManager.Resolve<IEntityManager>().GetComponent<MetaDataComponent>(moveEvent.Sender).EntityLifeStage) >= EntityLifeStage.Deleted ||
                 gridId == GridId.Invalid ||
                 !moveEvent.NewPosition.IsValid(EntityManager))
             {
@@ -365,7 +365,7 @@ namespace Robust.Server.GameObjects
 
             // Memory leak protection
             var gridBounds = _mapManager.GetGrid(gridId).WorldBounds;
-            if (!gridBounds.Contains(IoCManager.Resolve<IEntityManager>().GetComponent<TransformComponent>(moveEvent.Sender.Uid).WorldPosition))
+            if (!gridBounds.Contains(IoCManager.Resolve<IEntityManager>().GetComponent<TransformComponent>(moveEvent.Sender).WorldPosition))
             {
                 HandleEntityRemove(moveEvent.Sender);
                 return;

Robust.Server/GameObjects/EntitySystems/UserInterfaceSystem.cs

@@ -81,7 +81,7 @@ namespace Robust.Server.GameObjects
             _sessionCache.Clear();
             _sessionCache.AddRange(ui.SubscribedSessions);
 
-            var transform = IoCManager.Resolve<IEntityManager>().GetComponent<TransformComponent>(ui.Owner.Owner.Uid);
+            var transform = IoCManager.Resolve<IEntityManager>().GetComponent<TransformComponent>(ui.Owner.Owner);
 
             var uiPos = transform.WorldPosition;
             var uiMap = transform.MapID;
@@ -91,18 +91,18 @@ namespace Robust.Server.GameObjects
                 var attachedEntity = session.AttachedEntity;
 
                 // The component manages the set of sessions, so this invalid session should be removed soon.
-                if (attachedEntity == null || !IoCManager.Resolve<IEntityManager>().EntityExists(attachedEntity.Uid))
+                if (attachedEntity == null || !IoCManager.Resolve<IEntityManager>().EntityExists(attachedEntity))
                 {
                     continue;
                 }
 
-                if (uiMap != IoCManager.Resolve<IEntityManager>().GetComponent<TransformComponent>(attachedEntity.Uid).MapID)
+                if (uiMap != IoCManager.Resolve<IEntityManager>().GetComponent<TransformComponent>(attachedEntity).MapID)
                 {
                     ui.Close(session);
                     continue;
                 }
 
-                var distanceSquared = (uiPos - IoCManager.Resolve<IEntityManager>().GetComponent<TransformComponent>(attachedEntity.Uid).WorldPosition).LengthSquared;
+                var distanceSquared = (uiPos - IoCManager.Resolve<IEntityManager>().GetComponent<TransformComponent>(attachedEntity).WorldPosition).LengthSquared;
                 if (distanceSquared > MaxWindowRangeSquared)
                 {
                     ui.Close(session);

Robust.Server/GameObjects/ServerEntityManager.cs

@@ -75,7 +75,7 @@ namespace Robust.Server.GameObjects
                 // As such, we can reset the modified ticks to Zero,
                 // which indicates "not different from client's own deserialization".
                 // So the initial data for the component or even the creation doesn't have to be sent over the wire.
-                foreach (var (netId, component) in GetNetComponents(entity.Uid))
+                foreach (var (netId, component) in GetNetComponents(entity))
                 {
                     // Make sure to ONLY get components that are defined in the prototype.
                     // Others could be instantiated directly by AddComponent (e.g. ContainerManager).
@@ -222,7 +222,7 @@ namespace Robust.Server.GameObjects
 
             var msg = _networkManager.CreateNetMessage<MsgEntity>();
             msg.Type = EntityMessageType.ComponentMessage;
-            msg.EntityUid = entity.Uid;
+            msg.EntityUid = entity;
             msg.NetId = netId.Value;
             msg.ComponentMessage = message;
             msg.SourceTick = _gameTiming.CurTick;

Robust.Server/GameStates/PVSSystem.cs

@@ -173,7 +173,7 @@ internal partial class PVSSystem : EntitySystem
 
     private void OnEntityMove(ref MoveEvent ev)
     {
-        UpdateEntityRecursive(ev.Sender.Uid, ev.Component);
+        UpdateEntityRecursive(ev.Sender, ev.Component);
     }
 
     private void OnTransformInit(EntityUid uid, TransformComponent component, ComponentInit args)
@@ -433,7 +433,7 @@ internal partial class PVSSystem : EntitySystem
             {
                 foreach (var containedEntity in container.ContainedEntities)
                 {
-                    TryAddToVisibleEnts(containedEntity.Uid, previousVisibleEnts, toSend, fromTick, ref newEntitiesSent, null,
+                    TryAddToVisibleEnts(containedEntity, previousVisibleEnts, toSend, fromTick, ref newEntitiesSent, null,
                         true, true);
                 }
             }
@@ -473,24 +473,24 @@ internal partial class PVSSystem : EntitySystem
 
             foreach (var uid in add)
             {
-                if (!seenEnts.Add(uid) || !EntityManager.TryGetEntity(uid, out var entity) || (!IoCManager.Resolve<IEntityManager>().EntityExists(entity.Uid) ? EntityLifeStage.Deleted : IoCManager.Resolve<IEntityManager>().GetComponent<MetaDataComponent>(entity.Uid).EntityLifeStage) >= EntityLifeStage.Deleted) continue;
+                if (!seenEnts.Add(uid) || !EntityManager.TryGetEntity(uid, out var entity) || (!IoCManager.Resolve<IEntityManager>().EntityExists(entity) ? EntityLifeStage.Deleted : IoCManager.Resolve<IEntityManager>().GetComponent<MetaDataComponent>(entity).EntityLifeStage) >= EntityLifeStage.Deleted) continue;
 
-                DebugTools.Assert((!IoCManager.Resolve<IEntityManager>().EntityExists(entity.Uid) ? EntityLifeStage.Deleted : IoCManager.Resolve<IEntityManager>().GetComponent<MetaDataComponent>(entity.Uid).EntityLifeStage) >= EntityLifeStage.Initialized);
+                DebugTools.Assert((!IoCManager.Resolve<IEntityManager>().EntityExists(entity) ? EntityLifeStage.Deleted : IoCManager.Resolve<IEntityManager>().GetComponent<MetaDataComponent>(entity).EntityLifeStage) >= EntityLifeStage.Initialized);
 
-                if (IoCManager.Resolve<IEntityManager>().GetComponent<MetaDataComponent>(entity.Uid).EntityLastModifiedTick >= fromTick)
-                    stateEntities.Add(GetEntityState(player, entity.Uid, GameTick.Zero));
+                if (IoCManager.Resolve<IEntityManager>().GetComponent<MetaDataComponent>(entity).EntityLastModifiedTick >= fromTick)
+                    stateEntities.Add(GetEntityState(player, entity, GameTick.Zero));
             }
 
             foreach (var uid in dirty)
             {
                 DebugTools.Assert(!add.Contains(uid));
 
-                if (!seenEnts.Add(uid) || !EntityManager.TryGetEntity(uid, out var entity) || (!IoCManager.Resolve<IEntityManager>().EntityExists(entity.Uid) ? EntityLifeStage.Deleted : IoCManager.Resolve<IEntityManager>().GetComponent<MetaDataComponent>(entity.Uid).EntityLifeStage) >= EntityLifeStage.Deleted) continue;
+                if (!seenEnts.Add(uid) || !EntityManager.TryGetEntity(uid, out var entity) || (!IoCManager.Resolve<IEntityManager>().EntityExists(entity) ? EntityLifeStage.Deleted : IoCManager.Resolve<IEntityManager>().GetComponent<MetaDataComponent>(entity).EntityLifeStage) >= EntityLifeStage.Deleted) continue;
 
-                DebugTools.Assert((!IoCManager.Resolve<IEntityManager>().EntityExists(entity.Uid) ? EntityLifeStage.Deleted : IoCManager.Resolve<IEntityManager>().GetComponent<MetaDataComponent>(entity.Uid).EntityLifeStage) >= EntityLifeStage.Initialized);
+                DebugTools.Assert((!IoCManager.Resolve<IEntityManager>().EntityExists(entity) ? EntityLifeStage.Deleted : IoCManager.Resolve<IEntityManager>().GetComponent<MetaDataComponent>(entity).EntityLifeStage) >= EntityLifeStage.Initialized);
 
-                if (IoCManager.Resolve<IEntityManager>().GetComponent<MetaDataComponent>(entity.Uid).EntityLastModifiedTick >= fromTick)
-                    stateEntities.Add(GetEntityState(player, entity.Uid, fromTick));
+                if (IoCManager.Resolve<IEntityManager>().GetComponent<MetaDataComponent>(entity).EntityLastModifiedTick >= fromTick)
+                    stateEntities.Add(GetEntityState(player, entity, fromTick));
             }
         }
 
@@ -503,15 +503,15 @@ internal partial class PVSSystem : EntitySystem
 
         foreach (var entity in EntityManager.GetEntities())
         {
-            if ((!IoCManager.Resolve<IEntityManager>().EntityExists(entity.Uid) ? EntityLifeStage.Deleted : IoCManager.Resolve<IEntityManager>().GetComponent<MetaDataComponent>(entity.Uid).EntityLifeStage) >= EntityLifeStage.Deleted)
+            if ((!IoCManager.Resolve<IEntityManager>().EntityExists(entity) ? EntityLifeStage.Deleted : IoCManager.Resolve<IEntityManager>().GetComponent<MetaDataComponent>(entity).EntityLifeStage) >= EntityLifeStage.Deleted)
             {
                 continue;
             }
 
-            DebugTools.Assert((!IoCManager.Resolve<IEntityManager>().EntityExists(entity.Uid) ? EntityLifeStage.Deleted : IoCManager.Resolve<IEntityManager>().GetComponent<MetaDataComponent>(entity.Uid).EntityLifeStage) >= EntityLifeStage.Initialized);
+            DebugTools.Assert((!IoCManager.Resolve<IEntityManager>().EntityExists(entity) ? EntityLifeStage.Deleted : IoCManager.Resolve<IEntityManager>().GetComponent<MetaDataComponent>(entity).EntityLifeStage) >= EntityLifeStage.Initialized);
 
-            if (IoCManager.Resolve<IEntityManager>().GetComponent<MetaDataComponent>(entity.Uid).EntityLastModifiedTick >= fromTick)
-                stateEntities.Add(GetEntityState(player, entity.Uid, fromTick));
+            if (IoCManager.Resolve<IEntityManager>().GetComponent<MetaDataComponent>(entity).EntityLastModifiedTick >= fromTick)
+                stateEntities.Add(GetEntityState(player, entity, fromTick));
         }
 
         // no point sending an empty collection

Robust.Server/Maps/MapLoader.cs

@@ -137,7 +137,7 @@ namespace Robust.Server.Maps
                 {
                     foreach (var entity in context.Entities)
                     {
-                        IoCManager.Resolve<IEntityManager>().GetComponent<MetaDataComponent>(entity.Uid).EntityPaused = true;
+                        IoCManager.Resolve<IEntityManager>().GetComponent<MetaDataComponent>(entity).EntityPaused = true;
                     }
                 }
             }
@@ -403,18 +403,18 @@ namespace Robust.Server.Maps
                         continue;
                     }
 
-                    if (IoCManager.Resolve<IEntityManager>().GetComponent<MetaDataComponent>(entity.Uid).EntityPrototype == null)
+                    if (IoCManager.Resolve<IEntityManager>().GetComponent<MetaDataComponent>(entity).EntityPrototype == null)
                     {
                         continue;
                     }
 
-                    foreach (var (netId, component) in _serverEntityManager.GetNetComponents(entity.Uid))
+                    foreach (var (netId, component) in _serverEntityManager.GetNetComponents(entity))
                     {
                         var castComp = (Component) component;
 
                         if (componentList.Any(p => p["type"].AsString() == component.Name))
                         {
-                            if (IoCManager.Resolve<IEntityManager>().GetComponent<MetaDataComponent>(entity.Uid).EntityPrototype.Components.ContainsKey(component.Name))
+                            if (IoCManager.Resolve<IEntityManager>().GetComponent<MetaDataComponent>(entity).EntityPrototype.Components.ContainsKey(component.Name))
                             {
                                 // This component is modified by the map so we have to send state.
                                 // Though it's still in the prototype itself so creation doesn't need to be sent.
@@ -448,7 +448,7 @@ namespace Robust.Server.Maps
                     var gridInternal = (IMapGridInternal) grid;
                     var body = entManager.EnsureComponent<PhysicsComponent>(grid.GridEntityId);
                     IEntity tempQualifier = _mapManager.GetMapEntity(grid.ParentMapId);
-                    body.Broadphase = IoCManager.Resolve<IEntityManager>().GetComponent<BroadphaseComponent>(tempQualifier.Uid);
+                    body.Broadphase = IoCManager.Resolve<IEntityManager>().GetComponent<BroadphaseComponent>(tempQualifier);
                     var fixtures = entManager.EnsureComponent<FixturesComponent>(grid.GridEntityId);
                     gridFixtures.ProcessGrid(gridInternal);
 
@@ -494,12 +494,12 @@ namespace Robust.Server.Maps
                 foreach (var grid in Grids)
                 {
                     var entity = _serverEntityManager.GetEntity(grid.GridEntityId);
-                    if (IoCManager.Resolve<IEntityManager>().GetComponent<TransformComponent>(entity.Uid).Parent != null)
+                    if (IoCManager.Resolve<IEntityManager>().GetComponent<TransformComponent>(entity).Parent != null)
                         continue;
 
-                    var mapOffset = IoCManager.Resolve<IEntityManager>().GetComponent<TransformComponent>(entity.Uid).LocalPosition;
-                    IoCManager.Resolve<IEntityManager>().GetComponent<TransformComponent>(entity.Uid).AttachParent(mapEntity);
-                    IoCManager.Resolve<IEntityManager>().GetComponent<TransformComponent>(entity.Uid).WorldPosition = mapOffset;
+                    var mapOffset = IoCManager.Resolve<IEntityManager>().GetComponent<TransformComponent>(entity).LocalPosition;
+                    IoCManager.Resolve<IEntityManager>().GetComponent<TransformComponent>(entity).AttachParent(mapEntity);
+                    IoCManager.Resolve<IEntityManager>().GetComponent<TransformComponent>(entity).WorldPosition = mapOffset;
                 }
             }
 
@@ -508,11 +508,11 @@ namespace Robust.Server.Maps
                 var pvs = EntitySystem.Get<PVSSystem>();
                 foreach (var entity in Entities)
                 {
-                    if (IoCManager.Resolve<IEntityManager>().TryGetComponent(entity.Uid, out IMapGridComponent? grid))
+                    if (IoCManager.Resolve<IEntityManager>().TryGetComponent(entity, out IMapGridComponent? grid))
                     {
                         var castGrid = (MapGrid) grid.Grid;
-                        castGrid.GridEntityId = entity.Uid;
-                        pvs?.EntityPVSCollection.UpdateIndex(entity.Uid);
+                        castGrid.GridEntityId = entity;
+                        pvs?.EntityPVSCollection.UpdateIndex(entity);
                     }
                 }
             }
@@ -608,7 +608,7 @@ namespace Robust.Server.Maps
 
                     var entity = _serverEntityManager.AllocEntity(type);
                     Entities.Add(entity);
-                    UidEntityMap.Add(uid, entity.Uid);
+                    UidEntityMap.Add(uid, entity);
                     _entitiesToDeserialize.Add((entity, entityDef));
 
                     if (_loadOptions!.StoreMapUids)
@@ -734,7 +734,7 @@ namespace Robust.Server.Maps
                     if (IsMapSavable(entity))
                     {
                         Entities.Add(entity);
-                        if (IoCManager.Resolve<IEntityManager>().TryGetComponent(entity.Uid, out MapSaveIdComponent? mapSaveId))
+                        if (IoCManager.Resolve<IEntityManager>().TryGetComponent(entity, out MapSaveIdComponent? mapSaveId))
                         {
                             withUid.Add(mapSaveId);
                         }
@@ -771,7 +771,7 @@ namespace Robust.Server.Maps
                         uidCounter += 1;
                     }
 
-                    EntityUidMap.Add(entity.Uid, uidCounter);
+                    EntityUidMap.Add(entity, uidCounter);
                     takenIds.Add(uidCounter);
                 }
             }
@@ -783,30 +783,30 @@ namespace Robust.Server.Maps
                 RootNode.Add("entities", entities);
 
                 var prototypeCompCache = new Dictionary<string, Dictionary<string, MappingDataNode>>();
-                foreach (var entity in Entities.OrderBy(e => EntityUidMap[e.Uid]))
+                foreach (var entity in Entities.OrderBy(e => EntityUidMap[e]))
                 {
                     CurrentWritingEntity = entity;
                     var mapping = new YamlMappingNode
                     {
-                        {"uid", EntityUidMap[entity.Uid].ToString(CultureInfo.InvariantCulture)}
+                        {"uid", EntityUidMap[entity].ToString(CultureInfo.InvariantCulture)}
                     };
 
-                    if (IoCManager.Resolve<IEntityManager>().GetComponent<MetaDataComponent>(entity.Uid).EntityPrototype != null)
+                    if (IoCManager.Resolve<IEntityManager>().GetComponent<MetaDataComponent>(entity).EntityPrototype != null)
                     {
-                        mapping.Add("type", IoCManager.Resolve<IEntityManager>().GetComponent<MetaDataComponent>(entity.Uid).EntityPrototype.ID);
-                        if (!prototypeCompCache.ContainsKey(IoCManager.Resolve<IEntityManager>().GetComponent<MetaDataComponent>(entity.Uid).EntityPrototype.ID))
+                        mapping.Add("type", IoCManager.Resolve<IEntityManager>().GetComponent<MetaDataComponent>(entity).EntityPrototype.ID);
+                        if (!prototypeCompCache.ContainsKey(IoCManager.Resolve<IEntityManager>().GetComponent<MetaDataComponent>(entity).EntityPrototype.ID))
                         {
-                            prototypeCompCache[IoCManager.Resolve<IEntityManager>().GetComponent<MetaDataComponent>(entity.Uid).EntityPrototype.ID] = new Dictionary<string, MappingDataNode>();
-                            foreach (var (compType, comp) in IoCManager.Resolve<IEntityManager>().GetComponent<MetaDataComponent>(entity.Uid).EntityPrototype.Components)
+                            prototypeCompCache[IoCManager.Resolve<IEntityManager>().GetComponent<MetaDataComponent>(entity).EntityPrototype.ID] = new Dictionary<string, MappingDataNode>();
+                            foreach (var (compType, comp) in IoCManager.Resolve<IEntityManager>().GetComponent<MetaDataComponent>(entity).EntityPrototype.Components)
                             {
-                                prototypeCompCache[IoCManager.Resolve<IEntityManager>().GetComponent<MetaDataComponent>(entity.Uid).EntityPrototype.ID].Add(compType, serializationManager.WriteValueAs<MappingDataNode>(comp.GetType(), comp));
+                                prototypeCompCache[IoCManager.Resolve<IEntityManager>().GetComponent<MetaDataComponent>(entity).EntityPrototype.ID].Add(compType, serializationManager.WriteValueAs<MappingDataNode>(comp.GetType(), comp));
                             }
                         }
                     }
 
                     var components = new YamlSequenceNode();
                     // See engine#636 for why the Distinct() call.
-                    foreach (var component in IoCManager.Resolve<IEntityManager>().GetComponents(entity.Uid))
+                    foreach (var component in IoCManager.Resolve<IEntityManager>().GetComponents(entity))
                     {
                         if (component is MapSaveIdComponent)
                             continue;
@@ -814,7 +814,7 @@ namespace Robust.Server.Maps
                         CurrentWritingComponent = component.Name;
                         var compMapping = serializationManager.WriteValueAs<MappingDataNode>(component.GetType(), component, context: this);
 
-                        if (IoCManager.Resolve<IEntityManager>().GetComponent<MetaDataComponent>(entity.Uid).EntityPrototype != null && prototypeCompCache[IoCManager.Resolve<IEntityManager>().GetComponent<MetaDataComponent>(entity.Uid).EntityPrototype.ID].TryGetValue(component.Name, out var protMapping))
+                        if (IoCManager.Resolve<IEntityManager>().GetComponent<MetaDataComponent>(entity).EntityPrototype != null && prototypeCompCache[IoCManager.Resolve<IEntityManager>().GetComponent<MetaDataComponent>(entity).EntityPrototype.ID].TryGetValue(component.Name, out var protMapping))
                         {
                             compMapping = compMapping.Except(protMapping);
                             if(compMapping == null) continue;
@@ -873,17 +873,17 @@ namespace Robust.Server.Maps
 
             private bool IsMapSavable(IEntity entity)
             {
-                if (IoCManager.Resolve<IEntityManager>().GetComponent<MetaDataComponent>(entity.Uid).EntityPrototype?.MapSavable == false || !GridIDMap.ContainsKey(IoCManager.Resolve<IEntityManager>().GetComponent<TransformComponent>(entity.Uid).GridID))
+                if (IoCManager.Resolve<IEntityManager>().GetComponent<MetaDataComponent>(entity).EntityPrototype?.MapSavable == false || !GridIDMap.ContainsKey(IoCManager.Resolve<IEntityManager>().GetComponent<TransformComponent>(entity).GridID))
                 {
                     return false;
                 }
 
                 // Don't serialize things parented to un savable things.
                 // For example clothes inside a person.
-                var current = IoCManager.Resolve<IEntityManager>().GetComponent<TransformComponent>(entity.Uid);
+                var current = IoCManager.Resolve<IEntityManager>().GetComponent<TransformComponent>(entity);
                 while (current.Parent != null)
                 {
-                    if (IoCManager.Resolve<IEntityManager>().GetComponent<MetaDataComponent>(current.Parent.Owner.Uid).EntityPrototype?.MapSavable == false)
+                    if (IoCManager.Resolve<IEntityManager>().GetComponent<MetaDataComponent>(current.Parent.Owner).EntityPrototype?.MapSavable == false)
                     {
                         return false;
                     }
@@ -957,7 +957,7 @@ namespace Robust.Server.Maps
             public DataNode Write(ISerializationManager serializationManager, IEntity value, bool alwaysWrite = false,
                 ISerializationContext? context = null)
             {
-                return Write(serializationManager, value.Uid, alwaysWrite, context);
+                return Write(serializationManager, (EntityUid) value, alwaysWrite, context);
             }
 
             public DataNode Write(ISerializationManager serializationManager, EntityUid value, bool alwaysWrite = false,
@@ -966,7 +966,7 @@ namespace Robust.Server.Maps
                 if (!EntityUidMap.TryGetValue(value, out var entityUidMapped))
                 {
                     // Terrible hack to mute this warning on the grids themselves when serializing blueprints.
-                    if (!IsBlueprintMode || !IoCManager.Resolve<IEntityManager>().HasComponent<MapGridComponent>(CurrentWritingEntity!.Uid) ||
+                    if (!IsBlueprintMode || !IoCManager.Resolve<IEntityManager>().HasComponent<MapGridComponent>(CurrentWritingEntity!) ||
                         CurrentWritingComponent != "Transform")
                     {
                         Logger.WarningS("map", "Cannot write entity UID '{0}'.", value);
@@ -1026,7 +1026,7 @@ namespace Robust.Server.Maps
             {
                 var val = int.Parse(node.Value);
 
-                if (val >= Entities.Count || !UidEntityMap.ContainsKey(val) || !Entities.TryFirstOrDefault(e => e.Uid == UidEntityMap[val], out var entity))
+                if (val >= Entities.Count || !UidEntityMap.ContainsKey(val) || !Entities.TryFirstOrDefault(e => e == UidEntityMap[val], out var entity))
                 {
                     Logger.ErrorS("map", "Error in map file: found local entity UID '{0}' which does not exist.", val);
                     return null!;

Robust.Server/Placement/PlacementManager.cs

@@ -121,7 +121,7 @@ namespace Robust.Server.Placement
             {
                 var created = _entityManager.SpawnEntity(entityTemplateName, coordinates);
 
-                IoCManager.Resolve<IEntityManager>().GetComponent<TransformComponent>(created.Uid).LocalRotation = dirRcv.ToAngle();
+                IoCManager.Resolve<IEntityManager>().GetComponent<TransformComponent>(created).LocalRotation = dirRcv.ToAngle();
             }
             else
             {
@@ -212,9 +212,9 @@ namespace Robust.Server.Placement
             foreach (IEntity entity in IoCManager.Resolve<IEntityLookup>().GetEntitiesIntersecting(start.GetMapId(_entityManager),
                 new Box2(start.Position, start.Position + rectSize)))
             {
-                if ((!IoCManager.Resolve<IEntityManager>().EntityExists(entity.Uid) ? EntityLifeStage.Deleted : IoCManager.Resolve<IEntityManager>().GetComponent<MetaDataComponent>(entity.Uid).EntityLifeStage) >= EntityLifeStage.Deleted || IoCManager.Resolve<IEntityManager>().HasComponent<IMapGridComponent>(entity.Uid) || IoCManager.Resolve<IEntityManager>().HasComponent<ActorComponent>(entity.Uid))
+                if ((!IoCManager.Resolve<IEntityManager>().EntityExists(entity) ? EntityLifeStage.Deleted : IoCManager.Resolve<IEntityManager>().GetComponent<MetaDataComponent>(entity).EntityLifeStage) >= EntityLifeStage.Deleted || IoCManager.Resolve<IEntityManager>().HasComponent<IMapGridComponent>(entity) || IoCManager.Resolve<IEntityManager>().HasComponent<ActorComponent>(entity))
                     continue;
-                IoCManager.Resolve<IEntityManager>().DeleteEntity(entity.Uid);
+                IoCManager.Resolve<IEntityManager>().DeleteEntity((EntityUid) entity);
             }
         }
 
@@ -223,7 +223,7 @@ namespace Robust.Server.Placement
         /// </summary>
         public void SendPlacementBegin(IEntity mob, int range, string objectType, string alignOption)
         {
-            if (!IoCManager.Resolve<IEntityManager>().TryGetComponent<ActorComponent?>(mob.Uid, out var actor))
+            if (!IoCManager.Resolve<IEntityManager>().TryGetComponent<ActorComponent?>(mob, out var actor))
                 return;
 
             var playerConnection = actor.PlayerSession.ConnectedClient;
@@ -244,7 +244,7 @@ namespace Robust.Server.Placement
         /// </summary>
         public void SendPlacementBeginTile(IEntity mob, int range, string tileType, string alignOption)
         {
-            if (!IoCManager.Resolve<IEntityManager>().TryGetComponent<ActorComponent?>(mob.Uid, out var actor))
+            if (!IoCManager.Resolve<IEntityManager>().TryGetComponent<ActorComponent?>(mob, out var actor))
                 return;
 
             var playerConnection = actor.PlayerSession.ConnectedClient;
@@ -265,7 +265,7 @@ namespace Robust.Server.Placement
         /// </summary>
         public void SendPlacementCancel(IEntity mob)
         {
-            if (!IoCManager.Resolve<IEntityManager>().TryGetComponent<ActorComponent?>(mob.Uid, out var actor))
+            if (!IoCManager.Resolve<IEntityManager>().TryGetComponent<ActorComponent?>(mob, out var actor))
                 return;
 
             var playerConnection = actor.PlayerSession.ConnectedClient;
@@ -311,7 +311,7 @@ namespace Robust.Server.Placement
         {
             var newPermission = new PlacementInformation
             {
-                MobUid = mob.Uid,
+                MobUid = mob,
                 Range = range,
                 IsTile = false,
                 EntityType = objectType,
@@ -319,7 +319,7 @@ namespace Robust.Server.Placement
             };
 
             IEnumerable<PlacementInformation> mobPermissions = from PlacementInformation permission in BuildPermissions
-                                                               where permission.MobUid == mob.Uid
+                                                               where permission.MobUid == mob
                                                                select permission;
 
             if (mobPermissions.Any()) //Already has one? Revoke the old one and add this one.
@@ -340,7 +340,7 @@ namespace Robust.Server.Placement
         {
             var newPermission = new PlacementInformation
             {
-                MobUid = mob.Uid,
+                MobUid = mob,
                 Range = range,
                 IsTile = true,
                 TileType = _tileDefinitionManager[tileType].TileId,
@@ -348,7 +348,7 @@ namespace Robust.Server.Placement
             };
 
             IEnumerable<PlacementInformation> mobPermissions = from PlacementInformation permission in BuildPermissions
-                                                               where permission.MobUid == mob.Uid
+                                                               where permission.MobUid == mob
                                                                select permission;
 
             if (mobPermissions.Any()) //Already has one? Revoke the old one and add this one.
@@ -368,7 +368,7 @@ namespace Robust.Server.Placement
         public void RevokeAllBuildPermissions(IEntity mob)
         {
             var mobPermissions = BuildPermissions
-                .Where(permission => permission.MobUid == mob.Uid)
+                .Where(permission => permission.MobUid == mob)
                 .ToList();
 
             if (mobPermissions.Count != 0)

Robust.Server/Player/PlayerSession.cs

@@ -44,7 +44,7 @@ namespace Robust.Server.Player
 
         [ViewVariables] public IEntity? AttachedEntity { get; set; }
 
-        [ViewVariables] public EntityUid? AttachedEntityUid => AttachedEntity?.Uid;
+        [ViewVariables] public EntityUid? AttachedEntityUid => AttachedEntity;
 
         private SessionStatus _status = SessionStatus.Connecting;
 
@@ -120,7 +120,7 @@ namespace Robust.Server.Player
             if (entity == null)
                 return;
 
-            AttachToEntity(entity.Uid);
+            AttachToEntity((EntityUid) entity);
         }
 
         /// <inheritdoc />
@@ -180,7 +180,7 @@ namespace Robust.Server.Player
         {
             if (Name != null && AttachedEntity != null)
             {
-                IoCManager.Resolve<IEntityManager>().GetComponent<MetaDataComponent>(AttachedEntity.Uid).EntityName = Name;
+                IoCManager.Resolve<IEntityManager>().GetComponent<MetaDataComponent>(AttachedEntity).EntityName = Name;
             }
         }
 
@@ -233,7 +233,7 @@ namespace Robust.Server.Player
             if (AttachedEntity == null)
                 PlayerState.ControlledEntity = null;
             else
-                PlayerState.ControlledEntity = AttachedEntity.Uid;
+                PlayerState.ControlledEntity = AttachedEntity;
 
             _playerManager.Dirty();
         }

Robust.Server/ViewVariables/Traits/ViewVariablesTraitEntity.cs

@@ -23,7 +23,7 @@ namespace Robust.Server.ViewVariables.Traits
             {
                 var list = new List<ViewVariablesBlobEntityComponents.Entry>();
                 // See engine#636 for why the Distinct() call.
-                foreach (var component in IoCManager.Resolve<IEntityManager>().GetComponents(_entity.Uid))
+                foreach (var component in IoCManager.Resolve<IEntityManager>().GetComponents(_entity))
                 {
                     var type = component.GetType();
                     list.Add(new ViewVariablesBlobEntityComponents.Entry
@@ -44,7 +44,7 @@ namespace Robust.Server.ViewVariables.Traits
 
                 foreach (var type in componentFactory.AllRegisteredTypes)
                 {
-                    if (IoCManager.Resolve<IEntityManager>().HasComponent(_entity.Uid, type))
+                    if (IoCManager.Resolve<IEntityManager>().HasComponent(_entity, type))
                         continue;
 
                     list.Add(componentFactory.GetRegistration(type).Name);

Robust.Shared.Scripting/ScriptGlobalsShared.cs

@@ -54,7 +54,7 @@ namespace Robust.Shared.Scripting
         public T gcm<T>(int i)
         {
             IEntity tempQualifier = getent(i);
-            return IoCManager.Resolve<IEntityManager>().GetComponent<T>(tempQualifier.Uid);
+            return IoCManager.Resolve<IEntityManager>().GetComponent<T>(tempQualifier);
         }
 
         public IEntity getent(EntityUid uid)

Robust.Shared/Containers/BaseContainer.cs

@@ -63,14 +63,14 @@ namespace Robust.Shared.Containers
             if (!CanInsert(toinsert))
                 return false;
 
-            var transform = IoCManager.Resolve<IEntityManager>().GetComponent<TransformComponent>(toinsert.Uid);
+            var transform = IoCManager.Resolve<IEntityManager>().GetComponent<TransformComponent>(toinsert);
 
             // CanInsert already checks nullability of Parent (or container forgot to call base that does)
             if (toinsert.TryGetContainerMan(out var containerManager) && !containerManager.Remove(toinsert))
                 return false; // Can't remove from existing container, can't insert.
 
             // Attach to parent first so we can check IsInContainer more easily.
-            transform.AttachParent(IoCManager.Resolve<IEntityManager>().GetComponent<TransformComponent>(Owner.Uid));
+            transform.AttachParent(IoCManager.Resolve<IEntityManager>().GetComponent<TransformComponent>(Owner));
             InternalInsert(toinsert);
 
             // This is an edge case where the parent grid is the container being inserted into, so AttachParent would not unanchor.
@@ -94,11 +94,11 @@ namespace Robust.Shared.Containers
                 return false;
 
             // no, you can't put maps or grids into containers
-            if (IoCManager.Resolve<IEntityManager>().HasComponent<IMapComponent>(toinsert.Uid) || IoCManager.Resolve<IEntityManager>().HasComponent<IMapGridComponent>(toinsert.Uid))
+            if (IoCManager.Resolve<IEntityManager>().HasComponent<IMapComponent>(toinsert) || IoCManager.Resolve<IEntityManager>().HasComponent<IMapGridComponent>(toinsert))
                 return false;
 
             // Crucial, prevent circular insertion.
-            return !IoCManager.Resolve<IEntityManager>().GetComponent<TransformComponent>(toinsert.Uid).ContainsEntity(IoCManager.Resolve<IEntityManager>().GetComponent<TransformComponent>(Owner.Uid));
+            return !IoCManager.Resolve<IEntityManager>().GetComponent<TransformComponent>(toinsert).ContainsEntity(IoCManager.Resolve<IEntityManager>().GetComponent<TransformComponent>(Owner));
 
             //Improvement: Traverse the entire tree to make sure we are not creating a loop.
         }
@@ -109,12 +109,12 @@ namespace Robust.Shared.Containers
             DebugTools.Assert(!Deleted);
             DebugTools.AssertNotNull(Manager);
             DebugTools.AssertNotNull(toremove);
-            DebugTools.Assert(IoCManager.Resolve<IEntityManager>().EntityExists(toremove.Uid));
+            DebugTools.Assert(IoCManager.Resolve<IEntityManager>().EntityExists(toremove));
 
             if (!CanRemove(toremove)) return false;
             InternalRemove(toremove);
 
-            IoCManager.Resolve<IEntityManager>().GetComponent<TransformComponent>(toremove.Uid).AttachParentToContainerOrGrid();
+            IoCManager.Resolve<IEntityManager>().GetComponent<TransformComponent>(toremove).AttachParentToContainerOrGrid();
             return true;
         }
 
@@ -124,7 +124,7 @@ namespace Robust.Shared.Containers
             DebugTools.Assert(!Deleted);
             DebugTools.AssertNotNull(Manager);
             DebugTools.AssertNotNull(toRemove);
-            DebugTools.Assert(IoCManager.Resolve<IEntityManager>().EntityExists(toRemove.Uid));
+            DebugTools.Assert(IoCManager.Resolve<IEntityManager>().EntityExists(toRemove));
 
             InternalRemove(toRemove);
         }
@@ -154,7 +154,7 @@ namespace Robust.Shared.Containers
         {
             DebugTools.Assert(!Deleted);
 
-            IoCManager.Resolve<IEntityManager>().EventBus.RaiseLocalEvent(Owner.Uid, new EntInsertedIntoContainerMessage(toinsert, this));
+            IoCManager.Resolve<IEntityManager>().EventBus.RaiseLocalEvent(Owner, new EntInsertedIntoContainerMessage(toinsert, this));
             IoCManager.Resolve<IEntityManager>().EventBus.RaiseEvent(EventSource.Local, new UpdateContainerOcclusionMessage(toinsert));
             Manager.Dirty();
         }
@@ -168,9 +168,9 @@ namespace Robust.Shared.Containers
             DebugTools.Assert(!Deleted);
             DebugTools.AssertNotNull(Manager);
             DebugTools.AssertNotNull(toremove);
-            DebugTools.Assert(IoCManager.Resolve<IEntityManager>().EntityExists(toremove.Uid));
+            DebugTools.Assert(IoCManager.Resolve<IEntityManager>().EntityExists(toremove));
 
-            IoCManager.Resolve<IEntityManager>().EventBus.RaiseLocalEvent(Owner.Uid, new EntRemovedFromContainerMessage(toremove, this));
+            IoCManager.Resolve<IEntityManager>().EventBus.RaiseLocalEvent(Owner, new EntRemovedFromContainerMessage(toremove, this));
             IoCManager.Resolve<IEntityManager>().EventBus.RaiseEvent(EventSource.Local, new UpdateContainerOcclusionMessage(toremove));
             Manager.Dirty();
         }

Robust.Shared/Containers/Container.cs

@@ -62,7 +62,7 @@ namespace Robust.Shared.Containers
 
             foreach (var entity in _containerList)
             {
-                IoCManager.Resolve<IEntityManager>().DeleteEntity(entity.Uid);
+                IoCManager.Resolve<IEntityManager>().DeleteEntity((EntityUid) entity);
             }
         }
     }

Robust.Shared/Containers/ContainerHelpers.cs

@@ -23,14 +23,14 @@ namespace Robust.Shared.Containers
         public static bool IsInContainer(this IEntity entity)
         {
             DebugTools.AssertNotNull(entity);
-            DebugTools.Assert(!((!IoCManager.Resolve<IEntityManager>().EntityExists(entity.Uid) ? EntityLifeStage.Deleted : IoCManager.Resolve<IEntityManager>().GetComponent<MetaDataComponent>(entity.Uid).EntityLifeStage) >= EntityLifeStage.Deleted));
+            DebugTools.Assert(!((!IoCManager.Resolve<IEntityManager>().EntityExists(entity) ? EntityLifeStage.Deleted : IoCManager.Resolve<IEntityManager>().GetComponent<MetaDataComponent>(entity).EntityLifeStage) >= EntityLifeStage.Deleted));
 
             // Notice the recursion starts at the Owner of the passed in entity, this
             // allows containers inside containers (toolboxes in lockers).
-            if (IoCManager.Resolve<IEntityManager>().GetComponent<TransformComponent>(entity.Uid).Parent == null)
+            if (IoCManager.Resolve<IEntityManager>().GetComponent<TransformComponent>(entity).Parent == null)
                 return false;
 
-            if (TryGetManagerComp(IoCManager.Resolve<IEntityManager>().GetComponent<TransformComponent>(entity.Uid).Parent.Owner, out var containerComp))
+            if (TryGetManagerComp(IoCManager.Resolve<IEntityManager>().GetComponent<TransformComponent>(entity).Parent.Owner, out var containerComp))
                 return containerComp.ContainsEntity(entity);
 
             return false;
@@ -45,9 +45,9 @@ namespace Robust.Shared.Containers
         public static bool TryGetContainerMan(this IEntity entity, [NotNullWhen(true)] out IContainerManager? manager)
         {
             DebugTools.AssertNotNull(entity);
-            DebugTools.Assert(!((!IoCManager.Resolve<IEntityManager>().EntityExists(entity.Uid) ? EntityLifeStage.Deleted : IoCManager.Resolve<IEntityManager>().GetComponent<MetaDataComponent>(entity.Uid).EntityLifeStage) >= EntityLifeStage.Deleted));
+            DebugTools.Assert(!((!IoCManager.Resolve<IEntityManager>().EntityExists(entity) ? EntityLifeStage.Deleted : IoCManager.Resolve<IEntityManager>().GetComponent<MetaDataComponent>(entity).EntityLifeStage) >= EntityLifeStage.Deleted));
 
-            var parentTransform = IoCManager.Resolve<IEntityManager>().GetComponent<TransformComponent>(entity.Uid).Parent;
+            var parentTransform = IoCManager.Resolve<IEntityManager>().GetComponent<TransformComponent>(entity).Parent;
             if (parentTransform != null && TryGetManagerComp(parentTransform.Owner, out manager) && manager.ContainsEntity(entity))
                 return true;
 
@@ -64,7 +64,7 @@ namespace Robust.Shared.Containers
         public static bool TryGetContainer(this IEntity entity, [NotNullWhen(true)] out IContainer? container)
         {
             DebugTools.AssertNotNull(entity);
-            DebugTools.Assert(!((!IoCManager.Resolve<IEntityManager>().EntityExists(entity.Uid) ? EntityLifeStage.Deleted : IoCManager.Resolve<IEntityManager>().GetComponent<MetaDataComponent>(entity.Uid).EntityLifeStage) >= EntityLifeStage.Deleted));
+            DebugTools.Assert(!((!IoCManager.Resolve<IEntityManager>().EntityExists(entity) ? EntityLifeStage.Deleted : IoCManager.Resolve<IEntityManager>().GetComponent<MetaDataComponent>(entity).EntityLifeStage) >= EntityLifeStage.Deleted));
 
             if (TryGetContainerMan(entity, out var manager))
                 return manager.TryGetContainer(entity, out container);
@@ -83,7 +83,7 @@ namespace Robust.Shared.Containers
         public static bool TryRemoveFromContainer(this IEntity entity, bool force, out bool wasInContainer)
         {
             DebugTools.AssertNotNull(entity);
-            DebugTools.Assert(!((!IoCManager.Resolve<IEntityManager>().EntityExists(entity.Uid) ? EntityLifeStage.Deleted : IoCManager.Resolve<IEntityManager>().GetComponent<MetaDataComponent>(entity.Uid).EntityLifeStage) >= EntityLifeStage.Deleted));
+            DebugTools.Assert(!((!IoCManager.Resolve<IEntityManager>().EntityExists(entity) ? EntityLifeStage.Deleted : IoCManager.Resolve<IEntityManager>().GetComponent<MetaDataComponent>(entity).EntityLifeStage) >= EntityLifeStage.Deleted));
 
             if (TryGetContainer(entity, out var container))
             {
@@ -118,7 +118,7 @@ namespace Robust.Shared.Containers
         {
             foreach (var entity in container.ContainedEntities.ToArray())
             {
-                if ((!IoCManager.Resolve<IEntityManager>().EntityExists(entity.Uid) ? EntityLifeStage.Deleted : IoCManager.Resolve<IEntityManager>().GetComponent<MetaDataComponent>(entity.Uid).EntityLifeStage) >= EntityLifeStage.Deleted) continue;
+                if ((!IoCManager.Resolve<IEntityManager>().EntityExists(entity) ? EntityLifeStage.Deleted : IoCManager.Resolve<IEntityManager>().GetComponent<MetaDataComponent>(entity).EntityLifeStage) >= EntityLifeStage.Deleted) continue;
 
                 if (force)
                     container.ForceRemove(entity);
@@ -126,10 +126,10 @@ namespace Robust.Shared.Containers
                     container.Remove(entity);
 
                 if (moveTo.HasValue)
-                    IoCManager.Resolve<IEntityManager>().GetComponent<TransformComponent>(entity.Uid).Coordinates = moveTo.Value;
+                    IoCManager.Resolve<IEntityManager>().GetComponent<TransformComponent>(entity).Coordinates = moveTo.Value;
 
                 if(attachToGridOrMap)
-                    IoCManager.Resolve<IEntityManager>().GetComponent<TransformComponent>(entity.Uid).AttachToGridOrMap();
+                    IoCManager.Resolve<IEntityManager>().GetComponent<TransformComponent>(entity).AttachToGridOrMap();
             }
         }
 
@@ -140,9 +140,9 @@ namespace Robust.Shared.Containers
         {
             foreach (var ent in container.ContainedEntities.ToArray())
             {
-                if ((!IoCManager.Resolve<IEntityManager>().EntityExists(ent.Uid) ? EntityLifeStage.Deleted : IoCManager.Resolve<IEntityManager>().GetComponent<MetaDataComponent>(ent.Uid).EntityLifeStage) >= EntityLifeStage.Deleted) continue;
+                if ((!IoCManager.Resolve<IEntityManager>().EntityExists(ent) ? EntityLifeStage.Deleted : IoCManager.Resolve<IEntityManager>().GetComponent<MetaDataComponent>(ent).EntityLifeStage) >= EntityLifeStage.Deleted) continue;
                 container.ForceRemove(ent);
-                IoCManager.Resolve<IEntityManager>().DeleteEntity(ent.Uid);
+                IoCManager.Resolve<IEntityManager>().DeleteEntity((EntityUid) ent);
             }
         }
 
@@ -158,7 +158,7 @@ namespace Robust.Shared.Containers
         {
             if (container.Insert(transform.Owner)) return true;
 
-            if (IoCManager.Resolve<IEntityManager>().GetComponent<TransformComponent>(container.Owner.Uid).Parent != null
+            if (IoCManager.Resolve<IEntityManager>().GetComponent<TransformComponent>(container.Owner).Parent != null
                 && TryGetContainer(container.Owner, out var newContainer))
                 return TryInsertIntoContainer(transform, newContainer);
 
@@ -168,14 +168,14 @@ namespace Robust.Shared.Containers
         private static bool TryGetManagerComp(this IEntity entity, [NotNullWhen(true)] out IContainerManager? manager)
         {
             DebugTools.AssertNotNull(entity);
-            DebugTools.Assert(!((!IoCManager.Resolve<IEntityManager>().EntityExists(entity.Uid) ? EntityLifeStage.Deleted : IoCManager.Resolve<IEntityManager>().GetComponent<MetaDataComponent>(entity.Uid).EntityLifeStage) >= EntityLifeStage.Deleted));
+            DebugTools.Assert(!((!IoCManager.Resolve<IEntityManager>().EntityExists(entity) ? EntityLifeStage.Deleted : IoCManager.Resolve<IEntityManager>().GetComponent<MetaDataComponent>(entity).EntityLifeStage) >= EntityLifeStage.Deleted));
 
-            if (IoCManager.Resolve<IEntityManager>().TryGetComponent(entity.Uid, out manager))
+            if (IoCManager.Resolve<IEntityManager>().TryGetComponent(entity, out manager))
                 return true;
 
             // RECURSION ALERT
-            if (IoCManager.Resolve<IEntityManager>().GetComponent<TransformComponent>(entity.Uid).Parent != null)
-                return TryGetManagerComp(IoCManager.Resolve<IEntityManager>().GetComponent<TransformComponent>(entity.Uid).Parent.Owner, out manager);
+            if (IoCManager.Resolve<IEntityManager>().GetComponent<TransformComponent>(entity).Parent != null)
+                return TryGetManagerComp(IoCManager.Resolve<IEntityManager>().GetComponent<TransformComponent>(entity).Parent.Owner, out manager);
 
             return false;
         }
@@ -272,7 +272,7 @@ namespace Robust.Shared.Containers
         public static T CreateContainer<T>(this IEntity entity, string containerId)
             where T : IContainer
         {
-            if (!IoCManager.Resolve<IEntityManager>().TryGetComponent<IContainerManager?>(entity.Uid, out var containermanager))
+            if (!IoCManager.Resolve<IEntityManager>().TryGetComponent<IContainerManager?>(entity, out var containermanager))
                 containermanager = IoCManager.Resolve<IEntityManager>().AddComponent<ContainerManagerComponent>(entity);
 
             return containermanager.MakeContainer<T>(containerId);

Robust.Shared/Containers/ContainerManagerComponent.cs

@@ -79,7 +79,7 @@ namespace Robust.Shared.Containers
                 for (var index = 0; index < container.ContainedEntities.Count; index++)
                 {
                     var iEntity = container.ContainedEntities[index];
-                    uidArr[index] = iEntity.Uid;
+                    uidArr[index] = iEntity;
                 }
 
                 var sContainer = new ContainerManagerComponentState.ContainerData(container.ContainerType, container.ID, container.ShowContents, container.OccludesLight, uidArr);

Robust.Shared/Containers/ContainerSlot.cs

@@ -88,7 +88,7 @@ namespace Robust.Shared.Containers
             IEntity? tempQualifier = ContainedEntity;
             if (tempQualifier != null)
             {
-                IoCManager.Resolve<IEntityManager>().DeleteEntity(tempQualifier.Uid);
+                IoCManager.Resolve<IEntityManager>().DeleteEntity((EntityUid) tempQualifier);
             }
         }
     }

Robust.Shared/Containers/SharedContainerSystem.cs

@@ -130,10 +130,10 @@ namespace Robust.Shared.Containers
         {
             var oldParentEntity = message.OldParent;
 
-            if (oldParentEntity == null || !IoCManager.Resolve<IEntityManager>().EntityExists(oldParentEntity.Uid))
+            if (oldParentEntity == null || !IoCManager.Resolve<IEntityManager>().EntityExists(oldParentEntity))
                 return;
 
-            if (IoCManager.Resolve<IEntityManager>().TryGetComponent(oldParentEntity.Uid, out IContainerManager? containerManager))
+            if (IoCManager.Resolve<IEntityManager>().TryGetComponent(oldParentEntity, out IContainerManager? containerManager))
                 containerManager.ForceRemove(message.Entity);
         }
     }

Robust.Shared/GameObjects/Component.cs

@@ -41,11 +41,11 @@ namespace Robust.Shared.GameObjects
 
         /// <inheritdoc />
         [ViewVariables]
-        public EntityUid OwnerUid => Owner.Uid;
+        public EntityUid OwnerUid => Owner;
 
         /// <inheritdoc />
         [ViewVariables]
-        public bool Paused => (!IoCManager.Resolve<IEntityManager>().EntityExists(Owner.Uid) ? EntityLifeStage.Deleted : IoCManager.Resolve<IEntityManager>().GetComponent<MetaDataComponent>(Owner.Uid).EntityLifeStage) >= EntityLifeStage.Deleted || IoCManager.Resolve<IEntityManager>().GetComponent<MetaDataComponent>(Owner.Uid).EntityPaused;
+        public bool Paused => (!IoCManager.Resolve<IEntityManager>().EntityExists(Owner) ? EntityLifeStage.Deleted : IoCManager.Resolve<IEntityManager>().GetComponent<MetaDataComponent>(Owner).EntityLifeStage) >= EntityLifeStage.Deleted || IoCManager.Resolve<IEntityManager>().GetComponent<MetaDataComponent>(Owner).EntityPaused;
 
         /// <inheritdoc />
         [ViewVariables]
@@ -260,7 +260,7 @@ namespace Robust.Shared.GameObjects
         [Obsolete("Component Messages are deprecated, use Entity Events instead.")]
         protected void SendMessage(ComponentMessage message)
         {
-            var components = IoCManager.Resolve<IEntityManager>().GetComponents(Owner.Uid);
+            var components = IoCManager.Resolve<IEntityManager>().GetComponents(Owner);
             foreach (var component in components)
             {
                 if (this != component)

Robust.Shared/GameObjects/ComponentExt.cs

@@ -19,7 +19,7 @@ namespace Robust.Shared.GameObjects
         public static bool EnsureComponent<T>(this IEntity entity, out T component) where T : Component, new()
         {
             ref T? comp = ref component!;
-            if (IoCManager.Resolve<IEntityManager>().TryGetComponent(entity.Uid, out comp))
+            if (IoCManager.Resolve<IEntityManager>().TryGetComponent(entity, out comp))
             {
                 return true;
             }
@@ -37,7 +37,7 @@ namespace Robust.Shared.GameObjects
         /// <returns>The existing component, or the new component if none existed yet.</returns>
         public static T EnsureComponent<T>(this IEntity entity) where T : Component, new()
         {
-            if (IoCManager.Resolve<IEntityManager>().TryGetComponent(entity.Uid, out T? component))
+            if (IoCManager.Resolve<IEntityManager>().TryGetComponent(entity, out T? component))
             {
                 return component;
             }
@@ -60,12 +60,12 @@ namespace Robust.Shared.GameObjects
         public static bool EnsureComponentWarn<T>(this IEntity entity, out T component, string? warning = null) where T : Component, new()
         {
             ref T? comp = ref component!;
-            if (IoCManager.Resolve<IEntityManager>().TryGetComponent(entity.Uid, out comp))
+            if (IoCManager.Resolve<IEntityManager>().TryGetComponent(entity, out comp))
             {
                 return true;
             }
 
-            warning ??= $"Entity {entity} at {IoCManager.Resolve<IEntityManager>().GetComponent<TransformComponent>(entity.Uid).MapPosition} did not have a {typeof(T)}";
+            warning ??= $"Entity {entity} at {IoCManager.Resolve<IEntityManager>().GetComponent<TransformComponent>(entity).MapPosition} did not have a {typeof(T)}";
 
             Logger.Warning(warning);
 
@@ -86,12 +86,12 @@ namespace Robust.Shared.GameObjects
         /// <returns>The existing component, or the new component if none existed yet.</returns>
         public static T EnsureComponentWarn<T>(this IEntity entity, string? warning = null) where T : Component, new()
         {
-            if (IoCManager.Resolve<IEntityManager>().TryGetComponent(entity.Uid, out T? component))
+            if (IoCManager.Resolve<IEntityManager>().TryGetComponent(entity, out T? component))
             {
                 return component;
             }
 
-            warning ??= $"Entity {entity} at {IoCManager.Resolve<IEntityManager>().GetComponent<TransformComponent>(entity.Uid).MapPosition} did not have a {typeof(T)}";
+            warning ??= $"Entity {entity} at {IoCManager.Resolve<IEntityManager>().GetComponent<TransformComponent>(entity).MapPosition} did not have a {typeof(T)}";
 
             Logger.Warning(warning);
 

Robust.Shared/GameObjects/Components/Collidable/PhysicsComponent.Physics.cs

@@ -299,8 +299,8 @@ namespace Robust.Shared.GameObjects
 
         public Box2 GetWorldAABB(Vector2? worldPos = null, Angle? worldRot = null)
         {
-            worldPos ??= IoCManager.Resolve<IEntityManager>().GetComponent<TransformComponent>(Owner.Uid).WorldPosition;
-            worldRot ??= IoCManager.Resolve<IEntityManager>().GetComponent<TransformComponent>(Owner.Uid).WorldRotation;
+            worldPos ??= IoCManager.Resolve<IEntityManager>().GetComponent<TransformComponent>(Owner).WorldPosition;
+            worldRot ??= IoCManager.Resolve<IEntityManager>().GetComponent<TransformComponent>(Owner).WorldRotation;
             var transform = new Transform(worldPos.Value, (float) worldRot.Value.Theta);
 
             var bounds = new Box2(transform.Position, transform.Position);
@@ -564,17 +564,17 @@ namespace Robust.Shared.GameObjects
             {
                 var linearVelocity = _linVelocity;
                 var angularVelocity = _angVelocity;
-                var parent = IoCManager.Resolve<IEntityManager>().GetComponent<TransformComponent>(Owner.Uid).Parent?.Owner;
+                var parent = IoCManager.Resolve<IEntityManager>().GetComponent<TransformComponent>(Owner).Parent?.Owner;
 
                 while (parent != null)
                 {
-                    if (IoCManager.Resolve<IEntityManager>().TryGetComponent(parent.Uid, out PhysicsComponent? body))
+                    if (IoCManager.Resolve<IEntityManager>().TryGetComponent(parent, out PhysicsComponent? body))
                     {
                         linearVelocity += body.LinearVelocity;
                         angularVelocity += body.AngularVelocity;
                     }
 
-                    parent = IoCManager.Resolve<IEntityManager>().GetComponent<TransformComponent>(parent.Uid).Parent?.Owner;
+                    parent = IoCManager.Resolve<IEntityManager>().GetComponent<TransformComponent>(parent).Parent?.Owner;
                 }
 
                 return (linearVelocity, angularVelocity);
@@ -620,16 +620,16 @@ namespace Robust.Shared.GameObjects
             get
             {
                 var velocity = _linVelocity;
-                var parent = IoCManager.Resolve<IEntityManager>().GetComponent<TransformComponent>(Owner.Uid).Parent?.Owner;
+                var parent = IoCManager.Resolve<IEntityManager>().GetComponent<TransformComponent>(Owner).Parent?.Owner;
 
                 while (parent != null)
                 {
-                    if (IoCManager.Resolve<IEntityManager>().TryGetComponent(parent.Uid, out PhysicsComponent? body))
+                    if (IoCManager.Resolve<IEntityManager>().TryGetComponent(parent, out PhysicsComponent? body))
                     {
                         velocity += body.LinearVelocity;
                     }
 
-                    parent = IoCManager.Resolve<IEntityManager>().GetComponent<TransformComponent>(parent.Uid).Parent?.Owner;
+                    parent = IoCManager.Resolve<IEntityManager>().GetComponent<TransformComponent>(parent).Parent?.Owner;
                 }
 
                 return velocity;
@@ -675,16 +675,16 @@ namespace Robust.Shared.GameObjects
             get
             {
                 var velocity = _angVelocity;
-                var parent = IoCManager.Resolve<IEntityManager>().GetComponent<TransformComponent>(Owner.Uid).Parent?.Owner;
+                var parent = IoCManager.Resolve<IEntityManager>().GetComponent<TransformComponent>(Owner).Parent?.Owner;
 
                 while (parent != null)
                 {
-                    if (IoCManager.Resolve<IEntityManager>().TryGetComponent(parent.Uid, out PhysicsComponent? body))
+                    if (IoCManager.Resolve<IEntityManager>().TryGetComponent(parent, out PhysicsComponent? body))
                     {
                         velocity += body.AngularVelocity;
                     }
 
-                    parent = IoCManager.Resolve<IEntityManager>().GetComponent<TransformComponent>(parent.Uid).Parent?.Owner;
+                    parent = IoCManager.Resolve<IEntityManager>().GetComponent<TransformComponent>(parent).Parent?.Owner;
                 }
 
                 return velocity;
@@ -729,7 +729,7 @@ namespace Robust.Shared.GameObjects
 
         public IEnumerable<PhysicsComponent> GetBodiesIntersecting()
         {
-            foreach (var entity in EntitySystem.Get<SharedPhysicsSystem>().GetCollidingEntities(IoCManager.Resolve<IEntityManager>().GetComponent<TransformComponent>(Owner.Uid).MapID, GetWorldAABB()))
+            foreach (var entity in EntitySystem.Get<SharedPhysicsSystem>().GetCollidingEntities(IoCManager.Resolve<IEntityManager>().GetComponent<TransformComponent>(Owner).MapID, GetWorldAABB()))
             {
                 yield return entity;
             }
@@ -763,7 +763,7 @@ namespace Robust.Shared.GameObjects
 
         public Transform GetTransform()
         {
-            var (worldPos, worldRot) = IoCManager.Resolve<IEntityManager>().GetComponent<TransformComponent>(Owner.Uid).GetWorldPositionRotation();
+            var (worldPos, worldRot) = IoCManager.Resolve<IEntityManager>().GetComponent<TransformComponent>(Owner).GetWorldPositionRotation();
 
             var xf = new Transform(worldPos, (float) worldRot.Theta);
             // xf.Position -= Transform.Mul(xf.Quaternion2D, LocalCenter);
@@ -841,10 +841,10 @@ namespace Robust.Shared.GameObjects
             }
 
             // TODO: Ordering fuckery need a new PR to fix some of this stuff
-            if (IoCManager.Resolve<IEntityManager>().GetComponent<TransformComponent>(Owner.Uid).MapID != MapId.Nullspace)
+            if (IoCManager.Resolve<IEntityManager>().GetComponent<TransformComponent>(Owner).MapID != MapId.Nullspace)
             {
-                IEntity tempQualifier = IoCManager.Resolve<IMapManager>().GetMapEntity(IoCManager.Resolve<IEntityManager>().GetComponent<TransformComponent>(Owner.Uid).MapID);
-                PhysicsMap = IoCManager.Resolve<IEntityManager>().GetComponent<SharedPhysicsMapComponent>(tempQualifier.Uid);
+                IEntity tempQualifier = IoCManager.Resolve<IMapManager>().GetMapEntity(IoCManager.Resolve<IEntityManager>().GetComponent<TransformComponent>(Owner).MapID);
+                PhysicsMap = IoCManager.Resolve<IEntityManager>().GetComponent<SharedPhysicsMapComponent>(tempQualifier);
             }
 
             Dirty();
@@ -869,7 +869,7 @@ namespace Robust.Shared.GameObjects
                 else
                 {
                     // TODO: Probably a bad idea but ehh future sloth's problem; namely that we have to duplicate code between here and CanCollide.
-                    IoCManager.Resolve<IEntityManager>().EventBus.RaiseLocalEvent(OwnerUid, new CollisionChangeMessage(this, Owner.Uid, _canCollide));
+                    IoCManager.Resolve<IEntityManager>().EventBus.RaiseLocalEvent(OwnerUid, new CollisionChangeMessage(this, Owner, _canCollide));
                     IoCManager.Resolve<IEntityManager>().EventBus.RaiseLocalEvent(OwnerUid, new PhysicsUpdateMessage(this));
                 }
             }
@@ -878,8 +878,8 @@ namespace Robust.Shared.GameObjects
                 _awake = false;
             }
 
-            var startup = new PhysicsInitializedEvent(Owner.Uid);
-            IoCManager.Resolve<IEntityManager>().EventBus.RaiseLocalEvent(Owner.Uid, ref startup);
+            var startup = new PhysicsInitializedEvent(Owner);
+            IoCManager.Resolve<IEntityManager>().EventBus.RaiseLocalEvent(Owner, ref startup);
 
             ResetMassData();
         }
@@ -974,11 +974,11 @@ namespace Robust.Shared.GameObjects
             // Does a joint prevent collision?
             // if one of them doesn't have jointcomp then they can't share a common joint.
             // otherwise, only need to iterate over the joints of one component as they both store the same joint.
-            if (IoCManager.Resolve<IEntityManager>().TryGetComponent(Owner.Uid, out JointComponent? jointComponentA) &&
-                IoCManager.Resolve<IEntityManager>().TryGetComponent(other.Owner.Uid, out JointComponent? jointComponentB))
+            if (IoCManager.Resolve<IEntityManager>().TryGetComponent(Owner, out JointComponent? jointComponentA) &&
+                IoCManager.Resolve<IEntityManager>().TryGetComponent(other.Owner, out JointComponent? jointComponentB))
             {
-                var aUid = jointComponentA.Owner.Uid;
-                var bUid = jointComponentB.Owner.Uid;
+                var aUid = (EntityUid) jointComponentA.Owner;
+                var bUid = (EntityUid) jointComponentB.Owner;
 
                 foreach (var (_, joint) in jointComponentA.Joints)
                 {
@@ -992,12 +992,12 @@ namespace Robust.Shared.GameObjects
             }
 
             var preventCollideMessage = new PreventCollideEvent(this, other);
-            IoCManager.Resolve<IEntityManager>().EventBus.RaiseLocalEvent(Owner.Uid, preventCollideMessage);
+            IoCManager.Resolve<IEntityManager>().EventBus.RaiseLocalEvent(Owner, preventCollideMessage);
 
             if (preventCollideMessage.Cancelled) return false;
 
             preventCollideMessage = new PreventCollideEvent(other, this);
-            IoCManager.Resolve<IEntityManager>().EventBus.RaiseLocalEvent(other.Owner.Uid, preventCollideMessage);
+            IoCManager.Resolve<IEntityManager>().EventBus.RaiseLocalEvent(other.Owner, preventCollideMessage);
 
             if (preventCollideMessage.Cancelled) return false;
 

Robust.Shared/GameObjects/Components/CollisionWakeComponent.cs

@@ -37,13 +37,13 @@ namespace Robust.Shared.GameObjects
 
         internal void RaiseStateChange()
         {
-            IoCManager.Resolve<IEntityManager>().EventBus.RaiseLocalEvent(Owner.Uid, new CollisionWakeStateMessage(), false);
+            IoCManager.Resolve<IEntityManager>().EventBus.RaiseLocalEvent(Owner, new CollisionWakeStateMessage(), false);
         }
 
         protected override void OnRemove()
         {
             base.OnRemove();
-            if (IoCManager.Resolve<IEntityManager>().TryGetComponent(Owner.Uid, out IPhysBody? body) && (!IoCManager.Resolve<IEntityManager>().EntityExists(Owner.Uid) ? EntityLifeStage.Deleted : IoCManager.Resolve<IEntityManager>().GetComponent<MetaDataComponent>(Owner.Uid).EntityLifeStage) < EntityLifeStage.Terminating)
+            if (IoCManager.Resolve<IEntityManager>().TryGetComponent(Owner, out IPhysBody? body) && (!IoCManager.Resolve<IEntityManager>().EntityExists(Owner) ? EntityLifeStage.Deleted : IoCManager.Resolve<IEntityManager>().GetComponent<MetaDataComponent>(Owner).EntityLifeStage) < EntityLifeStage.Terminating)
             {
                 body.CanCollide = true;
             }

Robust.Shared/GameObjects/Components/IgnorePauseComponent.cs

@@ -11,15 +11,15 @@ namespace Robust.Shared.GameObjects
         protected override void OnAdd()
         {
             base.OnAdd();
-            IoCManager.Resolve<IEntityManager>().GetComponent<MetaDataComponent>(Owner.Uid).EntityPaused = false;
+            IoCManager.Resolve<IEntityManager>().GetComponent<MetaDataComponent>(Owner).EntityPaused = false;
         }
 
         protected override void OnRemove()
         {
             base.OnRemove();
-            if (IoCManager.Resolve<IPauseManager>().IsMapPaused(IoCManager.Resolve<IEntityManager>().GetComponent<TransformComponent>(Owner.Uid).MapID))
+            if (IoCManager.Resolve<IPauseManager>().IsMapPaused(IoCManager.Resolve<IEntityManager>().GetComponent<TransformComponent>(Owner).MapID))
             {
-                IoCManager.Resolve<IEntityManager>().GetComponent<MetaDataComponent>(Owner.Uid).EntityPaused = true;
+                IoCManager.Resolve<IEntityManager>().GetComponent<MetaDataComponent>(Owner).EntityPaused = true;
             }
         }
     }

Robust.Shared/GameObjects/Components/Light/OccluderComponent.cs

@@ -29,7 +29,7 @@ namespace Robust.Shared.GameObjects
             {
                 _boundingBox = value;
                 Dirty();
-                IoCManager.Resolve<IEntityManager>().EventBus.RaiseLocalEvent(Owner.Uid, new OccluderUpdateEvent(this));
+                IoCManager.Resolve<IEntityManager>().EventBus.RaiseLocalEvent(Owner, new OccluderUpdateEvent(this));
             }
         }
 
@@ -45,11 +45,11 @@ namespace Robust.Shared.GameObjects
                 _enabled = value;
                 if (_enabled)
                 {
-                    IoCManager.Resolve<IEntityManager>().EventBus.RaiseLocalEvent(Owner.Uid, new OccluderAddEvent(this));
+                    IoCManager.Resolve<IEntityManager>().EventBus.RaiseLocalEvent(Owner, new OccluderAddEvent(this));
                 }
                 else
                 {
-                    IoCManager.Resolve<IEntityManager>().EventBus.RaiseLocalEvent(Owner.Uid, new OccluderRemoveEvent(this));
+                    IoCManager.Resolve<IEntityManager>().EventBus.RaiseLocalEvent(Owner, new OccluderRemoveEvent(this));
                 }
 
                 Dirty();

Robust.Shared/GameObjects/Components/Light/SharedPointLightComponent.cs

@@ -39,7 +39,7 @@ namespace Robust.Shared.GameObjects
             {
                 if (_enabled == value) return;
                 _enabled = value;
-                IoCManager.Resolve<IEntityManager>().EventBus.RaiseLocalEvent(Owner.Uid, new PointLightToggleEvent(_enabled));
+                IoCManager.Resolve<IEntityManager>().EventBus.RaiseLocalEvent(Owner, new PointLightToggleEvent(_enabled));
                 Dirty();
             }
         }

Robust.Shared/GameObjects/Components/Map/MapComponent.cs

@@ -65,7 +65,7 @@ namespace Robust.Shared.GameObjects
             _mapIndex = state.MapId;
             LightingEnabled = state.LightingEnabled;
 
-            ((TransformComponent) IoCManager.Resolve<IEntityManager>().GetComponent<TransformComponent>(Owner.Uid)).ChangeMapId(_mapIndex);
+            ((TransformComponent) IoCManager.Resolve<IEntityManager>().GetComponent<TransformComponent>(Owner)).ChangeMapId(_mapIndex);
         }
     }
 

Robust.Shared/GameObjects/Components/Map/MapGridComponent.cs

@@ -59,11 +59,11 @@ namespace Robust.Shared.GameObjects
         protected override void Initialize()
         {
             base.Initialize();
-            var mapId = IoCManager.Resolve<IEntityManager>().GetComponent<TransformComponent>(Owner.Uid).MapID;
+            var mapId = IoCManager.Resolve<IEntityManager>().GetComponent<TransformComponent>(Owner).MapID;
 
             if (_mapManager.HasMapEntity(mapId))
             {
-                IoCManager.Resolve<IEntityManager>().GetComponent<TransformComponent>(Owner.Uid).AttachParent(_mapManager.GetMapEntity(mapId));
+                IoCManager.Resolve<IEntityManager>().GetComponent<TransformComponent>(Owner).AttachParent(_mapManager.GetMapEntity(mapId));
             }
         }
 
@@ -76,14 +76,14 @@ namespace Robust.Shared.GameObjects
 
             if (result)
             {
-                xform.Parent = IoCManager.Resolve<IEntityManager>().GetComponent<TransformComponent>(Owner.Uid);
+                xform.Parent = IoCManager.Resolve<IEntityManager>().GetComponent<TransformComponent>(Owner);
 
                 // anchor snapping
                 xform.LocalPosition = Grid.GridTileToLocal(tileIndices).Position;
 
                 xform.SetAnchored(result);
 
-                if (IoCManager.Resolve<IEntityManager>().TryGetComponent<PhysicsComponent?>(xform.Owner.Uid, out var physicsComponent))
+                if (IoCManager.Resolve<IEntityManager>().TryGetComponent<PhysicsComponent?>(xform.Owner, out var physicsComponent))
                 {
                     physicsComponent.BodyType = BodyType.Static;
                 }
@@ -104,7 +104,7 @@ namespace Robust.Shared.GameObjects
             var tileIndices = Grid.TileIndicesFor(transform.Coordinates);
             Grid.RemoveFromSnapGridCell(tileIndices, transform.OwnerUid);
             xform.SetAnchored(false);
-            if (IoCManager.Resolve<IEntityManager>().TryGetComponent<PhysicsComponent?>(xform.Owner.Uid, out var physicsComponent))
+            if (IoCManager.Resolve<IEntityManager>().TryGetComponent<PhysicsComponent?>(xform.Owner, out var physicsComponent))
             {
                 physicsComponent.BodyType = BodyType.Dynamic;
             }

Robust.Shared/GameObjects/Components/MetaDataComponent.cs

@@ -143,11 +143,11 @@ namespace Robust.Shared.GameObjects
             get => _entityPaused;
             set
             {
-                if (_entityPaused == value || value && IoCManager.Resolve<IEntityManager>().HasComponent<IgnorePauseComponent>(Owner.Uid))
+                if (_entityPaused == value || value && IoCManager.Resolve<IEntityManager>().HasComponent<IgnorePauseComponent>(Owner))
                     return;
 
                 _entityPaused = value;
-                IoCManager.Resolve<IEntityManager>().EventBus.RaiseLocalEvent(Owner.Uid, new EntityPausedEvent(Owner.Uid, value));
+                IoCManager.Resolve<IEntityManager>().EventBus.RaiseLocalEvent(Owner, new EntityPausedEvent(Owner, value));
             }
         }
 

Robust.Shared/GameObjects/Components/Transform/TransformComponent.cs

@@ -428,7 +428,7 @@ namespace Robust.Shared.GameObjects
                     if (value && _mapManager.TryFindGridAt(MapPosition, out var grid))
                     {
                         IEntity tempQualifier = IoCManager.Resolve<IEntityManager>().GetEntity(grid.GridEntityId);
-                        _anchored = IoCManager.Resolve<IEntityManager>().GetComponent<IMapGridComponent>(tempQualifier.Uid).AnchorEntity(this);
+                        _anchored = IoCManager.Resolve<IEntityManager>().GetComponent<IMapGridComponent>(tempQualifier).AnchorEntity(this);
                     }
                     // If no grid found then unanchor it.
                     else
@@ -439,7 +439,7 @@ namespace Robust.Shared.GameObjects
                 else if (value && !_anchored && _mapManager.TryFindGridAt(MapPosition, out var grid))
                 {
                     IEntity tempQualifier = IoCManager.Resolve<IEntityManager>().GetEntity(grid.GridEntityId);
-                    _anchored = IoCManager.Resolve<IEntityManager>().GetComponent<IMapGridComponent>(tempQualifier.Uid).AnchorEntity(this);
+                    _anchored = IoCManager.Resolve<IEntityManager>().GetComponent<IMapGridComponent>(tempQualifier).AnchorEntity(this);
                 }
                 else if (!value && _anchored)
                 {
@@ -456,7 +456,11 @@ namespace Robust.Shared.GameObjects
 
         [ViewVariables]
         public IEnumerable<TransformComponent> Children =>
-            _children.Select(u => { return IoCManager.Resolve<IEntityManager>().GetComponent<TransformComponent>(IoCManager.Resolve<IEntityManager>().GetEntity(u).Uid); });
+            _children.Select(u =>
+            {
+                IEntity tempQualifier = IoCManager.Resolve<IEntityManager>().GetEntity(u);
+                return IoCManager.Resolve<IEntityManager>().GetComponent<TransformComponent>(tempQualifier);
+            });
 
         [ViewVariables] public IEnumerable<EntityUid> ChildEntityUids => _children;
 
@@ -511,7 +515,7 @@ namespace Robust.Shared.GameObjects
                 else
                 {
                     // second level node, terminates recursion up the branch of the tree
-                    if (IoCManager.Resolve<IEntityManager>().TryGetComponent(p.Owner.Uid, out IMapComponent? mapComp))
+                    if (IoCManager.Resolve<IEntityManager>().TryGetComponent(p.Owner, out IMapComponent? mapComp))
                     {
                         value = mapComp.WorldMap;
                     }
@@ -546,12 +550,12 @@ namespace Robust.Shared.GameObjects
 
         private GridId GetGridIndex()
         {
-            if (IoCManager.Resolve<IEntityManager>().HasComponent<IMapComponent>(Owner.Uid))
+            if (IoCManager.Resolve<IEntityManager>().HasComponent<IMapComponent>(Owner))
             {
                 return GridId.Invalid;
             }
 
-            if (IoCManager.Resolve<IEntityManager>().TryGetComponent(Owner.Uid, out IMapGridComponent? gridComponent))
+            if (IoCManager.Resolve<IEntityManager>().TryGetComponent(Owner, out IMapGridComponent? gridComponent))
             {
                 return gridComponent.GridIndex;
             }
@@ -733,7 +737,7 @@ namespace Robust.Shared.GameObjects
 
         public void AttachParent(IEntity parent)
         {
-            var transform = IoCManager.Resolve<IEntityManager>().GetComponent<TransformComponent>(parent.Uid);
+            var transform = IoCManager.Resolve<IEntityManager>().GetComponent<TransformComponent>(parent);
             AttachParent(transform);
         }
 
@@ -872,7 +876,7 @@ namespace Robust.Shared.GameObjects
 #endif
                             }
 
-                            AttachParent(IoCManager.Resolve<IEntityManager>().GetComponent<TransformComponent>(newParent.Uid));
+                            AttachParent(IoCManager.Resolve<IEntityManager>().GetComponent<TransformComponent>(newParent));
                         }
                     }
 

Robust.Shared/GameObjects/EntityManager.Components.cs

@@ -172,7 +172,7 @@ namespace Robust.Shared.GameObjects
 
         public void AddComponent<T>(IEntity entity, T component, bool overwrite = false) where T : Component
         {
-            AddComponent(entity.Uid, component, overwrite);
+            AddComponent((EntityUid) entity, component, overwrite);
         }
 
         public void AddComponent<T>(EntityUid uid, T component, bool overwrite = false) where T : Component
@@ -464,7 +464,7 @@ namespace Robust.Shared.GameObjects
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public T EnsureComponent<T>(IEntity entity) where T : Component, new()
         {
-            if (TryGetComponent<T>(entity.Uid, out var component))
+            if (TryGetComponent<T>(entity, out var component))
             {
                 return component;
             }

Robust.Shared/GameObjects/EntityManager.cs

@@ -166,7 +166,7 @@ namespace Robust.Shared.GameObjects
 
             if (coordinates.IsValid(this))
             {
-                IoCManager.Resolve<IEntityManager>().GetComponent<TransformComponent>(newEntity.Uid).Coordinates = coordinates;
+                IoCManager.Resolve<IEntityManager>().GetComponent<TransformComponent>(newEntity).Coordinates = coordinates;
             }
 
             return newEntity;
@@ -176,13 +176,13 @@ namespace Robust.Shared.GameObjects
         public virtual IEntity CreateEntityUninitialized(string? prototypeName, MapCoordinates coordinates)
         {
             var newEntity = CreateEntity(prototypeName);
-            IoCManager.Resolve<IEntityManager>().GetComponent<TransformComponent>(newEntity.Uid).AttachParent(_mapManager.GetMapEntity(coordinates.MapId));
+            IoCManager.Resolve<IEntityManager>().GetComponent<TransformComponent>(newEntity).AttachParent(_mapManager.GetMapEntity(coordinates.MapId));
 
             // TODO: Look at this bullshit. Please code a way to force-move an entity regardless of anchoring.
-            var oldAnchored = IoCManager.Resolve<IEntityManager>().GetComponent<TransformComponent>(newEntity.Uid).Anchored;
-            IoCManager.Resolve<IEntityManager>().GetComponent<TransformComponent>(newEntity.Uid).Anchored = false;
-            IoCManager.Resolve<IEntityManager>().GetComponent<TransformComponent>(newEntity.Uid).WorldPosition = coordinates.Position;
-            IoCManager.Resolve<IEntityManager>().GetComponent<TransformComponent>(newEntity.Uid).Anchored = oldAnchored;
+            var oldAnchored = IoCManager.Resolve<IEntityManager>().GetComponent<TransformComponent>(newEntity).Anchored;
+            IoCManager.Resolve<IEntityManager>().GetComponent<TransformComponent>(newEntity).Anchored = false;
+            IoCManager.Resolve<IEntityManager>().GetComponent<TransformComponent>(newEntity).WorldPosition = coordinates.Position;
+            IoCManager.Resolve<IEntityManager>().GetComponent<TransformComponent>(newEntity).Anchored = oldAnchored;
             return newEntity;
         }
 
@@ -223,7 +223,7 @@ namespace Robust.Shared.GameObjects
         /// <returns>True if a value was returned, false otherwise.</returns>
         public bool TryGetEntity(EntityUid uid, [NotNullWhen(true)] out IEntity? entity)
         {
-            if (Entities.TryGetValue(uid, out var cEntity) && !((!IoCManager.Resolve<IEntityManager>().EntityExists(cEntity.Uid) ? EntityLifeStage.Deleted : IoCManager.Resolve<IEntityManager>().GetComponent<MetaDataComponent>(cEntity.Uid).EntityLifeStage) >= EntityLifeStage.Deleted))
+            if (Entities.TryGetValue(uid, out var cEntity) && !((!IoCManager.Resolve<IEntityManager>().EntityExists(cEntity) ? EntityLifeStage.Deleted : IoCManager.Resolve<IEntityManager>().GetComponent<MetaDataComponent>(cEntity).EntityLifeStage) >= EntityLifeStage.Deleted))
             {
                 entity = cEntity;
                 return true;
@@ -276,10 +276,10 @@ namespace Robust.Shared.GameObjects
             // Networking blindly spams entities at this function, they can already be
             // deleted from being a child of a previously deleted entity
             // TODO: Why does networking need to send deletes for child entities?
-            if ((!IoCManager.Resolve<IEntityManager>().EntityExists(e.Uid) ? EntityLifeStage.Deleted : IoCManager.Resolve<IEntityManager>().GetComponent<MetaDataComponent>(e.Uid).EntityLifeStage) >= EntityLifeStage.Deleted)
+            if ((!IoCManager.Resolve<IEntityManager>().EntityExists(e) ? EntityLifeStage.Deleted : IoCManager.Resolve<IEntityManager>().GetComponent<MetaDataComponent>(e).EntityLifeStage) >= EntityLifeStage.Deleted)
                 return;
 
-            if ((!IoCManager.Resolve<IEntityManager>().EntityExists(e.Uid) ? EntityLifeStage.Deleted : IoCManager.Resolve<IEntityManager>().GetComponent<MetaDataComponent>(e.Uid).EntityLifeStage) >= EntityLifeStage.Terminating)
+            if ((!IoCManager.Resolve<IEntityManager>().EntityExists(e) ? EntityLifeStage.Deleted : IoCManager.Resolve<IEntityManager>().GetComponent<MetaDataComponent>(e).EntityLifeStage) >= EntityLifeStage.Terminating)
 #if !EXCEPTION_TOLERANCE
                 throw new InvalidOperationException("Called Delete on an entity already being deleted.");
 #else
@@ -291,14 +291,14 @@ namespace Robust.Shared.GameObjects
 
         private void RecursiveDeleteEntity(IEntity entity)
         {
-            if((!IoCManager.Resolve<IEntityManager>().EntityExists(entity.Uid) ? EntityLifeStage.Deleted : IoCManager.Resolve<IEntityManager>().GetComponent<MetaDataComponent>(entity.Uid).EntityLifeStage) >= EntityLifeStage.Deleted) //TODO: Why was this still a child if it was already deleted?
+            if((!IoCManager.Resolve<IEntityManager>().EntityExists(entity) ? EntityLifeStage.Deleted : IoCManager.Resolve<IEntityManager>().GetComponent<MetaDataComponent>(entity).EntityLifeStage) >= EntityLifeStage.Deleted) //TODO: Why was this still a child if it was already deleted?
                 return;
 
-            var uid = entity.Uid;
-            var transform = IoCManager.Resolve<IEntityManager>().GetComponent<TransformComponent>(entity.Uid);
-            var metadata = IoCManager.Resolve<IEntityManager>().GetComponent<MetaDataComponent>(entity.Uid);
-            IoCManager.Resolve<IEntityManager>().GetComponent<MetaDataComponent>(entity.Uid).EntityLifeStage = EntityLifeStage.Terminating;
-            EventBus.RaiseLocalEvent(entity.Uid, new EntityTerminatingEvent(), false);
+            var uid = (EntityUid) entity;
+            var transform = IoCManager.Resolve<IEntityManager>().GetComponent<TransformComponent>(entity);
+            var metadata = IoCManager.Resolve<IEntityManager>().GetComponent<MetaDataComponent>(entity);
+            IoCManager.Resolve<IEntityManager>().GetComponent<MetaDataComponent>(entity).EntityLifeStage = EntityLifeStage.Terminating;
+            EventBus.RaiseLocalEvent(entity, new EntityTerminatingEvent(), false);
 
             // DeleteEntity modifies our _children collection, we must cache the collection to iterate properly
             foreach (var childTransform in transform.Children.ToArray())
@@ -322,17 +322,17 @@ namespace Robust.Shared.GameObjects
             }
 
             // Dispose all my components, in a safe order so transform is available
-            DisposeComponents(entity.Uid);
+            DisposeComponents(entity);
 
             metadata.EntityLifeStage = EntityLifeStage.Deleted;
-            EntityDeleted?.Invoke(this, entity.Uid);
+            EntityDeleted?.Invoke(this, entity);
             EventBus.RaiseEvent(EventSource.Local, new EntityDeletedMessage(entity));
-            Entities.Remove(entity.Uid);
+            Entities.Remove(entity);
         }
 
         public void QueueDeleteEntity(IEntity entity)
         {
-            QueueDeleteEntity(entity.Uid);
+            QueueDeleteEntity((EntityUid) entity);
         }
 
         public void QueueDeleteEntity(EntityUid uid)
@@ -379,7 +379,7 @@ namespace Robust.Shared.GameObjects
 
             var entity = AllocEntity(uid);
 
-            IoCManager.Resolve<IEntityManager>().GetComponent<MetaDataComponent>(entity.Uid).EntityPrototype = prototype;
+            IoCManager.Resolve<IEntityManager>().GetComponent<MetaDataComponent>(entity).EntityPrototype = prototype;
 
             return entity;
         }
@@ -402,10 +402,10 @@ namespace Robust.Shared.GameObjects
             var entity = new IEntity(uid.Value);
 
             // we want this called before adding components
-            EntityAdded?.Invoke(this, entity.Uid);
+            EntityAdded?.Invoke(this, entity);
 
             // We do this after the event, so if the event throws we have not committed
-            Entities[entity.Uid] = entity;
+            Entities[entity] = entity;
 
             // Create the MetaDataComponent and set it directly on the Entity to avoid a stack overflow in DEBUG.
             var metadata = new MetaDataComponent() { Owner = entity };
@@ -431,7 +431,7 @@ namespace Robust.Shared.GameObjects
             var entity = AllocEntity(prototypeName, uid);
             try
             {
-                EntityPrototype.LoadEntity(IoCManager.Resolve<IEntityManager>().GetComponent<MetaDataComponent>(entity.Uid).EntityPrototype, entity, ComponentFactory, null);
+                EntityPrototype.LoadEntity(IoCManager.Resolve<IEntityManager>().GetComponent<MetaDataComponent>(entity).EntityPrototype, entity, ComponentFactory, null);
                 return entity;
             }
             catch (Exception e)
@@ -445,7 +445,7 @@ namespace Robust.Shared.GameObjects
 
         private protected void LoadEntity(IEntity entity, IEntityLoadContext? context)
         {
-            EntityPrototype.LoadEntity(IoCManager.Resolve<IEntityManager>().GetComponent<MetaDataComponent>(entity.Uid).EntityPrototype, entity, ComponentFactory, context);
+            EntityPrototype.LoadEntity(IoCManager.Resolve<IEntityManager>().GetComponent<MetaDataComponent>(entity).EntityPrototype, entity, ComponentFactory, context);
         }
 
         private void InitializeAndStartEntity(IEntity entity, MapId mapId)
@@ -468,14 +468,14 @@ namespace Robust.Shared.GameObjects
 
         protected void InitializeEntity(IEntity entity)
         {
-            InitializeComponents(entity.Uid);
-            EntityInitialized?.Invoke(this, entity.Uid);
+            InitializeComponents(entity);
+            EntityInitialized?.Invoke(this, entity);
         }
 
         protected void StartEntity(IEntity entity)
         {
-            StartComponents(entity.Uid);
-            EntityStarted?.Invoke(this, entity.Uid);
+            StartComponents(entity);
+            EntityStarted?.Invoke(this, entity);
         }
 
         /// <inheritdoc />

Robust.Shared/GameObjects/EntitySystem.Resolve.cs

@@ -21,7 +21,7 @@ namespace Robust.Shared.GameObjects
         protected bool Resolve<TComp>(EntityUid uid, [NotNullWhen(true)] ref TComp? component, bool logMissing = true)
             where TComp : IComponent
         {
-            DebugTools.Assert(component == null || uid == component.Owner.Uid, "Specified Entity is not the component's Owner!");
+            DebugTools.Assert(component == null || uid == component.Owner, "Specified Entity is not the component's Owner!");
 
             if (component != null)
                 return true;

Robust.Shared/GameObjects/IComponent.cs

@@ -47,7 +47,7 @@ namespace Robust.Shared.GameObjects
         /// <summary>
         ///     Entity Uid that this component is attached to.
         /// </summary>
-        EntityUid OwnerUid => Owner.Uid;
+        EntityUid OwnerUid => Owner;
 
         /// <summary>
         /// Component has been properly initialized.

Robust.Shared/GameObjects/IEntity.cs

@@ -8,8 +8,6 @@ namespace Robust.Shared.GameObjects
     [CopyByRef, Serializable]
     public sealed class IEntity : EntityUid
     {
-        [ViewVariables] public EntityUid Uid => this;
-
         public IEntity(int uid) : base(uid)
         {
         }

Robust.Shared/GameObjects/IMapInit.cs

@@ -27,11 +27,11 @@ namespace Robust.Shared.GameObjects
 
         public static void RunMapInit(this IEntity entity)
         {
-            DebugTools.Assert((!IoCManager.Resolve<IEntityManager>().EntityExists(entity.Uid) ? EntityLifeStage.Deleted : IoCManager.Resolve<IEntityManager>().GetComponent<MetaDataComponent>(entity.Uid).EntityLifeStage) == EntityLifeStage.Initialized);
-            IoCManager.Resolve<IEntityManager>().GetComponent<MetaDataComponent>(entity.Uid).EntityLifeStage = EntityLifeStage.MapInitialized;
+            DebugTools.Assert((!IoCManager.Resolve<IEntityManager>().EntityExists(entity) ? EntityLifeStage.Deleted : IoCManager.Resolve<IEntityManager>().GetComponent<MetaDataComponent>(entity).EntityLifeStage) == EntityLifeStage.Initialized);
+            IoCManager.Resolve<IEntityManager>().GetComponent<MetaDataComponent>(entity).EntityLifeStage = EntityLifeStage.MapInitialized;
 
-            IoCManager.Resolve<IEntityManager>().EventBus.RaiseLocalEvent(entity.Uid, MapInit, false);
-            foreach (var init in IoCManager.Resolve<IEntityManager>().GetComponents<IMapInit>(entity.Uid))
+            IoCManager.Resolve<IEntityManager>().EventBus.RaiseLocalEvent(entity, MapInit, false);
+            foreach (var init in IoCManager.Resolve<IEntityManager>().GetComponents<IMapInit>(entity))
             {
                 init.MapInit();
             }

Robust.Shared/GameObjects/Systems/EntityLookup.cs

@@ -169,7 +169,7 @@ namespace Robust.Shared.GameObjects
         {
             // This event needs to be handled immediately as anchoring is handled immediately
             // and any callers may potentially get duplicate entities that just changed state.
-            if (IoCManager.Resolve<IEntityManager>().GetComponent<TransformComponent>(@event.Entity.Uid).Anchored)
+            if (IoCManager.Resolve<IEntityManager>().GetComponent<TransformComponent>(@event.Entity).Anchored)
             {
                 RemoveFromEntityTrees(@event.Entity);
             }
@@ -191,7 +191,7 @@ namespace Robust.Shared.GameObjects
 
         private void HandleLookupInit(EntityUid uid, EntityLookupComponent component, ComponentInit args)
         {
-            var capacity = (int) Math.Min(256, Math.Ceiling(IoCManager.Resolve<IEntityManager>().GetComponent<TransformComponent>(component.Owner.Uid).ChildCount / (float) GrowthRate) * GrowthRate);
+            var capacity = (int) Math.Min(256, Math.Ceiling(IoCManager.Resolve<IEntityManager>().GetComponent<TransformComponent>(component.Owner).ChildCount / (float) GrowthRate) * GrowthRate);
 
             component.Tree = new DynamicTree<IEntity>(
                 GetRelativeAABBFromEntity,
@@ -207,7 +207,7 @@ namespace Robust.Shared.GameObjects
             var aabb = GetWorldAABB(entity);
             var tree = GetLookup(entity);
 
-            return (tree != null ? IoCManager.Resolve<IEntityManager>().GetComponent<TransformComponent>(tree.Owner.Uid) : null).InvWorldMatrix.TransformBox(aabb) ?? aabb;
+            return (tree != null ? IoCManager.Resolve<IEntityManager>().GetComponent<TransformComponent>(tree.Owner) : null).InvWorldMatrix.TransformBox(aabb) ?? aabb;
         }
 
         private void HandleEntityDeleted(object? sender, EntityUid uid)
@@ -218,7 +218,7 @@ namespace Robust.Shared.GameObjects
         private void HandleEntityStarted(object? sender, EntityUid uid)
         {
             var entity = _entityManager.GetEntity(uid);
-            if (IoCManager.Resolve<IEntityManager>().GetComponent<TransformComponent>(entity.Uid).Anchored) return;
+            if (IoCManager.Resolve<IEntityManager>().GetComponent<TransformComponent>(entity).Anchored) return;
             UpdateEntityTree(entity);
         }
 
@@ -236,30 +236,30 @@ namespace Robust.Shared.GameObjects
             // Could be more efficient but essentially nuke their old lookup and add to new lookup if applicable.
             while (_parentChangeQueue.TryDequeue(out var mapChangeEvent))
             {
-                _handledThisTick.Add(mapChangeEvent.Entity.Uid);
+                _handledThisTick.Add(mapChangeEvent.Entity);
                 RemoveFromEntityTrees(mapChangeEvent.Entity);
 
-                if ((!IoCManager.Resolve<IEntityManager>().EntityExists(mapChangeEvent.Entity.Uid) ? EntityLifeStage.Deleted : IoCManager.Resolve<IEntityManager>().GetComponent<MetaDataComponent>(mapChangeEvent.Entity.Uid).EntityLifeStage) >= EntityLifeStage.Deleted || IoCManager.Resolve<IEntityManager>().GetComponent<TransformComponent>(mapChangeEvent.Entity.Uid).Anchored) continue;
+                if ((!IoCManager.Resolve<IEntityManager>().EntityExists(mapChangeEvent.Entity) ? EntityLifeStage.Deleted : IoCManager.Resolve<IEntityManager>().GetComponent<MetaDataComponent>(mapChangeEvent.Entity).EntityLifeStage) >= EntityLifeStage.Deleted || IoCManager.Resolve<IEntityManager>().GetComponent<TransformComponent>(mapChangeEvent.Entity).Anchored) continue;
                 UpdateEntityTree(mapChangeEvent.Entity, GetWorldAabbFromEntity(mapChangeEvent.Entity));
             }
 
             while (_moveQueue.TryPop(out var moveEvent))
             {
-                if (!_handledThisTick.Add(moveEvent.Sender.Uid) ||
-                    (!IoCManager.Resolve<IEntityManager>().EntityExists(moveEvent.Sender.Uid) ? EntityLifeStage.Deleted : IoCManager.Resolve<IEntityManager>().GetComponent<MetaDataComponent>(moveEvent.Sender.Uid).EntityLifeStage) >= EntityLifeStage.Deleted ||
-                    IoCManager.Resolve<IEntityManager>().GetComponent<TransformComponent>(moveEvent.Sender.Uid).Anchored) continue;
+                if (!_handledThisTick.Add(moveEvent.Sender) ||
+                    (!IoCManager.Resolve<IEntityManager>().EntityExists(moveEvent.Sender) ? EntityLifeStage.Deleted : IoCManager.Resolve<IEntityManager>().GetComponent<MetaDataComponent>(moveEvent.Sender).EntityLifeStage) >= EntityLifeStage.Deleted ||
+                    IoCManager.Resolve<IEntityManager>().GetComponent<TransformComponent>(moveEvent.Sender).Anchored) continue;
 
-                DebugTools.Assert(!IoCManager.Resolve<IEntityManager>().GetComponent<TransformComponent>(moveEvent.Sender.Uid).Anchored);
+                DebugTools.Assert(!IoCManager.Resolve<IEntityManager>().GetComponent<TransformComponent>(moveEvent.Sender).Anchored);
                 UpdateEntityTree(moveEvent.Sender, moveEvent.WorldAABB);
             }
 
             while (_rotateQueue.TryPop(out var rotateEvent))
             {
-                if (!_handledThisTick.Add(rotateEvent.Sender.Uid) ||
-                    (!IoCManager.Resolve<IEntityManager>().EntityExists(rotateEvent.Sender.Uid) ? EntityLifeStage.Deleted : IoCManager.Resolve<IEntityManager>().GetComponent<MetaDataComponent>(rotateEvent.Sender.Uid).EntityLifeStage) >= EntityLifeStage.Deleted ||
-                    IoCManager.Resolve<IEntityManager>().GetComponent<TransformComponent>(rotateEvent.Sender.Uid).Anchored) continue;
+                if (!_handledThisTick.Add(rotateEvent.Sender) ||
+                    (!IoCManager.Resolve<IEntityManager>().EntityExists(rotateEvent.Sender) ? EntityLifeStage.Deleted : IoCManager.Resolve<IEntityManager>().GetComponent<MetaDataComponent>(rotateEvent.Sender).EntityLifeStage) >= EntityLifeStage.Deleted ||
+                    IoCManager.Resolve<IEntityManager>().GetComponent<TransformComponent>(rotateEvent.Sender).Anchored) continue;
 
-                DebugTools.Assert(!IoCManager.Resolve<IEntityManager>().GetComponent<TransformComponent>(rotateEvent.Sender.Uid).Anchored);
+                DebugTools.Assert(!IoCManager.Resolve<IEntityManager>().GetComponent<TransformComponent>(rotateEvent.Sender).Anchored);
                 UpdateEntityTree(rotateEvent.Sender, rotateEvent.WorldAABB);
             }
 
@@ -307,7 +307,7 @@ namespace Robust.Shared.GameObjects
 
                     _final = true;
                     IEntity tempQualifier = _mapManager.GetMapEntity(_mapId);
-                    component = IoCManager.Resolve<IEntityManager>().GetComponent<EntityLookupComponent>(tempQualifier.Uid);
+                    component = IoCManager.Resolve<IEntityManager>().GetComponent<EntityLookupComponent>(tempQualifier);
                     return true;
                 }
 
@@ -351,11 +351,11 @@ namespace Robust.Shared.GameObjects
 
             while (enumerator.MoveNext(out var lookup))
             {
-                var offsetBox = IoCManager.Resolve<IEntityManager>().GetComponent<TransformComponent>(lookup.Owner.Uid).InvWorldMatrix.TransformBox(box);
+                var offsetBox = IoCManager.Resolve<IEntityManager>().GetComponent<TransformComponent>(lookup.Owner).InvWorldMatrix.TransformBox(box);
 
                 lookup.Tree.QueryAabb(ref found, (ref bool found, in IEntity ent) =>
                 {
-                    if ((!IoCManager.Resolve<IEntityManager>().EntityExists(ent.Uid) ? EntityLifeStage.Deleted : IoCManager.Resolve<IEntityManager>().GetComponent<MetaDataComponent>(ent.Uid).EntityLifeStage) >= EntityLifeStage.Deleted) return true;
+                    if ((!IoCManager.Resolve<IEntityManager>().EntityExists(ent) ? EntityLifeStage.Deleted : IoCManager.Resolve<IEntityManager>().GetComponent<MetaDataComponent>(ent).EntityLifeStage) >= EntityLifeStage.Deleted) return true;
                     found = true;
                     return false;
 
@@ -380,7 +380,7 @@ namespace Robust.Shared.GameObjects
             var enumerator = GetLookupsIntersecting(mapId, worldAABB);
             while (enumerator.MoveNext(out var lookup))
             {
-                var offsetBox = IoCManager.Resolve<IEntityManager>().GetComponent<TransformComponent>(lookup.Owner.Uid).InvWorldMatrix.TransformBox(worldAABB);
+                var offsetBox = IoCManager.Resolve<IEntityManager>().GetComponent<TransformComponent>(lookup.Owner).InvWorldMatrix.TransformBox(worldAABB);
 
                 lookup.Tree._b2Tree.FastQuery(ref offsetBox, (ref IEntity data) => callback(data));
             }
@@ -414,11 +414,11 @@ namespace Robust.Shared.GameObjects
 
             while (enumerator.MoveNext(out var lookup))
             {
-                var offsetBox = IoCManager.Resolve<IEntityManager>().GetComponent<TransformComponent>(lookup.Owner.Uid).InvWorldMatrix.TransformBox(worldAABB);
+                var offsetBox = IoCManager.Resolve<IEntityManager>().GetComponent<TransformComponent>(lookup.Owner).InvWorldMatrix.TransformBox(worldAABB);
 
                 lookup.Tree.QueryAabb(ref list, (ref List<IEntity> list, in IEntity ent) =>
                 {
-                    if (!((!IoCManager.Resolve<IEntityManager>().EntityExists(ent.Uid) ? EntityLifeStage.Deleted : IoCManager.Resolve<IEntityManager>().GetComponent<MetaDataComponent>(ent.Uid).EntityLifeStage) >= EntityLifeStage.Deleted))
+                    if (!((!IoCManager.Resolve<IEntityManager>().EntityExists(ent) ? EntityLifeStage.Deleted : IoCManager.Resolve<IEntityManager>().GetComponent<MetaDataComponent>(ent).EntityLifeStage) >= EntityLifeStage.Deleted))
                     {
                         list.Add(ent);
                     }
@@ -445,11 +445,11 @@ namespace Robust.Shared.GameObjects
 
             while (enumerator.MoveNext(out var lookup))
             {
-                var offsetBox = IoCManager.Resolve<IEntityManager>().GetComponent<TransformComponent>(lookup.Owner.Uid).InvWorldMatrix.TransformBox(worldBounds);
+                var offsetBox = IoCManager.Resolve<IEntityManager>().GetComponent<TransformComponent>(lookup.Owner).InvWorldMatrix.TransformBox(worldBounds);
 
                 lookup.Tree.QueryAabb(ref list, (ref List<IEntity> list, in IEntity ent) =>
                 {
-                    if (!((!IoCManager.Resolve<IEntityManager>().EntityExists(ent.Uid) ? EntityLifeStage.Deleted : IoCManager.Resolve<IEntityManager>().GetComponent<MetaDataComponent>(ent.Uid).EntityLifeStage) >= EntityLifeStage.Deleted))
+                    if (!((!IoCManager.Resolve<IEntityManager>().EntityExists(ent) ? EntityLifeStage.Deleted : IoCManager.Resolve<IEntityManager>().GetComponent<MetaDataComponent>(ent).EntityLifeStage) >= EntityLifeStage.Deleted))
                     {
                         list.Add(ent);
                     }
@@ -478,7 +478,7 @@ namespace Robust.Shared.GameObjects
 
             while (enumerator.MoveNext(out var lookup))
             {
-                var localPoint = IoCManager.Resolve<IEntityManager>().GetComponent<TransformComponent>(lookup.Owner.Uid).InvWorldMatrix.Transform(position);
+                var localPoint = IoCManager.Resolve<IEntityManager>().GetComponent<TransformComponent>(lookup.Owner).InvWorldMatrix.Transform(position);
 
                 lookup.Tree.QueryPoint(ref state, (ref (List<IEntity> list, Vector2 position) state, in IEntity ent) =>
                 {
@@ -521,7 +521,7 @@ namespace Robust.Shared.GameObjects
         public IEnumerable<IEntity> GetEntitiesIntersecting(IEntity entity, float enlarged = 0f, LookupFlags flags = LookupFlags.IncludeAnchored)
         {
             var worldAABB = GetWorldAabbFromEntity(entity);
-            var xform = _entityManager.GetComponent<TransformComponent>(entity.Uid);
+            var xform = _entityManager.GetComponent<TransformComponent>(entity);
 
             var (worldPos, worldRot) = xform.GetWorldPositionRotation();
 
@@ -531,11 +531,11 @@ namespace Robust.Shared.GameObjects
             while (enumerator.MoveNext(out var lookup))
             {
                 // To get the tightest bounds possible we'll re-calculate it for each lookup.
-                var localBounds = GetLookupBounds(entity.Uid, lookup, worldPos, worldRot, enlarged);
+                var localBounds = GetLookupBounds(entity, lookup, worldPos, worldRot, enlarged);
 
                 lookup.Tree.QueryAabb(ref list, (ref List<IEntity> list, in IEntity ent) =>
                 {
-                    if (!((!IoCManager.Resolve<IEntityManager>().EntityExists(ent.Uid) ? EntityLifeStage.Deleted : IoCManager.Resolve<IEntityManager>().GetComponent<MetaDataComponent>(ent.Uid).EntityLifeStage) >= EntityLifeStage.Deleted))
+                    if (!((!IoCManager.Resolve<IEntityManager>().EntityExists(ent) ? EntityLifeStage.Deleted : IoCManager.Resolve<IEntityManager>().GetComponent<MetaDataComponent>(ent).EntityLifeStage) >= EntityLifeStage.Deleted))
                     {
                         list.Add(ent);
                     }
@@ -553,8 +553,8 @@ namespace Robust.Shared.GameObjects
 
         private Box2 GetLookupBounds(EntityUid uid, EntityLookupComponent lookup, Vector2 worldPos, Angle worldRot, float enlarged)
         {
-            var localPos = IoCManager.Resolve<IEntityManager>().GetComponent<TransformComponent>(lookup.Owner.Uid).InvWorldMatrix.Transform(worldPos);
-            var localRot = worldRot - IoCManager.Resolve<IEntityManager>().GetComponent<TransformComponent>(lookup.Owner.Uid).WorldRotation;
+            var localPos = IoCManager.Resolve<IEntityManager>().GetComponent<TransformComponent>(lookup.Owner).InvWorldMatrix.Transform(worldPos);
+            var localRot = worldRot - IoCManager.Resolve<IEntityManager>().GetComponent<TransformComponent>(lookup.Owner).WorldRotation;
 
             if (_entityManager.TryGetComponent(uid, out PhysicsComponent? body))
             {
@@ -583,20 +583,20 @@ namespace Robust.Shared.GameObjects
         /// <inheritdoc />
         public bool IsIntersecting(IEntity entityOne, IEntity entityTwo)
         {
-            var position = IoCManager.Resolve<IEntityManager>().GetComponent<TransformComponent>(entityOne.Uid).MapPosition.Position;
+            var position = IoCManager.Resolve<IEntityManager>().GetComponent<TransformComponent>(entityOne).MapPosition.Position;
             return Intersecting(entityTwo, position);
         }
 
         private bool Intersecting(IEntity entity, Vector2 mapPosition)
         {
-            if (IoCManager.Resolve<IEntityManager>().TryGetComponent(entity.Uid, out IPhysBody? component))
+            if (IoCManager.Resolve<IEntityManager>().TryGetComponent(entity, out IPhysBody? component))
             {
                 if (component.GetWorldAABB().Contains(mapPosition))
                     return true;
             }
             else
             {
-                var transform = IoCManager.Resolve<IEntityManager>().GetComponent<TransformComponent>(entity.Uid);
+                var transform = IoCManager.Resolve<IEntityManager>().GetComponent<TransformComponent>(entity);
                 var entPos = transform.WorldPosition;
                 if (MathHelper.CloseToPercent(entPos.X, mapPosition.X)
                     && MathHelper.CloseToPercent(entPos.Y, mapPosition.Y))
@@ -637,7 +637,7 @@ namespace Robust.Shared.GameObjects
         public IEnumerable<IEntity> GetEntitiesInRange(IEntity entity, float range, LookupFlags flags = LookupFlags.IncludeAnchored)
         {
             var worldAABB = GetWorldAabbFromEntity(entity);
-            return GetEntitiesInRange(IoCManager.Resolve<IEntityManager>().GetComponent<TransformComponent>(entity.Uid).MapID, worldAABB, range, flags);
+            return GetEntitiesInRange(IoCManager.Resolve<IEntityManager>().GetComponent<TransformComponent>(entity).MapID, worldAABB, range, flags);
         }
 
         /// <inheritdoc />
@@ -648,7 +648,7 @@ namespace Robust.Shared.GameObjects
 
             foreach (var entity in GetEntitiesInRange(coordinates, range * 2, flags))
             {
-                var angle = new Angle(IoCManager.Resolve<IEntityManager>().GetComponent<TransformComponent>(entity.Uid).WorldPosition - position);
+                var angle = new Angle(IoCManager.Resolve<IEntityManager>().GetComponent<TransformComponent>(entity).WorldPosition - position);
                 if (angle.Degrees < direction.Degrees + arcWidth / 2 &&
                     angle.Degrees > direction.Degrees - arcWidth / 2)
                     yield return entity;
@@ -662,11 +662,11 @@ namespace Robust.Shared.GameObjects
 
             foreach (EntityLookupComponent comp in _entityManager.EntityQuery<EntityLookupComponent>(true))
             {
-                if (IoCManager.Resolve<IEntityManager>().GetComponent<TransformComponent>(comp.Owner.Uid).MapID != mapId) continue;
+                if (IoCManager.Resolve<IEntityManager>().GetComponent<TransformComponent>(comp.Owner).MapID != mapId) continue;
 
                 foreach (var entity in comp.Tree)
                 {
-                    if ((!IoCManager.Resolve<IEntityManager>().EntityExists(entity.Uid) ? EntityLifeStage.Deleted : IoCManager.Resolve<IEntityManager>().GetComponent<MetaDataComponent>(entity.Uid).EntityLifeStage) >= EntityLifeStage.Deleted) continue;
+                    if ((!IoCManager.Resolve<IEntityManager>().EntityExists(entity) ? EntityLifeStage.Deleted : IoCManager.Resolve<IEntityManager>().GetComponent<MetaDataComponent>(entity).EntityLifeStage) >= EntityLifeStage.Deleted) continue;
 
                     yield return entity;
                 }
@@ -701,7 +701,7 @@ namespace Robust.Shared.GameObjects
 
             while (enumerator.MoveNext(out var lookup))
             {
-                var offsetPos = IoCManager.Resolve<IEntityManager>().GetComponent<TransformComponent>(lookup.Owner.Uid).InvWorldMatrix.Transform(position);
+                var offsetPos = IoCManager.Resolve<IEntityManager>().GetComponent<TransformComponent>(lookup.Owner).InvWorldMatrix.Transform(position);
 
                 lookup.Tree.QueryPoint(ref state, (ref (List<IEntity> list, Vector2 position) state, in IEntity ent) =>
                 {
@@ -731,26 +731,26 @@ namespace Robust.Shared.GameObjects
 
         private static EntityLookupComponent? GetLookup(IEntity entity)
         {
-            if (IoCManager.Resolve<IEntityManager>().GetComponent<TransformComponent>(entity.Uid).MapID == MapId.Nullspace)
+            if (IoCManager.Resolve<IEntityManager>().GetComponent<TransformComponent>(entity).MapID == MapId.Nullspace)
             {
                 return null;
             }
 
             // if it's map return null. Grids should return the map's broadphase.
-            if (IoCManager.Resolve<IEntityManager>().HasComponent<EntityLookupComponent>(entity.Uid) &&
-                IoCManager.Resolve<IEntityManager>().GetComponent<TransformComponent>(entity.Uid).Parent == null)
+            if (IoCManager.Resolve<IEntityManager>().HasComponent<EntityLookupComponent>(entity) &&
+                IoCManager.Resolve<IEntityManager>().GetComponent<TransformComponent>(entity).Parent == null)
             {
                 return null;
             }
 
-            var parent = IoCManager.Resolve<IEntityManager>().GetComponent<TransformComponent>(entity.Uid).Parent?.Owner;
+            var parent = IoCManager.Resolve<IEntityManager>().GetComponent<TransformComponent>(entity).Parent?.Owner;
 
             while (true)
             {
                 if (parent == null) break;
 
-                if (IoCManager.Resolve<IEntityManager>().TryGetComponent(parent.Uid, out EntityLookupComponent? comp)) return comp;
-                parent = IoCManager.Resolve<IEntityManager>().GetComponent<TransformComponent>(parent.Uid).Parent?.Owner;
+                if (IoCManager.Resolve<IEntityManager>().TryGetComponent(parent, out EntityLookupComponent? comp)) return comp;
+                parent = IoCManager.Resolve<IEntityManager>().GetComponent<TransformComponent>(parent).Parent?.Owner;
             }
 
             return null;
@@ -761,14 +761,14 @@ namespace Robust.Shared.GameObjects
         {
             // look there's JANK everywhere but I'm just bandaiding it for now for shuttles and we'll fix it later when
             // PVS is more stable and entity anchoring has been battle-tested.
-            if ((!IoCManager.Resolve<IEntityManager>().EntityExists(entity.Uid) ? EntityLifeStage.Deleted : IoCManager.Resolve<IEntityManager>().GetComponent<MetaDataComponent>(entity.Uid).EntityLifeStage) >= EntityLifeStage.Deleted)
+            if ((!IoCManager.Resolve<IEntityManager>().EntityExists(entity) ? EntityLifeStage.Deleted : IoCManager.Resolve<IEntityManager>().GetComponent<MetaDataComponent>(entity).EntityLifeStage) >= EntityLifeStage.Deleted)
             {
                 RemoveFromEntityTrees(entity);
                 return true;
             }
 
-            DebugTools.Assert((!IoCManager.Resolve<IEntityManager>().EntityExists(entity.Uid) ? EntityLifeStage.Deleted : IoCManager.Resolve<IEntityManager>().GetComponent<MetaDataComponent>(entity.Uid).EntityLifeStage) >= EntityLifeStage.Initialized);
-            DebugTools.Assert(!IoCManager.Resolve<IEntityManager>().GetComponent<TransformComponent>(entity.Uid).Anchored);
+            DebugTools.Assert((!IoCManager.Resolve<IEntityManager>().EntityExists(entity) ? EntityLifeStage.Deleted : IoCManager.Resolve<IEntityManager>().GetComponent<MetaDataComponent>(entity).EntityLifeStage) >= EntityLifeStage.Initialized);
+            DebugTools.Assert(!IoCManager.Resolve<IEntityManager>().GetComponent<TransformComponent>(entity).Anchored);
 
             var lookup = GetLookup(entity);
 
@@ -788,10 +788,10 @@ namespace Robust.Shared.GameObjects
                 return true;
             }
 
-            var transform = IoCManager.Resolve<IEntityManager>().GetComponent<TransformComponent>(entity.Uid);
+            var transform = IoCManager.Resolve<IEntityManager>().GetComponent<TransformComponent>(entity);
             DebugTools.Assert(transform.Initialized);
 
-            var aabb = IoCManager.Resolve<IEntityManager>().GetComponent<TransformComponent>(lookup.Owner.Uid).InvWorldMatrix.TransformBox(worldAABB.Value);
+            var aabb = IoCManager.Resolve<IEntityManager>().GetComponent<TransformComponent>(lookup.Owner).InvWorldMatrix.TransformBox(worldAABB.Value);
 
             // for debugging
             var necessary = 0;
@@ -801,9 +801,9 @@ namespace Robust.Shared.GameObjects
                 ++necessary;
             }
 
-            if (!IoCManager.Resolve<IEntityManager>().HasComponent<EntityLookupComponent>(entity.Uid))
+            if (!IoCManager.Resolve<IEntityManager>().HasComponent<EntityLookupComponent>(entity))
             {
-                foreach (var childTx in IoCManager.Resolve<IEntityManager>().GetComponent<TransformComponent>(entity.Uid).ChildEntityUids)
+                foreach (var childTx in IoCManager.Resolve<IEntityManager>().GetComponent<TransformComponent>(entity).ChildEntityUids)
                 {
                     if (!_handledThisTick.Add(childTx)) continue;
 
@@ -838,9 +838,9 @@ namespace Robust.Shared.GameObjects
         {
             Vector2 pos;
 
-            if ((!IoCManager.Resolve<IEntityManager>().EntityExists(ent.Uid) ? EntityLifeStage.Deleted : IoCManager.Resolve<IEntityManager>().GetComponent<MetaDataComponent>(ent.Uid).EntityLifeStage) >= EntityLifeStage.Deleted)
+            if ((!IoCManager.Resolve<IEntityManager>().EntityExists(ent) ? EntityLifeStage.Deleted : IoCManager.Resolve<IEntityManager>().GetComponent<MetaDataComponent>(ent).EntityLifeStage) >= EntityLifeStage.Deleted)
             {
-                pos = IoCManager.Resolve<IEntityManager>().GetComponent<TransformComponent>(ent.Uid).WorldPosition;
+                pos = IoCManager.Resolve<IEntityManager>().GetComponent<TransformComponent>(ent).WorldPosition;
                 return new Box2(pos, pos);
             }
 
@@ -849,9 +849,9 @@ namespace Robust.Shared.GameObjects
                 return GetWorldAABB(manager.Owner);
             }
 
-            pos = IoCManager.Resolve<IEntityManager>().GetComponent<TransformComponent>(ent.Uid).WorldPosition;
+            pos = IoCManager.Resolve<IEntityManager>().GetComponent<TransformComponent>(ent).WorldPosition;
 
-            return IoCManager.Resolve<IEntityManager>().TryGetComponent(ent.Uid, out ILookupWorldBox2Component? lookup) ?
+            return IoCManager.Resolve<IEntityManager>().TryGetComponent(ent, out ILookupWorldBox2Component? lookup) ?
                 lookup.GetWorldAABB(pos) :
                 new Box2(pos, pos);
         }

Robust.Shared/GameObjects/Systems/OccluderSystem.cs

@@ -39,11 +39,11 @@ namespace Robust.Shared.GameObjects
             foreach (var grid in _mapManager.FindGridsIntersecting(mapId, worldAABB))
             {
                 IEntity tempQualifier = EntityManager.GetEntity(grid.GridEntityId);
-                yield return IoCManager.Resolve<IEntityManager>().GetComponent<OccluderTreeComponent>(tempQualifier.Uid);
+                yield return IoCManager.Resolve<IEntityManager>().GetComponent<OccluderTreeComponent>(tempQualifier);
             }
 
             IEntity tempQualifier1 = _mapManager.GetMapEntity(mapId);
-            yield return IoCManager.Resolve<IEntityManager>().GetComponent<OccluderTreeComponent>(tempQualifier1.Uid);
+            yield return IoCManager.Resolve<IEntityManager>().GetComponent<OccluderTreeComponent>(tempQualifier1);
         }
 
         private void HandleOccluderInit(EntityUid uid, OccluderComponent component, ComponentInit args)
@@ -60,7 +60,7 @@ namespace Robust.Shared.GameObjects
 
         private void HandleOccluderTreeInit(EntityUid uid, OccluderTreeComponent component, ComponentInit args)
         {
-            var capacity = (int) Math.Min(256, Math.Ceiling(IoCManager.Resolve<IEntityManager>().GetComponent<TransformComponent>(component.Owner.Uid).ChildCount / TreeGrowthRate) * TreeGrowthRate);
+            var capacity = (int) Math.Min(256, Math.Ceiling(IoCManager.Resolve<IEntityManager>().GetComponent<TransformComponent>(component.Owner).ChildCount / TreeGrowthRate) * TreeGrowthRate);
 
             component.Tree = new DynamicTree<OccluderComponent>(ExtractAabbFunc, capacity: capacity);
         }
@@ -74,16 +74,16 @@ namespace Robust.Shared.GameObjects
         {
             var entity = component.Owner;
 
-            if ((!IoCManager.Resolve<IEntityManager>().EntityExists(entity.Uid) ? EntityLifeStage.Deleted : IoCManager.Resolve<IEntityManager>().GetComponent<MetaDataComponent>(entity.Uid).EntityLifeStage) >= EntityLifeStage.Deleted || IoCManager.Resolve<IEntityManager>().GetComponent<TransformComponent>(entity.Uid).MapID == MapId.Nullspace) return null;
+            if ((!IoCManager.Resolve<IEntityManager>().EntityExists(entity) ? EntityLifeStage.Deleted : IoCManager.Resolve<IEntityManager>().GetComponent<MetaDataComponent>(entity).EntityLifeStage) >= EntityLifeStage.Deleted || IoCManager.Resolve<IEntityManager>().GetComponent<TransformComponent>(entity).MapID == MapId.Nullspace) return null;
 
-            var parent = IoCManager.Resolve<IEntityManager>().GetComponent<TransformComponent>(entity.Uid).Parent?.Owner;
+            var parent = IoCManager.Resolve<IEntityManager>().GetComponent<TransformComponent>(entity).Parent?.Owner;
 
             while (true)
             {
                 if (parent == null) break;
 
-                if (IoCManager.Resolve<IEntityManager>().TryGetComponent(parent.Uid, out OccluderTreeComponent? comp)) return comp;
-                parent = IoCManager.Resolve<IEntityManager>().GetComponent<TransformComponent>(parent.Uid).Parent?.Owner;
+                if (IoCManager.Resolve<IEntityManager>().TryGetComponent(parent, out OccluderTreeComponent? comp)) return comp;
+                parent = IoCManager.Resolve<IEntityManager>().GetComponent<TransformComponent>(parent).Parent?.Owner;
             }
 
             return null;
@@ -165,7 +165,7 @@ namespace Robust.Shared.GameObjects
 
         private static Box2 ExtractAabbFunc(in OccluderComponent o)
         {
-            return o.BoundingBox.Translated(IoCManager.Resolve<IEntityManager>().GetComponent<TransformComponent>(o.Owner.Uid).LocalPosition);
+            return o.BoundingBox.Translated(IoCManager.Resolve<IEntityManager>().GetComponent<TransformComponent>(o.Owner).LocalPosition);
         }
 
         public IEnumerable<RayCastResults> IntersectRayWithPredicate(MapId mapId, in Ray ray, float maxLength,
@@ -179,7 +179,7 @@ namespace Robust.Shared.GameObjects
 
             foreach (var comp in GetOccluderTrees(mapId, worldBox))
             {
-                var transform = IoCManager.Resolve<IEntityManager>().GetComponent<TransformComponent>(comp.Owner.Uid);
+                var transform = IoCManager.Resolve<IEntityManager>().GetComponent<TransformComponent>(comp.Owner);
                 var matrix = transform.InvWorldMatrix;
                 var treeRot = transform.WorldRotation;
 

Robust.Shared/GameObjects/Systems/SharedGridFixtureSystem.cs

@@ -53,13 +53,13 @@ namespace Robust.Shared.GameObjects
 
             DebugTools.Assert(chunk.ValidTiles > 0);
 
-            if (!IoCManager.Resolve<IEntityManager>().TryGetComponent(gridEnt.Uid, out PhysicsComponent? physicsComponent))
+            if (!IoCManager.Resolve<IEntityManager>().TryGetComponent(gridEnt, out PhysicsComponent? physicsComponent))
             {
                 Logger.ErrorS("physics", $"Trying to regenerate collision for {gridEnt} that doesn't have {nameof(physicsComponent)}");
                 return;
             }
 
-            if (!IoCManager.Resolve<IEntityManager>().TryGetComponent(gridEnt.Uid, out FixturesComponent? fixturesComponent))
+            if (!IoCManager.Resolve<IEntityManager>().TryGetComponent(gridEnt, out FixturesComponent? fixturesComponent))
             {
                 Logger.ErrorS("physics", $"Trying to regenerate collision for {gridEnt} that doesn't have {nameof(fixturesComponent)}");
                 return;
@@ -156,7 +156,7 @@ namespace Robust.Shared.GameObjects
             if (updated)
             {
                 _fixtures.FixtureUpdate(fixturesComponent, physicsComponent);
-                EntityManager.EventBus.RaiseLocalEvent(gridEnt.Uid,new GridFixtureChangeEvent {NewFixtures = chunk.Fixtures});
+                EntityManager.EventBus.RaiseLocalEvent(gridEnt,new GridFixtureChangeEvent {NewFixtures = chunk.Fixtures});
             }
         }
     }

Robust.Shared/GameObjects/Systems/SharedGridTraversalSystem.cs

@@ -34,7 +34,7 @@ namespace Robust.Shared.GameObjects
         {
             while (_queuedEvents.TryPop(out var moveEvent))
             {
-                if (!_handledThisTick.Add(moveEvent.Sender.Uid)) continue;
+                if (!_handledThisTick.Add(moveEvent.Sender)) continue;
                 HandleMove(ref moveEvent);
             }
 
@@ -45,15 +45,15 @@ namespace Robust.Shared.GameObjects
         {
             var entity = moveEvent.Sender;
 
-            if ((!IoCManager.Resolve<IEntityManager>().EntityExists(entity.Uid) ? EntityLifeStage.Deleted : IoCManager.Resolve<IEntityManager>().GetComponent<MetaDataComponent>(entity.Uid).EntityLifeStage) >= EntityLifeStage.Deleted ||
-                IoCManager.Resolve<IEntityManager>().HasComponent<IMapComponent>(entity.Uid) ||
-                IoCManager.Resolve<IEntityManager>().HasComponent<IMapGridComponent>(entity.Uid) ||
+            if ((!IoCManager.Resolve<IEntityManager>().EntityExists(entity) ? EntityLifeStage.Deleted : IoCManager.Resolve<IEntityManager>().GetComponent<MetaDataComponent>(entity).EntityLifeStage) >= EntityLifeStage.Deleted ||
+                IoCManager.Resolve<IEntityManager>().HasComponent<IMapComponent>(entity) ||
+                IoCManager.Resolve<IEntityManager>().HasComponent<IMapGridComponent>(entity) ||
                 entity.IsInContainer())
             {
                 return;
             }
 
-            var transform = IoCManager.Resolve<IEntityManager>().GetComponent<TransformComponent>(entity.Uid);
+            var transform = IoCManager.Resolve<IEntityManager>().GetComponent<TransformComponent>(entity);
 
             if (float.IsNaN(moveEvent.NewPosition.X) || float.IsNaN(moveEvent.NewPosition.Y))
             {
@@ -65,13 +65,13 @@ namespace Robust.Shared.GameObjects
             // Change parent if necessary
             if (_mapManager.TryFindGridAt(transform.MapID, mapPos, out var grid) &&
                 EntityManager.TryGetEntity(grid.GridEntityId, out var gridEnt) &&
-                grid.GridEntityId != entity.Uid)
+                grid.GridEntityId != entity)
             {
                 // Some minor duplication here with AttachParent but only happens when going on/off grid so not a big deal ATM.
                 if (grid.Index != transform.GridID)
                 {
                     transform.AttachParent(gridEnt);
-                    RaiseLocalEvent(entity.Uid, new ChangedGridEvent(entity, transform.GridID, grid.Index));
+                    RaiseLocalEvent(entity, new ChangedGridEvent(entity, transform.GridID, grid.Index));
                 }
             }
             else
@@ -82,7 +82,7 @@ namespace Robust.Shared.GameObjects
                 if (oldGridId != GridId.Invalid)
                 {
                     transform.AttachParent(_mapManager.GetMapEntity(transform.MapID));
-                    RaiseLocalEvent(entity.Uid, new ChangedGridEvent(entity, oldGridId, GridId.Invalid));
+                    RaiseLocalEvent(entity, new ChangedGridEvent(entity, oldGridId, GridId.Invalid));
                 }
             }
         }

Robust.Shared/GameObjects/Systems/SharedPhysicsSystem.Queries.cs

@@ -42,7 +42,7 @@ namespace Robust.Shared.GameObjects
 
             foreach (var broadphase in _broadphaseSystem.GetBroadphases(mapId, collider))
             {
-                var gridCollider = IoCManager.Resolve<IEntityManager>().GetComponent<TransformComponent>(broadphase.Owner.Uid).InvWorldMatrix.TransformBox(collider);
+                var gridCollider = IoCManager.Resolve<IEntityManager>().GetComponent<TransformComponent>(broadphase.Owner).InvWorldMatrix.TransformBox(collider);
 
                 broadphase.Tree.QueryAabb(ref state, (ref (Box2 collider, MapId map, bool found) state, in FixtureProxy proxy) =>
                 {
@@ -105,7 +105,7 @@ namespace Robust.Shared.GameObjects
 
             foreach (var broadphase in _broadphaseSystem.GetBroadphases(mapId, worldAABB))
             {
-                var gridAABB = IoCManager.Resolve<IEntityManager>().GetComponent<TransformComponent>(broadphase.Owner.Uid).InvWorldMatrix.TransformBox(worldAABB);
+                var gridAABB = IoCManager.Resolve<IEntityManager>().GetComponent<TransformComponent>(broadphase.Owner).InvWorldMatrix.TransformBox(worldAABB);
 
                 foreach (var proxy in broadphase.Tree.QueryAabb(gridAABB, false))
                 {
@@ -127,7 +127,7 @@ namespace Robust.Shared.GameObjects
 
             foreach (var broadphase in _broadphaseSystem.GetBroadphases(mapId, worldBounds.CalcBoundingBox()))
             {
-                var gridAABB = IoCManager.Resolve<IEntityManager>().GetComponent<TransformComponent>(broadphase.Owner.Uid).InvWorldMatrix.TransformBox(worldBounds);
+                var gridAABB = IoCManager.Resolve<IEntityManager>().GetComponent<TransformComponent>(broadphase.Owner).InvWorldMatrix.TransformBox(worldBounds);
 
                 foreach (var proxy in broadphase.Tree.QueryAabb(gridAABB, false))
                 {
@@ -151,7 +151,7 @@ namespace Robust.Shared.GameObjects
         public IEnumerable<PhysicsComponent> GetCollidingEntities(PhysicsComponent body, float enlarge = 0f)
         {
             // TODO: Should use the collisionmanager test for overlap instead (once I optimise and check it actually works).
-            var mapId = IoCManager.Resolve<IEntityManager>().GetComponent<TransformComponent>(body.Owner.Uid).MapID;
+            var mapId = IoCManager.Resolve<IEntityManager>().GetComponent<TransformComponent>(body.Owner).MapID;
 
             if (mapId == MapId.Nullspace || body.FixtureCount == 0) return Array.Empty<PhysicsComponent>();
 
@@ -161,7 +161,7 @@ namespace Robust.Shared.GameObjects
 
             foreach (var broadphase in _broadphaseSystem.GetBroadphases(mapId, worldAABB))
             {
-                var (_, broadRot, broadInvMatrix) = IoCManager.Resolve<IEntityManager>().GetComponent<TransformComponent>(broadphase.Owner.Uid).GetWorldPositionRotationInvMatrix();
+                var (_, broadRot, broadInvMatrix) = IoCManager.Resolve<IEntityManager>().GetComponent<TransformComponent>(broadphase.Owner).GetWorldPositionRotationInvMatrix();
 
                 var localTransform = new Transform(broadInvMatrix.Transform(transform.Position), transform.Quaternion2D.Angle - broadRot);
 
@@ -225,11 +225,11 @@ namespace Robust.Shared.GameObjects
 
             foreach (var broadphase in _broadphaseSystem.GetBroadphases(mapId, rayBox))
             {
-                var invMatrix = IoCManager.Resolve<IEntityManager>().GetComponent<TransformComponent>(broadphase.Owner.Uid).InvWorldMatrix;
-                var matrix = IoCManager.Resolve<IEntityManager>().GetComponent<TransformComponent>(broadphase.Owner.Uid).WorldMatrix;
+                var invMatrix = IoCManager.Resolve<IEntityManager>().GetComponent<TransformComponent>(broadphase.Owner).InvWorldMatrix;
+                var matrix = IoCManager.Resolve<IEntityManager>().GetComponent<TransformComponent>(broadphase.Owner).WorldMatrix;
 
                 var position = invMatrix.Transform(ray.Position);
-                var gridRot = new Angle(-IoCManager.Resolve<IEntityManager>().GetComponent<TransformComponent>(broadphase.Owner.Uid).WorldRotation.Theta);
+                var gridRot = new Angle(-IoCManager.Resolve<IEntityManager>().GetComponent<TransformComponent>(broadphase.Owner).WorldRotation.Theta);
                 var direction = gridRot.RotateVec(ray.Direction);
 
                 var gridRay = new CollisionRay(position, direction, ray.CollisionMask);
@@ -307,8 +307,8 @@ namespace Robust.Shared.GameObjects
 
             foreach (var broadphase in _broadphaseSystem.GetBroadphases(mapId, rayBox))
             {
-                var offset = IoCManager.Resolve<IEntityManager>().GetComponent<TransformComponent>(broadphase.Owner.Uid).InvWorldMatrix.Transform(ray.Position);
-                var gridRot = new Angle(-IoCManager.Resolve<IEntityManager>().GetComponent<TransformComponent>(broadphase.Owner.Uid).WorldRotation.Theta);
+                var offset = IoCManager.Resolve<IEntityManager>().GetComponent<TransformComponent>(broadphase.Owner).InvWorldMatrix.Transform(ray.Position);
+                var gridRot = new Angle(-IoCManager.Resolve<IEntityManager>().GetComponent<TransformComponent>(broadphase.Owner).WorldRotation.Theta);
                 var direction = gridRot.RotateVec(ray.Direction);
 
                 var gridRay = new CollisionRay(offset, direction, ray.CollisionMask);

Robust.Shared/GameObjects/Systems/SharedPhysicsSystem.cs

@@ -142,15 +142,15 @@ namespace Robust.Shared.GameObjects
         {
             var entity = args.Entity;
 
-            if (!((!IoCManager.Resolve<IEntityManager>().EntityExists(entity.Uid) ? EntityLifeStage.Deleted : IoCManager.Resolve<IEntityManager>().GetComponent<MetaDataComponent>(entity.Uid).EntityLifeStage) >= EntityLifeStage.Initialized) ||
-                !IoCManager.Resolve<IEntityManager>().TryGetComponent(entity.Uid, out PhysicsComponent? body) ||
+            if (!((!IoCManager.Resolve<IEntityManager>().EntityExists(entity) ? EntityLifeStage.Deleted : IoCManager.Resolve<IEntityManager>().GetComponent<MetaDataComponent>(entity).EntityLifeStage) >= EntityLifeStage.Initialized) ||
+                !IoCManager.Resolve<IEntityManager>().TryGetComponent(entity, out PhysicsComponent? body) ||
                 entity.IsInContainer()) return;
 
             var oldParent = args.OldParent;
             var linearVelocityDiff = Vector2.Zero;
             var angularVelocityDiff = 0f;
 
-            if (oldParent != null && IoCManager.Resolve<IEntityManager>().TryGetComponent(oldParent.Uid, out PhysicsComponent? oldBody))
+            if (oldParent != null && IoCManager.Resolve<IEntityManager>().TryGetComponent(oldParent, out PhysicsComponent? oldBody))
             {
                 var (linear, angular) = oldBody.MapVelocities;
 
@@ -158,9 +158,9 @@ namespace Robust.Shared.GameObjects
                 angularVelocityDiff += angular;
             }
 
-            var newParent = IoCManager.Resolve<IEntityManager>().GetComponent<TransformComponent>(entity.Uid).Parent?.Owner;
+            var newParent = IoCManager.Resolve<IEntityManager>().GetComponent<TransformComponent>(entity).Parent?.Owner;
 
-            if (newParent != null && IoCManager.Resolve<IEntityManager>().TryGetComponent(newParent.Uid, out PhysicsComponent? newBody))
+            if (newParent != null && IoCManager.Resolve<IEntityManager>().TryGetComponent(newParent, out PhysicsComponent? newBody))
             {
                 var (linear, angular) = newBody.MapVelocities;
 
@@ -234,7 +234,7 @@ namespace Robust.Shared.GameObjects
 
         private void HandleMapChange(EntMapIdChangedMessage message)
         {
-            if (!IoCManager.Resolve<IEntityManager>().TryGetComponent(message.Entity.Uid, out PhysicsComponent? physicsComponent))
+            if (!IoCManager.Resolve<IEntityManager>().TryGetComponent(message.Entity, out PhysicsComponent? physicsComponent))
                 return;
 
             Get<SharedJointSystem>().ClearJoints(physicsComponent);
@@ -242,20 +242,20 @@ namespace Robust.Shared.GameObjects
             if (oldMapId != MapId.Nullspace)
             {
                 IEntity tempQualifier = MapManager.GetMapEntity(oldMapId);
-                IoCManager.Resolve<IEntityManager>().GetComponent<SharedPhysicsMapComponent>(tempQualifier.Uid).RemoveBody(physicsComponent);
+                IoCManager.Resolve<IEntityManager>().GetComponent<SharedPhysicsMapComponent>(tempQualifier).RemoveBody(physicsComponent);
             }
 
-            var newMapId = IoCManager.Resolve<IEntityManager>().GetComponent<TransformComponent>(message.Entity.Uid).MapID;
+            var newMapId = IoCManager.Resolve<IEntityManager>().GetComponent<TransformComponent>(message.Entity).MapID;
             if (newMapId != MapId.Nullspace)
             {
                 IEntity tempQualifier = MapManager.GetMapEntity(newMapId);
-                IoCManager.Resolve<IEntityManager>().GetComponent<SharedPhysicsMapComponent>(tempQualifier.Uid).AddBody(physicsComponent);
+                IoCManager.Resolve<IEntityManager>().GetComponent<SharedPhysicsMapComponent>(tempQualifier).AddBody(physicsComponent);
             }
         }
 
         private void HandlePhysicsUpdateMessage(PhysicsUpdateMessage message)
         {
-            var mapId = IoCManager.Resolve<IEntityManager>().GetComponent<TransformComponent>(message.Component.Owner.Uid).MapID;
+            var mapId = IoCManager.Resolve<IEntityManager>().GetComponent<TransformComponent>(message.Component.Owner).MapID;
 
             if (mapId == MapId.Nullspace)
                 return;
@@ -263,42 +263,42 @@ namespace Robust.Shared.GameObjects
             if (message.Component.Deleted || !message.Component.CanCollide)
             {
                 IEntity tempQualifier = MapManager.GetMapEntity(mapId);
-                IoCManager.Resolve<IEntityManager>().GetComponent<SharedPhysicsMapComponent>(tempQualifier.Uid).RemoveBody(message.Component);
+                IoCManager.Resolve<IEntityManager>().GetComponent<SharedPhysicsMapComponent>(tempQualifier).RemoveBody(message.Component);
             }
             else
             {
                 IEntity tempQualifier = MapManager.GetMapEntity(mapId);
-                IoCManager.Resolve<IEntityManager>().GetComponent<SharedPhysicsMapComponent>(tempQualifier.Uid).AddBody(message.Component);
+                IoCManager.Resolve<IEntityManager>().GetComponent<SharedPhysicsMapComponent>(tempQualifier).AddBody(message.Component);
             }
         }
 
         private void HandleWakeMessage(PhysicsWakeMessage message)
         {
-            var mapId = IoCManager.Resolve<IEntityManager>().GetComponent<TransformComponent>(message.Body.Owner.Uid).MapID;
+            var mapId = IoCManager.Resolve<IEntityManager>().GetComponent<TransformComponent>(message.Body.Owner).MapID;
 
             if (mapId == MapId.Nullspace)
                 return;
 
             IEntity tempQualifier = MapManager.GetMapEntity(mapId);
-            IoCManager.Resolve<IEntityManager>().GetComponent<SharedPhysicsMapComponent>(tempQualifier.Uid).AddAwakeBody(message.Body);
+            IoCManager.Resolve<IEntityManager>().GetComponent<SharedPhysicsMapComponent>(tempQualifier).AddAwakeBody(message.Body);
         }
 
         private void HandleSleepMessage(PhysicsSleepMessage message)
         {
-            var mapId = IoCManager.Resolve<IEntityManager>().GetComponent<TransformComponent>(message.Body.Owner.Uid).MapID;
+            var mapId = IoCManager.Resolve<IEntityManager>().GetComponent<TransformComponent>(message.Body.Owner).MapID;
 
             if (mapId == MapId.Nullspace)
                 return;
 
             IEntity tempQualifier = MapManager.GetMapEntity(mapId);
-            IoCManager.Resolve<IEntityManager>().GetComponent<SharedPhysicsMapComponent>(tempQualifier.Uid).RemoveSleepBody(message.Body);
+            IoCManager.Resolve<IEntityManager>().GetComponent<SharedPhysicsMapComponent>(tempQualifier).RemoveSleepBody(message.Body);
         }
 
         private void HandleContainerInserted(EntInsertedIntoContainerMessage message)
         {
-            if (!IoCManager.Resolve<IEntityManager>().TryGetComponent(message.Entity.Uid, out PhysicsComponent? physicsComponent)) return;
+            if (!IoCManager.Resolve<IEntityManager>().TryGetComponent(message.Entity, out PhysicsComponent? physicsComponent)) return;
 
-            var mapId = IoCManager.Resolve<IEntityManager>().GetComponent<TransformComponent>(message.Container.Owner.Uid).MapID;
+            var mapId = IoCManager.Resolve<IEntityManager>().GetComponent<TransformComponent>(message.Container.Owner).MapID;
 
             physicsComponent.LinearVelocity = Vector2.Zero;
             physicsComponent.AngularVelocity = 0.0f;
@@ -307,20 +307,20 @@ namespace Robust.Shared.GameObjects
             if (mapId != MapId.Nullspace)
             {
                 IEntity tempQualifier = MapManager.GetMapEntity(mapId);
-                IoCManager.Resolve<IEntityManager>().GetComponent<SharedPhysicsMapComponent>(tempQualifier.Uid).RemoveBody(physicsComponent);
+                IoCManager.Resolve<IEntityManager>().GetComponent<SharedPhysicsMapComponent>(tempQualifier).RemoveBody(physicsComponent);
             }
         }
 
         private void HandleContainerRemoved(EntRemovedFromContainerMessage message)
         {
-            if (!IoCManager.Resolve<IEntityManager>().TryGetComponent(message.Entity.Uid, out PhysicsComponent? physicsComponent)) return;
+            if (!IoCManager.Resolve<IEntityManager>().TryGetComponent(message.Entity, out PhysicsComponent? physicsComponent)) return;
 
-            var mapId = IoCManager.Resolve<IEntityManager>().GetComponent<TransformComponent>(message.Container.Owner.Uid).MapID;
+            var mapId = IoCManager.Resolve<IEntityManager>().GetComponent<TransformComponent>(message.Container.Owner).MapID;
 
             if (mapId != MapId.Nullspace)
             {
                 IEntity tempQualifier = MapManager.GetMapEntity(mapId);
-                IoCManager.Resolve<IEntityManager>().GetComponent<SharedPhysicsMapComponent>(tempQualifier.Uid).AddBody(physicsComponent);
+                IoCManager.Resolve<IEntityManager>().GetComponent<SharedPhysicsMapComponent>(tempQualifier).AddBody(physicsComponent);
             }
         }
 

Robust.Shared/GameObjects/Systems/SharedTransformSystem.cs

@@ -66,7 +66,7 @@ namespace Robust.Shared.GameObjects
 
         public void DeferMoveEvent(ref MoveEvent moveEvent)
         {
-            if (IoCManager.Resolve<IEntityManager>().HasComponent<IMapGridComponent>(moveEvent.Sender.Uid))
+            if (IoCManager.Resolve<IEntityManager>().HasComponent<IMapGridComponent>(moveEvent.Sender))
                 _gridMoves.Enqueue(moveEvent);
             else
                 _otherMoves.Enqueue(moveEvent);
@@ -84,7 +84,7 @@ namespace Robust.Shared.GameObjects
             {
                 while (queue.TryDequeue(out var ev))
                 {
-                    if ((!IoCManager.Resolve<IEntityManager>().EntityExists(ev.Sender.Uid) ? EntityLifeStage.Deleted : IoCManager.Resolve<IEntityManager>().GetComponent<MetaDataComponent>(ev.Sender.Uid).EntityLifeStage) >= EntityLifeStage.Deleted)
+                    if ((!IoCManager.Resolve<IEntityManager>().EntityExists(ev.Sender) ? EntityLifeStage.Deleted : IoCManager.Resolve<IEntityManager>().GetComponent<MetaDataComponent>(ev.Sender).EntityLifeStage) >= EntityLifeStage.Deleted)
                         continue;
 
                     // Hopefully we can remove this when PVS gets updated to not use NaNs
@@ -93,7 +93,7 @@ namespace Robust.Shared.GameObjects
                         continue;
                     }
 
-                    RaiseLocalEvent(ev.Sender.Uid, ref ev);
+                    RaiseLocalEvent(ev.Sender, ref ev);
                 }
             }
         }

Robust.Shared/GameObjects/Systems/TimerSystem.cs

@@ -18,9 +18,9 @@ namespace Robust.Shared.GameObjects
 
             foreach (var timer in timers)
             {
-                if (!timer.Deleted && !((!IoCManager.Resolve<IEntityManager>().EntityExists(timer.Owner.Uid) ? EntityLifeStage.Deleted : IoCManager.Resolve<IEntityManager>().GetComponent<MetaDataComponent>(timer.Owner.Uid).EntityLifeStage) >= EntityLifeStage.Deleted) && timer.RemoveOnEmpty && timer.TimerCount == 0)
+                if (!timer.Deleted && !((!IoCManager.Resolve<IEntityManager>().EntityExists(timer.Owner) ? EntityLifeStage.Deleted : IoCManager.Resolve<IEntityManager>().GetComponent<MetaDataComponent>(timer.Owner).EntityLifeStage) >= EntityLifeStage.Deleted) && timer.RemoveOnEmpty && timer.TimerCount == 0)
                 {
-                    EntityManager.RemoveComponent<TimerComponent>(timer.Owner.Uid);
+                    EntityManager.RemoveComponent<TimerComponent>(timer.Owner);
                 }
             }
         }

Robust.Shared/Localization/LocFunction.cs

@@ -175,7 +175,7 @@ namespace Robust.Shared.Localization
     {
         public override string Format(LocContext ctx)
         {
-            return IoCManager.Resolve<IEntityManager>().GetComponent<MetaDataComponent>(Value.Uid).EntityName;
+            return IoCManager.Resolve<IEntityManager>().GetComponent<MetaDataComponent>(Value).EntityName;
         }
     }