Пример #1
0
        public Ent EntType(MyEntity ent)
        {
            if (ent is IMyFloatingObject)
            {
                if (CustomCollision.AllAabbInShield(ent.PositionComp.WorldAABB, DetectMatrixOutsideInv, _obbCorners))
                {
                    return(Ent.Ignore);
                }
                return(Ent.Floater);
            }

            var voxel = ent as MyVoxelBase;

            if (voxel != null && (Session.Enforced.DisableVoxelSupport == 1 || ShieldComp.Modulator == null || ShieldComp.Modulator.ModSet.Settings.ModulateVoxels || !GridIsMobile))
            {
                return(Ent.Ignore);
            }

            if (EntityBypass.Contains(ent))
            {
                return(Ent.Ignore);
            }

            var character = ent as IMyCharacter;

            if (character != null)
            {
                var dude = MyAPIGateway.Players.GetPlayerControllingEntity(ent)?.IdentityId;
                if (dude == null)
                {
                    return(Ent.Ignore);
                }
                var playerrelationship = MyCube.GetUserRelationToOwner((long)dude);
                if (playerrelationship == MyRelationsBetweenPlayerAndBlock.Owner || playerrelationship == MyRelationsBetweenPlayerAndBlock.FactionShare)
                {
                    var playerInShield = CustomCollision.PointInShield(ent.PositionComp.WorldAABB.Center, DetectMatrixOutsideInv);
                    return(playerInShield ? Ent.Protected : Ent.Friendly);
                }

                if (character.IsDead)
                {
                    return(Ent.Ignore);
                }

                if (CustomCollision.NewObbPointsInShield(ent, DetectMatrixOutsideInv, _obbPoints) == 9)
                {
                    return(Ent.EnemyInside);
                }
                return(Ent.EnemyPlayer);
            }
            var grid = ent as MyCubeGrid;

            if (grid != null)
            {
                ModulateGrids = (ShieldComp.Modulator != null && ShieldComp.Modulator.ModSet.Settings.ModulateGrids) || Session.Enforced.DisableEntityBarrier == 1;
                ModulatorGridComponent modComp;
                grid.Components.TryGet(out modComp);
                if (!string.IsNullOrEmpty(modComp?.ModulationPassword) && modComp.ModulationPassword == Shield.CustomData)
                {
                    var modShield = modComp.Modulator?.ShieldComp?.DefenseShields;
                    if (modShield != null)
                    {
                        lock (modShield.SubLock)
                        {
                            foreach (var subGrid in modShield.ShieldComp.SubGrids)
                            {
                                if (ShieldEnt.PositionComp.WorldVolume.Intersects(grid.PositionComp.WorldVolume))
                                {
                                    if (CustomCollision.CornerOrCenterInShield(grid, DetectMatrixOutsideInv, _resetEntCorners) > 0)
                                    {
                                        return(Ent.Protected);
                                    }
                                    AuthenticatedCache.Add(subGrid);
                                }
                                else
                                {
                                    AuthenticatedCache.Add(subGrid);
                                }
                            }
                        }
                        return(Ent.Authenticated);
                    }
                    foreach (var subGrid in modComp.SubGrids)
                    {
                        if (ShieldEnt.PositionComp.WorldVolume.Intersects(grid.PositionComp.WorldVolume))
                        {
                            if (CustomCollision.CornerOrCenterInShield(grid, DetectMatrixOutsideInv, _resetEntCorners) > 0)
                            {
                                return(Ent.Protected);
                            }
                            AuthenticatedCache.Add(subGrid);
                        }
                        else
                        {
                            AuthenticatedCache.Add(subGrid);
                        }
                    }
                }
                var bigOwners    = grid.BigOwners;
                var bigOwnersCnt = bigOwners.Count;
                if (CustomCollision.AllAabbInShield(ent.PositionComp.WorldAABB, DetectMatrixOutsideInv, _obbCorners))
                {
                    return(Ent.Protected);
                }
                if (!ModulateGrids && bigOwnersCnt == 0)
                {
                    return(Ent.NobodyGrid);
                }
                var enemy = !ModulateGrids && GridEnemy(grid, bigOwners);
                if (!enemy)
                {
                    lock (SubLock) if (ShieldComp.SubGrids.Contains(grid))
                        {
                            return(Ent.Protected);
                        }
                    var pointsInShield = CustomCollision.NewObbPointsInShield(grid, DetectMatrixOutsideInv, _obbPoints);
                    return(pointsInShield > 0 ? Ent.Protected : Ent.Friendly);
                }

                ShieldGridComponent shieldComponent;
                grid.Components.TryGet(out shieldComponent);
                if (shieldComponent?.DefenseShields?.ShieldComp != null && shieldComponent.DefenseShields.NotFailed)
                {
                    var dsComp       = shieldComponent.DefenseShields;
                    var shieldEntity = MyCube.Parent;
                    dsComp.EnemyShields.Add(shieldEntity);
                    return(Ent.Shielded);
                }
                return(Ent.EnemyGrid);
            }

            if (ent is IMyMeteor || (ent.DefinitionId.HasValue && ent.DefinitionId.Value.TypeId == Session.Instance.MissileObj))
            {
                return(Ent.Other);
            }
            if (voxel != null && GridIsMobile)
            {
                return(Ent.VoxelBase);
            }
            return(0);
        }
