示例#1
0
        public static void FixIds()
        {
            if (!BlockLimiterConfig.Instance.EnableLimits)
            {
                return;
            }
            var blockCache = new HashSet <MySlimBlock>();

            GridCache.GetBlocks(blockCache);

            Task.Run(() =>
            {
                Parallel.ForEach(blockCache, block =>
                {
                    if (block == null || !block.BlockDefinition.ContainsComputer())
                    {
                        return;
                    }

                    if (block.OwnerId == block.BuiltBy)
                    {
                        return;
                    }
                    if (block.OwnerId == 0 && block.BuiltBy > 0)
                    {
                        block.FatBlock.ChangeBlockOwnerRequest(block.BuiltBy, MyOwnershipShareModeEnum.Faction);

                        return;
                    }

                    block.TransferAuthorship(block.OwnerId);
                });
            });
        }
示例#2
0
        public static void PlayerLimit(long id)
        {
            if (id == 0)
            {
                return;
            }
            var blockCache   = new HashSet <MySlimBlock>();
            var playerBlocks = new HashSet <MySlimBlock>();

            var faction = MySession.Static.Factions.GetPlayerFaction(id);

            GridCache.GetBlocks(blockCache);
            if (blockCache.Count == 0)
            {
                return;
            }

            playerBlocks.UnionWith(blockCache.Where(x => Block.IsOwner(x, id)));

            if (playerBlocks.Count == 0)
            {
                foreach (var limit in BlockLimiterConfig.Instance.AllLimits)
                {
                    limit.FoundEntities.Remove(id);
                }
                return;
            }

            foreach (var limit in BlockLimiterConfig.Instance.AllLimits)
            {
                Parallel.Invoke(() =>
                {
                    if (!limit.LimitPlayers ||
                        Utilities.IsExcepted(id, limit.Exceptions) ||
                        faction != null && Utilities.IsExcepted(faction.FactionId, limit.Exceptions))
                    {
                        limit.FoundEntities.Remove(id);
                        return;
                    }

                    var limitedBlocks = playerBlocks.Count(x =>
                                                           Block.IsMatch(x.BlockDefinition, limit));
                    if (limitedBlocks == 0)
                    {
                        limit.FoundEntities.Remove(id);
                        return;
                    }

                    limit.FoundEntities[id] = limitedBlocks;
                });
            }
        }
示例#3
0
        public static void SetClipboard(string text)
        {
            var blocks = new HashSet <MySlimBlock>();

            GridCache.GetBlocks(blocks);
            if (blocks.Count == 0)
            {
                return;
            }
            foreach (var block in blocks)
            {
                if (!(block.FatBlock is MyTerminalBlock tBlock))
                {
                    continue;
                }

                if (!tBlock.CustomName.ToString().Contains("Blocklimiter Clipboard", StringComparison.OrdinalIgnoreCase))
                {
                    continue;
                }
                tBlock.CustomData = text;
            }
        }
示例#4
0
        public static void FactionLimit(long id)
        {
            if (id == 0)
            {
                return;
            }
            var blockCache    = new HashSet <MySlimBlock>();
            var factionBlocks = new HashSet <MySlimBlock>();

            var faction = MySession.Static.Factions.TryGetFactionById(id);

            if (faction == null)
            {
                return;
            }

            GridCache.GetBlocks(blockCache);
            if (blockCache.Count == 0)
            {
                return;
            }

            factionBlocks.UnionWith(blockCache.Where(x => x.FatBlock?.GetOwnerFactionTag() == faction.Tag));

            if (factionBlocks.Count == 0)
            {
                return;
            }

            foreach (var limit in BlockLimiterConfig.Instance.AllLimits)
            {
                Parallel.Invoke(() =>
                {
                    if (!limit.LimitFaction || Utilities.IsExcepted(faction.FactionId, limit.Exceptions))
                    {
                        limit.FoundEntities.Remove(id);
                        return;
                    }
                    var factionBlockCount = factionBlocks.Count(x => Block.IsMatch(x.BlockDefinition, limit));

                    if (factionBlockCount == 0)
                    {
                        limit.FoundEntities.Remove(id);
                        return;
                    }
                    limit.FoundEntities[id] = factionBlockCount;
                });

                /*
                 * if (!limit.LimitFaction || Utilities.IsExcepted(faction.FactionId, limit.Exceptions))
                 * {
                 *  limit.FoundEntities.Remove(id);
                 *  continue;
                 * }
                 * var factionBlockCount = factionBlocks.Count(x => Block.IsMatch(x.BlockDefinition, limit));
                 *
                 * if (factionBlockCount == 0)
                 * {
                 *  limit.FoundEntities.Remove(id);
                 *  continue;
                 * }
                 * limit.FoundEntities[id] = factionBlockCount;
                 */
            }
        }