public static bool TryGetAimedBlock(IMyPlayer player, out MyTextPanel panel)
{
panel = null;
if (player == null)
{
return(false);
}
var character = ((MyCharacter)player.Character);
if (character == null)
{
return(false);
}
if (!GridCache.TryGetGridById(character.AimedGrid, out var aimedGrid))
{
return(false);
}
var aimedBlock = aimedGrid.GetCubeBlock(character.AimedBlock);
if (aimedBlock.FatBlock is MyTextPanel txtPanel && Block.IsOwner(aimedBlock, player.IdentityId))
{
panel = txtPanel;
}
return(panel != null);
}
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);
});
});
}
public static bool IsOwner(MyCubeGrid grid, long id)
{
if (grid == null || id == 0)
{
return(false);
}
return(GridCache.GetOwners(grid).Contains(id) || GridCache.GetBuilders(grid).Contains(id));
}
public static void IncreaseCount(MyCubeBlockDefinition def, long playerId, int amount = 1, long gridId = 0)
{
if (!BlockLimiterConfig.Instance.EnableLimits)
{
return;
}
var faction = MySession.Static.Factions.GetPlayerFaction(playerId);
foreach (var limit in Limits)
{
if (!limit.IsMatch(def))
{
continue;
}
var foundGrid = GridCache.TryGetGridById(gridId, out var grid);
if (foundGrid && !limit.IsGridType(grid))
{
limit.FoundEntities.Remove(gridId);
continue;
}
if (limit.IgnoreNpcs)
{
if (MySession.Static.Players.IdentityIsNpc(playerId))
{
continue;
}
if (foundGrid && MySession.Static.Players.IdentityIsNpc(GridCache.GetBuilders(grid).FirstOrDefault()))
{
continue;
}
}
if (limit.LimitPlayers && playerId > 0)
{
limit.FoundEntities.AddOrUpdate(playerId, amount, (l, i) => i + amount);
}
if (limit.LimitGrids && gridId > 0)
{
limit.FoundEntities.AddOrUpdate(gridId, amount, (l, i) => i + amount);
}
if (limit.LimitFaction && faction != null)
{
limit.FoundEntities.AddOrUpdate(faction.FactionId, amount, (l, i) => i + amount);
}
}
}
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;
});
}
}
public static bool FactionLimit(long id)
{
if (id == 0)
{
return(false);
}
var factionBlocks = new HashSet <MySlimBlock>();
var limits = BlockLimiterConfig.Instance.AllLimits;
GridCache.GetFactionBlocks(factionBlocks, id);
if (factionBlocks.Count == 0)
{
foreach (var limit in limits)
{
limit.FoundEntities.Remove(id);
}
return(false);
}
var faction = MySession.Static.Factions.TryGetFactionById(id);
if (faction == null)
{
return(false);
}
Parallel.ForEach(limits, limit =>
{
if (!limit.LimitFaction)
{
limit.FoundEntities.Remove(id);
return;
}
var factionBlockCount = factionBlocks.Count(x => limit.IsMatch(x.BlockDefinition));
if (factionBlockCount == 0)
{
limit.FoundEntities.Remove(id);
return;
}
limit.FoundEntities[id] = factionBlockCount;
});
return(true);
}
public static bool IsExcepted(long obj, List <string> exceptions)
{
var excepted = false;
var allExceptions = new HashSet <string>();
allExceptions.UnionWith(exceptions);
allExceptions.UnionWith(BlockLimiterConfig.Instance.GeneralException);
if (allExceptions.Contains(obj.ToString()))
{
return(true);
}
var faction = MySession.Static.Factions.TryGetFactionById(obj);
if (faction != null)
{
return(allExceptions.Contains(faction.Tag));
}
var id = MySession.Static.Players.TryGetIdentity(obj);
if (id != null)
{
var steamId = MySession.Static.Players.TryGetSteamId(obj);
return((allExceptions.Contains(id.DisplayName)) || steamId > 0 &&
allExceptions.Contains(steamId.ToString()));
}
if (!GridCache.TryGetGridById(obj, out var grid))
{
return(false);
}
if (allExceptions.Contains(grid.DisplayName))
{
excepted = true;
}
if (grid.BigOwners.Any(x => allExceptions.Contains(x.ToString())))
{
return(true);
}
return(excepted);
}
public static bool PlayerLimit(long id)
{
if (id == 0)
{
return(false);
}
var playerBlocks = new HashSet <MySlimBlock>();
GridCache.GetPlayerBlocks(playerBlocks, id);
var limits = BlockLimiterConfig.Instance.AllLimits;
if (limits?.Count == 0)
{
return(false);
}
if (playerBlocks.Count == 0)
{
foreach (var limit in BlockLimiterConfig.Instance.AllLimits)
{
limit.FoundEntities.Remove(id);
}
return(false);
}
Parallel.ForEach(BlockLimiterConfig.Instance.AllLimits, limit =>
{
if (!limit.LimitPlayers)
{
limit.FoundEntities.Remove(id);
return;
}
var limitedBlocks = playerBlocks.Count(x =>
limit.IsMatch(x.BlockDefinition));
if (limitedBlocks == 0)
{
limit.FoundEntities.Remove(id);
return;
}
limit.FoundEntities[id] = limitedBlocks;
});
return(true);
}
private static bool CountViolation(MyCubeSize size, long owner)
{
if (owner == 0)
{
return(false);
}
if (Utilities.IsExcepted(owner))
{
return(false);
}
var playerGrids = new HashSet <MyCubeGrid>();
GridCache.GetPlayerGrids(playerGrids, owner);
var smallGrids = playerGrids.Count(x => x.GridSizeEnum == MyCubeSize.Small && IsBiggestGridInGroup(x));
var largeGrids = playerGrids.Count(x => x.GridSizeEnum == MyCubeSize.Large && IsBiggestGridInGroup(x));
if (size == MyCubeSize.Large)
{
if (BlockLimiterConfig.Instance.MaxLargeGrids == 0)
{
return(false);
}
if (BlockLimiterConfig.Instance.MaxLargeGrids < 0)
{
return(true);
}
return(largeGrids >= BlockLimiterConfig.Instance.MaxLargeGrids);
}
if (BlockLimiterConfig.Instance.MaxSmallGrids == 0)
{
return(false);
}
if (BlockLimiterConfig.Instance.MaxSmallGrids < 0)
{
return(true);
}
return(smallGrids >= BlockLimiterConfig.Instance.MaxSmallGrids);
}
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;
}
}
public static StringBuilder GetLimit(long playerId)
{
var sb = new StringBuilder();
if (playerId == 0)
{
sb.AppendLine("Player not found");
return(sb);
}
var limitItems = BlockLimiterConfig.Instance.AllLimits;
if (limitItems.Count < 1)
{
sb.AppendLine("No limit found");
return(sb);
}
var playerFaction = MySession.Static.Factions.GetPlayerFaction(playerId);
foreach (var item in limitItems)
{
if (item.BlockList.Count == 0 || item.FoundEntities.Count == 0)
{
continue;
}
var itemName = string.IsNullOrEmpty(item.Name) ? item.BlockList.FirstOrDefault() : item.Name;
sb.AppendLine();
sb.AppendLine($"----->{itemName}<-----");
if (item.LimitPlayers && item.FoundEntities.TryGetValue(playerId, out var pCount))
{
if (pCount < 1)
{
continue;
}
sb.AppendLine($"Player Limit = {pCount}/{item.Limit}");
}
if (item.LimitFaction && playerFaction != null &&
item.FoundEntities.TryGetValue(playerFaction.FactionId, out var fCount))
{
if (fCount < 1)
{
continue;
}
sb.AppendLine($"Faction Limit = {fCount}/{item.Limit} ");
}
if (!item.LimitGrids || (!item.FoundEntities.Any(x =>
GridCache.TryGetGridById(x.Key, out var grid) && Grid.IsOwner(grid, playerId))))
{
continue;
}
sb.AppendLine("Grid Limits:");
foreach (var(id, gCount) in item.FoundEntities)
{
if (!GridCache.TryGetGridById(id, out var grid) || !Grid.IsOwner(grid, playerId))
{
continue;
}
if (gCount < 1)
{
continue;
}
sb.AppendLine($"->{grid.DisplayName} = {gCount} / {item.Limit}");
}
}
return(sb);
}
public static bool IsWithinLimits(MyCubeBlockDefinition def, long ownerId, long gridId, int count = 1)
{
if (def == null || Math.Abs(ownerId + gridId) < 1)
{
return(true);
}
var ownerFaction = MySession.Static.Factions.GetPlayerFaction(ownerId);
if (ownerId > 0 && Utilities.IsExcepted(ownerId, new List <string>()) || (ownerFaction != null && Utilities.IsExcepted(ownerFaction.FactionId, new List <string>())) ||
gridId > 0 && Utilities.IsExcepted(gridId, new List <string>()))
{
return(true);
}
var allow = true;
foreach (var item in BlockLimiterConfig.Instance.AllLimits)
{
if (!item.BlockList.Any() || !IsMatch(def, item))
{
continue;
}
if (ownerId > 0 && (Utilities.IsExcepted(ownerId, item.Exceptions) || ownerFaction != null && Utilities.IsExcepted(ownerFaction.FactionId, item.Exceptions) || gridId > 0 && Utilities.IsExcepted(gridId, item.Exceptions)))
{
continue;
}
if (item.Limit == 0 && (item.LimitGrids || item.LimitPlayers || item.LimitFaction))
{
return(false);
}
if (item.LimitGrids && gridId > 0 && item.FoundEntities.TryGetValue(gridId, out var gCount))
{
if (GridCache.TryGetGridById(gridId, out var grid) && Grid.IsGridType(grid, item))
{
if (gCount + count > item.Limit)
{
allow = false;
break;
}
}
}
if (ownerId > 0 && item.LimitPlayers && item.FoundEntities.TryGetValue(ownerId, out var pCount))
{
if (pCount + count > item.Limit)
{
allow = false;
break;
}
}
if (ownerFaction == null || !item.LimitFaction || !item.FoundEntities.TryGetValue(ownerFaction.FactionId, out var fCount))
{
continue;
}
{
if (fCount + count <= item.Limit)
{
continue;
}
allow = false;
break;
}
}
return(allow);
}
public static bool IsExcepted(object target, LimitItem limit = null)
{
if (target == null)
{
return(false);
}
HashSet <string> allExceptions = new HashSet <string>();
if (limit != null)
{
allExceptions = new HashSet <string>(limit.Exceptions);
}
allExceptions.UnionWith(BlockLimiterConfig.Instance.GeneralException);
if (allExceptions.Count == 0)
{
return(false);
}
MyIdentity identity = null;
MyFaction faction = null;
long identityId = 0;
ulong playerSteamId = 0;
string displayName = "";
HashSet <long> gridOwners = new HashSet <long>();
switch (target)
{
case HashSet <long> owners:
gridOwners.UnionWith(owners);
break;
case ulong steamId:
if (steamId == 0)
{
return(false);
}
playerSteamId = steamId;
identityId = GetPlayerIdFromSteamId(steamId);
identity = MySession.Static.Players.TryGetIdentity(identityId);
displayName = identity.DisplayName;
faction = MySession.Static.Factions.GetPlayerFaction(identityId);
break;
case string name:
if (allExceptions.Contains(name))
{
return(true);
}
if (TryGetPlayerByNameOrId(name, out identity))
{
identityId = identity.IdentityId;
faction = MySession.Static.Factions.GetPlayerFaction(identityId);
displayName = identity.DisplayName;
playerSteamId = GetSteamIdFromPlayerId(identityId);
}
break;
case long id:
if (id == 0)
{
return(false);
}
identityId = id;
identity = MySession.Static.Players.TryGetIdentity(id);
if (identity != null)
{
faction = MySession.Static.Factions.GetPlayerFaction(id);
displayName = identity.DisplayName;
playerSteamId = GetSteamIdFromPlayerId(id);
}
else
{
faction = (MyFaction)MySession.Static.Factions.TryGetFactionById(id);
}
if (MyEntities.TryGetEntityById(id, out var entity))
{
if (allExceptions.Contains(entity.DisplayName))
{
return(true);
}
}
if (GridCache.TryGetGridById(id, out var foundGrid))
{
gridOwners.UnionWith(GridCache.GetOwners(foundGrid));
if (allExceptions.Contains(foundGrid.DisplayName))
{
return(true);
}
}
break;
case MyFaction targetFaction:
if (allExceptions.Contains(targetFaction.Tag) ||
allExceptions.Contains(targetFaction.FactionId.ToString()))
{
return(true);
}
break;
case MyPlayer player:
playerSteamId = player.Character.ControlSteamId;
if (playerSteamId == 0)
{
return(false);
}
if (allExceptions.Contains(playerSteamId.ToString()))
{
return(true);
}
identityId = GetPlayerIdFromSteamId(playerSteamId);
if (identityId > 0)
{
if (allExceptions.Contains(identityId.ToString()))
{
return(true);
}
identity = MySession.Static.Players.TryGetIdentity(identityId);
displayName = identity.DisplayName;
}
break;
case MyCubeGrid grid:
{
if (allExceptions.Contains(grid.DisplayName) || allExceptions.Contains(grid.EntityId.ToString()))
{
return(true);
}
var owners = GridCache.GetOwners(grid);
if (owners.Count == 0)
{
break;
}
gridOwners.UnionWith(owners);
break;
}
}
foreach (var owner in gridOwners)
{
if (owner == 0)
{
continue;
}
if (allExceptions.Contains(owner.ToString()))
{
return(true);
}
identity = MySession.Static.Players.TryGetIdentity(owner);
playerSteamId = GetSteamIdFromPlayerId(owner);
if (playerSteamId > 0 && allExceptions.Contains(playerSteamId.ToString()))
{
return(true);
}
if (identity != null)
{
if (allExceptions.Contains(identity.DisplayName))
{
return(true);
}
}
faction = MySession.Static.Factions.GetPlayerFaction(owner);
if (faction != null && (allExceptions.Contains(faction.Tag) ||
allExceptions.Contains(faction.FactionId.ToString())))
{
return(true);
}
}
if (playerSteamId > 0 && allExceptions.Contains(playerSteamId.ToString()))
{
return(true);
}
if (identityId > 0 && allExceptions.Contains(identityId.ToString()))
{
return(true);
}
if (identity != null && allExceptions.Contains(identity.DisplayName))
{
return(true);
}
if (faction != null && (allExceptions.Contains(faction.Tag) || allExceptions.Contains(faction.FactionId.ToString())))
{
return(true);
}
if (!string.IsNullOrEmpty(displayName) && allExceptions.Contains(displayName))
{
return(true);
}
return(false);
}
public static bool CanMerge(MyCubeGrid grid1, MyCubeGrid grid2, out List <string> blocks, out int count, out string limitName)
{
limitName = null;
blocks = new List <string>();
count = 0;
if (grid1 == null || grid2 == null)
{
return(true);
}
if (Utilities.IsExcepted(GridCache.GetOwners(grid1)) ||
Utilities.IsExcepted(GridCache.GetOwners(grid2)))
{
return(true);
}
var blocksHash = new HashSet <MySlimBlock>(grid1.CubeBlocks);
blocksHash.UnionWith(grid2.CubeBlocks);
if (blocksHash.Count == 0)
{
return(true);
}
blocks.Add("All blocks - Size Violation");
var gridSize = grid1.CubeBlocks.Count + grid2.CubeBlocks.Count;
var gridType = grid1.GridSizeEnum;
var isStatic = grid1.IsStatic || grid2.IsStatic;
if (BlockLimiterConfig.Instance.MaxBlockSizeShips > 0 && !isStatic && gridSize >= BlockLimiterConfig.Instance.MaxBlockSizeShips)
{
count = Math.Abs(gridSize - BlockLimiterConfig.Instance.MaxBlockSizeShips);
limitName = "MaxBlockSizeShips";
return(false);
}
if (BlockLimiterConfig.Instance.MaxBlockSizeStations > 0 && isStatic && gridSize >= BlockLimiterConfig.Instance.MaxBlockSizeStations)
{
count = Math.Abs(gridSize - BlockLimiterConfig.Instance.MaxBlockSizeStations);
limitName = "MaxBlockSizeStations";
return(false);
}
if (BlockLimiterConfig.Instance.MaxBlocksLargeGrid > 0 && gridType == MyCubeSize.Large && gridSize >= BlockLimiterConfig.Instance.MaxBlocksLargeGrid)
{
count = Math.Abs(gridSize - BlockLimiterConfig.Instance.MaxBlocksLargeGrid);
limitName = "MaxBlocksLargeGrid";
return(false);
}
if (BlockLimiterConfig.Instance.MaxBlocksSmallGrid > 0 && gridType == MyCubeSize.Small && gridSize >= BlockLimiterConfig.Instance.MaxBlocksSmallGrid)
{
count = Math.Abs(gridSize - BlockLimiterConfig.Instance.MaxBlocksSmallGrid);
limitName = "MaxBlocksSmallGrid";
return(false);
}
blocks.Clear();
count = 0;
foreach (var limit in BlockLimiterConfig.Instance.AllLimits)
{
limitName = limit.Name;
if (!limit.LimitGrids)
{
continue;
}
if (Utilities.IsExcepted(grid1) || Utilities.IsExcepted(grid2))
{
continue;
}
var matchingBlocks = new List <MySlimBlock>(blocksHash.Where(x => limit.IsMatch(x.BlockDefinition)));
if (matchingBlocks.Count <= limit.Limit)
{
continue;
}
count = Math.Abs(matchingBlocks.Count - limit.Limit);
blocks.Add(matchingBlocks[0].BlockDefinition.ToString().Substring(16));
return(false);
}
return(true);
}
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;
*/
}
}
public static bool IsWithinLimits(MyCubeBlockDefinition def, long ownerId, long gridId, int count, out string limit)
{
limit = string.Empty;
if (def == null || Math.Abs(ownerId + gridId) < 1)
{
return(true);
}
var ownerFaction = MySession.Static.Factions.GetPlayerFaction(ownerId);
var allow = true;
if (Grid.IsSizeViolation(gridId))
{
return(false);
}
if (BlockLimiterConfig.Instance.AllLimits.Count == 0)
{
return(true);
}
var foundGrid = GridCache.TryGetGridById(gridId, out var grid);
if (!foundGrid)
{
GridCache.AddGrid(grid);
}
var subGrids = Grid.GetSubGrids(grid);
foreach (var item in BlockLimiterConfig.Instance.AllLimits)
{
limit = item.Name;
if (!item.IsMatch(def))
{
continue;
}
if ((ownerId > 0 && item.IsExcepted(ownerId)) ||
gridId > 0 && item.IsExcepted(gridId))
{
continue;
}
if (foundGrid && !item.IsGridType(grid))
{
continue;
}
if (item.Limit == 0 && (item.LimitGrids || item.LimitPlayers || item.LimitFaction))
{
return(false);
}
if (item.LimitGrids && gridId > 0)
{
item.FoundEntities.TryGetValue(gridId, out var gCount);
if (foundGrid && item.IsGridType(grid))
{
if (gCount + count > item.Limit)
{
allow = false;
break;
}
//Counts found subgrid blocks too.
var subGBlockCount = 0;
foreach (var subGrid in subGrids)
{
if (!item.FoundEntities.TryGetValue(subGrid.EntityId, out var subGCount))
{
continue;
}
subGBlockCount += subGCount;
}
if (subGBlockCount + count + gCount > item.Limit)
{
allow = false;
break;
}
}
}
if (ownerId > 0 && item.LimitPlayers && item.FoundEntities.TryGetValue(ownerId, out var pCount))
{
if (pCount + count > item.Limit)
{
allow = false;
break;
}
}
if (ownerFaction == null || !item.LimitFaction || !item.FoundEntities.TryGetValue(ownerFaction.FactionId, out var fCount))
{
continue;
}
{
if (fCount + count <= item.Limit)
{
continue;
}
allow = false;
break;
}
}
return(allow);
}
public static void DecreaseCount(MyCubeBlockDefinition def, List <long> playerIds, int amount = 1, long gridId = 0)
{
if (!BlockLimiterConfig.Instance.EnableLimits)
{
return;
}
var factions = new List <MyFaction>();
foreach (var playerId in playerIds)
{
var faction = MySession.Static.Factions.GetPlayerFaction(playerId);
if (faction == null)
{
continue;
}
factions.Add(faction);
}
foreach (var limit in Limits)
{
if (!limit.IsMatch(def))
{
continue;
}
var foundGrid = GridCache.TryGetGridById(gridId, out var grid);
if (foundGrid && !limit.IsGridType(grid))
{
limit.FoundEntities.Remove(gridId);
continue;
}
if (limit.LimitGrids && gridId > 0)
{
limit.FoundEntities.AddOrUpdate(gridId, 0, (l, i) => Math.Max(0, i - amount));
}
foreach (var playerId in playerIds)
{
if (playerId == 0)
{
continue;
}
if (limit.IgnoreNpcs)
{
if (MySession.Static.Players.IdentityIsNpc(playerId))
{
limit.FoundEntities.Remove(playerId);
continue;
}
if (foundGrid && MySession.Static.Players.IdentityIsNpc(GridCache.GetBuilders(grid).FirstOrDefault()))
{
continue;
}
}
if (limit.LimitPlayers)
{
limit.FoundEntities.AddOrUpdate(playerId, 0, (l, i) => Math.Max(0, i - amount));
}
}
if (limit.LimitFaction && factions.Count > 0)
{
foreach (var faction in factions)
{
limit.FoundEntities.AddOrUpdate(faction.FactionId, 0, (l, i) => Math.Max(0, i - amount));
}
}
limit.ClearEmptyEntities();
}
}
public static bool IsSizeViolation(long id)
{
return(GridCache.TryGetGridById(id, out var grid) && IsSizeViolation(grid, false, out _));
}
public static StringBuilder GetLimit(long playerId)
{
var sb = new StringBuilder();
sb.AppendLine("Ain't find shit");
if (playerId == 0)
{
return(sb);
}
var limitItems = BlockLimiterConfig.Instance.AllLimits;
if (limitItems.Count < 1)
{
return(sb);
}
sb.Clear();
var playerFaction = MySession.Static.Factions.GetPlayerFaction(playerId);
var playerBlocks = new HashSet <MySlimBlock>();
if (playerId > 0)
{
GridCache.GetPlayerBlocks(playerBlocks, playerId);
var grids = new HashSet <MyCubeGrid>();
GridCache.GetPlayerGrids(grids, playerId);
if (grids.Count > 0)
{
if (BlockLimiterConfig.Instance.MaxBlockSizeShips > 0)
{
sb.AppendLine($"Ship Limits");
foreach (var grid in grids.Where(x => x.BlocksCount > 0 && !x.IsStatic))
{
sb.AppendLine(
$"{grid.DisplayName}: {grid.BlocksCount}/{BlockLimiterConfig.Instance.MaxBlockSizeShips}");
}
}
if (BlockLimiterConfig.Instance.MaxBlockSizeStations > 0)
{
sb.AppendLine($"Station Limits");
foreach (var grid in grids.Where(x => x.BlocksCount > 0 && x.IsStatic))
{
sb.AppendLine(
$"{grid.DisplayName}: {grid.BlocksCount}/{BlockLimiterConfig.Instance.MaxBlockSizeStations}");
}
}
if (BlockLimiterConfig.Instance.MaxBlocksLargeGrid > 0)
{
sb.AppendLine($"Large Grid Block Limits");
foreach (var grid in grids.Where(x => x.BlocksCount > 0 && x.GridSizeEnum == MyCubeSize.Large))
{
sb.AppendLine(
$"{grid.DisplayName}: {grid.BlocksCount}/{BlockLimiterConfig.Instance.MaxBlocksLargeGrid}");
}
}
if (BlockLimiterConfig.Instance.MaxBlocksSmallGrid > 0)
{
sb.AppendLine($"Small Grid Block Limits");
foreach (var grid in grids.Where(x => x.BlocksCount > 0 && x.GridSizeEnum == MyCubeSize.Small))
{
sb.AppendLine(
$"{grid.DisplayName}: {grid.BlocksCount}/{BlockLimiterConfig.Instance.MaxBlocksSmallGrid}");
}
}
if (BlockLimiterConfig.Instance.MaxSmallGrids > 0)
{
sb.AppendLine($"Small Grids Limits: {grids.Count(x=>x.GridSizeEnum == MyCubeSize.Small)}/{BlockLimiterConfig.Instance.MaxSmallGrids}");
}
if (BlockLimiterConfig.Instance.MaxLargeGrids > 0)
{
sb.AppendLine($"Large Grid Limits: {grids.Count(x=>x.GridSizeEnum == MyCubeSize.Large)}/{BlockLimiterConfig.Instance.MaxLargeGrids}");
}
}
}
foreach (var item in limitItems)
{
if (item.BlockList.Count == 0 || item.FoundEntities.Count == 0)
{
continue;
}
var itemName = string.IsNullOrEmpty(item.Name) ? item.BlockList.FirstOrDefault() : item.Name;
sb.AppendLine();
sb.AppendLine($"----->{itemName}<-----");
if (item.LimitPlayers && item.FoundEntities.TryGetValue(playerId, out var pCount))
{
if (pCount > 1)
{
var dictionary = new ConcurrentDictionary <long, double>();
sb.AppendLine($"Player Limit = {pCount}/{item.Limit}");
if (playerBlocks.Count > 0)
{
foreach (var block in playerBlocks)
{
if (!item.IsMatch(block.BlockDefinition))
{
continue;
}
dictionary.AddOrUpdate(block.CubeGrid.EntityId, 1, (l, i) => i + 1);
}
foreach (var(gridId, amount) in dictionary)
{
if (!GridCache.TryGetGridById(gridId, out var grid) && Grid.IsOwner(grid, playerId))
{
sb.AppendLine($"[UnknownGrid] = {amount}");
continue;
}
sb.AppendLine($"{grid.DisplayName} = {amount}");
}
}
}
}
if (item.LimitFaction && playerFaction != null &&
item.FoundEntities.TryGetValue(playerFaction.FactionId, out var fCount))
{
if (fCount > 1)
{
sb.AppendLine($"Faction Limit = {fCount}/{item.Limit} ");
}
}
if (!item.LimitGrids)
{
continue;
}
var gridDictionary = new Dictionary <string, int>();
foreach (var(id, gCount) in item.FoundEntities)
{
if (!GridCache.TryGetGridById(id, out var grid) || !Grid.IsOwner(grid, playerId))
{
continue;
}
if (!item.IsGridType(grid))
{
item.FoundEntities.Remove(id);
continue;
}
if (gCount < 1)
{
continue;
}
gridDictionary[grid.DisplayName] = gCount;
}
if (gridDictionary.Count == 0)
{
continue;
}
sb.AppendLine("Grid Limits:");
foreach (var(name, gCount) in gridDictionary)
{
sb.AppendLine($"->{name} = {gCount} / {item.Limit}");
}
}
return(sb);
}