Пример #2
0
        public Ent EntType(MyEntity ent)
        {
            if (ent is IMyFloatingObject)
            {
                if (CustomCollision.AllAabbInShield(ent.PositionComp.WorldAABB, DetectMatrixOutsideInv, _obbCorners))
                {
                    return(Ent.Ignore);
                }
                return(Ent.Floater);
            }

            var voxel = ent as MyVoxelBase;

            if (voxel != null && (Session.Enforced.DisableVoxelSupport == 1 || ShieldComp.Modulator == null || ShieldComp.Modulator.ModSet.Settings.ModulateVoxels || !GridIsMobile))
            {
                return(Ent.Ignore);
            }

            if (EntityBypass.Contains(ent))
            {
                return(Ent.Ignore);
            }

            var character = ent as IMyCharacter;

            if (character != null)
            {
                var getComponentOwner = ent as IMyComponentOwner <MyIDModule>;

                long       playerId;
                MyIDModule targetIdModule;
                if (getComponentOwner != null && getComponentOwner.GetComponent(out targetIdModule))
                {
                    playerId = targetIdModule.Owner;
                }
                else
                {
                    var controllingId = character.ControllerInfo?.ControllingIdentityId;
                    playerId = controllingId ?? 0;
                }

                if (playerId == 0 || character.IsDead || character.Integrity <= 0)
                {
                    return(Ent.Ignore);
                }

                var playerrelationship = MyIDModule.GetRelationPlayerBlock(MyCube.IDModule.Owner, playerId, MyOwnershipShareModeEnum.Faction);

                var modulateAllies = (ShieldComp.Modulator != null && ShieldComp.Modulator.ModSet.Settings.AllowAllies);
                if (playerrelationship == MyRelationsBetweenPlayerAndBlock.Owner || playerrelationship == MyRelationsBetweenPlayerAndBlock.FactionShare || modulateAllies && playerrelationship == MyRelationsBetweenPlayerAndBlock.Friends)
                {
                    var playerInShield = CustomCollision.PointInShield(ent.PositionComp.WorldAABB.Center, DetectMatrixOutsideInv);
                    return(playerInShield ? Ent.Protected : Ent.Friendly);
                }

                if (CustomCollision.NewObbPointsInShield(ent, DetectMatrixOutsideInv, _obbPoints) == 9)
                {
                    return(Ent.EnemyInside);
                }

                return(Ent.EnemyPlayer);
            }
            var grid = ent as MyCubeGrid;

            if (grid != null)
            {
                var modulateGrids = (ShieldComp.Modulator != null && ShieldComp.Modulator.ModSet.Settings.ModulateGrids) || Session.Enforced.DisableEntityBarrier == 1;

                ModulatorGridComponent modComp;
                grid.Components.TryGet(out modComp);
                if (!string.IsNullOrEmpty(modComp?.ModulationPassword) && modComp.ModulationPassword == Shield.CustomData)
                {
                    var modShield = modComp.Modulator?.ShieldComp?.DefenseShields;
                    if (modShield != null)
                    {
                        foreach (var subGrid in modShield.ShieldComp.SubGrids.Keys)
                        {
                            if (ShieldEnt.PositionComp.WorldVolume.Intersects(grid.PositionComp.WorldVolume))
                            {
                                if (CustomCollision.CornerOrCenterInShield(grid, DetectMatrixOutsideInv, _resetEntCorners) > 0)
                                {
                                    return(Ent.Protected);
                                }
                                AuthenticatedCache.Add(subGrid);
                            }
                            else
                            {
                                AuthenticatedCache.Add(subGrid);
                            }
                        }
                        return(Ent.Authenticated);
                    }
                    foreach (var subGrid in modComp.SubGrids)
                    {
                        if (ShieldEnt.PositionComp.WorldVolume.Intersects(grid.PositionComp.WorldVolume))
                        {
                            if (CustomCollision.CornerOrCenterInShield(grid, DetectMatrixOutsideInv, _resetEntCorners) > 0)
                            {
                                return(Ent.Protected);
                            }
                            AuthenticatedCache.Add((MyCubeGrid)subGrid);
                        }
                        else
                        {
                            AuthenticatedCache.Add((MyCubeGrid)subGrid);
                        }
                    }
                }

                List <long>        bigOwners;
                int                bigOwnersCnt;
                Session.ParentGrid parent;
                if (Session.Instance.GetParentGrid.TryGetValue(grid, out parent) && !CustomCollision.AllAabbInShield(parent.Parent.PositionComp.WorldAABB, DetectMatrixOutsideInv, _obbCorners))
                {
                    bigOwners    = grid.BigOwners;
                    bigOwnersCnt = bigOwners.Count;
                    if (bigOwnersCnt == 0 || GridEnemy(grid, bigOwners))
                    {
                        return(Ent.EnemyGrid);
                    }
                }
                else
                {
                    bigOwners    = grid.BigOwners;
                    bigOwnersCnt = bigOwners.Count;
                }


                if (CustomCollision.AllAabbInShield(ent.PositionComp.WorldAABB, DetectMatrixOutsideInv, _obbCorners))
                {
                    return(Ent.Protected);
                }
                if (!modulateGrids && bigOwnersCnt == 0)
                {
                    return(Ent.NobodyGrid);
                }
                var enemy = !modulateGrids && GridEnemy(grid, bigOwners);
                if (!enemy)
                {
                    if (ShieldComp.SubGrids.ContainsKey(grid))
                    {
                        return(Ent.Protected);
                    }

                    var pointsInShield = CustomCollision.NewObbPointsInShield(grid, DetectMatrixOutsideInv, _obbPoints);
                    return(pointsInShield > 0 ? Ent.Protected : Ent.Friendly);
                }

                ShieldGridComponent shieldComponent;
                grid.Components.TryGet(out shieldComponent);
                if (shieldComponent?.DefenseShields?.ShieldComp != null && shieldComponent.DefenseShields.NotFailed && shieldComponent.DefenseShields.DsState != null && !shieldComponent.DefenseShields.DsState.State.ReInforce)
                {
                    var dsComp       = shieldComponent.DefenseShields;
                    var shieldEntity = MyCube.Parent;
                    dsComp.EnemyShields.Add(shieldEntity);
                    return(Ent.Shielded);
                }
                return(Ent.EnemyGrid);
            }

            if (ent is IMyMeteor || (ent.DefinitionId.HasValue && ent.DefinitionId.Value.TypeId == Session.Instance.MissileObj))
            {
                return(Ent.Other);
            }
            if (voxel != null && GridIsMobile)
            {
                return(Ent.VoxelBase);
            }
            return(0);
        }