Raycast has an overload for predicates, various fixes (#848)

Content.Client/State/GameScreenBase.cs

@@ -60,7 +60,7 @@ namespace Content.Client.State
                 var playerPos = _playerManager.LocalPlayer.ControlledEntity.Transform.MapPosition;
                 var entityPos = entityToClick.Transform.WorldPosition;
                 inRange = _entitySystemManager.GetEntitySystem<SharedInteractionSystem>()
-                    .InRangeUnobstructed(playerPos,entityPos,ignoredEnt: _playerManager.LocalPlayer.ControlledEntity);
+                    .InRangeUnobstructed(playerPos, entityPos, predicate:entity => entity != _playerManager.LocalPlayer.ControlledEntity || entity != entityToClick);
             }
 
             InteractionOutlineComponent outline;

Content.Shared/GameObjects/EntitySystems/ExamineSystemShared.cs

@@ -1,13 +1,15 @@
+using Content.Server.GameObjects.EntitySystems;
 using Content.Shared.GameObjects.Components.Mobs;
 using JetBrains.Annotations;
 using Robust.Shared.GameObjects.Systems;
 using Robust.Shared.Interfaces.GameObjects;
+using Robust.Shared.IoC;
 
 namespace Content.Shared.GameObjects.EntitySystems
 {
     public abstract class ExamineSystemShared : EntitySystem
     {
-        public const float ExamineRange = 8f;
+        public const float ExamineRange = 16f;
         public const float ExamineRangeSquared = ExamineRange * ExamineRange;
 
         [Pure]
@@ -28,8 +30,10 @@ namespace Content.Shared.GameObjects.EntitySystems
                 return false;
             }
 
-            var delta = examined.Transform.WorldPosition - examiner.Transform.WorldPosition;
+            return IoCManager.Resolve<IEntitySystemManager>()
-            return delta.LengthSquared <= ExamineRangeSquared;
+                .GetEntitySystem<SharedInteractionSystem>()
+                .InRangeUnobstructed(examiner.Transform.MapPosition, examined.Transform.MapPosition.Position,
+                    ExamineRange, predicate: entity => entity == examiner || entity == examined, insideBlockerValid:true);
         }
     }
 }

Content.Shared/GameObjects/EntitySystems/SharedInteractionSystem.cs

@@ -1,4 +1,5 @@
-using Content.Shared.Physics;
+using System;
+using Content.Shared.Physics;
 using JetBrains.Annotations;
 using Robust.Shared.GameObjects.Systems;
 using Robust.Shared.Interfaces.GameObjects;
@@ -34,12 +35,12 @@ namespace Content.Server.GameObjects.EntitySystems
         /// <param name="otherCoords">Other set of coordinates to use.</param>
         /// <param name="range">maximum distance between the two sets of coordinates.</param>
         /// <param name="collisionMask">the mask to check for collisions</param>
-        /// <param name="ignoredEnt">the entity to be ignored when checking for collisions.</param>
+        /// <param name="predicate">.</param>
         /// <param name="mapManager">Map manager containing the two GridIds.</param>
         /// <param name="insideBlockerValid">if coordinates inside obstructions count as obstructed or not</param>
         /// <returns>True if the two points are within a given range without being obstructed.</returns>
         public bool InRangeUnobstructed(MapCoordinates coords, Vector2 otherCoords, float range = InteractionRange,
-            int collisionMask = (int)CollisionGroup.Impassable, IEntity ignoredEnt = null, bool insideBlockerValid = false)
+            int collisionMask = (int)CollisionGroup.Impassable, Func<IEntity, bool> predicate = null, bool insideBlockerValid = false)
         {
             var dir = otherCoords - coords.Position;
 
@@ -47,18 +48,37 @@ namespace Content.Server.GameObjects.EntitySystems
             if (range > 0f && !(dir.LengthSquared <= range * range)) return false;
 
             var ray = new CollisionRay(coords.Position, dir.Normalized, collisionMask);
-            var rayResults = _physicsManager.IntersectRay(coords.MapId, ray, dir.Length, ignoredEnt, true);
+            var rayResults = _physicsManager.IntersectRayWithPredicate(coords.MapId, ray, dir.Length, predicate, true);
-            if(!rayResults.DidHitObject || (insideBlockerValid && rayResults.DidHitObject && rayResults.Distance < 1f))
+            if(!rayResults.DidHitObject || (insideBlockerValid && rayResults.DidHitObject && (rayResults.HitPos - otherCoords).Length < 1f))
             {
                 _mapManager.TryFindGridAt(coords, out var mapGrid);
                 var srcPos = mapGrid.MapToGrid(coords);
                 var destPos = new GridCoordinates(otherCoords, mapGrid);
-                if (srcPos.InRange(_mapManager, destPos, InteractionRange))
+                if (srcPos.InRange(_mapManager, destPos, range))
                 {
                     return true;
                 }
             }
             return false;
         }
+
+        /// <summary>
+        ///     Checks that these coordinates are within a certain distance without any
+        ///     entity that matches the collision mask obstructing them.
+        ///     If the <paramref name="range"/> is zero or negative,
+        ///     this method will only check if nothing obstructs the two sets of coordinates..
+        /// </summary>
+        /// <param name="coords">Set of coordinates to use.</param>
+        /// <param name="otherCoords">Other set of coordinates to use.</param>
+        /// <param name="range">maximum distance between the two sets of coordinates.</param>
+        /// <param name="collisionMask">the mask to check for collisions</param>
+        /// <param name="ignoredEnt">the entity to be ignored when checking for collisions.</param>
+        /// <param name="mapManager">Map manager containing the two GridIds.</param>
+        /// <param name="insideBlockerValid">if coordinates inside obstructions count as obstructed or not</param>
+        /// <returns>True if the two points are within a given range without being obstructed.</returns>
+        public bool InRangeUnobstructed(MapCoordinates coords, Vector2 otherCoords, float range = InteractionRange,
+            int collisionMask = (int)CollisionGroup.Impassable, IEntity ignoredEnt = null, bool insideBlockerValid = false) =>
+            InRangeUnobstructed(coords, otherCoords, range, collisionMask,
+                ignoredEnt == null ? null : (Func<IEntity, bool>)(entity => ignoredEnt == entity), insideBlockerValid);
     }
 }