Example #1
0
        // admin deletearea x y z radius
        public override bool HandleCommand(ulong userId, string[] words)
        {
            if (words.Count() != 4 && words.Count() != 0)
            {
                return(false);
            }

            if (!words.Any())
            {
                Communication.SendPrivateInformation(userId, GetHelp());
                return(true);
            }

            // Test Input
            float test = 0;

            for (int r = 0; r < 4; r++)
            {
                if (!float.TryParse(words[r], out test))
                {
                    Communication.SendPrivateInformation(userId, string.Format("The value at position {0} - '{1}' is invalid.  Please try the command again.", r + 1, words[r]));
                    return(true);
                }
            }

            Vector3D startPosition = new Vector3(float.Parse(words[0]), float.Parse(words[1]), float.Parse(words[2]));
            float    radius        = float.Parse(words[3]);

            CubeGrids.RemoveGridsInSphere(userId, startPosition, radius, RemoveGridTypes.Stations);
            return(true);
        }
        // admin nobeacon scan
        public override bool HandleCommand(ulong userId, string[] words)
        {
            try
            {
                HashSet <IMyEntity> entities          = new HashSet <IMyEntity>();
                HashSet <IMyEntity> entitiesToConfirm = new HashSet <IMyEntity>();
                HashSet <IMyEntity> entitiesConnected = new HashSet <IMyEntity>();
                HashSet <IMyEntity> entitiesFound     = new HashSet <IMyEntity>();
                Wrapper.GameAction(() =>
                {
                    MyAPIGateway.Entities.GetEntities(entities, x => x is IMyCubeGrid);
                });

                foreach (IMyEntity entity in entities)
                {
                    if (!(entity is IMyCubeGrid))
                    {
                        continue;
                    }

                    IMyCubeGrid grid = (IMyCubeGrid)entity;
                    MyObjectBuilder_CubeGrid gridBuilder = CubeGrids.SafeGetObjectBuilder(grid);
                    if (gridBuilder == null)
                    {
                        continue;
                    }

                    bool found = false;
                    foreach (MyObjectBuilder_CubeBlock block in gridBuilder.CubeBlocks)
                    {
                        if (block.TypeId == typeof(MyObjectBuilder_Beacon))
                        {
                            found = true;
                            break;
                        }
                    }

                    if (!found)
                    {
                        entitiesToConfirm.Add(grid);
                    }
                }

                CubeGrids.GetGridsUnconnected(entitiesFound, entitiesToConfirm);

                foreach (IMyEntity entity in entitiesFound)
                {
                    CubeGridEntity gridEntity = (CubeGridEntity)GameEntityManager.GetEntity(entity.EntityId);
                    Communication.SendPrivateInformation(userId, string.Format("Found entity '{0}' ({1}) at {2} with no beacon.", gridEntity.Name, gridEntity.EntityId, General.Vector3DToString(entity.GetPosition())));
                }

                Communication.SendPrivateInformation(userId, string.Format("Found {0} grids with no beacons", entitiesFound.Count));
            }
            catch (Exception ex)
            {
                Logging.WriteLineAndConsole(string.Format("Scan error: {0}", ex.ToString()));
            }

            return(true);
        }
        // admin nobeacon scan
        public override bool HandleCommand(ulong userId, string[] words)
        {
            string linkType = "";

            if (words.Length > 0 && words[0].ToLower( ) == "physical")
            {
                linkType = " physical";
            }

            try
            {
                string command             = $"excludesblocksubtype:beacon quiet{linkType}";
                HashSet <GridGroup> groups = CubeGrids.ScanGrids(0, CommandParser.GetCommandParts(command).ToArray());
                int groupsCount            = groups.Count;
                int gridsCount             = 0;

                foreach (var group in groups)
                {
                    //if ( group.GetFatBlocks( ).Any( x =>  x is IMyBeacon ) )
                    //    continue;

                    //groupsCount++;
                    gridsCount += group.Grids.Count;
                    Communication.SendPrivateInformation(userId, $"Found group with parent {group.Parent.DisplayName} ({group.Parent.EntityId}) at {group.Parent.PositionComp.GetPosition( )} with no beacon.");
                }

                Communication.SendPrivateInformation(userId, $"Found {gridsCount} grids in {groupsCount} groups with no beacon.");
            }
            catch (Exception ex)
            {
                Log.Info(string.Format("Scan error: {0}", ex.ToString( )));
            }

            return(true);
        }
        private HashSet <long> GetAllOwners()
        {
            HashSet <long>      owners   = new HashSet <long>();
            HashSet <IMyEntity> entities = new HashSet <IMyEntity>();

            MyAPIGateway.Entities.GetEntities(entities);

            foreach (IMyEntity entity in entities)
            {
                if (!(entity is IMyCubeGrid))
                {
                    continue;
                }

                IMyCubeGrid grid = (IMyCubeGrid)entity;
                MyObjectBuilder_CubeGrid gridBuilder = CubeGrids.SafeGetObjectBuilder(grid);
                if (gridBuilder == null)
                {
                    continue;
                }

                foreach (MyObjectBuilder_CubeBlock block in gridBuilder.CubeBlocks)
                {
                    if (block.Owner != 0 && !owners.Contains(block.Owner))
                    {
                        owners.Add(block.Owner);
                    }
                }
            }
            return(owners);
        }
        /// <exception cref="OverflowException"></exception>
        private void ProcessTriggerItem(SettingsCleanupTriggerItem item)
        {
            if (_triggerdItem != null && _triggerdItem != item)
            {
                return;
            }

            if (_triggerdItem == null)
            {
                // Increase to 5 minutes
                if (DateTime.Now - item.LastRan > TimeSpan.FromMinutes(5))
                {
                    item.LastRan = DateTime.Now;
                    string command = string.Format("{0} quiet", item.ScanCommand);
                    HashSet <IMyEntity> entities = CubeGrids.ScanGrids(0, command);
                    if (entities.Count >= item.MaxCapacity)
                    {
                        Communication.SendPublicInformation(string.Format("[NOTICE]: Cleanup triggered.  ({0} of {1}) triggered grids found.  Cleanup will run in {2} minutes.  Reason: {3}", entities.Count, item.MaxCapacity, item.MinutesAfterCapacity, item.Reason));
                        item.NotificationItemsRan.Clear( );
                        _triggerdItem = item;
                        return;
                    }
                }
            }
            else
            {
                if (DateTime.Now - item.LastRan > TimeSpan.FromMinutes(item.MinutesAfterCapacity))
                {
                    string command = string.Format("{0} quiet", item.ScanCommand);
                    HashSet <IMyEntity> entities = CubeGrids.ScanGrids(0, command);
                    CubeGrids.DeleteGrids(entities);
                    Communication.SendPublicInformation(string.Format("[NOTICE]: Triggered cleanup has run.  {0} entities removed.  Have a nice day.", entities.Count));
                    _triggerdItem = null;
                    return;
                }

                foreach (SettingsCleanupNotificationItem notifyItem in PluginSettings.Instance.CleanupNotificationItems)
                {
                    if (item.NotificationItemsRan.Contains(notifyItem))
                    {
                        continue;
                    }

                    if (notifyItem.MinutesBeforeCleanup > item.MinutesAfterCapacity)
                    {
                        continue;
                    }

                    if (DateTime.Now - item.LastRan > TimeSpan.FromMinutes(item.MinutesAfterCapacity - notifyItem.MinutesBeforeCleanup))
                    {
                        item.NotificationItemsRan.Add(notifyItem);
                        string notification = notifyItem.Message.Replace("%cleanup_reason%", item.Reason);
                        Communication.SendPublicInformation(notification);
                    }
                }
            }
        }
Example #6
0
        // /admin movefrom x y z x y z radius
        public override bool HandleCommand(ulong userId, string[] words)
        {
            if (words.Count() < 2)
            {
                Communication.SendPrivateInformation(userId, GetHelp());
                return(true);
            }

            string sourceName = words[0];
            float  distance   = 50f;

            // TODO Allow quotes so we can do distance?
            bool parse = false;

            if (words.Count() > 2)
            {
                parse = float.TryParse(words[words.Count() - 1], out distance);
            }

            string targetName;

            if (parse)
            {
                targetName = string.Join(" ", words.Skip(1).Take(words.Count() - 2).ToArray());
            }
            else
            {
                targetName = string.Join(" ", words.Skip(1).ToArray());
            }

            Vector3D  position;
            IMyEntity entity = Player.FindControlledEntity(targetName);

            if (entity == null)
            {
                entity = CubeGrids.Find(targetName);
                if (entity == null)
                {
                    Communication.SendPrivateInformation(userId, string.Format("Can not find user or grid with the name: {0}", targetName));
                    return(true);
                }
            }

            position = entity.GetPosition();

            Communication.SendPrivateInformation(userId, string.Format("Trying to move {0} to within {1}m of {2}.  This may take about 20 seconds.", sourceName, distance, targetName));
            Vector3D startPosition = MathUtility.RandomPositionFromPoint((Vector3)position, distance);

            if (!Player.Move(sourceName, startPosition))
            {
                Communication.SendPrivateInformation(userId, string.Format("Can not move user: {0} (Is user in a cockpit or not in game?)", sourceName));
                return(true);
            }

            Communication.SendPrivateInformation(userId, string.Format("Moved {0} to within {1}m of {2}", sourceName, (int)Math.Round(Vector3D.Distance(startPosition, position)), targetName));
            return(true);
        }
Example #7
0
 // admin nobeacon scan
 public override bool HandleCommand(ulong userId, string[] words)
 {
     try
     {
         CubeGrids.ScanGrids(userId, words);
     }
     catch (Exception ex)
     {
         Log.Info(ex, "scan grid");
         return(false);
     }
     return(true);
 }
