示例#1
0
        public static bool CompareAllowedReputation(TargetRelationEnum allowedRelations, TargetRelationEnum resultRelation)
        {
            if (allowedRelations.HasFlag(TargetRelationEnum.Faction) && resultRelation.HasFlag(TargetRelationEnum.Faction))
            {
                return(true);
            }

            //Relation: Neutral
            if (allowedRelations.HasFlag(TargetRelationEnum.Neutral) && resultRelation.HasFlag(TargetRelationEnum.Neutral))
            {
                return(true);
            }

            //Relation: Enemy
            if (allowedRelations.HasFlag(TargetRelationEnum.Enemy) && resultRelation.HasFlag(TargetRelationEnum.Enemy))
            {
                return(true);
            }

            //Relation: Friend
            if (allowedRelations.HasFlag(TargetRelationEnum.Friend) && resultRelation.HasFlag(TargetRelationEnum.Friend))
            {
                return(true);
            }

            //Relation: Unowned
            if (allowedRelations.HasFlag(TargetRelationEnum.Unowned) && resultRelation.HasFlag(TargetRelationEnum.Unowned))
            {
                return(true);
            }

            return(false);
        }
示例#2
0
        public void ResetResults()
        {
            CollisionDetected = false;
            Type = CollisionType.None;
            Time = 0;

            GridEntity        = null;
            VoxelEntity       = null;
            SafezoneEntity    = null;
            ShieldBlockEntity = null;
            PlayerEntity      = null;

            GridCoords     = Vector3D.Zero;
            VoxelCoords    = Vector3D.Zero;
            SafezoneCoords = Vector3D.Zero;
            ShieldCoords   = Vector3D.Zero;
            PlayerCoords   = Vector3D.Zero;

            GridDistance     = -1;
            VoxelDistance    = -1;
            SafezoneDistance = -1;
            ShieldDistance   = -1;
            PlayerDistance   = -1;

            GridOwner    = TargetOwnerEnum.None;
            GridRelation = TargetRelationEnum.None;
        }
示例#3
0
        public void ShieldIntersectionCheck()
        {
            IMyEntity shieldEntity = null;

            if (RAI_SessionCore.Instance.ShieldApiLoaded)
            {
                var api    = RAI_SessionCore.Instance.SApi;
                var result = api.ClosestShieldInLine(Line, true);

                if (result.Item1.HasValue)
                {
                    var dist = (double)result.Item1.Value;
                    shieldEntity = result.Item2;

                    ShieldCoords      = StartPosition + Line.Direction * dist;
                    ShieldDistance    = dist;
                    ShieldBlockEntity = shieldEntity;
                    ShieldOwner       = OwnershipHelper.GetOwnershipTypes((IMyTerminalBlock)shieldEntity);
                    ShieldRelation    = OwnershipHelper.GetTargetReputation(_collisionSystem.Owner, (IMyTerminalBlock)shieldEntity);
                }
            }
        }
示例#4
0
        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;
            }
        }