// Temporary method
 public static int Calculate(MyTrashRemovalSettings settings)
 {
     int num = 0;
     foreach (var entity in MyEntities.GetEntities())
     {
         if (entity != null)
         {
             num += CalculateTrash(ref settings, entity);
         }
     }
     return num;
 }
        // Temporary method
        public static int Calculate(MyTrashRemovalSettings settings)
        {
            int num = 0;

            foreach (var entity in MyEntities.GetEntities())
            {
                if (entity != null)
                {
                    num += CalculateTrash(ref settings, entity);
                }
            }
            return(num);
        }
 public static int CalculateTrash(ref MyTrashRemovalSettings settings, MyEntity entity)
 {
     // So far removal is applied only to grids
     var grid = entity as MyCubeGrid;
     if (grid != null)
     {
         var keepReason = GetTrashState(grid, settings);             
         if (keepReason == MyTrashRemovalFlags.None)
         {
             return 1;
         }
     }
     return 0;
 }
        public static int CalculateTrash(ref MyTrashRemovalSettings settings, MyEntity entity)
        {
            // So far removal is applied only to grids
            var grid = entity as MyCubeGrid;

            if (grid != null)
            {
                var keepReason = GetTrashState(grid, settings);
                if (keepReason == MyTrashRemovalFlags.None)
                {
                    return(1);
                }
            }
            return(0);
        }
 public static void Apply(MyTrashRemovalSettings settings, MyTrashRemovalOperation operation)
 {
     foreach (var entity in MyEntities.GetEntities())
     {
         // So far removal is applied only to grids
         var grid = entity as MyCubeGrid;
         if (grid != null)
         {
             var keepReason = GetTrashState(grid, settings);
             if (keepReason == MyTrashRemovalFlags.None)
             {
                 ApplyOperation(grid, operation);
             }
         }
     }
 }
 public static void Apply(MyTrashRemovalSettings settings, MyTrashRemovalOperation operation)
 {
     foreach (var entity in MyEntities.GetEntities())
     {
         // So far removal is applied only to grids
         var grid = entity as MyCubeGrid;
         if (grid != null)
         {
             var keepReason = GetTrashState(grid, settings);
             if (keepReason == MyTrashRemovalFlags.None)
             {
                 ApplyOperation(grid, operation);
             }
         }
     }
 }
        static MyTrashRemovalFlags GetTrashState(MyCubeGrid grid, MyTrashRemovalSettings settings, out float metric,bool checkGroup = false)
        {
            metric = -1;

            HashSet<MySlimBlock> blocks = grid.GetBlocks();

            if (blocks != null  && blocks.Count > settings.BlockCountThreshold)
            {
                metric = settings.BlockCountThreshold;
                return MyTrashRemovalFlags.WithBlockCount;
            }

            if (!settings.HasFlag(MyTrashRemovalFlags.Fixed) && grid.IsStatic)
                return MyTrashRemovalFlags.Fixed;

            bool isAccelerating = false;
            bool isLinearMoving = false;
            bool isStationary = true;

            if (grid.Physics != null)
            {
                isAccelerating = grid.Physics.AngularAcceleration.AbsMax() > 0.05f || grid.Physics.LinearAcceleration.AbsMax() > 0.05f;
                isStationary = grid.Physics.AngularVelocity.AbsMax() < 0.05f && grid.Physics.LinearVelocity.AbsMax() < 0.05f;
                isLinearMoving = !isAccelerating && !isStationary;
            }

            if (!settings.HasFlag(MyTrashRemovalFlags.Stationary) && isStationary)
                return MyTrashRemovalFlags.Stationary;

            if (!settings.HasFlag(MyTrashRemovalFlags.Linear) && isLinearMoving)
                return MyTrashRemovalFlags.Linear;

            if (!settings.HasFlag(MyTrashRemovalFlags.Accelerating) && isAccelerating)
                return MyTrashRemovalFlags.Accelerating;


            if (grid.GridSystems != null)
            {
                bool isPowered = grid.GridSystems.ResourceDistributor.ResourceStateByType(MyResourceDistributorComponent.ElectricityId) != MyResourceStateEnum.NoPower;
                if (!settings.HasFlag(MyTrashRemovalFlags.Powered) && isPowered)
                    return MyTrashRemovalFlags.Powered;

                if (!settings.HasFlag(MyTrashRemovalFlags.Controlled) && grid.GridSystems.ControlSystem.IsControlled)
                    return MyTrashRemovalFlags.Controlled;

                if (!settings.HasFlag(MyTrashRemovalFlags.WithProduction) && grid.GridSystems.ControlSystem.IsControlled)
                    return MyTrashRemovalFlags.WithProduction;
            }

            if (!settings.HasFlag(MyTrashRemovalFlags.WithMedBay) && grid.BlocksCounters.GetValueOrDefault(typeof(MyObjectBuilder_MedicalRoom)) > 0)
                return MyTrashRemovalFlags.WithMedBay;

            if (IsCloseToPlayerOrCamera(grid, settings.PlayerDistanceThreshold))
            {
                metric = settings.PlayerDistanceThreshold;
                return MyTrashRemovalFlags.DistanceFromPlayer;
            }

            if (checkGroup && MyCubeGridGroups.Static.Physical != null)
            {
                var physicalGroup = MyCubeGridGroups.Static.Physical.GetGroup(grid);
                if (physicalGroup != null)
                {
                    foreach (var cubeGrid in physicalGroup.Nodes)
                    {
                        if (cubeGrid.NodeData == null || cubeGrid.NodeData.Physics == null || cubeGrid.NodeData.Physics.Shape == null || cubeGrid.NodeData == grid)
                            continue;


                        var subGridReason = GetTrashState(cubeGrid.NodeData, settings, out metric, false);
                        if (subGridReason != MyTrashRemovalFlags.None)
                        {
                            return subGridReason;
                        }
                    }
                }
            }

            return MyTrashRemovalFlags.None;
        }
 public static MyTrashRemovalFlags GetTrashState(MyCubeGrid grid, MyTrashRemovalSettings settings)
 {
     float metric;
     return GetTrashState(grid, settings, out metric,true);
 }
        static void RemoveTrash_Implementation(MyTrashRemovalSettings settings, MyTrashRemovalOperation operation)
        {
            if (!MyEventContext.Current.IsLocallyInvoked && !MySession.Static.HasPlayerAdminRights(MyEventContext.Current.Sender.Value))
            {
                MyEventContext.ValidationFailed();
                return;
            }

            MyTrashRemoval.Apply(settings, operation);
        }
 static void UploadSettingsToServer(MyTrashRemovalSettings newSettings)
 {
     MyTrashRemoval.PreviewSettings = newSettings;
 }
        static MyTrashRemovalFlags GetTrashState(MyCubeGrid grid, MyTrashRemovalSettings settings, out float metric, bool checkGroup = false)
        {
            metric = -1;

            HashSet <MySlimBlock> blocks = grid.GetBlocks();

            if (blocks != null && blocks.Count > settings.BlockCountThreshold)
            {
                metric = settings.BlockCountThreshold;
                return(MyTrashRemovalFlags.WithBlockCount);
            }

            if (!settings.HasFlag(MyTrashRemovalFlags.Fixed) && grid.IsStatic)
            {
                return(MyTrashRemovalFlags.Fixed);
            }

            bool isAccelerating = false;
            bool isLinearMoving = false;
            bool isStationary   = true;

            if (grid.Physics != null)
            {
                isAccelerating = grid.Physics.AngularAcceleration.AbsMax() > 0.05f || grid.Physics.LinearAcceleration.AbsMax() > 0.05f;
                isStationary   = grid.Physics.AngularVelocity.AbsMax() < 0.05f && grid.Physics.LinearVelocity.AbsMax() < 0.05f;
                isLinearMoving = !isAccelerating && !isStationary;
            }

            if (!settings.HasFlag(MyTrashRemovalFlags.Stationary) && isStationary)
            {
                return(MyTrashRemovalFlags.Stationary);
            }

            if (!settings.HasFlag(MyTrashRemovalFlags.Linear) && isLinearMoving)
            {
                return(MyTrashRemovalFlags.Linear);
            }

            if (!settings.HasFlag(MyTrashRemovalFlags.Accelerating) && isAccelerating)
            {
                return(MyTrashRemovalFlags.Accelerating);
            }


            if (grid.GridSystems != null)
            {
                bool isPowered = grid.GridSystems.ResourceDistributor.ResourceStateByType(MyResourceDistributorComponent.ElectricityId) != MyResourceStateEnum.NoPower;
                if (!settings.HasFlag(MyTrashRemovalFlags.Powered) && isPowered)
                {
                    return(MyTrashRemovalFlags.Powered);
                }

                if (!settings.HasFlag(MyTrashRemovalFlags.Controlled) && grid.GridSystems.ControlSystem.IsControlled)
                {
                    return(MyTrashRemovalFlags.Controlled);
                }

                if (!settings.HasFlag(MyTrashRemovalFlags.WithProduction) && grid.GridSystems.ControlSystem.IsControlled)
                {
                    return(MyTrashRemovalFlags.WithProduction);
                }
            }

            if (!settings.HasFlag(MyTrashRemovalFlags.WithMedBay) && grid.BlocksCounters.GetValueOrDefault(typeof(MyObjectBuilder_MedicalRoom)) > 0)
            {
                return(MyTrashRemovalFlags.WithMedBay);
            }

            if (IsCloseToPlayerOrCamera(grid, settings.PlayerDistanceThreshold))
            {
                metric = settings.PlayerDistanceThreshold;
                return(MyTrashRemovalFlags.DistanceFromPlayer);
            }

            if (checkGroup && MyCubeGridGroups.Static.Physical != null)
            {
                var physicalGroup = MyCubeGridGroups.Static.Physical.GetGroup(grid);
                if (physicalGroup != null)
                {
                    foreach (var cubeGrid in physicalGroup.Nodes)
                    {
                        if (cubeGrid.NodeData == null || cubeGrid.NodeData.Physics == null || cubeGrid.NodeData.Physics.Shape == null || cubeGrid.NodeData == grid)
                        {
                            continue;
                        }


                        var subGridReason = GetTrashState(cubeGrid.NodeData, settings, out metric, false);
                        if (subGridReason != MyTrashRemovalFlags.None)
                        {
                            return(subGridReason);
                        }
                    }
                }
            }

            return(MyTrashRemovalFlags.None);
        }
        public static MyTrashRemovalFlags GetTrashState(MyCubeGrid grid, MyTrashRemovalSettings settings)
        {
            float metric;

            return(GetTrashState(grid, settings, out metric, true));
        }
 static void UploadSettingsToServer(MyTrashRemovalSettings newSettings)
 {
     if (!MyEventContext.Current.IsLocallyInvoked && !MySession.Static.HasPlayerAdminRights(MyEventContext.Current.Sender.Value))
     {
         MyEventContext.ValidationFailed();
         return;
     }
     MyTrashRemoval.PreviewSettings = newSettings;
 }