Example #8
0
        public void Process()
        {
            lock (m_items)
            {
                if (!m_items.Any())
                {
                    return;
                }

                for (int r = m_items.Count() - 1; r >= 0; r--)
                {
                    TimedEntityCleanupItem item = m_items[r];

                    if (DateTime.Now - item.addedTime > TimeSpan.FromSeconds(item.secondsAfterAdding))
                    {
                        try
                        {
                            IMyEntity entity = null;
                            Wrapper.GameAction(() =>
                            {
                                MyAPIGateway.Entities.TryGetEntityById(item.entityId, out entity);
                            });

                            if (entity != null)
                            {
                                MyObjectBuilder_CubeGrid gridBuilder = CubeGrids.SafeGetObjectBuilder((IMyCubeGrid)entity);
                                if (gridBuilder == null)
                                {
                                    continue;
                                }

                                CubeGridEntity entityToDispose = new CubeGridEntity((MyObjectBuilder_CubeGrid)entity.GetObjectBuilder(), entity);
                                entityToDispose.Dispose();
                            }
                            else
                            {
                                Logging.WriteLineAndConsole("Entity is null");
                            }
                        }
                        catch (Exception ex)
                        {
                            Logging.WriteLineAndConsole(string.Format("Dispose Error: {0}", ex.ToString()));
                        }

                        m_items.RemoveAt(r);
                    }
                }
            }
        }
        // admin nobeacon scan
        public override bool HandleCommand(ulong userId, string[] words)
        {
            HashSet <IMyEntity> grids = CubeGrids.ScanGrids(userId, words);

            bool confirm = true;

            /*
             * if (words.FirstOrDefault(x => x.ToLower() == "confirm") != null)
             * {
             *      confirm = true;
             * }
             */
            int count = 0;

            foreach (IMyEntity entity in grids)
            {
                if (!(entity is IMyCubeGrid))
                {
                    continue;
                }

                IMyCubeGrid grid = (IMyCubeGrid)entity;
                MyObjectBuilder_CubeGrid gridBuilder = CubeGrids.SafeGetObjectBuilder(grid);
                if (confirm)
                {
                    BaseEntityNetworkManager.BroadcastRemoveEntity(entity, true);
                }

                long   ownerId   = 0;
                string ownerName = "";
                if (CubeGrids.GetBigOwners(gridBuilder).Count > 0)
                {
                    ownerId   = CubeGrids.GetBigOwners(gridBuilder).First();
                    ownerName = PlayerMap.Instance.GetPlayerItemFromPlayerId(ownerId).Name;
                }

                if (confirm)
                {
                    Logging.WriteLineAndConsole("Cleanup", string.Format("Cleanup Removed Grid - Id: {0} Display: {1} OwnerId: {2} OwnerName: {3}", entity.EntityId, entity.DisplayName, ownerId, ownerName));
                }

                count++;
            }

            Communication.SendPrivateInformation(userId, string.Format("Operation deletes {0} grids", count));
            return(true);
        }
        /// <exception cref="OverflowException"></exception>
        private void ProcessTimedItem(SettingsCleanupTimedItem item)
        {
            _start = DateTime.Now;             // this needs to be updated for each run so multi-day runtimes are handled properly

            DateTime itemTime = new DateTime(_start.Year, _start.Month, _start.Day, item.Restart.Hour, item.Restart.Minute, 0);

            if (DateTime.Now - itemTime > _twentySeconds)
            {
                itemTime = itemTime.AddDays(1);
            }

            if (DateTime.Now - item.LastRan < _oneMinute)
            {
                return;
            }

            if (itemTime - DateTime.Now < _oneSecond && DateTime.Now - item.LastRan > _oneMinute)
            {
                string command = string.Format("{0} quiet", item.ScanCommand);
                HashSet <IMyEntity> entities = CubeGrids.ScanGrids(0, CommandParser.GetCommandParts(command).ToArray( ));
                CubeGrids.DeleteGrids(entities);
                Communication.SendPublicInformation(string.Format("[NOTICE]: Timed cleanup has run.  {0} entities removed.  Have a nice day.", entities.Count));
                item.LastRan = DateTime.Now;
                item.NotificationItemsRan.Clear( );
                return;
            }

            foreach (SettingsCleanupNotificationItem notifyItem in PluginSettings.Instance.CleanupNotificationItems)
            {
                if (item.NotificationItemsRan.Contains(notifyItem))
                {
                    continue;
                }

                if (itemTime - DateTime.Now < TimeSpan.FromMinutes(notifyItem.MinutesBeforeCleanup))
                {
                    item.NotificationItemsRan.Add(notifyItem);

                    if (DateTime.Now - notifyItem.lastRan > _oneMinute)
                    {
                        notifyItem.lastRan = DateTime.Now;
                        string notification = notifyItem.Message.Replace("%cleanup_reason%", item.Reason);
                        Communication.SendPublicInformation(notification);
                    }
                }
            }
        }
        /// <exception cref="OverflowException"></exception>
        private void ProcessTimedItem(SettingsCleanupTimedItem item)
        {
            DateTime time = new DateTime(_start.Year, _start.Month, _start.Day, item.Restart.Hour, item.Restart.Minute, 0);

            if (time - DateTime.Now < TimeSpan.FromSeconds(-20))
            {
                time = new DateTime(_start.Year, _start.Month, _start.Day + 1, item.Restart.Hour, item.Restart.Minute, 0);
            }

            if (DateTime.Now - item.LastRan < TimeSpan.FromMinutes(1))
            {
                return;
            }

            if (time - DateTime.Now < TimeSpan.FromSeconds(1) && DateTime.Now - item.LastRan > TimeSpan.FromMinutes(1))
            {
                string command = string.Format("{0} quiet", item.ScanCommand);
                HashSet <IMyEntity> entities = CubeGrids.ScanGrids(0, command);
                CubeGrids.DeleteGrids(entities);
                Communication.SendPublicInformation(string.Format("[NOTICE]: Timed cleanup has run.  {0} entities removed.  Have a nice day.", entities.Count));
                item.LastRan = DateTime.Now;
                item.NotificationItemsRan.Clear( );
                return;
            }

            foreach (SettingsCleanupNotificationItem notifyItem in PluginSettings.Instance.CleanupNotificationItems)
            {
                if (item.NotificationItemsRan.Contains(notifyItem))
                {
                    continue;
                }

                if (time - DateTime.Now < TimeSpan.FromMinutes(notifyItem.MinutesBeforeCleanup))
                {
                    item.NotificationItemsRan.Add(notifyItem);

                    if (DateTime.Now - notifyItem.lastRan > TimeSpan.FromMinutes(1))
                    {
                        notifyItem.lastRan = DateTime.Now;
                        string notification = notifyItem.Message.Replace("%cleanup_reason%", item.Reason);
                        Communication.SendPublicInformation(notification);
                    }
                }
            }
        }
        private void ExtractCommandFromEntity(IMyEntity entity)
        {
            IMyCubeGrid grid = (IMyCubeGrid)entity;
            MyObjectBuilder_CubeGrid gridBuilder = CubeGrids.SafeGetObjectBuilder(grid);

            if (gridBuilder == null)
            {
                return;
            }

            string command = string.Empty;

            foreach (MyObjectBuilder_CubeBlock block in gridBuilder.CubeBlocks)
            {
                MyObjectBuilder_Beacon beacon = block as MyObjectBuilder_Beacon;
                if (beacon != null)
                {
                    command = beacon.CustomName;
                    break;
                }
            }

            string player   = entity.DisplayName.Replace("CommRelay", string.Empty);
            long   playerId = long.Parse(player);
            ulong  steamId  = PlayerMap.Instance.GetSteamIdFromPlayerId(playerId);

            Wrapper.GameAction(() =>
            {
                entity.DisplayName = string.Empty;
                BaseEntityNetworkManager.BroadcastRemoveEntity(entity, false);
            });

            Essentials.Log.Info("COMMAND {1} - {2}: {0}", command, playerId, entity.EntityId);
            if (!m_processedRelays.Contains(entity.EntityId))
            {
                m_processedRelays.Add(entity.EntityId);
                Essentials.Instance.HandleChatMessage(steamId, command);
            }
            else
            {
                Essentials.Log.Info("Ignoring repeat beacon: {0}");
            }
        }
Example #13
0
        // admin nobeacon scan
        public override bool HandleCommand(ulong userId, string[] words)
        {
            HashSet <GridGroup> groups = CubeGrids.ScanGrids(userId, words);

            bool confirm = true;

            /*
             *      if (words.FirstOrDefault(x => x.ToLower() == "confirm") != null)
             *      {
             *              confirm = true;
             *      }
             */
            int gridCount  = 0;
            int groupCount = 0;

            foreach (GridGroup group in groups)
            {
                long   ownerId   = 0;
                string ownerName = "";
                if (group.BigOwners.Count > 0)
                {
                    ownerId   = group.BigOwners.First( );
                    ownerName = PlayerMap.Instance.GetPlayerItemFromPlayerId(ownerId).Name;
                }

                if (confirm)
                {
                    Log.Info("Cleanup removed group with parent - Id: {0} Display: {1} OwnerId: {2} OwnerName: {3}",
                             group.Parent.EntityId, group.Parent.DisplayName, ownerId, ownerName);
                }

                gridCount += group.Grids.Count;
                groupCount++;

                if (confirm)
                {
                    group.Close(  );
                }
            }

            Communication.SendPrivateInformation(userId, $"Operation deletes {gridCount} grids in {groupCount} groups.");
            return(true);
        }
