private MyVoxelPhysics CreateVoxelPhysics(ref Vector3I increment, ref Vector3I_RangeIterator it)
{
if (m_physicsShapes == null)
{
m_physicsShapes = new MyConcurrentDictionary <Vector3I, MyVoxelPhysics>();
}
MyVoxelPhysics voxelMap = null;
if (!m_physicsShapes.TryGetValue(it.Current, out voxelMap))
{
Vector3I storageMin = it.Current * increment;
Vector3I storageMax = storageMin + increment;
BoundingBox check = new BoundingBox(storageMin, storageMax);
if (Storage.Intersect(ref check, false) == ContainmentType.Intersects)
{
voxelMap = new MyVoxelPhysics();
voxelMap.Init(m_storage,
this.PositionLeftBottomCorner + storageMin * MyVoxelConstants.VOXEL_SIZE_IN_METRES, storageMin,
storageMax, this);
voxelMap.Save = false;
MyEntities.Add(voxelMap);
}
m_physicsShapes.Add(it.Current, voxelMap);
}
return(voxelMap);
}
public void InitWriteCache(int prealloc = 128)
{
//Debug.Assert(m_cachedChunks == null, "Error: Cache already initialized"); disabled due to shared storages
if (m_cachedChunks != null)
{
return;
}
if (OperationsComponent != null)
{
CachedWrites = true;
}
else
{
return;
}
m_cachedChunks = new MyConcurrentDictionary <Vector3I, VoxelChunk>(prealloc, Vector3I.Comparer);
m_pendingChunksToWrite = new MyConcurrentQueue <Vector3I>(prealloc / 10);
m_chunksbyAge = new MyQueue <Vector3I>(prealloc);
m_cacheMap = new MyDynamicAABBTree(Vector3.Zero);
m_cacheLock = new FastResourceLock();
OperationsComponent.Add(this);
}
/// <summary>
/// Initializes a new instance of the <see cref="Pool<T>"/> class.
/// </summary>
public Pool()
{
#if WINDOWS_PHONE
m_instances = new MyConcurrentDictionary <Thread, MyConcurrentQueue <T> >(1);
#else
m_instances = new MyConcurrentDictionary <Thread, MyConcurrentQueue <T> >(Environment.ProcessorCount);
#endif
}
public static void AddOrUpdate <T>(this MyConcurrentDictionary <T, float> dic, T key, float value)
{
if (dic.ContainsKey(key))
{
dic[key] += value;
}
else
{
dic[key] = value;
}
}
public void UpdateBlacklist()
{
var blacklist = MyScriptCompiler.Static.Whitelist.OpenIngameBlacklistBatch();
var types = new MyConcurrentHashSet <Type>();
var memberDict = new MyConcurrentDictionary <Type, List <string> >();
Parallel.ForEach(PluginSettings.Instance.BlacklistItems, item =>
{
if (string.IsNullOrEmpty(item.Type))
{
return;
}
var targetType = FindTypeInAllAssemblies(item.Type);
if (targetType == null)
{
return;
}
if (string.IsNullOrEmpty(item.Member))
{
lock (types)
types.Add(targetType);
}
var members = targetType.GetMember(item.Member);
if (members.Length != 0)
{
if (!memberDict.ContainsKey(targetType))
{
memberDict.Add(targetType, new List <string>());
}
memberDict[targetType].Add(item.Member);
}
});
if (types.Count > 0)
{
blacklist.AddTypes(types.ToArray());
foreach (var type in types)
{
Essentials.Log.Info($"Added type {type.Name} to PB blacklist.");
}
}
foreach (var entry in memberDict)
{
blacklist.AddMembers(entry.Key, entry.Value.ToArray());
foreach (var name in entry.Value)
{
Essentials.Log.Info($"Added {entry.Key.Name}.{name} to PB blacklist.");
}
}
}
public static void Punish(MyConcurrentDictionary <MySlimBlock, LimitItem.PunishmentType> removalCollection)
{
if (removalCollection.Count == 0 || !BlockLimiterConfig.Instance.EnableLimits)
{
return;
}
var chatManager = BlockLimiter.Instance.Torch.CurrentSession.Managers.GetManager <ChatManagerServer>();
lock (removalCollection)
{
Task.Run(() =>
{
Parallel.ForEach(removalCollection, collective =>
{
var(block, punishment) = collective;
var ownerSteamId = MySession.Static.Players.TryGetSteamId(block.OwnerId);
if (block.IsDestroyed || block.FatBlock.Closed || block.FatBlock.MarkedForClose)
{
return;
}
Color color = Color.Yellow;
switch (punishment)
{
case LimitItem.PunishmentType.None:
return;
case LimitItem.PunishmentType.DeleteBlock:
BlockLimiter.Instance.Torch.InvokeAsync(() =>
{
block.CubeGrid?.RemoveBlock(block);
});
BlockLimiter.Instance.Log.Info(
$"Removed {block.BlockDefinition} from {block.CubeGrid.DisplayName}");
break;
case LimitItem.PunishmentType.ShutOffBlock:
if (!(block.FatBlock is MyFunctionalBlock fBlock))
{
return;
}
KillBlock(fBlock);
break;
public void InitWriteCache(int prealloc = 128)
{
//Debug.Assert(m_cachedChunks == null, "Error: Cache already initialized"); disabled due to shared storages
if (m_cachedChunks != null) return;
if (OperationsComponent != null)
CachedWrites = true;
else
return;
m_cachedChunks = new MyConcurrentDictionary<Vector3I, VoxelChunk>(prealloc, Vector3I.Comparer);
m_pendingChunksToWrite = new MyConcurrentQueue<Vector3I>(prealloc / 10);
m_chunksbyAge = new MyQueue<Vector3I>(prealloc);
m_cacheMap = new MyDynamicAABBTree(Vector3.Zero);
m_cacheLock = new FastResourceLock();
OperationsComponent.Add(this);
}
public override void Handle()
{
if (!BlockLimiterConfig.Instance.EnableLimits)
{
return;
}
var limitItems = BlockLimiterConfig.Instance.AllLimits;
if (!limitItems.Any())
{
return;
}
_blockCache.Clear();
GridCache.GetBlocks(_blockCache);
if (!_blockCache.Any())
{
return;
}
var removeBlocks = new MyConcurrentDictionary <MySlimBlock, LimitItem.PunishmentType>();
var punishCount = 0;
var blocks = _blockCache.ToList();
foreach (var item in limitItems)
{
if (!item.FoundEntities.Any() ||
item.Punishment == LimitItem.PunishmentType.None)
{
continue;
}
foreach (var(id, count) in item.FoundEntities)
{
if (id == 0 || Utilities.IsExcepted(id, item.Exceptions))
{
item.FoundEntities.Remove(id);
continue;
}
if (count <= item.Limit)
{
continue;
}
for (var i = blocks.Count; i-- > 0;)
{
var block = blocks[i];
if (!Block.IsMatch(block.BlockDefinition, item))
{
continue;
}
if (Math.Abs(punishCount - count) <= item.Limit)
{
break;
}
if (item.IgnoreNpcs)
{
if (MySession.Static.Players.IdentityIsNpc(block.FatBlock.BuiltBy) || MySession.Static.Players.IdentityIsNpc(block.FatBlock.OwnerId))
{
item.FoundEntities.Remove(id);
continue;
}
}
if (item.LimitGrids && block.CubeGrid.EntityId == id)
{
punishCount++;
removeBlocks[block] = item.Punishment;
continue;
}
if (item.LimitPlayers)
{
if (Block.IsOwner(block, id))
{
punishCount++;
removeBlocks[block] = item.Punishment;
continue;
}
}
if (!item.LimitFaction)
{
continue;
}
var faction = MySession.Static.Factions.TryGetFactionById(id);
if (faction == null || !block.FatBlock.GetOwnerFactionTag().Equals(faction.Tag))
{
continue;
}
punishCount++;
removeBlocks[block] = item.Punishment;
}
}
}
_blockCache.Clear();
if (!removeBlocks.Keys.Any())
{
return;
}
Task.Run(() =>
{
MySandboxGame.Static.Invoke(() =>
{
foreach (var(block, punishment) in removeBlocks)
{
try
{
switch (punishment)
{
case LimitItem.PunishmentType.DeleteBlock:
if (BlockLimiterConfig.Instance.EnableLog)
{
Log.Info(
$"removed {block.BlockDefinition.BlockPairName} from {block.CubeGrid.DisplayName}");
}
block.CubeGrid.RemoveBlock(block);
continue;
case LimitItem.PunishmentType.ShutOffBlock:
if (!(block.FatBlock is MyFunctionalBlock funcBlock) || funcBlock.Enabled == false)
{
continue;
}
if (BlockLimiterConfig.Instance.EnableLog)
{
Log.Info(
$"Turned off {block.BlockDefinition.BlockPairName} from {block.CubeGrid.DisplayName}");
}
funcBlock.Enabled = false;
continue;
case LimitItem.PunishmentType.Explode:
if (BlockLimiterConfig.Instance.EnableLog)
{
Log.Info(
$"Destroyed {block.BlockDefinition.BlockPairName} from {block.CubeGrid.DisplayName}");
}
block.DoDamage(block.BlockDefinition.MaxIntegrity * 10, MyDamageType.Explosion);
continue;
default:
throw new ArgumentOutOfRangeException();
}
}
catch (Exception e)
{
if (BlockLimiterConfig.Instance.EnableLog)
{
Log.Error(e);
}
}
}
}, "BlockLimiter");
});
}
public static int RunPunishment(HashSet <MySlimBlock> blocks, List <LimitItem.PunishmentType> punishmentTypes = null)
{
var totalBlocksPunished = 0;
if (!blocks.Any() || !BlockLimiterConfig.Instance.EnableLimits)
{
return(0);
}
var limitItems = BlockLimiterConfig.Instance.AllLimits;
BlockSwitchPatch.KeepOffBlocks.Clear();
if (limitItems.Count == 0)
{
return(0);
}
var punishBlocks = new MyConcurrentDictionary <MySlimBlock, LimitItem.PunishmentType>();
var punishCount = 0;
foreach (var item in limitItems.Where(item => item.FoundEntities.Count > 0 && item.Punishment != LimitItem.PunishmentType.None))
{
if (punishmentTypes != null && !punishmentTypes.Contains(item.Punishment))
{
continue;
}
var idsToRemove = new HashSet <long>();
foreach (var(id, count) in item.FoundEntities)
{
if (id == 0 || Utilities.IsExcepted(id, item))
{
idsToRemove.Add(id);
continue;
}
if (count <= item.Limit)
{
continue;
}
foreach (var block in blocks)
{
if (block?.BuiltBy == null || block.CubeGrid.IsPreview)
{
continue;
}
if (!item.IsMatch(block.BlockDefinition))
{
continue;
}
var defBase = MyDefinitionManager.Static.GetDefinition(block.BlockDefinition.Id);
if (defBase != null && !_firstCheckCompleted && !defBase.Context.IsBaseGame)
{
continue;
}
if (Math.Abs(punishCount - count) <= item.Limit)
{
break;
}
if (item.IgnoreNpcs)
{
if (MySession.Static.Players.IdentityIsNpc(block.FatBlock.BuiltBy) || MySession.Static.Players.IdentityIsNpc(block.FatBlock.OwnerId))
{
idsToRemove.Add(id);
continue;
}
}
if (item.Punishment == LimitItem.PunishmentType.ShutOffBlock &&
block.FatBlock is MyFunctionalBlock fBlock && (!fBlock.Enabled || block.FatBlock.MarkedForClose || block.FatBlock.Closed))
{
punishCount++;
continue;
}
if (item.LimitGrids && block.CubeGrid.EntityId == id)
{
punishCount++;
punishBlocks[block] = item.Punishment;
continue;
}
if (item.LimitPlayers)
{
if (Block.IsOwner(block, id))
{
punishCount++;
punishBlocks[block] = item.Punishment;
continue;
}
}
if (!item.LimitFaction)
{
continue;
}
var faction = MySession.Static.Factions.TryGetFactionById(id);
if (faction == null || block.FatBlock.GetOwnerFactionTag()?.Equals(faction.Tag) == false)
{
continue;
}
punishCount++;
punishBlocks[block] = item.Punishment;
}
}
idsToRemove.ForEach(x => item.FoundEntities.Remove(x));
}
if (punishBlocks.Count == 0)
{
return(totalBlocksPunished);
}
totalBlocksPunished = punishBlocks.Count;
_firstCheckCompleted = !_firstCheckCompleted;
Log.Info($"Punishing {totalBlocksPunished} blocks");
Block.Punish(punishBlocks);
return(totalBlocksPunished);
}
public static int RunPunishment(HashSet <MySlimBlock> blocks, List <LimitItem.PunishmentType> punishmentTypes = null)
{
var totalBlocksPunished = 0;
if (blocks.Count == 0 || !BlockLimiterConfig.Instance.EnableLimits)
{
return(0);
}
var limitItems = BlockLimiterConfig.Instance.AllLimits.Where(item => item.FoundEntities.Count > 0 && item.Punishment != LimitItem.PunishmentType.None).ToList();
if (limitItems.Count == 0)
{
return(0);
}
var punishBlocks = new MyConcurrentDictionary <MySlimBlock, LimitItem.PunishmentType>();
for (var i = limitItems.Count - 1; i >= 0; i--)
{
var item = limitItems[i];
if (punishmentTypes != null && !punishmentTypes.Contains(item.Punishment))
{
continue;
}
var idsToRemove = new HashSet <long>();
var punishCount = 0;
foreach (var(id, count) in item.FoundEntities)
{
if (id == 0 || item.IsExcepted(id))
{
idsToRemove.Add(id);
continue;
}
if (count <= item.Limit)
{
continue;
}
foreach (var block in blocks)
{
if (block.CubeGrid.IsPreview || !item.IsMatch(block.BlockDefinition))
{
continue;
}
var defBase = MyDefinitionManager.Static.GetDefinition(block.BlockDefinition.Id);
if (defBase != null && !_firstCheckCompleted && !defBase.Context.IsBaseGame)
{
continue;
}
if (Math.Abs(punishCount - count) <= item.Limit)
{
break;
}
if (item.IgnoreNpcs)
{
if (MySession.Static.Players.IdentityIsNpc(block.FatBlock.BuiltBy) ||
MySession.Static.Players.IdentityIsNpc(block.FatBlock.OwnerId))
{
idsToRemove.Add(id);
continue;
}
}
//Reverting to old shutoff due to performance issues
if (item.Punishment == LimitItem.PunishmentType.ShutOffBlock &&
block.FatBlock is MyFunctionalBlock fBlock && (!fBlock.Enabled ||
block.FatBlock.MarkedForClose ||
block.FatBlock.Closed))
{
punishCount++;
continue;
}
//Todo Fix this function and re-implement. Currently too expensive
/*
* if (item.Punishment == LimitItem.PunishmentType.ShutOffBlock && Math.Abs(GetDisabledBlocks(id,item) - count) <= item.Limit )
* {
* continue;
* }
*/
var playerSteamId = MySession.Static.Players.TryGetSteamId(id);
if (playerSteamId > 0 && !Annoy.AnnoyQueue.ContainsKey(playerSteamId))
{
Annoy.AnnoyQueue[playerSteamId] = DateTime.Now;
break;
}
if (item.LimitGrids && block.CubeGrid.EntityId == id)
{
punishCount++;
punishBlocks[block] = item.Punishment;
continue;
}
if (item.LimitPlayers)
{
if (Block.IsOwner(block, id))
{
punishCount++;
punishBlocks[block] = item.Punishment;
continue;
}
}
if (!item.LimitFaction)
{
continue;
}
var faction = MySession.Static.Factions.TryGetFactionById(id);
if (faction == null || block.FatBlock.GetOwnerFactionTag()?.Equals(faction.Tag) == false)
{
continue;
}
punishCount++;
punishBlocks[block] = item.Punishment;
}
}
}
totalBlocksPunished = punishBlocks.Count;
_firstCheckCompleted = !_firstCheckCompleted;
if (totalBlocksPunished == 0)
{
return(totalBlocksPunished);
}
Log.Debug($"Punishing {punishBlocks.Count} blocks");
Block.Punish(punishBlocks);
/*
* List<MySlimBlock> GetDisabledBlocks(long id, LimitItem limit)
* {
* var disabledBlocks = new List<MySlimBlock>();
* foreach (var block in blocks)
* {
* if (!(block.FatBlock is MyFunctionalBlock fBlock) || block.FatBlock.MarkedForClose || block.FatBlock.Closed) continue;
* if (block.CubeGrid.EntityId != id && !Block.IsOwner(block,id)) continue;
* if (BlockSwitchPatch.KeepOffBlocks.Contains(block.FatBlock))
* {
* disabledBlocks.Add(block);
* continue;
* }
* if (fBlock.Enabled)continue;
* disabledBlocks.Add(block);
* }
*
* return disabledBlocks;
* }
*
* int GetDisabledCount (long id, LimitItem limit)
* {
* var disabledCount = 0;
* foreach (var block in blocks)
* {
* if (!limit.IsGridType(block.CubeGrid)) continue;
* if (!limit.IsMatch(block.BlockDefinition)) continue;
* if (!(block.FatBlock is MyFunctionalBlock fBlock) || block.FatBlock.MarkedForClose || block.FatBlock.Closed) continue;
* if (block.CubeGrid.EntityId != id && !Block.IsOwner(block,id)) continue;
* if (BlockSwitchPatch.KeepOffBlocks.Contains(block.FatBlock))
* {
* disabledCount++;
* continue;
* }
* if (fBlock.Enabled)continue;
* disabledCount++;
* }
* return disabledCount;
* }
*/
return(totalBlocksPunished);
}
public static void Punish(MyConcurrentDictionary <MySlimBlock, LimitItem.PunishmentType> removalCollection)
{
if (removalCollection.Count == 0)
{
return;
}
var log = BlockLimiter.Instance.Log;
if (!BlockLimiterConfig.Instance.EnableLimits)
{
return;
}
var chatManager = BlockLimiter.Instance.Torch.CurrentSession.Managers.GetManager <ChatManagerServer>();
lock (removalCollection)
{
Task.Run(() =>
{
Parallel.ForEach(removalCollection, collective =>
{
var(block, punishment) = collective;
var ownerSteamId = MySession.Static.Players.TryGetSteamId(block.OwnerId);
if (block.IsDestroyed || block.FatBlock.Closed || block.FatBlock.MarkedForClose)
{
return;
}
Color color = Color.Yellow;
switch (punishment)
{
case LimitItem.PunishmentType.None:
return;
case LimitItem.PunishmentType.DeleteBlock:
MySandboxGame.Static.Invoke(() =>
{
block.CubeGrid.RemoveBlock(block);
}, "BlockLimiter");
log.Info(
$"Removed {block.BlockDefinition} from {block.CubeGrid.DisplayName}");
break;
case LimitItem.PunishmentType.ShutOffBlock:
KillBlock(block.FatBlock);
break;
case LimitItem.PunishmentType.Explode:
log.Info(
$"Destroyed {block.BlockDefinition} from {block.CubeGrid.DisplayName}");
MySandboxGame.Static.Invoke(() =>
{
block.DoDamage(block.BlockDefinition.MaxIntegrity, MyDamageType.Fire);
}, "BlockLimiter");
break;
default:
return;
}
if (ownerSteamId != 0 && MySession.Static.Players.IsPlayerOnline(block.OwnerId))
{
chatManager?.SendMessageAsOther(BlockLimiterConfig.Instance.ServerName, $"Punishing {((MyTerminalBlock)block.FatBlock).CustomName} from {block.CubeGrid.DisplayName} with {punishment}", color, ownerSteamId);
}
});
});
}
}