public double SafeZoneIntersectionCheck(MySafeZone zone)
{
var zoneEntity = zone as IMyEntity;
if (zone.Shape == MySafeZoneShape.Sphere)
{
var newSphere = new BoundingSphereD(zoneEntity.PositionComp.WorldVolume.Center, zone.Radius);
var result = Ray.Intersects(newSphere);
if (result.HasValue == true)
{
return((double)result);
}
}
else
{
var result = Ray.Intersects(zoneEntity.PositionComp.WorldAABB);
if (result.HasValue == true)
{
return((double)result);
}
}
return(-1);
}
private void CheckAdminRights()
{
const string spider = "Space_spider";
const string wolf = "SpaceWolf";
foreach (var item in Players)
{
var pLevel = item.Value.PromoteLevel;
var playerId = item.Key;
var player = item.Value;
var wasAdmin = Admins.ContainsKey(playerId);
if (pLevel == MyPromoteLevel.Admin || pLevel == MyPromoteLevel.Owner || pLevel == MyPromoteLevel.SpaceMaster)
{
var character = player.Character;
var isAdmin = false;
if (character != null)
{
if (character.Definition.Id.SubtypeName.Equals(wolf) || character.Definition.Id.SubtypeName.StartsWith(spider))
{
continue;
}
if (MySafeZone.CheckAdminIgnoreSafezones(player.SteamUserId))
{
isAdmin = true;
}
else
{
foreach (var gridAi in GridTargetingAIs.Values)
{
if (gridAi.Targets.ContainsKey((MyEntity)character) && gridAi.Weapons.Count > 0 && ((IMyTerminalBlock)gridAi.Weapons[0].MyCube).HasPlayerAccess(playerId))
{
if (MyIDModule.GetRelationPlayerBlock(playerId, gridAi.AiOwner) == MyRelationsBetweenPlayerAndBlock.Enemies)
{
isAdmin = true;
break;
}
}
}
}
if (isAdmin)
{
Admins[playerId] = character;
AdminMap[character] = player;
continue;
}
}
}
if (wasAdmin)
{
IMyCharacter removeCharacter;
IMyPlayer removePlayer;
Admins.TryRemove(playerId, out removeCharacter);
AdminMap.TryRemove(removeCharacter, out removePlayer);
}
}
}
public static void InsertEntityInternalPostfix(MyEntity entity, ref MySafeZone __instance, ref bool __result)
{
if (!__result)
{
return;
}
var top = entity.GetTopMostParent();
top.SetSafeZone(__instance);
}
private bool TouchingSafeZone(MySafeZone safeZone)
{
var myObb = new MyOrientedBoundingBoxD(MyGrid.PositionComp.LocalAABB, MyGrid.PositionComp.WorldMatrixRef);
if (safeZone.Shape == MySafeZoneShape.Sphere)
{
var sphere = new BoundingSphereD(safeZone.PositionComp.WorldVolume.Center, safeZone.Radius);
return(myObb.Intersects(ref sphere));
}
return(new MyOrientedBoundingBoxD(safeZone.PositionComp.LocalAABB, safeZone.PositionComp.WorldMatrixRef).Contains(ref myObb) != ContainmentType.Disjoint);
}
private static bool IsAllowed(MySafeZone safezone, MyOrientedBoundingBoxD obb, IMyEntity original = null)
{
if (!safezone.Enabled)
{
return(true);
}
if (safezone.AccessTypeGrids == Sandbox.Common.ObjectBuilders.MySafeZoneAccess.Whitelist)
{
return(false);
}
if (safezone.Shape == Sandbox.Common.ObjectBuilders.MySafeZoneShape.Box)
{
var zoneOBB = new MyOrientedBoundingBoxD(safezone.PositionComp.LocalAABB, safezone.PositionComp.WorldMatrixRef);
if (obb.Contains(ref zoneOBB) == ContainmentType.Disjoint)
{
return(true);
}
}
else
{
var zoneSphere = new BoundingSphereD(safezone.PositionComp.GetPosition(), safezone.Radius);
if (obb.Contains(ref zoneSphere) == ContainmentType.Disjoint)
{
return(true);
}
}
// 512 = VRage.Game.ObjectBuilders.Components.MySafeZoneAction.BuildingProjections
if (original == null)
{
return(safezone.IsActionAllowed(obb.GetAABB(), CastProhibit(safezone.AllowedActions, 512)));
}
return(safezone.IsActionAllowed((MyEntity)original, CastProhibit(safezone.AllowedActions, 512)));
}
public static void InsertEntity_ImplementationPostfix(long entityId, ref MyConcurrentHashSet <long> ___m_containedEntities, ref MySafeZone __instance)
{
if (___m_containedEntities.Contains(entityId))
{
return;
}
if (MyEntities.TryGetEntityById(entityId, out var top))
{
top.SetSafeZone(__instance);
}
}
public static bool IsOutside(this MySafeZone self, MyEntity entity)
{
return(MethodDelegateInstance(self, entity));
}
public void TargetIntersectionCheck()
{
_entityScanList.Clear();
_voxelScanList.Clear();
_entityScanList = new List <MyLineSegmentOverlapResult <MyEntity> >();
MyGamePruningStructure.GetTopmostEntitiesOverlappingRay(ref Line, _entityScanList);
IMyCubeGrid closestGrid = null;
double closestGridDistance = -1;
MySafeZone closestZone = null;
double closestZoneDistance = -1;
IMyCharacter closestCharacter = null;
double closestCharacterDistance = -1;
foreach (var item in _entityScanList)
{
var targetGrid = item.Element as IMyCubeGrid;
var targetZone = item.Element as MySafeZone;
var targetVoxel = item.Element as MyVoxelBase;
var targetPlayer = item.Element as IMyCharacter;
if (targetGrid != null)
{
if (targetGrid == _collisionSystem.RemoteControl.SlimBlock.CubeGrid || _collisionSystem.RemoteControl.SlimBlock.CubeGrid.IsSameConstructAs(targetGrid))
{
continue;
}
if (closestGrid == null || (closestGrid != null && item.Distance < closestGridDistance))
{
closestGrid = targetGrid;
closestGridDistance = item.Distance;
}
}
if (targetZone != null)
{
if (closestZone == null || (closestZone != null && item.Distance < closestZoneDistance))
{
closestZone = targetZone;
closestZoneDistance = item.Distance;
}
}
if (targetVoxel != null)
{
_voxelScanList.Add(targetVoxel);
}
if (targetPlayer != null)
{
if (closestCharacter == null || (closestCharacter != null && item.Distance < closestCharacterDistance))
{
closestCharacter = targetPlayer;
closestCharacterDistance = item.Distance;
}
}
}
if (closestGrid != null)
{
double minDist = 0;
double maxDist = 0;
bool boxCheckResult = closestGrid.PositionComp.WorldAABB.Intersect(ref Ray, out minDist, out maxDist);
Vector3D startBox = boxCheckResult ? (minDist - 5) * DirectionVector + StartPosition : StartPosition;
Vector3D endBox = boxCheckResult ? (maxDist + 5) * DirectionVector + StartPosition : EndPosition;
var blockPos = closestGrid.RayCastBlocks(startBox, endBox);
if (!blockPos.HasValue)
{
return;
}
IMySlimBlock slimBlock = closestGrid.GetCubeBlock(blockPos.Value);
if (slimBlock == null)
{
return;
}
Vector3D blockPosition = Vector3D.Zero;
slimBlock.ComputeWorldCenter(out blockPosition);
GridCoords = blockPosition;
GridDistance = Vector3D.Distance(blockPosition, StartPosition);
GridEntity = closestGrid;
GridOwner = OwnershipHelper.GetOwnershipTypes(closestGrid, false);
GridRelation = OwnershipHelper.GetTargetReputation(_collisionSystem.Owner, closestGrid, false);
}
if (closestZone != null)
{
SafezoneEntity = closestZone;
SafezoneCoords = closestZoneDistance * DirectionVector + StartPosition;
SafezoneDistance = closestZoneDistance;
}
if (closestCharacter != null)
{
PlayerEntity = closestCharacter;
PlayerCoords = PlayerEntity.PositionComp.WorldAABB.Center;
PlayerDistance = closestCharacterDistance;
}
}
public SafeZoneEntity(IMyEntity entity) : base(entity)
{
SafeZone = entity as MySafeZone;
}
public static bool UpdateSafeZoneEnabledPatch(MySafeZoneComponent __instance, MySafeZone safeZone, bool activate)
{
Log.Info($"{nameof(MySafeZoneComponentPatch)}.{nameof(UpdateSafeZoneEnabledPatch)}({activate})");
return(Plugin.PermitsPlayerSafeZone(__instance.Entity, activate));
}