Example #14
0
        public GridGroup(MyCubeGrid grid, GridLinkTypeEnum linkType = GridLinkTypeEnum.Logical)
        {
            _linkType = linkType;

            if (grid.InScene)
            {
                List <MyCubeGrid> tmpList = new List <MyCubeGrid>( );

                //find the group containing this grid with the given link type
                Wrapper.GameAction(() => tmpList = MyCubeGridGroups.Static.GetGroups(linkType).GetGroupNodes(grid));

                _grids.UnionWith(tmpList);
            }
            //manually create a group for out of scene grids because they have a null group (yay Dusan fixed the crash)
            else
            {
                //use the old method to filter out grids with pistons or rotors, for safety
                HashSet <IMyEntity> thisEntity = new HashSet <IMyEntity>();
                HashSet <IMyEntity> returnSet  = new HashSet <IMyEntity>();
                thisEntity.Add((IMyEntity)grid);
                CubeGrids.GetGridsUnconnected(returnSet, thisEntity);

                if (returnSet.Count > 0)
                {
                    _grids.Add(grid);
                }
                else
                {
                    return;
                }
            }

            //populate our internal lists
            ComputeParent( );
            ComputeCubeBlocks( );
            ComputeFatBlocks( );
            ComputeSmallOwners( );
            ComputeBigOwners( );
        }
Example #15
0
        public override bool HandleCommand(ulong userId, string[] words)
        {
            HashSet <IMyEntity> entitiesFound = CubeGrids.ScanCleanup(userId, words);

            foreach (IMyEntity entity in entitiesFound)
            {
                CubeGridEntity removeEntity = new CubeGridEntity((MyObjectBuilder_CubeGrid)entity.GetObjectBuilder(), entity);
                removeEntity.Dispose();

                IMyCubeGrid grid      = (IMyCubeGrid)entity;
                long        ownerId   = 0;
                string      ownerName = "";
                if (grid.BigOwners.Count > 0)
                {
                    ownerId   = grid.BigOwners.First();
                    ownerName = PlayerMap.Instance.GetPlayerItemFromPlayerId(ownerId).Name;
                }

                Log.Info("Cleanup", string.Format("Cleanup Removed Grid - Id: {0} Display: {1} OwnerId: {2} OwnerName: {3}", entity.EntityId, entity.DisplayName, ownerId, ownerName));
            }
            return(true);
        }
Example #16
0
        public override bool HandleCommand(ulong userId, string[] words)
        {
            int  page   = 1;
            bool dialog = false;

            if (words.Length > 0)
            {
                if (words[0] == "dialog")
                {
                    dialog = true;
                }

                int.TryParse(words[0], out page);
                if (page < 1)
                {
                    page = 1;
                }
            }

            if (PlayerMap.Instance.GetPlayerIdsFromSteamId(userId).Count < 1 && userId != 0)
            {
                Communication.SendPrivateInformation(userId, "Error occurred while processing this command. (1)");
                return(true);
            }

            long playerId = 0;

            if (PlayerMap.Instance.GetPlayerIdsFromSteamId(userId).Count > 0)
            {
                playerId = PlayerMap.Instance.GetPlayerIdsFromSteamId(userId).First();
            }

            HashSet <IMyEntity> entities = new HashSet <IMyEntity>();
            List <IMyPlayer>    players  = new List <IMyPlayer>();

            Wrapper.GameAction(() =>
            {
                MyAPIGateway.Entities.GetEntities(entities, x => x is IMyCubeGrid);
            });
            MyAPIGateway.Players.GetPlayers(players);

            IMyPlayer player = players.FirstOrDefault(x => x.SteamUserId == userId);

            string result = "";
            int    count  = 0;

            foreach (IMyEntity entity in entities)
            {
                MyCubeGrid grid = entity as MyCubeGrid;

                if (grid == null)
                {
                    continue;
                }

                if (grid.SmallOwners.Contains(playerId))
                {
                    if (result != "")
                    {
                        result += "\r\n";
                    }

                    if (CubeGrids.IsFullOwner(grid, playerId, player) && !dialog)
                    {
                        result += string.Format("Grid '{0}' at {2}", grid.DisplayName, grid.EntityId, ShowCoordinates(entity.GetPosition()));
                    }
                    else if (CubeGrids.IsFullOwner(grid, playerId, player) && dialog)
                    {
                        result += string.Format("{0} - {1} - {2}bl - {3}", grid.DisplayName, ShowCoordinates(entity.GetPosition()), grid.CubeBlocks.Count, grid.GridSizeEnum);
                    }
                    else
                    {
                        result += string.Format("Grid '{0}'", grid.DisplayName, grid.EntityId);
                    }

                    count++;
                }
            }

            if (dialog)
            {
                Communication.DisplayDialog(userId, "User Grid List", "Ships / Stations you own:", result.Replace("\r\n", "|"), "OK");
                return(true);
            }

            string[] resultLines = result.Split(new string[] { "\r\n" }, StringSplitOptions.None);

            int pages = ((resultLines.Length - 1) / 6) + 1;

            if (page > pages)
            {
                page = pages;
            }

            string output = "";

            for (int r = ((page - 1) * 6); r < resultLines.Length && r < ((page) * 6); r++)
            {
                string line = resultLines[r];
                if (output != "")
                {
                    output += "\r\n";
                }

                output += line;
            }
            Communication.SendPrivateInformation(userId, output);

            Communication.SendPrivateInformation(userId, string.Format("Displaying page {0} of {1} - {2} grids", page, pages, count));
            return(true);
        }
        // admin nobeacon scan
        public override bool HandleCommand(ulong userId, string[] words)
        {
            if (words.Count() != 2)
            {
                Communication.SendPrivateInformation(userId, GetHelp());
                return(true);
            }

            string blockType  = words[0].ToLower();
            int    blockCount = 0;

            if (!int.TryParse(words[1], out blockCount))
            {
                Communication.SendPrivateInformation(userId, string.Format("Invalid block count: {0}", words[1]));
                return(true);
            }

            blockCount = Math.Max(blockCount, 1);

            Communication.SendPrivateInformation(userId, string.Format("Looking for grids that contain more than {0} of type {1}", blockCount, blockType));

            HashSet <IMyEntity> entities = new HashSet <IMyEntity>();

            Wrapper.GameAction(() =>
            {
                MyAPIGateway.Entities.GetEntities(entities, x => x is IMyCubeGrid);
            });

            HashSet <IMyEntity> entitiesToConfirm   = new HashSet <IMyEntity>();
            HashSet <IMyEntity> entitiesUnconnected = new HashSet <IMyEntity>();
            HashSet <IMyEntity> entitiesFound       = new HashSet <IMyEntity>();

            foreach (IMyEntity entity in entities)
            {
                if (!(entity is IMyCubeGrid))
                {
                    continue;
                }

                IMyCubeGrid grid = (IMyCubeGrid)entity;
                MyObjectBuilder_CubeGrid gridBuilder = CubeGrids.SafeGetObjectBuilder(grid);
                if (gridBuilder == null)
                {
                    continue;
                }

                if (PluginSettings.Instance.LoginEntityWhitelist.Contains(entity.EntityId.ToString()))
                {
                    continue;
                }

                entitiesToConfirm.Add(entity);
            }

            CubeGrids.GetGridsUnconnected(entitiesUnconnected, entitiesToConfirm);
            foreach (IMyEntity entity in entitiesUnconnected)
            {
                IMyCubeGrid grid = (IMyCubeGrid)entity;
                MyObjectBuilder_CubeGrid gridBuilder = CubeGrids.SafeGetObjectBuilder((IMyCubeGrid)entity);
                if (gridBuilder == null)
                {
                    continue;
                }

                int count = 0;
                foreach (MyObjectBuilder_CubeBlock block in gridBuilder.CubeBlocks)
                {
                    if (block.GetId().SubtypeName.ToLower().Contains(blockType))
                    {
                        count++;
                    }
                }

                if (count >= blockCount)
                {
                    Communication.SendPrivateInformation(userId, string.Format("Found grid '{0}' ({1}) owned by '{5}' which has more than {3} blocks of type {4}.  BlockCount={2}", entity.DisplayName, entity.EntityId, ((MyObjectBuilder_CubeGrid)entity.GetObjectBuilder()).CubeBlocks.Count, blockCount, blockType, grid.BigOwners.Count > 0 ? PlayerMap.Instance.GetPlayerItemFromPlayerId(grid.BigOwners.First()).Name : "No one"));
                    entitiesFound.Add(entity);
                    continue;
                }
            }

            /*
             * foreach(IMyEntity entity in entitiesFound)
             * {
             *      IMyCubeGrid grid = (IMyCubeGrid)entity;
             * }
             */

            Communication.SendPrivateInformation(userId, string.Format("Found {0} grids considered to be overlimit", entitiesFound.Count));
            return(true);
        }
Example #18
0
 // admin nobeacon scan
 public override bool HandleCommand(ulong userId, string command)
 {
     string[] words = command.Split(' ');
     CubeGrids.ScanCleanup(userId, words);
     return(true);
 }
        public static bool ToggleMedbayGrids(ulong steamId)
        {
            if (_checkConceal || _checkReveal)
            {
                Communication.SendPrivateInformation(steamId, "Server busy");
                return(false);
            }

            _checkConceal = true;
            _checkReveal  = true;
            try
            {
                DateTime start = DateTime.Now;

                // Toggle off
                HashSet <IMyEntity> entities      = new HashSet <IMyEntity>( );
                HashSet <IMyEntity> entitiesFound = new HashSet <IMyEntity>( );

                try
                {
                    MyAPIGateway.Entities.GetEntities(entities);
                }
                catch
                {
                    Essentials.Log.Info("Error getting entity list, skipping check");
                    return(false);
                }

                CubeGrids.GetGridsUnconnected(entitiesFound, entities);

                HashSet <IMyEntity> entitiesToConceal = new HashSet <IMyEntity>( );
                FilterEntitiesForMedbayCheck(steamId, entitiesFound, entitiesToConceal);

                if (entitiesToConceal.Count > 0)
                {
                    //if (PluginSettings.Instance.DynamicClientConcealEnabled)
                    //{
                    //ClientEntityManagement.Refresh(steamId);
                    //}

                    Communication.SendClientMessage(steamId, string.Format("/conceal {0}", string.Join(",", entitiesToConceal.Select(x => x.EntityId.ToString( ) + ":" + ((MyObjectBuilder_CubeGrid)x.GetObjectBuilder( )).CubeBlocks.Count.ToString( ) + ":" + x.DisplayName).ToArray( ))));
                    Thread.Sleep(1500);
                    ConcealEntities(entitiesToConceal);
                    //CheckAndRevealEntities();
                }

                if ((DateTime.Now - start).TotalMilliseconds > 2000 && PluginSettings.Instance.DynamicShowMessages)
                {
                    Essentials.Log.Info("Completed Toggle: {0}ms", (DateTime.Now - start).TotalMilliseconds);
                }
            }
            catch (Exception ex)
            {
                Essentials.Log.Error(ex);
            }
            finally
            {
                _checkConceal = false;
                _checkReveal  = false;
            }

            return(true);
        }
Example #20
0
        public override bool HandleCommand(ulong userId, string[] words)
        {
            if (!PluginSettings.Instance.DockingEnabled)
            {
                return(false);
            }

            if (words.Length < 1)
            {
                Communication.SendPrivateInformation(userId, GetHelp());
                return(true);
            }

            if (m_docking)
            {
                Communication.SendPrivateInformation(userId, "Server is busy");
                return(true);
            }

            m_docking = true;
            try
            {
                string pylonName = string.Join(" ", words);

                /*
                 * int timeLeft;
                 * if (Entity.CheckCoolDown(pylonName, out timeLeft))
                 * {
                 *      Communication.Message(String.Format("The docking zone '{0}' is on cooldown.  Please wait a {1} seconds before trying to dock/undock again.", pylonName, Math.Max(0, timeLeft)));
                 *      return;
                 * }
                 */

                if (PlayerMap.Instance.GetPlayerIdsFromSteamId(userId).Count < 1)
                {
                    Communication.SendPrivateInformation(userId, $"Unable to find player Id: {userId}");
                    return(true);
                }

                long playerId = PlayerMap.Instance.GetPlayerIdsFromSteamId(userId).First();

                Dictionary <string, List <IMyCubeBlock> > testList;
                List <IMyCubeBlock> beaconList;
                DockingZone.FindByName(pylonName, out testList, out beaconList, playerId);
                if (beaconList.Count == 4)
                {
                    // Check ownership
                    foreach (IMyCubeBlock entityBlock in beaconList)
                    {
                        IMyTerminalBlock terminal = (IMyTerminalBlock)entityBlock;
                        if (!terminal.HasPlayerAccess(playerId))
                        {
                            Communication.SendPrivateInformation(userId, $"You do not have permission to use '{pylonName}'.  You must either own all the beacons or they must be shared with faction.");
                            return(true);
                        }
                    }

                    // Check for bounding box intsection of other docking zones
                    int intersectElement = 0;
                    if (Entity.CheckForIntersection(testList, beaconList, out intersectElement))
                    {
                        Communication.SendPrivateInformation(userId, $"The docking zone '{pylonName}' intersects with docking zone '{testList.ElementAt( intersectElement ).Key}'.  Make sure you place your docking zones so they don't overlap.");
                        return(true);
                    }

                    // Check if ship already docked in this zone
                    IMyCubeBlock       e             = beaconList[0];
                    IMyCubeGrid        parent        = (IMyCubeGrid)e.Parent;
                    long[]             beaconListIds = beaconList.Select(b => b.EntityId).ToArray();
                    long               ownerId       = beaconList.First().OwnerId;
                    List <DockingItem> checkItems    = Docking.Instance.Find(d => d.PlayerId == ownerId && d.TargetEntityId == parent.EntityId && d.DockingBeaconIds.Intersect(beaconListIds).Count() == 4);
                    if (checkItems.Count >= PluginSettings.Instance.DockingShipsPerZone)
                    {
                        Communication.SendPrivateInformation(userId, $"Docking zone '{pylonName}' already contains the maximum capacity of ships.");
                        return(true);
                    }

                    // Figure out center of docking area, and other distance information
                    double   maxDistance = 99;
                    Vector3D vPos        = new Vector3D(0, 0, 0);

                    foreach (IMyCubeBlock b in beaconList)
                    {
                        Vector3D beaconPos = Entity.GetBlockEntityPosition(b);
                        vPos += beaconPos;
                    }

                    vPos = vPos / 4;
                    foreach (IMyCubeBlock b in beaconList)
                    {
                        Vector3D beaconPos = Entity.GetBlockEntityPosition(b);
                        maxDistance = Math.Min(maxDistance, Vector3D.Distance(vPos, beaconPos));
                    }

                    // Find ship in docking area
                    IMyCubeGrid         dockingEntity = null;
                    HashSet <IMyEntity> cubeGrids     = new HashSet <IMyEntity>();
                    Wrapper.GameAction(() =>
                    {
                        MyAPIGateway.Entities.GetEntities(cubeGrids, f => f is IMyCubeGrid);
                    });
                    foreach (IMyCubeGrid gridCheck in cubeGrids)
                    {
                        if (gridCheck.IsStatic || gridCheck == parent)
                        {
                            continue;
                        }

                        double distance = Vector3D.Distance(gridCheck.GetPosition(), vPos);
                        if (distance < maxDistance)
                        {
                            dockingEntity = gridCheck;
                            break;
                        }
                    }

                    // Figure out if the ship fits in docking area, and then save ship
                    if (dockingEntity != null)
                    {
                        // Get bounding box of both the docking zone and docking ship
                        OrientedBoundingBoxD targetBounding  = Entity.GetBoundingBox(beaconList);
                        OrientedBoundingBoxD dockingBounding = Entity.GetBoundingBox(dockingEntity);

                        // Make sure the docking zone contains the docking ship.  If they intersect or are disjointed, then fail
                        if (!Entity.GreaterThan(dockingBounding.HalfExtent * 2, targetBounding.HalfExtent * 2))
                        {
                            Communication.SendPrivateInformation(userId, $"The ship '{dockingEntity.DisplayName}' is too large for it's carrier.  The ship's bounding box must fit inside the docking zone bounding box!");
                            return(true);
                        }

                        if (targetBounding.Contains(ref dockingBounding) != ContainmentType.Contains)
                        {
                            Communication.SendPrivateInformation(userId, $"The ship '{dockingEntity.DisplayName}' is not fully inside the docking zone '{pylonName}'.  Make sure the ship is fully contained inside the docking zone");
                            return(true);
                        }

                        // Calculate the mass and ensure the docking ship is less than half the mass of the dock
                        float parentMass  = Entity.CalculateMass(parent);
                        float dockingMass = Entity.CalculateMass(dockingEntity);
                        if (dockingMass > parentMass)
                        {
                            Communication.SendPrivateInformation(userId, $"The ship you're trying to dock is too heavy for it's carrier.  The ship mass must be less than half the large ship / stations mass! (DM={dockingMass}kg CM={parentMass}kg)");
                            return(true);
                        }

                        // Check to see if the ship is piloted, if it is, error out.
                        // TODO: Check to see if we can get a real time copy of this entity?
                        List <IMySlimBlock> blocks = new List <IMySlimBlock>();
                        dockingEntity.GetBlocks(blocks, x => x.FatBlock is MyCockpit);
                        foreach (IMySlimBlock slim in blocks)
                        {
                            //MyObjectBuilder_Cockpit c = (MyObjectBuilder_Cockpit)slim.FatBlock.GetObjectBuilderCubeBlock();
                            var c = (MyShipController)slim.FatBlock;
                            if (c.Pilot != null)
                            {
                                Communication.SendPrivateInformation(userId, $"Ship in docking zone '{pylonName}' has a pilot!  Please exit the ship before trying to dock.  (Sometimes this can lag a bit.  Wait 10 seconds and try again)");
                                return(true);
                            }
                        }

                        // Save position and rotation information.  Some fun stuff here.
                        // Get our dock rotation as a quaternion
                        Quaternion saveQuat = Quaternion.CreateFromRotationMatrix(parent.WorldMatrix.GetOrientation());
                        // Transform docked ship's local position by inverse of the the parent (unwinds parent) and save it for when we undock
                        Vector3D savePos = Vector3D.Transform(dockingEntity.GetPosition() - parent.GetPosition(), Quaternion.Inverse(saveQuat));
                        // Get local rotation of dock ship, and save it for when we undock
                        saveQuat = Quaternion.Inverse(saveQuat) * Quaternion.CreateFromRotationMatrix(dockingEntity.WorldMatrix.GetOrientation());

                        // Save ship to file and remove
                        FileInfo info = new FileInfo(Path.Combine(Essentials.PluginPath, "Docking", $"docked_{ownerId}_{parent.EntityId}_{dockingEntity.EntityId}.sbc"));
                        if (!Directory.Exists(info.DirectoryName))
                        {
                            Directory.CreateDirectory(info.DirectoryName);
                        }
                        //CubeGridEntity dockingGrid = new CubeGridEntity((MyObjectBuilder_CubeGrid)dockingEntity.GetObjectBuilder(), dockingEntity);
                        MyObjectBuilder_CubeGrid gridBuilder = CubeGrids.SafeGetObjectBuilder(dockingEntity);
                        if (gridBuilder == null)
                        {
                            Communication.SendPrivateInformation(userId, $"Failed to load entity for export: {dockingEntity.DisplayName}");
                            return(true);
                        }

                        // Save item
                        DockingItem dockItem = new DockingItem
                        {
                            DockedEntityId   = dockingEntity.EntityId,
                            TargetEntityId   = parent.EntityId,
                            PlayerId         = ownerId,
                            DockingBeaconIds = beaconList.Select(s => s.EntityId).ToArray( ),
                            DockedName       = dockingEntity.DisplayName,
                            SavePos          = savePos,
                            SaveQuat         = saveQuat
                        };
                        Docking.Instance.Add(dockItem);

                        // Serialize and save ship to file
                        MyObjectBuilderSerializer.SerializeXML(info.FullName, false, gridBuilder);
                        Wrapper.BeginGameAction(() => dockingEntity.Close( ));

                        Communication.SendPrivateInformation(userId, $"Docked ship '{dockItem.DockedName}' in docking zone '{pylonName}'.");
                        Log.Info("Docked ship \"{0}\" in docking zone \"{1}\". Saved to {2}", dockItem.DockedName, pylonName, info.FullName);

                        /*
                         * // Add a cool down
                         * DockingCooldownItem cItem = new DockingCooldownItem();
                         * cItem.name = pylonName;
                         * cItem.startTime = DateTime.Now;
                         * PluginDocking.CooldownList.Add(cItem);
                         */
                    }
                    else
                    {
                        Communication.SendPrivateInformation(userId, $"No ships in docking zone '{pylonName}'.");
                    }
                }
                else if (beaconList.Count > 4)
                {
                    Communication.SendPrivateInformation(userId, $"Too many beacons with the name or another zone with the name '{pylonName}'.  Place only 4 beacons to create a zone or try a different zone name.");
                }
                else
                {
                    Communication.SendPrivateInformation(userId, string.Format("Can not locate docking zone '{0}'.  There must be 4 beacons with the name '{0}' to create a docking zone.  Beacons must be fully built!", pylonName));
                }

                return(true);
            }
            catch (SecurityException ex)
            {
                Log.Error("Can't access docked ship file.", ex);
                return(false);
            }
            catch (UnauthorizedAccessException ex)
            {
                Log.Error("Can't access docked ship file.", ex);
                return(false);
            }
            catch (DirectoryNotFoundException ex)
            {
                Log.Error("Directory does not exist", ex);
                return(false);
            }
            catch (IOException ex)
            {
                Log.Error(ex);
                return(false);
            }
            finally
            {
                m_docking = false;
            }
        }
        static public void RevealAll( )
        {
            HashSet <IMyEntity> entities = new HashSet <IMyEntity>( );

            Wrapper.GameAction(() =>
            {
                MyAPIGateway.Entities.GetEntities(entities);
            });

            List <MyObjectBuilder_EntityBase> addList = new List <MyObjectBuilder_EntityBase>( );
            int count = 0;

            Wrapper.GameAction(() =>
            {
                foreach (IMyEntity entity in entities)
                {
                    if (entity.InScene)
                    {
                        continue;
                    }

                    if (!(entity is IMyCubeGrid))
                    {
                        continue;
                    }

                    MyObjectBuilder_CubeGrid builder = CubeGrids.SafeGetObjectBuilder((IMyCubeGrid)entity);
                    if (builder == null)
                    {
                        continue;
                    }

                    count++;
                    IMyCubeGrid grid = (IMyCubeGrid)entity;
                    long ownerId     = 0;
                    string ownerName = "";
                    if (CubeGrids.GetBigOwners(builder).Count > 0)
                    {
                        ownerId   = CubeGrids.GetBigOwners(builder).First( );
                        ownerName = PlayerMap.Instance.GetPlayerItemFromPlayerId(ownerId).Name;
                    }

                    //grid.PersistentFlags = (MyPersistentEntityFlags2.InScene | MyPersistentEntityFlags2.CastShadows);
                    //grid.InScene = true;
                    //grid.CastShadows = true;
                    builder.PersistentFlags = (MyPersistentEntityFlags2.InScene | MyPersistentEntityFlags2.CastShadows);
                    MyAPIGateway.Entities.RemapObjectBuilder(builder);
                    if (PluginSettings.Instance.DynamicShowMessages)
                    {
                        Essentials.Log.Info("Force Revealing - Id: {0} -> {4} Display: {1} OwnerId: {2} OwnerName: {3}", entity.EntityId, entity.DisplayName.Replace("\r", "").Replace("\n", ""), ownerId, ownerName, builder.EntityId);
                    }

                    IMyEntity newEntity = MyAPIGateway.Entities.CreateFromObjectBuilder(builder);
                    if (newEntity == null)
                    {
                        Essentials.Log.Warn("CreateFromObjectBuilder failed: {0}", builder.EntityId);
                        continue;
                    }
                    //these methods no longer exist.
                    //KEEEEEEEEN!

                    //BaseEntityNetworkManager.BroadcastRemoveEntity( entity, false );

                    /*
                     *                  MyAPIGateway.Entities.AddEntity( newEntity );
                     *                  addList.Add( newEntity.GetObjectBuilder( ) );
                     *                  MyAPIGateway.Multiplayer.SendEntitiesCreated( addList );
                     *                  addList.Clear( );
                     */
                    MyAPIGateway.Entities.CreateFromObjectBuilderAndAdd(newEntity.GetObjectBuilder());
                }
            });
            if (PluginSettings.Instance.DynamicShowMessages)
            {
                Essentials.Log.Info("Revealed {0} grids", count);
            }
        }
Example #22
0
        static public void RevealAll()
        {
            HashSet <IMyEntity> entities = new HashSet <IMyEntity>();

            Wrapper.GameAction(() =>
            {
                MyAPIGateway.Entities.GetEntities(entities);
            });

            List <MyObjectBuilder_EntityBase> addList = new List <MyObjectBuilder_EntityBase>();
            int count = 0;

            Wrapper.GameAction(() =>
            {
                foreach (IMyEntity entity in entities)
                {
                    if (entity.InScene)
                    {
                        continue;
                    }

                    if (!(entity is IMyCubeGrid))
                    {
                        continue;
                    }

                    MyObjectBuilder_CubeGrid builder = CubeGrids.SafeGetObjectBuilder((IMyCubeGrid)entity);
                    if (builder == null)
                    {
                        continue;
                    }

                    count++;
                    IMyCubeGrid grid = (IMyCubeGrid)entity;
                    long ownerId     = 0;
                    string ownerName = "";
                    if (CubeGrids.GetBigOwners(builder).Count > 0)
                    {
                        ownerId   = CubeGrids.GetBigOwners(builder).First();
                        ownerName = PlayerMap.Instance.GetPlayerItemFromPlayerId(ownerId).Name;
                    }

                    //grid.PersistentFlags = (MyPersistentEntityFlags2.InScene | MyPersistentEntityFlags2.CastShadows);
                    //grid.InScene = true;
                    //grid.CastShadows = true;
                    builder.PersistentFlags = (MyPersistentEntityFlags2.InScene | MyPersistentEntityFlags2.CastShadows);
                    MyAPIGateway.Entities.RemapObjectBuilder(builder);
                    Logging.WriteLineAndConsole("Conceal", string.Format("Force Revealing - Id: {0} -> {4} Display: {1} OwnerId: {2} OwnerName: {3}", entity.EntityId, entity.DisplayName.Replace("\r", "").Replace("\n", ""), ownerId, ownerName, builder.EntityId));

                    IMyEntity newEntity = MyAPIGateway.Entities.CreateFromObjectBuilder(builder);
                    if (newEntity == null)
                    {
                        Logging.WriteLineAndConsole("Conceal", string.Format("Issue - CreateFromObjectBuilder failed: {0}", newEntity.EntityId));
                        continue;
                    }

                    BaseEntityNetworkManager.BroadcastRemoveEntity(entity, false);
                    MyAPIGateway.Entities.AddEntity(newEntity, true);
                    addList.Add(newEntity.GetObjectBuilder());
                    MyAPIGateway.Multiplayer.SendEntitiesCreated(addList);
                    addList.Clear();
                }
            });

            Logging.WriteLineAndConsole(string.Format("Revealed {0} grids", count));
        }
Example #23
0
        public static bool ToggleMedbayGrids(ulong steamId)
        {
            if (_checkConceal || _checkReveal)
            {
                Communication.SendPrivateInformation(steamId, "Server busy");
                return(false);
            }

            _checkConceal = true;
            _checkReveal  = true;
            try
            {
                DateTime start = DateTime.Now;

                // Toggle off
                HashSet <IMyEntity> entities      = new HashSet <IMyEntity>();
                HashSet <IMyEntity> entitiesFound = new HashSet <IMyEntity>();

                try
                {
                    MyAPIGateway.Entities.GetEntities(entities);
                }
                catch
                {
                    Logging.WriteLineAndConsole("CheckAndConcealEntities(): Error getting entity list, skipping check");
                    return(false);
                }

                CubeGrids.GetGridsUnconnected(entitiesFound, entities);

                HashSet <IMyEntity> entitiesToConceal = new HashSet <IMyEntity>();
                foreach (IMyEntity entity in entitiesFound)
                {
                    if (!(entity is IMyCubeGrid))
                    {
                        continue;
                    }

                    if (entity.DisplayName.Contains("CommRelay"))
                    {
                        continue;
                    }

                    if (!entity.InScene)
                    {
                        continue;
                    }

                    if (((IMyCubeGrid)entity).GridSizeEnum != MyCubeSize.Small && !PluginSettings.Instance.ConcealIncludeLargeGrids)
                    {
                        continue;
                    }

                    IMyCubeGrid grid     = (IMyCubeGrid)entity;
                    long        playerId = PlayerMap.Instance.GetFastPlayerIdFromSteamId(steamId);
                    if (!grid.BigOwners.Contains(playerId) && !grid.SmallOwners.Contains(playerId))
                    {
                        continue;
                    }

                    bool found = false;
                    // Check to see if grid is close to dock / shipyard
                    foreach (IMyCubeGrid checkGrid in ProcessDockingZone.ZoneCache)
                    {
                        try
                        {
                            if (Vector3D.Distance(checkGrid.GetPosition(), grid.GetPosition()) < 100d)
                            {
                                found = true;
                                break;
                            }
                        }
                        catch
                        {
                            continue;
                        }
                    }

                    if (!found)
                    {
                        // Check for block type rules
                    }

                    if (!found)
                    {
                        entitiesToConceal.Add(entity);
                    }
                }

                if (entitiesToConceal.Count > 0)
                {
                    //if (PluginSettings.Instance.DynamicClientConcealEnabled)
                    //{
                    //ClientEntityManagement.Refresh(steamId);
                    //}

                    Communication.SendClientMessage(steamId, string.Format("/conceal {0}", string.Join(",", entitiesToConceal.Select(x => x.EntityId.ToString() + ":" + ((MyObjectBuilder_CubeGrid)x.GetObjectBuilder()).CubeBlocks.Count.ToString() + ":" + x.DisplayName).ToArray())));
                    Thread.Sleep(1500);
                    ConcealEntities(entitiesToConceal);
                    //CheckAndRevealEntities();
                }

                if ((DateTime.Now - start).TotalMilliseconds > 2000)
                {
                    Logging.WriteLineAndConsole(string.Format("Completed Toggle: {0}ms", (DateTime.Now - start).TotalMilliseconds));
                }
            }
            catch (Exception ex)
            {
                Logging.WriteLineAndConsole(string.Format("CheckAndConceal(): {0}", ex.ToString()));
            }
            finally
            {
                _checkConceal = false;
                _checkReveal  = false;
            }

            return(true);
        }
Example #24
0
        private static void ConcealEntity(IMyEntity entity)
        {
            int pos = 0;

            try
            {
                if (!entity.InScene)
                {
                    return;
                }

                MyObjectBuilder_CubeGrid builder = CubeGrids.SafeGetObjectBuilder((IMyCubeGrid)entity);
                if (builder == null)
                {
                    return;
                }

                pos = 1;
                IMyCubeGrid grid      = (IMyCubeGrid)entity;
                long        ownerId   = 0;
                string      ownerName = "";
                if (CubeGrids.GetOwner(builder, out ownerId))
                {
                    //ownerId = grid.BigOwners.First();
                    ownerName = PlayerMap.Instance.GetPlayerItemFromPlayerId(ownerId).Name;
                }

                pos = 2;
                if (entity.Physics != null)
                {
                    entity.Physics.LinearVelocity  = Vector3.Zero;
                    entity.Physics.AngularVelocity = Vector3.Zero;
                }

                /*
                 * entity.InScene = false;
                 * entity.CastShadows = false;
                 * entity.Visible = false;
                 */

                builder.PersistentFlags = MyPersistentEntityFlags2.None;
                MyAPIGateway.Entities.RemapObjectBuilder(builder);

                pos = 3;
                if (RemovedGrids.Contains(entity.EntityId))
                {
                    Logging.WriteLineAndConsole("Conceal", string.Format("Concealing - Id: {0} DUPE FOUND - Display: {1} OwnerId: {2} OwnerName: {3}", entity.EntityId, entity.DisplayName, ownerId, ownerName, builder.EntityId));
                    BaseEntityNetworkManager.BroadcastRemoveEntity(entity, false);
                }
                else
                {
                    if (!PluginSettings.Instance.DynamicConcealServerOnly)
                    {
                        /*
                         * if (PluginSettings.Instance.DynamicBlockManagementEnabled)
                         * {
                         *      bool enable = false;
                         *      lock (BlockManagement.Instance.GridDisabled)
                         *      {
                         *              if(BlockManagement.Instance.GridDisabled.Contains(entity.EntityId))
                         *                      enable = true;
                         *      }
                         *
                         *      if(enable)
                         *              BlockManagement.Instance.EnableGrid((IMyCubeGrid)entity);
                         * }
                         */
                        IMyEntity newEntity = MyAPIGateway.Entities.CreateFromObjectBuilder(builder);
                        Logging.WriteLineAndConsole("Conceal", string.Format("Start Concealing - Id: {0} -> {4} Display: {1} OwnerId: {2} OwnerName: {3}", entity.EntityId, entity.DisplayName, ownerId, ownerName, newEntity.EntityId));
                        if (newEntity == null)
                        {
                            Logging.WriteLineAndConsole("Conceal", string.Format("Issue - CreateFromObjectBuilder failed: {0}", newEntity.EntityId));
                            return;
                        }

                        RemovedGrids.Add(entity.EntityId);
                        BaseEntityNetworkManager.BroadcastRemoveEntity(entity, false);
                        MyAPIGateway.Entities.AddEntity(newEntity, false);
                        Logging.WriteLineAndConsole("Conceal", string.Format("End Concealing - Id: {0} -> {4} Display: {1} OwnerId: {2} OwnerName: {3}", entity.EntityId, entity.DisplayName, ownerId, ownerName, newEntity.EntityId));
                    }
                    else
                    {
                        Logging.WriteLineAndConsole("Conceal", string.Format("Start Concealing - Id: {0} -> {4} Display: {1} OwnerId: {2} OwnerName: {3}", entity.EntityId, entity.DisplayName, ownerId, ownerName, builder.EntityId));
                        entity.InScene = false;
                        Logging.WriteLineAndConsole("Conceal", string.Format("End Concealing - Id: {0} -> {4} Display: {1} OwnerId: {2} OwnerName: {3}", entity.EntityId, entity.DisplayName, ownerId, ownerName, builder.EntityId));
                    }
                }
            }
            catch (Exception ex)
            {
                Logging.WriteLineAndConsole(string.Format("ConcealEntity({1}): {0}", ex.ToString(), pos));
            }
        }
Example #25
0
        private static void RevealEntity(KeyValuePair <IMyEntity, string> item)
        {
            IMyEntity entity = item.Key;
            string    reason = item.Value;
            //Wrapper.GameAction(() =>
            //{
            MyObjectBuilder_CubeGrid builder = CubeGrids.SafeGetObjectBuilder((IMyCubeGrid)entity);

            if (builder == null)
            {
                return;
            }

            IMyCubeGrid grid      = (IMyCubeGrid)entity;
            long        ownerId   = 0;
            string      ownerName = "";

            if (CubeGrids.GetBigOwners(builder).Count > 0)
            {
                ownerId   = CubeGrids.GetBigOwners(builder).First();
                ownerName = PlayerMap.Instance.GetPlayerItemFromPlayerId(ownerId).Name;
            }

            /*
             * entity.InScene = true;
             * entity.CastShadows = true;
             * entity.Visible = true;
             */

            builder.PersistentFlags = (MyPersistentEntityFlags2.InScene | MyPersistentEntityFlags2.CastShadows);
            MyAPIGateway.Entities.RemapObjectBuilder(builder);
            //builder.EntityId = 0;

            if (RemovedGrids.Contains(entity.EntityId))
            {
                Logging.WriteLineAndConsole("Conceal", string.Format("Revealing - Id: {0} DUPE FOUND Display: {1} OwnerId: {2} OwnerName: {3}  Reason: {4}", entity.EntityId, entity.DisplayName.Replace("\r", "").Replace("\n", ""), ownerId, ownerName, reason));
                BaseEntityNetworkManager.BroadcastRemoveEntity(entity, false);
            }
            else
            {
                if (!PluginSettings.Instance.DynamicConcealServerOnly)
                {
                    IMyEntity newEntity = MyAPIGateway.Entities.CreateFromObjectBuilder(builder);
                    Logging.WriteLineAndConsole("Conceal", string.Format("Start Revealing - Id: {0} -> {4} Display: {1} OwnerId: {2} OwnerName: {3}  Reason: {5}", entity.EntityId, entity.DisplayName.Replace("\r", "").Replace("\n", ""), ownerId, ownerName, newEntity.EntityId, reason));
                    if (newEntity == null)
                    {
                        Logging.WriteLineAndConsole("Conceal", string.Format("Issue - CreateFromObjectBuilder failed: {0}", newEntity.EntityId));
                        return;
                    }

                    RemovedGrids.Add(entity.EntityId);
                    BaseEntityNetworkManager.BroadcastRemoveEntity(entity, false);
                    MyAPIGateway.Entities.AddEntity(newEntity, true);

                    /*CC
                     * if (PluginSettings.Instance.DynamicClientConcealEnabled)
                     * {
                     *      ClientEntityManagement.AddEntityState(newEntity.EntityId);
                     * }
                     */

                    builder.EntityId = newEntity.EntityId;
                    List <MyObjectBuilder_EntityBase> addList = new List <MyObjectBuilder_EntityBase>();
                    addList.Add(newEntity.GetObjectBuilder());
                    MyAPIGateway.Multiplayer.SendEntitiesCreated(addList);
                    Logging.WriteLineAndConsole("Conceal", string.Format("End Revealing - Id: {0} -> {4} Display: {1} OwnerId: {2} OwnerName: {3}  Reason: {5}", entity.EntityId, entity.DisplayName.Replace("\r", "").Replace("\n", ""), ownerId, ownerName, newEntity.EntityId, reason));
                }
                else
                {
                    Logging.WriteLineAndConsole("Conceal", string.Format("Start Revealing - Id: {0} -> {4} Display: {1} OwnerId: {2} OwnerName: {3}  Reason: {4}", entity.EntityId, entity.DisplayName.Replace("\r", "").Replace("\n", ""), ownerId, ownerName, reason));
                    entity.InScene = true;
                    // Send to users, client will remove if doesn't need - this solves login problem

                    /*CC
                     * if (PluginSettings.Instance.DynamicClientConcealEnabled)
                     * {
                     *      ClientEntityManagement.AddEntityState(entity.EntityId);
                     *      List<MyObjectBuilder_EntityBase> addList = new List<MyObjectBuilder_EntityBase>();
                     *      addList.Add(entity.GetObjectBuilder());
                     * MyAPIGateway.Multiplayer.SendEntitiesCreated(addList);
                     * }
                     */
                    Logging.WriteLineAndConsole("Conceal", string.Format("End Revealing - Id: {0} -> {4} Display: {1} OwnerId: {2} OwnerName: {3}  Reason: {4}", entity.EntityId, entity.DisplayName.Replace("\r", "").Replace("\n", ""), ownerId, ownerName, reason));
                }
            }
            //});
        }
Example #26
0
        public static void CheckAndConcealEntities()
        {
            if (_checkConceal)
            {
                return;
            }

            _checkConceal = true;
            try
            {
                DateTime start      = DateTime.Now;
                double   distCheck  = 0d;
                double   blockRules = 0d;
                double   getGrids   = 0d;
                double   co         = 0f;

                ProcessedGrids.Clear();
                List <IMyPlayer>    players          = new List <IMyPlayer>();
                HashSet <IMyEntity> entities         = new HashSet <IMyEntity>();
                HashSet <IMyEntity> entitiesFiltered = new HashSet <IMyEntity>();
                HashSet <IMyEntity> entitiesFound    = new HashSet <IMyEntity>();

                try
                {
                    MyAPIGateway.Players.GetPlayers(players);
                }
                catch (Exception ex)
                {
                    Logging.WriteLineAndConsole(string.Format("Error getting players list.  Check and Conceal failed: {0}", ex.ToString()));
                    return;
                }

                try
                {
                    MyAPIGateway.Entities.GetEntities(entities);
                }
                catch
                {
                    Logging.WriteLineAndConsole("CheckAndConcealEntities(): Error getting entity list, skipping check");
                    return;
                }

                foreach (IMyEntity entity in entities)
                {
                    if (!(entity is IMyCubeGrid))
                    {
                        continue;
                    }

                    if (!entity.InScene)
                    {
                        continue;
                    }

                    entitiesFiltered.Add(entity);
                }

                DateTime getGridsStart = DateTime.Now;
                CubeGrids.GetGridsUnconnected(entitiesFound, entitiesFiltered);
                getGrids += (DateTime.Now - getGridsStart).TotalMilliseconds;

                HashSet <IMyEntity> entitiesToConceal = new HashSet <IMyEntity>();
                foreach (IMyEntity entity in entitiesFound)
                {
                    if (!(entity is IMyCubeGrid))
                    {
                        continue;
                    }

                    if (entity.DisplayName.Contains("CommRelay"))
                    {
                        continue;
                    }

                    if (entity.Physics == null)                     // Projection
                    {
                        continue;
                    }

                    if (!entity.InScene)
                    {
                        continue;
                    }

                    if (((IMyCubeGrid)entity).GridSizeEnum != MyCubeSize.Small && !PluginSettings.Instance.ConcealIncludeLargeGrids)
                    {
                        continue;
                    }

                    IMyCubeGrid grid = (IMyCubeGrid)entity;

                    bool     found     = false;
                    DateTime distStart = DateTime.Now;
                    foreach (IMyPlayer player in players)
                    {
                        double distance = 0f;
                        if (Entity.GetDistanceBetweenGridAndPlayer(grid, player, out distance))
                        {
                            if (distance < PluginSettings.Instance.DynamicConcealDistance)
                            {
                                found = true;
                            }
                        }
                    }
                    distCheck += (DateTime.Now - distStart).TotalMilliseconds;

                    if (!found)
                    {
                        // Check to see if grid is close to dock / shipyard
                        foreach (IMyCubeGrid checkGrid in ProcessDockingZone.ZoneCache)
                        {
                            try
                            {
                                if (Vector3D.Distance(checkGrid.GetPosition(), grid.GetPosition()) < 100d)
                                {
                                    found = true;
                                    break;
                                }
                            }
                            catch
                            {
                                continue;
                            }
                        }
                    }

                    if (!found)
                    {
                        // Check for block type rules
                        DateTime blockStart = DateTime.Now;
                        if (CheckConcealBlockRules(grid, players))
                        {
                            found = true;
                        }

                        blockRules += (DateTime.Now - blockStart).TotalMilliseconds;
                    }

                    if (!found)
                    {
                        entitiesToConceal.Add(entity);
                    }
                }

                DateTime coStart = DateTime.Now;
                if (entitiesToConceal.Count > 0)
                {
                    ConcealEntities(entitiesToConceal);
                }
                co += (DateTime.Now - coStart).TotalMilliseconds;

                if ((DateTime.Now - start).TotalMilliseconds > 2000)
                {
                    Logging.WriteLineAndConsole(string.Format("Completed Conceal Check: {0}ms (gg: {3}, dc: {2} ms, br: {1}ms, co: {4}ms)", (DateTime.Now - start).TotalMilliseconds, blockRules, distCheck, getGrids, co));
                }
            }
            catch (Exception ex)
            {
                Logging.WriteLineAndConsole(string.Format("CheckAndConceal(): {0}", ex.ToString()));
            }
            finally
            {
                _checkConceal = false;
            }
        }
        // admin deletearea x y z radius
        public override bool HandleCommand(ulong userId, string command)
        {
            string[] words = command.Split(' ');
            if (words.Length > 3)
            {
                return(false);
            }

            if (!words.Any())
            {
                Communication.SendPrivateInformation(userId, GetHelp());
                return(true);
            }

            int days = -1;

            if (!int.TryParse(words[0], out days) || days < 0)
            {
                Communication.SendPrivateInformation(userId, string.Format("Invalid argument.  Days argument must be an integer that is 0 or greater."));
                return(true);
            }

            // Just assume that anything after the days is going to "ignorenologin"
            bool removeNoLoginInformation = true;
            bool removeOwnerless          = true;

            if (words.Count() > 1)
            {
                foreach (string word in words)
                {
                    if (word.ToLower() == "ignorenologin")
                    {
                        removeNoLoginInformation = false;
                    }
                    if (word.ToLower() == "ignoreownerless")
                    {
                        removeOwnerless = false;
                    }
                }
            }

            Communication.SendPrivateInformation(userId, string.Format("Scanning for grids with owners that haven't logged in {0} days.  (Must Have Login Info={1})", days, removeNoLoginInformation));

            HashSet <IMyEntity> entities = new HashSet <IMyEntity>();

            Wrapper.GameAction(() =>
            {
                MyAPIGateway.Entities.GetEntities(entities, x => x is IMyCubeGrid);
            });

            HashSet <IMyEntity> entitiesFound = new HashSet <IMyEntity>();

            foreach (IMyEntity entity in entities)
            {
                if (!(entity is IMyCubeGrid))
                {
                    continue;
                }

                IMyCubeGrid              grid        = (IMyCubeGrid)entity;
                CubeGridEntity           gridEntity  = (CubeGridEntity)GameEntityManager.GetEntity(grid.EntityId);
                MyObjectBuilder_CubeGrid gridBuilder = CubeGrids.SafeGetObjectBuilder(grid);
                if (gridBuilder == null)
                {
                    continue;
                }

                // This entity is protected by whitelist
                if (PluginSettings.Instance.LoginEntityWhitelist.Length > 0 && PluginSettings.Instance.LoginEntityWhitelist.Contains(grid.EntityId.ToString()))
                {
                    continue;
                }

                if (CubeGrids.GetAllOwners(gridBuilder).Count < 1 && removeOwnerless)
                {
                    Communication.SendPrivateInformation(userId, string.Format("Found entity '{0}' ({1}) not owned by anyone.", gridEntity.Name, entity.EntityId));
                    entitiesFound.Add(entity);
                    continue;
                }

                foreach (long player in CubeGrids.GetBigOwners(gridBuilder))
                {
                    // This playerId is protected by whitelist
                    if (PluginSettings.Instance.LoginPlayerIdWhitelist.Length > 0 && PluginSettings.Instance.LoginPlayerIdWhitelist.Contains(player.ToString()))
                    {
                        continue;
                    }

                    MyObjectBuilder_Checkpoint.PlayerItem checkItem = PlayerMap.Instance.GetPlayerItemFromPlayerId(player);
                    if (checkItem.IsDead || checkItem.Name == "")
                    {
                        Communication.SendPrivateInformation(userId, string.Format("Found entity '{0}' ({1}) owned by dead player - ID: {2}", gridEntity.Name, entity.EntityId, player));
                        entitiesFound.Add(entity);
                        continue;
                    }

                    PlayerItem item = Players.Instance.GetPlayerById(player);
                    if (item == null)
                    {
                        if (removeNoLoginInformation)
                        {
                            Communication.SendPrivateInformation(userId, string.Format("Found entity '{0}' ({1}) owned by a player with no login info: {2}", gridEntity.Name, entity.EntityId, checkItem.Name));
                            entitiesFound.Add(entity);
                        }
                    }
                    else if (item.LastLogin < DateTime.Now.AddDays(days * -1))
                    {
                        Communication.SendPrivateInformation(userId, string.Format("Found entity '{0}' ({1}) owned by inactive player: {2}", gridEntity.Name, entity.EntityId, PlayerMap.Instance.GetPlayerItemFromPlayerId(player).Name));
                        entitiesFound.Add(entity);
                    }
                }
            }

            Communication.SendPrivateInformation(userId, string.Format("Found {0} grids owned by inactive users", entitiesFound.Count));

            foreach (IMyEntity entity in entitiesFound)
            {
                if (!(entity is IMyCubeGrid))
                {
                    continue;
                }

                CubeGridEntity gridEntity = new CubeGridEntity((MyObjectBuilder_CubeGrid)entity.GetObjectBuilder(), entity);
                gridEntity.Dispose();
            }

            Communication.SendPrivateInformation(userId, string.Format("Removed {0} grids owned by inactive users", entitiesFound.Count));
            return(true);
        }
Example #28
0
 // admin nobeacon scan
 public override bool HandleCommand(ulong userId, string[] words)
 {
     CubeGrids.ScanCleanup(userId, words);
     return(true);
 }
        // admin deletearea x y z radius
        public override bool HandleCommand(ulong userId, string[] words)
        {
            HashSet <IMyEntity> entities          = new HashSet <IMyEntity>();
            HashSet <IMyEntity> entitiesToConfirm = new HashSet <IMyEntity>();
            HashSet <IMyEntity> entitiesConnected = new HashSet <IMyEntity>();
            HashSet <IMyEntity> entitiesFound     = new HashSet <IMyEntity>();

            Wrapper.GameAction(() =>
            {
                MyAPIGateway.Entities.GetEntities(entities, x => x is IMyCubeGrid);
            });

            foreach (IMyEntity entity in entities)
            {
                if (!(entity is IMyCubeGrid))
                {
                    continue;
                }

                IMyCubeGrid grid = (IMyCubeGrid)entity;
                MyObjectBuilder_CubeGrid gridBuilder = CubeGrids.SafeGetObjectBuilder(grid);
                if (gridBuilder == null)
                {
                    continue;
                }

                bool found = false;
                foreach (MyObjectBuilder_CubeBlock block in gridBuilder.CubeBlocks)
                {
                    if (block.TypeId == typeof(MyObjectBuilder_Beacon))
                    {
                        found = true;
                        break;
                    }
                }

                if (!found)
                {
                    entitiesToConfirm.Add(grid);
                }
            }

            CubeGrids.GetGridsUnconnected(entitiesFound, entitiesToConfirm);

            foreach (IMyEntity entity in entitiesFound)
            {
                CubeGridEntity gridEntity = (CubeGridEntity)GameEntityManager.GetEntity(entity.EntityId);
                if (gridEntity == null)
                {
                    Log.Info("A found entity gridEntity was null!");
                    continue;
                }
                Communication.SendPrivateInformation(userId, string.Format("Found entity '{0}' ({1}) at {2} with no beacon.", gridEntity.Name, entity.EntityId, General.Vector3DToString(entity.GetPosition())));
            }

            for (int r = entitiesFound.Count - 1; r >= 0; r--)
            {
                //MyAPIGateway.Entities.RemoveEntity(entity);
                IMyEntity      entity     = entitiesFound.ElementAt(r);
                CubeGridEntity gridEntity = new CubeGridEntity((MyObjectBuilder_CubeGrid)entity.GetObjectBuilder(), entity);
                gridEntity.Dispose();
            }

            Communication.SendPrivateInformation(userId, string.Format("Removed {0} grids with no beacons", entitiesFound.Count));

            return(true);
        }
Example #30
0
        public override bool HandleCommand(ulong userId, string[] words)
        {
            bool showConcealed = true;

            if (words.Length > 0 && words[0].ToLower() == "revealed")
            {
                showConcealed = false;
            }

            if (showConcealed)
            {
                HashSet <IMyEntity> entities = new HashSet <IMyEntity>();
                Wrapper.GameAction(() =>
                {
                    MyAPIGateway.Entities.GetEntities(entities);
                });

                Communication.SendPrivateInformation(userId, "==== Concealed Entities ===");
                int count = 0;
                foreach (IMyEntity entity in entities)
                {
                    if (!(entity is IMyCubeGrid))
                    {
                        continue;
                    }

                    if (entity.InScene)
                    {
                        continue;
                    }

                    IMyCubeGrid grid      = (IMyCubeGrid)entity;
                    long        ownerId   = 0;
                    string      ownerName = "";
                    if (grid.BigOwners.Count > 0)
                    {
                        ownerId   = grid.BigOwners.First();
                        ownerName = PlayerMap.Instance.GetPlayerItemFromPlayerId(ownerId).Name;
                    }

                    if (ownerName == "")
                    {
                        ownerName = "No one";
                    }

                    Communication.SendPrivateInformation(userId, string.Format("Id: {0} Display: {1} OwnerId: {2} OwnerName: {3} Position: {4}", entity.EntityId, entity.DisplayName, ownerId, ownerName, General.Vector3DToString(entity.GetPosition())));
                    count++;
                }

                Communication.SendPrivateInformation(userId, string.Format("Total concealed entities: {0}", count));
            }
            else
            {
                HashSet <IMyEntity> entities = new HashSet <IMyEntity>();
                Wrapper.GameAction(() =>
                {
                    MyAPIGateway.Entities.GetEntities(entities);
                });

                Communication.SendPrivateInformation(userId, "==== Revealed Entities ===");
                Communication.SendPrivateInformation(userId, "==== Unconnected Entities ===");
                HashSet <IMyEntity> entitiesFound = new HashSet <IMyEntity>();
                CubeGrids.GetGridsUnconnected(entitiesFound, entities);
                int count = 0;
                List <IMySlimBlock> slimBlocks = new List <IMySlimBlock>();
                foreach (IMyEntity entity in entitiesFound)
                {
                    if (!(entity is IMyCubeGrid))
                    {
                        continue;
                    }

                    if (!entity.InScene)
                    {
                        continue;
                    }

                    IMyCubeGrid grid      = (IMyCubeGrid)entity;
                    long        ownerId   = 0;
                    string      ownerName = "";
                    if (grid.BigOwners.Count > 0)
                    {
                        ownerId   = grid.BigOwners.First();
                        ownerName = PlayerMap.Instance.GetPlayerItemFromPlayerId(ownerId).Name;
                    }

                    if (ownerName == "")
                    {
                        ownerName = "No one";
                    }

                    grid.GetBlocks(slimBlocks, null);
                    Communication.SendPrivateInformation(userId, string.Format("Id: {0} Display: {1} OwnerId: {2} OwnerName: {3} Position: {4} BlockCount: {5}", entity.EntityId, entity.DisplayName, ownerId, ownerName, General.Vector3DToString(entity.GetPosition()), slimBlocks.Count));
                    slimBlocks.Clear();
                    count++;
                }

                Communication.SendPrivateInformation(userId, string.Format("Total unconnected revealed entities: {0}", count));

                Communication.SendPrivateInformation(userId, "==== Connected Entities ===");
                HashSet <IMyEntity> connectedFound = new HashSet <IMyEntity>();
                CubeGrids.GetConnectedGrids(connectedFound);
                Console.WriteLine("Here: {0} : {1} {2}", connectedFound.Intersect(entitiesFound).Count(), entitiesFound.Count, connectedFound.Count);
                count = 0;
                slimBlocks.Clear();
                foreach (IMyEntity entity in connectedFound)
                {
                    if (!(entity is IMyCubeGrid))
                    {
                        continue;
                    }

                    if (entitiesFound.Contains(entity))
                    {
                        continue;
                    }

                    if (!entity.InScene)
                    {
                        continue;
                    }

                    if (CubeGrids.GetRecursiveGridList((IMyCubeGrid)entity).Count < 2)
                    {
                        continue;
                    }

                    IMyCubeGrid grid      = (IMyCubeGrid)entity;
                    long        ownerId   = 0;
                    string      ownerName = "";
                    if (grid.BigOwners.Count > 0)
                    {
                        ownerId   = grid.BigOwners.First();
                        ownerName = PlayerMap.Instance.GetPlayerItemFromPlayerId(ownerId).Name;
                    }

                    if (ownerName == "")
                    {
                        ownerName = "No one";
                    }

                    grid.GetBlocks(slimBlocks, null);
                    Communication.SendPrivateInformation(userId, string.Format("Id: {0} Display: {1} OwnerId: {2} OwnerName: {3} Position: {4} BlockCount: {5} Connections: {6}", entity.EntityId, entity.DisplayName, ownerId, ownerName, General.Vector3DToString(entity.GetPosition()), slimBlocks.Count, CubeGrids.GetRecursiveGridList(grid).Count));
                    //Communication.SendPrivateInformation(userId, string.Format("Id: {0} Display: {1} OwnerId: {2} OwnerName: {3} Position: {4} BlockCount: {5} Connections: {6}", entity.EntityId, entity.DisplayName, ownerId, ownerName, General.Vector3DToString(entity.GetPosition()), slimBlocks.Count));
                    slimBlocks.Clear();
                    count++;
                }

                Communication.SendPrivateInformation(userId, string.Format("Total connected revealed entities: {0}", count));
            }

            return(true);
        }